Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 583