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 DEBUG␊
46␉#define DBG(x...)␉printf(x)␊
47#else␊
48␉#define DBG(x...)␉msglog(x)␊
49#endif␊
50␊
51bool gUseCommonAndOSdir = true;␊
52␊
53struct Module { ␊
54␉struct Module *nextModule;␊
55␉long willLoad;␊
56␉TagPtr dict;␊
57␉char *plistAddr;␊
58␉long plistLength;␊
59␉char *executablePath;␊
60␉char *bundlePath;␊
61␉long bundlePathLength;␊
62};␊
63typedef struct Module Module, *ModulePtr;␊
64␊
65struct DriverInfo {␊
66␉char *plistAddr;␊
67␉long plistLength;␊
68␉void *executableAddr;␊
69␉long executableLength;␊
70␉void *bundlePathAddr;␊
71␉long bundlePathLength;␊
72};␊
73typedef struct DriverInfo DriverInfo, *DriverInfoPtr;␊
74␊
75#define kDriverPackageSignature1 'MKXT'␊
76#define kDriverPackageSignature2 'MOSX'␊
77␊
78struct DriversPackage {␊
79␉unsigned long signature1;␊
80␉unsigned long signature2;␊
81␉unsigned long length;␊
82␉unsigned long adler32;␊
83␉unsigned long version;␊
84␉unsigned long numDrivers;␊
85␉unsigned long reserved1;␊
86␉unsigned long reserved2;␊
87};␊
88typedef struct DriversPackage DriversPackage;␊
89␊
90enum {␊
91␉kCFBundleType2,␊
92␉kCFBundleType3␊
93};␊
94␊
95long (*LoadExtraDrivers_p)(FileLoadDrivers_t FileLoadDrivers_p);␊
96␊
97static inline unsigned long Adler32( unsigned char * buffer, long length );␊
98␊
99long FileLoadDrivers(char *dirSpec, long plugin);␊
100long NetLoadDrivers(char *dirSpec);␊
101long LoadDriverMKext(char *fileSpec);␊
102long LoadDriverPList(char *dirSpec, char *name, long bundleType);␊
103long LoadMatchedModules(void);␊
104␊
105static long MatchPersonalities(void);␊
106static long MatchLibraries(void);␊
107␊
108#ifdef NOTDEF␊
109␉static ModulePtr FindModule(char *name);␊
110␉static void ThinFatFile(void **loadAddrP, unsigned long *lengthP);␊
111#endif␊
112static long ParseXML(char *buffer, ModulePtr *module, TagPtr *personalities);␊
113static long InitDriverSupport(void);␊
114␊
115ModulePtr gModuleHead, gModuleTail;␊
116static TagPtr␉gPersonalityHead, gPersonalityTail;␊
117static char␉*gExtensionsSpec;␊
118static char␉*gDriverSpec;␊
119static char␉*gFileSpec;␊
120static char␉*gTempSpec;␊
121static char␉*gFileName;␊
122// Bungo:␊
123char gDarwinBuildVerStr[256] = "Darwin Kernel Version";␊
124␊
125static inline unsigned long Adler32( unsigned char *buffer, long length )␊
126{␊
127␉long cnt;␊
128␉unsigned long result, lowHalf, highHalf;␊
129␊
130␉lowHalf = 1;␊
131␉highHalf = 0;␊
132␊
133␉for (cnt = 0; cnt < length; cnt++)␊
134␉{␊
135␉␉if ((cnt % 5000) == 0)␊
136␉␉{␊
137␉␉␉lowHalf %= 65521L;␊
138␉␉␉highHalf %= 65521L;␊
139␉␉}␊
140␊
141␉␉lowHalf += buffer[cnt];␊
142␉␉highHalf += lowHalf;␊
143␉}␊
144␊
145␉lowHalf %= 65521L;␊
146␉highHalf %= 65521L;␊
147␊
148␉result = (highHalf << 16) | lowHalf;␊
149␊
150␉return result;␊
151}␊
152␊
153//==========================================================================␊
154// InitDriverSupport␊
155static long InitDriverSupport( void )␊
156{␊
157␉gExtensionsSpec = malloc( 4096 );␊
158␉gDriverSpec = malloc( 4096 );␊
159␉gFileSpec = malloc( 4096 );␊
160␉gTempSpec = malloc( 4096 );␊
161␉gFileName = malloc( 4096 );␊
162␊
163␉if ( !gExtensionsSpec || !gDriverSpec || !gFileSpec || !gTempSpec || !gFileName )␊
164␉{␊
165␉␉stop("InitDriverSupport error");␊
166␉}␊
167␊
168␉return 0;␊
169}␊
170␊
171//==========================================================================␊
172// LoadDrivers␊
173long LoadDrivers( char *dirSpec )␊
174{␊
175␉char dirSpecExtra[1024];␊
176␉long flags, ret=-1;␊
177␉u_int32_t time;␊
178␊
179␉if ( InitDriverSupport() != 0 )␊
180␉{␊
181␉␉return 0;␊
182␉}␊
183␊
184␉// ========================================␊
185␉gUseCommonAndOSdir = false; // old behavior␊
186␊
187␉ret = GetFileInfo("bt(0,0)/Extra/Extensions/", "Common", &flags, &time);␊
188␊
189␉// if the boot partition contains /Extra/Extensions/Common there is no need␊
190␉// to look else where because users will have also /Extra/Extensions/10.x␊
191␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeDirectory))␊
192␉{␊
193␉␉gUseCommonAndOSdir = true;␊
194␉␉verbose("/Extra/Extensions/Common and /Extra/Extensions/%s in use.\n", gBootVolume->OSVersion);␊
195␉␉//getchar();␊
196␉}␊
197␉// ========================================␊
198␊
199␉// Load extra drivers if a hook has been installed.␊
200␉if (LoadExtraDrivers_p != NULL)␊
201␉{␊
202␉␉(*LoadExtraDrivers_p)(&FileLoadDrivers);␊
203␉}␊
204␊
205␉if ( gBootFileType == kNetworkDeviceType )␊
206␉{␊
207␉␉if (NetLoadDrivers(dirSpec) != 0)␊
208␉␉{␊
209␉␉␉error("LoadDrivers: Could not load drivers from the network\n");␊
210␉␉␉return -1;␊
211␉␉}␊
212␉}␊
213␉else if ( gBootFileType == kBlockDeviceType )␊
214␉{␊
215␉␉// First try to load Extra extensions from the ramdisk if isn't aliased as bt(0,0).␊
216␉␉if (gRAMDiskVolume && !gRAMDiskBTAliased)␊
217␉␉{␊
218␉␉␉strcpy(dirSpecExtra, "rd(0,0)/Extra/");␊
219␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
220␉␉}␊
221␉␉// =====================================================================␊
222␉␉// Secondly try to load drivers from Common folder if in use␊
223␉␉if (gUseCommonAndOSdir)␊
224␉␉{␊
225␉␉␉sprintf(dirSpecExtra, "bt(0,0)/Extra/Extensions/Common");␊
226␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
227␉␉}␊
228␉␉// =====================================================================␊
229␊
230␉␉// Next try to load Extra extensions from the selected root partition.␊
231␉␉if (gUseCommonAndOSdir)␊
232␉␉{␊
233␉␉␉sprintf(dirSpecExtra, "bt(0,0)/Extra/Extensions/%s", gBootVolume->OSVersion);␊
234␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
235␉␉␉//verbose("gUseCommonAndOSdir = %s\n", dirSpecExtra);␊
236␉␉␉//getchar();␊
237␉␉}␊
238␉␉else␊
239␉␉{␊
240␉␉␉strlcpy(dirSpecExtra, "/Extra/", sizeof(dirSpecExtra));␊
241␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
242␉␉␉{␊
243␉␉␉␉// If failed, then try to load Extra extensions from the boot partition␊
244␉␉␉␉// in case we have a separate booter partition or a bt(0,0) aliased ramdisk.␊
245␉␉␉␉if ( !(gBIOSBootVolume->biosdev == gBootVolume->biosdev && gBIOSBootVolume->part_no == gBootVolume->part_no)␊
246␉␉␉␉␉|| (gRAMDiskVolume && gRAMDiskBTAliased) )␊
247␉␉␉␉{␊
248␉␉␉␉␉// Next try a specfic OS version folder ie 10.12␊
249␉␉␉␉␉sprintf(dirSpecExtra, "bt(0,0)/Extra/%s/", &gMacOSVersion[0]);␊
250␉␉␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
251␉␉␉␉␉{␊
252␉␉␉␉␉␉// Next we'll try the base␊
253␉␉␉␉␉␉strlcpy(dirSpecExtra, "bt(0,0)/Extra/", sizeof(dirSpecExtra));␊
254␉␉␉␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
255␉␉␉␉␉}␊
256␉␉␉␉}␊
257␉␉␉}␊
258␉␉}␊
259␊
260␉␉if(!gHaveKernelCache)␊
261␉␉{␊
262␉␉␉// Don't load main driver (from /System/Library/Extentions) if gHaveKernelCache is set.␊
263␉␉␉// since these drivers will already be in the kernel cache.␊
264␉␉␉// NOTE: when gHaveKernelCache, xnu cannot (by default) load *any* extra kexts from the bootloader.␊
265␉␉␉// The /Extra code is not disabled in this case due to a kernel patch that allows for this to happen.␊
266␊
267␉␉␉// Also try to load Extensions from boot helper partitions.␊
268␉␉␉if (gBootVolume->flags & kBVFlagBooter)␊
269␉␉␉{␊
270␉␉␉␉strlcpy(dirSpecExtra, "/com.apple.boot.P/System/Library/", sizeof(dirSpecExtra));␊
271␉␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
272␉␉␉␉{␊
273␉␉␉␉␉strlcpy(dirSpecExtra, "/com.apple.boot.R/System/Library/", sizeof(dirSpecExtra));␊
274␉␉␉␉␉if (FileLoadDrivers(dirSpecExtra, 0) != 0)␊
275␉␉␉␉␉{␊
276␉␉␉␉␉␉strlcpy(dirSpecExtra, "/com.apple.boot.S/System/Library/", sizeof(dirSpecExtra));␊
277␉␉␉␉␉␉FileLoadDrivers(dirSpecExtra, 0);␊
278␉␉␉␉␉}␊
279␉␉␉␉}␊
280␉␉␉}␊
281␊
282␉␉␉if (gMKextName[0] != '\0')␊
283␉␉␉{␊
284␉␉␉␉verbose("LoadDrivers: Loading from '%s'\n", gMKextName);␊
285␉␉␉␉if ( LoadDriverMKext(gMKextName) != 0 )␊
286␉␉␉␉{␊
287␉␉␉␉␉error("Could not load %s\n", gMKextName);␊
288␉␉␉␉␉return -1;␊
289␉␉␉␉}␊
290␉␉␉}␊
291␉␉␉else␊
292␉␉␉{␊
293␉␉␉␉verbose("Attempting to load drivers from standard repositories:\n");␊
294␊
295␉␉␉␉if ( (gMacOSVersion[3] == '9') || ((gMacOSVersion[3] == '1') && ((gMacOSVersion[4] == '0') || (gMacOSVersion[4] == '1') || (gMacOSVersion[4] == '2') ) )) // issue 352␊
296␉␉␉␉{␊
297␉␉␉␉␉verbose("\t- Third party extensions search path: /Library/Extensions\n");␊
298␉␉␉␉␉strlcpy(gExtensionsSpec, dirSpec, 4087); /* 4096 - sizeof("Library/") mean 4096 - 9 = 4087 */␊
299␉␉␉␉␉strcat(gExtensionsSpec, gUseCommonAndOSdir ? "Library/Extensions" : "Library/");␊
300␉␉␉␉␉FileLoadDrivers(gExtensionsSpec, 0);␊
301␉␉␉␉}␊
302␊
303␉␉␉␉verbose("\t- Apple extensions search path: /System/Library/Extensions\n");␊
304␉␉␉␉strlcpy(gExtensionsSpec, dirSpec, 4080); /* 4096 - sizeof("System/Library/") mean 4096 -16 = 4080 */␊
305␉␉␉␉strcat(gExtensionsSpec, gUseCommonAndOSdir ? "System/Library/Extensions" : "System/Library/");␊
306␉␉␉␉FileLoadDrivers(gExtensionsSpec, 0);␊
307␉␉␉}␊
308␊
309␉␉}␊
310␉}␊
311␉else␊
312␉{␊
313␉␉return 0;␊
314␉}␊
315␊
316␉MatchPersonalities();␊
317␊
318␉MatchLibraries();␊
319␊
320␉LoadMatchedModules();␊
321␊
322␉return 0;␊
323}␊
324␊
325//==========================================================================␊
326// FileLoadMKext␊
327static long FileLoadMKext( const char *dirSpec, const char *extDirSpec )␊
328{␊
329␉long␉␉ret, flags;␊
330␉u_int32_t␉time, time2;␊
331␉char␉␉altDirSpec[512];␊
332␉␊
333␉snprintf(altDirSpec, sizeof(altDirSpec), "%s%s", dirSpec, extDirSpec);␊
334␉ret = GetFileInfo(altDirSpec, "Extensions.mkext", &flags, &time);␊
335␊
336␉if ((ret == 0) && ((flags & kFileTypeMask) == kFileTypeFlat))␊
337␉{␊
338␉␉ret = GetFileInfo(dirSpec, "Extensions", &flags, &time2);␊
339␊
340␉␉if ((ret != 0)␊
341␉␉␉|| ((flags & kFileTypeMask) != kFileTypeDirectory)␊
342␉␉␉|| (((gBootMode & kBootModeSafe) == 0) && (time == (time2 + 1))))␊
343␉␉{␊
344␉␉␉snprintf(gDriverSpec, sizeof(altDirSpec) + 18, "%sExtensions.mkext", altDirSpec);␊
345␉␉␉verbose("LoadDrivers: Loading from '%s'\n", gDriverSpec);␊
346␊
347␉␉␉if (LoadDriverMKext(gDriverSpec) == 0)␊
348␉␉␉{␊
349␉␉␉␉return 0;␊
350␉␉␉}␊
351␉␉}␊
352␉}␊
353␉return -1;␊
354}␊
355␊
356//==========================================================================␊
357// FileLoadDrivers␊
358long FileLoadDrivers( char *dirSpec, long plugin )␊
359{␊
360␉long long␉index;␊
361␉long␉␉ret, length, flags, bundleType;␊
362␉long␉␉result = -1;␊
363␉u_int32_t␉time;␊
364␉const char␉* name;␊
365␊
366␉if ( !plugin )␊
367␉{␊
368␉␉// First try 10.6's path for loading Extensions.mkext.␊
369␉␉if (FileLoadMKext(dirSpec, "Caches/com.apple.kext.caches/Startup/") == 0) {␊
370␉␉␉return 0;␊
371␉␉}␊
372␊
373␉␉// Next try the legacy path.␊
374␉␉else if (FileLoadMKext(dirSpec, "") == 0)␊
375␉␉{␊
376␉␉␉return 0;␊
377␉␉}␊
378␊
379␉␉if (!gUseCommonAndOSdir)␊
380␉␉{␊
381␉␉␉// means that we already provide a full path to the Extensions directory␊
382␉␉␉strcat(dirSpec, "Extensions");␊
383␉␉}␊
384␉}␊
385␊
386␉index = 0;␊
387␉while (1)␊
388␉{␊
389␉␉ret = GetDirEntry(dirSpec, &index, &name, &flags, &time);␊
390␉␉if (ret == -1) {␊
391␉␉␉break;␊
392␉␉}␊
393␊
394␉␉// Make sure this is a directory.␊
395␉␉if ((flags & kFileTypeMask) != kFileTypeDirectory)␊
396␉␉{␊
397␉␉␉continue;␊
398␉␉}␊
399␊
400␉␉// Make sure this is a kext.␊
401␉␉length = strlen(name);␊
402␉␉if (strncmp(name + length - 5, ".kext", sizeof(".kext") ))␊
403␉␉{␊
404␉␉␉continue;␊
405␉␉}␊
406␊
407␉␉// Save the file name.␊
408␉␉strlcpy(gFileName, name, 4096);␊
409␊
410␉␉// Determine the bundle type.␊
411␉␉snprintf(gTempSpec, 4096, "%s/%s", dirSpec, gFileName);␊
412␉␉ret = GetFileInfo(gTempSpec, "Contents", &flags, &time);␊
413␉␉if (ret == 0)␊
414␉␉{␊
415␉␉␉bundleType = kCFBundleType2;␊
416␉␉}␊
417␉␉else␊
418␉␉{␊
419␉␉␉bundleType = kCFBundleType3;␊
420␉␉}␊
421␊
422␉␉if (!plugin)␊
423␉␉{␊
424␉␉␉snprintf(gDriverSpec, 4096, "%s/%s/%sPlugIns", dirSpec, gFileName, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
425␉␉}␊
426␊
427␉␉ret = LoadDriverPList(dirSpec, gFileName, bundleType);␊
428␊
429␉␉if (result != 0)␊
430␉␉{␊
431␉␉␉result = ret;␊
432␉␉}␊
433␊
434␉␉if (!plugin)␊
435␉␉{␊
436␉␉␉FileLoadDrivers(gDriverSpec, 1);␊
437␉␉}␊
438␉}␊
439␊
440␉return result;␊
441}␊
442␊
443//==========================================================================␊
444// ␊
445long NetLoadDrivers( char *dirSpec )␊
446{␊
447␉long tries;␊
448␊
449#if NODEF␊
450␉long cnt;␊
451␊
452␉// Get the name of the kernel␊
453␉cnt = strlen(gBootFile);␊
454␉while (cnt--) {␊
455␉␉if ((gBootFile[cnt] == '\\') || (gBootFile[cnt] == ','))␊
456␉␉{␊
457␉␉␉cnt++;␊
458␉␉␉break;␊
459␉␉}␊
460␉}␊
461#endif␊
462␊
463␉// INTEL modification␊
464␉snprintf(gDriverSpec, 4096, "%s%s.mkext", dirSpec, bootInfo->bootFile);␊
465 ␊
466␉verbose("NetLoadDrivers: Loading from [%s]\n", gDriverSpec);␊
467 ␊
468␉tries = 3;␊
469␉while (tries--)␊
470␉{␊
471␉␉if (LoadDriverMKext(gDriverSpec) == 0)␊
472␉␉{␊
473␉␉␉break;␊
474␉␉}␊
475␉}␊
476␉if (tries == -1)␊
477␉{␊
478␉␉return -1;␊
479␉}␊
480␊
481␉return 0;␊
482}␊
483␊
484//==========================================================================␊
485// loadDriverMKext␊
486long LoadDriverMKext( char *fileSpec )␊
487{␊
488␉unsigned long␉driversAddr, driversLength;␊
489␉long␉␉length;␊
490␉char␉␉segName[32];␊
491␉DriversPackage␉*package;␊
492␊
493#define GetPackageElement(e) OSSwapBigToHostInt32(package->e)␊
494␊
495␉// Load the MKext.␊
496␉length = LoadThinFatFile(fileSpec, (void **)&package);␊
497␉if (length < sizeof (DriversPackage))␊
498␉{␊
499␉␉return -1;␊
500␉}␊
501␊
502␉// call hook to notify modules that the mkext has been loaded␊
503␉execute_hook("LoadDriverMKext", (void *)fileSpec, (void *)package, (void *) &length, NULL);␊
504␊
505␉␊
506␉// Verify the MKext.␊
507␉if (( GetPackageElement(signature1) != kDriverPackageSignature1) ||␊
508␉␉( GetPackageElement(signature2) != kDriverPackageSignature2) ||␊
509␉␉( GetPackageElement(length) > kLoadSize ) ||␊
510␉␉( GetPackageElement(adler32) !=␊
511␉␉Adler32((unsigned char *)&package->version, GetPackageElement(length) - 0x10) ) )␊
512␉{␊
513␉␉return -1;␊
514␉}␊
515␊
516␉// Make space for the MKext.␊
517␉driversLength = GetPackageElement(length);␊
518␉driversAddr = AllocateKernelMemory(driversLength);␊
519␊
520␉// Copy the MKext.␊
521␉memcpy((void *)driversAddr, (void *)package, driversLength);␊
522␊
523␉// Add the MKext to the memory map.␊
524␉snprintf(segName, sizeof(segName), "DriversPackage-%lx", driversAddr);␊
525␉AllocateMemoryRange(segName, driversAddr, driversLength, kBootDriverTypeMKEXT);␊
526␊
527␉return 0;␊
528}␊
529␊
530//==========================================================================␊
531// LoadDriverPList␊
532long LoadDriverPList( char *dirSpec, char *name, long bundleType )␊
533{␊
534␉long␉␉length, executablePathLength, bundlePathLength;␊
535␉ModulePtr␉module;␊
536␉TagPtr␉␉personalities;␊
537␉char␉␉*buffer = 0;␊
538␉char␉␉*tmpExecutablePath = 0;␊
539␉char␉␉*tmpBundlePath = 0;␊
540␉long␉␉ret = -1;␊
541␊
542␉do {␊
543␉// Save the driver path.␊
544 ␊
545␉if(name)␊
546␉{␊
547␉␉snprintf(gFileSpec, 4096, "%s/%s/%s", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : "");␊
548␉}␊
549␉else␊
550␉{␊
551␉␉snprintf(gFileSpec, 4096, "%s/%s", dirSpec, (bundleType == kCFBundleType2) ? "Contents/MacOS/" : "");␊
552␉}␊
553␉executablePathLength = strlen(gFileSpec) + 1;␊
554␊
555␉tmpExecutablePath = malloc(executablePathLength);␊
556␉if (tmpExecutablePath == 0) {␊
557␉␉break;␊
558␉}␊
559␉strlcpy(tmpExecutablePath, gFileSpec, executablePathLength);␊
560␊
561␉if(name)␊
562␉{␊
563␉␉snprintf(gFileSpec, 4096, "%s/%s", dirSpec, name);␊
564␉}␊
565␉else␊
566␉{␊
567␉␉strncpy(gFileSpec, dirSpec, 4096);␊
568␉}␊
569␉bundlePathLength = strlen(gFileSpec) + 1;␊
570␊
571␉tmpBundlePath = malloc(bundlePathLength);␊
572␉if (tmpBundlePath == 0)␊
573␉{␊
574␉␉break;␊
575␉}␊
576␊
577␉strlcpy(tmpBundlePath, gFileSpec, bundlePathLength);␊
578␊
579␉// Construct the file spec to the plist, then load it.␊
580␊
581␉if(name)␊
582␉{␊
583␉␉snprintf(gFileSpec, 4096, "%s/%s/%sInfo.plist", dirSpec, name, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
584␉}␊
585␉else␊
586␉{␊
587␉␉snprintf(gFileSpec, 4096, "%s/%sInfo.plist", dirSpec, (bundleType == kCFBundleType2) ? "Contents/" : "");␊
588␉}␊
589␊
590␉length = LoadFile(gFileSpec);␊
591␊
592␉if (length == -1)␊
593␉{␊
594␉␉break;␊
595␉}␊
596␊
597␉length = length + 1;␊
598␉buffer = malloc(length);␊
599␊
600␉if (buffer == 0)␊
601␉{␊
602␉␉break;␊
603␉}␊
604␊
605␉strlcpy(buffer, (char *)kLoadAddr, length);␊
606␊
607␉// Parse the plist.␊
608␊
609␉ret = ParseXML(buffer, &module, &personalities);␊
610␊
611␉if (ret != 0) {␊
612␉␉break;␊
613␉}␊
614␊
615␉if (!module) // cparm␊
616␉{␊
617␉␉ret = -1;␊
618␉␉break;␊
619␉} // Should never happen but it will make the compiler happy␊
620␊
621␉// Allocate memory for the driver path and the plist.␊
622␊
623␉module->executablePath = tmpExecutablePath;␊
624␉module->bundlePath = tmpBundlePath;␊
625␉module->bundlePathLength = bundlePathLength;␊
626␉module->plistAddr = malloc(length);␊
627␊
628␉if ((module->executablePath == 0) || (module->bundlePath == 0) || (module->plistAddr == 0))␊
629␉{␊
630␉␉break;␊
631␉}␊
632␊
633␉// Save the driver path in the module.␊
634␉//strcpy(module->driverPath, tmpDriverPath);␊
635␉tmpExecutablePath = 0;␊
636␉tmpBundlePath = 0;␊
637␊
638␉// Add the plist to the module.␊
639␊
640␉strlcpy(module->plistAddr, (char *)kLoadAddr, length);␊
641␉module->plistLength = length;␊
642␊
643␉// Add the module to the end of the module list.␊
644 ␊
645␉if (gModuleHead == 0) {␊
646␉␉gModuleHead = module;␊
647␉} else ␉{␊
648␉␉gModuleTail->nextModule = module;␊
649␉}␊
650␉gModuleTail = module;␊
651␊
652␉// Add the persionalities to the personality list.␊
653␊
654␉if (personalities) {␊
655␉␉personalities = personalities->tag;␊
656␉}␊
657␉while (personalities != 0)␊
658␉{␊
659␉␉if (gPersonalityHead == 0) {␊
660␉␉␉gPersonalityHead = personalities->tag;␊
661␉␉} else {␊
662␉␉␉gPersonalityTail->tagNext = personalities->tag;␊
663␉␉}␊
664␊
665␉␉gPersonalityTail = personalities->tag;␊
666␉␉personalities = personalities->tagNext;␊
667␉}␊
668 ␊
669␉ret = 0;␊
670␉}␊
671␉while (0);␊
672 ␊
673␉if ( buffer ) {␊
674␉␉free( buffer );␊
675␉}␊
676␉if ( tmpExecutablePath ) {␊
677␉␉free( tmpExecutablePath );␊
678␉}␊
679␉if ( tmpBundlePath ) {␊
680␉␉free( tmpBundlePath );␊
681␉}␊
682␉return ret;␊
683}␊
684␊
685//==========================================================================␊
686// LoadMatchedModules␊
687long LoadMatchedModules( void )␊
688{␊
689␉TagPtr␉prop;␊
690␉ModulePtr␉module;␊
691␉char␉␉*fileName, segName[32];␊
692␉DriverInfoPtr␉driver;␊
693␉long␉␉length, driverAddr, driverLength;␊
694␉void␉␉*executableAddr = 0;␊
695␉void␉␉*embedded = 0;␊
696␊
697␉module = gModuleHead;␊
698␊
699␉while (module != 0)␊
700␉{␊
701␉␉if (module->willLoad)␊
702␉␉{␊
703␉␉␉prop = XMLGetProperty(module->dict, kPropCFBundleExecutable);␊
704␊
705␉␉␉if (prop != 0)␊
706␉␉␉{␊
707␉␉␉␉fileName = prop->string;␊
708␉␉␉␉snprintf(gFileSpec, 4096, "%s%s", module->executablePath, fileName);␊
709␊
710␉␉␉␉␉length = LoadThinFatFile(gFileSpec, &executableAddr);␊
711␉␉␉␉␉if (length == 0)␊
712␉␉␉␉␉{␊
713␉␉␉␉␉␉length = LoadFile(gFileSpec);␊
714␉␉␉␉␉␉executableAddr = (void *)kLoadAddr;␊
715␉␉␉␉␉}␊
716//␉␉␉␉printf("%s length = %d addr = 0x%x\n", gFileSpec, length, driverModuleAddr); getchar();␊
717␉␉␉}␊
718␉␉␉else␊
719␉␉␉{␊
720␉␉␉␉length = 0;␊
721␉␉␉}␊
722␊
723␉␉␉if ((length != -1) && executableAddr)␊
724␉␉␉{␊
725␉␉␉␉// Make make in the image area.␊
726␊
727␉␉␉␉execute_hook("LoadMatchedModules", module, &length, executableAddr, NULL);␊
728␊
729␉␉␉␉driverLength = sizeof(DriverInfo) + module->plistLength + length + module->bundlePathLength;␊
730␉␉␉␉driverAddr = AllocateKernelMemory(driverLength);␊
731␊
732␉␉␉␉// Set up the DriverInfo.␊
733␉␉␉␉driver = (DriverInfoPtr)driverAddr;␊
734␉␉␉␉driver->plistAddr = (char *)(driverAddr + sizeof(DriverInfo));␊
735␉␉␉␉driver->plistLength = module->plistLength;␊
736␊
737␉␉␉␉if (length != 0)␊
738␉␉␉␉{␊
739␉␉␉␉␉driver->executableAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
740␉␉␉␉␉␉␉␉␉␉ module->plistLength);␊
741␉␉␉␉␉driver->executableLength = length;␊
742␉␉␉␉}␊
743␉␉␉␉else␊
744␉␉␉␉{␊
745␉␉␉␉␉driver->executableAddr␉ = 0;␊
746␉␉␉␉␉driver->executableLength = 0;␊
747␉␉␉␉}␊
748␊
749␉␉␉␉driver->bundlePathAddr = (void *)(driverAddr + sizeof(DriverInfo) +␊
750␉␉␉␉␉␉␉␉␉ module->plistLength + driver->executableLength);␊
751␉␉␉␉driver->bundlePathLength = module->bundlePathLength;␊
752␊
753␉␉␉␉// Save the plist, module and bundle.␊
754␉␉␉␉strlcpy(driver->plistAddr, module->plistAddr, driver->plistLength);␊
755␊
756␉␉␉␉if (length != 0)␊
757␉␉␉␉{␊
758␉␉␉␉␉memcpy(driver->executableAddr, executableAddr, length);␊
759␉␉␉␉}␊
760␊
761␉␉␉␉strlcpy(driver->bundlePathAddr, module->bundlePath, module->bundlePathLength);␊
762␊
763␉␉␉␉// Add an entry to the memory map.␊
764␉␉␉␉snprintf(segName, sizeof(segName), "Driver-%lx", (unsigned long)driver);␊
765␉␉␉␉AllocateMemoryRange(segName, driverAddr, driverLength,␊
766␉␉␉␉␉␉␉␉␉kBootDriverTypeKEXT);␊
767␉␉␉}␊
768␉␉}␊
769␉␉module = module->nextModule;␊
770␉}␊
771␊
772␉if(embedded)␊
773␉{␊
774␉␉free(embedded);␊
775␉}␊
776␉return 0;␊
777}␊
778␊
779//==========================================================================␊
780// MatchPersonalities␊
781static long MatchPersonalities( void )␊
782{␊
783␉/* IONameMatch support not implemented */␊
784␉return 0;␊
785}␊
786␊
787//==========================================================================␊
788// MatchLibraries␊
789static long MatchLibraries( void )␊
790{␊
791␉TagPtr prop;␊
792␉TagPtr prop2;␊
793␉ModulePtr module;␊
794␉ModulePtr module2;␊
795␉long done;␊
796␊
797␉do {␊
798␉␉done = 1;␊
799␉␉module = gModuleHead;␊
800 ␊
801␉␉while (module != 0)␊
802␉␉{␊
803␉␉␉if (module->willLoad == 1)␊
804␉␉␉{␊
805␉␉␉␉prop = XMLGetProperty(module->dict, kPropOSBundleLibraries);␊
806␊
807␉␉␉␉if (prop != 0)␊
808␉␉␉␉{␊
809␉␉␉␉␉prop = prop->tag;␊
810␊
811␉␉␉␉␉while (prop != 0)␊
812␉␉␉␉␉{␊
813␉␉␉␉␉␉module2 = gModuleHead;␊
814␊
815␉␉␉␉␉␉while (module2 != 0)␊
816␉␉␉␉␉␉{␊
817␉␉␉␉␉␉␉prop2 = XMLGetProperty(module2->dict, kPropCFBundleIdentifier);␊
818␊
819␉␉␉␉␉␉␉if ((prop2 != 0) && (!strcmp(prop->string, prop2->string)))␊
820␉␉␉␉␉␉␉{␊
821␉␉␉␉␉␉␉␉if (module2->willLoad == 0)␊
822␉␉␉␉␉␉␉␉{␊
823␉␉␉␉␉␉␉␉␉module2->willLoad = 1;␊
824␉␉␉␉␉␉␉␉}␊
825␉␉␉␉␉␉␉␉break;␊
826␉␉␉␉␉␉␉}␊
827␉␉␉␉␉␉␉module2 = module2->nextModule;␊
828␉␉␉␉␉␉}␊
829␉␉␉␉␉␉prop = prop->tagNext;␊
830␉␉␉␉␉}␊
831␉␉␉␉}␊
832␉␉␉␉module->willLoad = 2;␊
833␉␉␉␉done = 0;␊
834␉␉␉}␊
835␉␉␉module = module->nextModule;␊
836␉␉}␊
837␉}␊
838␉while (!done);␊
839␊
840␉return 0;␊
841}␊
842␊
843//==========================================================================␊
844// FindModule␊
845␊
846#if NOTDEF␊
847static ModulePtr FindModule( char *name )␊
848{␊
849␉ModulePtr module;␊
850␉TagPtr prop;␊
851␊
852␉module = gModuleHead;␊
853␊
854␉while (module != 0)␊
855␉{␊
856␉␉prop = GetProperty(module->dict, kPropCFBundleIdentifier);␊
857␊
858␉␉if ((prop != 0) && !strcmp(name, prop->string))␊
859␉␉{␊
860␉␉␉break;␊
861␉␉}␊
862␊
863␉␉module = module->nextModule;␊
864␉}␊
865 ␊
866␉return module;␊
867}␊
868#endif /* NOTDEF */␊
869␊
870//==========================================================================␊
871// ParseXML␊
872static long ParseXML( char *buffer, ModulePtr *module, TagPtr *personalities )␊
873{␊
874␉long␉␉length;␊
875␉long␉␉pos = 0;␊
876␉TagPtr␉␉moduleDict;␊
877␉TagPtr␉␉required;␊
878␉ModulePtr␉tmpModule;␊
879␊
880␉while (1)␊
881␉{␊
882␉␉length = XMLParseNextTag(buffer + pos, &moduleDict);␊
883␉␉if (length == -1)␊
884␉␉{␊
885␉␉␉break;␊
886␉␉}␊
887␊
888␉␉pos += length;␊
889␊
890␉␉if (moduleDict == 0)␊
891␉␉{␊
892␉␉␉continue;␊
893␉␉}␊
894␉␉if (moduleDict->type == kTagTypeDict)␊
895␉␉{␊
896␉␉␉break;␊
897␉␉}␊
898␉␉XMLFreeTag(moduleDict);␊
899␉}␊
900␊
901␉if (length == -1)␊
902␉{␊
903␉␉return -1;␊
904␉}␊
905␊
906␉required = XMLGetProperty(moduleDict, kPropOSBundleRequired);␊
907␊
908␉␉if ( (required == 0) || (required->type != kTagTypeString) || !strncmp(required->string, "Safe Boot", sizeof("Safe Boot")))␊
909␉␉{␊
910␉␉␉XMLFreeTag(moduleDict);␊
911␉␉␉return -2;␊
912␉␉}␊
913␊
914␉tmpModule = malloc(sizeof(Module));␊
915␉if (tmpModule == 0)␊
916␉{␊
917␉␉XMLFreeTag(moduleDict);␊
918␉␉return -1;␊
919␉}␊
920␉tmpModule->dict = moduleDict;␊
921 ␊
922␉// For now, load any module that has OSBundleRequired != "Safe Boot".␊
923␊
924␉tmpModule->willLoad = 1;␊
925␊
926␉*module = tmpModule;␊
927 ␊
928␉// Get the personalities.␊
929␊
930␉*personalities = XMLGetProperty(moduleDict, kPropIOKitPersonalities);␊
931 ␊
932␉return 0;␊
933}␊
934␊
935#if NOTDEF␊
936static char gPlatformName[64];␊
937#endif␊
938␊
939long DecodeKernel(void *binary, entry_t *rentry, char **raddr, int *rsize)␊
940{␊
941␉long ret = 0;␊
942␉compressed_kernel_header *kernel_header = (compressed_kernel_header *)binary;␊
943␉u_int32_t uncompressed_size = 0, size = 0, adler32 = 0;␊
944␉void *buffer = NULL;␊
945␉unsigned long len = 0;␊
946␊
947/*#if 0␊
948␉printf("kernel header:\n");␊
949␉printf("signature: 0x%x\n", kernel_header->signature);␊
950␉printf("compress_type: 0x%x\n", kernel_header->compress_type);␊
951␉printf("adler32: 0x%x\n", kernel_header->adler32);␊
952␉printf("uncompressed_size: 0x%x\n", kernel_header->uncompressed_size);␊
953␉printf("compressed_size: 0x%x\n", kernel_header->compressed_size);␊
954␉getchar();␊
955#endif*/␊
956␊
957␉if (kernel_header->signature == OSSwapBigToHostConstInt32('comp'))␊
958␉{␊
959␉␉DBG("Decompressing Kernel Cache:\n");␊
960␊
961␉␉if ((kernel_header->compress_type != OSSwapBigToHostConstInt32('lzss')) &&␊
962␉␉␉(kernel_header->compress_type != OSSwapBigToHostConstInt32('lzvn')))␊
963␉␉{␊
964␉␉␉error("\tERROR: kernel compression is bad!\n");␊
965␉␉␉return -1;␊
966␉␉}␊
967␊
968␉␉if (kernel_header->compress_type == OSSwapBigToHostConstInt32('lzss'))␊
969␉␉{␊
970␉␉␉verbose ("\t- Decompressing Kernel Using lzss\n");␊
971␉␉}␊
972␊
973␉␉if (kernel_header->compress_type == OSSwapBigToHostConstInt32('lzvn'))␊
974␉␉{␊
975␉␉␉verbose ("\t- Decompressing Kernel Using lzvn\n");␊
976␉␉}␊
977␊
978#if NOTDEF␊
979␉␉if (kernel_header->platform_name[0] && strcmp(gPlatformName, kernel_header->platform_name))␊
980␉␉{␊
981␉␉␉return -1;␊
982␉␉}␊
983␊
984␉␉if (kernel_header->root_path[0] && strcmp(gBootFile, kernel_header->root_path))␊
985␉␉{␊
986␉␉␉return -1;␊
987␉␉}␊
988#endif␊
989␉␉uncompressed_size = OSSwapBigToHostInt32(kernel_header->uncompressed_size);␊
990␉␉binary = buffer = malloc(uncompressed_size);␊
991␊
992␉␉// MinusZwei␊
993␉␉size = 0;␊
994␉␉switch (kernel_header->compress_type)␊
995␉␉{␊
996␉␉␉case OSSwapBigToHostConstInt32('lzvn'):␊
997␉␉␉␉size = lzvn_decode(binary, uncompressed_size, &kernel_header->data[0], OSSwapBigToHostInt32(kernel_header->compressed_size));␊
998␉␉␉␉break;␊
999␊
1000␉␉␉case OSSwapBigToHostConstInt32('lzss'):␊
1001␉␉␉␉size = decompress_lzss((u_int8_t *)binary, uncompressed_size, &kernel_header->data[0], OSSwapBigToHostInt32(kernel_header->compressed_size));␊
1002␉␉␉␉break;␊
1003␊
1004␉␉␉default:␊
1005␉␉␉␉break;␊
1006␉␉}␊
1007␉␉// MinusZwei␊
1008␊
1009␉␉if (uncompressed_size != size)␊
1010␉␉{␊
1011␉␉␉if ( kernel_header->compress_type == OSSwapBigToHostConstInt32('lzvn'))␊
1012␉␉␉{␊
1013␉␉␉␉error("ERROR! Size mismatch from lzvn (found: %x, expected: %x).\n", size, uncompressed_size);␊
1014␉␉␉}␊
1015␊
1016␉␉␉if ( kernel_header->compress_type == OSSwapBigToHostConstInt32('lzss'))␊
1017␉␉␉{␊
1018␉␉␉␉error("ERROR! size mismatch from lzss (found: %x, expected: %x).\n", size, uncompressed_size);␊
1019␉␉␉}␊
1020␊
1021␉␉␉return -1;␊
1022␉␉}␊
1023␊
1024␉␉adler32 = Adler32(binary, uncompressed_size);␊
1025␉␉if (OSSwapBigToHostInt32(kernel_header->adler32) != adler32)␊
1026␉␉{␊
1027␉␉␉error("ERROR! Adler mismatch (found: %X, expected: %X).\n", adler32, OSSwapBigToHostInt32(kernel_header->adler32));␊
1028␉␉␉return -1;␊
1029␉␉}␊
1030␊
1031␉␉DBG("\n");␊
1032␉}␊
1033␉␊
1034␉ret = ThinFatFile(&binary, &len);␊
1035␉if (ret == 0 && len == 0 && archCpuType==CPU_TYPE_X86_64)␊
1036␉{␊
1037␉␉archCpuType=CPU_TYPE_I386;␊
1038␉␉ret = ThinFatFile(&binary, &len);␊
1039␉}␊
1040␊
1041␉// Bungo: scan binary for Darwin Kernel Version string␊
1042␉useDarwinVersion = true;␊
1043␉uint32_t offset = 0;␊
1044␉strncpy(gDarwinBuildVerStr, "Darwin Kernel Version", sizeof(gDarwinBuildVerStr));␊
1045␊
1046␉while ((offset < 0xFFFFFFFF - (uint32_t)binary - 256) && memcmp(binary + offset, gDarwinBuildVerStr, 21))␊
1047␉{␊
1048␉␉offset++;␊
1049␉}␊
1050␉if (offset < 0xFFFFFFFF - (uint32_t)binary - 256)␊
1051␉{␊
1052␉␉strncpy(gDarwinBuildVerStr, (char *)(binary + offset), sizeof(gDarwinBuildVerStr));␊
1053␉}␊
1054␉else␊
1055␉{␊
1056␉␉strcat(gDarwinBuildVerStr, ": Unknown");␊
1057␉␉useDarwinVersion = false;␊
1058␉}␊
1059␉// Micky1979 use Bungo gDarwinBuildVerStr and split into gDarwinMajor, gDarwinMinor and gDarwinRev␊
1060␉if (useDarwinVersion)␊
1061␉{␊
1062␉␉useDarwinVersion = false;␊
1063␉␉const char *pattern = strstr(gDarwinBuildVerStr, "Darwin Kernel Version ")+22;␊
1064␉␉const char *until = strstr(pattern, ":");␊
1065␉␉size_t vlen = until - pattern;␊
1066␉␉char *ver = (char *)malloc(sizeof(char)*(len+1));␊
1067␉␉strncpy(ver, pattern, vlen);␊
1068␉␉ver[vlen] = '\0';␊
1069␉␉char *delim;␊
1070␉␉char *temp;␊
1071␉␉gDarwinMajor = -1; gDarwinMinor = -1; gDarwinRev = -1;␊
1072␉␉if (ver != NULL)␊
1073␉␉{␊
1074␉␉␉temp = ver;␊
1075␉␉␉int count = 1;␊
1076␉␉␉while ((delim = strsep_c(&ver, ".")) != NULL)␊
1077␉␉␉{␊
1078␉␉␉␉switch (count)␊
1079␉␉␉␉{␊
1080␉␉␉␉␉case 1: gDarwinMajor = atoi(delim); break;␊
1081␉␉␉␉␉case 2: gDarwinMinor = atoi(delim); break;␊
1082␉␉␉␉␉case 3: gDarwinRev = atoi(delim); break;␊
1083␉␉␉␉␉default: break;␊
1084␉␉␉␉}␊
1085␉␉␉␉count ++;␊
1086␉␉␉}␊
1087␉␉␉free(temp);␊
1088␉␉}␊
1089␊
1090␉␉if (gDarwinMajor >= 0 && gDarwinMinor >= 0 && gDarwinRev >= 0)␊
1091␉␉{␊
1092␉␉␉useDarwinVersion = true;␊
1093␉␉}␊
1094␊
1095␉␉switch (gDarwinMajor)␊
1096␉␉{␊
1097␉␉␉case 10:␊
1098␉␉␉␉switch (gDarwinMinor)␊
1099␉␉␉␉{␊
1100␉␉␉␉␉case 0: kernelOSVer = 0xA060000; break;␊
1101␉␉␉␉␉case 1: kernelOSVer = 0xA060100; break;␊
1102␉␉␉␉␉case 2: kernelOSVer = 0xA060200; break;␊
1103␉␉␉␉␉case 3: kernelOSVer = 0xA060300; break;␊
1104␉␉␉␉␉case 4: kernelOSVer = 0xA060400; break;␊
1105␉␉␉␉␉case 5: kernelOSVer = 0xA060500; break;␊
1106␉␉␉␉␉case 6: kernelOSVer = 0xA060600; break;␊
1107␉␉␉␉␉case 7: kernelOSVer = 0xA060700; break;␊
1108␉␉␉␉␉case 8: kernelOSVer = 0xA060800; break;␊
1109␉␉␉␉␉default:kernelOSVer = 0xA060800; break; //Last known kernel␊
1110␉␉␉␉}␊
1111␉␉␉␉break;␊
1112␉␉␉case 11:␊
1113␉␉␉␉switch (gDarwinMinor)␊
1114␉␉␉␉{␊
1115␉␉␉␉␉case 0: kernelOSVer = 0xA070000; break;␊
1116␉␉␉␉␉case 1: kernelOSVer = 0xA070100; break;␊
1117␉␉␉␉␉case 2: kernelOSVer = 0xA070200; break;␊
1118␉␉␉␉␉case 3: kernelOSVer = 0xA070300; break;␊
1119␉␉␉␉␉case 4:␊
1120␉␉␉␉␉␉switch (gDarwinRev)␊
1121␉␉␉␉␉␉{␊
1122␉␉␉␉␉␉␉case 0: kernelOSVer = 0xA070400; break;␊
1123␉␉␉␉␉␉␉case 1: kernelOSVer = 0xA070400; break;␊
1124␉␉␉␉␉␉␉case 2: kernelOSVer = 0xA070500; break;␊
1125␉␉␉␉␉␉␉default:kernelOSVer = 0xA070500; break; //Last known kernel␊
1126␉␉␉␉␉␉}␊
1127␉␉␉␉␉default:kernelOSVer = 0xA070500; break; //Last known kernel␊
1128␉␉␉␉}␊
1129␉␉␉␉break;␊
1130␉␉␉case 12:␊
1131␉␉␉␉switch (gDarwinMinor)␊
1132␉␉␉␉{␊
1133␉␉␉␉␉case 0: kernelOSVer = 0xA080000; break;␊
1134␉␉␉␉␉case 1: kernelOSVer = 0xA080100; break;␊
1135␉␉␉␉␉case 2: kernelOSVer = 0xA080200; break;␊
1136␉␉␉␉␉case 3: kernelOSVer = 0xA080300; break;␊
1137␉␉␉␉␉case 4: kernelOSVer = 0xA080400; break;␊
1138␉␉␉␉␉case 5: kernelOSVer = 0xA080500; break; // 10.8.5␊
1139␉␉␉␉␉case 6: kernelOSVer = 0xA080500; break; // 10.8.5 update␊
1140␉␉␉␉␉default:kernelOSVer = 0xA080500; break; //Last known kernel␊
1141␉␉␉␉}␊
1142␉␉␉␉break;␊
1143␉␉␉case 13:␊
1144␉␉␉␉switch (gDarwinMinor)␊
1145␉␉␉␉{␊
1146␉␉␉␉␉case 0: kernelOSVer = 0xA090000;␊
1147␉␉␉␉␉switch (gDarwinRev)␊
1148␉␉␉␉␉{␊
1149␉␉␉␉␉␉case 0: kernelOSVer = 0xA090000; break;␊
1150␉␉␉␉␉␉case 1: kernelOSVer = 0xA090000; break; // never exist (or released)␊
1151␉␉␉␉␉␉case 2: kernelOSVer = 0xA090100; break;␊
1152␉␉␉␉␉␉default:kernelOSVer = 0xA090100; break; //Last known kernel␊
1153␉␉␉␉␉}␊
1154␉␉␉␉␉␉break;␊
1155␉␉␉␉␉case 1: kernelOSVer = 0xA090100; break; // never exist (or released)␊
1156␉␉␉␉␉case 2: kernelOSVer = 0xA090200; break;␊
1157␉␉␉␉␉case 3: kernelOSVer = 0xA090300; break;␊
1158␉␉␉␉␉case 4: kernelOSVer = 0xA090400; break;␊
1159␉␉␉␉␉case 5: kernelOSVer = 0xA090500; break;␊
1160␉␉␉␉␉default:kernelOSVer = 0xA090500; break; //Last known kernel␊
1161␉␉␉␉}␊
1162␉␉␉␉break;␊
1163␉␉␉case 14:␊
1164␉␉␉␉switch (gDarwinMinor)␊
1165␉␉␉␉{␊
1166␉␉␉␉␉case 0: kernelOSVer = 0xA0A0000; break; // same kernel of 10.10.1␊
1167␉␉␉␉␉case 1: kernelOSVer = 0xA0A0100; break; // same kernel of 10.10␊
1168␉␉␉␉␉case 2: kernelOSVer = 0xA0A0200; break;␊
1169␉␉␉␉␉case 3: kernelOSVer = 0xA0A0300; break;␊
1170␉␉␉␉␉case 4: kernelOSVer = 0xA0A0400; break;␊
1171␉␉␉␉␉case 5: kernelOSVer = 0xA0A0500; break;␊
1172␉␉␉␉␉default:kernelOSVer = 0xA0A0500; break; //Last known kernel␊
1173␉␉␉␉}␊
1174␉␉␉␉break;␊
1175␉␉␉case 15: /* El Capitan */␊
1176␉␉␉␉switch (gDarwinMinor)␊
1177␉␉␉␉{␊
1178␉␉␉␉␉case 0: kernelOSVer = 0xA0B0000; break;␊
1179␉␉␉␉␉case 1: kernelOSVer = 0xA0B0100; break;␊
1180␉␉␉␉␉case 2: kernelOSVer = 0xA0B0200; break;␊
1181␉␉␉␉␉case 3: kernelOSVer = 0xA0B0300; break;␊
1182␉␉␉␉␉case 4: kernelOSVer = 0xA0B0400; break;␊
1183␉␉␉␉␉case 5: kernelOSVer = 0xA0B0500; break;␊
1184␉␉␉␉␉case 6: kernelOSVer = 0xA0B0600; break;␊
1185␉␉␉␉␉default:kernelOSVer = 0xA0B0600; break; //Last known kernel (add here updates)␊
1186␉␉␉␉}␊
1187␉␉␉␉break;␊
1188␉␉␉case 16: /* Sierra */␊
1189␉␉␉␉switch (gDarwinMinor)␊
1190␉␉␉␉{␊
1191␉␉␉␉␉case 0: kernelOSVer = 0xA0C0000; break;␊
1192␉␉␉␉␉case 1: kernelOSVer = 0xA0C0100; break;␊
1193␉␉␉␉␉case 2: kernelOSVer = 0xA0C0200; break;␊
1194␉␉␉␉␉case 3: kernelOSVer = 0xA0C0200; break;␊
1195␉␉␉␉␉case 4: kernelOSVer = 0xA0C0300; break;␊
1196␉␉␉␉␉case 5: kernelOSVer = 0xA0C0400; break;␊
1197␉␉␉␉␉default:kernelOSVer = 0xA0C0400; break; //Last known kernel (add here updates)␊
1198␉␉␉␉}␊
1199␉␉␉␉break;␊
1200␉␉␉default:␊
1201␉␉␉␉kernelOSVer = 0xA0C0400;␊
1202␉␉␉␉break; //Last known kernel is Sierra 10.12.4␊
1203␉␉␉}␊
1204␉␉}␊
1205␉␉else␊
1206␉␉{␊
1207␉␉␉switch (MacOSVerCurrent)␊
1208␉␉␉{␊
1209␉␉␉// Snow␊
1210␉␉␉case 0xA060000: gDarwinMajor = 10; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.6␊
1211␉␉␉case 0xA060100: gDarwinMajor = 10; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.6.1␊
1212␉␉␉case 0xA060200: gDarwinMajor = 10; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.6.2␊
1213␉␉␉case 0xA060300: gDarwinMajor = 10; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.6.3␊
1214␉␉␉case 0xA060400: gDarwinMajor = 10; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.6.4␊
1215␉␉␉case 0xA060500: gDarwinMajor = 10; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.6.5␊
1216␉␉␉case 0xA060600: gDarwinMajor = 10; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.6.6␊
1217␉␉␉case 0xA060700: gDarwinMajor = 10; gDarwinMinor = 7; gDarwinRev = 0; break; // 10.6.7␊
1218␉␉␉case 0xA060800: gDarwinMajor = 10; gDarwinMinor = 8; gDarwinRev = 0; break; // 10.6.8␊
1219␉␉␉// Lion␊
1220␉␉␉case 0xA070000: gDarwinMajor = 11; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.7␊
1221␉␉␉case 0xA070100: gDarwinMajor = 11; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.7.1␊
1222␉␉␉case 0xA070200: gDarwinMajor = 11; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.7.2␊
1223␉␉␉case 0xA070300: gDarwinMajor = 11; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.7.3␊
1224␉␉␉case 0xA070400: gDarwinMajor = 11; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.7.4␊
1225␉␉␉case 0xA070500: gDarwinMajor = 11; gDarwinMinor = 4; gDarwinRev = 2; break; // 10.7.5␊
1226␉␉␉// ML␊
1227␉␉␉case 0xA080000: gDarwinMajor = 12; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.8␊
1228␉␉␉case 0xA080100: gDarwinMajor = 12; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.8.1␊
1229␉␉␉case 0xA080200: gDarwinMajor = 12; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.8.2␊
1230␉␉␉case 0xA080300: gDarwinMajor = 12; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.8.3␊
1231␉␉␉case 0xA080400: gDarwinMajor = 12; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.8.4␊
1232␉␉␉case 0xA080500: gDarwinMajor = 12; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.8.5␊
1233␉␉␉// Mavericks␊
1234␉␉␉case 0xA090000: gDarwinMajor = 13; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.9␊
1235␉␉␉case 0xA090100: gDarwinMajor = 13; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.9.1␊
1236␉␉␉case 0xA090200: gDarwinMajor = 13; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.9.2␊
1237␉␉␉case 0xA090300: gDarwinMajor = 13; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.9.3␊
1238␉␉␉case 0xA090400: gDarwinMajor = 13; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.9.4␊
1239␉␉␉case 0xA090500: gDarwinMajor = 13; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.9.5␊
1240␉␉␉// Yosemite␊
1241␉␉␉case 0xA0A0000: gDarwinMajor = 14; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.10␊
1242␉␉␉case 0xA0A0100: gDarwinMajor = 14; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.10.1␊
1243␉␉␉case 0xA0A0200: gDarwinMajor = 14; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.10.2␊
1244␉␉␉case 0xA0A0300: gDarwinMajor = 14; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.10.3␊
1245␉␉␉case 0xA0A0400: gDarwinMajor = 14; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.10.4␊
1246␉␉␉case 0xA0A0500: gDarwinMajor = 14; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.10.5␊
1247␉␉␉// El Capitan␊
1248␉␉␉case 0xA0B0000: gDarwinMajor = 15; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.11␊
1249␉␉␉case 0xA0B0100: gDarwinMajor = 15; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.11.1␊
1250␉␉␉case 0xA0B0200: gDarwinMajor = 15; gDarwinMinor = 2; gDarwinRev = 0; break; // 10.11.2␊
1251␉␉␉case 0xA0B0300: gDarwinMajor = 15; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.11.3␊
1252␉␉␉case 0xA0B0400: gDarwinMajor = 15; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.11.4␊
1253␉␉␉case 0xA0B0500: gDarwinMajor = 15; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.11.5␊
1254␉␉␉case 0xA0B0600: gDarwinMajor = 15; gDarwinMinor = 6; gDarwinRev = 0; break; // 10.11.6␊
1255␉␉␉// Sierra␊
1256␉␉␉case 0xA0C0000: gDarwinMajor = 16; gDarwinMinor = 0; gDarwinRev = 0; break; // 10.12␊
1257␉␉␉case 0xA0C0100: gDarwinMajor = 16; gDarwinMinor = 1; gDarwinRev = 0; break; // 10.12.1␊
1258␉␉␉case 0xA0C0200: gDarwinMajor = 16; gDarwinMinor = 3; gDarwinRev = 0; break; // 10.12.2␊
1259␉␉␉case 0xA0C0300: gDarwinMajor = 16; gDarwinMinor = 4; gDarwinRev = 0; break; // 10.12.3␊
1260␉␉␉case 0xA0C0400: gDarwinMajor = 16; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.12.4␊
1261␉␉␉// default = last known kernel␊
1262␉␉␉default: gDarwinMajor = 16; gDarwinMinor = 5; gDarwinRev = 0; break; // 10.12.4;␊
1263␉␉}␊
1264␉}␊
1265␊
1266␉// Notify modules that the kernel has been decompressed, thinned and is about to be decoded␊
1267␉execute_hook("DecodeKernel", (void *)binary, NULL, NULL, NULL);␊
1268␊
1269/* ================================================================ */␊
1270␊
1271␉ret = DecodeMachO(binary, uncompressed_size, rentry, raddr, rsize);␊
1272␉if (ret < 0 && archCpuType == CPU_TYPE_X86_64)␊
1273␉{␊
1274␉␉archCpuType = CPU_TYPE_I386;␊
1275␉␉ret = DecodeMachO(binary, uncompressed_size, rentry, raddr, rsize);␊
1276␉}␊
1277␊
1278␉return ret;␊
1279}␊
1280

Archive Download this file

Revision: 2871