Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 636