Chameleon

Chameleon Svn Source Tree

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

Source at commit 742 created 13 years 2 months ago.
By meklort, Module system cleanup. Potential bugfix: If a module symbol is missing, bind symbol with void function w/o notifying user.
1/*␊
2 * Copyright 2010 Evan Lojewski. All rights reserved.␊
3 *␊
4 */␊
5#ifndef DEBUG_MODULES␊
6#define DEBUG_MODULES 0␊
7#endif␊
8␊
9#include "boot.h"␊
10#include "bootstruct.h"␊
11#include "modules.h"␊
12␊
13␊
14#if DEBUG_MODULES␊
15#define DBG(x...)␉printf(x);␊
16#define DBGPAUSE()␉getc()␊
17#else␊
18#define DBG(x...)␊
19#define DBGPAUSE()␊
20#endif␊
21␊
22// NOTE: Global so that modules can link with this␊
23unsigned long long textAddress = 0;␊
24unsigned long long textSection = 0;␊
25␊
26void* symbols_module_start = (void*)0xFFFFFFFF;␉// TGlobal, value is populated by the makefile with actual address␊
27␊
28/** Internal symbols, however there are accessor methods **/␊
29moduleHook_t* moduleCallbacks = NULL;␊
30moduleList_t* loadedModules = NULL;␊
31symbolList_t* moduleSymbols = NULL;␊
32unsigned int (*lookup_symbol)(const char*) = NULL;␊
33␊
34␊
35/*␊
36 * Initialize the module system by loading the Symbols.dylib module.␊
37 * Once loaded, locate the _lookup_symbol function so that internal␊
38 * symbols can be resolved.␊
39 */␊
40int init_module_system()␊
41{␊
42␉int retVal = 0;␊
43␉void (*module_start)(void) = NULL;␊
44␉char* module_data = symbols_module_start + BOOT2_ADDR;␊
45 ␊
46␉// Intialize module system␊
47␉if(symbols_module_start != (void*)0xFFFFFFFF)␊
48␉{␊
49␉␉// Module system was compiled in (Symbols.dylib addr known)␊
50␉␉module_start = parse_mach(module_data, &load_module, &add_symbol);␊
51␉␉␊
52␉␉if(module_start && module_start != (void*)0xFFFFFFFF)␊
53␉␉{␊
54␉␉␉// Notify the system that it was laoded␊
55␉␉␉module_loaded(SYMBOLS_MODULE /*moduleName, moduleVersion, moduleCompat*/);␊
56␉␉␉␊
57␉␉␉(*module_start)();␉// Start the module. This will point to load_all_modules due to the way the dylib was constructed.␊
58␉␉␉execute_hook("ModulesLoaded", NULL, NULL, NULL, NULL);␊
59␉␉␉DBG("Module %s Loaded.\n", SYMBOLS_MODULE);␊
60␉␉␉retVal = 1;␊
61␊
62␉␉}␊
63␉␉else␊
64␉␉{␊
65␉␉␉// The module does not have a valid start function␊
66␉␉␉printf("Unable to start %s\n", SYMBOLS_MODULE); getc();␊
67␉␉}␉␉␊
68␉}␊
69␉return retVal;␊
70}␊
71␊
72␊
73/*␊
74 * Load all modules in the /Extra/modules/ directory␊
75 * Module depencdies will be loaded first␊
76 * Modules will only be loaded once. When loaded a module must␊
77 * setup apropriete function calls and hooks as required.␊
78 * NOTE: To ensure a module loads after another you may ␊
79 * link one module with the other. For dyld to allow this, you must␊
80 * reference at least one symbol within the module.␊
81 */␊
82void load_all_modules()␊
83{␊
84␉char* name;␊
85␉long flags;␊
86␉long time;␊
87␉struct dirstuff* moduleDir = opendir("/Extra/modules/");␊
88␉while(readdir(moduleDir, (const char**)&name, &flags, &time) >= 0)␊
89␉{␊
90␉␉if(strcmp(&name[strlen(name) - sizeof("dylib")], ".dylib") == 0)␊
91␉␉{␊
92␉␉␉char* tmp = malloc(strlen(name) + 1);␊
93␉␉␉strcpy(tmp, name);␊
94␉␉␉␊
95␉␉␉if(!load_module(tmp))␊
96␉␉␉{␊
97␉␉␉␉// failed to load␊
98␉␉␉␉// free(tmp);␊
99␉␉␉}␊
100␉␉}␊
101␉␉else ␊
102␉␉{␊
103␉␉␉DBG("Ignoring %s\n", name);␊
104␉␉}␊
105␊
106␉}␊
107}␊
108␊
109␊
110/*␊
111 * Load a module file in /Extra/modules/␊
112 */␊
113int load_module(char* module)␊
114{␊
115␉int retVal = 1;␊
116␉void (*module_start)(void) = NULL;␊
117␉char modString[128];␊
118␉int fh = -1;␊
119␊
120␉// Check to see if the module has already been loaded␊
121␉if(is_module_loaded(module))␊
122␉{␊
123␉␉return 1;␊
124␉}␊
125␉␊
126␉sprintf(modString, MODULE_PATH "%s", module);␊
127␉fh = open(modString, 0);␊
128␉if(fh < 0)␊
129␉{␊
130␉␉DBG("WARNING: Unable to locate module %s\n", modString); DBGPAUSE();␊
131␉␉return 0;␊
132␉}␊
133␉␊
134␉unsigned int moduleSize = file_size(fh);␊
135␉char* module_base = (char*) malloc(moduleSize);␊
136␉if (moduleSize && read(fh, module_base, moduleSize) == moduleSize)␊
137␉{␊
138␉␉// Module loaded into memory, parse it␊
139␉␉module_start = parse_mach(module_base, &load_module, &add_symbol);␊
140␊
141␉␉if(module_start && module_start != (void*)0xFFFFFFFF)␊
142␉␉{␊
143␉␉␉// Notify the system that it was laoded␊
144␉␉␉module_loaded(module/*moduleName, moduleVersion, moduleCompat*/);␊
145␉␉␉(*module_start)();␉// Start the module␊
146␉␉␉DBG("Module %s Loaded.\n", module); DBGPAUSE();␊
147␉␉}␊
148#if DEBUG_MODULES␊
149␉␉else // The module does not have a valid start function. This may be a library.␊
150␉␉{␊
151␉␉␉printf("WARNING: Unable to start %s\n", module);␊
152␉␉␉getc();␊
153␉␉}␊
154#else␊
155␉␉else msglog("WARNING: Unable to start %s\n", module);␊
156#endif␊
157␉}␊
158␉else␊
159␉{␊
160␉␉DBG("Unable to read in module %s\n.", module); DBGPAUSE();␊
161␉␉retVal = 0;␊
162␉}␊
163␊
164␉close(fh);␊
165␉return retVal;␊
166}␊
167␊
168/*␊
169 * add_symbol␊
170 * This function adds a symbol from a module to the list of known symbols ␊
171 * possibly change to a pointer and add this to the Symbol module so that it can␊
172 * adjust it's internal symbol list (sort) to optimize locating new symbols␊
173 * NOTE: returns the address if the symbol is "start", else returns 0xFFFFFFFF␊
174 */␊
175long long add_symbol(char* symbol, long long addr, char is64)␊
176{␊
177␉if(is64) return 0xFFFFFFFF; // Fixme␊
178␊
179␉// This only can handle 32bit symbols ␊
180␉symbolList_t* entry;␊
181␉//DBG("Adding symbol %s at 0x%X\n", symbol, addr);␊
182␉␊
183␉entry = malloc(sizeof(symbolList_t));␊
184␉entry->next = moduleSymbols;␊
185␉moduleSymbols = entry;␊
186␉␊
187␉entry->addr = (UInt32)addr;␊
188␉entry->symbol = symbol;␊
189␉␊
190␉if(strcmp(symbol, "start") == 0)␊
191␉{␊
192␉␉return addr;␊
193␉}␊
194␉else␊
195␉{␊
196␉␉return 0xFFFFFFFF; // fixme␊
197␉}␊
198}␊
199␊
200␊
201/*␊
202 * print out the information about the loaded module␊
203 */␊
204void module_loaded(const char* name/*, UInt32 version, UInt32 compat*/)␊
205{␊
206␉moduleList_t* new_entry = malloc(sizeof(moduleList_t));␊
207␉new_entry->next = loadedModules;␊
208␊
209␉loadedModules = new_entry;␊
210␉␊
211␉new_entry->name = (char*)name;␊
212//␉new_entry->version = version;␊
213//␉new_entry->compat = compat;␊
214}␊
215␊
216int is_module_loaded(const char* name)␊
217{␊
218␉// todo sorted search␊
219␉moduleList_t* entry = loadedModules;␊
220␉while(entry)␊
221␉{␊
222␉␉if(strcmp(entry->name, name) == 0)␊
223␉␉{␊
224␉␉␉DBG("Located module %s\n", name); DBGPAUSE();␊
225␉␉␉return 1;␊
226␉␉}␊
227␉␉else␊
228␉␉{␊
229␉␉␉entry = entry->next;␊
230␉␉}␊
231␊
232␉}␊
233␉␊
234␉DBG("Module %s not found\n", name); DBGPAUSE();␊
235␉return 0;␊
236}␊
237␊
238/*␊
239 *␉lookup symbols in all loaded modules. Thins inludes boot syms due to Symbols.dylib construction␊
240 *␊
241 */␊
242unsigned int lookup_all_symbols(const char* name)␊
243{␊
244␉symbolList_t* entry = moduleSymbols;␊
245␉while(entry)␊
246␉{␊
247␉␉if(strcmp(entry->symbol, name) == 0)␊
248␉␉{␊
249␉␉␉//DBG("External symbol %s located at 0x%X\n", name, entry->addr);␊
250␉␉␉return entry->addr;␊
251␉␉}␊
252␉␉else␊
253␉␉{␊
254␉␉␉entry = entry->next;␊
255␉␉}␊
256␉}␊
257␉␊
258#if DEBUG_MODULES␊
259␉verbose("Unable to locate symbol %s\n", name);␊
260␉getc();␊
261#endif␊
262␉␊
263␉if(strcmp(name, VOID_SYMBOL) == 0) return 0xFFFFFFFF;␊
264␉// In the event that a symbol does not exist␊
265␉// Return a pointer to a void function.␊
266␉else return lookup_all_symbols(VOID_SYMBOL);␉␊
267}␊
268␊
269/********************************************************************************/␊
270/*␉Macho Parser␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉*/␊
271/********************************************************************************/␊
272␊
273/*␊
274 * Parse through a macho module. The module will be rebased and binded␊
275 * as specified in the macho header. If the module is sucessfuly laoded␊
276 * the module iinit address will be returned.␊
277 * NOTE; all dependecies will be loaded before this module is started␊
278 * NOTE: If the module is unable to load ot completeion, the modules␊
279 * symbols will still be available.␊
280 */␊
281void* parse_mach(void* binary, int(*dylib_loader)(char*), long long(*symbol_handler)(char*, long long, char))␊
282{␉␊
283␉char is64 = false;␊
284␉void (*module_start)(void) = NULL;␊
285␉␊
286␉// Module info␊
287␉/*char* moduleName = NULL;␊
288␉ UInt32 moduleVersion = 0;␊
289␉ UInt32 moduleCompat = 0;␊
290␉ */␊
291␉// TODO convert all of the structs to a union␊
292␉struct load_command *loadCommand = NULL;␊
293␉struct dylib_command* dylibCommand = NULL;␊
294␉struct dyld_info_command* dyldInfoCommand = NULL;␊
295␉␊
296␉struct symtab_command* symtabCommand = NULL;␊
297␉struct segment_command *segCommand = NULL;␊
298␉struct segment_command_64 *segCommand64 = NULL;␊
299␉␊
300␉//struct dysymtab_command* dysymtabCommand = NULL;␊
301␉UInt32 binaryIndex = 0;␊
302␉UInt16 cmd = 0;␊
303␉␊
304␉textSection = 0;␊
305␉textAddress = 0;␉// reinitialize text location in case it doesn't exist;␊
306␉␊
307␉// Parse through the load commands␊
308␉if(((struct mach_header*)binary)->magic == MH_MAGIC)␊
309␉{␊
310␉␉is64 = false;␊
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 = true;␊
317␉␉binaryIndex += sizeof(struct mach_header_64);␊
318␉}␊
319␉else␊
320␉{␊
321␉␉printf("Invalid mach magic 0x%X\n", ((struct mach_header*)binary)->magic);␊
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)␊
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: // 32bit macho␊
350␉␉␉␉segCommand = binary + binaryIndex;␊
351␉␉␉␉␊
352␉␉␉␉if(strcmp("__TEXT", segCommand->segname) == 0)␊
353␉␉␉␉{␊
354␉␉␉␉␉UInt32 sectionIndex;␊
355␉␉␉␉␉␊
356␉␉␉␉␉sectionIndex = sizeof(struct segment_command);␊
357␉␉␉␉␉␊
358␉␉␉␉␉struct section *sect;␊
359␉␉␉␉␉␊
360␉␉␉␉␉while(sectionIndex < segCommand->cmdsize)␊
361␉␉␉␉␉{␊
362␉␉␉␉␉␉sect = binary + binaryIndex + sectionIndex;␊
363␉␉␉␉␉␉␊
364␉␉␉␉␉␉sectionIndex += sizeof(struct section);␊
365␉␉␉␉␉␉␊
366␉␉␉␉␉␉␊
367␉␉␉␉␉␉if(strcmp("__text", sect->sectname) == 0)␊
368␉␉␉␉␉␉{␊
369␉␉␉␉␉␉␉// __TEXT,__text found, save the offset and address for when looking for the calls.␊
370␉␉␉␉␉␉␉textSection = sect->offset;␊
371␉␉␉␉␉␉␉textAddress = sect->addr;␊
372␉␉␉␉␉␉␉break;␊
373␉␉␉␉␉␉}␉␉␉␉␉␊
374␉␉␉␉␉}␊
375␉␉␉␉}␊
376␉␉␉␉␊
377␉␉␉␉break;␊
378␉␉␉case LC_SEGMENT_64:␉// 64bit macho's␊
379␉␉␉␉segCommand64 = binary + binaryIndex;␉␉␉␉␊
380␉␉␉␉if(strcmp("__TEXT", segCommand64->segname) == 0)␊
381␉␉␉␉{␊
382␉␉␉␉␉UInt32 sectionIndex;␊
383␉␉␉␉␉␊
384␉␉␉␉␉sectionIndex = sizeof(struct segment_command_64);␊
385␉␉␉␉␉␊
386␉␉␉␉␉struct section_64 *sect;␊
387␉␉␉␉␉␊
388␉␉␉␉␉while(sectionIndex < segCommand64->cmdsize)␊
389␉␉␉␉␉{␊
390␉␉␉␉␉␉sect = binary + binaryIndex + sectionIndex;␊
391␉␉␉␉␉␉␊
392␉␉␉␉␉␉sectionIndex += sizeof(struct section_64);␊
393␉␉␉␉␉␉␊
394␉␉␉␉␉␉␊
395␉␉␉␉␉␉if(strcmp("__text", sect->sectname) == 0)␊
396␉␉␉␉␉␉{␊
397␉␉␉␉␉␉␉// __TEXT,__text found, save the offset and address for when looking for the calls.␊
398␉␉␉␉␉␉␉textSection = sect->offset;␊
399␉␉␉␉␉␉␉textAddress = sect->addr;␊
400␉␉␉␉␉␉␉␊
401␉␉␉␉␉␉␉break;␊
402␉␉␉␉␉␉}␉␉␉␉␉␊
403␉␉␉␉␉}␊
404␉␉␉␉}␉␉␉␉␊
405␉␉␉␉␊
406␉␉␉␉break;␊
407␉␉␉␉␊
408␉␉␉␉␊
409␉␉␉case LC_LOAD_DYLIB:␊
410␉␉␉case LC_LOAD_WEAK_DYLIB ^ LC_REQ_DYLD:␊
411␉␉␉␉dylibCommand = binary + binaryIndex;␊
412␉␉␉␉char* module = binary + binaryIndex + ((UInt32)*((UInt32*)&dylibCommand->dylib.name));␊
413␉␉␉␉// TODO: verify version␊
414␉␉␉␉// =␉dylibCommand->dylib.current_version;␊
415␉␉␉␉// =␉dylibCommand->dylib.compatibility_version;␊
416␉␉␉␉if(dylib_loader)␊
417␉␉␉␉{␊
418␉␉␉␉␉char* name = malloc(strlen(module) + strlen(".dylib") + 1);␊
419␉␉␉␉␉sprintf(name, "%s.dylib", module);␊
420␉␉␉␉␉␊
421␉␉␉␉␉if (!dylib_loader(name))␊
422␉␉␉␉␉{␊
423␉␉␉␉␉␉// NOTE: any symbols exported by dep will be replace with the void function␊
424␉␉␉␉␉␉free(name);␊
425␉␉␉␉␉}␊
426␉␉␉␉}␊
427␉␉␉␉␊
428␉␉␉␉break;␊
429␉␉␉␉␊
430␉␉␉case LC_ID_DYLIB:␊
431␉␉␉␉dylibCommand = binary + binaryIndex;␊
432␉␉␉␉/*moduleName =␉binary + binaryIndex + ((UInt32)*((UInt32*)&dylibCommand->dylib.name));␊
433␉␉␉␉ moduleVersion =␉dylibCommand->dylib.current_version;␊
434␉␉␉␉ moduleCompat =␉dylibCommand->dylib.compatibility_version;␊
435␉␉␉␉ */␊
436␉␉␉␉break;␊
437␉␉␉␉␊
438␉␉␉case LC_DYLD_INFO:␊
439␉␉␉//case LC_DYLD_INFO_ONLY:␉// compressed info, 10.6+ macho files, already handeled␊
440␉␉␉␉// Bind and rebase info is stored here␊
441␉␉␉␉dyldInfoCommand = binary + binaryIndex;␊
442␉␉␉␉break;␊
443␉␉␉␉␊
444␉␉␉case LC_DYSYMTAB:␊
445␉␉␉case LC_UUID:␊
446␉␉␉case LC_UNIXTHREAD:␊
447␉␉␉␉break;␊
448␉␉␉␉␊
449␉␉␉default:␊
450␉␉␉␉DBG("Unhandled loadcommand 0x%X\n", loadCommand->cmd & 0x7FFFFFFF);␊
451␉␉␉␉break;␊
452␉␉␉␉␊
453␉␉}␊
454␉␉␊
455␉␉binaryIndex += cmdSize;␊
456␉}␊
457␊
458␉// bind_macho uses the symbols, if the textAdd does not exist (Symbols.dylib, no code), addresses are static and not relative␊
459␉module_start = (void*)handle_symtable((UInt32)binary, symtabCommand, symbol_handler, is64);␊
460␉␊
461␉if(dyldInfoCommand)␊
462␉{␊
463␉␉// Rebase the module before binding it.␊
464␉␉if(dyldInfoCommand->rebase_off)␉␉rebase_macho(binary, (char*)dyldInfoCommand->rebase_off,␉dyldInfoCommand->rebase_size);␊
465␉␉// Bind all symbols. ␊
466␉␉if(dyldInfoCommand->bind_off)␉␉bind_macho(binary, (char*)dyldInfoCommand->bind_off,␉␉dyldInfoCommand->bind_size);␊
467␉␉if(dyldInfoCommand->weak_bind_off)␉bind_macho(binary, (char*)dyldInfoCommand->weak_bind_off,␉dyldInfoCommand->weak_bind_size);␊
468␉␉if(dyldInfoCommand->lazy_bind_off)␉bind_macho(binary, (char*)dyldInfoCommand->lazy_bind_off,␉dyldInfoCommand->lazy_bind_size);␊
469␉}␊
470␉␊
471␉return module_start;␊
472␉␊
473}␊
474␊
475/*␊
476 * parse the symbol table␊
477 * Lookup any undefined symbols␊
478 */␊
479␊
480unsigned int handle_symtable(UInt32 base, struct symtab_command* symtabCommand, long long(*symbol_handler)(char*, long long, char), char is64)␊
481{␊
482␉unsigned int module_start␉= 0xFFFFFFFF;␉␊
483␉UInt32 symbolIndex␉␉␉= 0;␊
484␉char* symbolString␉␉␉= base + (char*)symtabCommand->stroff;␊
485␊
486␉// TODO: verify that the _TEXT,_text segment starts at the same locaiton in the file. If not␊
487␉//␉␉␉subtract the vmaddress and add the actual file address back on. (NOTE: if compiled properly, not needed)␊
488␉if(!is64)␊
489␉{␊
490␉␉struct nlist* symbolEntry = (void*)base + symtabCommand->symoff;␊
491␉␉while(symbolIndex < symtabCommand->nsyms)␊
492␉␉{␊
493␉␉␉// If the symbol is exported by this module␊
494␉␉␉if(symbolEntry->n_value &&␊
495␉␉␉ symbol_handler(symbolString + symbolEntry->n_un.n_strx, textAddress ? (long long)base + symbolEntry->n_value : symbolEntry->n_value, is64) != 0xFFFFFFFF)␊
496␉␉␉{␊
497␉␉␉␉␊
498␉␉␉␉// Module start located. Start is an alias so don't register it␊
499␉␉␉␉module_start = textAddress ? base + symbolEntry->n_value : symbolEntry->n_value;␊
500␉␉␉}␊
501␉␉␉␊
502␉␉␉symbolEntry++;␊
503␉␉␉symbolIndex++;␉// TODO remove␊
504␉␉}␊
505␉}␊
506␉else␊
507␉{␊
508␉␉struct nlist_64* symbolEntry = (void*)base + symtabCommand->symoff;␊
509␉␉// NOTE First entry is *not* correct, but we can ignore it (i'm getting radar:// right now, verify later)␉␊
510␉␉while(symbolIndex < symtabCommand->nsyms)␊
511␉␉{␊
512␉␉␉␊
513␉␉␉␊
514␉␉␉// If the symbol is exported by this module␊
515␉␉␉if(symbolEntry->n_value &&␊
516␉␉␉ symbol_handler(symbolString + symbolEntry->n_un.n_strx, textAddress ? (long long)base + symbolEntry->n_value : symbolEntry->n_value, is64) != 0xFFFFFFFF)␊
517␉␉␉{␊
518␉␉␉␉␊
519␉␉␉␉// Module start located. Start is an alias so don't register it␊
520␉␉␉␉module_start = textAddress ? base + symbolEntry->n_value : symbolEntry->n_value;␊
521␉␉␉}␊
522␉␉␉␊
523␉␉␉symbolEntry++;␊
524␉␉␉symbolIndex++;␉// TODO remove␊
525␉␉}␊
526␉}␊
527␉return module_start;␊
528}␊
529␊
530// Based on code from dylibinfo.cpp and ImageLoaderMachOCompressed.cpp␊
531void rebase_macho(void* base, char* rebase_stream, UInt32 size)␊
532{␊
533␉rebase_stream += (UInt32)base;␊
534␉␊
535␉UInt8 immediate = 0;␊
536␉UInt8 opcode = 0;␊
537␉UInt8 type = 0;␊
538␉UInt32 segmentAddress = 0;␊
539␉␊
540␉␊
541␉UInt32 tmp = 0;␊
542␉UInt32 tmp2 = 0;␊
543␉UInt8 bits = 0;␊
544␉int index = 0;␊
545␉unsigned int i = 0;␊
546␉␊
547␉while(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, reset vars␊
557␉␉␉␉immediate = 0;␊
558␉␉␉␉opcode = 0;␊
559␉␉␉␉type = 0;␊
560␉␉␉␉segmentAddress = 0;␊
561␉␉␉default:␊
562␉␉␉␉break;␊
563␉␉␉␉␊
564␉␉␉␉␊
565␉␉␉case REBASE_OPCODE_SET_TYPE_IMM:␊
566␉␉␉␉type = immediate;␊
567␉␉␉␉break;␊
568␉␉␉␉␊
569␉␉␉␉␊
570␉␉␉case REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:␊
571␉␉␉␉// Locate address to begin rebasing␊
572␉␉␉␉segmentAddress = 0;␊
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␊
698inline void rebase_location(UInt32* location, char* base, int type)␊
699{␉␊
700␉switch(type)␊
701␉{␊
702␉␉case REBASE_TYPE_POINTER:␊
703␉␉case REBASE_TYPE_TEXT_ABSOLUTE32:␊
704␉␉␉*location += (UInt32)base;␊
705␉␉␉break;␊
706␉␉␉␊
707␉␉default:␊
708␉␉␉break;␊
709␉}␊
710}␊
711␊
712␊
713// Based on code from dylibinfo.cpp and ImageLoaderMachOCompressed.cpp␊
714// NOTE: this uses 32bit values, and not 64bit values. ␊
715// There is a possibility that this could cause issues,␊
716// however the modules are 32 bits, so it shouldn't matter too much␊
717void bind_macho(void* base, char* bind_stream, UInt32 size)␊
718{␉␊
719␉bind_stream += (UInt32)base;␊
720␉␊
721␉UInt8 immediate = 0;␊
722␉UInt8 opcode = 0;␊
723␉UInt8 type = BIND_TYPE_POINTER;␊
724␉␊
725␉UInt32 segmentAddress = 0;␊
726␉␊
727␉UInt32 address = 0;␊
728␉␊
729␉SInt32 addend = 0;␊
730␉SInt32 libraryOrdinal = 0;␊
731␉␊
732␉const char* symbolName = NULL;␊
733␉UInt8 symboFlags = 0;␊
734␉UInt32 symbolAddr = 0xFFFFFFFF;␊
735␉␊
736␉// Temperary variables␊
737␉UInt8 bits = 0;␊
738␉UInt32 tmp = 0;␊
739␉UInt32 tmp2 = 0;␊
740␉UInt32 index = 0;␊
741␉unsigned int i = 0;␊
742␉␊
743␉while(i < size)␊
744␉{␊
745␉␉immediate = bind_stream[i] & BIND_IMMEDIATE_MASK;␊
746␉␉opcode = bind_stream[i] & BIND_OPCODE_MASK;␊
747␉␉␊
748␉␉␊
749␉␉switch(opcode)␊
750␉␉{␊
751␉␉␉case BIND_OPCODE_DONE:␊
752␉␉␉␉// reset vars␊
753␉␉␉␉type = BIND_TYPE_POINTER;␊
754␉␉␉␉segmentAddress = 0;␊
755␉␉␉␉address = 0;␊
756␉␉␉␉addend = 0;␊
757␉␉␉␉libraryOrdinal = 0;␊
758␉␉␉␉symbolAddr = 0xFFFFFFFF;␊
759␉␉␉default:␊
760␉␉␉␉break;␊
761␉␉␉␉␊
762␉␉␉case BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:␊
763␉␉␉␉libraryOrdinal = immediate;␊
764␉␉␉␉break;␊
765␉␉␉␉␊
766␉␉␉case BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:␊
767␉␉␉␉libraryOrdinal = 0;␊
768␉␉␉␉bits = 0;␊
769␉␉␉␉do␊
770␉␉␉␉{␊
771␉␉␉␉␉libraryOrdinal |= (bind_stream[++i] & 0x7f) << bits;␊
772␉␉␉␉␉bits += 7;␊
773␉␉␉␉}␊
774␉␉␉␉while(bind_stream[i] & 0x80);␊
775␉␉␉␉break;␊
776␉␉␉␉␊
777␉␉␉case BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:␊
778␉␉␉␉libraryOrdinal = immediate ? (SInt8)(BIND_OPCODE_MASK | immediate) : immediate;␉␉␉␉␊
779␉␉␉␉break;␊
780␉␉␉␉␊
781␉␉␉case BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:␊
782␉␉␉␉symboFlags = immediate;␊
783␉␉␉␉symbolName = (char*)&bind_stream[++i];␊
784␉␉␉␉i += strlen((char*)&bind_stream[i]);␊
785␊
786␉␉␉␉symbolAddr = lookup_all_symbols(symbolName);␊
787␉␉␉␉break;␊
788␉␉␉␉␊
789␉␉␉case BIND_OPCODE_SET_TYPE_IMM:␊
790␉␉␉␉type = immediate;␊
791␉␉␉␉break;␊
792␉␉␉␉␊
793␉␉␉case BIND_OPCODE_SET_ADDEND_SLEB:␊
794␉␉␉␉addend = 0;␊
795␉␉␉␉bits = 0;␊
796␉␉␉␉do␊
797␉␉␉␉{␊
798␉␉␉␉␉addend |= (bind_stream[++i] & 0x7f) << bits;␊
799␉␉␉␉␉bits += 7;␊
800␉␉␉␉}␊
801␉␉␉␉while(bind_stream[i] & 0x80);␊
802␉␉␉␉␊
803␉␉␉␉if(!(bind_stream[i-1] & 0x40)) addend *= -1;␊
804␉␉␉␉break;␊
805␉␉␉␉␊
806␉␉␉case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:␊
807␉␉␉␉segmentAddress = 0;␊
808␉␉␉␉␊
809␉␉␉␉// Locate address␊
810␉␉␉␉struct segment_command* segCommand = NULL;␉// NOTE: 32bit only␊
811␉␉␉␉␊
812␉␉␉␉unsigned int binIndex = 0;␊
813␉␉␉␉index = 0;␊
814␉␉␉␉do␊
815␉␉␉␉{␊
816␉␉␉␉␉segCommand = base + sizeof(struct mach_header) + binIndex;␊
817␉␉␉␉␉binIndex += segCommand->cmdsize;␊
818␉␉␉␉␉index++;␊
819␉␉␉␉}␊
820␉␉␉␉while(index <= immediate);␊
821␉␉␉␉␊
822␉␉␉␉segmentAddress = segCommand->fileoff;␊
823␉␉␉␉␊
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␉␉␉␉break;␊
836␉␉␉␉␊
837␉␉␉case BIND_OPCODE_ADD_ADDR_ULEB:␊
838␉␉␉␉// Read in offset␊
839␉␉␉␉tmp = 0;␊
840␉␉␉␉bits = 0;␊
841␉␉␉␉do␊
842␉␉␉␉{␊
843␉␉␉␉␉tmp |= (bind_stream[++i] & 0x7f) << bits;␊
844␉␉␉␉␉bits += 7;␊
845␉␉␉␉}␊
846␉␉␉␉while(bind_stream[i] & 0x80);␊
847␉␉␉␉␊
848␉␉␉␉segmentAddress += tmp;␊
849␉␉␉␉break;␊
850␉␉␉␉␊
851␉␉␉case BIND_OPCODE_DO_BIND:␊
852␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
853␉␉␉␉{␊
854␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
855␉␉␉␉␉␉␊
856␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, type);␊
857␉␉␉␉}␊
858␉␉␉␉else␊
859␉␉␉␉{␊
860␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
861␉␉␉␉␉getc();␊
862␉␉␉␉}␊
863␉␉␉␉␊
864␉␉␉␉segmentAddress += sizeof(void*);␊
865␉␉␉␉break;␊
866␉␉␉␉␊
867␉␉␉case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:␊
868␉␉␉␉// Read in offset␊
869␉␉␉␉tmp = 0;␊
870␉␉␉␉bits = 0;␊
871␉␉␉␉do␊
872␉␉␉␉{␊
873␉␉␉␉␉tmp |= (bind_stream[++i] & 0x7f) << bits;␊
874␉␉␉␉␉bits += 7;␊
875␉␉␉␉}␊
876␉␉␉␉while(bind_stream[i] & 0x80);␊
877␊
878␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
879␉␉␉␉{␊
880␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
881␉␉␉␉␉␊
882␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, type);␊
883␉␉␉␉}␊
884␉␉␉␉else␊
885␉␉␉␉{␊
886␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
887␉␉␉␉␉getc();␊
888␉␉␉␉}␊
889␊
890␉␉␉␉segmentAddress += tmp + sizeof(void*);␊
891␉␉␉␉␊
892␉␉␉␉␊
893␉␉␉␉break;␊
894␉␉␉␉␊
895␉␉␉case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:␊
896␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
897␉␉␉␉{␊
898␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
899␉␉␉␉␉␊
900␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, type);␊
901␉␉␉␉}␊
902␉␉␉␉else␊
903␉␉␉␉{␊
904␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
905␉␉␉␉␉getc();␊
906␉␉␉␉}␊
907␉␉␉␉segmentAddress += (immediate * sizeof(void*)) + sizeof(void*);␊
908␉␉␉␉␊
909␉␉␉␉␊
910␉␉␉␉break;␊
911␉␉␉␉␊
912␉␉␉case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:␊
913␉␉␉␉tmp = 0;␊
914␉␉␉␉bits = 0;␊
915␉␉␉␉do␊
916␉␉␉␉{␊
917␉␉␉␉␉tmp |= (bind_stream[++i] & 0x7f) << bits;␊
918␉␉␉␉␉bits += 7;␊
919␉␉␉␉}␊
920␉␉␉␉while(bind_stream[i] & 0x80);␊
921␉␉␉␉␊
922␉␉␉␉␊
923␉␉␉␉tmp2 = 0;␊
924␉␉␉␉bits = 0;␊
925␉␉␉␉do␊
926␉␉␉␉{␊
927␉␉␉␉␉tmp2 |= (bind_stream[++i] & 0x7f) << bits;␊
928␉␉␉␉␉bits += 7;␊
929␉␉␉␉}␊
930␉␉␉␉while(bind_stream[i] & 0x80);␊
931␉␉␉␉␊
932␉␉␉␉␊
933␉␉␉␉if(symbolAddr != 0xFFFFFFFF)␊
934␉␉␉␉{␊
935␉␉␉␉␉for(index = 0; index < tmp; index++)␊
936␉␉␉␉␉{␊
937␉␉␉␉␉␉␊
938␉␉␉␉␉␉address = segmentAddress + (UInt32)base;␊
939␉␉␉␉␉␉bind_location((UInt32*)address, (char*)symbolAddr, addend, type);␊
940␉␉␉␉␉␉segmentAddress += tmp2 + sizeof(void*);␊
941␉␉␉␉␉}␊
942␉␉␉␉}␊
943␉␉␉␉else␊
944␉␉␉␉{␊
945␉␉␉␉␉printf("Unable to bind symbol %s\n", symbolName);␊
946␉␉␉␉␉getc();␊
947␉␉␉␉}␊
948␉␉␉␉break;␊
949␉␉}␊
950␉␉i++;␊
951␉}␊
952}␊
953␊
954inline void bind_location(UInt32* location, char* value, UInt32 addend, int type)␊
955{␉␊
956␉// do actual update␊
957␉char* newValue = value + addend;␊
958␉␊
959␉switch (type) {␊
960␉␉case BIND_TYPE_POINTER:␊
961␉␉case BIND_TYPE_TEXT_ABSOLUTE32:␊
962␉␉␉break;␊
963␉␉␉␊
964␉␉case BIND_TYPE_TEXT_PCREL32:␊
965␉␉␉newValue -= ((UInt32)location + 4);␊
966␉␉␉␊
967␉␉␉break;␊
968␉␉default:␊
969␉␉␉return;␊
970␉}␊
971␉//DBG("Binding 0x%X to 0x%X (was 0x%X)\n", location, newValue, *location);␊
972␉*location = (UInt32)newValue;␊
973}␊
974␊
975/********************************************************************************/␊
976/*␉Module Hook Interface␉␉␉␉␉␉␉␉␉␉␉␉␉␉*/␊
977/********************************************************************************/␊
978␊
979/*␊
980* Locate the symbol for an already loaded function and modify the beginning of␊
981* the function to jump directly to the new one␊
982* example: replace_function("_HelloWorld_start", &replacement_start);␊
983*/␊
984int replace_function(const char* symbol, void* newAddress)␊
985{␊
986␉UInt32* jumpPointer = malloc(sizeof(UInt32*));␉ ␊
987␉UInt32 addr = lookup_all_symbols(symbol);␊
988␉␊
989␉char* binary = (char*)addr;␊
990␉if(addr != 0xFFFFFFFF)␊
991␉{␊
992␉␉//DBG("Replacing %s to point to 0x%x\n", symbol, newAddress);␊
993␉␉*binary++ = 0xFF;␉// Jump␊
994␉␉*binary++ = 0x25;␉// Long Jump␊
995␉␉*((UInt32*)binary) = (UInt32)jumpPointer;␊
996␉␉␊
997␉␉*jumpPointer = (UInt32)newAddress;␊
998␉␉return 1;␊
999␉}␊
1000␉return 0;␊
1001}␊
1002␊
1003␊
1004/*␊
1005 *␉execute_hook( const char* name )␊
1006 *␉␉name - Name of the module hook␊
1007 *␉␉␉If any callbacks have been registered for this hook␊
1008 *␉␉␉they will be executed now in the same order that the␊
1009 *␉␉␉hooks were added.␊
1010*/␊
1011int execute_hook(const char* name, void* arg1, void* arg2, void* arg3, void* arg4)␊
1012{␊
1013␉DBG("Attempting to execute hook '%s'\n", name); DBGPAUSE();␊
1014␉moduleHook_t* hook = hook_exists(name);␊
1015␉␊
1016␉if(hook)␊
1017␉{␊
1018␉␉// Loop through all callbacks for this module␊
1019␉␉callbackList_t* callbacks = hook->callbacks;␊
1020␊
1021␉␉while(callbacks)␊
1022␉␉{␊
1023␉␉␉// Execute callback␊
1024␉␉␉callbacks->callback(arg1, arg2, arg3, arg4);␊
1025␉␉␉callbacks = callbacks->next;␊
1026␉␉}␊
1027␉␉DBG("Hook '%s' executed.\n", name); DBGPAUSE();␊
1028␉␉return 1;␊
1029␉}␊
1030␉else␊
1031␉{␊
1032␉␉// Callback for this hook doesn't exist;␊
1033␉␉DBG("No callbacks for '%s' hook.\n", name);␊
1034␉␉return 0;␊
1035␉}␊
1036}␊
1037␊
1038␊
1039␊
1040/*␊
1041 *␉register_hook_callback( const char* name, void(*callback)())␊
1042 *␉␉name - Name of the module hook to attach to.␊
1043 *␉␉callbacks - The funciton pointer that will be called when the␊
1044 *␉␉␉hook is executed. When registering a new callback name, the callback is added sorted.␊
1045 *␉␉␉NOTE: the hooks take four void* arguments.␊
1046 */␊
1047void register_hook_callback(const char* name, void(*callback)(void*, void*, void*, void*))␊
1048{␉␊
1049␉DBG("Adding callback for '%s' hook.\n", name); DBGPAUSE();␊
1050␉␊
1051␉moduleHook_t* hook = hook_exists(name);␊
1052␉␊
1053␉if(hook)␊
1054␉{␊
1055␉␉// append␊
1056␉␉callbackList_t* newCallback = malloc(sizeof(callbackList_t));␊
1057␉␉newCallback->next = hook->callbacks;␊
1058␉␉hook->callbacks = newCallback;␊
1059␉␉newCallback->callback = callback;␊
1060␉}␊
1061␉else␊
1062␉{␊
1063␉␉// create new hook␊
1064␉␉moduleHook_t* newHook = malloc(sizeof(moduleHook_t));␉␉␊
1065␉␉newHook->name = name;␊
1066␉␉newHook->callbacks = malloc(sizeof(callbackList_t));␊
1067␉␉newHook->callbacks->callback = callback;␊
1068␉␉newHook->callbacks->next = NULL;␊
1069␉␉␊
1070␉␉newHook->next = moduleCallbacks;␊
1071␉␉moduleCallbacks = newHook;␊
1072␉␉␊
1073␉}␊
1074␉␊
1075#if DEBUG_MODULES␊
1076␉//print_hook_list();␊
1077␉//getc();␊
1078#endif␊
1079␉␊
1080}␊
1081␊
1082␊
1083moduleHook_t* hook_exists(const char* name)␊
1084{␊
1085␉moduleHook_t* hooks = moduleCallbacks;␊
1086␉␊
1087␉// look for a hook. If it exists, return the moduleHook_t*,␊
1088␉// If not, return NULL.␊
1089␉while(hooks)␊
1090␉{␊
1091␉␉if(strcmp(name, hooks->name) == 0)␊
1092␉␉{␊
1093␉␉␉//DBG("Located hook %s\n", name);␊
1094␉␉␉return hooks;␊
1095␉␉}␊
1096␉␉hooks = hooks->next;␊
1097␉}␊
1098␉//DBG("Hook %s does not exist\n", name);␊
1099␉return NULL;␊
1100␉␊
1101}␊
1102␊
1103#if DEBUG_MODULES␊
1104void print_hook_list()␊
1105{␊
1106␉printf("---Hook Table---\n");␊
1107␉␊
1108␉moduleHook_t* hooks = moduleCallbacks;␊
1109␉while(hooks)␊
1110␉{␊
1111␉␉printf("Hook: %s\n", hooks->name);␊
1112␉␉hooks = hooks->next;␊
1113␉}␊
1114}␊
1115#endif␊
1116␊
1117/********************************************************************************/␊
1118/*␉dyld / Linker Interface␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉␉*/␊
1119/********************************************************************************/␊
1120␊
1121void dyld_stub_binder()␊
1122{␊
1123␉// TODO: actualy impliment this function (asm)␊
1124␉printf("ERROR: dyld_stub_binder was called, should have been take care of by the linker.\n");␊
1125␉getc();␊
1126}␊
1127

Archive Download this file

Revision: 742