Chameleon

Chameleon Svn Source Tree

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

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

Archive Download this file

Revision: 491