void CRecordingEngExtInterceptor::SteamAPI_UnregisterCallResult(class CCallbackBase *pCallback, SteamAPICall_t hAPICall)
{
CSteamCallbackRecordingWrapper* wrappee = getOrCreateCallbackWrapper(pCallback);
if (wrappee->GetFlags() != pCallback->GetFlags()) rehlds_syserror("%s: flags desync", __FUNCTION__);
if (wrappee->GetICallback() != pCallback->GetICallback()) rehlds_syserror("%s: flags desync", __FUNCTION__);
CSteamApiUnrigestierCallResultCall fcall(wrappee->getRehldsCallbackId(), hAPICall, wrappee); CRecorderFuncCall frec(&fcall);
PushFunc(&frec);
m_BasePlatform->SteamAPI_UnregisterCallResult(wrappee, hAPICall);
fcall.setResult(wrappee);
pCallback->SetFlags(wrappee->GetFlags());
pCallback->SetICallback(wrappee->GetICallback());
PopFunc(&frec);
}
IGameClient* GetRehldsApiClient(client_t* cl)
{
int idx = cl - g_psvs.clients;
if (idx < 0 || idx >= g_psvs.maxclients)
{
rehlds_syserror(__FUNCTION__": Invalid client index %d", idx);
}
return g_GameClients[idx];
}
CRehldsFlightRecorder::CRehldsFlightRecorder() {
m_MetaRegion = (uint8*) sys_allocmem(META_REGION_SIZE);
m_DataRegion = (uint8*) sys_allocmem(DATA_REGION_SIZE);
if (!m_MetaRegion || !m_DataRegion) {
rehlds_syserror("%s: direct allocation failed", __FUNCTION__);
}
//initialize meta region header
char* metaPos = (char*)m_MetaRegion;
const char* metaSignature = "REHLDS_FLIGHTREC_META";
metaPos += sprintf(metaPos, "%s%s%s:", metaSignature, metaSignature, metaSignature);
m_pMetaHeader = (meta_header*)metaPos;
metaPos += sizeof(meta_header);
m_pRecorderState = (recorder_state*)metaPos;
metaPos += sizeof(recorder_state);
if ((metaPos - (char*)m_MetaRegion) > META_REGION_HEADER) {
rehlds_syserror("%s: Meta header overflow", __FUNCTION__);
}
//initialize data region header
char* dataPos = (char*)m_DataRegion;
const char* dataSignature = "REHLDS_FLIGHTREC_DATA";
dataPos += sprintf(dataPos, "%s%s%s:", dataSignature, dataSignature, dataSignature);
m_pDataHeader = (data_header*)dataPos;
dataPos += sizeof(data_header);
if ((dataPos - (char*)m_pDataHeader) > DATA_REGION_HEADER) {
rehlds_syserror("%s: Data header overflow", __FUNCTION__);
}
InitHeadersContent();
m_MetaRegionPtr = m_MetaRegion + META_REGION_HEADER;
m_DataRegionPtr = m_DataRegion + DATA_REGION_HEADER;
}
void CRehldsFlightRecorder::StartMessage(uint16 msg, bool entrance) {
if (msg == 0 || msg > m_pMetaHeader->numMessages) {
rehlds_syserror("%s: Invalid message id %u", __FUNCTION__, msg);
}
if (entrance) {
msg = msg | 0x8000;
}
if (m_pRecorderState->curMessage != 0) {
rehlds_syserror("%s: overlapping messages", __FUNCTION__);
}
unsigned int sz = DATA_REGION_MAIN_SIZE - m_pRecorderState->wpos;
if (sz < 6) {
MoveToStart();
}
m_pRecorderState->curMessage = msg;
m_pRecorderState->lastMsgBeginPos = m_pRecorderState->wpos;
*(uint16*)(m_DataRegionPtr + m_pRecorderState->wpos) = msg;
m_pRecorderState->wpos += 2;
}
void CRehldsFlightRecorder::EndMessage(uint16 msg, bool entrance) {
if (entrance) {
msg = msg | 0x8000;
}
if (m_pRecorderState->curMessage != msg) {
rehlds_syserror("%s: invalid message %u", __FUNCTION__, msg);
}
unsigned int freeSz = DATA_REGION_MAIN_SIZE - m_pRecorderState->wpos;
if (freeSz < 2) {
MoveToStart();
}
unsigned int msgSize = m_pRecorderState->wpos - m_pRecorderState->lastMsgBeginPos;
if (msgSize > MSG_MAX_SIZE) {
rehlds_syserror("%s: too big message %u; size%u", __FUNCTION__, msg, msgSize);
}
*(uint16*)(m_DataRegionPtr + m_pRecorderState->wpos) = msgSize;
m_pRecorderState->wpos += 2;
m_pRecorderState->curMessage = 0;
}
void CRehldsFlightRecorder::WriteBuffer(const void* data, unsigned int len) {
if (m_pRecorderState->curMessage == 0) {
rehlds_syserror("%s: Could not write, invalid state", __FUNCTION__);
}
CheckSize(len);
unsigned int freeSz = DATA_REGION_MAIN_SIZE - m_pRecorderState->wpos;
if (freeSz < len) {
MoveToStart();
}
memcpy(m_DataRegionPtr + m_pRecorderState->wpos, data, len);
m_pRecorderState->wpos += len;
}
void CRecordingEngExtInterceptor::PopFunc(CRecorderFuncCall* func)
{
if (func != m_LastFunc)
rehlds_syserror("%s: stack corrupted", __FUNCTION__);
writeCall(!func->m_StartWritten, true, func->m_FuncCall);
if (m_LastFunc->m_Prev == NULL) {
m_LastFunc = m_RootFunc = NULL;
}
else
{
m_LastFunc = m_LastFunc->m_Prev;
m_LastFunc->m_Next = NULL;
}
}
bool CSteamAppsRecordingWrapper::BIsVACBanned()
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return false;
}
HAuthTicket CSteamGameServerRecordingWrapper::GetAuthSessionTicket(void *pTicket, int cbMaxTicket, uint32 *pcbTicket)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return k_HAuthTicketInvalid;
}
int Netchan_CreateFileFragments_(qboolean server, netchan_t *chan, const char *filename)
#endif // REHLDS_FIXES
{
int chunksize;
int compressedFileTime;
FileHandle_t hfile;
signed int filesize;
int remaining;
fragbufwaiting_t *p;
int send;
fragbuf_t *buf;
char compressedfilename[MAX_PATH];
qboolean firstfragment;
int bufferid;
qboolean bCompressed;
int pos;
fragbufwaiting_t *wait;
int uncompressed_size;
bufferid = 1;
firstfragment = TRUE;
bCompressed = FALSE;
chunksize = chan->pfnNetchan_Blocksize(chan->connection_status);
Q_snprintf(compressedfilename, sizeof compressedfilename, "%s.ztmp", filename);
compressedFileTime = FS_GetFileTime(compressedfilename);
if (compressedFileTime >= FS_GetFileTime(filename) && (hfile = FS_Open(compressedfilename, "rb")))
{
filesize = FS_Size(hfile);
FS_Close(hfile);
bCompressed = TRUE;
hfile = FS_Open(filename, "rb");
if (!hfile)
{
Con_Printf("Warning: Unable to open %s for transfer\n", filename);
return 0;
}
uncompressed_size = FS_Size(hfile);
if (uncompressed_size > sv_filetransfermaxsize.value)
{
FS_Close(hfile);
Con_Printf("Warning: File %s is too big to transfer from host %s\n", filename, NET_AdrToString(chan->remote_address));
return 0;
}
}
else
{
hfile = FS_Open(filename, "rb");
if (!hfile)
{
Con_Printf("Warning: Unable to open %s for transfer\n", filename);
return 0;
}
filesize = FS_Size(hfile);
if (filesize > sv_filetransfermaxsize.value)
{
FS_Close(hfile);
Con_Printf("Warning: File %s is too big to transfer from host %s\n", filename, NET_AdrToString(chan->remote_address));
return 0;
}
uncompressed_size = filesize;
if (sv_filetransfercompression.value != 0.0)
{
unsigned char* uncompressed = (unsigned char*)Mem_Malloc(filesize);
unsigned char* compressed = (unsigned char*)Mem_Malloc(filesize);
unsigned int compressedSize = filesize;
FS_Read(uncompressed, filesize, 1, hfile);
if (BZ_OK == BZ2_bzBuffToBuffCompress((char*)compressed, &compressedSize, (char*)uncompressed, filesize, 9, 0, 30))
{
FileHandle_t destFile = FS_Open(compressedfilename, "wb");
if (destFile)
{
Con_DPrintf("Creating compressed version of file %s (%d -> %d)\n", filename, filesize, compressedSize);
FS_Write(compressed, compressedSize, 1, destFile);
FS_Close(destFile);
filesize = compressedSize;
bCompressed = TRUE;
}
}
Mem_Free(uncompressed);
Mem_Free(compressed);
}
}
FS_Close(hfile);
wait = (fragbufwaiting_t *)Mem_ZeroMalloc(0xCu);
remaining = filesize;
pos = 0;
while (remaining)
{
send = min(chunksize, remaining);
buf = Netchan_AllocFragbuf();
if (!buf)
{
Con_Printf("Couldn't allocate fragbuf_t\n");
Mem_Free(wait);
if (server)
{
#ifdef REHLDS_FIXES
SV_DropClient(&g_psvs.clients[chan->player_slot - 1], 0, "Malloc problem");
#else // REHLDS_FIXES
SV_DropClient(host_client, 0, "Malloc problem");
#endif // REHLDS_FIXES
return 0;
}
else
{
rehlds_syserror("%s: Reverse clientside code", __func__);
//return 0;
}
}
buf->bufferid = bufferid++;
SZ_Clear(&buf->frag_message);
if (firstfragment)
{
firstfragment = FALSE;
MSG_WriteString(&buf->frag_message, filename);
MSG_WriteString(&buf->frag_message, bCompressed ? "bz2" : "uncompressed");
MSG_WriteLong(&buf->frag_message, uncompressed_size);
send -= buf->frag_message.cursize;
}
buf->isfile = TRUE;
buf->iscompressed = bCompressed;
buf->size = send;
buf->foffset = pos;
Q_strncpy(buf->filename, filename, MAX_PATH - 1);
buf->filename[MAX_PATH - 1] = 0;
pos += send;
remaining -= send;
Netchan_AddFragbufToTail(wait, buf);
}
if (!chan->waitlist[FRAG_FILE_STREAM])
{
chan->waitlist[FRAG_FILE_STREAM] = wait;
}
else
{
p = chan->waitlist[FRAG_FILE_STREAM];
while (p->next)
p = p->next;
p->next = wait;
}
return 1;
}
ISteamHTTP* __cdecl SteamHTTP_hooked()
{
rehlds_syserror("%s: not implemented", __func__);
//return NULL;
}
void __cdecl SteamAPI_Shutdown_hooked()
{
rehlds_syserror("%s: not implemented", __func__);
}
void __cdecl SteamAPI_SetMiniDumpComment_hooked(const char *pchMsg)
{
rehlds_syserror("%s: not implemented", __func__);
}
void CSteamGameServerRecordingWrapper::GetGameplayStats()
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
}
bool CSteamGameServerRecordingWrapper::RequestUserGroupStatus(CSteamID steamIDUser, CSteamID steamIDGroup)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return false;
}
EUserHasLicenseForAppResult CSteamGameServerRecordingWrapper::UserHasLicenseForApp(CSteamID steamID, AppId_t appID)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return k_EUserHasLicenseResultDoesNotHaveLicense;
}
void CSteamGameServerRecordingWrapper::CancelAuthTicket(HAuthTicket hAuthTicket)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
}
void CSteamGameServerRecordingWrapper::EndAuthSession(CSteamID steamID)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
}
EBeginAuthSessionResult CSteamGameServerRecordingWrapper::BeginAuthSession(const void *pAuthTicket, int cbAuthTicket, CSteamID steamID)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return k_EBeginAuthSessionResultInvalidTicket;
}
void CSteamGameServerRecordingWrapper::SetGameData(const char *pchGameData)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
}
const char* CSteamAppsRecordingWrapper::GetAvailableGameLanguages()
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return NULL;
}
SteamAPICall_t CSteamGameServerRecordingWrapper::GetServerReputation()
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return k_uAPICallInvalid;
}
void __cdecl SteamAPI_WriteMiniDump_hooked(uint32 uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID)
{
rehlds_syserror("%s: not implemented", __func__);
}
uint32 CSteamGameServerRecordingWrapper::GetPublicIP()
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return 0;
}
void __cdecl SteamAPI_RegisterCallResult_hooked(class CCallbackBase *pCallback, SteamAPICall_t hAPICall)
{
rehlds_syserror("%s: not implemented", __func__);
}
SteamAPICall_t CSteamGameServerRecordingWrapper::AssociateWithClan(CSteamID steamIDClan)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return k_uAPICallInvalid;
}
void Netchan_CreateFileFragmentsFromBuffer(qboolean server, netchan_t *chan, const char *filename, unsigned char *uncompressed_pbuf, int uncompressed_size)
{
int chunksize;
int send;
fragbufwaiting_t *p;
fragbuf_t *buf;
unsigned char *pbuf;
qboolean bCompressed;
qboolean firstfragment;
signed int bufferid;
int remaining;
int pos;
unsigned int size;
fragbufwaiting_t *wait;
if (!uncompressed_size)
return;
bufferid = 1;
firstfragment = TRUE;
size = uncompressed_size;
pbuf = (unsigned char *)Mem_Malloc(uncompressed_size);
if (BZ2_bzBuffToBuffCompress((char*)pbuf, &size, (char*)uncompressed_pbuf, uncompressed_size, 9, 0, 30))
{
bCompressed = FALSE;
Mem_Free(pbuf);
pbuf = uncompressed_pbuf;
size = uncompressed_size;
}
else
{
bCompressed = TRUE;
Con_DPrintf("Compressed %s for transmission (%d -> %d)\n", filename, uncompressed_size, size);
}
chunksize = chan->pfnNetchan_Blocksize(chan->connection_status);
send = chunksize;
wait = (fragbufwaiting_t *)Mem_ZeroMalloc(0xCu);
remaining = size;
pos = 0;
while (remaining > 0)
{
send = min(remaining, chunksize);
buf = (fragbuf_t *)Netchan_AllocFragbuf();
if (!buf)
{
Con_Printf("Couldn't allocate fragbuf_t\n");
Mem_Free(wait);
if (server)
SV_DropClient(host_client, 0, "Malloc problem");
else
rehlds_syserror("%s:Reverse me: client-side code", __func__);
#ifdef REHLDS_FIXES
if (bCompressed) {
Mem_Free(pbuf);
}
#endif
return;
}
buf->bufferid = bufferid++;
SZ_Clear(&buf->frag_message);
if (firstfragment)
{
firstfragment = FALSE;
MSG_WriteString(&buf->frag_message, filename);
MSG_WriteString(&buf->frag_message, bCompressed ? "bz2" : "uncompressed");
MSG_WriteLong(&buf->frag_message, uncompressed_size);
send -= buf->frag_message.cursize;
}
buf->isbuffer = TRUE;
buf->isfile = TRUE;
buf->size = send;
buf->foffset = pos;
MSG_WriteBuf(&buf->frag_message, send, &pbuf[pos]);
pos += send;
remaining -= send;
Netchan_AddFragbufToTail(wait, buf);
}
if (!chan->waitlist[FRAG_FILE_STREAM]) {
chan->waitlist[FRAG_FILE_STREAM] = wait;
}
else
{
p = chan->waitlist[FRAG_FILE_STREAM];
while (p->next)
p = p->next;
p->next = wait;
}
#ifdef REHLDS_FIXES
if (bCompressed) {
Mem_Free(pbuf);
}
#endif
}
SteamAPICall_t CSteamGameServerRecordingWrapper::ComputeNewPlayerCompatibility(CSteamID steamIDNewPlayer)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
return k_uAPICallInvalid;
}
void CSteamGameServerRecordingWrapper::ForceHeartbeat()
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
}
void CSteamGameServerRecordingWrapper::SetRegion(const char *pszRegion)
{
rehlds_syserror("%s: not implemented", __FUNCTION__);
}
