/**--------------------------------------------------------------------------**\ ============================== y_hooks - Hook any callback! ============================== Description: Automatically hooks any callbacks with a very simple syntax. Legal: Version: MPL 1.1 The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. The Original Code is the SA:MP callback hooks include. The Initial Developer of the Original Code is Alex "Y_Less" Cole. Portions created by the Initial Developer are Copyright (C) 2008 the Initial Developer. All Rights Reserved. Contributors: ZeeX, koolk, JoeBullet/Google63, g_aSlice/Slice Thanks: JoeBullet/Google63 - Handy arbitrary ASM jump code using SCTRL. Peter, Cam - Support. ZeeX, g_aSlice/Slice, Popz, others - Very productive conversations. koolk - IsPlayerinAreaEx code. TheAlpha - Danish translation. breadfish - German translation. Fireburn - Dutch translation. yom - French translation. 50p - Polish translation. Zamaroht - Spanish translation. Dracoblue, sintax, mabako, Xtreme, other coders - Producing other modes for me to strive to better. Pixels^ - Running XScripters where the idea was born. Matite - Pestering me to release it and using it. Very special thanks to: Thiadmer - PAWN, whose limits continue to amaze me! Kye/Kalcor - SA:MP. SA:MP Team past, present and future - SA:MP. Version: 3.0 Changelog: 23/03/14: Rewrote for better ordering. 26/12/13: Added sections. 15/04/13: Changed the assembly to be shorter by actually using the stack. Now slightly handles return values. 14/04/13: Entirely new version - simpler, faster, and more generic. 02/01/13: Rewrote the system to do away with ALS. Removed overflow checks in every callback. Streamlined code. 14/04/12: Added crash fix from Slice, now returning correct values. Fixed ALS detection of mode callbacks. 25/02/12: Extracted most of the code to a separate file. 17/03/11: Second complete re-write using another new technique. Now VERY fast! Updated OnPlayerUpdate code using Google63's SCTRL jump code. 06/08/10: First version \**--------------------------------------------------------------------------**/ /* ad88888ba d8" "8b ,d Y8, 88 `Y8aaaaa, ,adPPYba, MM88MMM 88 88 8b,dPPYba, `"""""8b, a8P_____88 88 88 88 88P' "8a `8b 8PP""""""" 88 88 88 88 d8 Y8a a8P "8b, ,aa 88, "8a, ,a88 88b, ,a8" "Y88888P" `"Ybbd8"' "Y888 `"YbbdP'Y8 88`YbbdP"' 88 88 */ #define hook%1(%2) UNIQUE_FUNCTION<@yH_%1@...>(%2);UNIQUE_FUNCTION<@yH_%1@...>(%2) #define rehook%1(%2) UNIQUE_FUNCTION<@yH_%1@...>(%2) #define Hook:%0_%1(%2) @yH_%1@%0(%2);@yH_%1@%0(%2) // Strip out extra spaces (nicely recursive) #define @yH_%0\32;%1(%2) @yH_%1(%2) #define Y_HOOKS_CONTINUE_RETURN_1 (1) // Continue the hook chain, return 1 #define Y_HOOKS_CONTINUE_RETURN_0 (0) // Continue the hook chain, return 0 #define Y_HOOKS_BREAK_RETURN_0 (-1) // Break the hook chain, return 0 #define Y_HOOKS_BREAK_RETURN_1 (-2) // Break the hook chain, return 1 enum E_HOOK_NAME_REPLACEMENT_DATA { E_HOOK_NAME_REPLACEMENT_SHORT[16], E_HOOK_NAME_REPLACEMENT_LONG[16], E_HOOK_NAME_REPLACEMENT_MIN, E_HOOK_NAME_REPLACEMENT_MAX } #if !defined CHAIN_ORDER #define CHAIN_ORDER() 0 #endif #define PRE_HOOK(%0) forward @CO_%0();public @CO_%0(){return CHAIN_ORDER()+1;} enum E_PRE_HOOK { E_PRE_HOOK_NAME[16], E_PRE_HOOK_VALUE } PRE_HOOK(HookChain) #undef CHAIN_ORDER #define CHAIN_ORDER @CO_HookChain static stock _HookChain_IncludeStates() <_ALS : _ALS_x0, _ALS : _ALS_x1, _ALS : _ALS_x2, _ALS : _ALS_x3> { } static stock _HookChain_IncludeStates() <_ALS : _ALS_go> { } #define HOOK_FORWARD:%0_%2(%1); \ forward %0_%2(%1); \ public %0_%2(%1) <_ALS : _ALS_x0, _ALS : _ALS_x1> { return 1; } \ public %0_%2(%1) <> { return 1; } #define HOOK_RET:%0(%1) forward @RET%0(); public @RET%0() HOOK_RET:OnPlayerCommandText() { return 0; } HOOK_RET:OnRconCommand() { return 0; } #if !defined MAX_HOOK_REPLACEMENTS #define MAX_HOOK_REPLACEMENTS (16) #endif // Generate a function name using only ONE of the parts, so two replacements for // the same long name will collide at compile-time #define DEFINE_HOOK_REPLACEMENT(%0,%1); forward @_yH%0(); public @_yH%0() { _Hooks_AddReplacement(#%0, #%1); } // Strip spaces from the generated function name. #define @_yH%0\32;%1(%2) @_yH%0%1(%2) // Create the default replacements. DEFINE_HOOK_REPLACEMENT(Checkpoint, CP ); DEFINE_HOOK_REPLACEMENT(Container , Cnt); DEFINE_HOOK_REPLACEMENT(Inventory , Inv); DEFINE_HOOK_REPLACEMENT(Dynamic , Dyn); DEFINE_HOOK_REPLACEMENT(TextDraw , TD ); DEFINE_HOOK_REPLACEMENT(Update , Upd); DEFINE_HOOK_REPLACEMENT(Object , Obj); DEFINE_HOOK_REPLACEMENT(Command , Cmd); DEFINE_HOOK_REPLACEMENT(DynamicCP , DynamicCP); static stock YSI_g_sReplacements[MAX_HOOK_REPLACEMENTS][E_HOOK_NAME_REPLACEMENT_DATA], YSI_g_sReplacementsLongOrder[MAX_HOOK_REPLACEMENTS], YSI_g_sReplacementsShortOrder[MAX_HOOK_REPLACEMENTS], YSI_g_sReplacePtr; /**--------------------------------------------------------------------------**\ Hooks_MakeLongName Function name to modify. - Expands all name parts like "CP" and "Obj" to their full versions (in this example "Checkpoint" and "Object"). \**--------------------------------------------------------------------------**/ stock Hooks_MakeLongName(name[64]) { new end = 0, i = 0, pos = -1, idx = YSI_g_sReplacementsShortOrder[0]; while (i != YSI_g_sReplacePtr) { // Allow for multiple replacements of the same string. if ((pos = strfind(name, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_SHORT], false, pos + 1)) == -1) { ++i, idx = YSI_g_sReplacementsShortOrder[i]; } // This assumes CamelCase. If the letter immediately following the end // of the string is lower-case, then the short word found is not a // complete word and should not be replaced. else if ('a' <= name[(end = pos + YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_MIN])] <= 'z') continue; else { P:5("Found hook name replacement: %d, %s", pos, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_SHORT]); // Found a complete word according to CamelCase rules. strdel(name, pos + 1, end), name[pos] = 0x80000000 | idx; } } // All the replacements have been found and marked. Now actually insert. // If "end" is "0", it means that it was never assigned to within the loop // above, which means that no replacements were found. if (end) { // "pos" must be "-1" at the start of this loop. while (name[++pos]) { if (name[pos] < '\0') { // Negative number instead of a character. Used to indicate // where a replacement should be inserted. They are not done // inline in the loop above because some replacements may be // contained within others - we don't want those to be both done // within each other. P:5("Inserting hook name replacement: %d, %s", pos, YSI_g_sReplacements[name[pos] & ~0x80000000][E_HOOK_NAME_REPLACEMENT_LONG]); P:7("Current character: 0x%04x%04x", name[pos] >>> 16, name[pos] & 0xFFFF); // It took me ages to find a bug in this code. For some reason, // "strins" was packing the result. This was because the value // in "name[pos]" was not a real character, so was seen as an // indication that the string was packed. I fixed it by moving // the assignment to "name[pos]" above "strins". So while the // two lines look independent, they aren't! i = name[pos] & ~0x80000000, name[pos] = YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_LONG], strins(name, YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_LONG + E_HOOK_NAME_REPLACEMENT_DATA:1], pos + 1), pos += YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_MAX] - 1; P:7("New string: %s", name); } } } // It is possible for the expansions to become TOO big. return Hooks_MakeShortName(name); } /**--------------------------------------------------------------------------**\ Hooks_MakeShortName Function name to modify. - Compresses function names when required to fit within 32 characters according to well defined rules (see "YSI_g_sReplacements"). \**--------------------------------------------------------------------------**/ stock Hooks_MakeShortName(name[64]) { // Easy one. new len, pos = -1, idx = YSI_g_sReplacementsLongOrder[0]; for (new i = 0; (len = strlen(name)) >= 32 && i != YSI_g_sReplacePtr; ) { if ((pos = strfind(name, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_LONG], false, pos + 1)) == -1) { ++i, idx = YSI_g_sReplacementsLongOrder[i]; } else { strdel(name, pos, pos + YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_MAX]), strins(name, YSI_g_sReplacements[idx][E_HOOK_NAME_REPLACEMENT_SHORT], pos); } } return len; } /**--------------------------------------------------------------------------**\ Hooks_IsolateName The string to get the hooked function name from. The input string without y_hooks name decorations. - \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_IsolateName(string:name[]) { new pos = strfind(name, "@", false, 4); // Make "pos" a legal value inside the error message. if (pos == -1) P:E("Invalid hook name: %s", unpack(name), ++pos); name[pos] = '\0', strdel(name, 0, 4); } /**--------------------------------------------------------------------------**\ Hooks_GetPreloadLibraries Desination in which to store all the preloads. Number of found preload libraries. Maximum number of libraries to store. - Some includes, like "fixes.inc" and anti-cheats MUST come before all other includes in order for everything to function correctly (at least fixes.inc must). This function looks for these definitions: PRE_HOOK(FIXES) Which tell y_hooks that any "FIXES_" prefixed callbacks are part of one of these chains. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_GetPreloadLibraries(preloads[][E_PRE_HOOK], &precount, size = sizeof (preloads)) { --size, precount = 0; new entry, idx; { new name[32 char], addr; while ((idx = AMX_GetPublicEntryPrefix(idx, entry, _A<@CO_>))) { if (precount == size) { P:E("y_hooks prehook array filled"); break; } addr = AMX_Read(entry); AMX_ReadString(AMX_Read(entry + 4) + AMX_BASE_ADDRESS + 4, name), strunpack(preloads[precount][E_PRE_HOOK_NAME], name, 16), preloads[precount][E_PRE_HOOK_VALUE] = CallFunction(addr), ++precount; // Remove this public from the publics table. Means that future public // function calls will be faster by having a smaller search space. Hooks_InvalidateName(entry); } } // Sort the preload libraries. { new tmp[E_PRE_HOOK]; for (entry = precount - 1; entry > 0; --entry) { for (idx = 0; idx != entry; ++idx) { if (preloads[idx][E_PRE_HOOK_VALUE] > preloads[idx + 1][E_PRE_HOOK_VALUE]) { tmp = preloads[idx], preloads[idx] = preloads[idx + 1], preloads[idx + 1] = tmp; } } } } } /**--------------------------------------------------------------------------**\ Hooks_GetPreHooks Names of libraries that come before y_hooks. Number of pre libraries. Name of the callback. Destination in which to store the headers. Number of headers found. - Finds all the AMX file headers for functions with a similar name to the given callback that should be called before (or near) the given callback. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_GetPreHooks(preloads[][E_PRE_HOOK], precount, name[64], hooks[], &count) { new idx, lfunc[64]; // Collect all the functions with something like this name. do { strcat(lfunc, name), Hooks_MakeShortName(lfunc); if (AMX_GetPublicEntry(0, hooks[count], lfunc, true)) ++count; strcpy(lfunc, preloads[idx][E_PRE_HOOK_NAME]), strcat(lfunc, "_"); } while (++idx <= precount); } /**--------------------------------------------------------------------------**\ Hooks_GetPointerRewrite All the prehooks for this callback. The number of prehooks. A pointer to write the new stub address to. The pointer for the function called after y_hooks. The name of the callback being processed. Space available in the header to write text in. - - \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_GetPointerRewrite(hooks[], num, &ptr, &next, name[], nlen) { switch (num) { case 0: { next = 0; new len = strlen(name); if (nlen >= len) { // We don't have an existing callback with this name, only hooks. // We need to add the name of the callback to the AMX header, // and we have enough space in which to do so. new str[32]; strpack(str, name), AMX_WriteString(AMX_BASE_ADDRESS + AMX_Read(ptr + 4), str, len); } else { P:F("Could not write function name in \"Hooks_MakePublicPointer\"."); // TODO: Fix this. Use an alternate memory location (the actual // code segment in which we are writing seems like a good // choice). } } case 1: { // No "fixes.inc", but this callback already exists. In that case, // just replace the pointer address. next = ptr = hooks[0]; } default: { // Special hooks. Optimise them. for (new cur = 1; cur != num; ++cur) { ptr = hooks[cur]; new tmp = AMX_Read(ptr), nt = Hooks_GetStubEntry(tmp); tmp += AMX_HEADER_COD, AMX_Write(tmp, _:RelocateOpcode(OP_JUMP)); switch (nt) { case -1: ptr = tmp + 4, next = 0; case 0: next = 0; default: { ptr = tmp + 4, next = tmp + nt, nt = AMX_Read(next), // Chain those not hooked. AMX_Write(ptr, nt), // Store the possible next address. AMX_Write(next, nt - (AMX_REAL_DATA + AMX_HEADER_COD)); } } } } } } /**--------------------------------------------------------------------------**\ Hooks_GetStubEntry Starting address of the function. The address at which the actual code in this function starts. This handles three cases. Regular functions end instantly as found. Functions that start with a switch (even before "PROC") are assumed to be state-based functions, and we find the most likely state to be used (i.e. we remove all future state changes). \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_GetStubEntry(stub) { // Get the address of the next function from the ALS state stub. new ctx[DisasmContext]; DisasmInit(ctx, stub, stub + 64); switch (DisasmNextInsn(ctx)) { case OP_LOAD_PRI: { if (DisasmNextInsn(ctx) == OP_SWITCH && DisasmNextInsn(ctx) == OP_CASETBL) { // Get the number of items in the casetable. if (DisasmGetNumOperands(ctx) == 3) // 2 means no used hook. { // Got a hook to return. Find it. new h0 = DisasmGetOperand(ctx, 3), h1 = DisasmGetOperand(ctx, 5), h2 = DisasmGetOperand(ctx, 7); if (h1 == h2) return 8 * 4; // Most likely. else if (h0 == h2) return 10 * 4; else if (h0 == h1) return 12 * 4; else P:E("y_hooks could not extract state stub jump"); } else return -1; } } case OP_JUMP: { // Already replaced once (shouldn't happen, but may if two different // hooks use two different short versions of a callback). return 4; // DisasmGetOperand(ctx, 0); } case OP_PROC: { //return stub; P:E("y_hooks attempting to redirect a PROC hook"); } } return 0; } /**--------------------------------------------------------------------------**\ Hooks_GetAllHooks The name of the callback (with y_hooks prefix). Array in which to store the function headers. Current position in the AMX header. Min bound of space used by all these names. The number of hooks found. The name of the function currently being processed is derived from the first found hook. This means we already know of one hook, but to simplify the code we get that one again here. Above we only know the name not the address. Hence the "- 1" in "i = idx - 1" (to go back one function name). Our "namelen" variable already contains the full length of the first found hook - this is the length of "name", plus N extra characters. The following are all valid, and may occur when orders are played with: @yH_OnX@ @yH_OnX@1 @yH_OnX@01 @yH_OnX@024 @yH_OnX@ZZZ @yH_OnX@999@024 If we want to get the EXACT space taken up by all these hook names we would need to get the string of the name in this function then measure it. There is really no point in doing this - if we have a second we will always have enough space for our new names. Instead, we assume that they are all just @yH_OnX@ And add on that minimum length accordingly (plus 1 for the NULL character). This length is used if the original callback doesn't exist but hooks do. In that case we need to add the callback to the AMX header, and there is a tiny chance that the original name will be longer than one hook's name. In that case, having two or more hooks will (AFAIK) always ensure that we have enough space to write the longer name. If there is only one hook, no original function, and the name of the hook is shorter than the name of the original function then we have an issue and will have to do something else instead. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_GetAllHooks(const name[], hooks[128], &idx, &namelen) { // Start from the very start - repeats the first item. new len = strlen(name) + 1, count, i = idx - 1; while ((i = AMX_GetPublicEntry(i, hooks[count], name))) { Hooks_InvalidateName(hooks[count]), idx = i; // Record how much consecutive space we have to play with in the AMX. if (count) namelen += len; // The first hook was already counted. // Increment and count how many hooks of this type we have. if (++count == sizeof (hooks)) { P:W("Hooks_GetAllHooks: Potential overflow."); break; } } return count; } /**--------------------------------------------------------------------------**\ - - \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_DoAllHooks() { // Get the preloaders. new precount = 0, preloads[8][E_PRE_HOOK]; Hooks_GetPreloadLibraries(preloads, precount); // Main loop new name[32], idx; // Get the next hook type. while ((idx = AMX_GetPublicNamePrefix(idx, name, _A<@yH_>))) { // Collect all the hooks of this function, and rewrite the call code. Hooks_Collate(preloads, precount, name, idx); } Hooks_SortPublics(); } /**--------------------------------------------------------------------------**\ - - \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_Collate(preloads[][E_PRE_HOOK], precount, name[32], &idx) { // This records the amount of space available in the nametable, currently // taken up by the names of hooks that we are about to destroy. new namelen = strlen(name); // For this function, note that: // // hook OnPlayerConnect(playerid) // // Compiles as: // // public @yH_OnPlayerConnect@XXX(playerid) // // Where "XXX" is some unique number (the exact value is irrelevant, it just // means that multiple hooks of the same function have different names). static sName[64], sHooks[128]; // Isolate the common prefix part: // // @yH_OnPlayerConnect@042 // // Becomes: // // @yH_OnPlayerConnect@ // // The numbers at the end are irrelevant, now we can just search for hooks // of this exact callback. name{strfind(name, "@", false, 4) + 1} = '\0', // The above now becomes: // // OnPlayerConnect // // This also handles cases such as: // // @yH_OnPlayerEnterRaceCheckpoint@162 // // Being invalid (too long), so instead converts the shortened: // // @yH_OnPlayerEnterRaceCP@162 // // To: // // OnPlayerEnterRaceCheckpoint // // Thus expanding common name length reductions. strunpack(sName, name), Hooks_IsolateName(sName), Hooks_MakeLongName(sName); new // Get all the hooks of this type. They are stored alphabetically. hookCount = Hooks_GetAllHooks(name, sHooks, idx, namelen), writePtr = sHooks[0], // Header for the first found hook. nextPtr, pc, ph[4]; // Get the preloads. Hooks_GetPreHooks(preloads, precount, sName, ph, pc), // Get where in the chain we are being inserted. Hooks_GetPointerRewrite(ph, pc, writePtr, nextPtr, sName, namelen); // Add ALS hooks to the end of the list. if ((sHooks[hookCount] = nextPtr)) ++hookCount; // Write the code. Hooks_GenerateCode(sName, sHooks, hookCount, writePtr, pc > 1); } /**--------------------------------------------------------------------------**\ Hooks_GenerateCode Name of the function to generate. All the functions to call. Number of functions to call. Where to write the new function's pointer. Needs to call other stuff first. - - \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_GenerateCode(name[64], hooks[], count, write, bool:hasprehooks) { // We now have: // // 1) All the hooks of this function. // 2) The original function if it exists. // 3) Special ALS chained functions if they exists. // // This took huge chunks of complex code in the old version. Now not so // much! I don't know if this code is faster (I suspect it is), but it is // absolutely simpler! new size = Hooks_WriteFunction(hooks, count, Hooks_GetDefaultReturn(name)); P:4("Hooks_GenerateCode %32s called: %6d %6d %08x %d", name[4], hasprehooks, size, hasprehooks ? (write - AMX_HEADER_COD) : (write - AMX_BASE_ADDRESS), CGen_GetCodeSpace()); if (size) { //AMX_Write(write, 40); if (hasprehooks) AMX_Write(write, CGen_GetCodeSpace() + AMX_REAL_DATA); else AMX_Write(write, CGen_GetCodeSpace() - AMX_HEADER_COD); CGen_AddCodeSpace(size); } else { if (hasprehooks) AMX_Write(write, AMX_Read(hooks[0]) + (AMX_REAL_DATA + AMX_HEADER_COD)); else AMX_Write(write, AMX_Read(hooks[0])); } } /**--------------------------------------------------------------------------**\ Hooks_InvalidateName The public function slot to destroy. - Basically, once we know a function has been included, wipe it from the AMX header. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_InvalidateName(entry) { AMX_Write(AMX_BASE_ADDRESS + AMX_Read(entry + 4), 0); } /* 88888888888 88 88 ad88 88 ,d "" 88 d8" 88 88 88 88 88aaaaa 88 88 8b,dPPYba, ,adPPYba, MM88MMM 88 ,adPPYba, 8b,dPPYba, 88 8b,dPPYba, MM88MMM ,adPPYba, 88""""" 88 88 88P' `"8a a8" "" 88 88 a8" "8a 88P' `"8a 88 88P' `"8a 88 a8" "8a 88 88 88 88 88 8b 88 88 8b d8 88 88 88 88 88 88 8b d8 88 "8a, ,a88 88 88 "8a, ,aa 88, 88 "8a, ,a8" 88 88 88 88 88 88 "8a, ,a8" 88 `"YbbdP'Y8 88 88 `"Ybbd8"' "Y888 88 `"YbbdP"' 88 88 88 88 88 88 `"YbbdP"' */ /**--------------------------------------------------------------------------**\ Hooks_GetFunctionWritePoint The function to get the address pointer of. Destination variable. The address at which this function's pointer is stored in the AMX header, if the function exists of course. - \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_GetFunctionWritePoint(name[], &write) { AMX_GetPublicEntry(0, write, name, true); } /**--------------------------------------------------------------------------**\ Hooks_GetDefaultReturn The function to get the default return of. The default return for a callback, normally 1. - \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC stock Hooks_GetDefaultReturn(name[64]) { strins(name, "@RET", 0); Hooks_MakeShortName(name); new ptr; if (AMX_GetPublicEntry(0, ptr, name, true)) { // A "RET_OnWhatever" function exists - rationalise the return. return CallFunction(AMX_Read(ptr)) ? 1 : 0; } return 1; } /* ,ad8888ba, 88 d8"' `"8b 88 d8' 88 88 ,adPPYba, ,adPPYb,88 ,adPPYba, ,adPPYb,d8 ,adPPYba, 8b,dPPYba, 88 a8" "8a a8" `Y88 a8P_____88 a8" `Y88 a8P_____88 88P' `"8a Y8, 8b d8 8b 88 8PP""""""" 8b 88 8PP""""""" 88 88 Y8a. .a8P "8a, ,a8" "8a, ,d88 "8b, ,aa "8a, ,d88 "8b, ,aa 88 88 `"Y8888Y"' `"YbbdP"' `"8bbdP"Y8 `"Ybbd8"' `"YbbdP"Y8 `"Ybbd8"' 88 88 aa, ,88 "Y8bbdP" */ /**--------------------------------------------------------------------------**\ Hooks_WriteFunction The hooks to link together. The number of functions in the array. The default return. Can future hooks be ignored on -1? The number of bytes written to memory. Generate some new code, very nicely :D. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_WriteFunction(const pointers[], const size, const ret = 1, const skipable = true) { new bool:multiple = size != 1, base = (AMX_HEADER_COD - AMX_BASE_ADDRESS) + AMX_REAL_ADDRESS, ctx[AsmContext]; // Make sure the underlying system doesn't change without us. Now supported // natively. CGen_UseCodeSpace(ctx); // Start of the function. @emit PROC // 1 // Allocate space for our "ret" variable at "frm - 4". if (multiple) @emit PUSH.C ret // 3 // Copy the stack to itself (MOVS). // Allocate space. @emit LOAD.S.alt 8 // 5 @emit LCTRL 4 // 7 @emit SUB // 8 @emit SCTRL 4 // 10 @emit XCHG // 11 // The "MOVS" OpCode only takes a constant, not a variable, so we need to // generate self-modifying code (just to be UBER meta)! This code is // generated AFTER the file is loaded so we bypass the data segment checks // and can freely write wherever we want. @emit STOR.pri (CGen_GetCodeSpace() + (18 * 4) - (multiple ? 0 : 8)) // 13 // Do the copying. "alt" is already "STK", load the "FRM" offset. @emit LCTRL 5 // 15 @emit ADD.C 12 // 17 // This is the instruction we want to modify... @emit MOVS 0 // 19 (- 1) // Push the (fake) number of parameters. @emit PUSH.C -4 // Now loop over all our functions and insert "CALL" opcodes for them. if (multiple) { for (new i = 0; ; ) { // Get the absolute offset from here. @emit CALL (AMX_Read(pointers[i]) + base) // 2 if (skipable) { // ===================================== // THIS SECTION IS CURRENTLY 10 CELLS. // ===================================== // Note: Including the original call... // // if (func() < 0) break; // else ret = ret & func(); // @emit ZERO.alt // 3 @emit JSLESS.rel ((size - i) * (10 * 4) - (5 * 4)) // 5 // ========================= // JUMP OVER THIS SECTION. // ========================= } @emit LOAD.S.alt -4 // 7 if (ret) @emit AND // 8 else @emit OR // 8 // Loop and do the very first items last. if (++i == size) break; else @emit STOR.S.pri -4 // 10 } if (skipable) { @emit JUMP.rel 4 // 10 // This is the point the large "JSLESS" above goes to. // -1 = 0, -2 = 1 @emit INVERT } } else if (skipable) { // Still need this code as they may hook a function that doesn't exist, // but we still need to correctly process -1 or -2. @emit CALL (AMX_Read(pointers[0]) + base) @emit ZERO.alt @emit JSGEQ.rel 4 @emit INVERT } else { // Just replace the original (turns out, this takes no code). Basically // just discard everything we've written so far (reclaims the memory). return 0; } // This is the point the small "JUMP" above goes to. @emit MOVE.alt // Remove the whole stack then get the return value. @emit LCTRL 5 @emit SCTRL 4 //@emit LOAD.S.pri -4 @emit MOVE.pri // Return. @emit RETN // Return the number of bytes written. return ctx[AsmContext_buffer_offset]; } /* ad88888ba 88 d8" "8b ,d "" Y8, 88 `Y8aaaaa, ,adPPYba, 8b,dPPYba, MM88MMM 88 8b,dPPYba, ,adPPYb,d8 `"""""8b, a8" "8a 88P' "Y8 88 88 88P' `"8a a8" `Y88 `8b 8b d8 88 88 88 88 88 8b 88 Y8a a8P "8a, ,a8" 88 88, 88 88 88 "8a, ,d88 "Y88888P" `"YbbdP"' 88 "Y888 88 88 88 `"YbbdP"Y8 aa, ,88 "Y8bbdP" */ /**--------------------------------------------------------------------------**\ Hooks_CompareNextCell The 1st address to read. The 2nd address to read. -1 - The first address is bigger. 0 - The addresses are the same 1 - The second address is bigger. Reads two addresses, converts them to big endian, and compares them as four characters of a string at once. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_CompareNextCell(addr0, addr1) { new s0 = Cell_ReverseBytes(AMX_Read(addr0)), s1 = Cell_ReverseBytes(AMX_Read(addr1)); // Propogate NULLs. if (!(s0 & 0xFF000000)) s0 = 0; else if (!(s0 & 0x00FF0000)) s0 &= 0xFF000000; else if (!(s0 & 0x0000FF00)) s0 &= 0xFFFF0000; else if (!(s0 & 0x000000FF)) s0 &= 0xFFFFFF00; if (!(s1 & 0xFF000000)) s1 = 0; else if (!(s1 & 0x00FF0000)) s1 &= 0xFF000000; else if (!(s1 & 0x0000FF00)) s1 &= 0xFFFF0000; else if (!(s1 & 0x000000FF)) s1 &= 0xFFFFFF00; // We need the numbers to be compared as big-endian. Now any trailing NULLs // don't matter at all. if (s1 > s0) return 1; else if (s1 < s0) return -1; else return 0; } /**--------------------------------------------------------------------------**\ Hooks_ComparePublics The index of the 1st public. The index of the 2nd public. - Compares two public function entries, and if need-be, swaps them over. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_ComparePublics(idx0, idx1) { idx0 = idx0 * 8 + AMX_HEADER_PUBLICS; idx1 = idx1 * 8 + AMX_HEADER_PUBLICS; new addr0 = AMX_BASE_ADDRESS + AMX_Read(idx0 + 4), addr1 = AMX_BASE_ADDRESS + AMX_Read(idx1 + 4); for ( ; ; ) { switch (Hooks_CompareNextCell(addr0, addr1)) { case -1: { // Swap them over. new tmpFunc = AMX_Read(idx0), tmpName = AMX_Read(idx0 + 4); AMX_Write(idx0, AMX_Read(idx1)); AMX_Write(idx0 + 4, AMX_Read(idx1 + 4)); AMX_Write(idx1, tmpFunc); AMX_Write(idx1 + 4, tmpName); return; } case 1: { // Already in order - good. return; } // case 0: // Loop. } addr0 += 4; addr1 += 4; } } /**--------------------------------------------------------------------------**\ Hooks_SortPublics - Goes through the whole of the public functions table and sorts them all in to alphabetical order. This is done as we move and rename some so we need to fix the virtual machine's binary search. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_SortPublics() { // Count the number of still active functions. new diff = Hooks_CountInvalidPublics() * 8, oldCount = (AMX_HEADER_NATIVES - AMX_HEADER_PUBLICS) / 8; // Now I need to SORT the functions, and I have honestly no idea how to do // that. Fortunately I don't actually need to move the strings themselves // around as they just sit nicely in the nametable; I only need to sort the // pointers. for (new i = oldCount - 1; i > 0; --i) { for (new j = 0; j != i; ++j) { // This neatly moves all the functions with blanked names to the // start of the public functions table (which will soon be moved). Hooks_ComparePublics(j, j + 1); } } // Move the start address UP to reduce the VM's search space. if (diff) { // Update stored values in y_amx so they reflect the new structure. AMX_Write(AMX_BASE_ADDRESS + 32, AMX_Read(AMX_BASE_ADDRESS + 32) + diff); AMX_HEADER_PUBLICS += diff; // I'd love to be able to update ZeeX's code as well, but I can't. // Issue pull request for this. ResetStaticAmxHeader(); } // TODO: Inform the fixes2 plugin of the change. That stores indexes, not // addresses so it needs to update itself (somehow - I don't actually know // HOW it will do this...) Probably inform it first, store the addresses, // then inform it again to track down and replace those addresses. } /**--------------------------------------------------------------------------**\ Hooks_CountInvalidPublics - Counts the number of public functions that have had their names erased. \**--------------------------------------------------------------------------**/ _Y_HOOKS_STATIC Hooks_CountInvalidPublics() { new idx, buf, count; // Search for functions whose names start with nothing. while ((idx = AMX_GetPublicEntryPrefix(idx, buf, 0))) ++count; P:4("Hooks_CountInvalidPublics: Invalid = %d", count); return count; } /**--------------------------------------------------------------------------**\ OnScriptInit - Call the main hook run code, then advance the ALS chain. \**--------------------------------------------------------------------------**/ // New stuff. stock _Hooks_AddReplacement(const longName[], const shortName[]) { // MAY need to strip spaces off the input strings, but I don't think so. if (YSI_g_sReplacePtr == MAX_HOOK_REPLACEMENTS) { P:E("Insufficient space in the replacements table."); return; } strcpy(YSI_g_sReplacements[YSI_g_sReplacePtr][E_HOOK_NAME_REPLACEMENT_SHORT], shortName, 16), strcpy(YSI_g_sReplacements[YSI_g_sReplacePtr][E_HOOK_NAME_REPLACEMENT_LONG] , longName , 16), YSI_g_sReplacements[YSI_g_sReplacePtr][E_HOOK_NAME_REPLACEMENT_MIN] = strlen(shortName), YSI_g_sReplacements[YSI_g_sReplacePtr][E_HOOK_NAME_REPLACEMENT_MAX] = strlen(longName), YSI_g_sReplacementsLongOrder[YSI_g_sReplacePtr] = YSI_g_sReplacePtr, YSI_g_sReplacementsShortOrder[YSI_g_sReplacePtr] = YSI_g_sReplacePtr, ++YSI_g_sReplacePtr; } /**--------------------------------------------------------------------------**\ Hooks_SortReplacements - Once all the replacement strings have been found, sort them by the length of the short versions of the strings. This is so that the longest (and special case, e.g. "DynamicCP"-> "DynamicCP") replacements are always done first. \**--------------------------------------------------------------------------**/ static stock Hooks_SortReplacements() { new idx0, idx1, temp; for (new i = YSI_g_sReplacePtr - 1; i > 0; --i) { for (new j = 0; j != i; ++j) { // Sort the strings in order of their short replacement. idx0 = YSI_g_sReplacementsShortOrder[j], idx1 = YSI_g_sReplacementsShortOrder[j + 1]; if (YSI_g_sReplacements[idx0][E_HOOK_NAME_REPLACEMENT_MIN] < YSI_g_sReplacements[idx1][E_HOOK_NAME_REPLACEMENT_MIN]) { temp = YSI_g_sReplacementsShortOrder[j], YSI_g_sReplacementsShortOrder[j] = YSI_g_sReplacementsShortOrder[j + 1], YSI_g_sReplacementsShortOrder[j + 1] = temp; } // Sort the strings in order of their long replacement. idx0 = YSI_g_sReplacementsLongOrder[j], idx1 = YSI_g_sReplacementsLongOrder[j + 1]; if (YSI_g_sReplacements[idx0][E_HOOK_NAME_REPLACEMENT_MAX] < YSI_g_sReplacements[idx1][E_HOOK_NAME_REPLACEMENT_MAX]) { temp = YSI_g_sReplacementsLongOrder[j], YSI_g_sReplacementsLongOrder[j] = YSI_g_sReplacementsLongOrder[j + 1], YSI_g_sReplacementsLongOrder[j + 1] = temp; } } } P:C(for (new i = 0 ; i != YSI_g_sReplacePtr; ++i) P:0("Hook Replacement: %d, %d, %s, %s", YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_MIN], YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_MAX], YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_SHORT], YSI_g_sReplacements[i][E_HOOK_NAME_REPLACEMENT_LONG]);); } /**--------------------------------------------------------------------------**\ OnScriptInit - Call the main hook run code, then advance the ALS chain. \**--------------------------------------------------------------------------**/ public OnScriptInit() { P:1("Hooks_OnScriptInit called"); state _ALS : _ALS_go; // Get the replacements. new idx, entry; // Loop over the redefinition functions and call them to have them call the // "_Hooks_AddReplacement" function above. If we were being REALLY clever, // these functions could be removed from the public functions table // afterwards (there is already code in y_hooks for this) to reduce is size. while ((idx = AMX_GetPublicEntryPrefix(idx, entry, _A<@_yH>))) { // From "amx\dynamic_call.inc" - check it is included in "y_hooks.inc". CallFunction(AMX_Read(entry)); Hooks_InvalidateName(entry); } Hooks_SortReplacements(); Hooks_DoAllHooks(); P:1("Hooks_OnScriptInit chain"); // Dump the generated callbacks for debugging. //DisasmDump("YSI_TEST.asm"); HookChain_OnScriptInit(); P:1("Hooks_OnScriptInit end"); return 1; } HOOK_FORWARD:HookChain_OnScriptInit(); #if defined _ALS_OnScriptInit #undef OnScriptInit #else #define _ALS_OnScriptInit #endif #define OnScriptInit(%0) HookChain_OnScriptInit(%0) <_ALS : _ALS_go>