324 lines
6.9 KiB
C++
324 lines
6.9 KiB
C++
#include "vcallbuilder.h"
|
|
#include "extension.h"
|
|
|
|
ValveCall::ValveCall()
|
|
{
|
|
call = NULL;
|
|
vparams = NULL;
|
|
retinfo = NULL;
|
|
thisinfo = NULL;
|
|
retbuf = NULL;
|
|
}
|
|
|
|
ValveCall::~ValveCall()
|
|
{
|
|
while (!stk.empty())
|
|
{
|
|
unsigned char *ptr = stk.front();
|
|
delete [] ptr;
|
|
stk.pop();
|
|
}
|
|
if (call)
|
|
{
|
|
call->Destroy();
|
|
}
|
|
delete [] retbuf;
|
|
delete [] vparams;
|
|
}
|
|
|
|
unsigned char *ValveCall::stk_get()
|
|
{
|
|
unsigned char *ptr;
|
|
if (stk.empty())
|
|
{
|
|
ptr = new unsigned char[stackSize];
|
|
} else {
|
|
ptr = stk.front();
|
|
stk.pop();
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
void ValveCall::stk_put(unsigned char *ptr)
|
|
{
|
|
stk.push(ptr);
|
|
}
|
|
|
|
ValveCall *CreateValveCall(void *addr,
|
|
ValveCallType vcalltype,
|
|
const ValvePassInfo *retInfo,
|
|
const ValvePassInfo *params,
|
|
unsigned int numParams)
|
|
{
|
|
if (numParams > 32)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
ValveCall *vc = new ValveCall;
|
|
|
|
size_t size = 0;
|
|
vc->stackSize = 0;
|
|
|
|
/* Get return information - encode only */
|
|
PassInfo retBuf;
|
|
size_t retBufSize = 0;
|
|
bool retbuf_needs_extra;
|
|
if (retInfo)
|
|
{
|
|
if ((size = ValveParamToBinParam(retInfo->vtype, retInfo->type, retInfo->flags, &retBuf, retbuf_needs_extra)) == 0)
|
|
{
|
|
delete vc;
|
|
return NULL;
|
|
}
|
|
retBufSize = retBuf.size;
|
|
if (retbuf_needs_extra)
|
|
{
|
|
retBufSize += size;
|
|
}
|
|
}
|
|
|
|
/* Get thisinfo if needed */
|
|
ValvePassInfo thisbuf;
|
|
ValvePassInfo *thisinfo = NULL;
|
|
CallConvention cv = CallConv_Cdecl;
|
|
if (vcalltype != ValveCall_Static)
|
|
{
|
|
thisinfo = &thisbuf;
|
|
thisinfo->type = PassType_Basic;
|
|
if (vcalltype == ValveCall_Entity)
|
|
{
|
|
thisinfo->vtype = Valve_CBaseEntity;
|
|
thisinfo->decflags |= VDECODE_FLAG_ALLOWWORLD;
|
|
} else if (vcalltype == ValveCall_Player) {
|
|
thisinfo->vtype = Valve_CBasePlayer;
|
|
thisinfo->decflags = 0;
|
|
}
|
|
thisinfo->encflags = 0;
|
|
thisinfo->flags = PASSFLAG_BYVAL;
|
|
thisinfo->offset = 0;
|
|
vc->stackSize += sizeof(void *);
|
|
cv = CallConv_ThisCall;
|
|
}
|
|
|
|
/* Get parameter info */
|
|
PassInfo paramBuf[32];
|
|
size_t sizes[32];
|
|
size_t normSize = 0;
|
|
size_t extraSize = 0;
|
|
for (unsigned int i=0; i<numParams; i++)
|
|
{
|
|
bool needs_extra;
|
|
if ((size = ValveParamToBinParam(params[i].vtype,
|
|
params[i].type,
|
|
params[i].flags,
|
|
¶mBuf[i],
|
|
needs_extra)) == 0)
|
|
{
|
|
delete vc;
|
|
return NULL;
|
|
}
|
|
if (needs_extra)
|
|
{
|
|
sizes[i] = size;
|
|
} else {
|
|
sizes[i] = 0;
|
|
}
|
|
normSize += paramBuf[i].size;
|
|
extraSize += sizes[i];
|
|
}
|
|
|
|
/* Now we can try creating the call */
|
|
if ((vc->call = g_pBinTools->CreateCall(addr,
|
|
cv,
|
|
(retInfo ? &retBuf : NULL),
|
|
paramBuf,
|
|
numParams))
|
|
== NULL)
|
|
{
|
|
if (!vc->call)
|
|
{
|
|
delete vc;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* Allocate extra space for thisptr AND ret buffer, even if we don't use it */
|
|
vc->vparams = new ValvePassInfo[numParams + 2];
|
|
|
|
/* We've got the call and everything is encoded.
|
|
* It's time to save the valve specific information and helper variables.
|
|
*/
|
|
if (retInfo)
|
|
{
|
|
/* Allocate and copy */
|
|
vc->retinfo = &(vc->vparams[numParams]);
|
|
*vc->retinfo = *retInfo;
|
|
vc->retinfo->offset = 0;
|
|
vc->retinfo->obj_offset = retbuf_needs_extra ? sizeof(void *) : 0;
|
|
/* Allocate stack space */
|
|
vc->retbuf = new unsigned char[retBufSize];
|
|
} else {
|
|
vc->retinfo = NULL;
|
|
vc->retbuf = NULL;
|
|
}
|
|
|
|
if (thisinfo)
|
|
{
|
|
/* Allocate and copy */
|
|
vc->thisinfo = &(vc->vparams[numParams + 1]);
|
|
*vc->thisinfo = *thisinfo;
|
|
vc->thisinfo->offset = 0;
|
|
vc->thisinfo->obj_offset = 0;
|
|
} else {
|
|
vc->thisinfo = NULL;
|
|
}
|
|
|
|
/* Now, save info about each parameter. */
|
|
size_t last_extra_offset = 0;
|
|
for (unsigned int i=0; i<numParams; i++)
|
|
{
|
|
/* Copy */
|
|
vc->vparams[i] = params[i];
|
|
vc->vparams[i].offset = vc->call->GetParamInfo(i)->offset;
|
|
vc->vparams[i].obj_offset = last_extra_offset;
|
|
last_extra_offset += sizes[i];
|
|
}
|
|
|
|
vc->stackSize = normSize + extraSize;
|
|
vc->stackEnd = normSize;
|
|
|
|
return vc;
|
|
}
|
|
|
|
ValveCall *CreateValveVCall(unsigned int vtableIdx,
|
|
ValveCallType vcalltype,
|
|
const ValvePassInfo *retInfo,
|
|
const ValvePassInfo *params,
|
|
unsigned int numParams)
|
|
{
|
|
if (numParams > 32)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
ValveCall *vc = new ValveCall;
|
|
|
|
size_t size = 0;
|
|
vc->stackSize = 0;
|
|
|
|
/* Get return information - encode only */
|
|
PassInfo retBuf;
|
|
size_t retBufSize = 0;
|
|
bool retbuf_needs_extra;
|
|
if (retInfo)
|
|
{
|
|
if ((size = ValveParamToBinParam(retInfo->vtype, retInfo->type, retInfo->flags, &retBuf, retbuf_needs_extra)) == 0)
|
|
{
|
|
delete vc;
|
|
return NULL;
|
|
}
|
|
retBufSize = retBuf.size;
|
|
if (retbuf_needs_extra)
|
|
{
|
|
retBufSize += size;
|
|
}
|
|
}
|
|
|
|
/* Get parameter info */
|
|
PassInfo paramBuf[32];
|
|
size_t sizes[32];
|
|
size_t normSize = 0;
|
|
size_t extraSize = 0;
|
|
for (unsigned int i=0; i<numParams; i++)
|
|
{
|
|
bool needs_extra;
|
|
if ((size = ValveParamToBinParam(params[i].vtype,
|
|
params[i].type,
|
|
params[i].flags,
|
|
¶mBuf[i],
|
|
needs_extra)) == 0)
|
|
{
|
|
delete vc;
|
|
return NULL;
|
|
}
|
|
if (needs_extra)
|
|
{
|
|
sizes[i] = size;
|
|
} else {
|
|
sizes[i] = 0;
|
|
}
|
|
normSize += paramBuf[i].size;
|
|
extraSize += sizes[i];
|
|
}
|
|
|
|
/* Now we can try creating the call */
|
|
if ((vc->call = g_pBinTools->CreateVCall(vtableIdx,
|
|
0,
|
|
0,
|
|
(retInfo ? &retBuf : NULL),
|
|
paramBuf,
|
|
numParams))
|
|
== NULL)
|
|
{
|
|
if (!vc->call)
|
|
{
|
|
delete vc;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* Allocate extra space for thisptr AND ret buffer, even if we don't use it */
|
|
vc->vparams = new ValvePassInfo[numParams + 2];
|
|
|
|
/* We've got the call and everything is encoded.
|
|
* It's time to save the valve specific information and helper variables.
|
|
*/
|
|
if (retInfo)
|
|
{
|
|
/* Allocate and copy */
|
|
vc->retinfo = &(vc->vparams[numParams]);
|
|
*vc->retinfo = *retInfo;
|
|
vc->retinfo->offset = 0;
|
|
vc->retinfo->obj_offset = retbuf_needs_extra ? sizeof(void *) : 0;
|
|
/* Allocate stack space */
|
|
vc->retbuf = new unsigned char[retBufSize];
|
|
} else {
|
|
vc->retinfo = NULL;
|
|
vc->retbuf = NULL;
|
|
}
|
|
|
|
/* Save the this info for the dynamic decoder */
|
|
vc->thisinfo = &(vc->vparams[numParams + 1]);
|
|
vc->thisinfo->type = PassType_Basic;
|
|
if (vcalltype == ValveCall_Entity)
|
|
{
|
|
vc->thisinfo->vtype = Valve_CBaseEntity;
|
|
vc->thisinfo->decflags = VDECODE_FLAG_ALLOWWORLD;
|
|
} else if (vcalltype == ValveCall_Player) {
|
|
vc->thisinfo->vtype = Valve_CBasePlayer;
|
|
vc->thisinfo->decflags = 0;
|
|
}
|
|
vc->thisinfo->encflags = 0;
|
|
vc->thisinfo->flags = PASSFLAG_BYVAL;
|
|
vc->thisinfo->offset = 0;
|
|
vc->thisinfo->obj_offset = 0;
|
|
normSize += sizeof(void *);
|
|
|
|
/* Now, save info about each parameter. */
|
|
size_t last_extra_offset = 0;
|
|
for (unsigned int i=0; i<numParams; i++)
|
|
{
|
|
/* Copy */
|
|
vc->vparams[i] = params[i];
|
|
vc->vparams[i].offset = vc->call->GetParamInfo(i)->offset;
|
|
vc->vparams[i].obj_offset = last_extra_offset;
|
|
last_extra_offset += sizes[i];
|
|
}
|
|
|
|
vc->stackSize = normSize + extraSize;
|
|
vc->stackEnd = normSize;
|
|
|
|
return vc;
|
|
}
|