reHLDS/ReGameDLL_CS
2
0
Fork 0
mirror of https://github.com/s1lentq/ReGameDLL_CS.git synced 2024-12-27 23:25:41 +03:00
Code Issues Packages Projects Releases Wiki Activity
27424741a0
ReGameDLL_CS/regamedll/testsuite/funccalls.cpp
s1lentq 56c2cb635f Added initial files project
2015-06-30 15:46:07 +06:00

3289 lines
94 KiB
C++
Raw Blame History

#include "precompiled.h"
void PrintSystemTime(LPSYSTEMTIME t, std::stringstream &ss)
{
ss << "{"
<< " Year: " << t->wYear
<< " Month: " << t->wMonth
<< " Day: " << t->wDay
<< " DayOfWeek: " << t->wDayOfWeek
<< " Hour: " << t->wHour
<< " Month: " << t->wMonth
<< " Second: " << t->wSecond
<< " Millisecond: " << t->wMilliseconds
<< " }";
}
void PrintFileTime(LPFILETIME t, std::stringstream &ss)
{
ss << "{"
<< " highDate: " << t->dwHighDateTime
<< " lowDate: " << t->dwLowDateTime
<< " }";
}
void PrintTm(struct tm* t, std::stringstream &ss) {
ss << "{"
<< " tm_year: " << t->tm_year
<< " tm_mon: " << t->tm_mon
<< " tm_yday: " << t->tm_yday
<< " tm_wday: " << t->tm_wday
<< " tm_mday: " << t->tm_mday
<< " tm_isdst: " << t->tm_isdst
<< " tm_hour: " << t->tm_hour
<< " tm_min: " << t->tm_min
<< " tm_sec: " << t->tm_sec
<< " }";
}
void PrintBinaryArray(const char* data, int dataLen, std::stringstream &ss)
{
ss << "[";
for (int i = 0; i < dataLen; i++)
ss << " " << (unsigned int) (unsigned char)data[i];
ss << "]";
}
void IEngExtCall::ensureArgsAreEqual(IEngExtCall* expect, bool strict, const char* callSource) {
if (compareInputArgs(expect, strict)) return;
std::string expectedSignature = expect->toString();
std::string mySignature = toString();
regamedll_syserror("%s: call arguments mismatch; expected signature:\n%s\n\ncurrent signature:\n%s", callSource, expectedSignature.c_str(), mySignature.c_str());
}
bool CompareSockAddrs(void* ps1, void* ps2) {
sockaddr* sa1 = (sockaddr*)ps1;
sockaddr* sa2 = (sockaddr*)ps2;
if (sa1->sa_family != sa2->sa_family)
return false;
int compareSize = 0;
switch (sa1->sa_family) {
case AF_INET:
compareSize = 8; // sa_family(2) + sin_addr(4) + sin_port(2)
break;
default:
regamedll_syserror("%s: Unknown sockaddr family %u", __FUNCTION__, sa1->sa_family);
}
return 0 == memcmp(ps1, ps2, compareSize);
}
/* ============================================================================
CSleepExtCall
============================================================================ */
CSleepExtCall::CSleepExtCall(DWORD time)
{
m_Time = time;
}
std::string CSleepExtCall::toString()
{
std::stringstream ss;
ss << "Sleep(" << m_Time << ")";
return ss.str();
}
bool CSleepExtCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSleepExtCall* otherSleep = dynamic_cast<CSleepExtCall*>(other);
if (otherSleep == NULL)
return false;
return otherSleep->m_Time == this->m_Time;
}
void CSleepExtCall::writePrologue(std::ostream &stream)
{
stream.write((char*)&m_Time, 4);
}
void CSleepExtCall::readPrologue(std::istream &stream)
{
stream.read((char*)&m_Time, 4);
}
/* ============================================================================
CQueryPerfFreqCall
============================================================================ */
std::string CQueryPerfFreqCall::toString()
{
LARGE_INTEGER li;
li.QuadPart = m_Freq;
std::stringstream ss;
ss << "QueryPerformanceFrequency(freq = { LowPart: " << li.LowPart << "; HighPart: " << li.HighPart << ") => " << m_Res;
return ss.str();
}
bool CQueryPerfFreqCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CQueryPerfFreqCall* otherPerfFreq = dynamic_cast<CQueryPerfFreqCall*>(other);
if (otherPerfFreq == NULL)
return false;
return true;
}
void CQueryPerfFreqCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Freq, 8).write((char*)&m_Res, 1);
}
void CQueryPerfFreqCall::readEpilogue(std::istream &stream) {
m_Res = 0;
stream.read((char*)&m_Freq, 8).read((char*)&m_Res, 1);
}
/* ============================================================================
CQueryPerfCounterCall
============================================================================ */
std::string CQueryPerfCounterCall::toString()
{
LARGE_INTEGER li;
li.QuadPart = m_Counter;
std::stringstream ss;
ss << "QueryPerformanceCounter(counter = { LowPart: " << li.LowPart << "; HighPart: " << li.HighPart << ") => " << m_Res;
return ss.str();
}
bool CQueryPerfCounterCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CQueryPerfCounterCall* otherPerfFreq = dynamic_cast<CQueryPerfCounterCall*>(other);
if (otherPerfFreq == NULL)
return false;
return true;
}
void CQueryPerfCounterCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Counter, 8).write((char*)&m_Res, 1);
}
void CQueryPerfCounterCall::readEpilogue(std::istream &stream) {
m_Res = 0;
stream.read((char*)&m_Counter, 8).read((char*)&m_Res, 1);
}
/* ============================================================================
CGetTickCountCall
============================================================================ */
std::string CGetTickCountCall::toString()
{
std::stringstream ss;
ss << "GetTickCount() => " << m_Res;
return ss.str();
}
bool CGetTickCountCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetTickCountCall* otherCall = dynamic_cast<CGetTickCountCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGetTickCountCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CGetTickCountCall::readEpilogue(std::istream &stream) {
m_Res = 0;
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CGetTickCountCall
============================================================================ */
std::string CGetLocalTimeCall::toString()
{
std::stringstream ss;
ss << "GetLocalTime() => ";
PrintSystemTime(&m_Res, ss);
return ss.str();
}
bool CGetLocalTimeCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetLocalTimeCall* otherCall = dynamic_cast<CGetLocalTimeCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGetLocalTimeCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, sizeof(m_Res));
}
void CGetLocalTimeCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, sizeof(m_Res));
}
/* ============================================================================
CGetSystemTimeCall
============================================================================ */
std::string CGetSystemTimeCall::toString()
{
std::stringstream ss;
ss << "GetSystemTime() => ";
PrintSystemTime(&m_Res, ss);
return ss.str();
}
bool CGetSystemTimeCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetSystemTimeCall* otherCall = dynamic_cast<CGetSystemTimeCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGetSystemTimeCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, sizeof(m_Res));
}
void CGetSystemTimeCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, sizeof(m_Res));
}
/* ============================================================================
CGetTimeZoneInfoCall
============================================================================ */
std::string CGetTimeZoneInfoCall::toString()
{
std::stringstream ss;
ss << "GetTimeZoneInfo() => {"
<< " Bias: " << m_Res.Bias
<< " StandardName: " << m_Res.StandardName
<< " StandardDate: "; PrintSystemTime(&m_Res.StandardDate, ss);
ss << " StandardBias: " << m_Res.StandardBias
<< " DaylightName: " << m_Res.DaylightName
<< " DaylightDate: "; PrintSystemTime(&m_Res.DaylightDate, ss);
ss << " DaylightBias: " << m_Res.DaylightBias
<< " }";
return ss.str();
}
bool CGetTimeZoneInfoCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetTimeZoneInfoCall* otherCall = dynamic_cast<CGetTimeZoneInfoCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGetTimeZoneInfoCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, sizeof(m_Res));
}
void CGetTimeZoneInfoCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, sizeof(m_Res));
}
/* ============================================================================
CSocketCall
============================================================================ */
CSocketCall::CSocketCall(int af, int type, int protocol)
{
m_Af = af;
m_Type = type;
m_Protocol = protocol;
m_Res = INVALID_SOCKET;
}
std::string CSocketCall::toString()
{
std::stringstream ss;
ss << "socket(af: " << m_Af << "; type: " << m_Type << "; protocol: " << m_Protocol << ") => " << m_Res;
return ss.str();
}
bool CSocketCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSocketCall* otherCall = dynamic_cast<CSocketCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Af != m_Af)
return false;
if (otherCall->m_Type != m_Type)
return false;
if (otherCall->m_Protocol != m_Protocol)
return false;
return true;
}
void CSocketCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Af, 4).write((char*)&m_Type, 4).write((char*)&m_Protocol, 4);
}
void CSocketCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CSocketCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_Af, 4).read((char*)&m_Type, 4).read((char*)&m_Protocol, 4);
}
void CSocketCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CIoCtlSocketCall
============================================================================ */
CIoCtlSocketCall::CIoCtlSocketCall(SOCKET s, long cmd, u_long inValue)
{
m_Socket = s;
m_Cmd = cmd;
m_InValue = inValue;
m_OutValue = 0; m_Res = 0;
}
std::string CIoCtlSocketCall::toString()
{
std::stringstream ss;
ss << "ioctlsocket(s: " << m_Socket << "; cmd: " << m_Cmd << "; val: { in: " << m_InValue << "; out: " << m_OutValue << " }) => " << m_Res;
return ss.str();
}
bool CIoCtlSocketCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CIoCtlSocketCall* otherCall = dynamic_cast<CIoCtlSocketCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Socket != m_Socket)
return false;
if (otherCall->m_Cmd != m_Cmd)
return false;
if (otherCall->m_InValue != m_InValue)
return false;
return true;
}
void CIoCtlSocketCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_Socket, 4)
.write((char*)&m_Cmd, 4)
.write((char*)&m_InValue, 4);
}
void CIoCtlSocketCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_OutValue, 4)
.write((char*)&m_Res, 4);
}
void CIoCtlSocketCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_Socket, 4)
.read((char*)&m_Cmd, 4)
.read((char*)&m_InValue, 4);
}
void CIoCtlSocketCall::readEpilogue(std::istream &stream) {
stream
.read((char*)&m_OutValue, 4)
.read((char*)&m_Res, 4);
}
/* ============================================================================
CSetSockOptCall
============================================================================ */
CSetSockOptCall::CSetSockOptCall(SOCKET s, int level, int optname, const char* optval, int optlen)
{
if (optlen > sizeof(m_OptVal))
regamedll_syserror("CSetSockOptCall(): too large optlen (%d max %d)", optlen, sizeof(m_OptVal));
m_Socket = s;
m_Level = level;
m_OptName = optname;
m_OptValLen = optlen;
memcpy(m_OptVal, optval, m_OptValLen);
m_Res = 0;
}
std::string CSetSockOptCall::toString()
{
std::stringstream ss;
ss << "setsockopt(s: " << m_Socket << "; level: " << m_Level << "; optName: " << m_OptName << "; optVal: ";
PrintBinaryArray(m_OptVal, m_OptValLen, ss);
ss << "; optLen: " << m_OptValLen << " ) => " << m_Res;
return ss.str();
}
bool CSetSockOptCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSetSockOptCall* otherCall = dynamic_cast<CSetSockOptCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Socket != m_Socket)
return false;
if (otherCall->m_Level != m_Level)
return false;
if (otherCall->m_OptName != m_OptName)
return false;
if (otherCall->m_OptValLen != m_OptValLen)
return false;
if (memcmp(otherCall->m_OptVal, m_OptVal, m_OptValLen))
return false;
return true;
}
void CSetSockOptCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_Socket, 4)
.write((char*)&m_Level, 4)
.write((char*)&m_OptName, 4)
.write((char*)&m_OptValLen, 4)
.write(m_OptVal, m_OptValLen);
}
void CSetSockOptCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CSetSockOptCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_Socket, 4)
.read((char*)&m_Level, 4)
.read((char*)&m_OptName, 4)
.read((char*)&m_OptValLen, 4);
stream.read(m_OptVal, m_OptValLen);
}
void CSetSockOptCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CCloseSocketCall
============================================================================ */
CCloseSocketCall::CCloseSocketCall(SOCKET s)
{
m_Socket = s;
m_Res = 0;
}
std::string CCloseSocketCall::toString()
{
std::stringstream ss;
ss << "closesocket(s: " << m_Socket << " ) => " << m_Res;
return ss.str();
}
bool CCloseSocketCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CCloseSocketCall* otherCall = dynamic_cast<CCloseSocketCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Socket != m_Socket)
return false;
return true;
}
void CCloseSocketCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Socket, 4);
}
void CCloseSocketCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CCloseSocketCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_Socket, 4);
}
void CCloseSocketCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CRecvFromCall
============================================================================ */
CRecvFromCall::CRecvFromCall(SOCKET s, int len, int flags, int fromlen)
{
m_Socket = s;
m_Len = len;
m_Flags = flags;
m_FromLenIn = fromlen;
m_FromLenOut = 0; m_Res = -1;
}
std::string CRecvFromCall::toString()
{
std::stringstream ss;
ss << "recvfrom(s: " << m_Socket << "; data: ";
PrintBinaryArray(m_Data, m_Res, ss);
ss << "; len: " << m_Len << "; flags: " << m_Flags << "; from: ";
PrintBinaryArray(m_From, m_FromLenOut, ss);
ss << "; fromlen: { in: " << m_FromLenIn << "; out: " << m_FromLenOut << " } ) => " << m_Res;
return ss.str();
}
bool CRecvFromCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CRecvFromCall* otherCall = dynamic_cast<CRecvFromCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Socket != m_Socket)
return false;
if (otherCall->m_Len != m_Len)
return false;
if (otherCall->m_Flags != m_Flags)
return false;
if (otherCall->m_FromLenIn != m_FromLenIn)
return false;
return true;
}
void CRecvFromCall::setResult(const void* data, const void* from, int fromLen, int res)
{
if (res > 0 && res > sizeof(m_Data))
regamedll_syserror("%s: too large datalen (%d max %d)", __FUNCTION__, res, sizeof(m_Data));
if (fromLen > sizeof(m_From))
regamedll_syserror("%s: too large fromlen (%d max %d)", __FUNCTION__, res, sizeof(m_From));
m_FromLenOut = fromLen;
m_Res = res;
if (res > 0)
memcpy(m_Data, data, res);
if (fromLen > 0)
memcpy(m_From, from, fromLen);
}
void CRecvFromCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_Socket, 4)
.write((char*)&m_Len, 4)
.write((char*)&m_Flags, 4)
.write((char*)&m_FromLenIn, 4);
}
void CRecvFromCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_FromLenOut, 4)
.write((char*)&m_Res, 4)
.write((char*)&m_From, (m_FromLenOut > 0 && m_Res >= 0) ? m_FromLenOut : 0)
.write((char*)&m_Data, (m_Res > 0) ? m_Res : 0);
}
void CRecvFromCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_Socket, 4)
.read((char*)&m_Len, 4)
.read((char*)&m_Flags, 4)
.read((char*)&m_FromLenIn, 4);
}
void CRecvFromCall::readEpilogue(std::istream &stream) {
stream
.read((char*)&m_FromLenOut, 4)
.read((char*)&m_Res, 4);
stream.read((char*)&m_From, (m_FromLenOut > 0 && m_Res >= 0) ? m_FromLenOut : 0)
.read((char*)&m_Data, (m_Res > 0) ? m_Res : 0);
}
/* ============================================================================
CSendToCall
============================================================================ */
CSendToCall::CSendToCall(SOCKET s, const void* buf, int len, int flags, const void* to, int tolen)
{
if (len > sizeof(m_Data))
regamedll_syserror("%s: too large datalen (%d max %d)", __FUNCTION__, len, sizeof(m_Data));
if (tolen > sizeof(m_To))
regamedll_syserror("%s: too large tolen (%d max %d)", __FUNCTION__, tolen, sizeof(m_To));
m_Socket = s;
m_Len = len;
m_Flags = flags;
m_ToLen = tolen;
memcpy(m_To, to, m_ToLen);
memcpy(m_Data, buf, m_Len);
m_Res = 0;
}
std::string CSendToCall::toString()
{
std::stringstream ss;
ss << "sendto(s: " << m_Socket << "; data: ";
PrintBinaryArray(m_Data, m_Len, ss);
ss << "; len: " << m_Len << "; flags: " << m_Flags << "; to: ";
PrintBinaryArray(m_To, m_ToLen, ss);
ss << "; tolen: " << m_ToLen << " ) => " << m_Res;
return ss.str();
}
bool CSendToCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSendToCall* otherCall = dynamic_cast<CSendToCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Socket != m_Socket)
return false;
if (strict) {
if (otherCall->m_Len != m_Len)
return false;
} else {
int maxDiff;
if (m_Len < 40) {
maxDiff = 10;
} else if (m_Len < 90) {
maxDiff = 15;
} else if (m_Len < 120) {
maxDiff = 18;
} else {
maxDiff = m_Len / 8;
}
if (abs(otherCall->m_Len - m_Len) > maxDiff)
return false;
}
if (otherCall->m_Flags != m_Flags)
return false;
if (otherCall->m_ToLen != m_ToLen)
return false;
if (strict) {
if (memcmp(otherCall->m_Data, m_Data, m_Len))
return false;
}
if (!CompareSockAddrs(otherCall->m_To, m_To))
return false;
return true;
}
void CSendToCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_Socket, 4)
.write((char*)&m_Len, 4)
.write((char*)&m_Flags, 4)
.write((char*)&m_ToLen, 4)
.write((char*)&m_To, m_ToLen)
.write((char*)&m_Data, m_Len);
}
void CSendToCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CSendToCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_Socket, 4)
.read((char*)&m_Len, 4)
.read((char*)&m_Flags, 4)
.read((char*)&m_ToLen, 4);
stream.read((char*)&m_To, m_ToLen)
.read((char*)&m_Data, m_Len);
}
void CSendToCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CBindCall
============================================================================ */
CBindCall::CBindCall(SOCKET s, const void* addr, int addrlen)
{
if (addrlen > sizeof(m_Addr))
regamedll_syserror("%s: too large tolen (%d max %d)", __FUNCTION__, addrlen, sizeof(m_Addr));
m_Socket = s;
m_AddrLen = addrlen;
memcpy(m_Addr, addr, addrlen);
m_Res = 0;
}
std::string CBindCall::toString()
{
std::stringstream ss;
ss << "bind(s: " << m_Socket << "; addr: ";
PrintBinaryArray(m_Addr, m_AddrLen, ss);
ss << "; addrlen: " << m_AddrLen << " ) => " << m_Res;
return ss.str();
}
bool CBindCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CBindCall* otherCall = dynamic_cast<CBindCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Socket != m_Socket)
return false;
if (otherCall->m_AddrLen != m_AddrLen)
return false;
if (!CompareSockAddrs(otherCall->m_Addr, m_Addr))
return false;
return true;
}
void CBindCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_Socket, 4)
.write((char*)&m_AddrLen, 4)
.write((char*)&m_Addr, m_AddrLen);
}
void CBindCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CBindCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_Socket, 4)
.read((char*)&m_AddrLen, 4);
stream.read((char*)&m_Addr, m_AddrLen);
}
void CBindCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CGetSockNameCall
============================================================================ */
CGetSockNameCall::CGetSockNameCall(SOCKET s, int addrlen)
{
m_Socket = s;
m_AddrLenIn = addrlen;
m_AddrLenOut = m_Res = 0;
}
std::string CGetSockNameCall::toString()
{
std::stringstream ss;
ss << "getsockname(s: " << m_Socket << "; addr: ";
PrintBinaryArray(m_Addr, m_AddrLenOut, ss);
ss << "; addrlen: { in: " << m_AddrLenIn << "; out: " << m_AddrLenOut << " } ) = > " << m_Res;
return ss.str();
}
void CGetSockNameCall::setResult(const void* addr, int addrlen, int res)
{
if (addrlen > sizeof(m_Addr))
regamedll_syserror("%s: too large tolen (%d max %d)", __FUNCTION__, addrlen, sizeof(m_Addr));
m_Res = res;
m_AddrLenOut = addrlen;
memcpy(m_Addr, addr, addrlen);
}
bool CGetSockNameCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetSockNameCall* otherCall = dynamic_cast<CGetSockNameCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Socket != m_Socket)
return false;
if (otherCall->m_AddrLenIn != m_AddrLenIn)
return false;
return true;
}
void CGetSockNameCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_Socket, 4)
.write((char*)&m_AddrLenIn, 4);
}
void CGetSockNameCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_AddrLenOut, 4)
.write((char*)&m_Res, 4)
.write((char*)&m_Addr, m_AddrLenOut);
}
void CGetSockNameCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_Socket, 4)
.read((char*)&m_AddrLenIn, 4);
}
void CGetSockNameCall::readEpilogue(std::istream &stream) {
stream
.read((char*)&m_AddrLenOut, 4)
.read((char*)&m_Res, 4);
stream.read((char*)&m_Addr, m_AddrLenOut);
}
/* ============================================================================
CWSAGetLastErrorCall
============================================================================ */
std::string CWSAGetLastErrorCall::toString()
{
std::stringstream ss;
ss << "WSAGetLastError() = > " << m_Res;
return ss.str();
}
bool CWSAGetLastErrorCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CWSAGetLastErrorCall* otherCall = (CWSAGetLastErrorCall*)other;
if (otherCall == NULL)
return false;
return true;
}
void CWSAGetLastErrorCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CWSAGetLastErrorCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CSteamCallbackCall1
============================================================================ */
CSteamCallbackCall1::CSteamCallbackCall1(int cbId, void* data, int dataSize, CCallbackBase* cb)
{
if (dataSize > sizeof(m_Data))
regamedll_syserror("%s: too large data (%d, max %d)", __FUNCTION__, dataSize, sizeof(m_Data));
m_CallbackId = cbId;
m_DataSize = dataSize;
memcpy(m_Data, data, dataSize);
m_InState.m_iCallback = cb->GetICallback();
m_InState.m_nCallbackFlags = cb->GetFlags();
m_OutState.clear();
}
std::string CSteamCallbackCall1::toString()
{
std::stringstream ss;
ss << "Steam_Callback1: { callbackId: " << m_CallbackId << "; data: ";
PrintBinaryArray(m_Data, m_DataSize, ss);
ss << "; dataSize: " << m_DataSize << " }";
return ss.str();
}
bool CSteamCallbackCall1::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamCallbackCall1* otherCall = dynamic_cast<CSteamCallbackCall1*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_InState.m_iCallback != m_InState.m_iCallback) return false;
if (otherCall->m_InState.m_nCallbackFlags != m_InState.m_nCallbackFlags) return false;
return true;
}
void CSteamCallbackCall1::writePrologue(std::ostream &stream) {
stream.write((char*)&m_CallbackId, 4)
.write((char*)&m_InState, sizeof(m_InState))
.write((char*)&m_DataSize, 4)
.write(m_Data, m_DataSize);
}
void CSteamCallbackCall1::readPrologue(std::istream &stream) {
stream
.read((char*)&m_CallbackId, 4)
.read((char*)&m_InState, sizeof(m_InState))
.read((char*)&m_DataSize, 4);
stream.read(m_Data, m_DataSize);
}
void CSteamCallbackCall1::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_OutState, sizeof(m_OutState));
}
void CSteamCallbackCall1::readEpilogue(std::istream &stream) {
stream.read((char*)&m_OutState, sizeof(m_OutState));
}
/* ============================================================================
CSteamCallbackCall2
============================================================================ */
CSteamCallbackCall2::CSteamCallbackCall2(int cbId, void* data, int dataSize, bool ioFailure, SteamAPICall_t apiCall, CCallbackBase* cb)
{
if (dataSize > sizeof(m_Data))
regamedll_syserror("%s: too large data (%d, max %d)", __FUNCTION__, dataSize, sizeof(m_Data));
m_CallbackId = cbId;
m_DataSize = dataSize;
memcpy(m_Data, data, dataSize);
m_bIOFailure = ioFailure;
m_SteamAPICall = apiCall;
m_InState.m_iCallback = cb->GetICallback();
m_InState.m_nCallbackFlags = cb->GetFlags();
m_OutState.clear();
}
std::string CSteamCallbackCall2::toString()
{
std::stringstream ss;
ss << "Steam_Callback1: { callbackId: " << m_CallbackId << "; data: ";
PrintBinaryArray(m_Data, m_DataSize, ss);
ss << "; dataSize: " << m_DataSize << "; ioFailure: " << m_bIOFailure << "; steamApiCall: " << m_SteamAPICall << " }";
return ss.str();
}
bool CSteamCallbackCall2::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamCallbackCall2* otherCall = dynamic_cast<CSteamCallbackCall2*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_InState.m_iCallback != m_InState.m_iCallback) return false;
if (otherCall->m_InState.m_nCallbackFlags != m_InState.m_nCallbackFlags) return false;
return true;
}
void CSteamCallbackCall2::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_CallbackId, 4)
.write((char*)&m_InState, sizeof(m_InState))
.write((char*)&m_DataSize, 4)
.write((char*)&m_bIOFailure, 1)
.write((char*)&m_SteamAPICall, sizeof(m_SteamAPICall))
.write(m_Data, m_DataSize);
}
void CSteamCallbackCall2::readPrologue(std::istream &stream) {
m_bIOFailure = false;
stream
.read((char*)&m_CallbackId, 4)
.read((char*)&m_InState, sizeof(m_InState))
.read((char*)&m_DataSize, 4)
.read((char*)&m_bIOFailure, 1)
.read((char*)&m_SteamAPICall, sizeof(m_SteamAPICall));
stream.read(m_Data, m_DataSize);
}
void CSteamCallbackCall2::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_OutState, sizeof(m_OutState));
}
void CSteamCallbackCall2::readEpilogue(std::istream &stream) {
stream.read((char*)&m_OutState, sizeof(m_OutState));
}
/* ============================================================================
CSteamApiRegisterCallbackCall
============================================================================ */
CSteamApiRegisterCallbackCall::CSteamApiRegisterCallbackCall(int regamedllCallbackId, int steamCallbackId, CCallbackBase* cb)
{
m_ReGameDLLCallbackId = regamedllCallbackId;
m_iSteamCallbackId = steamCallbackId;
m_InState.m_iCallback = cb->GetICallback();
m_InState.m_nCallbackFlags = cb->GetFlags();
m_OutState.clear();
}
std::string CSteamApiRegisterCallbackCall::toString()
{
std::stringstream ss;
ss << "SteamAPI_RegisterCallback( regamedllCallbackId: " << m_ReGameDLLCallbackId << "; steamCallbackId: " << m_iSteamCallbackId << " )";
return ss.str();
}
bool CSteamApiRegisterCallbackCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamApiRegisterCallbackCall* otherCall = dynamic_cast<CSteamApiRegisterCallbackCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_iSteamCallbackId != m_iSteamCallbackId)
return false;
if (otherCall->m_ReGameDLLCallbackId != m_ReGameDLLCallbackId)
return false;
if (otherCall->m_InState.m_iCallback != m_InState.m_iCallback) return false;
if (otherCall->m_InState.m_nCallbackFlags != m_InState.m_nCallbackFlags) return false;
return true;
}
void CSteamApiRegisterCallbackCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_InState, sizeof(m_InState))
.write((char*)&m_ReGameDLLCallbackId, 4)
.write((char*)&m_iSteamCallbackId, 4);
}
void CSteamApiRegisterCallbackCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_InState, sizeof(m_InState))
.read((char*)&m_ReGameDLLCallbackId, 4)
.read((char*)&m_iSteamCallbackId, 4);
}
void CSteamApiRegisterCallbackCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_OutState, sizeof(m_OutState));
}
void CSteamApiRegisterCallbackCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_OutState, sizeof(m_OutState));
}
/* ============================================================================
CSteamApiInitCall
============================================================================ */
std::string CSteamApiInitCall::toString()
{
std::stringstream ss;
ss << "CSteamApiInitCall( ) => " << m_Res;
return ss.str();
}
bool CSteamApiInitCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamApiInitCall* otherCall = dynamic_cast<CSteamApiInitCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CSteamApiInitCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 1);
}
void CSteamApiInitCall::readEpilogue(std::istream &stream) {
m_Res = false;
stream.read((char*)&m_Res, 1);
}
/* ============================================================================
CSteamApiUnrigestierCallResultCall
============================================================================ */
CSteamApiUnrigestierCallResultCall::CSteamApiUnrigestierCallResultCall(int regamedllCallbackId, SteamAPICall_t steamApiCall, CCallbackBase* cb)
{
m_ReGameDLLCallbackId = regamedllCallbackId;
m_SteamApiCall = steamApiCall;
m_InState.m_iCallback = cb->GetICallback();
m_InState.m_nCallbackFlags = cb->GetFlags();
m_OutState.clear();
}
std::string CSteamApiUnrigestierCallResultCall::toString()
{
std::stringstream ss;
ss << "SteamAPI_UnregisterCallResult( regamedllCallbackId: " << m_ReGameDLLCallbackId << "; steamApiCall: " << m_SteamApiCall << " )";
return ss.str();
}
bool CSteamApiUnrigestierCallResultCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamApiUnrigestierCallResultCall* otherCall = dynamic_cast<CSteamApiUnrigestierCallResultCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_SteamApiCall != m_SteamApiCall)
return false;
if (otherCall->m_ReGameDLLCallbackId != m_ReGameDLLCallbackId)
return false;
if (otherCall->m_InState.m_iCallback != m_InState.m_iCallback) return false;
if (otherCall->m_InState.m_nCallbackFlags != m_InState.m_nCallbackFlags) return false;
return true;
}
void CSteamApiUnrigestierCallResultCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_InState, sizeof(m_InState))
.write((char*)&m_ReGameDLLCallbackId, 4)
.write((char*)&m_SteamApiCall, sizeof(m_SteamApiCall));
}
void CSteamApiUnrigestierCallResultCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_InState, sizeof(m_InState))
.read((char*)&m_ReGameDLLCallbackId, 4)
.read((char*)&m_SteamApiCall, sizeof(m_SteamApiCall));
}
void CSteamApiUnrigestierCallResultCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_OutState, sizeof(m_OutState));
}
void CSteamApiUnrigestierCallResultCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_OutState, sizeof(m_OutState));
}
/* ============================================================================
CSteamAppsCall
============================================================================ */
std::string CSteamAppsCall::toString()
{
std::stringstream ss;
ss << "SteamApps( )";
return ss.str();
}
bool CSteamAppsCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamAppsCall* otherCall = dynamic_cast<CSteamAppsCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CSteamAppsCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_ReturnNull, 1);
}
void CSteamAppsCall::readEpilogue(std::istream &stream) {
m_ReturnNull = false;
stream.read((char*)&m_ReturnNull, 1);
}
/* ============================================================================
CSteamAppGetCurrentGameLanguageCall
============================================================================ */
std::string CSteamAppGetCurrentGameLanguageCall::toString()
{
std::stringstream ss;
ss << "SteamApps::GetCurrentGameLanguage( ) => " << m_Res;
return ss.str();
}
void CSteamAppGetCurrentGameLanguageCall::setResult(const char* res)
{
if (res == NULL)
regamedll_syserror("%s: null result", __FUNCTION__);
m_ResLen = strlen(res) + 1;
if (m_ResLen > sizeof(m_Res))
regamedll_syserror("%s: too large result", __FUNCTION__);
memcpy(m_Res, res, m_ResLen);
}
bool CSteamAppGetCurrentGameLanguageCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamAppGetCurrentGameLanguageCall* otherCall = dynamic_cast<CSteamAppGetCurrentGameLanguageCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CSteamAppGetCurrentGameLanguageCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_ResLen, 4)
.write((char*)&m_Res, m_ResLen);
}
void CSteamAppGetCurrentGameLanguageCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_ResLen, 4);
stream.read((char*)&m_Res, m_ResLen);
}
/* ============================================================================
CSteamGameServerInitCall
============================================================================ */
CSteamGameServerInitCall::CSteamGameServerInitCall(uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString)
{
if (pchVersionString == NULL)
regamedll_syserror("%s: version is null", __FUNCTION__);
m_VersionLen = strlen(pchVersionString) + 1;
if (m_VersionLen > sizeof(m_Version))
regamedll_syserror("%s: too long version string", __FUNCTION__);
memcpy(m_Version, pchVersionString, m_VersionLen);
m_IP = unIP;
m_SteamPort = usSteamPort;
m_GamePort = usGamePort;
m_QueryPort = usQueryPort;
m_ServerMode = eServerMode;
m_Res = false;
}
std::string CSteamGameServerInitCall::toString()
{
std::stringstream ss;
ss << "SteamGameServer_Init( unIP: " << m_IP << "; usSteamPort: " << m_SteamPort
<< "; usQueryPort: " << m_QueryPort << "; eServerMode: " << m_ServerMode
<< "; pchVersionString: " << m_Version << " ) => " << m_Res;
return ss.str();
}
bool CSteamGameServerInitCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamGameServerInitCall* otherCall = dynamic_cast<CSteamGameServerInitCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_VersionLen != m_VersionLen)
return false;
if (strcmp(otherCall->m_Version, m_Version))
return false;
if (otherCall->m_IP != m_IP)
return false;
if (otherCall->m_SteamPort != m_SteamPort)
return false;
if (otherCall->m_GamePort != m_GamePort)
return false;
if (otherCall->m_QueryPort != m_QueryPort)
return false;
if (otherCall->m_ServerMode != m_ServerMode)
return false;
return true;
}
void CSteamGameServerInitCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_IP, sizeof(m_IP))
.write((char*)&m_SteamPort, sizeof(m_SteamPort))
.write((char*)&m_GamePort, sizeof(m_GamePort))
.write((char*)&m_QueryPort, sizeof(m_QueryPort))
.write((char*)&m_ServerMode, sizeof(m_ServerMode))
.write((char*)&m_VersionLen, sizeof(m_VersionLen))
.write(m_Version, m_VersionLen);
}
void CSteamGameServerInitCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 1);
}
void CSteamGameServerInitCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_IP, sizeof(m_IP))
.read((char*)&m_SteamPort, sizeof(m_SteamPort))
.read((char*)&m_GamePort, sizeof(m_GamePort))
.read((char*)&m_QueryPort, sizeof(m_QueryPort))
.read((char*)&m_ServerMode, sizeof(m_ServerMode))
.read((char*)&m_VersionLen, sizeof(m_VersionLen));
stream.read(m_Version, m_VersionLen);
}
void CSteamGameServerInitCall::readEpilogue(std::istream &stream) {
m_Res = false;
stream.read((char*)&m_Res, 1);
}
/* ============================================================================
CSteamGameServerCall
============================================================================ */
std::string CSteamGameServerCall::toString()
{
std::stringstream ss;
ss << "SteamGameServer( )";
return ss.str();
}
bool CSteamGameServerCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamGameServerCall* otherCall = dynamic_cast<CSteamGameServerCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CSteamGameServerCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_ReturnNull, 1);
}
void CSteamGameServerCall::readEpilogue(std::istream &stream) {
m_ReturnNull = false;
stream.read((char*)&m_ReturnNull, 1);
}
/* ============================================================================
CGameServerSetProductCall
============================================================================ */
CGameServerSetProductCall::CGameServerSetProductCall(const char* product)
{
if (product == NULL)
regamedll_syserror("%s: product is null", __FUNCTION__);
m_ProductLen = strlen(product) + 1;
if (m_ProductLen > sizeof(m_Product))
regamedll_syserror("%s: too long product string", __FUNCTION__);
memcpy(m_Product, product, m_ProductLen);
}
std::string CGameServerSetProductCall::toString()
{
std::stringstream ss;
ss << "GS::SetProduct( product: " << m_Product << " ) ";
return ss.str();
}
bool CGameServerSetProductCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetProductCall* otherCall = dynamic_cast<CGameServerSetProductCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_ProductLen != m_ProductLen)
return false;
if (strcmp(otherCall->m_Product, m_Product))
return false;
return true;
}
void CGameServerSetProductCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_ProductLen, sizeof(m_ProductLen))
.write(m_Product, m_ProductLen);
}
void CGameServerSetProductCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_ProductLen, sizeof(m_ProductLen));
stream.read(m_Product, m_ProductLen);
}
/* ============================================================================
CGameServerSetModDirCall
============================================================================ */
CGameServerSetModDirCall::CGameServerSetModDirCall(const char* dir)
{
if (dir == NULL)
regamedll_syserror("%s: dir is null", __FUNCTION__);
m_DirLen = strlen(dir) + 1;
if (m_DirLen > sizeof(m_Dir))
regamedll_syserror("%s: too long dir string", __FUNCTION__);
memcpy(m_Dir, dir, m_DirLen);
}
std::string CGameServerSetModDirCall::toString()
{
std::stringstream ss;
ss << "GS::SetGameDir( gamedir: " << m_Dir << " ) ";
return ss.str();
}
bool CGameServerSetModDirCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetModDirCall* otherCall = dynamic_cast<CGameServerSetModDirCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_DirLen != m_DirLen)
return false;
if (strcmp(otherCall->m_Dir, m_Dir))
return false;
return true;
}
void CGameServerSetModDirCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_DirLen, sizeof(m_DirLen))
.write(m_Dir, m_DirLen);
}
void CGameServerSetModDirCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_DirLen, sizeof(m_DirLen));
stream.read(m_Dir, m_DirLen);
}
/* ============================================================================
CGameServerSetDedicatedServerCall
============================================================================ */
CGameServerSetDedicatedServerCall::CGameServerSetDedicatedServerCall(bool dedicated)
{
m_Dedicated = dedicated;
}
std::string CGameServerSetDedicatedServerCall::toString()
{
std::stringstream ss;
ss << "GS::SetDedicatedServer( dedicated: " << m_Dedicated << " ) ";
return ss.str();
}
bool CGameServerSetDedicatedServerCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetDedicatedServerCall* otherCall = dynamic_cast<CGameServerSetDedicatedServerCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Dedicated != m_Dedicated)
return false;
return true;
}
void CGameServerSetDedicatedServerCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Dedicated, 1);
}
void CGameServerSetDedicatedServerCall::readPrologue(std::istream &stream) {
m_Dedicated = false;
stream.read((char*)&m_Dedicated, 1);
}
/* ============================================================================
CGameServerSetGameDescCall
============================================================================ */
CGameServerSetGameDescCall::CGameServerSetGameDescCall(const char* desc)
{
if (desc == NULL)
regamedll_syserror("%s: desc is null", __FUNCTION__);
m_DescLen = strlen(desc) + 1;
if (m_DescLen > sizeof(m_Desc))
regamedll_syserror("%s: too long dir string", __FUNCTION__);
memcpy(m_Desc, desc, m_DescLen);
}
std::string CGameServerSetGameDescCall::toString()
{
std::stringstream ss;
ss << "GS::SetGameDescription( description: " << m_Desc << " ) ";
return ss.str();
}
bool CGameServerSetGameDescCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetGameDescCall* otherCall = dynamic_cast<CGameServerSetGameDescCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_DescLen != m_DescLen)
return false;
if (strcmp(otherCall->m_Desc, m_Desc))
return false;
return true;
}
void CGameServerSetGameDescCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_DescLen, sizeof(m_DescLen))
.write(m_Desc, m_DescLen);
}
void CGameServerSetGameDescCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_DescLen, sizeof(m_DescLen));
stream.read(m_Desc, m_DescLen);
}
/* ============================================================================
CGameServerLogOnAnonymousCall
============================================================================ */
std::string CGameServerLogOnAnonymousCall::toString()
{
std::stringstream ss;
ss << "GS::LogOnAnonymous( ) ";
return ss.str();
}
bool CGameServerLogOnAnonymousCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerLogOnAnonymousCall* otherCall = dynamic_cast<CGameServerLogOnAnonymousCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
/* ============================================================================
CGameServerEnableHeartbeatsCall
============================================================================ */
CGameServerEnableHeartbeatsCall::CGameServerEnableHeartbeatsCall(bool hearbeats)
{
m_Heartbeats = hearbeats;
}
std::string CGameServerEnableHeartbeatsCall::toString()
{
std::stringstream ss;
ss << "GS::EnableHeartbeats( active: " << m_Heartbeats << " ) ";
return ss.str();
}
bool CGameServerEnableHeartbeatsCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerEnableHeartbeatsCall* otherCall = dynamic_cast<CGameServerEnableHeartbeatsCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Heartbeats != m_Heartbeats)
return false;
return true;
}
void CGameServerEnableHeartbeatsCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Heartbeats, 1);
}
void CGameServerEnableHeartbeatsCall::readPrologue(std::istream &stream) {
m_Heartbeats = false;
stream.read((char*)&m_Heartbeats, 1);
}
/* ============================================================================
CGameServerSetHeartbeatIntervalCall
============================================================================ */
CGameServerSetHeartbeatIntervalCall::CGameServerSetHeartbeatIntervalCall(int interval)
{
m_Interval = interval;
}
std::string CGameServerSetHeartbeatIntervalCall::toString()
{
std::stringstream ss;
ss << "GS::SetHeartbeatInterval( interval: " << m_Interval << " ) ";
return ss.str();
}
bool CGameServerSetHeartbeatIntervalCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetHeartbeatIntervalCall* otherCall = dynamic_cast<CGameServerSetHeartbeatIntervalCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Interval != m_Interval)
return false;
return true;
}
void CGameServerSetHeartbeatIntervalCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Interval, 4);
}
void CGameServerSetHeartbeatIntervalCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_Interval, 4);
}
/* ============================================================================
CGameServerSetMaxPlayersCall
============================================================================ */
CGameServerSetMaxPlayersCall::CGameServerSetMaxPlayersCall(int maxPlayers)
{
m_MaxPlayers = maxPlayers;
}
std::string CGameServerSetMaxPlayersCall::toString()
{
std::stringstream ss;
ss << "GS::ServerSetMaxPlayersCount( count: " << m_MaxPlayers << " ) ";
return ss.str();
}
bool CGameServerSetMaxPlayersCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetMaxPlayersCall* otherCall = dynamic_cast<CGameServerSetMaxPlayersCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_MaxPlayers != m_MaxPlayers)
return false;
return true;
}
void CGameServerSetMaxPlayersCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_MaxPlayers, 4);
}
void CGameServerSetMaxPlayersCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_MaxPlayers, 4);
}
/* ============================================================================
CGameServerSetBotCountCall
============================================================================ */
CGameServerSetBotCountCall::CGameServerSetBotCountCall(int numBots)
{
m_NumBots = numBots;
}
std::string CGameServerSetBotCountCall::toString()
{
std::stringstream ss;
ss << "GS::SetBotCount( count: " << m_NumBots << " ) ";
return ss.str();
}
bool CGameServerSetBotCountCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetBotCountCall* otherCall = dynamic_cast<CGameServerSetBotCountCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_NumBots != m_NumBots)
return false;
return true;
}
void CGameServerSetBotCountCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_NumBots, 4);
}
void CGameServerSetBotCountCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_NumBots, 4);
}
/* ============================================================================
CGameServerSetServerNameCall
============================================================================ */
CGameServerSetServerNameCall::CGameServerSetServerNameCall(const char* serverName)
{
if (serverName == NULL)
regamedll_syserror("%s: serverName is null", __FUNCTION__);
m_ServerNameLen = strlen(serverName) + 1;
if (m_ServerNameLen > sizeof(m_ServerName))
regamedll_syserror("%s: too long serverName string", __FUNCTION__);
memcpy(m_ServerName, serverName, m_ServerNameLen);
}
std::string CGameServerSetServerNameCall::toString()
{
std::stringstream ss;
ss << "GS::SetServerName( serverName: " << m_ServerName << " ) ";
return ss.str();
}
bool CGameServerSetServerNameCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetServerNameCall* otherCall = dynamic_cast<CGameServerSetServerNameCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_ServerNameLen != m_ServerNameLen)
return false;
if (strcmp(otherCall->m_ServerName, m_ServerName))
return false;
return true;
}
void CGameServerSetServerNameCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_ServerNameLen, sizeof(m_ServerNameLen))
.write(m_ServerName, m_ServerNameLen);
}
void CGameServerSetServerNameCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_ServerNameLen, sizeof(m_ServerNameLen));
stream.read(m_ServerName, m_ServerNameLen);
}
/* ============================================================================
CGameServerSetMapNameCall
============================================================================ */
CGameServerSetMapNameCall::CGameServerSetMapNameCall(const char* mapName)
{
if (mapName == NULL)
regamedll_syserror("%s: serverName is null", __FUNCTION__);
m_MapNameLen = strlen(mapName) + 1;
if (m_MapNameLen > sizeof(m_MapName))
regamedll_syserror("%s: too long mapName string", __FUNCTION__);
memcpy(m_MapName, mapName, m_MapNameLen);
}
std::string CGameServerSetMapNameCall::toString()
{
std::stringstream ss;
ss << "GS::SetMapName( serverName: " << m_MapName << " ) ";
return ss.str();
}
bool CGameServerSetMapNameCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetMapNameCall* otherCall = dynamic_cast<CGameServerSetMapNameCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_MapNameLen != m_MapNameLen)
return false;
if (strcmp(otherCall->m_MapName, m_MapName))
return false;
return true;
}
void CGameServerSetMapNameCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_MapNameLen, sizeof(m_MapNameLen))
.write(m_MapName, m_MapNameLen);
}
void CGameServerSetMapNameCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_MapNameLen, sizeof(m_MapNameLen));
stream.read(m_MapName, m_MapNameLen);
}
/* ============================================================================
CGameServerSetPasswordProtectedCall
============================================================================ */
CGameServerSetPasswordProtectedCall::CGameServerSetPasswordProtectedCall(bool passwordProtected)
{
m_PasswordProtected = passwordProtected;
}
std::string CGameServerSetPasswordProtectedCall::toString()
{
std::stringstream ss;
ss << "GS::SetPasswordProtected( protected: " << m_PasswordProtected << " ) ";
return ss.str();
}
bool CGameServerSetPasswordProtectedCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetPasswordProtectedCall* otherCall = dynamic_cast<CGameServerSetPasswordProtectedCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_PasswordProtected != m_PasswordProtected)
return false;
return true;
}
void CGameServerSetPasswordProtectedCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_PasswordProtected, 1);
}
void CGameServerSetPasswordProtectedCall::readPrologue(std::istream &stream) {
m_PasswordProtected = false;
stream.read((char*)&m_PasswordProtected, 1);
}
/* ============================================================================
CGameServerClearAllKVsCall
============================================================================ */
std::string CGameServerClearAllKVsCall::toString()
{
std::stringstream ss;
ss << "GS::ClearAllKeyValues( ) ";
return ss.str();
}
bool CGameServerClearAllKVsCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerClearAllKVsCall* otherCall = dynamic_cast<CGameServerClearAllKVsCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
/* ============================================================================
CGameServerSetKeyValueCall
============================================================================ */
CGameServerSetKeyValueCall::CGameServerSetKeyValueCall(const char* key, const char* value)
{
if (key == NULL)
regamedll_syserror("%s: key is null", __FUNCTION__);
m_KeyLen = strlen(key) + 1;
if (m_KeyLen > sizeof(m_Key))
regamedll_syserror("%s: too long key string", __FUNCTION__);
memcpy(m_Key, key, m_KeyLen);
if (value == NULL)
regamedll_syserror("%s: value is null", __FUNCTION__);
m_ValueLen = strlen(value) + 1;
if (m_ValueLen > sizeof(m_Value))
regamedll_syserror("%s: too long value string", __FUNCTION__);
memcpy(m_Value, value, m_ValueLen);
}
std::string CGameServerSetKeyValueCall::toString()
{
std::stringstream ss;
ss << "GS::SetKeyValue( key: '" << m_Key << "'; value:'" << m_Value << "' ) ";
return ss.str();
}
bool CGameServerSetKeyValueCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSetKeyValueCall* otherCall = dynamic_cast<CGameServerSetKeyValueCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_KeyLen != m_KeyLen)
return false;
if (otherCall->m_ValueLen != m_ValueLen)
return false;
if (strcmp(otherCall->m_Key, m_Key))
return false;
if (strcmp(otherCall->m_Value, m_Value))
return false;
return true;
}
void CGameServerSetKeyValueCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_ValueLen, sizeof(m_ValueLen))
.write((char*)&m_KeyLen, sizeof(m_KeyLen))
.write(m_Value, m_ValueLen)
.write(m_Key, m_KeyLen);
}
void CGameServerSetKeyValueCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_ValueLen, sizeof(m_ValueLen))
.read((char*)&m_KeyLen, sizeof(m_KeyLen));
stream
.read(m_Value, m_ValueLen)
.read(m_Key, m_KeyLen);
}
/* ============================================================================
CSteamApiSetBreakpadAppIdCall
============================================================================ */
CSteamApiSetBreakpadAppIdCall::CSteamApiSetBreakpadAppIdCall(uint32 appId)
{
m_AppId = appId;
}
std::string CSteamApiSetBreakpadAppIdCall::toString()
{
std::stringstream ss;
ss << "SteamAPI_SetBreakpadAppID( count: " << m_AppId << " ) ";
return ss.str();
}
bool CSteamApiSetBreakpadAppIdCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamApiSetBreakpadAppIdCall* otherCall = dynamic_cast<CSteamApiSetBreakpadAppIdCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_AppId != m_AppId)
return false;
return true;
}
void CSteamApiSetBreakpadAppIdCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_AppId, 4);
}
void CSteamApiSetBreakpadAppIdCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_AppId, 4);
}
/* ============================================================================
CGameServerWasRestartRequestedCall
============================================================================ */
std::string CGameServerWasRestartRequestedCall::toString()
{
std::stringstream ss;
ss << "GS::WasRestartRequested() => " << m_Result;
return ss.str();
}
bool CGameServerWasRestartRequestedCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerWasRestartRequestedCall* otherCall = dynamic_cast<CGameServerWasRestartRequestedCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGameServerWasRestartRequestedCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Result, 1);
}
void CGameServerWasRestartRequestedCall::readPrologue(std::istream &stream) {
m_Result = false;
stream.read((char*)&m_Result, 1);
}
/* ============================================================================
CSteamGameServerRunCallbacksCall
============================================================================ */
std::string CSteamGameServerRunCallbacksCall::toString()
{
std::stringstream ss;
ss << "SteamGameServer_RunCallbacks()";
return ss.str();
}
bool CSteamGameServerRunCallbacksCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamGameServerRunCallbacksCall* otherCall = dynamic_cast<CSteamGameServerRunCallbacksCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
/* ============================================================================
CGameServerGetNextOutgoingPacketCall
============================================================================ */
CGameServerGetNextOutgoingPacketCall::CGameServerGetNextOutgoingPacketCall(int maxOut)
{
m_MaxOut = maxOut;
m_BufLen = m_Result = 0; m_Addr = 0; m_Port = 0;
}
void CGameServerGetNextOutgoingPacketCall::setResult(void* buf, int res, uint32* pAddr, uint16* pPort)
{
m_BufLen = res > 0 ? res : 0;
if (m_BufLen > 0) {
if (m_BufLen > sizeof(m_Buf))
regamedll_syserror("%s: too long buffer returned", __FUNCTION__);
memcpy(m_Buf, buf, m_BufLen);
}
m_Result = res;
if (pAddr == NULL)
regamedll_syserror("%s: pAddr is NULL", __FUNCTION__);
if (pPort == NULL)
regamedll_syserror("%s: pPort is NULL", __FUNCTION__);
m_Addr = *pAddr;
m_Port = *pPort;
}
std::string CGameServerGetNextOutgoingPacketCall::toString()
{
std::stringstream ss;
ss << "GS::GetNextOutgoingPacket(buf: "; PrintBinaryArray(m_Buf, m_BufLen, ss);
ss << ", maxOut: " << m_MaxOut << ", addr: " << m_Addr << ", port: " << m_Port << " ) => " << m_Result;
return ss.str();
}
bool CGameServerGetNextOutgoingPacketCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerGetNextOutgoingPacketCall* otherCall = dynamic_cast<CGameServerGetNextOutgoingPacketCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_MaxOut != this->m_MaxOut)
return false;
return true;
}
void CGameServerGetNextOutgoingPacketCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_MaxOut, 4);
}
void CGameServerGetNextOutgoingPacketCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_Result, 4)
.write((char*)&m_Addr, 4)
.write((char*)&m_Port, 2)
.write((char*)&m_BufLen, 4)
.write(m_Buf, m_BufLen);
}
void CGameServerGetNextOutgoingPacketCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_MaxOut, 4);
}
void CGameServerGetNextOutgoingPacketCall::readEpilogue(std::istream &stream) {
stream
.read((char*)&m_Result, 4)
.read((char*)&m_Addr, 4)
.read((char*)&m_Port, 2)
.read((char*)&m_BufLen, 4);
stream.read(m_Buf, m_BufLen);
}
/* ============================================================================
CSteamApiRunCallbacksCall
============================================================================ */
std::string CSteamApiRunCallbacksCall::toString()
{
std::stringstream ss;
ss << "SteamAPI_RunCallbacks()";
return ss.str();
}
bool CSteamApiRunCallbacksCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamApiRunCallbacksCall* otherCall = dynamic_cast<CSteamApiRunCallbacksCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
/* ============================================================================
CGameServerGetSteamIdCall
============================================================================ */
std::string CGameServerGetSteamIdCall::toString()
{
std::stringstream ss;
ss << "GS::GetSteamId( ) => " << m_SteamId;
return ss.str();
}
bool CGameServerGetSteamIdCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerGetSteamIdCall* otherCall = dynamic_cast<CGameServerGetSteamIdCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGameServerGetSteamIdCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_SteamId, 8);
}
void CGameServerGetSteamIdCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_SteamId, 8);
}
/* ============================================================================
CGameServerBSecureCall
============================================================================ */
std::string CGameServerBSecureCall::toString()
{
std::stringstream ss;
ss << "GS::BSecure( ) => " << m_Res;
return ss.str();
}
bool CGameServerBSecureCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerBSecureCall* otherCall = dynamic_cast<CGameServerBSecureCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGameServerBSecureCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 1);
}
void CGameServerBSecureCall::readEpilogue(std::istream &stream) {
m_Res = false;
stream.read((char*)&m_Res, 1);
}
/* ============================================================================
CGameServerHandleIncomingPacketCall
============================================================================ */
CGameServerHandleIncomingPacketCall::CGameServerHandleIncomingPacketCall(const void *pData, int cbData, uint32 srcIP, uint16 srcPort)
{
m_Len = cbData;
if (m_Len > sizeof(m_Data))
regamedll_syserror("%s: too long packet", __FUNCTION__);
memcpy(m_Data, pData, m_Len);
m_Ip = srcIP;
m_Port = srcPort;
m_Res = false;
}
std::string CGameServerHandleIncomingPacketCall::toString()
{
std::stringstream ss;
ss << "GS::CGameServerHandleIncomingPacketCall(data: "; PrintBinaryArray(m_Data, m_Len, ss);
ss << ", len: " << m_Len << ", ip: " << m_Ip << ", port: " << m_Port << ") => " << m_Res;
return ss.str();
}
bool CGameServerHandleIncomingPacketCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerHandleIncomingPacketCall* otherCall = dynamic_cast<CGameServerHandleIncomingPacketCall*>(other);
if (otherCall == NULL)
return false;
if (m_Len != otherCall->m_Len)
return false;
if (memcmp(m_Data, otherCall->m_Data, m_Len))
return false;
if (m_Ip != otherCall->m_Ip || m_Port != otherCall->m_Port)
return false;
return true;
}
void CGameServerHandleIncomingPacketCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_Ip, 4)
.write((char*)&m_Port, 2)
.write((char*)&m_Len, 4)
.write(m_Data, m_Len);
}
void CGameServerHandleIncomingPacketCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_Ip, 4)
.read((char*)&m_Port, 2)
.read((char*)&m_Len, 4);
stream.read(m_Data, m_Len);
}
void CGameServerHandleIncomingPacketCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 1);
}
void CGameServerHandleIncomingPacketCall::readEpilogue(std::istream &stream) {
m_Res = false;
stream.read((char*)&m_Res, 1);
}
/* ============================================================================
CGameServerSendUserConnectAndAuthenticateCall
============================================================================ */
CGameServerSendUserConnectAndAuthenticateCall::CGameServerSendUserConnectAndAuthenticateCall(uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize)
{
m_AuthBlobLen = cubAuthBlobSize;
if (m_AuthBlobLen > sizeof(m_AuthBlob))
regamedll_syserror("%s: too long auth blob", __FUNCTION__);
memcpy(m_AuthBlob, pvAuthBlob, m_AuthBlobLen);
m_IP = unIPClient;
m_OutSteamId = 0;
m_Res = false;
}
std::string CGameServerSendUserConnectAndAuthenticateCall::toString()
{
std::stringstream ss;
ss << "GS::CGameServerSendUserConnectAndAuthenticateCall(ip: " << m_IP << "authBlob: "; PrintBinaryArray(m_AuthBlob, m_AuthBlobLen, ss);
ss << ", authBlobLen: " << m_AuthBlobLen << ", steamId: " << m_OutSteamId << ") => " << m_Res;
return ss.str();
}
bool CGameServerSendUserConnectAndAuthenticateCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSendUserConnectAndAuthenticateCall* otherCall = dynamic_cast<CGameServerSendUserConnectAndAuthenticateCall*>(other);
if (otherCall == NULL)
return false;
if (m_AuthBlobLen != otherCall->m_AuthBlobLen)
return false;
if (strict) {
if (memcmp(m_AuthBlob, otherCall->m_AuthBlob, m_AuthBlobLen))
return false;
}
if (m_IP != otherCall->m_IP)
return false;
return true;
}
void CGameServerSendUserConnectAndAuthenticateCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_IP, 4)
.write((char*)&m_AuthBlobLen, 4)
.write(m_AuthBlob, m_AuthBlobLen);
}
void CGameServerSendUserConnectAndAuthenticateCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_IP, 4)
.read((char*)&m_AuthBlobLen, 4);
stream.read(m_AuthBlob, m_AuthBlobLen);
}
void CGameServerSendUserConnectAndAuthenticateCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_OutSteamId, 8)
.write((char*)&m_Res, 1);
}
void CGameServerSendUserConnectAndAuthenticateCall::readEpilogue(std::istream &stream) {
m_Res = false;
stream
.read((char*)&m_OutSteamId, 8)
.read((char*)&m_Res, 1);
}
/* ============================================================================
CGameServerSendUserDisconnectCall
============================================================================ */
std::string CGameServerSendUserDisconnectCall::toString()
{
std::stringstream ss;
ss << "GS::CGameServerSendUserDisconnectCall(steamId: " << m_SteamId << ") ";
return ss.str();
}
bool CGameServerSendUserDisconnectCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerSendUserDisconnectCall* otherCall = dynamic_cast<CGameServerSendUserDisconnectCall*>(other);
if (otherCall == NULL)
return false;
if (m_SteamId != otherCall->m_SteamId)
return false;
return true;
}
void CGameServerSendUserDisconnectCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_SteamId, 8);
}
void CGameServerSendUserDisconnectCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_SteamId, 8);
}
/* ============================================================================
CGameServerBUpdateUserDataCall
============================================================================ */
CGameServerBUpdateUserDataCall::CGameServerBUpdateUserDataCall(CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore)
{
m_PlayerNameLen = strlen(pchPlayerName) + 1;
if (m_PlayerNameLen > sizeof(m_PlayerName))
regamedll_syserror("%s: too long player name", __FUNCTION__);
memcpy(m_PlayerName, pchPlayerName, m_PlayerNameLen);
m_SteamId = steamIDUser.ConvertToUint64();
m_Score = uScore;
}
std::string CGameServerBUpdateUserDataCall::toString()
{
std::stringstream ss;
ss << "GS::BUpdateUserData(steamIDUser: " << m_SteamId << "playerName: "; PrintBinaryArray(m_PlayerName, m_PlayerNameLen, ss);
ss << ", uScore: " << m_Score << " ) => " << m_Res;
return ss.str();
}
bool CGameServerBUpdateUserDataCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerBUpdateUserDataCall* otherCall = dynamic_cast<CGameServerBUpdateUserDataCall*>(other);
if (otherCall == NULL)
return false;
if (m_PlayerNameLen != otherCall->m_PlayerNameLen)
return false;
if (memcmp(m_PlayerName, otherCall->m_PlayerName, m_PlayerNameLen))
return false;
if (m_SteamId != otherCall->m_SteamId)
return false;
if (m_Score != otherCall->m_Score)
return false;
return true;
}
void CGameServerBUpdateUserDataCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_SteamId, 8)
.write((char*)&m_Score, 4)
.write((char*)&m_PlayerNameLen, 4)
.write(m_PlayerName, m_PlayerNameLen);
}
void CGameServerBUpdateUserDataCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_SteamId, 8)
.read((char*)&m_Score, 4)
.read((char*)&m_PlayerNameLen, 4);
stream.read(m_PlayerName, m_PlayerNameLen);
}
void CGameServerBUpdateUserDataCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 1);
}
void CGameServerBUpdateUserDataCall::readEpilogue(std::istream &stream) {
m_Res = false;
stream.read((char*)&m_Res, 1);
}
/* ============================================================================
CGameServerCreateUnauthUserConnectionCall
============================================================================ */
std::string CGameServerCreateUnauthUserConnectionCall::toString()
{
std::stringstream ss;
ss << "GS::CreateUnauthUserConnection() => " << m_SteamId;
return ss.str();
}
bool CGameServerCreateUnauthUserConnectionCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerCreateUnauthUserConnectionCall* otherCall = dynamic_cast<CGameServerCreateUnauthUserConnectionCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGameServerCreateUnauthUserConnectionCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_SteamId, 8);
}
void CGameServerCreateUnauthUserConnectionCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_SteamId, 8);
}
/* ============================================================================
CGetHostNameCall
============================================================================ */
std::string CGetHostNameCall::toString()
{
std::stringstream ss;
ss << "gethostname(name: " << m_Name << "; nameLen: " << m_NameLenIn << " ) => " << m_Res;
return ss.str();
}
bool CGetHostNameCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetHostNameCall* otherCall = dynamic_cast<CGetHostNameCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_NameLenIn != this->m_NameLenIn)
return false;
return true;
}
void CGetHostNameCall::setResult(char* hostName, int res) {
m_NameLenOut = strlen(hostName) + 1;
if (m_NameLenOut > sizeof(m_Name))
regamedll_syserror("%s: too long host name", __FUNCTION__);
strcpy(m_Name, hostName);
m_Res = res;
}
void CGetHostNameCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_NameLenIn, 4);
}
void CGetHostNameCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_NameLenIn, 4);
}
void CGetHostNameCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_NameLenOut, 4)
.write((char*)&m_Res, 4)
.write(m_Name, m_NameLenOut);
}
void CGetHostNameCall::readEpilogue(std::istream &stream) {
stream
.read((char*)&m_NameLenOut, 4)
.read((char*)&m_Res, 4);
stream.read(m_Name, m_NameLenOut);
}
/* ============================================================================
CGetHostByNameCall
============================================================================ */
CGetHostByNameCall::CGetHostByNameCall(const char* name)
{
m_NameLen = strlen(name) + 1;
if (m_NameLen > sizeof(m_Name))
regamedll_syserror("%s: too long name", __FUNCTION__);
strcpy(m_Name, name);
}
std::string CGetHostByNameCall::toString()
{
std::stringstream ss;
ss << "gethostbyname(name: " << m_Name << " ) => <>";
return ss.str();
}
bool CGetHostByNameCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetHostByNameCall* otherCall = dynamic_cast<CGetHostByNameCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_NameLen != this->m_NameLen)
return false;
if (strcmp(otherCall->m_Name, this->m_Name))
return false;
return true;
}
void CGetHostByNameCall::setResult(const hostent* hostEnt) {
m_HostentData.hostNameLen = strlen(hostEnt->h_name) + 1;
if (m_HostentData.hostNameLen > sizeof(m_HostentData.hostName)) {
regamedll_syserror("%s: too long host name", __FUNCTION__);
}
strcpy(m_HostentData.hostName, hostEnt->h_name);
int i = 0;
while (hostEnt->h_aliases[i]) {
if (i >= HOSTENT_DATA_MAX_ALIASES) {
regamedll_syserror("%s: too many aliases", __FUNCTION__);
}
m_HostentData.aliasesLengths[i] = strlen(hostEnt->h_aliases[i]) + 1;
if (m_HostentData.aliasesLengths[i] > sizeof(m_HostentData.aliases[i])) {
regamedll_syserror("%s: too long alias", __FUNCTION__);
}
strcpy(m_HostentData.aliases[i], hostEnt->h_aliases[i]);
i++;
}
m_HostentData.numAliases = i;
m_HostentData.addrtype = hostEnt->h_addrtype;
m_HostentData.addrLen = hostEnt->h_length;
if (m_HostentData.addrLen > sizeof(m_HostentData.addrs[0])) {
regamedll_syserror("%s: too long addr", __FUNCTION__);
}
i = 0;
while (hostEnt->h_addr_list[i]) {
if (i >= HOSTENT_DATA_MAX_ADDRS) {
regamedll_syserror("%s: too many addrs", __FUNCTION__);
}
memcpy(m_HostentData.addrs[i], hostEnt->h_addr_list[i], m_HostentData.addrLen);
i++;
}
m_HostentData.numAddrs = i;
}
void CGetHostByNameCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_NameLen, 4).write(m_Name, m_NameLen);
}
void CGetHostByNameCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_NameLen, 4);
stream.read(m_Name, m_NameLen);
}
void CGetHostByNameCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_HostentData.hostNameLen, 4)
.write((char*)&m_HostentData.numAddrs, 4)
.write((char*)&m_HostentData.numAliases, 4)
.write((char*)&m_HostentData.addrLen, 2)
.write((char*)&m_HostentData.addrtype, 2)
.write(m_HostentData.hostName, m_HostentData.hostNameLen)
.write((char*)&m_HostentData.aliasesLengths[0], 4 * m_HostentData.numAliases);
for (int i = 0; i < m_HostentData.numAliases; i++) {
stream.write(m_HostentData.aliases[i], m_HostentData.aliasesLengths[i]);
}
for (int i = 0; i < m_HostentData.numAddrs; i++) {
stream.write(m_HostentData.addrs[i], m_HostentData.addrLen);
}
}
void CGetHostByNameCall::readEpilogue(std::istream &stream) {
stream
.read((char*)&m_HostentData.hostNameLen, 4)
.read((char*)&m_HostentData.numAddrs, 4)
.read((char*)&m_HostentData.numAliases, 4)
.read((char*)&m_HostentData.addrLen, 2)
.read((char*)&m_HostentData.addrtype, 2);
stream
.read(m_HostentData.hostName, m_HostentData.hostNameLen)
.read((char*)&m_HostentData.aliasesLengths[0], 4 * m_HostentData.numAliases);
for (int i = 0; i < m_HostentData.numAliases; i++) {
stream.read(m_HostentData.aliases[i], m_HostentData.aliasesLengths[i]);
}
for (int i = 0; i < m_HostentData.numAddrs; i++) {
stream.read(m_HostentData.addrs[i], m_HostentData.addrLen);
}
}
/* ============================================================================
CGetProcessTimesCall
============================================================================ */
std::string CGetProcessTimesCall::toString()
{
std::stringstream ss;
ss << "GetProcessTimes( creationTime: "; PrintFileTime(&m_CreationTime, ss);
ss << "; exitTime: "; PrintFileTime(&m_ExitTime, ss);
ss << "; kernelTime: "; PrintFileTime(&m_KernelTime, ss);
ss << "; userTime: "; PrintFileTime(&m_UserTime, ss);
ss << " ) => " << m_Res;
return ss.str();
}
bool CGetProcessTimesCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetProcessTimesCall* otherCall = dynamic_cast<CGetProcessTimesCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGetProcessTimesCall::setResult(BOOL res, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime)
{
m_Res = res;
memcpy(&m_CreationTime, lpCreationTime, sizeof(m_CreationTime));
memcpy(&m_ExitTime, lpExitTime, sizeof(m_ExitTime));
memcpy(&m_KernelTime, lpKernelTime, sizeof(m_KernelTime));
memcpy(&m_UserTime, lpUserTime, sizeof(m_UserTime));
}
void CGetProcessTimesCall::writeEpilogue(std::ostream &stream) {
stream
.write((char*)&m_CreationTime, sizeof(m_CreationTime))
.write((char*)&m_ExitTime, sizeof(m_ExitTime))
.write((char*)&m_KernelTime, sizeof(m_KernelTime))
.write((char*)&m_UserTime, sizeof(m_UserTime))
.write((char*)&m_Res, 1);
}
void CGetProcessTimesCall::readEpilogue(std::istream &stream) {
m_Res = 0;
stream
.read((char*)&m_CreationTime, sizeof(m_CreationTime))
.read((char*)&m_ExitTime, sizeof(m_ExitTime))
.read((char*)&m_KernelTime, sizeof(m_KernelTime))
.read((char*)&m_UserTime, sizeof(m_UserTime))
.read((char*)&m_Res, 1);
}
/* ============================================================================
CGetSystemTimeAsFileTimeCall
============================================================================ */
std::string CGetSystemTimeAsFileTimeCall::toString()
{
std::stringstream ss;
ss << "GetSystemTimeAsFileTime( systemTime: "; PrintFileTime(&m_SystemTime, ss);
ss << " )";
return ss.str();
}
bool CGetSystemTimeAsFileTimeCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGetSystemTimeAsFileTimeCall* otherCall = dynamic_cast<CGetSystemTimeAsFileTimeCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGetSystemTimeAsFileTimeCall::setResult(LPFILETIME systemTime)
{
memcpy(&m_SystemTime, systemTime, sizeof(m_SystemTime));
}
void CGetSystemTimeAsFileTimeCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_SystemTime, sizeof(m_SystemTime));
}
void CGetSystemTimeAsFileTimeCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_SystemTime, sizeof(m_SystemTime));
}
/* ============================================================================
CStdTimeCall
============================================================================ */
CStdTimeCall::CStdTimeCall(uint32* inTime)
{
m_InTimeNull = (inTime == NULL);
}
std::string CStdTimeCall::toString()
{
std::stringstream ss;
ss << "time( isNull: " << m_InTimeNull << ") => " << m_Res;
return ss.str();
}
bool CStdTimeCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CStdTimeCall* otherCall = dynamic_cast<CStdTimeCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_InTimeNull != this->m_InTimeNull)
return false;
return true;
}
void CStdTimeCall::setResult(uint32 res)
{
m_Res = res;
}
void CStdTimeCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_InTimeNull, 1);
}
void CStdTimeCall::readPrologue(std::istream &stream) {
m_InTimeNull = false;
stream.read((char*)&m_InTimeNull, 1);
}
void CStdTimeCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CStdTimeCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CStdLocalTimeCall
============================================================================ */
CStdLocalTimeCall::CStdLocalTimeCall(uint32 inTime)
{
m_Time = inTime;
}
std::string CStdLocalTimeCall::toString()
{
std::stringstream ss;
ss << "localTime( time: " << m_Time << ") => ";
PrintTm(&m_Res, ss);
return ss.str();
}
bool CStdLocalTimeCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CStdLocalTimeCall* otherCall = dynamic_cast<CStdLocalTimeCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Time != this->m_Time)
return false;
return true;
}
void CStdLocalTimeCall::setResult(struct tm *res)
{
memcpy(&m_Res, res, sizeof(m_Res));
}
void CStdLocalTimeCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Time, 4);
}
void CStdLocalTimeCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_Time, 4);
}
void CStdLocalTimeCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, sizeof(m_Res));
}
void CStdLocalTimeCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, sizeof(m_Res));
}
/* ============================================================================
CStdSrandCall
============================================================================ */
std::string CStdSrandCall::toString()
{
std::stringstream ss;
ss << "srand( seed: " << m_Seed << ") ";
return ss.str();
}
bool CStdSrandCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CStdSrandCall* otherCall = dynamic_cast<CStdSrandCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_Seed != this->m_Seed)
return false;
return true;
}
void CStdSrandCall::writePrologue(std::ostream &stream) {
stream.write((char*)&m_Seed, 4);
}
void CStdSrandCall::readPrologue(std::istream &stream) {
stream.read((char*)&m_Seed, 4);
}
/* ============================================================================
CStdRandCall
============================================================================ */
std::string CStdRandCall::toString()
{
std::stringstream ss;
ss << "rand( ) => " << m_Res;
return ss.str();
}
bool CStdRandCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CStdRandCall* otherCall = dynamic_cast<CStdRandCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CStdRandCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 4);
}
void CStdRandCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_Res, 4);
}
/* ============================================================================
CGameServerLogOffCall
============================================================================ */
std::string CGameServerLogOffCall::toString()
{
std::stringstream ss;
ss << "GS:LogOff( ) ";
return ss.str();
}
bool CGameServerLogOffCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerLogOffCall* otherCall = dynamic_cast<CGameServerLogOffCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
/* ============================================================================
CSteamGameServerShutdownCall
============================================================================ */
std::string CSteamGameServerShutdownCall::toString()
{
std::stringstream ss;
ss << "SteamGameServer_Shutdown( ) ";
return ss.str();
}
bool CSteamGameServerShutdownCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamGameServerShutdownCall* otherCall = dynamic_cast<CSteamGameServerShutdownCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
/* ============================================================================
CSteamApiUnregisterCallbackCall
============================================================================ */
CSteamApiUnregisterCallbackCall::CSteamApiUnregisterCallbackCall(int regamedllCallbackId, CCallbackBase* cb)
{
m_ReGameDLLCallbackId = regamedllCallbackId;
m_InState.m_iCallback = cb->GetICallback();
m_InState.m_nCallbackFlags = cb->GetFlags();
m_OutState.clear();
}
std::string CSteamApiUnregisterCallbackCall::toString()
{
std::stringstream ss;
ss << "SteamAPI_UnregisterCallback( regamedllCallbackId: " << m_ReGameDLLCallbackId << " )";
return ss.str();
}
bool CSteamApiUnregisterCallbackCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CSteamApiUnregisterCallbackCall* otherCall = dynamic_cast<CSteamApiUnregisterCallbackCall*>(other);
if (otherCall == NULL)
return false;
if (otherCall->m_ReGameDLLCallbackId != m_ReGameDLLCallbackId)
return false;
if (otherCall->m_InState.m_iCallback != m_InState.m_iCallback) return false;
if (otherCall->m_InState.m_nCallbackFlags != m_InState.m_nCallbackFlags) return false;
return true;
}
void CSteamApiUnregisterCallbackCall::writePrologue(std::ostream &stream) {
stream
.write((char*)&m_InState, sizeof(m_InState))
.write((char*)&m_ReGameDLLCallbackId, 4);
}
void CSteamApiUnregisterCallbackCall::readPrologue(std::istream &stream) {
stream
.read((char*)&m_InState, sizeof(m_InState))
.read((char*)&m_ReGameDLLCallbackId, 4);
}
void CSteamApiUnregisterCallbackCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_OutState, sizeof(m_OutState));
}
void CSteamApiUnregisterCallbackCall::readEpilogue(std::istream &stream) {
stream.read((char*)&m_OutState, sizeof(m_OutState));
}
/* ============================================================================
CGameServerBLoggedOnCall
============================================================================ */
std::string CGameServerBLoggedOnCall::toString()
{
std::stringstream ss;
ss << "GS::BLoggedOn( ) => " << m_Res;
return ss.str();
}
bool CGameServerBLoggedOnCall::compareInputArgs(IEngExtCall* other, bool strict)
{
CGameServerBLoggedOnCall* otherCall = dynamic_cast<CGameServerBLoggedOnCall*>(other);
if (otherCall == NULL)
return false;
return true;
}
void CGameServerBLoggedOnCall::writeEpilogue(std::ostream &stream) {
stream.write((char*)&m_Res, 1);
}
void CGameServerBLoggedOnCall::readEpilogue(std::istream &stream) {
m_Res = false;
stream.read((char*)&m_Res, 1);
}
/*
class CGameServerBLoggedOnCall : public IEngExtCall {
public:
bool m_Res;
public:
CGameServerBLoggedOnCall() { m_Res = false; }
void setResult(bool res) { m_Res = res; }
virtual bool compareInputArgs(IEngExtCall* other);
virtual std::string toString();
virtual ExtCallFuncs getOpcode() { return ECF_GS_BLOGGEDON; }
virtual void writeEpilogue(std::ostream &stream);
virtual void readEpilogue(std::istream &stream);
};
*/
#define IEngExtCallFactory_CreateFuncCall(clazz, buf, bufLen) \
if (sizeof(clazz) > bufLen) regamedll_syserror("%s: buffer to small", __FUNCTION__); \
return new(buf) clazz();
IEngExtCall* IEngExtCallFactory::createByOpcode(ExtCallFuncs opc, void* buf, int ptrSize) {
switch (opc) {
case ECF_SLEEP: IEngExtCallFactory_CreateFuncCall(CSleepExtCall, buf, ptrSize);
case ECF_QUERY_PERF_FREQ: IEngExtCallFactory_CreateFuncCall(CQueryPerfFreqCall, buf, ptrSize);
case ECF_QUERY_PERF_COUNTER: IEngExtCallFactory_CreateFuncCall(CQueryPerfCounterCall, buf, ptrSize);
case ECF_GET_TICK_COUNT: IEngExtCallFactory_CreateFuncCall(CGetTickCountCall, buf, ptrSize);
case ECF_GET_LOCAL_TIME: IEngExtCallFactory_CreateFuncCall(CGetLocalTimeCall, buf, ptrSize);
case ECF_GET_SYSTEM_TIME: IEngExtCallFactory_CreateFuncCall(CGetSystemTimeCall, buf, ptrSize);
case ECF_GET_TIMEZONE_INFO: IEngExtCallFactory_CreateFuncCall(CGetTimeZoneInfoCall, buf, ptrSize);
case ECF_SOCKET: IEngExtCallFactory_CreateFuncCall(CSocketCall, buf, ptrSize);
case ECF_IOCTL_SOCKET: IEngExtCallFactory_CreateFuncCall(CIoCtlSocketCall, buf, ptrSize);
case ECF_SET_SOCK_OPT: IEngExtCallFactory_CreateFuncCall(CSetSockOptCall, buf, ptrSize);
case ECF_CLOSE_SOCKET: IEngExtCallFactory_CreateFuncCall(CCloseSocketCall, buf, ptrSize);
case ECF_RECVFROM: IEngExtCallFactory_CreateFuncCall(CRecvFromCall, buf, ptrSize);
case ECF_SENDTO: IEngExtCallFactory_CreateFuncCall(CSendToCall, buf, ptrSize);
case ECF_BIND: IEngExtCallFactory_CreateFuncCall(CBindCall , buf, ptrSize);
case ECF_GET_SOCK_NAME: IEngExtCallFactory_CreateFuncCall(CGetSockNameCall, buf, ptrSize);
case ECF_WSA_GET_LAST_ERROR: IEngExtCallFactory_CreateFuncCall(CWSAGetLastErrorCall, buf, ptrSize);
case ECF_STEAM_CALLBACK_CALL_1: IEngExtCallFactory_CreateFuncCall(CSteamCallbackCall1, buf, ptrSize);
case ECF_STEAM_CALLBACK_CALL_2: IEngExtCallFactory_CreateFuncCall(CSteamCallbackCall2, buf, ptrSize);
case ECF_STEAM_API_REGISTER_CALLBACK: IEngExtCallFactory_CreateFuncCall(CSteamApiRegisterCallbackCall, buf, ptrSize);
case ECF_STEAM_API_INIT: IEngExtCallFactory_CreateFuncCall(CSteamApiRegisterCallbackCall, buf, ptrSize);
case ECF_STEAM_API_UNREGISTER_CALL_RESULT: IEngExtCallFactory_CreateFuncCall(CSteamApiUnrigestierCallResultCall, buf, ptrSize);
case ECF_STEAMAPPS: IEngExtCallFactory_CreateFuncCall(CSteamAppsCall, buf, ptrSize);
case ECF_STEAMAPPS_GET_CURRENT_GAME_LANGUAGE: IEngExtCallFactory_CreateFuncCall(CSteamAppGetCurrentGameLanguageCall, buf, ptrSize);
case ECF_STEAMGAMESERVER_INIT: IEngExtCallFactory_CreateFuncCall(CSteamGameServerInitCall, buf, ptrSize);
case ECF_STEAMGAMESERVER: IEngExtCallFactory_CreateFuncCall(CSteamGameServerCall, buf, ptrSize);
case ECF_GS_SET_PRODUCT: IEngExtCallFactory_CreateFuncCall(CGameServerSetProductCall, buf, ptrSize);
case ECF_GS_SET_GAME_DIR: IEngExtCallFactory_CreateFuncCall(CGameServerSetModDirCall, buf, ptrSize);
case ECF_GS_SET_DEDICATED_SERVER: IEngExtCallFactory_CreateFuncCall(CGameServerSetDedicatedServerCall, buf, ptrSize);
case ECF_GS_SET_GAME_DESC: IEngExtCallFactory_CreateFuncCall(CGameServerSetGameDescCall, buf, ptrSize);
case ECF_GS_LOG_ON_ANONYMOUS: IEngExtCallFactory_CreateFuncCall(CGameServerLogOnAnonymousCall, buf, ptrSize);
case ECF_GS_ENABLE_HEARTBEATS: IEngExtCallFactory_CreateFuncCall(CGameServerEnableHeartbeatsCall, buf, ptrSize);
case ECF_GS_SET_HEARTBEATS_INTERVAL: IEngExtCallFactory_CreateFuncCall(CGameServerSetHeartbeatIntervalCall, buf, ptrSize);
case ECF_GS_SET_MAX_PLAYERS_COUNT: IEngExtCallFactory_CreateFuncCall(CGameServerSetMaxPlayersCall, buf, ptrSize);
case ECF_GS_SET_BOT_PLAYERS_COUNT: IEngExtCallFactory_CreateFuncCall(CGameServerSetBotCountCall, buf, ptrSize);
case ECF_GS_SET_SERVER_NAME: IEngExtCallFactory_CreateFuncCall(CGameServerSetServerNameCall, buf, ptrSize);
case ECF_GS_SET_MAP_NAME: IEngExtCallFactory_CreateFuncCall(CGameServerSetMapNameCall, buf, ptrSize);
case ECF_GS_SET_PASSWORD_PROTECTED: IEngExtCallFactory_CreateFuncCall(CGameServerSetPasswordProtectedCall, buf, ptrSize);
case ECF_GS_CLEAR_ALL_KEY_VALUES: IEngExtCallFactory_CreateFuncCall(CGameServerClearAllKVsCall, buf, ptrSize);
case ECF_GS_SET_KEY_VALUE: IEngExtCallFactory_CreateFuncCall(CGameServerSetKeyValueCall, buf, ptrSize);
case ECF_STEAM_API_SET_BREAKPAD_APP_ID: IEngExtCallFactory_CreateFuncCall(CSteamApiSetBreakpadAppIdCall, buf, ptrSize);
case ECF_GS_WAS_RESTART_REQUESTED: IEngExtCallFactory_CreateFuncCall(CGameServerWasRestartRequestedCall, buf, ptrSize);
case ECF_STEAMGAMESERVER_RUN_CALLBACKS: IEngExtCallFactory_CreateFuncCall(CSteamGameServerRunCallbacksCall, buf, ptrSize);
case ECF_GS_GET_NEXT_OUTGOING_PACKET: IEngExtCallFactory_CreateFuncCall(CGameServerGetNextOutgoingPacketCall, buf, ptrSize);
case ECF_STEAM_API_RUN_CALLBACKS: IEngExtCallFactory_CreateFuncCall(CSteamApiRunCallbacksCall, buf, ptrSize);
case ECF_GS_GET_STEAM_ID: IEngExtCallFactory_CreateFuncCall(CGameServerGetSteamIdCall, buf, ptrSize);
case ECF_GS_BSECURE: IEngExtCallFactory_CreateFuncCall(CGameServerBSecureCall, buf, ptrSize);
case ECF_GS_HANDLE_INCOMING_PACKET: IEngExtCallFactory_CreateFuncCall(CGameServerHandleIncomingPacketCall, buf, ptrSize);
case ECF_GS_SEND_USER_CONNECT_AND_AUTHENTICATE: IEngExtCallFactory_CreateFuncCall(CGameServerSendUserConnectAndAuthenticateCall, buf, ptrSize);
case ECF_GS_SEND_USER_DISCONNECT: IEngExtCallFactory_CreateFuncCall(CGameServerSendUserDisconnectCall, buf, ptrSize);
case ECF_GS_BUPDATE_USER_DATA: IEngExtCallFactory_CreateFuncCall(CGameServerBUpdateUserDataCall, buf, ptrSize);
case ECF_GS_CREATE_UNAUTH_USER_CONNECTION: IEngExtCallFactory_CreateFuncCall(CGameServerCreateUnauthUserConnectionCall, buf, ptrSize);
case ECF_GET_HOST_BY_NAME: IEngExtCallFactory_CreateFuncCall(CGetHostByNameCall, buf, ptrSize);
case ECF_GET_HOST_NAME: IEngExtCallFactory_CreateFuncCall(CGetHostNameCall, buf, ptrSize);
case ECF_GET_PROCESS_TIMES: IEngExtCallFactory_CreateFuncCall(CGetProcessTimesCall, buf, ptrSize);
case ECF_GET_SYSTEM_TIME_AS_FILE_TIME: IEngExtCallFactory_CreateFuncCall(CGetSystemTimeAsFileTimeCall, buf, ptrSize);
case ECF_CSTD_TIME: IEngExtCallFactory_CreateFuncCall(CStdTimeCall, buf, ptrSize);
case ECF_CSTD_LOCALTIME: IEngExtCallFactory_CreateFuncCall(CStdLocalTimeCall, buf, ptrSize);
case ECF_CSTD_SRAND_CALL: IEngExtCallFactory_CreateFuncCall(CStdSrandCall, buf, ptrSize);
case ECF_CSTD_RAND_CALL: IEngExtCallFactory_CreateFuncCall(CStdRandCall, buf, ptrSize);
case ECF_GS_LOGOFF: IEngExtCallFactory_CreateFuncCall(CGameServerLogOffCall, buf, ptrSize);
case ECF_STEAMGAMESERVER_SHUTDOWN: IEngExtCallFactory_CreateFuncCall(CSteamGameServerShutdownCall, buf, ptrSize);
case ECF_STEAM_API_UNREGISTER_CALLBACK: IEngExtCallFactory_CreateFuncCall(CSteamApiUnregisterCallbackCall, buf, ptrSize);
case ECF_GS_BLOGGEDON: IEngExtCallFactory_CreateFuncCall(CGameServerBLoggedOnCall, buf, ptrSize);
default:
regamedll_syserror("%s: unknown funccall opcode %d", __FUNCTION__, opc);
return NULL;
}
}
Reference in New Issue View Git Blame Copy Permalink