static int
anoubisd_msg_eventask_size(const char *buf, int buflen)
{
struct anoubisd_msg_eventask *msg;
struct buf_offset offs[5];
int i, j, total = 0;
DECLARE_SIZE();
CAST(msg, buf, buflen);
/* Detect offset overlaps */
ADDOFFSET(0, csum);
ADDOFFSET(1, path);
ADDOFFSET(2, ctxcsum);
ADDOFFSET(3, ctxpath);
ADDOFFSET(4, ev);
for (i=0; i<5; ++i) {
int s1, e1;
if (offs[i].len == 0)
continue;
s1 = offs[i].off;
e1 = s1 + offs[i].len;
if (e1 > total)
total = e1;
for (j=0; j<i; ++j) {
int s2, e2;
if (offs[j].len == 0)
continue;
s2 = offs[j].off;
e2 = s2 + offs[j].len;
if (s2 < e1 && s1 < e2)
return -1;
}
}
SHIFT_FIELD(msg, payload, buf, buflen);
if (total > buflen)
return -1;
ADD_SIZE(total);
if (msg->pathlen)
CHECK_STRING(buf+msg->pathoff, msg->pathlen);
if (msg->ctxpathlen)
CHECK_STRING(buf+msg->ctxpathoff, msg->ctxpathlen);
if (msg->evlen) {
int size = eventdev_hdr_size(buf+msg->evoff, msg->evlen);
CHECK_SIZE(size);
}
RETURN_SIZE();
}
// Wrapper for realloc. Adds debug info then mimics realloc behavior
void* __wrap_realloc(void* pAllocMem, size_t size)
{
#ifdef MEMPOOL_ENABLED
void* tempPtr;
#endif
#ifndef MEMDEBUG_ENABLED
return REALLOC(pAllocMem,size);
#else
void* pNewAllocMem;
volatile int pReturnFnAddress;
GET_RTNFNADDR;
if (tMemDebug::m_Enabled && ((pAllocMem==0) || tMemDebug::HasDebugInfo(pAllocMem)))
{
if (pAllocMem)
{
tMemDebug::Free(pAllocMem);
pNewAllocMem = REALLOC((void*)SUBOFFSET(pAllocMem),
size+ALLOC_OFFSET);
}
else
pNewAllocMem = MALLOC(size+ALLOC_OFFSET);
if (pNewAllocMem)
{
tMemDebug::Allocate(pNewAllocMem,pReturnFnAddress,size);
tMemDebug::CheckForTrace((char*)"rallc",(void*)ADDOFFSET(pNewAllocMem),
pReturnFnAddress,true);
return ((void*)ADDOFFSET(pNewAllocMem));
}
else
return 0;
}
else
{
pNewAllocMem = REALLOC(pAllocMem, size);
if (pAllocMem) tMemDebug::IncrementAllocStats();
return pNewAllocMem;
}
#endif // MEMDEBUG_ENABLED
}
// Wrapper for calloc. Add debug info, zero the data, then call the real malloc.
void* __wrap_calloc(size_t nmemb, size_t size)
{
#ifndef MEMDEBUG_ENABLED
return CALLOC(nmemb,size);
#else // MEMDEBUG_ENABLED
#ifdef MEMPOOL_ENABLED
void* tempPtr;
#endif
void* pAllocMem;
volatile int pReturnFnAddress;
GET_RTNFNADDR;
if (tMemDebug::m_Enabled)
{
pAllocMem = MALLOC(nmemb*size+ALLOC_OFFSET);
if (pAllocMem)
{
unsigned int i;
char* ptr=(char*)ADDOFFSET(pAllocMem);
// zero out the buffer
for (i=0; i<(nmemb*size); i++)
*ptr++=0;
tMemDebug::Allocate(pAllocMem,pReturnFnAddress,nmemb*size);
tMemDebug::CheckForTrace((char*)"callc",(void*)ADDOFFSET(pAllocMem),
pReturnFnAddress,true);
return ((void*)ADDOFFSET(pAllocMem));
}
else
return 0;
}
else
{
pAllocMem = CALLOC(nmemb,size);
tMemDebug::IncrementAllocStats();
return pAllocMem;
}
#endif // MEMDEBUG_ENABLED
}
// override new operator
void* operator new(unsigned int size)
{
#ifdef MEMPOOL_ENABLED
void* tempPtr;
#endif
#ifndef MEMDEBUG_ENABLED
return MALLOC(size);
#else
void* pAllocMem;
volatile int pReturnFnAddress=0;
GET_RTNFNADDR;
if (tMemDebug::m_Enabled)
{
pAllocMem = MALLOC(size+ALLOC_OFFSET);
if (pAllocMem)
{
tMemDebug::Allocate(pAllocMem,pReturnFnAddress, size);
tMemDebug::CheckForTrace((char*)"new ",(void*)ADDOFFSET(pAllocMem),
pReturnFnAddress,true);
return ((void*)ADDOFFSET(pAllocMem));
}
else
throw std::bad_alloc();
}
else
{
pAllocMem = MALLOC(size);
tMemDebug::IncrementAllocStats();
return pAllocMem;
}
#endif // MEMDEBUG_ENABLED
}
// Wrapper for malloc. Adds debug info and then calls the real malloc
void* __wrap_malloc(size_t size)
{
#ifdef MEMPOOL_ENABLED
void* tempPtr;
#endif
#ifndef MEMDEBUG_ENABLED
return MALLOC(size);
#else // MEMDEBUG_ENABLED
void* pAllocMem;
volatile int pReturnFnAddress;
GET_RTNFNADDR;
if (tMemDebug::m_Enabled)
{
pAllocMem = MALLOC(size+ALLOC_OFFSET);
if (pAllocMem)
{
tMemDebug::Allocate(pAllocMem,pReturnFnAddress,size);
tMemDebug::CheckForTrace((char*)"mallc",(void*)ADDOFFSET(pAllocMem),
pReturnFnAddress,true);
return ((void*)ADDOFFSET(pAllocMem));
}
else
return 0;
}
else
{
pAllocMem = MALLOC(size);
tMemDebug::IncrementAllocStats();
return pAllocMem;
}
#endif // MEMDEBUG_ENABLED
}