redo/BlockLua
1
0
Fork 1
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

initial

Browse Source
This commit is contained in:
Redo
2025-10-01 16:26:18 -07:00
commit 36ba54b248
43 changed files with 9810 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
inc/tsfuncs/BlFuncs.cpp Normal file
View File

@@ -0,0 +1,238 @@
//////////////////////////////////////////////////
// BlFuncs Version 1.0
// Includes
#include "BlHooks.hpp"
#include "BlFuncs.hpp"
#include <stdio.h>
// Scanned structures
ADDR tsf_mCacheSequence;
ADDR tsf_mCacheAllocator;
ADDR tsf_gIdDictionary;
ADDR tsf_gEvalState_globalVars;
BlFunctionDefIntern(tsf_BlStringTable__insert );
BlFunctionDefIntern(tsf_BlNamespace__find );
BlFunctionDefIntern(tsf_BlNamespace__createLocalEntry);
BlFunctionDefIntern(tsf_BlDataChunker__freeBlocks );
BlFunctionDefIntern(tsf_BlCon__evaluate );
BlFunctionDefIntern(tsf_BlCon__executef );
BlFunctionDefIntern(tsf_BlCon__executefSimObj );
BlFunctionDefIntern(tsf_BlCon__getVariable );
BlFunctionDefIntern(tsf_BlDictionary__addVariable );
BlFunctionDefIntern(tsf_BlSim__findObject_name );
BlFunctionDefIntern(tsf_BlStringStack__getArgBuffer );
BlFunctionDefIntern(tsf_BlSimObject__getDataField );
BlFunctionDefIntern(tsf_BlSimObject__setDataField );
BlFunctionDefIntern(tsf_BlCon__getReturnBuffer );
// C->TS Args
char* tsf_GetIntArg(signed int value) {
char* ret = tsf_BlStringStack__getArgBuffer(16);
snprintf(ret, 16, "%d", value);
return ret;
}
char* tsf_GetFloatArg(float value) {
char* ret = tsf_BlStringStack__getArgBuffer(32);
snprintf(ret, 32, "%g", value);
return ret;
}
char* tsf_GetStringArg(char* value) {
int len = strlen(value)+1;
char* ret = tsf_BlStringStack__getArgBuffer(len);
memcpy(ret, value, len);
return ret;
}
char* tsf_GetThisArg(ADDR obj) {
return tsf_GetIntArg(*(signed int *)(obj + 32));
}
// Eval
const char* tsf_Eval(const char *code) {
const char *argv[] = {nullptr, code};
return tsf_BlCon__evaluate(0, 2, argv);
}
const char* tsf_Evalf(const char *fmt, ...) {
va_list args;
char code[4096];
va_start(args, fmt);
vsnprintf(code, 4096, fmt, args);
va_end(args);
return tsf_Eval((const char*)code);
}
// Objects
ADDR tsf_FindObject(unsigned int id) {
ADDR obj = *(ADDR*)(*(ADDR*)(tsf_gIdDictionary) + 4*(id & 0xFFF));
if(!obj) return 0;
while(obj && *(unsigned int *)(obj + 32) != id) {
obj = *(ADDR*)(obj + 16);
if(!obj) return 0;
}
return obj;
}
ADDR tsf_FindObject(const char* name) {
return (ADDR)tsf_BlSim__findObject_name(name);
}
ADDR tsf_LookupNamespace(const char* ns, const char* package) {
const char* ste_package;
if(package) {
ste_package = tsf_BlStringTable__insert(package, 0);
} else {
ste_package = nullptr;
}
if(ns) {
const char* ste_namespace = tsf_BlStringTable__insert(ns, 0);
return tsf_BlNamespace__find(ste_namespace, ste_package);
} else {
return tsf_BlNamespace__find(nullptr, ste_package);
}
}
ADDR tsf_LookupNamespace(const char* ns) {
return tsf_LookupNamespace(ns, nullptr);
}
// Object Fields
const char* tsf_GetDataField(ADDR simObject, const char* slotName, const char* array) {
const char *ste_slotName;
if(slotName) {
ste_slotName = tsf_BlStringTable__insert(slotName, 0);
} else {
ste_slotName = nullptr;
}
return tsf_BlSimObject__getDataField(simObject, ste_slotName, array);
}
void tsf_SetDataField(ADDR simObject, const char* slotName, const char* array, const char* value) {
const char* ste_slotName;
if(slotName) {
ste_slotName = tsf_BlStringTable__insert(slotName, 0);
} else {
ste_slotName = nullptr;
}
tsf_BlSimObject__setDataField(simObject, ste_slotName, array, value);
}
// TS Global Variables
const char *tsf_GetVar(const char* name) {
return tsf_BlCon__getVariable(name);
}
void tsf_AddVarInternal(const char* name, signed int varType, void* data) {
tsf_BlDictionary__addVariable((ADDR *)tsf_gEvalState_globalVars, name, varType, data);
}
void tsf_AddVar(const char* name, const char** data) {
tsf_AddVarInternal(name, 10, data);
}
void tsf_AddVar(const char* name, signed int* data) {
tsf_AddVarInternal(name, 4, data);
}
void tsf_AddVar(const char* name, float* data) {
tsf_AddVarInternal(name, 8, data);
}
void tsf_AddVar(const char* name, bool* data) {
tsf_AddVarInternal(name, 6, data);
}
// TS->C Functions
ADDR tsf_AddConsoleFuncInternal(const char* pname, const char* cname, const char* fname, signed int cbtype, const char* usage, signed int mina, signed int maxa) {
const char *ste_fname = tsf_BlStringTable__insert(fname, 0);
ADDR ns = tsf_LookupNamespace(cname, pname);
ADDR ent = tsf_BlNamespace__createLocalEntry(ns, ste_fname);
*(signed int *)tsf_mCacheSequence += 1;
tsf_BlDataChunker__freeBlocks(*(ADDR *)tsf_mCacheAllocator);
*(const char**)(ent + 24) = usage ;
*(signed int* )(ent + 16) = mina ;
*(signed int* )(ent + 20) = maxa ;
*(signed int* )(ent + 12) = cbtype;
return ent;
}
void tsf_AddConsoleFunc(const char* pname, const char* cname, const char* fname, tsf_StringCallback sc, const char* usage, signed int mina, signed int maxa) {
ADDR ent = tsf_AddConsoleFuncInternal(pname, cname, fname, 1, usage, mina, maxa);
*(tsf_StringCallback *)(ent + 40) = sc;
}
void tsf_AddConsoleFunc(const char* pname, const char* cname, const char* fname, tsf_IntCallback ic, const char* usage, signed int mina, signed int maxa) {
ADDR ent = tsf_AddConsoleFuncInternal(pname, cname, fname, 2, usage, mina, maxa);
*(tsf_IntCallback *)(ent + 40) = ic;
}
void tsf_AddConsoleFunc(const char* pname, const char* cname, const char* fname, tsf_FloatCallback fc, const char* usage, signed int mina, signed int maxa) {
ADDR ent = tsf_AddConsoleFuncInternal(pname, cname, fname, 3, usage, mina, maxa);
*(tsf_FloatCallback *)(ent + 40) = fc;
}
void tsf_AddConsoleFunc(const char* pname, const char* cname, const char* fname, tsf_VoidCallback vc, const char* usage, signed int mina, signed int maxa) {
ADDR ent = tsf_AddConsoleFuncInternal(pname, cname, fname, 4, usage, mina, maxa);
*(tsf_VoidCallback *)(ent + 40) = vc;
}
void tsf_AddConsoleFunc(const char* pname, const char* cname, const char* fname, tsf_BoolCallback bc, const char* usage, signed int mina, signed int maxa) {
ADDR ent = tsf_AddConsoleFuncInternal(pname, cname, fname, 5, usage, mina, maxa);
*(tsf_BoolCallback *)(ent + 40) = bc;
}
// Initialization
bool tsf_InitInternal() {
BlScanFunctionText(tsf_BlStringTable__insert , "83 EC 0C 80 3D ? ? ? ? ?" );
BlScanFunctionText(tsf_BlNamespace__find , "55 8B EC 6A FF 68 ? ? ? ? 64 A1 ? ? ? ? 50 83 EC 0C 53 56 57 A1 ? ? ? ? 33 C5 50 8D 45 F4 64 A3 ? ? ? ? 8B DA 8B D1" );
BlScanFunctionText(tsf_BlNamespace__createLocalEntry, "55 8B EC 6A FF 68 ? ? ? ? 64 A1 ? ? ? ? 50 83 EC 08 53 56 57 A1 ? ? ? ? 33 C5 50 8D 45 F4 64 A3 ? ? ? ? 89 4D F0" );
BlScanFunctionText(tsf_BlDataChunker__freeBlocks , "55 8B EC 6A FF 68 ? ? ? ? 64 A1 ? ? ? ? 50 51 53 56 57 A1 ? ? ? ? 33 C5 50 8D 45 F4 64 A3 ? ? ? ? 8B D9 8B 33" );
BlScanFunctionText(tsf_BlCon__evaluate , "55 8B EC 6A FF 68 ? ? ? ? 64 A1 ? ? ? ? 50 56 57 A1 ? ? ? ? 33 C5 50 8D 45 F4 64 A3 ? ? ? ? 8B 75 10" );
BlScanFunctionText(tsf_BlCon__executef , "81 EC ? ? ? ? A1 ? ? ? ? 33 C4 89 84 24 ? ? ? ? 53 55 56 8B B4 24 ? ? ? ? 33 C9" );
BlScanFunctionText(tsf_BlCon__executefSimObj , "81 EC ? ? ? ? A1 ? ? ? ? 33 C4 89 84 24 ? ? ? ? 53 56 8B B4 24 ? ? ? ? 33 C9" );
BlScanFunctionText(tsf_BlCon__getVariable , "53 56 8B F1 57 85 F6 0F 84 ? ? ? ?" );
BlScanFunctionText(tsf_BlDictionary__addVariable , "8B 44 24 04 56 57 8B F9" );
BlScanFunctionText(tsf_BlSim__findObject_name , "57 8B F9 8A 17" );
BlScanFunctionText(tsf_BlStringStack__getArgBuffer , "55 8B EC 83 E4 F8 8B 0D ? ? ? ? A1 ? ? ? ? 56 57 8B 7D 08 8D 14 01 03 D7 3B 15 ? ? ? ? 72 2C 8B 0D" );
BlScanFunctionText(tsf_BlSimObject__getDataField , "51 53 8B D9 55 56 8B 74 24 14" );
BlScanFunctionText(tsf_BlSimObject__setDataField , "81 EC ? ? ? ? A1 ? ? ? ? 33 C4 89 84 24 ? ? ? ? 8B 84 24 ? ? ? ? 53 8B D9 89 44 24 04" );
BlScanFunctionText(tsf_BlCon__getReturnBuffer , "81 F9 ? ? ? ? 76 2B" );
ADDR BlScanText (tsf_mCacheSequenceLoc , "FF 05 ? ? ? ? B9 ? ? ? ? 8B F8 E8 ? ? ? ? 8B 44 24 1C 89 47 18 8B 44 24 14" );
ADDR BlScanText (tsf_mCacheAllocatorLoc , "89 35 ? ? ? ? C7 06 ? ? ? ? A1 ? ? ? ? 68 ? ? ? ? C7 40 ? ? ? ? ? E8 ? ? ? ? 83 C4 04 8B 4D F4 64 89 0D ? ? ? ? 59 5E 8B E5 5D C3");
ADDR BlScanText (tsf_gIdDictionaryLoc , "89 15 ? ? ? ? E8 ? ? ? ? 8B F0 89 75 F0" );
ADDR BlScanText (tsf_gEvalState_globalVarsLoc , "B9 ? ? ? ? E8 ? ? ? ? 68 ? ? ? ? 6A 0A 68 ? ? ? ? B9 ? ? ? ? E8 ? ? ? ? E8 ? ? ? ?" );
tsf_mCacheSequence = *(ADDR*)(tsf_mCacheSequenceLoc + 2);
tsf_mCacheAllocator = *(ADDR*)(tsf_mCacheAllocatorLoc + 2);
tsf_gIdDictionary = *(ADDR*)(tsf_gIdDictionaryLoc + 2);
tsf_gEvalState_globalVars = *(ADDR*)(tsf_gEvalState_globalVarsLoc + 1);
return true;
}
bool tsf_DeinitInternal() {
return true;
}

109
inc/tsfuncs/BlFuncs.hpp Normal file
View File

@@ -0,0 +1,109 @@
//////////////////////////////////////////////////
// BlFuncs Version 1.0
#ifndef _H_BLFUNCS
#define _H_BLFUNCS
// Require BlHooks to be included before this header
#ifndef _H_BLHOOKS
#error "BlFuncs.hpp: You must include BlHooks.hpp first"
#else
typedef const char * (*tsf_StringCallback)(ADDR, signed int, const char *[]);
typedef signed int (*tsf_IntCallback )(ADDR, signed int, const char *[]);
typedef float (*tsf_FloatCallback )(ADDR, signed int, const char *[]);
typedef void (*tsf_VoidCallback )(ADDR, signed int, const char *[]);
typedef bool (*tsf_BoolCallback )(ADDR, signed int, const char *[]);
/* These functions are used for tsf_BlCon__executefSimObj.
They refer to a special buffer for the argument stack.
For tsf_BlCon__executef, you need to use your own buffers. */
char *tsf_GetIntArg(int);
char *tsf_GetFloatArg(float);
char *tsf_ScriptThis(ADDR);
const char *tsf_Eval(const char *);
const char *tsf_Evalf(const char *, ...);
ADDR tsf_FindObject(unsigned int);
ADDR tsf_FindObject(const char *);
ADDR tsf_LookupNamespace(const char *, const char *);
const char *tsf_GetDataField(ADDR, const char *, const char *);
void tsf_SetDataField(ADDR, const char *, const char *, const char *);
const char *tsf_GetVar(const char *);
void tsf_AddVarInternal(const char *, signed int, void *);
void tsf_AddVar(const char *, const char **);
void tsf_AddVar(const char *, signed int *);
void tsf_AddVar(const char *, float *);
void tsf_AddVar(const char *, bool *);
ADDR tsf_AddConsoleFuncInternal(const char *, const char *, const char *, signed int, const char *, signed int, signed int);
void tsf_AddConsoleFunc(const char *, const char *, const char *, tsf_StringCallback, const char *, signed int, signed int);
void tsf_AddConsoleFunc(const char *, const char *, const char *, tsf_IntCallback, const char *, signed int, signed int);
void tsf_AddConsoleFunc(const char *, const char *, const char *, tsf_FloatCallback, const char *, signed int, signed int);
void tsf_AddConsoleFunc(const char *, const char *, const char *, tsf_VoidCallback, const char *, signed int, signed int);
void tsf_AddConsoleFunc(const char *, const char *, const char *, tsf_BoolCallback, const char *, signed int, signed int);
bool tsf_InitInternal();
extern ADDR tsf_mCacheSequence;
extern ADDR tsf_mCacheAllocator;
extern ADDR tsf_gIdDictionary;
extern ADDR tsf_gEvalState_globalVars;
BlFunctionDefExtern(const char *, __stdcall, tsf_BlStringTable__insert, const char *, bool);
BlFunctionDefExtern(ADDR, __fastcall, tsf_BlNamespace__find, const char *, const char *);
BlFunctionDefExtern(ADDR, __thiscall, tsf_BlNamespace__createLocalEntry, ADDR, const char *);
BlFunctionDefExtern(void, __thiscall, tsf_BlDataChunker__freeBlocks, ADDR);
BlFunctionDefExtern(const char *, , tsf_BlCon__evaluate, ADDR, signed int, const char **);
BlFunctionDefExtern(const char *, , tsf_BlCon__executef, signed int, ...);
BlFunctionDefExtern(const char *, , tsf_BlCon__executefSimObj, ADDR *, signed int, ...);
BlFunctionDefExtern(const char *, __thiscall, tsf_BlCon__getVariable, const char *);
BlFunctionDefExtern(void, __thiscall, tsf_BlDictionary__addVariable, ADDR *, const char *, signed int, void *);
BlFunctionDefExtern(ADDR *, __thiscall, tsf_BlSim__findObject_name, const char *);
BlFunctionDefExtern(char *, __stdcall, tsf_BlStringStack__getArgBuffer, unsigned int);
BlFunctionDefExtern(const char *, __thiscall, tsf_BlSimObject__getDataField, ADDR, const char *, const char *);
BlFunctionDefExtern(void, __thiscall, tsf_BlSimObject__setDataField, ADDR, const char *, const char *, const char *);
BlFunctionDefExtern(char *, __fastcall, tsf_BlCon__getReturnBuffer, unsigned int);
// Function short names
#define BlEval tsf_Eval
#define BlEvalf tsf_Evalf
#define BlIntArg tsf_GetIntArg
#define BlFloatArg tsf_GetFloatArg
#define BlThisArg tsf_GetThisArg
#define BlStringArg(x) tsf_GetStringArg((char*)x)
#define BlReturnBuffer tsf_BlCon__getReturnBuffer
#define BlObject tsf_FindObject
#define BlNamespace tsf_LookupNamespace
#define BlGetField tsf_GetDataField
#define BlSetField tsf_SetDataField
#define BlGetVar tsf_GetVar
#define BlAddVar tsf_AddVar
#define BlAddFunction tsf_AddConsoleFunc
#define __22ND_ARGUMENT(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, ...) a22
#define __NUM_LIST(...) __22ND_ARGUMENT(dummy, ##__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define BlCall(...) \
tsf_BlCon__executef(__NUM_LIST(__VA_ARGS__), __VA_ARGS__)
#define BlCallObj(obj, ...) \
tsf_BlCon__executefSimObj((ADDR*)obj, __NUM_LIST(__VA_ARGS__), __VA_ARGS__)
#define BlFuncsInit() if(!tsf_InitInternal()) { return false; }
#define BlFuncsDeinit() if(!tsf_DeinitInternal()) { return false; }
#endif
#endif

207
inc/tsfuncs/BlHooks.cpp Normal file
View File

@@ -0,0 +1,207 @@
//////////////////////////////////////////////////
// RedoBlHooks Version 3.0
// Includes
#include <Windows.h>
#include <Psapi.h>
//#include <map>
#include "BlHooks.hpp"
// Scanned structures
BlFunctionDefIntern(tsh_BlPrintf);
// Sig Scanning
ADDR ImageBase;
ADDR ImageSize;
void tsh_i_InitScanner(){
HMODULE module = GetModuleHandle(NULL);
if(module) {
MODULEINFO info;
GetModuleInformation(GetCurrentProcess(), module, &info, sizeof(MODULEINFO));
ImageBase = (ADDR)info.lpBaseOfDll;
ImageSize = info.SizeOfImage;
}
}
bool tsh_i_CompareData(BYTE *data, BYTE *pattern, char* mask){
for (; *mask; ++data, ++pattern, ++mask){
if (*mask=='x' && *data!=*pattern)
return false;
}
return (*mask)==0;
}
ADDR tsh_i_FindPattern(ADDR imageBase, ADDR imageSize, BYTE *pattern, char *mask){
for (ADDR i=imageBase; i < imageBase+imageSize; i++){
if(tsh_i_CompareData((PBYTE)i, pattern, mask)){
return i;
}
}
return 0;
}
// Convert a text-style pattern into code-style
void tsh_i_PatternTextToCode(char* text, char** opatt, char** omask) {
unsigned int len = strlen(text);
char* patt = (char*)malloc(len);
char* mask = (char*)malloc(len);
int outidx = 0;
int val = 0;
bool uk = false;
for(unsigned int i=0; i<len; i++){
char c = text[i];
if(c=='?'){
uk = true;
}else if(c>='0' && c<='9'){
val = (val<<4) + (c-'0');
}else if(c>='A' && c<='F'){
val = (val<<4) + (c-'A'+10);
}else if(c>='a' && c<='f'){
val = (val<<4) + (c-'a'+10);
}else if(c==' '){
patt[outidx] = uk ? 0 : val;
mask[outidx] = uk ? '?' : 'x';
val = 0;
uk = false;
outidx++;
}
}
patt[outidx] = uk ? 0 : val;
mask[outidx] = uk ? '?' : 'x';
outidx++;
patt[outidx] = 0;
mask[outidx] = 0;
*opatt = patt;
*omask = mask;
}
// Public functions for sig scanning
// Scan using code-style pattern
ADDR tsh_ScanCode(char* pattern, char* mask) {
return tsh_i_FindPattern(ImageBase, ImageSize-strlen(mask), (BYTE*)pattern, mask);
}
// Scan using a text-style pattern
ADDR tsh_ScanText(char* text) {
char* patt;
char* mask;
tsh_i_PatternTextToCode(text, &patt, &mask);
ADDR res = tsh_ScanCode(patt, mask);
free(patt);
free(mask);
return res;
}
// Call Patching and Hooking
// Remove protection from address
//std::map<ADDR, std::pair<ADDR, ADDR>> tsh_DeprotectedAddresses;
void tsh_DeprotectAddress(ADDR length, ADDR location) {
DWORD oldProtection;
VirtualProtect((void*)location, length, PAGE_EXECUTE_READWRITE, &oldProtection);
//tsh_DeprotectedAddresses[location] = {length, oldProtection};
}
// Patch a string of bytes by deprotecting and then overwriting
void tsh_PatchBytes(ADDR length, ADDR location, BYTE* repl) {
tsh_DeprotectAddress(length, location);
memcpy((void*)location, (void*)repl, (size_t)length);
}
void tsh_PatchByte(ADDR location, BYTE value) {
tsh_PatchBytes(location, 1, &value);
}
void tsh_ReplaceInt(ADDR addr, int rval) {
tsh_PatchBytes(4, addr, (BYTE*)(&rval));
}
int tsh_i_CallOffset(ADDR instr, ADDR func) {
return func - (instr+4);
}
void tsh_i_ReplaceCall(ADDR instr, ADDR target) {
tsh_ReplaceInt(instr, tsh_i_CallOffset(instr, target));
}
void tsh_i_PatchCopy(ADDR dest, ADDR src, unsigned int len) {
for(unsigned int i=0; i<len; i++){
tsh_PatchByte(dest+i, *((BYTE*)(src+i)));
}
}
void tsh_HookFunction(ADDR victim, ADDR detour, BYTE* origbytes) {
memcpy(origbytes, (BYTE*)victim, 6); //save old data
*(BYTE*)victim = 0xE9; //jmp rel32
*(ADDR*)(victim+1) = (detour - (victim+5)); // jump offset
*(BYTE*)(victim+5) = 0xC3; //retn
}
void tsh_UnhookFunction(ADDR victim, BYTE* origbytes){
tsh_i_PatchCopy(victim, (ADDR)origbytes, 6); //restore old data
}
int tsh_PatchAllMatchesCode(ADDR len, char* patt, char* mask, char* replace, bool debugprint){
int numpatched = 0;
for(ADDR i=ImageBase; i<ImageBase+ImageSize-len; i++){
if(tsh_i_CompareData((BYTE*)i, (BYTE*)patt, mask)){
if(debugprint) BlPrintf("RedoBlHooks: Patching call at %08x", i);
numpatched++;
tsh_DeprotectAddress(i, len);
for(ADDR c=0; c<len; c++){
tsh_PatchByte(i+c, replace[c]);
}
}
}
return numpatched;
}
int tsh_PatchAllMatchesHex(ADDR len, char* text, char* replace, bool debugprint) {
char* patt;
char* mask;
tsh_i_PatternTextToCode(text, &patt, &mask);
int res = tsh_PatchAllMatchesCode(len, patt, mask, replace, debugprint);
free(patt);
free(mask);
return res;
}
// Initialization
bool tsh_InitInternal(){
tsh_i_InitScanner();
BlScanFunctionText(tsh_BlPrintf, "8D 44 24 08 33 D2 50 FF 74 24 08 33 C9 E8 ? ? ? ? 83 C4 08 C3");
return true;
}
bool tsh_DeinitInternal() {
return true;
}

122
inc/tsfuncs/BlHooks.hpp Normal file
View File

@@ -0,0 +1,122 @@
//////////////////////////////////////////////////
// RedoBlHooks Version 3.0
#ifndef _H_BLHOOKS
#define _H_BLHOOKS
// Typedefs
typedef unsigned char BYTE;
typedef unsigned int ADDR;
// Prototypes
bool tsh_InitInternal();
bool tsh_DeinitInternal();
ADDR tsh_ScanCode(char*, char*);
ADDR tsh_ScanText(char*);
void tsh_HookFunction(ADDR, ADDR, BYTE*);
void tsh_UnhookFunction(ADDR, BYTE*);
int tsh_PatchAllMatches(unsigned int, char*, char*, char*, bool);
void tsh_PatchByte(ADDR, BYTE);
void tsh_PatchBytes(unsigned int, ADDR, BYTE*);
void tsh_PatchInt(ADDR, int);
// Debug print settings
#ifndef TSH_NO_DEBUG_PRINT
#define tsh_DEBUGPRINT false
#else
#define tsh_DEBUGPRINT true
#endif
// Function short names
// Use in code when the def is not shared in a header
#define BlFunctionDef(returnType, convention, name, ...) \
typedef returnType (convention *tsh_##name##FnT)(__VA_ARGS__); \
tsh_##name##FnT name;
// Use in header for shared function defs when a BlFunctionDefIntern exists in code
#define BlFunctionDefExtern(returnType, convention, name, ...) \
typedef returnType (convention *tsh_##name##FnT)(__VA_ARGS__); \
extern tsh_##name##FnT name;
// Use in code for shared function defs when a BlFunctionDefExtern exists in header
#define BlFunctionDefIntern(name) \
tsh_##name##FnT name;
// Scan for and assign the pattern to the variable, or err and return if not found
#define BlScanFunctionCode(target, patt, mask) \
target = (tsh_##target##FnT)tsh_ScanCode((char*)patt, (char*)mask); \
if(!target){ \
BlPrintf("RedoBlHooks | Cannot find function "#target"!"); \
return false; \
}else{ \
if(tsh_DEBUGPRINT) BlPrintf("RedoBlHooks | Found function "#target" at %08x", (int)target); \
}
#define BlScanFunctionText(target, text) \
target = (tsh_##target##FnT)tsh_ScanText((char*)text); \
if(!target){ \
BlPrintf("RedoBlHooks | Cannot find function "#target"!"); \
return false; \
}else{ \
if(tsh_DEBUGPRINT) BlPrintf("RedoBlHooks | Found function "#target" at %08x", (int)target); \
}
#define BlScanCode(target, patt, mask) \
target = tsh_ScanCode((char*)patt, (char*)mask); \
if(!target){ \
BlPrintf("RedoBlHooks | Cannot find pattern "#target"!"); \
return false; \
}else{ \
if(tsh_DEBUGPRINT) BlPrintf("RedoBlHooks | Found "#target" at %08x", (int)target); \
}
#define BlScanText(target, text) \
target = tsh_ScanText((char*)text); \
if(!target){ \
BlPrintf("RedoBlHooks | Cannot find "#target"!"); \
return false; \
}else{ \
if(tsh_DEBUGPRINT) BlPrintf("RedoBlHooks | Found "#target" at %08x", (int)target); \
}
// Use in code to define the data and functions for hooking a function
#define BlFunctionHookDef(func) \
BYTE tsh_BlFunctionHook##func##Data[6]; \
void func##HookOn(){ tsh_HookFunction((ADDR)func, (ADDR)func##Hook, tsh_BlFunctionHook##func##Data); } \
void func##HookOff(){ tsh_UnhookFunction((ADDR)func, tsh_BlFunctionHook##func##Data); }
// Use in code to initialize the hook once
#define BlFunctionHookInit(func) \
tsh_DeprotectAddress(6, (ADDR)func); \
func##HookOn();
// Replace all matches of the pattern with the given byte string
#define BlPatchAllMatchesCode(len, patt, mask, repl) \
tsh_PatchAllMatchesCode((ADDR)len, (char*)patt, (char*)mask, (char*)repl, tsh_DEBUGPRINT);
#define BlPatchAllMatchesText(len, text, repl) \
tsh_PatchAllMatchesCode((ADDR)len, (char*)text, (char*)repl, tsh_DEBUGPRINT);
// Deprotect and replace one byte
#define BlPatchByte(addr, byte) \
tsh_PatchByte((ADDR)addr, (BYTE)byte);
// Deprotect and replace a byte string
#define BlPatchBytes(len, addr, repl) \
tsh_PatchBytes((ADDR)len, (ADDR)addr, (BYTE*)repl);
// BlPrintf(char* format, ...)
#define BlPrintf(...) if(tsh_BlPrintf) { tsh_BlPrintf(__VA_ARGS__); }
// BlHooksInit() -> bool: success
#define BlHooksInit() if(!tsh_InitInternal()) { BlPrintf("BlHooksInit failed"); return false; }
// BlHooksDeinit() -> bool: success
#define BlHooksDeinit() if(!tsh_DeinitInternal()) { BlPrintf("BlHooksDeinit failed"); return false; }
// Scanned structures
BlFunctionDefExtern(void, , tsh_BlPrintf, const char*, ...);
#endif