UNLOZE/sm-ext-dhooks2
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update

Browse Source
This commit is contained in:
Dr!fter 2013-08-19 22:33:44 -04:00
parent 2f38de616e
commit 61c887f042
10 changed files with 365 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -19,12 +19,12 @@ MMSOURCE19 = ../mmsource-1.9
### EDIT BELOW FOR OTHER PROJECTS ###
#####################################
PROJECT = sample
PROJECT = dhooks
#Uncomment for Metamod: Source enabled extension
USEMETA = true
OBJECTS = sdk/smsdk_ext.cpp extension.cpp vhook.cpp ../sourcemod-central/public/jit/x86/assembler-x86.cpp
OBJECTS = sdk/smsdk_ext.cpp extension.cpp vhook.cpp $(SMSDK)/public/jit/x86/assembler-x86.cpp listeners.cpp natives.cpp vfunc_call.cpp
##############################################
### CONFIGURE ANY OTHER FLAGS/OPTIONS HERE ###

1
listeners.cpp
View File

@ -53,7 +53,6 @@ void DHooksEntityListener::OnEntityDestroyed(CBaseEntity *pEntity)
DHooksManager *manager = g_pHooks.Element(i);
if(manager->callback->entity == entity)
{
META_CONPRINT("Removing 1\n");
delete manager;
g_pHooks.Remove(i);
}

2
msvc10/sdk.vcxproj
View File

@ -886,6 +886,7 @@
<ClCompile Include="..\extension.cpp" />
<ClCompile Include="..\listeners.cpp" />
<ClCompile Include="..\natives.cpp" />
<ClCompile Include="..\vfunc_call.cpp" />
<ClCompile Include="..\vhook.cpp" />
<ClCompile Include="..\sdk\smsdk_ext.cpp" />
</ItemGroup>
@ -893,6 +894,7 @@
<ClInclude Include="..\extension.h" />
<ClInclude Include="..\listeners.h" />
<ClInclude Include="..\natives.h" />
<ClInclude Include="..\vfunc_call.h" />
<ClInclude Include="..\vhook.h" />
<ClInclude Include="..\sdk\smsdk_config.h" />
<ClInclude Include="..\sdk\smsdk_ext.h" />

4
msvc10/sdk.vcxproj.filters
View File

@ -11,6 +11,7 @@
</ClCompile>
<ClCompile Include="..\natives.cpp" />
<ClCompile Include="..\listeners.cpp" />
<ClCompile Include="..\vfunc_call.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\extension.h">
@ -34,6 +35,9 @@
<ClInclude Include="..\listeners.h">
<Filter>Headers</Filter>
</ClInclude>
<ClInclude Include="..\vfunc_call.h">
<Filter>Headers</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<Filter Include="Headers">

122
natives.cpp
View File

@ -93,9 +93,10 @@ cell_t Native_HookEntity(IPluginContext *pContext, const cell_t *params)
for(int i = g_pHooks.Count() -1; i >= 0; i--)
{
if(g_pHooks.Element(i)->callback->hookType == HookType_Entity && g_pHooks.Element(i)->callback->entity == params[3] && g_pHooks.Element(i)->callback->offset == setup->offset && g_pHooks.Element(i)->callback->post == post && g_pHooks.Element(i)->remove_callback == pContext->GetFunctionById(params[4]) && g_pHooks.Element(i)->callback->plugin_callback == setup->callback)
DHooksManager *manager = g_pHooks.Element(i);
if(manager->callback->hookType == HookType_Entity && manager->callback->entity == params[3] && manager->callback->offset == setup->offset && manager->callback->post == post && manager->remove_callback == pContext->GetFunctionById(params[4]) && manager->callback->plugin_callback == setup->callback)
{
return g_pHooks.Element(i)->hookid;
return manager->hookid;
}
}
CBaseEntity *pEnt = UTIL_GetCBaseEntity(params[3]);
@ -134,7 +135,7 @@ cell_t Native_GetParam(IPluginContext *pContext, const cell_t *params)
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
}
if(params[2] > paramStruct->dg->params.Count() || params[2] < 0)
if(params[2] < 0 || params[2] > paramStruct->dg->params.Count())
{
return pContext->ThrowNativeError("Invalid param number %i max params is %i", params[2], paramStruct->dg->params.Count());
}
@ -170,10 +171,89 @@ cell_t Native_GetParam(IPluginContext *pContext, const cell_t *params)
}
cell_t Native_GetReturn(IPluginContext *pContext, const cell_t *params)
{
if(params[1] == BAD_HANDLE)
{
return pContext->ThrowNativeError("Invalid Handle %i", BAD_HANDLE);
}
HandleError err;
HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
HookReturnStruct *returnStruct;
if((err = handlesys->ReadHandle(params[1], g_HookReturnHandle, &sec, (void **)&returnStruct)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
}
switch(returnStruct->type)
{
case ReturnType_Int:
return *(int *)returnStruct->orgResult;
case ReturnType_Bool:
return *(cell_t *)returnStruct->orgResult;
case ReturnType_CBaseEntity:
return gamehelpers->EntityToBCompatRef((CBaseEntity *)returnStruct->orgResult);
case ReturnType_Edict:
return gamehelpers->IndexOfEdict((edict_t *)returnStruct->orgResult);
case ReturnType_Float:
return sp_ftoc(*(float *)returnStruct->orgResult);
default:
return pContext->ThrowNativeError("Invalid param type (%i) to get",returnStruct->type);
}
return 1;
}
cell_t Native_SetReturn(IPluginContext *pContext, const cell_t *params)
{
if(params[1] == BAD_HANDLE)
{
return pContext->ThrowNativeError("Invalid Handle %i", BAD_HANDLE);
}
HandleError err;
HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
HookReturnStruct *returnStruct;
if((err = handlesys->ReadHandle(params[1], g_HookReturnHandle, &sec, (void **)&returnStruct)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
}
CBaseEntity *pEnt;
edict_t *pEdict;
float *fpVal;
switch(returnStruct->type)
{
case ReturnType_Int:
returnStruct->newResult = (void *)((int)params[2]);
break;
case ReturnType_Bool:
returnStruct->newResult = (void *)(params[2] != 0);
break;
case ReturnType_CBaseEntity:
pEnt = UTIL_GetCBaseEntity(params[2]);
if(!pEnt)
{
return pContext->ThrowNativeError("Invalid entity index passed for return value");
}
returnStruct->newResult = pEnt;
break;
case ReturnType_Edict:
pEdict = gamehelpers->EdictOfIndex(params[2]);
if(!pEdict || pEdict->IsFree())
{
pContext->ThrowNativeError("Invalid entity index passed for return value");
}
returnStruct->newResult = pEdict;
break;
case ReturnType_Float:
fpVal = new float;
*fpVal = sp_ctof(params[2]);
returnStruct->newResult = fpVal;
break;
default:
return pContext->ThrowNativeError("Invalid param type (%i) to get",returnStruct->type);
}
returnStruct->isChanged = true;
return 1;
}
/*cell_t Native_SetParam(IPluginContext *pContext, const cell_t *params);
@ -196,7 +276,7 @@ cell_t Native_GetParamString(IPluginContext *pContext, const cell_t *params)
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
}
if(params[2] > paramStruct->dg->params.Count() || params[2] <= 0)
if(params[2] <= 0 || params[2] > paramStruct->dg->params.Count())
{
return pContext->ThrowNativeError("Invalid param number %i max params is %i", params[2], paramStruct->dg->params.Count());
}
@ -216,8 +296,42 @@ cell_t Native_GetParamString(IPluginContext *pContext, const cell_t *params)
}
//cell_t Native_GetReturnString(IPluginContext *pContext, const cell_t *params);
//cell_t Native_SetReturnString(IPluginContext *pContext, const cell_t *params);
//native DHookSetParamString(Handle:hParams, num, String:value[])
cell_t Native_SetParamString(IPluginContext *pContext, const cell_t *params)
{
if(params[1] == BAD_HANDLE)
{
return pContext->ThrowNativeError("Invalid Handle %i", BAD_HANDLE);
}
HandleError err;
HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());
HookParamsStruct *paramStruct;
if((err = handlesys->ReadHandle(params[1], g_HookParamsHandle, &sec, (void **)&paramStruct)) != HandleError_None)
{
return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);
}
if(params[2] <= 0 || params[2] > paramStruct->dg->params.Count())
{
return pContext->ThrowNativeError("Invalid param number %i max params is %i", params[2], paramStruct->dg->params.Count());
}
int index = params[2] - 1;
char *value;
pContext->LocalToString(params[3], &value);
if(paramStruct->dg->params.Element(index).type == HookParamType_CharPtr)
{
if(paramStruct->newParams[index] != NULL)
delete (char *)paramStruct->newParams[index];
paramStruct->newParams[index] = new char[strlen(value)+1];
strcpy((char *)paramStruct->newParams[index], value);
paramStruct->isChanged[index] = true;
}
return 1;
}

121
vfunc_call.cpp Normal file
View File

@ -0,0 +1,121 @@
#include "vfunc_call.h"
#define PARAMINFO_SWITCH(passType) \
paramInfo[i].flags = dg->params.Element(i).flag; \
paramInfo[i].size = dg->params.Element(i).size; \
paramInfo[i].type = passType;
#define VSTK_PARAM_SWITCH(paramType) \
if(paramStruct->isChanged[i]) \
{ \
*(paramType *)vptr = (paramType)(paramStruct->newParams[i]); \
} \
else \
{ \
*(paramType *)vptr = (paramType)(paramStruct->orgParams[i]); \
} \
if(i + 1 != dg->params.Count()) \
{ \
vptr += dg->params.Element(i).size; \
} \
break;
#define VSTK_PARAM_SWITCH_FLOAT() \
if(paramStruct->isChanged[i]) \
{ \
*(float *)vptr = *(float *)(paramStruct->newParams[i]); \
} \
else \
{ \
*(float *)vptr = *(float *)(paramStruct->orgParams[i]); \
} \
if(i + 1 != dg->params.Count()) \
{ \
vptr += dg->params.Element(i).size; \
} \
break;
void *CallVFunction(DHooksCallback *dg, HookParamsStruct *paramStruct, void *iface)
{
PassInfo *paramInfo = NULL;
PassInfo returnInfo;
if(dg->returnType != ReturnType_Void)
{
returnInfo.flags = dg->returnFlag;
returnInfo.size = sizeof(void *);
returnInfo.type = PassType_Basic;
}
ICallWrapper *pCall;
size_t size = GetStackArgsSize(dg);
unsigned char *vstk = (unsigned char *)malloc(sizeof(void *) + size);
unsigned char *vptr = vstk;
*(void **)vptr = iface;
if(paramStruct)
{
vptr += sizeof(void *);
paramInfo = (PassInfo *)malloc(sizeof(PassInfo) * dg->params.Count());
for(int i = 0; i < dg->params.Count(); i++)
{
switch(dg->params.Element(i).type)
{
case HookParamType_Int:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(int);
case HookParamType_Bool:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(cell_t);
case HookParamType_Float:
PARAMINFO_SWITCH(PassType_Float);
VSTK_PARAM_SWITCH_FLOAT();
case HookParamType_String:
PARAMINFO_SWITCH(PassType_Object);
VSTK_PARAM_SWITCH(int);
case HookParamType_StringPtr:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(string_t *);
case HookParamType_CharPtr:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(char *);
case HookParamType_VectorPtr:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(Vector *);
case HookParamType_CBaseEntity:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(CBaseEntity *);
case HookParamType_Edict:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(edict_t *);
default:
PARAMINFO_SWITCH(PassType_Basic);
VSTK_PARAM_SWITCH(void *);
}
}
}
void *ret = 0;
if(dg->returnType == ReturnType_Void)
{
pCall = g_pBinTools->CreateVCall(dg->offset, 0, 0, NULL, paramInfo, dg->params.Count());
pCall->Execute(vstk, NULL);
}
else
{
pCall = g_pBinTools->CreateVCall(dg->offset, 0, 0, &returnInfo, paramInfo, dg->params.Count());
pCall->Execute(vstk, &ret);
}
pCall->Destroy();
free(vstk);
if(paramInfo != NULL)
{
free(paramInfo);
}
return ret;
}

7
vfunc_call.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef _INCLUDE_VFUNC_CALL_H_
#define _INCLUDE_VFUNC_CALL_H_
#include "vhook.h"
void *CallVFunction(DHooksCallback *dg, HookParamsStruct *paramStruct, void *iface);
#endif

106
vhook.cpp
View File

@ -1,4 +1,5 @@
#include "vhook.h"
#include "vfunc_call.h"
SourceHook::IHookManagerAutoGen *g_pHookManager = NULL;
@ -39,13 +40,9 @@ DHooksManager::DHooksManager(HookSetup *setup, void *iface, IPluginFunction *rem
{
protoInfo.SetReturnType(0, SourceHook::PassInfo::PassType_Unknown, 0, NULL, NULL, NULL, NULL);
}
else if(this->callback->returnType == ReturnType_Float)
{
protoInfo.SetReturnType(sizeof(float), SourceHook::PassInfo::PassType_Float, 0, NULL, NULL, NULL, NULL);
}
else
{
protoInfo.SetReturnType(sizeof(void *), SourceHook::PassInfo::PassType_Basic, 0, NULL, NULL, NULL, NULL);
protoInfo.SetReturnType(sizeof(void *), SourceHook::PassInfo::PassType_Basic, setup->returnFlag, NULL, NULL, NULL, NULL);
}
HookManagerPubFunc hook = g_pHookManager->MakeHookMan(protoInfo, 0, this->callback->offset);
@ -82,10 +79,9 @@ SourceHook::PassInfo::PassType GetParamTypePassType(HookParamType type)
switch(type)
{
case HookParamType_Float:
return SourceHook::PassInfo::PassType::PassType_Float;
default:
return SourceHook::PassInfo::PassType::PassType_Basic;
return SourceHook::PassInfo::PassType_Float;
}
return SourceHook::PassInfo::PassType_Basic;
}
size_t GetStackArgsSize(DHooksCallback *dg)
{
@ -102,10 +98,12 @@ HookParamsStruct *GetParamStruct(DHooksCallback *dg, void **argStack, size_t arg
res->dg = dg;
res->orgParams = (void **)malloc(argStackSize);
res->newParams = (void **)malloc(argStackSize);
res->isChanged = (bool *)malloc(dg->params.Count() * sizeof(bool));
memcpy(res->orgParams, argStack, argStackSize);
for(int i = 0; i < dg->params.Count(); i++)
{
res->newParams[i] = NULL;
res->isChanged[i] = false;
}
return res;
}
@ -114,8 +112,32 @@ HookReturnStruct *GetReturnStruct(DHooksCallback *dg, const void *result)
HookReturnStruct *res = new HookReturnStruct();
res->isChanged = false;
res->type = dg->returnType;
res->orgResult = &result;
res->newResult = 0;
res->newResult = NULL;
float *fpVal = NULL;
if(result && dg->post)
{
switch(dg->returnType)
{
//ReturnType_String,
//ReturnType_Vector,
case ReturnType_Int:
case ReturnType_Bool:
res->orgResult = (int *)result;
break;
case ReturnType_Float:
res->orgResult = new float;
*fpVal = *(float *)result;
res->orgResult = fpVal;
default:
res->orgResult = (void *)result;
}
}
else
{
res->orgResult = NULL;
}
return res;
}
@ -128,15 +150,23 @@ cell_t GetThisPtr(void *iface, ThisPointerType type)
return (cell_t)iface;
}
#ifndef __linux__
void *Callback(DHooksCallback *dg, void **argStack, size_t *argsizep)
#else
void *Callback(DHooksCallback *dg, void **argStack)
#endif
{
HookReturnStruct *returnStruct = NULL;
HookParamsStruct *paramStruct = NULL;
Handle_t rHndl;
Handle_t pHndl;
#ifndef __linux__
*argsizep = GetStackArgsSize(dg);
#else
size_t argsize = GetStackArgsSize(dg);
#endif
if(dg->thisType == ThisPointer_CBaseEntity || dg->thisType == ThisPointer_Address)
{
@ -157,9 +187,16 @@ void *Callback(DHooksCallback *dg, void **argStack, size_t *argsizep)
}
dg->plugin_callback->PushCell(rHndl);
}
#ifndef __linux__
if(*argsizep > 0)
{
paramStruct = GetParamStruct(dg, argStack, *argsizep);
#else
if(argsize > 0)
{
paramStruct = GetParamStruct(dg, argStack, argsize);
#endif
pHndl = handlesys->CreateHandle(g_HookParamsHandle, paramStruct, dg->plugin_callback->GetParentRuntime()->GetDefaultContext()->GetIdentity(), myself->GetIdentity(), NULL);
if(!pHndl)
{
@ -180,32 +217,24 @@ void *Callback(DHooksCallback *dg, void **argStack, size_t *argsizep)
dg->plugin_callback->Execute(&result);
void *ret = g_SHPtr->GetOverrideRetPtr();
void *res = 0;
ret = 0;
switch((MRESReturn)result)
{
case MRES_Handled:
case MRES_ChangedHandled:
g_SHPtr->DoRecall();
g_SHPtr->SetRes(MRES_SUPERCEDE);
//ret = CallVFunction(dg, argStack, g_SHPtr->GetIfacePtr());
memcpy(res, ret, sizeof(void *));
ret = CallVFunction(dg, paramStruct, g_SHPtr->GetIfacePtr());
break;
case MRES_ChangedOverride:
g_SHPtr->DoRecall();
g_SHPtr->SetRes(MRES_SUPERCEDE);
//CallVFunction(dg, argStack, g_SHPtr->GetIfacePtr());
ret = CallVFunction(dg, paramStruct, g_SHPtr->GetIfacePtr());
if(dg->returnType != ReturnType_Void)
{
if(returnStruct->isChanged)
{
memcpy(ret, returnStruct->newResult, sizeof(void *));
memcpy(res, returnStruct->newResult, sizeof(void *));
}
else if(dg->post)
{
memcpy(ret, returnStruct->orgResult, sizeof(void *));
memcpy(res, returnStruct->orgResult, sizeof(void *));
ret = returnStruct->newResult;
}
}
break;
@ -215,13 +244,11 @@ void *Callback(DHooksCallback *dg, void **argStack, size_t *argsizep)
{
if(returnStruct->isChanged)
{
memcpy(ret, returnStruct->newResult, sizeof(void *));
memcpy(res, returnStruct->newResult, sizeof(void *));
ret = returnStruct->newResult;
}
else if(dg->post)
{
memcpy(ret, returnStruct->orgResult, sizeof(void *));
memcpy(res, returnStruct->orgResult, sizeof(void *));
ret = (void *)returnStruct->orgResult;
}
}
break;
@ -231,13 +258,11 @@ void *Callback(DHooksCallback *dg, void **argStack, size_t *argsizep)
{
if(returnStruct->isChanged)
{
memcpy(ret, returnStruct->newResult, sizeof(void *));
memcpy(res, returnStruct->newResult, sizeof(void *));
ret = returnStruct->newResult;
}
else if(dg->post)
{
memcpy(ret, returnStruct->orgResult, sizeof(void *));
memcpy(res, returnStruct->orgResult, sizeof(void *));
ret = returnStruct->orgResult;
}
}
break;
@ -257,24 +282,5 @@ void *Callback(DHooksCallback *dg, void **argStack, size_t *argsizep)
handlesys->FreeHandle(pHndl, &sec);
}
return res;
return ret;
}
#else
void *Callback(DHooksCallback *dg, void **argStack)
{
if(dg->returnType == ReturnType_Void)
{
META_CONPRINTF("String is %s\n", argStack[0]);
g_SHPtr->SetRes(MRES_IGNORED);
}
else
{
//META_CONPRINTF("Entity %i\n", gamehelpers->ReferenceToIndex(gamehelpers->EntityToBCompatRef((CBaseEntity *)g_SHPtr->GetIfacePtr())));
g_SHPtr->SetRes(MRES_SUPERCEDE);
void *ret = g_SHPtr->GetOverrideRetPtr();
ret = (void *)false;
return false;
}
return 0;
}
#endif

57
vhook.h
View File

@ -68,8 +68,32 @@ struct ParamInfo
SourceHook::PassInfo::PassType pass_type;
};
struct HookReturnStruct
class HookReturnStruct
{
public:
~HookReturnStruct()
{
if(this->isChanged && this->newResult)
{
if(this->type == ReturnType_CharPtr)
{
delete (char *)this->newResult;
}
else if(this->type == ReturnType_VectorPtr)
{
delete (Vector *)this->newResult;
}
else if(this->type == ReturnType_Float)
{
if(this->orgResult)
{
free(this->orgResult);
}
free(this->newResult);
}
}
}
public:
ReturnType type;
bool isChanged;
void *orgResult;
@ -129,9 +153,9 @@ static void *GenerateThunk(ReturnType type)
masm.lea(eax, Operand(ebp, 12));
masm.push(eax);
masm.push(Operand(ebp, 8));
if(type == ReturnType_Float)
/*if(type == ReturnType_Float)
masm.call(ExternalAddress((void *)Callback_float));
else
else*/
masm.call(ExternalAddress((void *)Callback));
masm.addl(esp, 8);
masm.pop(ebp);
@ -191,22 +215,41 @@ public:
this->orgParams = NULL;
this->newParams = NULL;
this->dg = NULL;
this->isChanged = NULL;
}
~HookParamsStruct()
{
if(this->orgParams != NULL)
{
delete this->orgParams;
free(this->orgParams);
}
if(this->isChanged != NULL)
{
free(this->isChanged);
}
if(this->newParams != NULL)
{
delete this->newParams;
for(int i = dg->params.Count() - 1; i >= 0 ; i--)
{
if(this->newParams[i] == NULL)
continue;
if(dg->params.Element(i).type == HookParamType_VectorPtr)
{
delete (Vector *)this->newParams[i];
}
else if(dg->params.Element(i).type == HookParamType_CharPtr)
{
delete (char *)this->newParams[i];
}
}
free(this->newParams);
}
}
public:
//CUtlVector<int> cleanup;
void **orgParams;
void **newParams;
bool *isChanged;
DHooksCallback *dg;
};
@ -255,6 +298,8 @@ public:
IPluginFunction *remove_callback;
};
size_t GetStackArgsSize(DHooksCallback *dg);
extern IBinTools *g_pBinTools;
extern HandleType_t g_HookParamsHandle;
extern HandleType_t g_HookReturnHandle;

0
vhook_macros.h
View File