Chameleon

Chameleon Svn Source Tree

Root/branches/cparm/i386/boot2/modules.c

1/*␊
2 * Copyright 2010 Evan Lojewski. All rights reserved.␊
3 *␊
4 */␊
5␊
6#include "boot.h"␊
7#include "bootstruct.h"␊
8#include "multiboot.h"␊
9#include "modules.h"␊
10␊
11#ifndef DEBUG_MODULES␊
12#define DEBUG_MODULES 0␊
13#endif␊
14␊
15#if DEBUG_MODULES␊
16#define DBG(x...)␉printf(x)␊
17#else␊
18#define DBG(x...)␊
19#endif␊
20␊
21// NOTE: Global so that modules can link with this␊
22unsigned long long textAddress = 0;␊
23unsigned long long textSection = 0;␊
24␊
25moduleHook_t* moduleCallbacks = NULL;␊
26moduleList_t* loadedModules = NULL;␊
27symbolList_t* moduleSymbols = NULL;␊
28unsigned int (*lookup_symbol)(const char*, int(*strcmp_callback)(const char*, const char*)) = NULL;␊
29␊
30#if DEBUG_MODULES␊
31VOID print_hook_list()␊
32{␊
33␉moduleHook_t* hooks = moduleCallbacks;␊
34␉printf("Hook list: \n");␊
35␉while(hooks)␊
36␉{␊
37␉␉printf("* %s\n", hooks->name);␊
38␉␉hooks = hooks->next;␊
39␉}␊
40␉printf("\n");␊
41}␊
42␊
43VOID print_symbol_list()␊
44{␊
45␉symbolList_t* symbol = moduleSymbols;␊
46␉printf("Symbol list: \n");␊
47␉while(symbol)␊
48␉{␊
49␉␉printf("* %s\n", symbol->symbol);␊
50␉␉symbol = symbol->next;␊
51␉}␊
52␉printf("\n");␊
53}␊
54#endif␊
55␊
56␊
57/*␊
58 * Initialize the module system by loading the Symbols.dylib module.␊
59 * Once loaded, locate the _lookup_symbol function so that internal␊
60 * symbols can be resolved.␊
61 */␊
62EFI_STATUS init_module_system()␊
63{␊
64␉msglog("* Attempting to load system module\n");␊
65␉␊
66␉// Intialize module system␊
67 EFI_STATUS status = load_module(SYMBOLS_MODULE);␊
68␉if((status == EFI_SUCCESS) || (status == EFI_ALREADY_STARTED)/*should never happen*/ ) ␊
69␉{␊
70␉␉lookup_symbol = (void*)lookup_all_symbols(SYMBOL_LOOKUP_SYMBOL);␊
71␉␉␊
72␉␉if((UInt32)lookup_symbol != 0xFFFFFFFF)␊
73␉␉{␊
74␉␉␉return EFI_SUCCESS;␊
75␉␉}␊
76␉␉␊
77␉}␊
78␉␊
79␉return EFI_LOAD_ERROR;␊
80}␊
81␊
82␊
83/*␊
84 * Load all modules in the /Extra/modules/ directory␊
85 * Module depencdies will be loaded first␊
86 * MOdules will only be loaded once. When loaded a module must␊
87 * setup apropriete function calls and hooks as required.␊
88 * NOTE: To ensure a module loads after another you may ␊
89 * link one module with the other. For dyld to allow this, you must␊
90 * reference at least one symbol within the module.␊
91 */␊
92␊
93VOID load_all_modules()␊
94{␊
95␉char* name;␊
96␉long flags;␊
97␉long time;␊
98␉struct dirstuff* moduleDir = opendir("/Extra/modules/");␊
99␉while(readdir(moduleDir, (const char**)&name, &flags, &time) >= 0)␊
100␉{␊
101␉␉if ((strcmp(SYMBOLS_MODULE,name)) == 0) continue; // if we found Symbols.dylib, just skip it␊
102␉␉␊
103␉␉int len = strlen(name);␊
104␉␉int ext_size = sizeof("dylib");␊
105␉␉␊
106␉␉if (len >= ext_size)␊
107␉␉{␊
108␉␉␉if(strcmp(&name[len - ext_size], ".dylib") == 0)␊
109␉␉␉{␉␉␉␉␊
110␉␉␉␉char *tmp = newString(name);␉␉␉␉␉␉␉␉␊
111␉␉␉␉if (!tmp) {␊
112␉␉␉␉␉continue;␊
113␉␉␉␉}␊
114␉␉␉␉msglog("* Attempting to load module: %s\n", tmp);␉␉␉␊
115␉␉␉␉if(load_module(tmp) != EFI_SUCCESS)␊
116␉␉␉␉{␊
117␉␉␉␉␉// failed to load or already loaded␊
118␉␉␉␉␉free(tmp);␊
119␉␉␉␉}␊
120␉␉␉}␊
121#if DEBUG_MODULES␊
122␉␉␉else ␊
123␉␉␉{␊
124␉␉␉␉DBG("Ignoring %s\n", name);␊
125␉␉␉}␊
126#endif␊
127␉␉}␉␉␊
128#if DEBUG_MODULES␊
129␉␉else ␊
130␉␉{␊
131␉␉␉DBG("Ignoring %s\n", name);␊
132␉␉}␊
133#endif␊
134␉␉␊
135␉}␊
136␉␊
137␉if (moduleDir)␊
138␉{␊
139␉␉closedir(moduleDir);␊
140␉␉␊
141␉}␊
142␉␊
143#if DEBUG_MODULES␊
144␉print_symbol_list();␊
145#endif␊
146}␊
147␊
148/*␊
149 * Load a module file in /Extra/modules␊
150 * TODO: verify version number of module␊
151 */␊
152EFI_STATUS load_module(char* module)␊
153{␊
154␉void (*module_start)(void) = NULL;␊
155␉␊
156␉␊
157␉// Check to see if the module has already been loaded␊
158␉if(is_module_loaded(module) == EFI_SUCCESS)␊
159␉{␊
160␉␉msglog("Module %s already registred\n", module);␊
161␉␉return EFI_ALREADY_STARTED;␊
162␉}␊
163␉␊
164␉int fh = -1;␊
165␉char *modString=NULL;␊
166␉modString = newStringWithFormat( "/Extra/modules/%s", module);␊
167␉if (!modString) {␊
168␉␉printf("Unable to allocate module name : /Extra/modules/%s\n", module);␊
169␉␉return EFI_OUT_OF_RESOURCES;␊
170␉}␊
171␉fh = open(modString);␊
172␉if(fh < 0)␊
173␉{␉␉␊
174#if DEBUG_MODULES␊
175␉␉DBG("Unable to locate module %s\n", modString);␊
176␉␉getc();␊
177#else␊
178␉␉msglog("Unable to locate module %s\n", modString);␊
179#endif␊
180␉␉free(modString);␊
181␉␉return EFI_OUT_OF_RESOURCES;␉␉␊
182␉}␊
183␉EFI_STATUS ret = EFI_SUCCESS;␊
184␉␊
185␉{␊
186␉␉int moduleSize = file_size(fh);␊
187␉␉␊
188␉␉char* module_base = NULL;␊
189␉␉␊
190␉␉if (moduleSize > 0)␊
191␉␉{␊
192␉␉␉module_base = (char*) malloc(moduleSize);␊
193␉␉}␉␉␊
194␉␉␊
195␉␉if (module_base && read(fh, module_base, moduleSize) == moduleSize)␊
196␉␉{␊
197␉␉␉␊
198␉␉␉DBG("Module %s read in.\n", modString);␊
199␉␉␉␊
200␉␉␉// Module loaded into memory, parse it␊
201␉␉␉module_start = parse_mach(module_base, &load_module, &add_symbol);␊
202␉␉␉␊
203␉␉␉if(module_start && (module_start != (void*)0xFFFFFFFF))␊
204␉␉␉{␊
205␉␉␉␉module_loaded(module/*moduleName, moduleVersion, moduleCompat*/);␊
206␉␉␉␉// Notify the system that it was laoded␊
207␉␉␉␉(*module_start)();␉// Start the module␊
208␉␉␉␉msglog("%s successfully Loaded.\n", module);␊
209␉␉␉}␊
210␉␉␉else␊
211␉␉␉{␊
212␉␉␉␉// The module does not have a valid start function␊
213␉␉␉␉printf("Unable to start %s\n", module);␉␊
214␉␉␉␉ret = EFI_NOT_STARTED;␊
215#if DEBUG_MODULES␉␉␉␊
216␉␉␉␉getc();␊
217#endif␊
218␉␉␉}␉␉␊
219␉␉}␊
220␉␉else␊
221␉␉{␊
222␉␉␉printf("Unable to read in module %s\n.", module);␊
223#if DEBUG_MODULES␉␉␊
224␉␉␉getc();␊
225#endif␊
226␉␉␉ret = EFI_LOAD_ERROR;␊
227␉␉}␊
228␉}␊
229␉close(fh);␊
230␉free(modString);␊
231␉return ret;␊
232}␊
233␊
234moduleHook_t* get_callback(const char* name)␊
235{␊
236␉moduleHook_t* hooks = moduleCallbacks;␊
237␉␊
238␉// look for a hook. If it exists, return the moduleHook_t*,␊
239␉// If not, return NULL.␊
240␉while(hooks)␊
241␉{␊
242␉␉if(strcmp(name, hooks->name) == 0)␊
243␉␉{␊
244␉␉␉//DBG("Located hook %s\n", name);␊
245␉␉␉return hooks;␊
246␉␉}␊
247␉␉hooks = hooks->next;␊
248␉}␊
249␉return NULL;␊
250␉␊
251}␊
252␊
253/*␊
254 *␉execute_hook( const char* name )␊
255 *␉␉name - Name of the module hook␊
256 *␉␉␉If any callbacks have been registered for this hook␊
257 *␉␉␉they will be executed now in the same order that the␊
258 *␉␉␉hooks were added.␊
259 */␊
260EFI_STATUS execute_hook(const char* name, void* arg1, void* arg2, void* arg3, void* arg4, void* arg5, void* arg6)␊
261{␊
262␉DBG("Attempting to execute hook '%s'\n", name);␊
263␉moduleHook_t* hook = get_callback(name);␊
264␉␊
265␉if(hook)␊
266␉{␊
267␉␉// Loop through all callbacks for this module␊
268␉␉callbackList_t* callbacks = hook->callbacks;␊
269␉␉␊
270␉␉while(callbacks)␊
271␉␉{␊
272␉␉␉// Execute callback␊
273␉␉␉callbacks->callback(arg1, arg2, arg3, arg4, arg5, arg6);␊
274␉␉␉callbacks = callbacks->next;␊
275␉␉}␊
276␉␉DBG("Hook '%s' executed.\n", name); ␊
277␉␉return EFI_SUCCESS;␊
278␉}␊
279␉␊
280␉// Callback for this hook doesn't exist;␊
281␉DBG("No callbacks for '%s' hook.\n", name);␊
282␉return EFI_NOT_FOUND;␊
283␉␊
284}␊
285␊
286/*␊
287 *␉register_hook_callback( const char* name, void(*callback)())␊
288 *␉␉name - Name of the module hook to attach to.␊
289 *␉␉callbacks - The funciton pointer that will be called when the␊
290 *␉␉␉hook is executed. When registering a new callback name, the callback is added sorted.␊
291 *␉␉␉NOTE: the hooks take four void* arguments.␊
292 */␊
293VOID register_hook_callback(const char* name, void(*callback)(void*, void*, void*, void*, void*, void*))␊
294{␉␊
295␉DBG("Adding callback for hook '%s'.\n", name);␊
296␉␊
297␉moduleHook_t* hook = get_callback(name);␊
298␉␊
299␉if(hook)␊
300␉{␊
301␉␉// append␊
302␉␉callbackList_t* newCallback = malloc(sizeof(callbackList_t));␊
303␉␉if (!newCallback) {␊
304␉␉␉DBG("Unable to allocate memory for callback \n");␊
305␉␉␉return;␊
306␉␉}␊
307␉␉newCallback->next = hook->callbacks;␊
308␉␉hook->callbacks = newCallback;␊
309␉␉newCallback->callback = callback;␊
310␉}␊
311␉else␊
312␉{␊
313␉␉// create new hook␊
314␉␉moduleHook_t* newHook = malloc(sizeof(moduleHook_t));␊
315␉␉if (!newHook) {␊
316␉␉␉DBG("Unable to allocate memory for hook '%s'.\n", name);␊
317␉␉␉return;␊
318␉␉}␊
319␉␉newHook->name = name;␊
320␉␉newHook->callbacks = malloc(sizeof(callbackList_t));␊
321␉␉if (!newHook->callbacks) {␊
322␉␉␉DBG("Unable to allocate memory for callback \n");␊
323␉␉␉free(newHook);␊
324␉␉␉return;␊
325␉␉}␊
326␉␉newHook->callbacks->callback = callback;␊
327␉␉newHook->callbacks->next = NULL;␊
328␉␉␊
329␉␉newHook->next = moduleCallbacks;␊
330␉␉moduleCallbacks = newHook;␊
331␉␉␊
332␉}␊
333␉␊
334#if DEBUG_MODULES␊
335␉print_hook_list();␊
336␉getc();␊
337#endif␊
338␉␊
339}␊
340␊
341#if DEBUG_MODULES␊
342unsigned long vmaddr;␊
343long vmsize;␊
344#endif␊
345␊
346/*␊
347 * Parse through a macho module. The module will be rebased and binded␊
348 * as specified in the macho header. If the module is successfully loaded␊
349 * the module iinit address will be returned.␊
350 * NOTE; all dependecies will be loaded before this module is started␊
351 * NOTE: If the module is unable to load ot completeion, the modules␊
352 * symbols will still be available (TODO: fix this). This should not␊
353 * happen as all dependencies are verified before the sybols are read in.␊
354 */␊
355void* parse_mach(void* binary, EFI_STATUS(*dylib_loader)(char*), long long(*symbol_handler)(char*, long long, char))␉// TODO: add param to specify valid archs␊
356{␉␊
357␉char is64 = false;␊
358␉void (*module_start)(void) = NULL;␊
359␉␊
360␉// Module info␊
361␉/*char* moduleName = NULL;␊
362␉ UInt32 moduleVersion = 0;␊
363␉ UInt32 moduleCompat = 0;␊
364␉ */␊
365␉␊
366␉// TODO convert all of the structs to a union␉␊
367␉struct dyld_info_command* dyldInfoCommand = NULL;␉␊
368␉struct symtab_command* symtabCommand = NULL;␉␊
369␉␊
370␉{␊
371␉␉struct segment_command *segCommand = NULL;␊
372␉␉struct segment_command_64 *segCommand64 = NULL;␊
373␉␉struct dylib_command* dylibCommand = NULL;␊
374␉␉struct load_command *loadCommand = NULL;␊
375␉␉UInt32 binaryIndex = 0;␊
376␉␉UInt16 cmd = 0;␊
377␉␉␊
378␉␉// Parse through the load commands␊
379␉␉if(((struct mach_header*)binary)->magic == MH_MAGIC)␊
380␉␉{␊
381␉␉␉is64 = false;␊
382␉␉␉binaryIndex += sizeof(struct mach_header);␊
383␉␉}␊
384␉␉else if(((struct mach_header_64*)binary)->magic == MH_MAGIC_64)␊
385␉␉{␊
386␉␉␉// NOTE: modules cannot be 64bit...␊
387␉␉␉is64 = true;␊
388␉␉␉binaryIndex += sizeof(struct mach_header_64);␊
389␉␉}␊
390␉␉else␊
391␉␉{␊
392␉␉␉printf("Modules: Invalid mach magic\n");␊
393␉␉␉getc();␊
394␉␉␉return NULL;␊
395␉␉}␊
396␉␉␊
397␉␉␊
398␉␉␊
399␉␉/*if(((struct mach_header*)binary)->filetype != MH_DYLIB)␊
400␉␉ {␊
401␉␉ printf("Module is not a dylib. Unable to load.\n");␊
402␉␉ getc();␊
403␉␉ return NULL; // Module is in the incorrect format␊
404␉␉ }*/␊
405␉␉␊
406␉␉while(cmd < ((struct mach_header*)binary)->ncmds)␊
407␉␉{␊
408␉␉␉cmd++;␊
409␉␉␉␊
410␉␉␉loadCommand = binary + binaryIndex;␊
411␉␉␉UInt32 cmdSize = loadCommand->cmdsize;␊
412␉␉␉␊
413␉␉␉␊
414␉␉␉switch ((loadCommand->cmd & 0x7FFFFFFF))␊
415␉␉␉{␊
416␉␉␉␉case LC_SYMTAB:␊
417␉␉␉␉␉symtabCommand = binary + binaryIndex;␊
418␉␉␉␉␉break;␊
419␉␉␉␉␉␊
420␉␉␉␉case LC_SEGMENT: // 32bit macho␊
421␉␉␉␉{␊
422␉␉␉␉␉segCommand = binary + binaryIndex;␊
423␉␉␉␉␉␊
424␉␉␉␉␉//printf("Segment name is %s\n", segCommand->segname);␊
425␉␉␉␉␉␊
426␉␉␉␉␉if(strcmp("__TEXT", segCommand->segname) == 0)␊
427␉␉␉␉␉{␊
428␉␉␉␉␉␉UInt32 sectionIndex;␊
429␉␉␉␉␉␉␊
430#if DEBUG_MODULES␊
431␉␉␉␉␉␉unsigned long fileaddr;␊
432␉␉␉␉␉␉long filesize;␉␉␉␉␉␊
433␉␉␉␉␉␉vmaddr = (segCommand->vmaddr & 0x3fffffff);␊
434␉␉␉␉␉␉vmsize = segCommand->vmsize;␉ ␊
435␉␉␉␉␉␉fileaddr = ((unsigned long)(binary + binaryIndex) + segCommand->fileoff);␊
436␉␉␉␉␉␉filesize = segCommand->filesize;␊
437␉␉␉␉␉␉␊
438␉␉␉␉␉␉printf("segname: %s, vmaddr: %x, vmsize: %x, fileoff: %x, filesize: %x, nsects: %d, flags: %x.\n",␊
439␉␉␉␉␉␉␉ segCommand->segname, (unsigned)vmaddr, (unsigned)vmsize, (unsigned)fileaddr, (unsigned)filesize,␊
440␉␉␉␉␉␉␉ (unsigned) segCommand->nsects, (unsigned)segCommand->flags);␊
441#if DEBUG_MODULES==2␊
442␉␉␉␉␉␉␊
443␉␉␉␉␉␉getc();␊
444#endif␊
445#endif␊
446␉␉␉␉␉␉␊
447␉␉␉␉␉␉sectionIndex = sizeof(struct segment_command);␊
448␉␉␉␉␉␉␊
449␉␉␉␉␉␉struct section *sect;␊
450␉␉␉␉␉␉␊
451␉␉␉␉␉␉while(sectionIndex < segCommand->cmdsize)␊
452␉␉␉␉␉␉{␊
453␉␉␉␉␉␉␉sect = binary + binaryIndex + sectionIndex;␊
454␉␉␉␉␉␉␉␊
455␉␉␉␉␉␉␉sectionIndex += sizeof(struct section);␊
456␉␉␉␉␉␉␉␊
457␉␉␉␉␉␉␉␊
458␉␉␉␉␉␉␉if(strcmp("__text", sect->sectname) == 0)␊
459␉␉␉␉␉␉␉{␊
460␉␉␉␉␉␉␉␉// __TEXT,__text found, save the offset and address for when looking for the calls.␊
461␉␉␉␉␉␉␉␉textSection = sect->offset;␊
462␉␉␉␉␉␉␉␉textAddress = sect->addr;␊
463␉␉␉␉␉␉␉␉break;␊
464␉␉␉␉␉␉␉}␉␉␉␉␉␊
465␉␉␉␉␉␉}␊
466␉␉␉␉␉}␊
467␉␉␉␉␉break;␊
468␉␉␉␉}␉␉␉␉␊
469␉␉␉␉case LC_SEGMENT_64:␉// 64bit macho's␊
470␉␉␉␉{␊
471␉␉␉␉␉segCommand64 = binary + binaryIndex;␊
472␉␉␉␉␉␊
473␉␉␉␉␉//printf("Segment name is %s\n", segCommand->segname);␊
474␉␉␉␉␉␊
475␉␉␉␉␉if(strcmp("__TEXT", segCommand64->segname) == 0)␊
476␉␉␉␉␉{␊
477␉␉␉␉␉␉UInt32 sectionIndex;␊
478␉␉␉␉␉␉␊
479#if DEBUG_MODULES␉␉␉␉␉␉␊
480␉␉␉␉␉␉unsigned long fileaddr;␊
481␉␉␉␉␉␉long filesize;␉␉␉␉␉␊
482␉␉␉␉␉␉vmaddr = (segCommand64->vmaddr & 0x3fffffff);␊
483␉␉␉␉␉␉vmsize = segCommand64->vmsize;␉ ␊
484␉␉␉␉␉␉fileaddr = ((unsigned long)(binary + binaryIndex) + segCommand64->fileoff);␊
485␉␉␉␉␉␉filesize = segCommand64->filesize;␊
486␉␉␉␉␉␉␊
487␉␉␉␉␉␉printf("segname: %s, vmaddr: %x, vmsize: %x, fileoff: %x, filesize: %x, nsects: %d, flags: %x.\n",␊
488␉␉␉␉␉␉␉ segCommand64->segname, (unsigned)vmaddr, (unsigned)vmsize, (unsigned)fileaddr, (unsigned)filesize,␊
489␉␉␉␉␉␉␉ (unsigned) segCommand64->nsects, (unsigned)segCommand64->flags);␊
490#if DEBUG_MODULES==2␊
491␉␉␉␉␉␉␊
492␉␉␉␉␉␉getc();␊
493#endif␊
494#endif␊
495␉␉␉␉␉␉␊
496␉␉␉␉␉␉sectionIndex = sizeof(struct segment_command_64);␊
497␉␉␉␉␉␉␊
498␉␉␉␉␉␉struct section_64 *sect;␊
499␉␉␉␉␉␉␊
500␉␉␉␉␉␉while(sectionIndex < segCommand64->cmdsize)␊
501␉␉␉␉␉␉{␊
502␉␉␉␉␉␉␉sect = binary + binaryIndex + sectionIndex;␊
503␉␉␉␉␉␉␉␊
504␉␉␉␉␉␉␉sectionIndex += sizeof(struct section_64);␊
505␉␉␉␉␉␉␉␊
506␉␉␉␉␉␉␉␊
507␉␉␉␉␉␉␉if(strcmp("__text", sect->sectname) == 0)␊
508␉␉␉␉␉␉␉{␊
509␉␉␉␉␉␉␉␉// __TEXT,__text found, save the offset and address for when looking for the calls.␊
510␉␉␉␉␉␉␉␉textSection = sect->offset;␊
511␉␉␉␉␉␉␉␉textAddress = sect->addr;␊
512␉␉␉␉␉␉␉␉␊
513␉␉␉␉␉␉␉␉break;␊
514␉␉␉␉␉␉␉}␉␉␉␉␉␊
515␉␉␉␉␉␉}␊
516␉␉␉␉␉}␊
517␉␉␉␉␉␊
518␉␉␉␉␉break;␊
519␉␉␉␉}␉␉␉␉␊
520␉␉␉␉case LC_DYSYMTAB:␊
521␉␉␉␉␉break;␊
522␉␉␉␉␉␊
523␉␉␉␉case LC_LOAD_DYLIB:␊
524␉␉␉␉case LC_LOAD_WEAK_DYLIB ^ LC_REQ_DYLD:␊
525␉␉␉␉{␊
526␉␉␉␉␉dylibCommand = binary + binaryIndex;␊
527␉␉␉␉␉char* module = binary + binaryIndex + ((UInt32)*((UInt32*)&dylibCommand->dylib.name));␊
528␉␉␉␉␉// TODO: verify version␊
529␉␉␉␉␉// =␉dylibCommand->dylib.current_version;␊
530␉␉␉␉␉// =␉dylibCommand->dylib.compatibility_version;␊
531␉␉␉␉␉␊
532␉␉␉␉␉char *name=NULL;␊
533␉␉␉␉␉name = newStringWithFormat( "%s.dylib", module);␊
534␉␉␉␉␉if (!name) {␊
535␉␉␉␉␉␉printf("Unable to allocate module name : %s\n", module);␊
536␉␉␉␉␉␉return NULL;␊
537␉␉␉␉␉}␊
538␉␉␉␉␉if(dylib_loader)␊
539␉␉␉␉␉{␊
540␉␉␉␉␉␉EFI_STATUS statue = dylib_loader(name);␊
541␉␉␉␉␉␉␊
542␉␉␉␉␉␉if( statue != EFI_SUCCESS)␊
543␉␉␉␉␉␉{␊
544␉␉␉␉␉␉␉if (statue != EFI_ALREADY_STARTED)␊
545␉␉␉␉␉␉␉{␊
546␉␉␉␉␉␉␉␉// Unable to load dependancy␊
547␉␉␉␉␉␉␉␉free(name);␊
548␉␉␉␉␉␉␉␉return NULL;␊
549␉␉␉␉␉␉␉}␊
550␉␉␉␉␉␉␉␊
551␉␉␉␉␉␉} ␊
552␉␉␉␉␉␉␊
553␉␉␉␉␉}␊
554␉␉␉␉␉free(name);␊
555␉␉␉␉␉␊
556␉␉␉␉␉break;␊
557␉␉␉␉}␉␉␉␉␊
558␉␉␉␉case LC_ID_DYLIB:␊
559␉␉␉␉␉dylibCommand = binary + binaryIndex;␊
560␉␉␉␉␉/*moduleName =␉binary + binaryIndex + ((UInt32)*((UInt32*)&dylibCommand->dylib.name));␊
561␉␉␉␉␉ moduleVersion =␉dylibCommand->dylib.current_version;␊
562␉␉␉␉␉ moduleCompat =␉dylibCommand->dylib.compatibility_version;␊
563␉␉␉␉␉ */␊
564␉␉␉␉␉break;␊
565␉␉␉␉␉␊
566␉␉␉␉case LC_DYLD_INFO:␊
567␉␉␉␉␉// Bind and rebase info is stored here␊
568␉␉␉␉␉dyldInfoCommand = binary + binaryIndex;␊
569␉␉␉␉␉break;␊
570␉␉␉␉␉␊
571␉␉␉␉case LC_UUID:␊
572␉␉␉␉␉break;␊
573␉␉␉␉␉␊
574␉␉␉␉case LC_UNIXTHREAD:␊
575␉␉␉␉␉break;␊
576␉␉␉␉␉␊
577␉␉␉␉default:␊
578␉␉␉␉␉DBG("Unhandled loadcommand 0x%X\n", loadCommand->cmd & 0x7FFFFFFF);␊
579␉␉␉␉␉break;␊
580␉␉␉␉␉␊
581␉␉␉}␊
582␉␉␉␊
583␉␉␉binaryIndex += cmdSize;␊
584␉␉}␊
585␉␉//if(!moduleName) return NULL;␊
586␉}␉␉␊
587␉␊
588␉// bind_macho uses the symbols.␊
589␉module_start = (void*)handle_symtable((UInt32)binary, symtabCommand, symbol_handler, is64);␊
590␉␊
591␉// Rebase the module before binding it.␊
592␉if(dyldInfoCommand && dyldInfoCommand->rebase_off)␊
593␉{␊
594␉␉rebase_macho(binary, (char*)dyldInfoCommand->rebase_off, dyldInfoCommand->rebase_size);␊
595␉}␊
596␉␊
597␉if(dyldInfoCommand && dyldInfoCommand->bind_off)␊
598␉{␊
599␉␉bind_macho(binary, (char*)dyldInfoCommand->bind_off, dyldInfoCommand->bind_size);␊
600␉}␊
601␉␊
602␉if(dyldInfoCommand && dyldInfoCommand->weak_bind_off)␊
603␉{␊
604␉␉// NOTE: this currently should never happen.␊
605␉␉bind_macho(binary, (char*)dyldInfoCommand->weak_bind_off, dyldInfoCommand->weak_bind_size);␊
606␉}␊
607␉␊
608␉if(dyldInfoCommand && dyldInfoCommand->lazy_bind_off)␊
609␉{␊
610␉␉// NOTE: we are binding the lazy pointers as a module is laoded,␊
611␉␉// This should be changed to bind when a symbol is referened at runtime instead.␊
612␉␉bind_macho(binary, (char*)dyldInfoCommand->lazy_bind_off, dyldInfoCommand->lazy_bind_size);␊
613␉}␊
614␉␊
615␉return module_start;␊
616␉␊
617}␊
618␊
619// Based on code from dylibinfo.cpp and ImageLoaderMachOCompressed.cpp␊
620void rebase_macho(void* base, char* rebase_stream, UInt32 size)␊
621{␊
622␉rebase_stream += (UInt32)base;␊
623␉␊
624␉UInt8 immediate = 0;␊
625␉UInt8 opcode = 0;␊
626␉UInt8 type = 0;␊
627␉␊
628␉UInt32 segmentAddress = 0;␊
629␉␊
630␉␊
631␉␊
632␉UInt32 tmp = 0;␊
633␉UInt32 tmp2 = 0;␊
634␉UInt8 bits = 0;␊
635␉UInt32 index = 0;␊
636␉␊
637␉int done = 0;␊
638␉unsigned int i = 0;␊
639␉␊
640␉while(/*!done &&*/ i < size)␊
641␉{␊
642␉␉immediate = rebase_stream[i] & REBASE_IMMEDIATE_MASK;␊
643␉␉opcode = rebase_stream[i] & REBASE_OPCODE_MASK;␊
644␉␉␊
645␉␉␊
646␉␉switch(opcode)␊
647␉␉{␊
648␉␉␉case REBASE_OPCODE_DONE:␊
649␉␉␉␉// Rebase complete.␊
650␉␉␉␉done = 1;␊
651␉␉␉␉break;␊
652␉␉␉␉␊
653␉␉␉␉␊
654␉␉␉case REBASE_OPCODE_SET_TYPE_IMM:␊
655␉␉␉␉// Set rebase type (pointer, absolute32, pcrel32)␊
656␉␉␉␉//DBG("Rebase type = 0x%X\n", immediate);␊
657␉␉␉␉type = immediate;␊
658␉␉␉␉break;␊
659␉␉␉␉␊
660␉␉␉␉␊
661␉␉␉case REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:␊
662␉␉␉{␊
663␉␉␉␉// Locate address to begin rebasing␊
664␉␉␉␉segmentAddress = 0;␊
665␉␉␉␉␊
666␉␉␉␉struct segment_command* segCommand = NULL; // NOTE: 32bit only␊
667␉␉␉␉␊
668␉␉␉␉{␊
669␉␉␉␉␉unsigned int binIndex = 0;␊
670␉␉␉␉␉index = 0;␊
671␉␉␉␉␉do␊
672␉␉␉␉␉{␊
673␉␉␉␉␉␉segCommand = base + sizeof(struct mach_header) + binIndex;␊
674␉␉␉␉␉␉␊
675␉␉␉␉␉␉␊
676␉␉␉␉␉␉binIndex += segCommand->cmdsize;␊
677␉␉␉␉␉␉index++;␊
678␉␉␉␉␉}␊
679␉␉␉␉␉while(index <= immediate);␊
680␉␉␉␉}␉␉␉␉␊
681␉␉␉␉␊
682␉␉␉␉segmentAddress = segCommand->fileoff;␊
683␉␉␉␉␊
684␉␉␉␉tmp = 0;␊
685␉␉␉␉bits = 0;␊
686␉␉␉␉do␊
687␉␉␉␉{␊
688␉␉␉␉␉tmp |= (rebase_stream[++i] & 0x7f) << bits;␊
689␉␉␉␉␉bits += 7;␊
690␉␉␉␉}␊
691␉␉␉␉while(rebase_stream[i] & 0x80);␊
692␉␉␉␉␊
693␉␉␉␉segmentAddress += tmp;␊
694␉␉␉␉break;␊
695␉␉␉}␉␉␉␉␊
696␉␉␉case REBASE_OPCODE_ADD_ADDR_ULEB:␊
697␉␉␉␉// Add value to rebase address␊
698␉␉␉␉tmp = 0;␊
699␉␉␉␉bits = 0;␊
700␉␉␉␉do␊
701␉␉␉␉{␊
702␉␉␉␉␉tmp <<= bits;␊
703␉␉␉␉␉tmp |= rebase_stream[++i] & 0x7f;␊
704␉␉␉␉␉bits += 7;␊
705␉␉␉␉}␊
706␉␉␉␉while(rebase_stream[i] & 0x80);␊
707␉␉␉␉␊
708␉␉␉␉segmentAddress +=␉tmp; ␊
709␉␉␉␉break;␊
710␉␉␉␉␊
711␉␉␉case REBASE_OPCODE_ADD_ADDR_IMM_SCALED:␊
712␉␉␉␉segmentAddress += immediate * sizeof(void*);␊
713␉␉␉␉break;␊
714␉␉␉␉␊
715␉␉␉␉␊
716␉␉␉case REBASE_OPCODE_DO_REBASE_IMM_TIMES:␊
717␉␉␉␉index = 0;␊
718␉␉␉␉for (index = 0; index < immediate; ++index)␊
719␉␉␉␉{␊
720␉␉␉␉␉rebase_location(base + segmentAddress, (char*)base, type);␊
721␉␉␉␉␉segmentAddress += sizeof(void*);␊
722␉␉␉␉}␊
723␉␉␉␉break;␊
724␉␉␉␉␊
725␉␉␉␉␊
726␉␉␉case REBASE_OPCODE_DO_REBASE_ULEB_TIMES:␊
727␉␉␉␉tmp = 0;␊
728␉␉␉␉bits = 0;␊
729␉␉␉␉do␊
730␉␉␉␉{␊
731␉␉␉␉␉tmp |= (rebase_stream[++i] & 0x7f) << bits;␊
732␉␉␉␉␉bits += 7;␊
733␉␉␉␉}␊
734␉␉␉␉while(rebase_stream[i] & 0x80);␊
735␉␉␉␉␊
736␉␉␉␉index = 0;␊
737␉␉␉␉for (index = 0; index < tmp; ++index)␊
738␉␉␉␉{␊
739␉␉␉␉␉//DBG("\tRebasing 0x%X\n", segmentAddress);␊
740␉␉␉␉␉rebase_location(base + segmentAddress, (char*)base, type);␉␉␉␉␉␊
741␉␉␉␉␉segmentAddress += sizeof(void*);␊
742␉␉␉␉}␊
743␉␉␉␉break;␊
744␉␉␉␉␊
745␉␉␉case REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:␊
746␉␉␉␉tmp = 0;␊
747␉␉␉␉bits = 0;␊
748␉␉␉␉do␊
749␉␉␉␉{␊
750␉␉␉␉␉tmp |= (rebase_stream[++i] & 0x7f) << bits;␊
751␉␉␉␉␉bits += 7;␊
752␉␉␉␉}␊
753␉␉␉␉while(rebase_stream[i] & 0x80);␊
754␉␉␉␉␊
755␉␉␉␉rebase_location(base + segmentAddress, (char*)base, type);␊
756␉␉␉␉␊
757␉␉␉␉segmentAddress += tmp + sizeof(void*);␊
758␉␉␉␉break;␊
759␉␉␉␉␊
760␉␉␉case REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:␊
761␉␉␉␉tmp = 0;␊
762␉␉␉␉bits = 0;␊
763␉␉␉␉do␊
764␉␉␉␉{␊
765␉␉␉␉␉tmp |= (rebase_stream[++i] & 0x7f) << bits;␊
766␉␉␉␉␉bits += 7;␊
767␉␉␉␉}␊
768␉␉␉␉while(rebase_stream[i] & 0x80);␊
769␉␉␉␉␊
770␉␉␉␉␊
771␉␉␉␉tmp2 = 0;␊
772␉␉␉␉bits = 0;␊
773␉␉␉␉do␊
774␉␉␉␉{␊
775␉␉␉␉␉tmp2 |= (rebase_stream[++i] & 0x7f) << bits;␊
776␉␉␉␉␉bits += 7;␊
777␉␉␉␉}␊
778␉␉␉␉while(rebase_stream[i] & 0x80);␊
779␉␉␉␉␊
780␉␉␉␉index = 0;␊
781␉␉␉␉for (index = 0; index < tmp; ++index)␊
782␉␉␉␉{␊
783␉␉␉␉␉␊
784␉␉␉␉␉rebase_location(base + segmentAddress, (char*)base, type);␊
785␉␉␉␉␉␊
786␉␉␉␉␉segmentAddress += tmp2 + sizeof(void*);␊
787␉␉␉␉}␊
788␉␉␉␉break;␊
789␉␉␉default:␊
790␉␉␉␉break;␊
791␉␉}␊
792␉␉i++;␊
793␉}␊
794}␊
795␊
796// Based on code from dylibinfo.cpp and ImageLoaderMachOCompressed.cpp␊
797// NOTE: this uses 32bit values, and not 64bit values. ␊
798// There is apossibility that this could cause issues,␊
799// however the macho file is 32 bit, so it shouldn't matter too much␊
800void bind_macho(void* base, char* bind_stream, UInt32 size)␊
801{␉␊
802␉bind_stream += (UInt32)base;␊
803␉␊
804␉UInt8 immediate = 0;␊
805␉UInt8 opcode = 0;␊
806␉UInt8 type = 0;␊
807␉␊
808␉UInt32 segmentAddress = 0;␊
809␉␊
810␉UInt32 address = 0;␊
811␉␊
812␉SInt32 addend = 0;␉␉␉// TODO: handle this␊
813␉SInt32 libraryOrdinal = 0;␊
814␉␊
815␉const char* symbolName = NULL;␊
816␉UInt8 symboFlags = 0;␊
817␉UInt32 symbolAddr = 0xFFFFFFFF;␊
818␉␊
819␉// Temperary variables␊
820␉UInt8 bits = 0;␊
821␉UInt32 tmp = 0;␊
822␉UInt32 tmp2 = 0;␊
823␉␊
824␉UInt32 index = 0;␊
825␉int done = 0;␊
826␉unsigned int i = 0;␊
827␉␊
828␉while(/*!done &&*/ i < size)␊
829␉{␊
830␉␉immediate = bind_stream[i] & BIND_IMMEDIATE_MASK;␊
831␉␉opcode = bind_stream[i] & BIND_OPCODE_MASK;␊
832␉␉␊
833␉␉␊
834␉␉switch(opcode)␊
835␉␉{␊
836␉␉␉case BIND_OPCODE_DONE:␊
837␉␉␉␉done = 1; ␊
838␉␉␉␉break;␊
839␉␉␉␉␊
840␉␉␉case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:␊
841␉␉␉␉libraryOrdinal = immediate;␊
842␉␉␉␉//DBG("BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: %d\n", libraryOrdinal);␊
843␉␉␉␉break;␊
844␉␉␉␉␊
845␉␉␉case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:␊
846␉␉␉␉libraryOrdinal = 0;␊
847␉␉␉␉bits = 0;␊
848␉␉␉␉do␊
849␉␉␉␉{␊
850␉␉␉␉␉libraryOrdinal |= (bind_stream[++i] & 0x7f) << bits;␊
851␉␉␉␉␉bits += 7;␊
852␉␉␉␉}␊
853␉␉␉␉while(bind_stream[i] & 0x80);␊
854␉␉␉␉␊
855␉␉␉␉//DBG("BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: %d\n", libraryOrdinal);␊
856␉␉␉␉␊
857␉␉␉␉break;␊
858␉␉␉␉␊
859␉␉␉case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:␊
860␉␉␉␉// NOTE: this is wrong, fortunately we don't use it␊
861␉␉␉␉libraryOrdinal = -immediate;␊
862␉␉␉␉//DBG("BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: %d\n", libraryOrdinal);␊
863␉␉␉␉␊
864␉␉␉␉break;␊
865␉␉␉␉␊
866␉␉␉case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:␊
867␉␉␉␉symboFlags = immediate;␊
868␉␉␉␉symbolName = (char*)&bind_stream[++i];␊
869␉␉␉␉i += strlen((char*)&bind_stream[i]);␊
870␉␉␉␉//DBG("BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: %s, 0x%X\n", symbolName, symboFlags);␊
871␉␉␉␉␊
872␉␉␉␉symbolAddr = lookup_all_symbols(symbolName);␊
873␉␉␉␉␊
874␉␉␉␉break;␊
875␉␉␉␉␊
876␉␉␉case BIND_OPCODE_SET_TYPE_IMM:␊
877␉␉␉␉// Set bind type (pointer, absolute32, pcrel32)␊
878␉␉␉␉type = immediate;␊
879␉␉␉␉//DBG("BIND_OPCODE_SET_TYPE_IMM: %d\n", type);␊
880␉␉␉␉␊
881␉␉␉␉break;␊
882␉␉␉␉␊
883␉␉␉case BIND_OPCODE_SET_ADDEND_SLEB:␊
884␉␉␉␉addend = 0;␊
885␉␉␉␉bits = 0;␊
886␉␉␉␉do␊
887␉␉␉␉{␊
888␉␉␉␉␉addend |= (bind_stream[++i] & 0x7f) << bits;␊
889␉␉␉␉␉bits += 7;␊
890␉␉␉␉}␊
891␉␉␉␉while(bind_stream[i] & 0x80);␊
892␉␉␉␉␊
893␉␉␉␉if(!(bind_stream[i-1] & 0x40)) addend *= -1;␊
894␉␉␉␉␊
895␉␉␉␉//DBG("BIND_OPCODE_SET_ADDEND_SLEB: %d\n", addend);␊
896␉␉␉␉break;␊
897␉␉␉␉␊
898␉␉␉case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:␊
899␉␉␉{␊
900␉␉␉␉segmentAddress = 0;␊
901␉␉␉␉␊
902␉␉␉␉// Locate address␊
903␉␉␉␉struct segment_command* segCommand = NULL;␉// NOTE: 32bit only␊
904␉␉␉␉␊
905␉␉␉␉{␊
906␉␉␉␉␉unsigned int binIndex = 0;␊
907␉␉␉␉␉index = 0;␊
908␉␉␉␉␉do␊
909␉␉␉␉␉{␊
910␉␉␉␉␉␉segCommand = base + sizeof(struct mach_header) + binIndex;␊
911␉␉␉␉␉␉binIndex += segCommand->cmdsize;␊
912␉␉␉␉␉␉index++;␊
913␉␉␉␉␉}while(index <= immediate);␊
914␉␉␉␉}␊
915␉␉␉␉␊
916␉␉␉␉␊
917␉␉␉␉segmentAddress = segCommand->fileoff;␊
918␉␉␉␉␊
919␉␉␉␉// Read in offset␊
920␉␉␉␉tmp = 0;␊
921␉␉␉␉bits = 0;␊
922␉␉␉␉do␊
923␉␉␉␉{␊
924␉␉␉␉␉tmp |= (bind_stream[++i] & 0x7f) << bits;␊
925␉␉␉␉␉bits += 7;␊
926␉␉␉␉}while(bind_stream[i] & 0x80);␊
927␉␉␉␉␊
928␉␉␉␉segmentAddress += tmp;␊
929␉␉␉␉␊
930␉␉␉␉//DBG("BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: 0x%X\n", segmentAddress);␊
931␉␉␉␉break;␊
932␉␉␉}␉␉␉␉␊
933␉␉␉case BIND_OPCODE_ADD_ADDR_ULEB:␊
934␉␉␉␉// Read in offset␊
935␉␉␉␉tmp = 0;␊
936␉␉␉␉bits = 0;␊
937␉␉␉␉do␊
938␉␉␉␉{␊
939␉␉␉␉␉tmp |= (bind_stream[++i] & 0x7f) << bits;␊
940␉␉␉␉␉bits += 7;␊
941␉␉␉␉}␊
942␉␉␉␉while(bind_stream[i] & 0x80);␊
943␉␉␉␉␊
944␉␉␉␉segmentAddress += tmp;␊
945␉␉␉␉//DBG("BIND_OPCODE_ADD_ADDR_ULEB: 0x%X\n", segmentAddress);␊
946␉␉␉␉break;␊
947␉␉␉␉␊
948␉␉␉case BIND_OPCODE_DO_BIND:␊
949␉␉␉␉//DBG("BIND_OPCODE_DO_BIND\n");␊
950␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
951␉␉␉␉{␊
952␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
953␉␉␉␉␉␊
954␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, BIND_TYPE_POINTER);␊
955␉␉␉␉}␊
956␉␉␉␉else if(strcmp(symbolName, SYMBOL_DYLD_STUB_BINDER) != 0)␊
957␉␉␉␉{␊
958␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
959 getc();␊
960␉␉␉␉}␊
961␉␉␉␉␊
962␉␉␉␉segmentAddress += sizeof(void*);␊
963␉␉␉␉break;␊
964␉␉␉␉␊
965␉␉␉case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:␊
966␉␉␉␉//DBG("BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB\n");␊
967␉␉␉␉␊
968␉␉␉␉␊
969␉␉␉␉// Read in offset␊
970␉␉␉␉tmp = 0;␊
971␉␉␉␉bits = 0;␊
972␉␉␉␉do␊
973␉␉␉␉{␊
974␉␉␉␉␉tmp |= (bind_stream[++i] & 0x7f) << bits;␊
975␉␉␉␉␉bits += 7;␊
976␉␉␉␉}␊
977␉␉␉␉while(bind_stream[i] & 0x80);␊
978␉␉␉␉␊
979␉␉␉␉␊
980␉␉␉␉␊
981␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
982␉␉␉␉{␊
983␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
984␉␉␉␉␉␊
985␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, BIND_TYPE_POINTER);␊
986␉␉␉␉}␊
987␉␉␉␉else if(strcmp(symbolName, SYMBOL_DYLD_STUB_BINDER) != 0)␊
988␉␉␉␉{␊
989␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
990␉␉␉␉}␊
991␉␉␉␉segmentAddress += tmp + sizeof(void*);␊
992␉␉␉␉␊
993␉␉␉␉␊
994␉␉␉␉break;␊
995␉␉␉␉␊
996␉␉␉case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:␊
997␉␉␉␉//DBG("BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED\n");␊
998␉␉␉␉␊
999␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
1000␉␉␉␉{␊
1001␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
1002␉␉␉␉␉␊
1003␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, BIND_TYPE_POINTER);␊
1004␉␉␉␉}␊
1005␉␉␉␉else if(strcmp(symbolName, SYMBOL_DYLD_STUB_BINDER) != 0)␊
1006␉␉␉␉{␊
1007␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
1008␉␉␉␉}␊
1009␉␉␉␉segmentAddress += (immediate * sizeof(void*)) + sizeof(void*);␊
1010␉␉␉␉␊
1011␉␉␉␉␊
1012␉␉␉␉break;␊
1013␉␉␉␉␊
1014␉␉␉case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:␊
1015␉␉␉␉␊
1016␉␉␉␉tmp = 0;␊
1017␉␉␉␉bits = 0;␊
1018␉␉␉␉do␊
1019␉␉␉␉{␊
1020␉␉␉␉␉tmp |= (bind_stream[++i] & 0x7f) << bits;␊
1021␉␉␉␉␉bits += 7;␊
1022␉␉␉␉}␊
1023␉␉␉␉while(bind_stream[i] & 0x80);␊
1024␉␉␉␉␊
1025␉␉␉␉␊
1026␉␉␉␉tmp2 = 0;␊
1027␉␉␉␉bits = 0;␊
1028␉␉␉␉do␊
1029␉␉␉␉{␊
1030␉␉␉␉␉tmp2 |= (bind_stream[++i] & 0x7f) << bits;␊
1031␉␉␉␉␉bits += 7;␊
1032␉␉␉␉}␊
1033␉␉␉␉while(bind_stream[i] & 0x80);␊
1034␉␉␉␉␊
1035␉␉␉␉␊
1036␉␉␉␉//DBG("BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB 0x%X 0x%X\n", tmp, tmp2);␊
1037␉␉␉␉␊
1038␉␉␉␉␊
1039␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
1040␉␉␉␉{␊
1041␉␉␉␉␉for(index = 0; index < tmp; index++)␊
1042␉␉␉␉␉{␊
1043␉␉␉␉␉␉␊
1044␉␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
1045␉␉␉␉␉␉␊
1046␉␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, BIND_TYPE_POINTER);␊
1047␉␉␉␉␉␉␊
1048␉␉␉␉␉␉segmentAddress += tmp2 + sizeof(void*);␊
1049␉␉␉␉␉}␊
1050␉␉␉␉}␊
1051␉␉␉␉else if(strcmp(symbolName, SYMBOL_DYLD_STUB_BINDER) != 0)␊
1052␉␉␉␉{␊
1053␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
1054␉␉␉␉}␊
1055␉␉␉␉␊
1056␉␉␉␉␊
1057␉␉␉␉break;␊
1058␉␉␉default:␊
1059␉␉␉␉break;␊
1060␉␉␉␉␊
1061␉␉}␊
1062␉␉i++;␊
1063␉}␊
1064}␊
1065␊
1066inline void rebase_location(UInt32* location, char* base, int type)␊
1067{␉␊
1068␉switch(type)␊
1069␉{␊
1070␉␉case REBASE_TYPE_POINTER:␊
1071␉␉case REBASE_TYPE_TEXT_ABSOLUTE32:␊
1072␉␉␉*location += (UInt32)base;␊
1073␉␉␉break;␊
1074␉␉␉␊
1075␉␉default:␊
1076␉␉␉break;␊
1077␉}␊
1078}␊
1079␊
1080inline void bind_location(UInt32* location, char* value, UInt32 addend, int type)␊
1081{␉␊
1082␉// do actual update␊
1083␉char* newValue = value + addend;␊
1084␉␊
1085␉switch (type) {␊
1086␉␉case BIND_TYPE_POINTER:␊
1087␉␉case BIND_TYPE_TEXT_ABSOLUTE32:␊
1088␉␉␉break;␊
1089␉␉␉␊
1090␉␉case BIND_TYPE_TEXT_PCREL32:␊
1091␉␉␉newValue -= ((UInt32)location + 4);␊
1092␉␉␉␊
1093␉␉␉break;␊
1094␉␉default:␊
1095␉␉␉return;␊
1096␉}␊
1097␉*location = (UInt32)newValue;␊
1098␉␊
1099␉␊
1100}␊
1101␊
1102/*␊
1103 * add_symbol␊
1104 * This function adds a symbol from a module to the list of known symbols ␊
1105 * possibly change to a pointer and add this to the Symbol module so that it can␊
1106 * adjust it's internal symbol list (sort) to optimize locating new symbols␊
1107 * NOTE: returns the address if the symbol is "start", else returns 0xFFFFFFFF␊
1108 */␊
1109long long add_symbol(char* symbol, long long addr, char is64)␊
1110{␊
1111␉if(is64) return 0xFFFFFFFF; // Fixme␊
1112␉␊
1113␉// This only can handle 32bit symbols ␊
1114␉symbolList_t* new_entry= malloc(sizeof(symbolList_t));␊
1115␉DBG("Adding symbol %s at 0x%X\n", symbol, addr);␊
1116␉if (new_entry)␊
1117␉{␉␊
1118␉␉new_entry->next = moduleSymbols;␊
1119␉␉␊
1120␉␉moduleSymbols = new_entry;␊
1121␉␉␊
1122␉␉new_entry->addr = (UInt32)addr;␊
1123␉␉new_entry->symbol = symbol;␊
1124␉␉return addr;␊
1125␉}␉␊
1126␉␊
1127␉return 0xFFFFFFFF;␊
1128␉␊
1129}␊
1130␊
1131/*␊
1132 * print out the information about the loaded module␊
1133 */␊
1134VOID module_loaded(const char* name/*, UInt32 version, UInt32 compat*/)␊
1135{␊
1136␉moduleList_t* new_entry = malloc(sizeof(moduleList_t));␊
1137␉if (new_entry)␊
1138␉{␉␊
1139␉␉new_entry->next = loadedModules;␊
1140␉␉␊
1141␉␉loadedModules = new_entry;␊
1142␉␉␊
1143␉␉new_entry->module = (char*)name;␊
1144␉␉//␉new_entry->version = version;␊
1145␉␉//␉new_entry->compat = compat;␊
1146␉}␊
1147}␊
1148␊
1149EFI_STATUS is_module_loaded(const char* name)␊
1150{␊
1151␉moduleList_t* entry = loadedModules;␊
1152␉while(entry)␊
1153␉{␊
1154␉␉DBG("Comparing %s with %s\n", name, entry->module);␊
1155␉␉char *fullname = newStringWithFormat("%s.dylib",name);␊
1156␉␉if(fullname && ((strcmp(entry->module, name) == 0) || (strcmp(entry->module, fullname) == 0)))␊
1157␉␉{␊
1158␉␉␉free(fullname);␊
1159␉␉␉DBG("Located module %s\n", name);␊
1160␉␉␉return EFI_SUCCESS;␊
1161␉␉}␊
1162␉␉else␊
1163␉␉{␊
1164␉␉␉entry = entry->next;␊
1165␉␉}␊
1166␉␉␊
1167␉}␊
1168␉DBG("Module %s not found\n", name);␊
1169␉␊
1170␉return EFI_NOT_FOUND;␊
1171}␊
1172␊
1173// Look for symbols using the Smbols moduel function.␊
1174// If non are found, look through the list of module symbols␊
1175unsigned int lookup_all_symbols(const char* name)␊
1176{␊
1177␉{␊
1178␉␉unsigned int addr = 0xFFFFFFFF;␊
1179␉␉if(lookup_symbol && (UInt32)lookup_symbol != 0xFFFFFFFF)␊
1180␉␉{␊
1181␉␉␉addr = lookup_symbol(name, &strcmp);␊
1182␉␉␉if(addr != 0xFFFFFFFF)␊
1183␉␉␉{␊
1184␉␉␉␉DBG("Internal symbol %s located at 0x%X\n", name, addr);␊
1185␉␉␉␉return addr;␊
1186␉␉␉}␊
1187␉␉}␊
1188␉}␉␊
1189␉␊
1190␉{␊
1191␉␉symbolList_t* entry = moduleSymbols;␊
1192␉␉while(entry)␊
1193␉␉{␊
1194␉␉␉if(strcmp(entry->symbol, name) == 0)␊
1195␉␉␉{␊
1196␉␉␉␉DBG("External symbol %s located at 0x%X\n", name, entry->addr);␊
1197␉␉␉␉return entry->addr;␊
1198␉␉␉}␊
1199␉␉␉else␊
1200␉␉␉{␊
1201␉␉␉␉entry = entry->next;␊
1202␉␉␉}␊
1203␉␉␉␊
1204␉␉}␊
1205␉}␊
1206␉␊
1207#if DEBUG_MODULES␊
1208␉if(strcmp(name, SYMBOL_DYLD_STUB_BINDER) != 0)␊
1209␉{␊
1210␉␉verbose("Unable to locate symbol %s\n", name);␊
1211␉␉getc();␊
1212␉}␊
1213#endif␊
1214␉return 0xFFFFFFFF;␊
1215}␊
1216␊
1217␊
1218/*␊
1219 * parse the symbol table␊
1220 * Lookup any undefined symbols␊
1221 */␊
1222␊
1223unsigned int handle_symtable(UInt32 base, struct symtab_command* symtabCommand, long long(*symbol_handler)(char*, long long, char), char is64)␊
1224{␉␉␊
1225␉unsigned int module_start = 0xFFFFFFFF;␊
1226␉␊
1227␉UInt32 symbolIndex = 0;␊
1228␉char* symbolString = base + (char*)symtabCommand->stroff;␊
1229␉//char* symbolTable = base + symtabCommand->symoff;␊
1230␉if(!is64)␊
1231␉{␊
1232␉␉struct nlist* symbolEntry = (void*)base + symtabCommand->symoff;␊
1233␉␉while(symbolIndex < symtabCommand->nsyms)␊
1234␉␉{␉␉␉␉␉␉␊
1235␉␉␉if(symbolEntry->n_value)␊
1236␉␉␉{␉␉␉␉␊
1237␉␉␉␉if(strstr(symbolString + symbolEntry->n_un.n_strx, "module_start") || (strcmp(symbolString + symbolEntry->n_un.n_strx, "start") == 0))␊
1238␉␉␉␉{␊
1239␉␉␉␉␉module_start = base + symbolEntry->n_value;␊
1240␉␉␉␉␉DBG("n_value %x module_start %x\n", (unsigned)symbolEntry->n_value, (unsigned)module_start);␊
1241␉␉␉␉}␊
1242␉␉␉␉else␊
1243␉␉␉␉{␊
1244␉␉␉␉␉symbol_handler(symbolString + symbolEntry->n_un.n_strx, (long long)base + symbolEntry->n_value, is64);␊
1245␉␉␉␉}␊
1246#if DEBUG_MODULES␊
1247␉␉␉␉bool isTexT = (((unsigned)symbolEntry->n_value > (unsigned)vmaddr) && ((unsigned)(vmaddr + vmsize) > (unsigned)symbolEntry->n_value ));␊
1248␉␉␉␉printf("%s %s\n", isTexT ? "__TEXT :" : "__DATA(OR ANY) :", symbolString + symbolEntry->n_un.n_strx);␊
1249#if DEBUG_MODULES==2␉␊
1250␉␉␉␉␊
1251␉␉␉␉if(strcmp(symbolString + symbolEntry->n_un.n_strx, "_BootHelp_txt") == 0)␊
1252␉␉␉␉{␊
1253␉␉␉␉␉long long addr = (long long)base + symbolEntry->n_value;␊
1254␉␉␉␉␉unsigned char *BootHelp = NULL;␊
1255␉␉␉␉␉BootHelp = (unsigned char*)(UInt32)addr;␉␉␉␉␉␊
1256␉␉␉␉␉printf("method 1: __DATA : BootHelp_txt[0] %x\n", BootHelp[0]);␊
1257␉␉␉␉␉␊
1258␉␉␉␉␉long long addr2 = symbolEntry->n_value;␊
1259␉␉␉␉␉unsigned char *BootHelp2 = NULL;␊
1260␉␉␉␉␉BootHelp2 = (unsigned char*)(UInt32)addr2;␉␉␉␉␉␊
1261␉␉␉␉␉printf("method 2: __DATA : BootHelp_txt[0] %x\n", BootHelp2[0]);␊
1262␉␉␉␉}␊
1263#endif␊
1264#endif␊
1265␉␉␉␉␊
1266␉␉␉}␊
1267␉␉␉␊
1268␉␉␉symbolEntry++;␊
1269␉␉␉symbolIndex++;␉// TODO remove␊
1270␉␉}␊
1271␉}␊
1272␉else␊
1273␉{␊
1274␉␉struct nlist_64* symbolEntry = (void*)base + symtabCommand->symoff;␊
1275␉␉// NOTE First entry is *not* correct, but we can ignore it (i'm getting radar:// right now)␉␊
1276␉␉while(symbolIndex < symtabCommand->nsyms)␊
1277␉␉{␉␊
1278␉␉␉␊
1279␉␉␉if(strstr(symbolString + symbolEntry->n_un.n_strx, "module_start") || (strcmp(symbolString + symbolEntry->n_un.n_strx, "start") == 0))␊
1280␉␉␉{␊
1281␉␉␉␉module_start = base + symbolEntry->n_value;␊
1282␉␉␉}␊
1283␉␉␉else␊
1284␉␉␉{␊
1285␉␉␉␉symbol_handler(symbolString + symbolEntry->n_un.n_strx, (long long)base + symbolEntry->n_value, is64);␊
1286␉␉␉}␊
1287␉␉␉␊
1288␉␉␉symbolEntry++;␊
1289␉␉␉symbolIndex++;␉// TODO remove␊
1290␉␉}␊
1291␉}␊
1292␉␊
1293␉return module_start;␊
1294␉␊
1295}␊
1296␊
1297␊
1298/*␊
1299 * Locate the symbol for an already loaded function and modify the beginning of␊
1300 * the function to jump directly to the new one␊
1301 * example: replace_function("_HelloWorld_start", &replacement_start);␊
1302 */␊
1303EFI_STATUS replace_function(const char* symbol, void* newAddress)␊
1304{␉␉ ␊
1305␉// TODO: look into using the next four bytes of the function instead␊
1306␉// Most functions should support this, as they probably will be at ␊
1307␉// least 10 bytes long, but you never know, this is sligtly safer as␊
1308␉// function can be as small as 6 bytes.␊
1309␉UInt32 addr = lookup_all_symbols(symbol);␊
1310␉␊
1311␉char* binary = (char*)addr;␊
1312␉if(addr != 0xFFFFFFFF)␊
1313␉{␊
1314␉␉UInt32* jumpPointer = malloc(sizeof(UInt32*));␊
1315␉␉if (!jumpPointer) {␊
1316␉␉␉return EFI_OUT_OF_RESOURCES;␊
1317␉␉}␊
1318␉␉␊
1319␉␉*binary++ = 0xFF;␉// Jump␊
1320␉␉*binary++ = 0x25;␉// Long Jump␊
1321␉␉*((UInt32*)binary) = (UInt32)jumpPointer;␊
1322␉␉␊
1323␉␉*jumpPointer = (UInt32)newAddress;␊
1324␉␉␊
1325␉␉return EFI_SUCCESS;␊
1326␉}␊
1327␉␊
1328␉return EFI_NOT_FOUND;␊
1329␉␊
1330}␊
1331

Archive Download this file

Revision: 1804