Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 680