reHLDS/rehlds
2
0
Fork 0
mirror of https://github.com/rehlds/rehlds.git synced 2025-03-27 04:39:02 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #30 from theAsmodai/master

Browse Source 
Fixed message fragments validation.
This commit is contained in:
dreamstalker 2015-06-07 22:29:04 +04:00
commit fe10787125
34 changed files with 327 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
rehlds/engine/client.h
View File

@ -137,7 +137,7 @@ typedef struct client_static_s
cactive_t state; cactive_t state;
netchan_t netchan; netchan_t netchan;
sizebuf_t datagram; sizebuf_t datagram;
byte datagram_buf[4000]; byte datagram_buf[MAX_DATAGRAM];
double connect_time; double connect_time;
int connect_retry; int connect_retry;
int challenge; int challenge;
@ -146,7 +146,7 @@ typedef struct client_static_s
char trueaddress[32]; char trueaddress[32];
float slist_time; float slist_time;
int signon; int signon;
char servername[260]; char servername[MAX_PATH];
char mapstring[64]; char mapstring[64];
char spawnparms[2048]; char spawnparms[2048];
char userinfo[256]; char userinfo[256];
@ -164,7 +164,7 @@ typedef struct client_static_s
FileHandle_t demoheader; FileHandle_t demoheader;
qboolean demowaiting; qboolean demowaiting;
qboolean demoappending; qboolean demoappending;
char demofilename[260]; char demofilename[MAX_PATH];
int demoframecount; int demoframecount;
int td_lastframe; int td_lastframe;
int td_startframe; int td_startframe;
@ -174,7 +174,7 @@ typedef struct client_static_s
double packet_loss_recalc_time; double packet_loss_recalc_time;
int playerbits; int playerbits;
soundfade_t soundfade; soundfade_t soundfade;
char physinfo[256]; char physinfo[MAX_PHYSINFO_STRING];
unsigned char md5_clientdll[16]; unsigned char md5_clientdll[16];
netadr_t game_stream; netadr_t game_stream;
netadr_t connect_stream; netadr_t connect_stream;
@ -210,7 +210,7 @@ typedef struct client_state_s
vec3_t simorg; vec3_t simorg;
vec3_t simvel; vec3_t simvel;
vec3_t simangles; vec3_t simangles;
vec_t predicted_origins[64][3]; vec3_t predicted_origins[64];
vec3_t prediction_error; vec3_t prediction_error;
float idealpitch; float idealpitch;
vec3_t viewheight; vec3_t viewheight;

8
rehlds/engine/cmd.cpp
View File

@ -92,7 +92,7 @@ void Cbuf_InsertText(char *text)
#ifdef REHLDS_FIXES #ifdef REHLDS_FIXES
if (currLen) if (currLen)
memmove(cmd_text.data + addLen, cmd_text.data, currLen); Q_memmove(cmd_text.data + addLen, cmd_text.data, currLen);
Q_memcpy(cmd_text.data, text, addLen); Q_memcpy(cmd_text.data, text, addLen);
cmd_text.cursize += addLen; cmd_text.cursize += addLen;
@ -131,7 +131,7 @@ void Cbuf_InsertTextLines(char *text)
#ifdef REHLDS_FIXES #ifdef REHLDS_FIXES
if (currLen) if (currLen)
memmove(cmd_text.data + addLen + 1, cmd_text.data, currLen); Q_memmove(cmd_text.data + addLen + 1, cmd_text.data, currLen);
cmd_text.data[0] = '\n'; // TODO: Why we need leading \n, if there is no commands in the start? cmd_text.data[0] = '\n'; // TODO: Why we need leading \n, if there is no commands in the start?
Q_memcpy(&cmd_text.data[1], text, addLen); Q_memcpy(&cmd_text.data[1], text, addLen);
@ -225,7 +225,7 @@ void Cbuf_Execute(void)
cmd_text.cursize -= i; cmd_text.cursize -= i;
#ifdef REHLDS_FIXES #ifdef REHLDS_FIXES
// dst overlaps src // dst overlaps src
memmove(text, text + i, cmd_text.cursize); Q_memmove(text, text + i, cmd_text.cursize);
#else // REHLDS_FIXES #else // REHLDS_FIXES
Q_memcpy(text, text + i, cmd_text.cursize); Q_memcpy(text, text + i, cmd_text.cursize);
#endif // REHLDS_FIXES #endif // REHLDS_FIXES
@ -559,7 +559,7 @@ void Cmd_Shutdown(void)
{ {
Z_Free(cmd_argv[i]); Z_Free(cmd_argv[i]);
} }
memset(cmd_argv, 0, sizeof(cmd_argv)); Q_memset(cmd_argv, 0, sizeof(cmd_argv));
cmd_argc = 0; cmd_argc = 0;
cmd_args = NULL; cmd_args = NULL;

2
rehlds/engine/com_custom.cpp
View File

@ -95,7 +95,7 @@ qboolean COM_CreateCustomization(customization_t *pListHead, resource_t *pResour
*pCustomization = 0; *pCustomization = 0;
pCust = (customization_t *)Mem_ZeroMalloc(sizeof(customization_t)); pCust = (customization_t *)Mem_ZeroMalloc(sizeof(customization_t));
memcpy(&pCust->resource, pResource, sizeof(pCust->resource)); Q_memcpy(&pCust->resource, pResource, sizeof(pCust->resource));
if (pResource->nDownloadSize <= 0) if (pResource->nDownloadSize <= 0)
{ {
bError = 1; bError = 1;

6
rehlds/engine/common.cpp
View File

@ -2030,7 +2030,7 @@ NOXREF int COM_ExpandFilename(char *filename)
char netpath[MAX_PATH]; char netpath[MAX_PATH];
FS_GetLocalPath(filename, netpath, ARRAYSIZE(netpath)); FS_GetLocalPath(filename, netpath, ARRAYSIZE(netpath));
strcpy(filename, netpath); Q_strcpy(filename, netpath);
return *filename != 0; return *filename != 0;
} }
@ -2303,12 +2303,12 @@ void COM_ParseDirectoryFromCmd(const char *pCmdName, char *pDirName, const char
if (pParameter) if (pParameter)
{ {
// Grab it // Grab it
strcpy(pDirName, pParameter); Q_strcpy(pDirName, pParameter);
} }
else if (pDefault) else if (pDefault)
{ {
// Ok, then use the default // Ok, then use the default
strcpy(pDirName, pDefault); Q_strcpy(pDirName, pDefault);
} }
else else
{ {

1
rehlds/engine/common.h
View File

@ -119,6 +119,7 @@ extern int loadsize;
#define Q_memset memset #define Q_memset memset
#define Q_memcpy memcpy #define Q_memcpy memcpy
#define Q_memmove memmove
#define Q_strlen strlen #define Q_strlen strlen
#define Q_memcmp memcmp #define Q_memcmp memcmp
#define Q_strcpy strcpy #define Q_strcpy strcpy

2
rehlds/engine/delta_jit.cpp
View File

@ -65,7 +65,7 @@ void DELTAJIT_CreateDescription(delta_t* delta, deltajitdata_t &jitdesc) {
return; return;
} }
memset(&jitdesc, 0, sizeof(jitdesc)); Q_memset(&jitdesc, 0, sizeof(jitdesc));
jitdesc.numblocks = numMemBlocks; jitdesc.numblocks = numMemBlocks;
jitdesc.numFields = delta->fieldCount; jitdesc.numFields = delta->fieldCount;

6
rehlds/engine/ed_strpool.cpp
View File

@ -20,7 +20,7 @@ CStringPoolMap g_EdStringPool;
sizebuf_t g_EdStringPool_Hunk; sizebuf_t g_EdStringPool_Hunk;
void Ed_StrPool_Init() { void Ed_StrPool_Init() {
memset(&g_EdStringPool_Hunk, 0, sizeof(g_EdStringPool_Hunk)); Q_memset(&g_EdStringPool_Hunk, 0, sizeof(g_EdStringPool_Hunk));
g_EdStringPool_Hunk.maxsize = 128 * 1024; g_EdStringPool_Hunk.maxsize = 128 * 1024;
g_EdStringPool_Hunk.data = (byte*) Hunk_AllocName(g_EdStringPool_Hunk.maxsize, "Ed_StrPool"); g_EdStringPool_Hunk.data = (byte*) Hunk_AllocName(g_EdStringPool_Hunk.maxsize, "Ed_StrPool");
@ -43,7 +43,7 @@ char* Ed_StrPool_Alloc(const char* origStr) {
Sys_Error(__FUNCTION__ ": Too long string allocated: %s", origStr); Sys_Error(__FUNCTION__ ": Too long string allocated: %s", origStr);
} }
strcpy(str, origStr); Q_strcpy(str, origStr);
char* new_p = str; char* new_p = str;
for (unsigned int i = 0; i < len; i++, new_p++) for (unsigned int i = 0; i < len; i++, new_p++)
{ {
@ -80,7 +80,7 @@ char* Ed_StrPool_Alloc(const char* origStr) {
if (!val) { if (!val) {
val = (char*) Hunk_Alloc(len); val = (char*) Hunk_Alloc(len);
memcpy(val, str, len); Q_memcpy(val, str, len);
} }
g_EdStringPool.put(val, val); g_EdStringPool.put(val, val);

6
rehlds/engine/filesystem.cpp
View File

@ -325,7 +325,7 @@ int FileSystem_SetGameDirectory(const char *pDefaultDir, const char *pGameDir)
} }
pchLang = CRehldsPlatformHolder::get()->SteamApps() ? CRehldsPlatformHolder::get()->SteamApps()->GetCurrentGameLanguage() : NULL; pchLang = CRehldsPlatformHolder::get()->SteamApps() ? CRehldsPlatformHolder::get()->SteamApps()->GetCurrentGameLanguage() : NULL;
strncpy(language, pchLang ? pchLang : "english", sizeof(language)); Q_strncpy(language, pchLang ? pchLang : "english", sizeof(language));
if (!g_bIsDedicatedServer && !IsGameSubscribed(pGameDir)) if (!g_bIsDedicatedServer && !IsGameSubscribed(pGameDir))
return 0; return 0;
@ -469,12 +469,12 @@ int FileSystem_AddFallbackGameDir(const char *pGameDir)
char language[128]; char language[128];
const char * pchLang = CRehldsPlatformHolder::get()->SteamApps() ? CRehldsPlatformHolder::get()->SteamApps()->GetCurrentGameLanguage() : NULL; const char * pchLang = CRehldsPlatformHolder::get()->SteamApps() ? CRehldsPlatformHolder::get()->SteamApps()->GetCurrentGameLanguage() : NULL;
strncpy(language, pchLang ? pchLang : "english", sizeof(language)); Q_strncpy(language, pchLang ? pchLang : "english", sizeof(language));
if (strlen(language) != 0 && Q_stricmp(language, "english")) if (strlen(language) != 0 && Q_stricmp(language, "english"))
{ {
char temp[MAX_PATH]; char temp[MAX_PATH];
sprintf(temp, "%s/%s_%s", GetBaseDirectory(), pGameDir, language); Q_sprintf(temp, "%s/%s_%s", GetBaseDirectory(), pGameDir, language);
g_pFileSystem->AddSearchPath(temp, "GAME"); g_pFileSystem->AddSearchPath(temp, "GAME");
} }
g_pFileSystem->AddSearchPath(pGameDir, "GAME"); g_pFileSystem->AddSearchPath(pGameDir, "GAME");

4
rehlds/engine/filesystem_internal.cpp
View File

@ -341,13 +341,13 @@ void FS_Rename(const char *originalName, const char *newName)
if (FS_GetLocalPath(originalName, localPath, 512)) if (FS_GetLocalPath(originalName, localPath, 512))
{ {
strcpy(newPath, localPath); Q_strcpy(newPath, localPath);
cut = strstr(newPath, originalName); cut = strstr(newPath, originalName);
if (cut) if (cut)
{ {
*cut = 0; *cut = 0;
strcat(newPath, newName); Q_strcat(newPath, newName);
rename(localPath, newPath); rename(localPath, newPath);
} }
} }

58
rehlds/engine/hashpak.cpp
View File

@ -163,7 +163,7 @@ qboolean HPAK_FindResource(hash_pack_directory_t *pDir, unsigned char *hash, str
if (Q_memcmp(hash, pDir->p_rgEntries[i].resource.rgucMD5_hash, 16) == 0) if (Q_memcmp(hash, pDir->p_rgEntries[i].resource.rgucMD5_hash, 16) == 0)
{ {
if (pResourceEntry) if (pResourceEntry)
memcpy(pResourceEntry, &pDir->p_rgEntries[i].resource, sizeof(resource_t)); Q_memcpy(pResourceEntry, &pDir->p_rgEntries[i].resource, sizeof(resource_t));
return TRUE; return TRUE;
} }
@ -180,7 +180,7 @@ void HPAK_AddToQueue(char *pakname, struct resource_s *pResource, void *pData, F
Q_memset(n, 0, sizeof(hash_pack_queue_t)); Q_memset(n, 0, sizeof(hash_pack_queue_t));
n->pakname = Mem_Strdup(pakname); n->pakname = Mem_Strdup(pakname);
memcpy(&n->resource, pResource, sizeof(resource_t)); Q_memcpy(&n->resource, pResource, sizeof(resource_t));
n->datasize = pResource->nDownloadSize; n->datasize = pResource->nDownloadSize;
n->data = Mem_Malloc(pResource->nDownloadSize); n->data = Mem_Malloc(pResource->nDownloadSize);
if (!n->data) if (!n->data)
@ -363,7 +363,7 @@ void HPAK_AddLump(qboolean bUseQueue, char *pakname, struct resource_s *pResourc
pNewEntry = &newdirectory.p_rgEntries[i]; pNewEntry = &newdirectory.p_rgEntries[i];
while (i < olddirectory.nEntries) while (i < olddirectory.nEntries)
{ {
memcpy(&newdirectory.p_rgEntries[i + 1], &olddirectory.p_rgEntries[i + 1], sizeof(hash_pack_entry_t)); Q_memcpy(&newdirectory.p_rgEntries[i + 1], &olddirectory.p_rgEntries[i + 1], sizeof(hash_pack_entry_t));
i++; i++;
} }
break; break;
@ -378,7 +378,7 @@ void HPAK_AddLump(qboolean bUseQueue, char *pakname, struct resource_s *pResourc
Q_memset(pNewEntry, 0, sizeof(hash_pack_entry_t)); Q_memset(pNewEntry, 0, sizeof(hash_pack_entry_t));
FS_Seek(iWrite, hash_pack_header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD); FS_Seek(iWrite, hash_pack_header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
memcpy(&pNewEntry->resource, pResource, sizeof(resource_t)); Q_memcpy(&pNewEntry->resource, pResource, sizeof(resource_t));
pNewEntry->nOffset = FS_Tell(iWrite); pNewEntry->nOffset = FS_Tell(iWrite);
pNewEntry->nFileLength = pResource->nDownloadSize; pNewEntry->nFileLength = pResource->nDownloadSize;
@ -523,7 +523,7 @@ void HPAK_RemoveLump(char *pakname, resource_t *pResource)
if (Q_memcmp(olddir.p_rgEntries[i].resource.rgucMD5_hash, pResource->rgucMD5_hash, 16)) if (Q_memcmp(olddir.p_rgEntries[i].resource.rgucMD5_hash, pResource->rgucMD5_hash, 16))
{ {
newentry = &newdir.p_rgEntries[n++]; newentry = &newdir.p_rgEntries[n++];
memcpy(newentry, oldentry, sizeof(hash_pack_entry_t)); Q_memcpy(newentry, oldentry, sizeof(hash_pack_entry_t));
newentry->nOffset = FS_Tell(tmp); newentry->nOffset = FS_Tell(tmp);
FS_Seek(fp, oldentry->nOffset, FILESYSTEM_SEEK_HEAD); FS_Seek(fp, oldentry->nOffset, FILESYSTEM_SEEK_HEAD);
@ -599,7 +599,7 @@ qboolean HPAK_ResourceForIndex(char *pakname, int nIndex, struct resource_s *pRe
directory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * directory.nEntries); directory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * directory.nEntries);
FS_Read(directory.p_rgEntries, sizeof(hash_pack_entry_t) * directory.nEntries, 1, fp); FS_Read(directory.p_rgEntries, sizeof(hash_pack_entry_t) * directory.nEntries, 1, fp);
entry = &directory.p_rgEntries[nIndex - 1]; entry = &directory.p_rgEntries[nIndex - 1];
memcpy(pResource, &entry->resource, sizeof(resource_t)); Q_memcpy(pResource, &entry->resource, sizeof(resource_t));
FS_Close(fp); FS_Close(fp);
Mem_Free(directory.p_rgEntries); Mem_Free(directory.p_rgEntries);
return TRUE; return TRUE;
@ -622,7 +622,7 @@ qboolean HPAK_ResourceForHash(char *pakname, unsigned char *hash, struct resourc
continue; continue;
if (pResourceEntry) if (pResourceEntry)
memcpy(pResourceEntry, &p->resource, sizeof(resource_t)); Q_memcpy(pResourceEntry, &p->resource, sizeof(resource_t));
return TRUE; return TRUE;
} }
@ -734,25 +734,25 @@ void HPAK_List_f(void)
switch (entry->resource.type) switch (entry->resource.type)
{ {
case t_sound: case t_sound:
strcpy(type, "sound"); Q_strcpy(type, "sound");
break; break;
case t_skin: case t_skin:
strcpy(type, "skin"); Q_strcpy(type, "skin");
break; break;
case t_model: case t_model:
strcpy(type, "model"); Q_strcpy(type, "model");
break; break;
case t_decal: case t_decal:
strcpy(type, "decal"); Q_strcpy(type, "decal");
break; break;
case t_generic: case t_generic:
strcpy(type, "generic"); Q_strcpy(type, "generic");
break; break;
case t_eventscript: case t_eventscript:
strcpy(type, "event"); Q_strcpy(type, "event");
break; break;
default: default:
strcpy(type, "?"); Q_strcpy(type, "?");
break; break;
} }
Con_Printf("%i: %10s %.2fK %s\n : %s\n", nCurrent + 1, type, entry->resource.nDownloadSize / 1024.0f, szFileName, MD5_Print(entry->resource.rgucMD5_hash)); Con_Printf("%i: %10s %.2fK %s\n : %s\n", nCurrent + 1, type, entry->resource.nDownloadSize / 1024.0f, szFileName, MD5_Print(entry->resource.rgucMD5_hash));
@ -834,7 +834,7 @@ void HPAK_CreatePak(char *pakname, struct resource_s *pResource, void *pData, Fi
Q_memset(hash_pack_dir.p_rgEntries, 0, sizeof(hash_pack_entry_t) * hash_pack_dir.nEntries); Q_memset(hash_pack_dir.p_rgEntries, 0, sizeof(hash_pack_entry_t) * hash_pack_dir.nEntries);
pCurrentEntry = &hash_pack_dir.p_rgEntries[0]; pCurrentEntry = &hash_pack_dir.p_rgEntries[0];
memcpy(&pCurrentEntry->resource, pResource, sizeof(resource_t)); Q_memcpy(&pCurrentEntry->resource, pResource, sizeof(resource_t));
pCurrentEntry->nOffset = FS_Tell(fp); pCurrentEntry->nOffset = FS_Tell(fp);
pCurrentEntry->nFileLength = pResource->nDownloadSize; pCurrentEntry->nFileLength = pResource->nDownloadSize;
@ -963,25 +963,25 @@ void HPAK_Validate_f(void)
switch (entry->resource.type) switch (entry->resource.type)
{ {
case t_sound: case t_sound:
strcpy(type, "sound"); Q_strcpy(type, "sound");
break; break;
case t_skin: case t_skin:
strcpy(type, "skin"); Q_strcpy(type, "skin");
break; break;
case t_model: case t_model:
strcpy(type, "model"); Q_strcpy(type, "model");
break; break;
case t_decal: case t_decal:
strcpy(type, "decal"); Q_strcpy(type, "decal");
break; break;
case t_generic: case t_generic:
strcpy(type, "generic"); Q_strcpy(type, "generic");
break; break;
case t_eventscript: case t_eventscript:
strcpy(type, "event"); Q_strcpy(type, "event");
break; break;
default: default:
strcpy(type, "?"); Q_strcpy(type, "?");
break; break;
} }
@ -1113,25 +1113,25 @@ void HPAK_Extract_f(void)
switch (entry->resource.type) switch (entry->resource.type)
{ {
case t_sound: case t_sound:
strcpy(type, "sound"); Q_strcpy(type, "sound");
break; break;
case t_skin: case t_skin:
strcpy(type, "skin"); Q_strcpy(type, "skin");
break; break;
case t_model: case t_model:
strcpy(type, "model"); Q_strcpy(type, "model");
break; break;
case t_decal: case t_decal:
strcpy(type, "decal"); Q_strcpy(type, "decal");
break; break;
case t_generic: case t_generic:
strcpy(type, "generic"); Q_strcpy(type, "generic");
break; break;
case t_eventscript: case t_eventscript:
strcpy(type, "event"); Q_strcpy(type, "event");
break; break;
default: default:
strcpy(type, "?"); Q_strcpy(type, "?");
break; break;
} }

8
rehlds/engine/host.cpp
View File

@ -1063,7 +1063,7 @@ void Host_Version(void)
Q_strcpy(gpszVersionString, "1.0.1.4"); Q_strcpy(gpszVersionString, "1.0.1.4");
Q_strcpy(gpszProductString, "valve"); Q_strcpy(gpszProductString, "valve");
strcpy(szFileName, "steam.inf"); Q_strcpy(szFileName, "steam.inf");
FileHandle_t fp = FS_Open(szFileName, "r"); FileHandle_t fp = FS_Open(szFileName, "r");
if (fp) if (fp)
{ {
@ -1088,7 +1088,7 @@ void Host_Version(void)
{ {
char szSteamVersionId[32]; char szSteamVersionId[32];
FS_GetInterfaceVersion(szSteamVersionId, sizeof(szSteamVersionId) - 1); FS_GetInterfaceVersion(szSteamVersionId, sizeof(szSteamVersionId) - 1);
_snprintf(gpszVersionString, sizeof(gpszVersionString), "%s/%s", &com_token[Q_strlen("PatchVersion=")], szSteamVersionId); Q_snprintf(gpszVersionString, sizeof(gpszVersionString), "%s/%s", &com_token[Q_strlen("PatchVersion=")], szSteamVersionId);
gpszVersionString[sizeof(gpszVersionString) - 1] = 0; gpszVersionString[sizeof(gpszVersionString) - 1] = 0;
} }
++gotKeys; ++gotKeys;
@ -1128,7 +1128,7 @@ int Host_Init(quakeparms_t *parms)
CRehldsPlatformHolder::get()->srand(CRehldsPlatformHolder::get()->time(NULL)); CRehldsPlatformHolder::get()->srand(CRehldsPlatformHolder::get()->time(NULL));
memcpy(&host_parms, parms, sizeof(host_parms)); Q_memcpy(&host_parms, parms, sizeof(host_parms));
com_argc = parms->argc; com_argc = parms->argc;
com_argv = parms->argv; com_argv = parms->argv;
realtime = 0; realtime = 0;
@ -1179,7 +1179,7 @@ int Host_Init(quakeparms_t *parms)
_snprintf(versionString, sizeof(versionString), "%s,%i,%i", gpszVersionString, PROTOCOL_VERSION, build_number()); Q_snprintf(versionString, sizeof(versionString), "%s,%i,%i", gpszVersionString, PROTOCOL_VERSION, build_number());
Cvar_Set("sv_version", versionString); Cvar_Set("sv_version", versionString);
Con_DPrintf("%4.1f Mb heap\n", (double)parms->memsize / (1024.0f * 1024.0f)); Con_DPrintf("%4.1f Mb heap\n", (double)parms->memsize / (1024.0f * 1024.0f));
R_InitTextures(); R_InitTextures();

16
rehlds/engine/host_cmd.cpp
View File

@ -508,8 +508,8 @@ void Host_Quit_Restart_f(void)
if (g_psv.active || (g_pcls.state == ca_active && g_pcls.trueaddress[0] && g_pPostRestartCmdLineArgs)) if (g_psv.active || (g_pcls.state == ca_active && g_pcls.trueaddress[0] && g_pPostRestartCmdLineArgs))
{ {
strcat(g_pPostRestartCmdLineArgs, " +connect "); Q_strcat(g_pPostRestartCmdLineArgs, " +connect ");
strcat(g_pPostRestartCmdLineArgs, g_pcls.servername); Q_strcat(g_pPostRestartCmdLineArgs, g_pcls.servername);
} }
else else
{ {
@ -520,7 +520,7 @@ void Host_Quit_Restart_f(void)
Cbuf_AddText("save quick\n"); Cbuf_AddText("save quick\n");
Cbuf_Execute(); Cbuf_Execute();
strcat(g_pPostRestartCmdLineArgs, " +load quick"); Q_strcat(g_pPostRestartCmdLineArgs, " +load quick");
} }
} }
@ -839,7 +839,7 @@ void Host_Map(qboolean bIsDemo, char *mapstring, char *mapName, qboolean loadGam
{ {
Q_strcpy(g_pcls.spawnparms, ""); Q_strcpy(g_pcls.spawnparms, "");
for (i = 0; i < Cmd_Argc(); i++) for (i = 0; i < Cmd_Argc(); i++)
strncat(g_pcls.spawnparms, Cmd_Argv(i), sizeof(g_pcls.spawnparms) - strlen(g_pcls.spawnparms) - 1); Q_strncat(g_pcls.spawnparms, Cmd_Argv(i), sizeof(g_pcls.spawnparms) - strlen(g_pcls.spawnparms) - 1);
} }
} }
if (sv_gpNewUserMsgs) if (sv_gpNewUserMsgs)
@ -898,8 +898,8 @@ void Host_Map_f(void)
mapstring[0] = 0; mapstring[0] = 0;
for (i = 0; i < Cmd_Argc(); i++) for (i = 0; i < Cmd_Argc(); i++)
{ {
strncat(mapstring, Cmd_Argv(i), 62 - Q_strlen(mapstring)); Q_strncat(mapstring, Cmd_Argv(i), 62 - Q_strlen(mapstring));
strncat(mapstring, " ", 62 - Q_strlen(mapstring)); Q_strncat(mapstring, " ", 62 - Q_strlen(mapstring));
} }
Q_strcat(mapstring, "\n"); Q_strcat(mapstring, "\n");
Q_strncpy(name, Cmd_Argv(1), sizeof(name) - 1); Q_strncpy(name, Cmd_Argv(1), sizeof(name) - 1);
@ -2312,7 +2312,7 @@ void Host_ClearSaveDirectory(void)
const char *pfn; const char *pfn;
Q_snprintf(szName, sizeof(szName), "%s", Host_SaveGameDirectory()); Q_snprintf(szName, sizeof(szName), "%s", Host_SaveGameDirectory());
strncat(szName, "*.HL?", sizeof(szName) - strlen(szName) - 1); Q_strncat(szName, "*.HL?", sizeof(szName) - strlen(szName) - 1);
COM_FixSlashes(szName); COM_FixSlashes(szName);
if (Sys_FindFirstPathID(szName, "GAMECONFIG") != NULL) if (Sys_FindFirstPathID(szName, "GAMECONFIG") != NULL)
@ -2321,7 +2321,7 @@ void Host_ClearSaveDirectory(void)
Q_snprintf(szName, sizeof(szName), "%s", Host_SaveGameDirectory()); Q_snprintf(szName, sizeof(szName), "%s", Host_SaveGameDirectory());
COM_FixSlashes(szName); COM_FixSlashes(szName);
FS_CreateDirHierarchy(szName, "GAMECONFIG"); FS_CreateDirHierarchy(szName, "GAMECONFIG");
strncat(szName, "*.HL?", sizeof(szName) - strlen(szName) - 1); Q_strncat(szName, "*.HL?", sizeof(szName) - strlen(szName) - 1);
for (pfn = Sys_FindFirstPathID(szName, "GAMECONFIG"); pfn; pfn = Sys_FindNext(NULL)) for (pfn = Sys_FindFirstPathID(szName, "GAMECONFIG"); pfn; pfn = Sys_FindNext(NULL))
{ {

2
rehlds/engine/mem.cpp
View File

@ -39,7 +39,7 @@ void *Mem_Malloc(size_t size)
void *Mem_ZeroMalloc(size_t size) void *Mem_ZeroMalloc(size_t size)
{ {
void *p = malloc(size); void *p = malloc(size);
memset(p, 0, size); Q_memset(p, 0, size);
return p; return p;
} }

10
rehlds/engine/model.cpp
View File

@ -282,10 +282,10 @@ model_t *Mod_LoadModel(model_t *mod, qboolean crash, qboolean trackCRC)
while (*(p++) == '/') while (*(p++) == '/')
; ;
strncpy(tmpName, p, sizeof(tmpName) - 1); Q_strncpy(tmpName, p, sizeof(tmpName) - 1);
tmpName[sizeof(tmpName) - 1] = '\0'; tmpName[sizeof(tmpName) - 1] = '\0';
strncpy(mod->name, tmpName, sizeof(mod->name) - 1); Q_strncpy(mod->name, tmpName, sizeof(mod->name) - 1);
mod->name[sizeof(mod->name) - 1] = '\0'; mod->name[sizeof(mod->name) - 1] = '\0';
} }
@ -392,7 +392,7 @@ void Mod_AdInit(void)
s = com_argv[i + 1]; s = com_argv[i + 1];
if (s && *s) if (s && *s)
{ {
_snprintf(filename, MAX_PATH, "%s", s); Q_snprintf(filename, MAX_PATH, "%s", s);
if (FS_FileSize(filename) > 0) if (FS_FileSize(filename) > 0)
{ {
Sys_Error("Mod_Init(): reverse me"); Sys_Error("Mod_Init(): reverse me");
@ -652,7 +652,7 @@ void Mod_LoadVisibility(lump_t *l)
return; return;
} }
loadmodel->visdata = (byte*) Hunk_AllocName(l->filelen, loadname); loadmodel->visdata = (byte*) Hunk_AllocName(l->filelen, loadname);
memcpy(loadmodel->visdata, mod_base + l->fileofs, l->filelen); Q_memcpy(loadmodel->visdata, mod_base + l->fileofs, l->filelen);
} }
/* <513a6> ../engine/model.c:913 */ /* <513a6> ../engine/model.c:913 */
@ -1326,7 +1326,7 @@ void Mod_LoadBrushModel_internal(model_t *mod, void *buffer)
if (i < mod->numsubmodels - 1) if (i < mod->numsubmodels - 1)
{ {
_snprintf(name, 10, "*%i", i + 1); Q_snprintf(name, 10, "*%i", i + 1);
submodel = Mod_FindName(0, name); submodel = Mod_FindName(0, name);
*submodel = *mod; *submodel = *mod;
loadmodel = submodel; loadmodel = submodel;

26
rehlds/engine/net.h
View File

@ -83,16 +83,25 @@
#define MAX_STREAMS 2 #define MAX_STREAMS 2
// Flow control bytes per second limits // Flow control bytes per second limits
#define MAX_RATE 20000 #define MAX_RATE 100000.0f
#define MIN_RATE 1000 #define MIN_RATE 1000.0f
// Default data rate // Default data rate
#define DEFAULT_RATE (9999.0f) #define DEFAULT_RATE (9999.0f)
// NETWORKING INFO // NETWORKING INFO
// Max size of udp packet payload
#define MAX_UDP_PACKET 4010 // 9 bytes SPLITHEADER + 4000 payload?
// Max length of a reliable message
#define MAX_MSGLEN 3990 // 10 reserved for fragheader?
// Max length of unreliable message
#define MAX_DATAGRAM 4000
// This is the packet payload without any header bytes (which are attached for actual sending) // This is the packet payload without any header bytes (which are attached for actual sending)
#define NET_MAX_PAYLOAD 3990 #define NET_MAX_PAYLOAD 65536
// This is the payload plus any header info (excluding UDP header) // This is the payload plus any header info (excluding UDP header)
@ -116,7 +125,7 @@
// Pad this to next higher 16 byte boundary // Pad this to next higher 16 byte boundary
// This is the largest packet that can come in/out over the wire, before processing the header // This is the largest packet that can come in/out over the wire, before processing the header
// bytes will be stripped by the networking channel layer // bytes will be stripped by the networking channel layer
//#define NET_MAX_MESSAGE PAD_NUMBER( ( NET_MAX_PAYLOAD + HEADER_BYTES ), 16 ) //#define NET_MAX_MESSAGE PAD_NUMBER( ( MAX_MSGLEN + HEADER_BYTES ), 16 )
// This is currently used value in the engine. TODO: define above gives 4016, check it why. // This is currently used value in the engine. TODO: define above gives 4016, check it why.
#define NET_MAX_MESSAGE 4037 #define NET_MAX_MESSAGE 4037
@ -237,7 +246,12 @@ typedef struct flow_s
// Size of fragmentation buffer internal buffers // Size of fragmentation buffer internal buffers
#define FRAGMENT_SIZE 1400 #define FRAGMENT_SIZE 1400
#ifndef REHLDS_FIXES
#define MAX_FRAGMENTS 25000 #define MAX_FRAGMENTS 25000
#else
#define MAX_FRAGMENTS ((NET_MAX_PAYLOAD + FRAGMENT_SIZE - 1) / FRAGMENT_SIZE) // should be enough for any send buf
#endif
#define UDP_HEADER_SIZE 28 #define UDP_HEADER_SIZE 28
#define MAX_RELIABLE_PAYLOAD 1200 #define MAX_RELIABLE_PAYLOAD 1200
@ -330,11 +344,11 @@ typedef struct netchan_s
// Staging and holding areas // Staging and holding areas
sizebuf_t message; sizebuf_t message;
byte message_buf[NET_MAX_PAYLOAD]; byte message_buf[MAX_MSGLEN];
// Reliable message buffer. We keep adding to it until reliable is acknowledged. Then we clear it. // Reliable message buffer. We keep adding to it until reliable is acknowledged. Then we clear it.
int reliable_length; int reliable_length;
byte reliable_buf[NET_MAX_PAYLOAD]; byte reliable_buf[MAX_MSGLEN];
// Waiting list of buffered fragments to go onto queue. Multiple outgoing buffers can be queued in succession. // Waiting list of buffered fragments to go onto queue. Multiple outgoing buffers can be queued in succession.
fragbufwaiting_t *waitlist[MAX_STREAMS]; fragbufwaiting_t *waitlist[MAX_STREAMS];

66
rehlds/engine/net_chan.cpp
View File

@ -117,12 +117,13 @@ void Netchan_OutOfBandPrint(netsrc_t sock, netadr_t adr, char *format, ...)
{ {
va_list argptr; va_list argptr;
char string[8192]; char string[8192];
size_t len;
va_start(argptr, format); va_start(argptr, format);
Q_vsnprintf(string, sizeof(string), format, argptr); len = Q_vsnprintf(string, sizeof(string), format, argptr);
va_end(argptr); va_end(argptr);
Netchan_OutOfBand(sock, adr, Q_strlen(string) + 1, (byte *)string); Netchan_OutOfBand(sock, adr, len + 1, (byte *)string);
} }
/* <65776> ../engine/net_chan.c:196 */ /* <65776> ../engine/net_chan.c:196 */
@ -379,7 +380,7 @@ void Netchan_Transmit(netchan_t *chan, int length, byte *data)
} }
if (send_from_regular) { if (send_from_regular) {
memcpy(chan->reliable_buf, chan->message_buf, chan->message.cursize); Q_memcpy(chan->reliable_buf, chan->message_buf, chan->message.cursize);
chan->reliable_length = chan->message.cursize; chan->reliable_length = chan->message.cursize;
SZ_Clear(&chan->message); SZ_Clear(&chan->message);
@ -417,7 +418,7 @@ void Netchan_Transmit(netchan_t *chan, int length, byte *data)
FileHandle_t hfile; FileHandle_t hfile;
if (pbuf->iscompressed) if (pbuf->iscompressed)
{ {
_snprintf(compressedfilename, sizeof(compressedfilename), "%s.ztmp", pbuf->filename); Q_snprintf(compressedfilename, sizeof(compressedfilename), "%s.ztmp", pbuf->filename);
hfile = FS_Open(compressedfilename, "rb"); hfile = FS_Open(compressedfilename, "rb");
} }
else else
@ -431,7 +432,7 @@ void Netchan_Transmit(netchan_t *chan, int length, byte *data)
} }
memcpy(chan->reliable_buf + chan->reliable_length, pbuf->frag_message.data, pbuf->frag_message.cursize); Q_memcpy(chan->reliable_buf + chan->reliable_length, pbuf->frag_message.data, pbuf->frag_message.cursize);
chan->reliable_length += pbuf->frag_message.cursize; chan->reliable_length += pbuf->frag_message.cursize;
chan->frag_length[i] = pbuf->frag_message.cursize; chan->frag_length[i] = pbuf->frag_message.cursize;
@ -500,7 +501,7 @@ void Netchan_Transmit(netchan_t *chan, int length, byte *data)
} }
// Is there room for the unreliable payload? // Is there room for the unreliable payload?
int max_send_size = 1400; int max_send_size = MAX_ROUTEABLE_PACKET;
if (!send_resending) if (!send_resending)
max_send_size = sb_send.maxsize; max_send_size = sb_send.maxsize;
@ -539,7 +540,7 @@ void Netchan_Transmit(netchan_t *chan, int length, byte *data)
NET_SendPacket(chan->sock, sb_send.cursize, sb_send.data, chan->remote_address); NET_SendPacket(chan->sock, sb_send.cursize, sb_send.data, chan->remote_address);
} }
if (g_psv.active && sv_lan.value != 0.0f && sv_lan_rate.value > 1000.0) if (g_psv.active && sv_lan.value != 0.0f && sv_lan_rate.value > MIN_RATE)
fRate = 1.0 / sv_lan_rate.value; fRate = 1.0 / sv_lan_rate.value;
else else
fRate = 1.0 / chan->rate; fRate = 1.0 / chan->rate;
@ -640,6 +641,7 @@ qboolean Netchan_Validate(netchan_t *chan, qboolean *frag_message, unsigned int
if (!frag_message[i]) if (!frag_message[i])
continue; continue;
#ifndef REHLDS_FIXES
if (FRAG_GETID(fragid[i]) > MAX_FRAGMENTS || FRAG_GETCOUNT(fragid[i]) > MAX_FRAGMENTS) if (FRAG_GETID(fragid[i]) > MAX_FRAGMENTS || FRAG_GETCOUNT(fragid[i]) > MAX_FRAGMENTS)
{ {
return FALSE; return FALSE;
@ -649,7 +651,27 @@ qboolean Netchan_Validate(netchan_t *chan, qboolean *frag_message, unsigned int
{ {
return FALSE; return FALSE;
} }
#else // REHLDS_FIXES
// total fragments should be <= MAX_FRAGMENTS and current fragment can't be > total fragments
if (FRAG_GETCOUNT(fragid[i]) > MAX_FRAGMENTS || FRAG_GETID(fragid[i]) > FRAG_GETCOUNT(fragid[i]))
return FALSE;
if ((size_t)frag_length[i] > FRAGMENT_SIZE || (size_t)frag_offset[i] > NET_MAX_PAYLOAD - 1)
return FALSE;
int frag_end = frag_offset[i] + frag_length[i];
// end of fragment is out of the packet
if (frag_end + msg_readcount > net_message.cursize)
return FALSE;
// fragment overlaps next stream's fragment or placed after it
for (int j = i + 1; j < MAX_STREAMS; j++)
{
if (frag_end > frag_offset[j]) // don't add msg_readcount for comparison
return FALSE;
}
#endif // REHLDS_FIXES
} }
return TRUE; return TRUE;
@ -850,17 +872,15 @@ qboolean Netchan_Process(netchan_t *chan)
} }
// Rearrange incoming data to not have the frag stuff in the middle of it // Rearrange incoming data to not have the frag stuff in the middle of it
int wpos = msg_readcount + frag_offset[i]; int wpos = msg_readcount + frag_offset[i];
int rpos = msg_readcount + frag_offset[i] + frag_length[i]; int rpos = wpos + frag_length[i];
int epos = net_message.cursize - rpos;
for (j = 0; j < epos; j++) { Q_memmove(net_message.data + wpos, net_message.data + rpos, net_message.cursize - rpos);
net_message.data[wpos + j] = net_message.data[rpos + j];
}
net_message.cursize -= frag_length[i]; net_message.cursize -= frag_length[i];
for (j = i + 1; j < MAX_STREAMS; j++) for (j = i + 1; j < MAX_STREAMS; j++)
{ {
frag_offset[j] -= frag_length[i]; frag_offset[j] -= frag_length[i]; // fragments order already validated
} }
} }
@ -1015,8 +1035,8 @@ void Netchan_CreateFragments_(qboolean server, netchan_t *chan, sizebuf_t *msg)
if (!BZ2_bzBuffToBuffCompress((char *)compressed, &compressedSize, (char *)msg->data, msg->cursize, 9, 0, 30)) if (!BZ2_bzBuffToBuffCompress((char *)compressed, &compressedSize, (char *)msg->data, msg->cursize, 9, 0, 30))
{ {
Con_DPrintf("Compressing split packet (%d -> %d bytes)\n", msg->cursize, compressedSize); Con_DPrintf("Compressing split packet (%d -> %d bytes)\n", msg->cursize, compressedSize);
memcpy(msg->data, hdr, sizeof(hdr)); Q_memcpy(msg->data, hdr, sizeof(hdr));
memcpy(msg->data + sizeof(hdr), compressed, compressedSize); Q_memcpy(msg->data + sizeof(hdr), compressed, compressedSize);
msg->cursize = compressedSize + sizeof(hdr); msg->cursize = compressedSize + sizeof(hdr);
} }
} }
@ -1189,7 +1209,7 @@ int Netchan_CreateFileFragments(qboolean server, netchan_t *chan, const char *fi
fragbufwaiting_t *p; fragbufwaiting_t *p;
int send; int send;
fragbuf_t *buf; fragbuf_t *buf;
char compressedfilename[260]; char compressedfilename[MAX_PATH];
int firstfragment; int firstfragment;
int bufferid; int bufferid;
int bCompressed; int bCompressed;
@ -1202,7 +1222,7 @@ int Netchan_CreateFileFragments(qboolean server, netchan_t *chan, const char *fi
bCompressed = FALSE; bCompressed = FALSE;
chunksize = chan->pfnNetchan_Blocksize(chan->connection_status); chunksize = chan->pfnNetchan_Blocksize(chan->connection_status);
Q_snprintf(compressedfilename, 0x104u, "%s.ztmp", filename); Q_snprintf(compressedfilename, sizeof compressedfilename, "%s.ztmp", filename);
compressedFileTime = FS_GetFileTime(compressedfilename); compressedFileTime = FS_GetFileTime(compressedfilename);
if (compressedFileTime >= FS_GetFileTime(filename)) if (compressedFileTime >= FS_GetFileTime(filename))
{ {
@ -1388,7 +1408,7 @@ qboolean Netchan_CopyNormalFragments(netchan_t *chan)
char uncompressed[65536]; char uncompressed[65536];
unsigned int uncompressedSize = 65536; unsigned int uncompressedSize = 65536;
BZ2_bzBuffToBuffDecompress(uncompressed, &uncompressedSize, (char*)net_message.data + 4, net_message.cursize - 4, 1, 0); BZ2_bzBuffToBuffDecompress(uncompressed, &uncompressedSize, (char*)net_message.data + 4, net_message.cursize - 4, 1, 0);
memcpy(net_message.data, uncompressed, uncompressedSize); Q_memcpy(net_message.data, uncompressed, uncompressedSize);
net_message.cursize = uncompressedSize; net_message.cursize = uncompressedSize;
} }
@ -1504,12 +1524,12 @@ qboolean Netchan_CopyFileFragments(netchan_t *chan)
{ {
// Copy it in // Copy it in
cursize -= msg_readcount; cursize -= msg_readcount;
memcpy(&buffer[pos], &p->frag_message.data[msg_readcount], cursize); Q_memcpy(&buffer[pos], &p->frag_message.data[msg_readcount], cursize);
p->frag_message.cursize = cursize; p->frag_message.cursize = cursize;
} }
else else
{ {
memcpy(&buffer[pos], p->frag_message.data, cursize); Q_memcpy(&buffer[pos], p->frag_message.data, cursize);
} }
pos += p->frag_message.cursize; pos += p->frag_message.cursize;
Mem_Free(p); Mem_Free(p);
@ -1550,10 +1570,10 @@ qboolean Netchan_CopyFileFragments(netchan_t *chan)
FileHandle_t handle; FileHandle_t handle;
#ifdef REHLDS_CHECKS #ifdef REHLDS_CHECKS
strncpy(filedir, filename, sizeof(filedir) - 1); Q_strncpy(filedir, filename, sizeof(filedir) - 1);
filedir[sizeof(filedir) - 1] = 0; filedir[sizeof(filedir) - 1] = 0;
#else #else
strncpy(filedir, filename, sizeof(filedir)); Q_strncpy(filedir, filename, sizeof(filedir));
#endif // REHLDS_CHECKS #endif // REHLDS_CHECKS
COM_FixSlashes(filedir); COM_FixSlashes(filedir);
pszFileName = strrchr(filedir, '\\'); pszFileName = strrchr(filedir, '\\');

110
rehlds/engine/net_ws.cpp
View File

@ -49,8 +49,8 @@ qboolean noipx;
int use_thread; int use_thread;
unsigned char net_message_buffer[65536]; unsigned char net_message_buffer[NET_MAX_PAYLOAD];
unsigned char in_message_buf[65536]; unsigned char in_message_buf[NET_MAX_PAYLOAD];
sizebuf_t in_message; sizebuf_t in_message;
netadr_t in_from; netadr_t in_from;
@ -154,7 +154,7 @@ short unsigned int Q_ntohs(short unsigned int netshort)
} }
/* <d31f4> ../engine/net_ws.c:194 */ /* <d31f4> ../engine/net_ws.c:194 */
void NetadrToSockadr(netadr_t *a, struct sockaddr *s) void NetadrToSockadr(const netadr_t *a, struct sockaddr *s)
{ {
Q_memset(s, 0, sizeof(*s)); Q_memset(s, 0, sizeof(*s));
@ -216,7 +216,7 @@ NOXREF short unsigned int NET_HostToNetShort(short unsigned int us_in)
} }
/* <d32b0> ../engine/net_ws.c:252 */ /* <d32b0> ../engine/net_ws.c:252 */
qboolean NET_CompareAdr(netadr_t a, netadr_t b) qboolean NET_CompareAdr(netadr_t& a, netadr_t& b)
{ {
if (a.type != b.type) if (a.type != b.type)
{ {
@ -249,7 +249,7 @@ qboolean NET_CompareAdr(netadr_t a, netadr_t b)
} }
/* <d32e9> ../engine/net_ws.c:277 */ /* <d32e9> ../engine/net_ws.c:277 */
qboolean NET_CompareClassBAdr(netadr_t a, netadr_t b) qboolean NET_CompareClassBAdr(netadr_t& a, netadr_t& b)
{ {
if (a.type != b.type) if (a.type != b.type)
{ {
@ -277,7 +277,7 @@ qboolean NET_CompareClassBAdr(netadr_t a, netadr_t b)
} }
/* <d3325> ../engine/net_ws.c:302 */ /* <d3325> ../engine/net_ws.c:302 */
qboolean NET_IsReservedAdr(netadr_t a) qboolean NET_IsReservedAdr(netadr_t& a)
{ {
if (a.type == NA_LOOPBACK) if (a.type == NA_LOOPBACK)
{ {
@ -314,7 +314,7 @@ qboolean NET_IsReservedAdr(netadr_t a)
} }
/* <d3352> ../engine/net_ws.c:332 */ /* <d3352> ../engine/net_ws.c:332 */
qboolean NET_CompareBaseAdr(netadr_t a, netadr_t b) qboolean NET_CompareBaseAdr(netadr_t& a, netadr_t& b)
{ {
if (a.type != b.type) if (a.type != b.type)
{ {
@ -345,7 +345,7 @@ qboolean NET_CompareBaseAdr(netadr_t a, netadr_t b)
} }
/* <d2bd7> ../engine/net_ws.c:357 */ /* <d2bd7> ../engine/net_ws.c:357 */
char *NET_AdrToString(netadr_t a) char *NET_AdrToString(const netadr_t& a)
{ {
static char s[64]; static char s[64];
@ -364,7 +364,7 @@ char *NET_AdrToString(netadr_t a)
} }
/* <d3406> ../engine/net_ws.c:375 */ /* <d3406> ../engine/net_ws.c:375 */
char *NET_BaseAdrToString(netadr_t a) char *NET_BaseAdrToString(netadr_t& a)
{ {
static char s[64]; static char s[64];
@ -515,7 +515,7 @@ qboolean NET_StringToAdr(const char *s, netadr_t *a)
} }
/* <d3579> ../engine/net_ws.c:502 */ /* <d3579> ../engine/net_ws.c:502 */
qboolean NET_IsLocalAddress(netadr_t adr) qboolean NET_IsLocalAddress(netadr_t& adr)
{ {
return adr.type == NA_LOOPBACK ? TRUE : FALSE; return adr.type == NA_LOOPBACK ? TRUE : FALSE;
} }
@ -625,7 +625,7 @@ qboolean NET_GetLoopPacket(netsrc_t sock, netadr_t *in_from_, sizebuf_t *msg)
} }
/* <d3659> ../engine/net_ws.c:612 */ /* <d3659> ../engine/net_ws.c:612 */
void NET_SendLoopPacket(netsrc_t sock, int length, void *data, netadr_t to) void NET_SendLoopPacket(netsrc_t sock, int length, void *data, const netadr_t& to)
{ {
int i; int i;
loopback_t *loop; loopback_t *loop;
@ -722,7 +722,7 @@ void NET_AddToLagged(netsrc_t sock, packetlag_t *pList, packetlag_t *pPacket, ne
pPacket->pPacketData = pStart; pPacket->pPacketData = pStart;
pPacket->nSize = messagedata.cursize; pPacket->nSize = messagedata.cursize;
pPacket->receivedTime = timestamp; pPacket->receivedTime = timestamp;
memcpy(&pPacket->net_from_, net_from_, sizeof(netadr_t)); Q_memcpy(&pPacket->net_from_, net_from_, sizeof(netadr_t));
} }
/* <d385e> ../engine/net_ws.c:731 */ /* <d385e> ../engine/net_ws.c:731 */
@ -827,7 +827,7 @@ qboolean NET_LagPacket(qboolean newdata, netsrc_t sock, netadr_t *from, sizebuf_
NET_RemoveFromPacketList(pPacket); NET_RemoveFromPacketList(pPacket);
NET_TransferRawData(&in_message, pPacket->pPacketData, pPacket->nSize); NET_TransferRawData(&in_message, pPacket->pPacketData, pPacket->nSize);
memcpy(&in_from, &pPacket->net_from_, sizeof(in_from)); Q_memcpy(&in_from, &pPacket->net_from_, sizeof(in_from));
if (pPacket->pPacketData) if (pPacket->pPacketData)
free(pPacket->pPacketData); free(pPacket->pPacketData);
@ -841,13 +841,13 @@ void NET_FlushSocket(netsrc_t sock)
struct sockaddr from; struct sockaddr from;
socklen_t fromlen; socklen_t fromlen;
int net_socket; int net_socket;
unsigned char buf[4010]; unsigned char buf[MAX_UDP_PACKET];
net_socket = ip_sockets[sock]; net_socket = ip_sockets[sock];
if (net_socket) if (net_socket)
{ {
fromlen = 16; fromlen = 16;
while (CRehldsPlatformHolder::get()->recvfrom(net_socket, (char*)buf, 4010, 0, &from, &fromlen) > 0) while (CRehldsPlatformHolder::get()->recvfrom(net_socket, (char*)buf, sizeof buf, 0, &from, &fromlen) > 0)
; ;
} }
} }
@ -855,27 +855,36 @@ void NET_FlushSocket(netsrc_t sock)
/* <d2cf1> ../engine/net_ws.c:911 */ /* <d2cf1> ../engine/net_ws.c:911 */
qboolean NET_GetLong(unsigned char *pData, int size, int *outSize) qboolean NET_GetLong(unsigned char *pData, int size, int *outSize)
{ {
int packetNumber; // 913 unsigned int packetNumber; // 913
int packetCount; // 913 unsigned int packetCount; // 913
int sequenceNumber; // 913 int sequenceNumber; // 913
unsigned char packetID; // 914 unsigned char packetID; // 914
static int gNetSplitFlags[NET_WS_MAX_FRAGMENTS]; // 918 static int gNetSplitFlags[NET_WS_MAX_FRAGMENTS]; // 918
SPLITPACKET *pHeader = (SPLITPACKET *) pData; // 915 SPLITPACKET *pHeader = (SPLITPACKET *) pData; // 915
sequenceNumber = pHeader->sequenceNumber; sequenceNumber = pHeader->sequenceNumber;
packetID = pHeader->packetID; packetID = pHeader->packetID;
packetCount = packetID & 0xF; packetCount = packetID & 0xF;
packetNumber = (unsigned int)packetID >> 4; packetNumber = (unsigned int)packetID >> 4;
if (packetNumber >= NET_WS_MAX_FRAGMENTS || packetCount > NET_WS_MAX_FRAGMENTS) if (packetNumber >= NET_WS_MAX_FRAGMENTS || packetCount > NET_WS_MAX_FRAGMENTS)
{ {
Con_Printf("Malformed packet number (%i)\n", packetID >> 4); Con_Printf("Malformed packet number (%i/%i)\n", packetNumber + 1, packetCount);
return FALSE; return FALSE;
} }
if (gNetSplit.currentSequence == -1 || sequenceNumber != gNetSplit.currentSequence) if (gNetSplit.currentSequence == -1 || sequenceNumber != gNetSplit.currentSequence)
{ {
gNetSplit.currentSequence = pHeader->sequenceNumber; gNetSplit.currentSequence = pHeader->sequenceNumber;
gNetSplit.splitCount = packetID & 0xF; gNetSplit.splitCount = packetCount;
#ifdef REHLDS_FIXES
gNetSplit.totalSize = 0;
// clear part's sequence
for (int i = 0; i < NET_WS_MAX_FRAGMENTS; i++)
gNetSplitFlags[i] = -1;
#endif
if (net_showpackets.value == 4.0f) if (net_showpackets.value == 4.0f)
Con_Printf("<-- Split packet restart %i count %i seq\n", gNetSplit.splitCount, sequenceNumber); Con_Printf("<-- Split packet restart %i count %i seq\n", gNetSplit.splitCount, sequenceNumber);
} }
@ -902,13 +911,16 @@ qboolean NET_GetLong(unsigned char *pData, int size, int *outSize)
); );
} }
if (SPLIT_SIZE * packetNumber + packetPayloadSize > 4010) if (SPLIT_SIZE * packetNumber + packetPayloadSize > MAX_UDP_PACKET)
{ {
Con_Printf("Malformed packet size (%i, %i)\n", SPLIT_SIZE * packetNumber, packetPayloadSize); Con_Printf("Malformed packet size (%i, %i)\n", SPLIT_SIZE * packetNumber, packetPayloadSize);
#ifdef REHLDS_FIXES
gNetSplit.currentSequence = -1;
#endif
return FALSE; return FALSE;
} }
memcpy(&gNetSplit.buffer[SPLIT_SIZE * packetNumber], pHeader + 1, packetPayloadSize); Q_memcpy(&gNetSplit.buffer[SPLIT_SIZE * packetNumber], pHeader + 1, packetPayloadSize);
} }
if (gNetSplit.splitCount > 0) if (gNetSplit.splitCount > 0)
@ -916,35 +928,39 @@ qboolean NET_GetLong(unsigned char *pData, int size, int *outSize)
if (packetCount > 0) if (packetCount > 0)
{ {
int i = 0; for (unsigned int i = 0; i < packetCount; i++)
while (gNetSplitFlags[i] == gNetSplit.currentSequence && i < packetCount)
++i;
if (i < packetCount)
{ {
Con_Printf( if (gNetSplitFlags[i] != gNetSplit.currentSequence)
"Split packet without all %i parts, part %i had wrong sequence %i/%i\n", {
packetCount, Con_Printf(
i + 1, "Split packet without all %i parts, part %i had wrong sequence %i/%i\n",
gNetSplitFlags[i], packetCount,
gNetSplit.currentSequence); i + 1,
return FALSE; gNetSplitFlags[i],
gNetSplit.currentSequence);
#ifdef REHLDS_FIXES
gNetSplit.currentSequence = -1; // no more parts can be attached, clear it
#endif
return FALSE;
}
} }
} }
gNetSplit.currentSequence = -1; gNetSplit.currentSequence = -1;
if (gNetSplit.totalSize <= 4010) if (gNetSplit.totalSize <= MAX_UDP_PACKET)
{ {
memcpy(pData, gNetSplit.buffer, gNetSplit.totalSize); Q_memcpy(pData, gNetSplit.buffer, gNetSplit.totalSize);
*outSize = gNetSplit.totalSize; *outSize = gNetSplit.totalSize;
return TRUE; return TRUE;
} }
else else
{ {
#ifdef REHLDS_FIXES
*outSize = 0;
#endif
Con_Printf("Split packet too large! %d bytes\n", gNetSplit.totalSize); Con_Printf("Split packet too large! %d bytes\n", gNetSplit.totalSize);
return FALSE; return FALSE;
} }
} }
/* <d3bd9> ../engine/net_ws.c:1021 */ /* <d3bd9> ../engine/net_ws.c:1021 */
@ -956,7 +972,7 @@ qboolean NET_QueuePacket(netsrc_t sock)
int net_socket; // 1026 int net_socket; // 1026
int protocol; // 1027 int protocol; // 1027
int err; // 1028 int err; // 1028
unsigned char buf[4010]; // 1029 unsigned char buf[MAX_UDP_PACKET]; // 1029
#ifdef _WIN32 #ifdef _WIN32
for (protocol = 0; protocol < 2; protocol++) for (protocol = 0; protocol < 2; protocol++)
@ -975,7 +991,7 @@ qboolean NET_QueuePacket(netsrc_t sock)
continue; continue;
fromlen = sizeof(from); fromlen = sizeof(from);
ret = CRehldsPlatformHolder::get()->recvfrom(net_socket, (char *)buf, 4010, 0, &from, &fromlen); ret = CRehldsPlatformHolder::get()->recvfrom(net_socket, (char *)buf, sizeof buf, 0, &from, &fromlen);
if (ret == -1) if (ret == -1)
{ {
#ifdef _WIN32 #ifdef _WIN32
@ -1005,13 +1021,13 @@ qboolean NET_QueuePacket(netsrc_t sock)
continue; continue;
} }
SockadrToNetadr(&from, &in_from); SockadrToNetadr(&from, &in_from);
if (ret != 4010) if (ret != MAX_UDP_PACKET)
break; break;
Con_Printf("NET_QueuePacket: Oversize packet from %s\n", NET_AdrToString(in_from)); Con_Printf("NET_QueuePacket: Oversize packet from %s\n", NET_AdrToString(in_from));
} }
if (ret == -1 || ret == 4010) { if (ret == -1 || ret == MAX_UDP_PACKET) {
return NET_LagPacket(0, sock, 0, 0); return NET_LagPacket(0, sock, 0, 0);
} }
@ -1260,7 +1276,7 @@ qboolean NET_GetPacket_internal(netsrc_t sock)
{ {
Q_memcpy(net_message.data, in_message.data, in_message.cursize); Q_memcpy(net_message.data, in_message.data, in_message.cursize);
net_message.cursize = in_message.cursize; net_message.cursize = in_message.cursize;
memcpy(&net_from, &in_from, 0x14u); Q_memcpy(&net_from, &in_from, 0x14u);
NET_ThreadUnlock(); NET_ThreadUnlock();
return bret; return bret;
} }
@ -1373,12 +1389,12 @@ int NET_SendLong(netsrc_t sock, int s, const char *buf, int len, int flags, cons
pPacket->packetID = (packetNumber << 4) + packetCount; pPacket->packetID = (packetNumber << 4) + packetCount;
memcpy(packet + sizeof(SPLITPACKET), buf + (packetNumber * SPLIT_SIZE), size); Q_memcpy(packet + sizeof(SPLITPACKET), buf + (packetNumber * SPLIT_SIZE), size);
if (net_showpackets.value == 4.0f) if (net_showpackets.value == 4.0f)
{ {
netadr_t adr; netadr_t adr;
memset(&adr, 0, sizeof(adr)); Q_memset(&adr, 0, sizeof(adr));
SockadrToNetadr((struct sockaddr *)to, &adr); SockadrToNetadr((struct sockaddr *)to, &adr);
@ -1420,7 +1436,7 @@ void NET_SendPacket_api(unsigned int length, void *data, const netadr_t &to) {
} }
/* <d43aa> ../engine/net_ws.c:1599 */ /* <d43aa> ../engine/net_ws.c:1599 */
void NET_SendPacket(netsrc_t sock, int length, void *data, netadr_t to) void NET_SendPacket(netsrc_t sock, int length, void *data, const netadr_t& to)
{ {
int ret; int ret;
struct sockaddr addr; struct sockaddr addr;
@ -2091,7 +2107,7 @@ void NET_Shutdown(void)
} }
/* <d4ccb> ../engine/net_ws.c:2470 */ /* <d4ccb> ../engine/net_ws.c:2470 */
qboolean NET_JoinGroup(netsrc_t sock, netadr_t addr) qboolean NET_JoinGroup(netsrc_t sock, netadr_t& addr)
{ {
ip_mreq mreq; ip_mreq mreq;
int net_socket = ip_sockets[sock]; int net_socket = ip_sockets[sock];
@ -2117,7 +2133,7 @@ qboolean NET_JoinGroup(netsrc_t sock, netadr_t addr)
} }
/* <d4d51> ../engine/net_ws.c:2504 */ /* <d4d51> ../engine/net_ws.c:2504 */
qboolean NET_LeaveGroup(netsrc_t sock, netadr_t addr) qboolean NET_LeaveGroup(netsrc_t sock, netadr_t& addr)
{ {
ip_mreq mreq; ip_mreq mreq;
int net_socket = ip_sockets[sock]; int net_socket = ip_sockets[sock];

30
rehlds/engine/net_ws.h
View File

@ -106,7 +106,7 @@ typedef struct LONGPACKET_t
int splitCount; int splitCount;
int totalSize; int totalSize;
// TODO: It should be NET_MAX_MESSAGE, but value differs // TODO: It should be NET_MAX_MESSAGE, but value differs
char buffer[4010]; // This has to be big enough to hold the largest message char buffer[MAX_UDP_PACKET]; // This has to be big enough to hold the largest message
} LONGPACKET; } LONGPACKET;
/* <d2ae9> ../engine/net_ws.c:900 */ /* <d2ae9> ../engine/net_ws.c:900 */
@ -212,8 +212,8 @@ extern cvar_t net_graph;
extern cvar_t net_graphwidth; extern cvar_t net_graphwidth;
extern cvar_t net_scale; extern cvar_t net_scale;
extern cvar_t net_graphpos; extern cvar_t net_graphpos;
extern unsigned char net_message_buffer[65536]; extern unsigned char net_message_buffer[NET_MAX_PAYLOAD];
extern unsigned char in_message_buf[65536]; extern unsigned char in_message_buf[NET_MAX_PAYLOAD];
extern sizebuf_t in_message; extern sizebuf_t in_message;
extern netadr_t in_from; extern netadr_t in_from;
extern int ip_sockets[3]; extern int ip_sockets[3];
@ -228,22 +228,22 @@ extern net_messages_t *normalqueue;
void NET_ThreadLock(void); void NET_ThreadLock(void);
void NET_ThreadUnlock(void); void NET_ThreadUnlock(void);
short unsigned int Q_ntohs(short unsigned int netshort); short unsigned int Q_ntohs(short unsigned int netshort);
void NetadrToSockadr(netadr_t *a, struct sockaddr *s); void NetadrToSockadr(const netadr_t *a, struct sockaddr *s);
void SockadrToNetadr(const struct sockaddr *s, netadr_t *a); void SockadrToNetadr(const struct sockaddr *s, netadr_t *a);
NOXREF short unsigned int NET_HostToNetShort(short unsigned int us_in); NOXREF short unsigned int NET_HostToNetShort(short unsigned int us_in);
qboolean NET_CompareAdr(netadr_t a, netadr_t b); qboolean NET_CompareAdr(netadr_t& a, netadr_t& b);
qboolean NET_CompareClassBAdr(netadr_t a, netadr_t b); qboolean NET_CompareClassBAdr(netadr_t& a, netadr_t& b);
qboolean NET_IsReservedAdr(netadr_t a); qboolean NET_IsReservedAdr(netadr_t& a);
qboolean NET_CompareBaseAdr(netadr_t a, netadr_t b); qboolean NET_CompareBaseAdr(netadr_t& a, netadr_t& b);
char *NET_AdrToString(netadr_t a); char *NET_AdrToString(const netadr_t& a);
char *NET_BaseAdrToString(netadr_t a); char *NET_BaseAdrToString(netadr_t& a);
qboolean NET_StringToSockaddr(const char *s, struct sockaddr *sadr); qboolean NET_StringToSockaddr(const char *s, struct sockaddr *sadr);
qboolean NET_StringToAdr(const char *s, netadr_t *a); qboolean NET_StringToAdr(const char *s, netadr_t *a);
qboolean NET_IsLocalAddress(netadr_t adr); qboolean NET_IsLocalAddress(netadr_t& adr);
char *NET_ErrorString(int code); char *NET_ErrorString(int code);
void NET_TransferRawData(sizebuf_t *msg, unsigned char *pStart, int nSize); void NET_TransferRawData(sizebuf_t *msg, unsigned char *pStart, int nSize);
qboolean NET_GetLoopPacket(netsrc_t sock, netadr_t *in_from_, sizebuf_t *msg); qboolean NET_GetLoopPacket(netsrc_t sock, netadr_t *in_from_, sizebuf_t *msg);
void NET_SendLoopPacket(netsrc_t sock, int length, void *data, netadr_t to); void NET_SendLoopPacket(netsrc_t sock, int length, void *data, const netadr_t& to);
void NET_RemoveFromPacketList(packetlag_t *pPacket); void NET_RemoveFromPacketList(packetlag_t *pPacket);
NOXREF int NET_CountLaggedList(packetlag_t *pList); NOXREF int NET_CountLaggedList(packetlag_t *pList);
void NET_ClearLaggedList(packetlag_t *pList); void NET_ClearLaggedList(packetlag_t *pList);
@ -265,7 +265,7 @@ void NET_AllocateQueues(void);
void NET_FlushQueues(void); void NET_FlushQueues(void);
int NET_SendLong(netsrc_t sock, int s, const char *buf, int len, int flags, const struct sockaddr *to, int tolen); int NET_SendLong(netsrc_t sock, int s, const char *buf, int len, int flags, const struct sockaddr *to, int tolen);
void NET_SendPacket_api(unsigned int length, void *data, const netadr_t &to); void NET_SendPacket_api(unsigned int length, void *data, const netadr_t &to);
void NET_SendPacket(netsrc_t sock, int length, void *data, netadr_t to); void NET_SendPacket(netsrc_t sock, int length, void *data, const netadr_t& to);
int NET_IPSocket(char *net_interface, int port, qboolean multicast); int NET_IPSocket(char *net_interface, int port, qboolean multicast);
void NET_OpenIP(void); void NET_OpenIP(void);
int NET_IPXSocket(int hostshort); int NET_IPXSocket(int hostshort);
@ -277,7 +277,7 @@ void MaxPlayers_f(void);
void NET_Init(void); void NET_Init(void);
void NET_ClearLagData(qboolean bClient, qboolean bServer); void NET_ClearLagData(qboolean bClient, qboolean bServer);
void NET_Shutdown(void); void NET_Shutdown(void);
qboolean NET_JoinGroup(netsrc_t sock, netadr_t addr); qboolean NET_JoinGroup(netsrc_t sock, netadr_t& addr);
qboolean NET_LeaveGroup(netsrc_t sock, netadr_t addr); qboolean NET_LeaveGroup(netsrc_t sock, netadr_t& addr);
#endif // NET_WS_H #endif // NET_WS_H

6
rehlds/engine/pmovetst.cpp
View File

@ -288,7 +288,7 @@ int _PM_TestPlayerPosition(vec_t *pos, pmtrace_t *ptrace, int(*pfnIgnore)(physen
tr = PM_PlayerTrace(pmove->origin, pmove->origin, 0, -1); tr = PM_PlayerTrace(pmove->origin, pmove->origin, 0, -1);
if (ptrace) if (ptrace)
memcpy(ptrace, &tr, sizeof(tr)); Q_memcpy(ptrace, &tr, sizeof(tr));
for (int i = 0; i < pmove->numphysent; i++) for (int i = 0; i < pmove->numphysent; i++)
{ {
@ -527,7 +527,7 @@ pmtrace_t _PM_PlayerTrace(vec_t *start, vec_t *end, int traceFlags, int numphyse
if (j == 0 || testtrace.allsolid || testtrace.startsolid || testtrace.fraction < total.fraction) if (j == 0 || testtrace.allsolid || testtrace.startsolid || testtrace.fraction < total.fraction)
{ {
bool remember = (total.startsolid == 0); bool remember = (total.startsolid == 0);
memcpy(&total, &testtrace, sizeof(total)); Q_memcpy(&total, &testtrace, sizeof(total));
if (!remember) if (!remember)
total.startsolid = 1; total.startsolid = 1;
closest = j; closest = j;
@ -563,7 +563,7 @@ pmtrace_t _PM_PlayerTrace(vec_t *start, vec_t *end, int traceFlags, int numphyse
if (total.fraction < trace.fraction) if (total.fraction < trace.fraction)
{ {
memcpy(&trace, &total, sizeof(trace)); Q_memcpy(&trace, &total, sizeof(trace));
trace.ent = i; trace.ent = i;
} }
} }

12
rehlds/engine/pr_cmds.cpp
View File

@ -1129,7 +1129,7 @@ short unsigned int EV_Precache(int type, const char *psz)
Host_Error("EV_Precache: only file type 1 supported currently\n"); Host_Error("EV_Precache: only file type 1 supported currently\n");
char szpath[MAX_PATH]; char szpath[MAX_PATH];
_snprintf(szpath, sizeof(szpath), "%s", psz); Q_snprintf(szpath, sizeof(szpath), "%s", psz);
COM_FixSlashes(szpath); COM_FixSlashes(szpath);
int scriptSize = 0; int scriptSize = 0;
@ -1361,7 +1361,7 @@ void EV_Playback(int flags, const edict_t *pInvoker, short unsigned int eventind
ei->packet_index = -1; ei->packet_index = -1;
if (pInvoker) if (pInvoker)
ei->entity_index = invoker; ei->entity_index = invoker;
memcpy(&ei->args, &eargs, sizeof(ei->args)); Q_memcpy(&ei->args, &eargs, sizeof(ei->args));
ei->fire_time = delay; ei->fire_time = delay;
continue; continue;
} }
@ -1382,7 +1382,7 @@ void EV_Playback(int flags, const edict_t *pInvoker, short unsigned int eventind
ei->packet_index = -1; ei->packet_index = -1;
if (pInvoker) if (pInvoker)
ei->entity_index = invoker; ei->entity_index = invoker;
memcpy(&ei->args, &eargs, sizeof(ei->args)); Q_memcpy(&ei->args, &eargs, sizeof(ei->args));
ei->fire_time = delay; ei->fire_time = delay;
} }
@ -1525,7 +1525,7 @@ int PF_IsMapValid_I(char *mapname)
return 0; return 0;
_snprintf(cBuf, sizeof(cBuf), "maps/%.32s.bsp", mapname); Q_snprintf(cBuf, sizeof(cBuf), "maps/%.32s.bsp", mapname);
return FS_FileExists(cBuf); return FS_FileExists(cBuf);
} }
@ -2024,7 +2024,7 @@ void PF_RunPlayerMove_I(edict_t *fakeclient, const float *viewangles, float forw
SV_PreRunCmd(); SV_PreRunCmd();
SV_RunCmd(&cmd, 0); SV_RunCmd(&cmd, 0);
memcpy(&host_client->lastcmd, &cmd, sizeof(host_client->lastcmd)); Q_memcpy(&host_client->lastcmd, &cmd, sizeof(host_client->lastcmd));
sv_player = oldclient; sv_player = oldclient;
host_client = old; host_client = old;
@ -2634,7 +2634,7 @@ int PF_CreateInstancedBaseline(int classname, struct entity_state_s *baseline)
return 0; return 0;
bls->classname[bls->number] = classname; bls->classname[bls->number] = classname;
memcpy(&bls->baseline[bls->number], baseline, sizeof(struct entity_state_s)); Q_memcpy(&bls->baseline[bls->number], baseline, sizeof(struct entity_state_s));
bls->number += 1; bls->number += 1;
return bls->number; return bls->number;
} }

10
rehlds/engine/server.h
View File

@ -59,7 +59,7 @@
#include "userid.h" #include "userid.h"
#include "pm_defs.h" #include "pm_defs.h"
#include "inst_baseline.h" #include "inst_baseline.h"
#include "net_ws.h"
#define DEFAULT_SOUND_PACKET_VOLUME 255 #define DEFAULT_SOUND_PACKET_VOLUME 255
#define DEFAULT_SOUND_PACKET_ATTENUATION 1.0f #define DEFAULT_SOUND_PACKET_ATTENUATION 1.0f
@ -153,9 +153,9 @@ typedef struct server_s
extra_baselines_t *instance_baselines; extra_baselines_t *instance_baselines;
server_state_t state; server_state_t state;
sizebuf_t datagram; sizebuf_t datagram;
unsigned char datagram_buf[4000]; unsigned char datagram_buf[MAX_DATAGRAM];
sizebuf_t reliable_datagram; sizebuf_t reliable_datagram;
unsigned char reliable_datagram_buf[4000]; unsigned char reliable_datagram_buf[MAX_DATAGRAM];
sizebuf_t multicast; sizebuf_t multicast;
unsigned char multicast_buf[1024]; unsigned char multicast_buf[1024];
sizebuf_t spectator; sizebuf_t spectator;
@ -212,7 +212,7 @@ typedef struct client_s
double nextping; double nextping;
double svtimebase; double svtimebase;
sizebuf_t datagram; sizebuf_t datagram;
byte datagram_buf[4000]; byte datagram_buf[MAX_DATAGRAM];
double connection_started; double connection_started;
double next_messagetime; double next_messagetime;
double next_messageinterval; double next_messageinterval;
@ -533,7 +533,7 @@ extern cvar_t sv_allow_dlfile;
extern cvar_t sv_version; extern cvar_t sv_version;
extern int sv_playermodel; extern int sv_playermodel;
extern char outputbuf[1400]; extern char outputbuf[MAX_ROUTEABLE_PACKET];
extern redirect_t sv_redirected; extern redirect_t sv_redirected;
extern netadr_t sv_redirectto; extern netadr_t sv_redirectto;

6
rehlds/engine/sv_log.cpp
View File

@ -220,7 +220,7 @@ void SV_SetLogAddress_f(void)
} }
g_psvs.log.net_log_ = TRUE; g_psvs.log.net_log_ = TRUE;
memcpy(&g_psvs.log.net_address_, &adr, sizeof(netadr_t)); Q_memcpy(&g_psvs.log.net_address_, &adr, sizeof(netadr_t));
Con_Printf("logaddress: %s\n", NET_AdrToString(adr)); Con_Printf("logaddress: %s\n", NET_AdrToString(adr));
} }
@ -292,7 +292,7 @@ void SV_AddLogAddress_f(void)
} }
tmp->next = NULL; tmp->next = NULL;
memcpy(&tmp->log.net_address_, &adr, sizeof(netadr_t)); Q_memcpy(&tmp->log.net_address_, &adr, sizeof(netadr_t));
list = firstLog; list = firstLog;
@ -310,7 +310,7 @@ void SV_AddLogAddress_f(void)
return; return;
} }
firstLog->next = NULL; firstLog->next = NULL;
memcpy(&firstLog->log.net_address_, &adr, sizeof(netadr_t)); Q_memcpy(&firstLog->log.net_address_, &adr, sizeof(netadr_t));
} }
Con_Printf("logaddress_add: %s\n", NET_AdrToString(adr)); Con_Printf("logaddress_add: %s\n", NET_AdrToString(adr));

109
rehlds/engine/sv_main.cpp
View File

@ -95,7 +95,7 @@ int numuserfilters;
int sv_playermodel; int sv_playermodel;
//int player_datacounts[32]; //int player_datacounts[32];
char outputbuf[1400]; char outputbuf[MAX_ROUTEABLE_PACKET];
redirect_t sv_redirected; redirect_t sv_redirected;
netadr_t sv_redirectto; netadr_t sv_redirectto;
@ -1527,7 +1527,7 @@ void SV_New_f(void)
{ {
int i; int i;
client_t *client; client_t *client;
unsigned char data[65536]; unsigned char data[NET_MAX_PAYLOAD];
sizebuf_t msg; sizebuf_t msg;
edict_t *ent; edict_t *ent;
char szRejectReason[128]; char szRejectReason[128];
@ -1611,7 +1611,7 @@ void SV_New_f(void)
/* <a7132> ../engine/sv_main.c:2057 */ /* <a7132> ../engine/sv_main.c:2057 */
void SV_SendRes_f(void) void SV_SendRes_f(void)
{ {
unsigned char data[65536]; unsigned char data[NET_MAX_PAYLOAD];
sizebuf_t msg; sizebuf_t msg;
Q_memset(&msg, 0, sizeof(msg)); Q_memset(&msg, 0, sizeof(msg));
@ -1636,7 +1636,7 @@ void SV_SendRes_f(void)
/* <a8922> ../engine/sv_main.c:2096 */ /* <a8922> ../engine/sv_main.c:2096 */
void SV_Spawn_f(void) void SV_Spawn_f(void)
{ {
unsigned char data[65536]; unsigned char data[NET_MAX_PAYLOAD];
sizebuf_t msg; sizebuf_t msg;
Q_memset(&msg, 0, sizeof(msg)); Q_memset(&msg, 0, sizeof(msg));
@ -1765,7 +1765,7 @@ qboolean SV_FilterUser(USERID_t *userid)
else else
{ {
if (i + 1 < j) if (i + 1 < j)
memmove(filter, &filter[1], sizeof(userfilter_t) * (j - i + 1)); Q_memmove(filter, &filter[1], sizeof(userfilter_t) * (j - i + 1));
numuserfilters = --j; numuserfilters = --j;
} }
@ -1827,6 +1827,9 @@ typedef struct challenge_s
} challenge_t; } challenge_t;
challenge_t g_rg_sv_challenges[1024]; challenge_t g_rg_sv_challenges[1024];
#ifdef REHLDS_OPT_PEDANTIC
int g_oldest_challenge = 0;
#endif
bool SV_CheckChallenge_api(const netadr_t &adr, int nChallengeValue) { bool SV_CheckChallenge_api(const netadr_t &adr, int nChallengeValue) {
netadr_t localAdr = adr; netadr_t localAdr = adr;
@ -2243,7 +2246,7 @@ void SV_ConnectClient_internal(void)
qboolean bIsSecure; qboolean bIsSecure;
client = NULL; client = NULL;
memcpy(&adr, &net_from, sizeof(adr)); Q_memcpy(&adr, &net_from, sizeof(adr));
nAuthProtocol = -1; nAuthProtocol = -1;
reconnect = FALSE; reconnect = FALSE;
port = Q_atoi("27005"); port = Q_atoi("27005");
@ -2338,7 +2341,7 @@ void SV_ConnectClient_internal(void)
SV_RejectConnection(&adr, "STEAM certificate length error! %i/%i\n", net_message.cursize - msg_readcount, sizeof(szSteamAuthBuf)); SV_RejectConnection(&adr, "STEAM certificate length error! %i/%i\n", net_message.cursize - msg_readcount, sizeof(szSteamAuthBuf));
return; return;
} }
memcpy(szSteamAuthBuf, &net_message.data[msg_readcount], len); Q_memcpy(szSteamAuthBuf, &net_message.data[msg_readcount], len);
client->network_userid.clientip = *(uint32 *)&adr.ip[0]; client->network_userid.clientip = *(uint32 *)&adr.ip[0];
if (adr.type == NA_LOOPBACK) if (adr.type == NA_LOOPBACK)
{ {
@ -2450,8 +2453,10 @@ void SVC_Ping(void)
void SVC_GetChallenge(void) void SVC_GetChallenge(void)
{ {
int i; int i;
#ifndef REHLDS_OPT_PEDANTIC
int oldest = 0; int oldest = 0;
int oldestTime = 0x7FFFFFFFu; int oldestTime = INT_MAX;
#endif
char data[1024]; char data[1024];
qboolean steam = FALSE; qboolean steam = FALSE;
@ -2464,19 +2469,30 @@ void SVC_GetChallenge(void)
{ {
if (NET_CompareBaseAdr(net_from, g_rg_sv_challenges[i].adr)) if (NET_CompareBaseAdr(net_from, g_rg_sv_challenges[i].adr))
break; break;
#ifndef REHLDS_OPT_PEDANTIC
if (g_rg_sv_challenges[i].time < oldestTime) if (g_rg_sv_challenges[i].time < oldestTime)
{ {
oldest = i; oldest = i;
oldestTime = g_rg_sv_challenges[i].time; oldestTime = g_rg_sv_challenges[i].time;
} }
#endif
} }
if (i == MAX_CHALLENGES) if (i == MAX_CHALLENGES)
{ {
#ifdef REHLDS_OPT_PEDANTIC
// oldest challenge is always next after last generated
i = g_oldest_challenge++;
if (g_oldest_challenge >= MAX_CHALLENGES)
g_oldest_challenge = 0;
#else
i = oldest; i = oldest;
g_rg_sv_challenges[oldest].challenge = (RandomLong(0, 0x8FFFu) << 16) | RandomLong(0, 0xFFFFu); #endif
g_rg_sv_challenges[oldest].adr = net_from; // generate new challenge number
g_rg_sv_challenges[oldest].time = realtime; g_rg_sv_challenges[i].challenge = ( RandomLong(0, 36863) << 16 ) | ( RandomLong(0, 65535) );
g_rg_sv_challenges[i].adr = net_from;
g_rg_sv_challenges[i].time = (int)realtime;
} }
if (steam) if (steam)
Q_snprintf(data, sizeof(data), "\xFF\xFF\xFF\xFF%c00000000 %u 3 %I64i %d\n", S2C_CHALLENGE, g_rg_sv_challenges[i].challenge, Steam_GSGetSteamID(), Steam_GSBSecure()); Q_snprintf(data, sizeof(data), "\xFF\xFF\xFF\xFF%c00000000 %u 3 %I64i %d\n", S2C_CHALLENGE, g_rg_sv_challenges[i].challenge, Steam_GSGetSteamID(), Steam_GSBSecure());
@ -2495,8 +2511,10 @@ void SVC_GetChallenge(void)
void SVC_ServiceChallenge(void) void SVC_ServiceChallenge(void)
{ {
int i; int i;
#ifndef REHLDS_OPT_PEDANTIC
int oldest = 0; int oldest = 0;
int oldestTime = 0x7FFFFFFFu; int oldestTime = INT_MAX;
#endif
char data[128]; char data[128];
const char *type; const char *type;
@ -2515,18 +2533,29 @@ void SVC_ServiceChallenge(void)
if (NET_CompareBaseAdr(net_from, g_rg_sv_challenges[i].adr)) if (NET_CompareBaseAdr(net_from, g_rg_sv_challenges[i].adr))
break; break;
#ifndef REHLDS_OPT_PEDANTIC
if (g_rg_sv_challenges[i].time < oldestTime) if (g_rg_sv_challenges[i].time < oldestTime)
{ {
oldestTime = g_rg_sv_challenges[i].time; oldestTime = g_rg_sv_challenges[i].time;
oldest = i; oldest = i;
} }
#endif
} }
if (i == MAX_CHALLENGES) if (i == MAX_CHALLENGES) // no challenge for ip
{ {
g_rg_sv_challenges[oldest].challenge = (RandomLong(0, 36863) << 16) | (RandomLong(0, 65535)); #ifdef REHLDS_OPT_PEDANTIC
g_rg_sv_challenges[oldest].adr = net_from; // oldest challenge is always next after last generated
g_rg_sv_challenges[oldest].time = (int)realtime; i = g_oldest_challenge++;
if(g_oldest_challenge >= MAX_CHALLENGES)
g_oldest_challenge = 0;
#else
i = oldest; i = oldest;
#endif
// generate new challenge number
g_rg_sv_challenges[i].challenge = (RandomLong(0, 36863) << 16) | (RandomLong(0, 65535));
g_rg_sv_challenges[i].adr = net_from;
g_rg_sv_challenges[i].time = (int)realtime;
} }
Q_snprintf(data, sizeof(data), "%c%c%c%cchallenge %s %u\n", 255, 255, 255, 255, type, g_rg_sv_challenges[i].challenge); Q_snprintf(data, sizeof(data), "%c%c%c%cchallenge %s %u\n", 255, 255, 255, 255, type, g_rg_sv_challenges[i].challenge);
@ -2749,7 +2778,7 @@ NOXREF void SVC_InfoString(void)
int count = 0; int count = 0;
int proxy = 0; int proxy = 0;
sizebuf_t buf; sizebuf_t buf;
unsigned char data[1400]; unsigned char data[MAX_ROUTEABLE_PACKET];
char address[256]; char address[256];
char gd[260]; char gd[260];
char info[2048]; char info[2048];
@ -2862,7 +2891,7 @@ NOXREF void SVC_Info(qboolean bDetailed)
int i; int i;
int count = 0; int count = 0;
sizebuf_t buf; sizebuf_t buf;
unsigned char data[1400]; unsigned char data[MAX_ROUTEABLE_PACKET];
char szModURL_Info[512]; char szModURL_Info[512];
char szModURL_DL[512]; char szModURL_DL[512];
int mod_version; int mod_version;
@ -3135,7 +3164,7 @@ void SV_EndRedirect(void)
/* <a81f5> ../engine/sv_main.c:4170 */ /* <a81f5> ../engine/sv_main.c:4170 */
void SV_BeginRedirect(redirect_t rd, netadr_t *addr) void SV_BeginRedirect(redirect_t rd, netadr_t *addr)
{ {
memcpy(&sv_redirectto, addr, sizeof(sv_redirectto)); Q_memcpy(&sv_redirectto, addr, sizeof(sv_redirectto));
sv_redirected = rd; sv_redirected = rd;
outputbuf[0] = 0; outputbuf[0] = 0;
} }
@ -3441,8 +3470,8 @@ void SV_CheckRate(client_t *cl)
{ {
if (cl->netchan.rate > sv_maxrate.value) if (cl->netchan.rate > sv_maxrate.value)
{ {
if (sv_maxrate.value > 100000.0f) if (sv_maxrate.value > MAX_RATE)
cl->netchan.rate = 100000.0; cl->netchan.rate = MAX_RATE;
else else
cl->netchan.rate = sv_maxrate.value; cl->netchan.rate = sv_maxrate.value;
} }
@ -3451,8 +3480,8 @@ void SV_CheckRate(client_t *cl)
{ {
if (cl->netchan.rate < sv_minrate.value) if (cl->netchan.rate < sv_minrate.value)
{ {
if (sv_minrate.value < 1000.0f) if (sv_minrate.value < MIN_RATE)
cl->netchan.rate = 1000.0; cl->netchan.rate = MIN_RATE;
else else
cl->netchan.rate = sv_minrate.value; cl->netchan.rate = sv_minrate.value;
} }
@ -3530,7 +3559,7 @@ qboolean SV_FilterPacket(void)
else else
{ {
if (i < numipfilters - 1) if (i < numipfilters - 1)
memcpy(curFilter, &curFilter[1], sizeof(ipfilter_t) * (numipfilters - i - 1)); Q_memcpy(curFilter, &curFilter[1], sizeof(ipfilter_t) * (numipfilters - i - 1));
--numipfilters; --numipfilters;
} }
@ -4522,7 +4551,7 @@ void SV_CleanupEnts(void)
/* <a96d8> ../engine/sv_main.c:5999 */ /* <a96d8> ../engine/sv_main.c:5999 */
qboolean SV_SendClientDatagram(client_t *client) qboolean SV_SendClientDatagram(client_t *client)
{ {
unsigned char buf[4000]; unsigned char buf[MAX_DATAGRAM];
sizebuf_t msg; sizebuf_t msg;
msg.buffername = "Client Datagram"; msg.buffername = "Client Datagram";
@ -5332,7 +5361,7 @@ void SetCStrikeFlags(void)
void SV_ActivateServer(int runPhysics) void SV_ActivateServer(int runPhysics)
{ {
int i; int i;
unsigned char data[65536]; unsigned char data[NET_MAX_PAYLOAD];
sizebuf_t msg; sizebuf_t msg;
client_t *cl; client_t *cl;
UserMsg *pTemp; UserMsg *pTemp;
@ -5916,13 +5945,13 @@ void SV_BanId_f(void)
userfilters[i].banTime = banTime; userfilters[i].banTime = banTime;
userfilters[i].banEndTime = (banTime == 0.0f) ? 0.0f : banTime * 60.0f + realtime; userfilters[i].banEndTime = (banTime == 0.0f) ? 0.0f : banTime * 60.0f + realtime;
memcpy(&userfilters[i].userid, id, sizeof(USERID_t)); Q_memcpy(&userfilters[i].userid, id, sizeof(USERID_t));
// give 3-rd party plugins a chance to serialize ID // give 3-rd party plugins a chance to serialize ID
g_RehldsHookchains.m_SerializeSteamId.callChain(NULL, &userfilters[i].userid); g_RehldsHookchains.m_SerializeSteamId.callChain(NULL, &userfilters[i].userid);
if (banTime == 0.0f) if (banTime == 0.0f)
sprintf(szreason, "permanently"); Q_sprintf(szreason, "permanently");
else else
Q_snprintf(szreason, sizeof(szreason), "for %.2f minutes", banTime); Q_snprintf(szreason, sizeof(szreason), "for %.2f minutes", banTime);
@ -6022,7 +6051,7 @@ void Host_Kick_f(void)
argsStartNum = 3; argsStartNum = 3;
} }
strncpy(idstring, p, 63); Q_strncpy(idstring, p, 63);
idstring[63] = 0; idstring[63] = 0;
if (!Q_strnicmp(idstring, "STEAM_", 6) || !Q_strnicmp(idstring, "VALVE_", 6)) if (!Q_strnicmp(idstring, "STEAM_", 6) || !Q_strnicmp(idstring, "VALVE_", 6))
@ -6143,7 +6172,7 @@ void SV_RemoveId_f(void)
return; return;
} }
strncpy(idstring, Cmd_Argv(1), sizeof(idstring) - 1); Q_strncpy(idstring, Cmd_Argv(1), sizeof(idstring) - 1);
idstring[63] = 0; idstring[63] = 0;
if (!idstring[0]) if (!idstring[0])
{ {
@ -6162,10 +6191,10 @@ void SV_RemoveId_f(void)
slot--; slot--;
USERID_t id; USERID_t id;
memcpy(&id, &userfilters[slot].userid, sizeof(id)); Q_memcpy(&id, &userfilters[slot].userid, sizeof(id));
if (slot + 1 < numuserfilters) if (slot + 1 < numuserfilters)
memcpy(&userfilters[slot], &userfilters[slot + 1], (numuserfilters - (slot + 1)) * sizeof(userfilter_t)); Q_memcpy(&userfilters[slot], &userfilters[slot + 1], (numuserfilters - (slot + 1)) * sizeof(userfilter_t));
numuserfilters--; numuserfilters--;
Con_Printf("UserID filter removed for %s, id %s\n", idstring, SV_GetIDString(&id)); Con_Printf("UserID filter removed for %s, id %s\n", idstring, SV_GetIDString(&id));
@ -6183,7 +6212,7 @@ void SV_RemoveId_f(void)
if (!Q_stricmp(SV_GetIDString(&userfilters[i].userid), idstring)) if (!Q_stricmp(SV_GetIDString(&userfilters[i].userid), idstring))
{ {
if (i + 1 < numuserfilters) if (i + 1 < numuserfilters)
memcpy(&userfilters[i], &userfilters[i + 1], (numuserfilters - (i + 1)) * sizeof(userfilter_t)); Q_memcpy(&userfilters[i], &userfilters[i + 1], (numuserfilters - (i + 1)) * sizeof(userfilter_t));
numuserfilters--; numuserfilters--;
Con_Printf("UserID filter removed for %s\n", idstring); Con_Printf("UserID filter removed for %s\n", idstring);
@ -6292,7 +6321,7 @@ void SV_AddIP_f(void)
if (!host_client->connected || !host_client->active || !host_client->spawned || host_client->fakeclient) if (!host_client->connected || !host_client->active || !host_client->spawned || host_client->fakeclient)
continue; continue;
memcpy(&net_from, &host_client->netchan.remote_address, sizeof(net_from)); Q_memcpy(&net_from, &host_client->netchan.remote_address, sizeof(net_from));
if (SV_FilterPacket()) if (SV_FilterPacket())
{ {
SV_ClientPrintf("The server operator has added you to banned list\n"); SV_ClientPrintf("The server operator has added you to banned list\n");
@ -6314,7 +6343,7 @@ void SV_RemoveIP_f(void)
if (ipfilters[i].mask == f.mask && ipfilters[i].compare.u32 == f.compare.u32) if (ipfilters[i].mask == f.mask && ipfilters[i].compare.u32 == f.compare.u32)
{ {
if (i + 1 < numipfilters) if (i + 1 < numipfilters)
memcpy(&ipfilters[i], &ipfilters[i + 1], (numipfilters - (i + 1)) * sizeof(ipfilter_t)); Q_memcpy(&ipfilters[i], &ipfilters[i + 1], (numipfilters - (i + 1)) * sizeof(ipfilter_t));
numipfilters--; numipfilters--;
ipfilters[numipfilters].banTime = 0.0f; ipfilters[numipfilters].banTime = 0.0f;
ipfilters[numipfilters].banEndTime = 0.0f; ipfilters[numipfilters].banEndTime = 0.0f;
@ -6384,19 +6413,19 @@ void SV_KickPlayer(int nPlayerSlot, int nReason)
return; return;
USERID_t id; USERID_t id;
memcpy(&id, &client->network_userid, sizeof(id)); Q_memcpy(&id, &client->network_userid, sizeof(id));
Log_Printf("Secure: \"%s<%i><%s><>\" was detected cheating and dropped from the server.\n", client->name, client->userid, SV_GetIDString(&id), nReason); Log_Printf("Secure: \"%s<%i><%s><>\" was detected cheating and dropped from the server.\n", client->name, client->userid, SV_GetIDString(&id), nReason);
char rgchT[1024]; char rgchT[1024];
rgchT[0] = svc_print; rgchT[0] = svc_print;
sprintf( Q_sprintf(
&rgchT[1], &rgchT[1],
"\n********************************************\nYou have been automatically disconnected\nfrom this secure server because an illegal\ncheat was detected on your computer.\nRepeat violators may be permanently banned\nfrom all secure servers.\n\nFor help cleaning your system of cheats, visit:\nhttp://www.counter-strike.net/cheat.html\n********************************************\n\n" "\n********************************************\nYou have been automatically disconnected\nfrom this secure server because an illegal\ncheat was detected on your computer.\nRepeat violators may be permanently banned\nfrom all secure servers.\n\nFor help cleaning your system of cheats, visit:\nhttp://www.counter-strike.net/cheat.html\n********************************************\n\n"
); );
Netchan_Transmit(&g_psvs.clients[nPlayerSlot].netchan, strlen(rgchT) + 1, (byte *)rgchT); Netchan_Transmit(&g_psvs.clients[nPlayerSlot].netchan, strlen(rgchT) + 1, (byte *)rgchT);
sprintf(rgchT, "%s was automatically disconnected\nfrom this secure server.\n", client->name); Q_sprintf(rgchT, "%s was automatically disconnected\nfrom this secure server.\n", client->name);
for (int i = 0; i < g_psvs.maxclients; i++) for (int i = 0; i < g_psvs.maxclients; i++)
{ {
if (!g_psvs.clients[i].active && !g_psvs.clients[i].spawned || g_psvs.clients[i].fakeclient) if (!g_psvs.clients[i].active && !g_psvs.clients[i].spawned || g_psvs.clients[i].fakeclient)
@ -7133,10 +7162,10 @@ qboolean SV_CompareUserID_internal(USERID_t *id1, USERID_t *id2)
char szID1[64]; char szID1[64];
char szID2[64]; char szID2[64];
strncpy(szID1, SV_GetIDString(id1), sizeof(szID1) - 1); Q_strncpy(szID1, SV_GetIDString(id1), sizeof(szID1) - 1);
szID1[sizeof(szID1) - 1] = 0; szID1[sizeof(szID1) - 1] = 0;
strncpy(szID2, SV_GetIDString(id2), sizeof(szID2) - 1); Q_strncpy(szID2, SV_GetIDString(id2), sizeof(szID2) - 1);
szID2[sizeof(szID2) - 1] = 0; szID2[sizeof(szID2) - 1] = 0;
return Q_stricmp(szID1, szID2) ? FALSE : TRUE; return Q_stricmp(szID1, szID2) ? FALSE : TRUE;

2
rehlds/engine/sv_phys.cpp
View File

@ -280,7 +280,7 @@ int SV_FlyMove(edict_t *ent, float time, trace_t *steptrace)
{ {
blocked |= 2u; blocked |= 2u;
if (steptrace) if (steptrace)
memcpy(steptrace, &trace, 0x38u); Q_memcpy(steptrace, &trace, 0x38u);
} }
SV_Impact(ent, trace.ent, &trace); SV_Impact(ent, trace.ent, &trace);

10
rehlds/engine/sv_remoteaccess.cpp
View File

@ -57,7 +57,7 @@ int CServerRemoteAccess::ReadDataResponse_noVirt(void *data, int len)
bytesToCopy = 0; bytesToCopy = 0;
if (bytesToCopy) if (bytesToCopy)
memcpy(data, response.Base(), bytesToCopy); Q_memcpy(data, response.Base(), bytesToCopy);
m_iBytesSent += bytesToCopy; m_iBytesSent += bytesToCopy;
@ -94,13 +94,13 @@ const char* CServerRemoteAccess::LookupStringValue(const char *variable)
count++; count++;
} }
_snprintf(s_ReturnBuf, sizeof(s_ReturnBuf) - 1, "%d", count); Q_snprintf(s_ReturnBuf, sizeof(s_ReturnBuf) - 1, "%d", count);
return s_ReturnBuf; return s_ReturnBuf;
} }
if (!Q_stricmp(variable, "maxplayers")) if (!Q_stricmp(variable, "maxplayers"))
{ {
_snprintf(s_ReturnBuf, sizeof(s_ReturnBuf) - 1, "%d", g_psvs.maxclients); Q_snprintf(s_ReturnBuf, sizeof(s_ReturnBuf) - 1, "%d", g_psvs.maxclients);
return s_ReturnBuf; return s_ReturnBuf;
} }
@ -150,10 +150,10 @@ void CServerRemoteAccess::GetMapList(CUtlBuffer &value)
char mapName[MAX_PATH]; char mapName[MAX_PATH];
char mapwild[64]; char mapwild[64];
strcpy(mapwild, "maps/*.bsp"); Q_strcpy(mapwild, "maps/*.bsp");
for (findfn = Sys_FindFirst(mapwild, 0); findfn; findfn = Sys_FindNext(0)) for (findfn = Sys_FindFirst(mapwild, 0); findfn; findfn = Sys_FindNext(0))
{ {
_snprintf(curDir, MAX_PATH, "maps/%s", findfn); Q_snprintf(curDir, MAX_PATH, "maps/%s", findfn);
FS_GetLocalPath(curDir, curDir, MAX_PATH); FS_GetLocalPath(curDir, curDir, MAX_PATH);
if (Q_strstr(curDir, com_gamedir)) if (Q_strstr(curDir, com_gamedir))
{ {

6
rehlds/engine/sv_steam3.cpp
View File

@ -186,19 +186,19 @@ void CSteam3Server::OnGSClientApprove(GSClientApprove_t *pGSClientSteam2Accept)
char msg[256]; char msg[256];
if (SV_FilterUser(&cl->network_userid)) if (SV_FilterUser(&cl->network_userid))
{ {
sprintf(msg, "You have been banned from this server\n"); Q_sprintf(msg, "You have been banned from this server\n");
SV_RejectConnection(&cl->netchan.remote_address, msg); SV_RejectConnection(&cl->netchan.remote_address, msg);
SV_DropClient(cl, 0, "STEAM UserID %s is in server ban list\n", SV_GetClientIDString(cl)); SV_DropClient(cl, 0, "STEAM UserID %s is in server ban list\n", SV_GetClientIDString(cl));
} }
else if (SV_CheckForDuplicateSteamID(cl) != -1) else if (SV_CheckForDuplicateSteamID(cl) != -1)
{ {
sprintf(msg, "Your UserID is already in use on this server.\n"); Q_sprintf(msg, "Your UserID is already in use on this server.\n");
SV_RejectConnection(&cl->netchan.remote_address, msg); SV_RejectConnection(&cl->netchan.remote_address, msg);
SV_DropClient(cl, 0, "STEAM UserID %s is already\nin use on this server\n", SV_GetClientIDString(cl)); SV_DropClient(cl, 0, "STEAM UserID %s is already\nin use on this server\n", SV_GetClientIDString(cl));
} }
else else
{ {
_snprintf(msg, 0x200u, "\"%s<%i><%s><>\" STEAM USERID validated\n", cl->name, cl->userid, SV_GetClientIDString(cl)); Q_snprintf(msg, 0x200u, "\"%s<%i><%s><>\" STEAM USERID validated\n", cl->name, cl->userid, SV_GetClientIDString(cl));
Con_DPrintf("%s", msg); Con_DPrintf("%s", msg);
Log_Printf("%s", msg); Log_Printf("%s", msg);
} }

8
rehlds/engine/sv_user.cpp
View File

@ -285,7 +285,7 @@ int SV_TransferConsistencyInfo(void)
} }
else else
{ {
_snprintf(filename, MAX_PATH, "sound/%s", r->szFileName); Q_snprintf(filename, MAX_PATH, "sound/%s", r->szFileName);
} }
MD5_Hash_File(r->rgucMD5_hash, filename, FALSE, FALSE, NULL); MD5_Hash_File(r->rgucMD5_hash, filename, FALSE, FALSE, NULL);
@ -431,7 +431,7 @@ void SV_CopyEdictToPhysent(physent_t *pe, int e, edict_t *check)
} }
else else
{ {
sprintf(pe->name, "?"); Q_sprintf(pe->name, "?");
} }
} }
else else
@ -577,7 +577,7 @@ void SV_AddLinksToPM_(areanode_t *node, float *pmove_mins, float *pmove_maxs)
pe = &pmove->moveents[pmove->nummoveent++]; pe = &pmove->moveents[pmove->nummoveent++];
} }
memcpy(pe, ve, sizeof(physent_t)); Q_memcpy(pe, ve, sizeof(physent_t));
} }
if (node->axis != -1) if (node->axis != -1)
@ -838,7 +838,7 @@ void SV_RunCmd(usercmd_t *ucmd, int random_seed)
pmove->friction = sv_player->v.friction; pmove->friction = sv_player->v.friction;
pmove->spectator = 0; pmove->spectator = 0;
pmove->waterjumptime = sv_player->v.teleport_time; pmove->waterjumptime = sv_player->v.teleport_time;
memcpy(&pmove->cmd, &cmd, sizeof(pmove->cmd)); Q_memcpy(&pmove->cmd, &cmd, sizeof(pmove->cmd));
pmove->dead = sv_player->v.health <= 0.0; pmove->dead = sv_player->v.health <= 0.0;
pmove->movetype = sv_player->v.movetype; pmove->movetype = sv_player->v.movetype;
pmove->flags = sv_player->v.flags; pmove->flags = sv_player->v.flags;

4
rehlds/engine/sys_dll.cpp
View File

@ -505,7 +505,7 @@ NOXREF void Sys_Warning(const char *pszWarning, ...)
char text[1024]; char text[1024];
va_start(argptr, pszWarning); va_start(argptr, pszWarning);
vsnprintf(text, sizeof(text), pszWarning, argptr); Q_vsnprintf(text, sizeof(text), pszWarning, argptr);
va_end(argptr); va_end(argptr);
Sys_Printf(text); Sys_Printf(text);
@ -1084,7 +1084,7 @@ void LoadThisDll(const char *szDllFilename)
} }
pextdll = &g_rgextdll[g_iextdllMac++]; pextdll = &g_rgextdll[g_iextdllMac++];
memset(pextdll, 0, sizeof(*pextdll)); Q_memset(pextdll, 0, sizeof(*pextdll));
pextdll->lDLLHandle = hDLL; pextdll->lDLLHandle = hDLL;
return; return;

8
rehlds/engine/sys_dll2.cpp
View File

@ -207,7 +207,7 @@ NOXREF void Sys_CheckOSVersion(void)
{ {
struct _OSVERSIONINFOA verInfo; struct _OSVERSIONINFOA verInfo;
memset(&verInfo, 0, sizeof(verInfo)); Q_memset(&verInfo, 0, sizeof(verInfo));
verInfo.dwOSVersionInfoSize = sizeof(verInfo); verInfo.dwOSVersionInfoSize = sizeof(verInfo);
if (!GetVersionExA(&verInfo)) if (!GetVersionExA(&verInfo))
Sys_Error("Couldn't get OS info"); Sys_Error("Couldn't get OS info");
@ -500,7 +500,7 @@ int Sys_InitGame(char *lpOrgCmdLine, char *pBaseDir, void *pwnd, int bIsDedicate
} }
#endif // SWDS #endif // SWDS
g_bIsDedicatedServer = bIsDedicated; g_bIsDedicatedServer = bIsDedicated;
memset(&gmodinfo, 0, sizeof(modinfo_t)); Q_memset(&gmodinfo, 0, sizeof(modinfo_t));
SV_ResetModInfo(); SV_ResetModInfo();
TraceInit("Sys_Init()", "Sys_Shutdown()", 0); TraceInit("Sys_Init()", "Sys_Shutdown()", 0);
@ -642,7 +642,7 @@ NOXREF int BuildMapCycleListHints(char **hints)
Con_Printf("Unable to allocate memory for map cycle hints list"); Con_Printf("Unable to allocate memory for map cycle hints list");
return 0; return 0;
} }
strcpy(*hints, szMap); Q_strcpy(*hints, szMap);
length = FS_Size(pFile); length = FS_Size(pFile);
if (length) if (length)
{ {
@ -695,7 +695,7 @@ bool CDedicatedServerAPI::Init_noVirt(char *basedir, char *cmdline, CreateInterf
if (!dedicated_) if (!dedicated_)
return false; return false;
strcpy(this->m_OrigCmd, cmdline); Q_strcpy(this->m_OrigCmd, cmdline);
if (!strstr(cmdline, "-nobreakpad")) if (!strstr(cmdline, "-nobreakpad"))
{ {
CRehldsPlatformHolder::get()->SteamAPI_UseBreakpadCrashHandler(va("%d", build_number()), "Aug 8 2013", "11:17:26", 0, 0, 0); CRehldsPlatformHolder::get()->SteamAPI_UseBreakpadCrashHandler(va("%d", build_number()), "Aug 8 2013", "11:17:26", 0, 0, 0);

2
rehlds/engine/sys_engine.cpp
View File

@ -90,7 +90,7 @@ void ForceReloadProfile()
Sys_Error("Only dedicated mode is supported"); Sys_Error("Only dedicated mode is supported");
/* /*
v0 = GetRateRegistrySetting(rate.string); v0 = GetRateRegistrySetting(rate.string);
strncpy(szRate, v0, 0x20u); Q_strncpy(szRate, v0, 0x20u);
Cvar_DirectSet(&rate, szRate); Cvar_DirectSet(&rate, szRate);
*/ */
} }

2
rehlds/engine/textures.cpp
View File

@ -112,7 +112,7 @@ qboolean TEX_InitFromWad(char *path)
{ {
ForwardSlashes(pszWadFile); ForwardSlashes(pszWadFile);
COM_FileBase(pszWadFile, wadName); COM_FileBase(pszWadFile, wadName);
_snprintf(wadPath, 0x100u, "%s", wadName); Q_snprintf(wadPath, 0x100u, "%s", wadName);
COM_DefaultExtension(wadPath, ".wad"); COM_DefaultExtension(wadPath, ".wad");
if (Q_strstr(wadName, "pldecal") || Q_strstr(wadName, "tempdecal")) if (Q_strstr(wadName, "pldecal") || Q_strstr(wadName, "tempdecal"))

4
rehlds/engine/wad.cpp
View File

@ -46,7 +46,7 @@ void W_CleanupName(char *in, char *out)
out[i] = c; out[i] = c;
} }
if (i < 16) if (i < 16)
memset(&out[i], 0, 16 - i); Q_memset(&out[i], 0, 16 - i);
} }
/* <c6d06> ../engine/wad.c:62 */ /* <c6d06> ../engine/wad.c:62 */
@ -149,7 +149,7 @@ void W_Shutdown(void)
if (!wad->loaded) if (!wad->loaded)
break; break;
memset(wad, 0, sizeof(wadlist_t)); Q_memset(wad, 0, sizeof(wadlist_t));
} }
} }

2
rehlds/engine/world.cpp
View File

@ -1113,7 +1113,7 @@ void SV_SingleClipMoveToEntity(edict_t *ent, const vec_t *start, const vec_t *mi
if (i == 0 || testtrace.allsolid || testtrace.startsolid || testtrace.fraction < trace->fraction) if (i == 0 || testtrace.allsolid || testtrace.startsolid || testtrace.fraction < trace->fraction)
{ {
int isSolid = trace->startsolid; int isSolid = trace->startsolid;
memcpy(trace, &testtrace, sizeof(trace_t)); Q_memcpy(trace, &testtrace, sizeof(trace_t));
if (isSolid) if (isSolid)
trace->startsolid = TRUE; trace->startsolid = TRUE;
closest = i; closest = i;

12
rehlds/engine/zone.cpp
View File

@ -404,7 +404,7 @@ NOXREF void Hunk_Print(qboolean all)
// //
// print the single block // print the single block
// //
memcpy(name, h->name, HUNK_NAME_LEN); Q_memcpy(name, h->name, HUNK_NAME_LEN);
if (all) if (all)
Con_Printf("%8p :%8i %8s\n", h, h->size, name); Con_Printf("%8p :%8i %8s\n", h, h->size, name);
@ -412,7 +412,7 @@ NOXREF void Hunk_Print(qboolean all)
// print the total // print the total
// //
if (next == endlow || next == endhigh || if (next == endlow || next == endhigh ||
strncmp(h->name, next->name, HUNK_NAME_LEN)) Q_strncmp(h->name, next->name, HUNK_NAME_LEN))
{ {
if (!all) if (!all)
Con_Printf(" :%8i %8s (TOTAL)\n", sum, name); Con_Printf(" :%8i %8s (TOTAL)\n", sum, name);
@ -906,13 +906,13 @@ NOXREF char *CommatizeNumber(int num, char *pout)
int len = 0; int len = 0;
int i; int i;
char outbuf[50]; char outbuf[50];
memset(outbuf, 0, 50); Q_memset(outbuf, 0, 50);
while (num) while (num)
{ {
char tempbuf[50]; char tempbuf[50];
int temp = num % 1000; int temp = num % 1000;
num = num / 1000; num = num / 1000;
strcpy(tempbuf, outbuf); Q_strcpy(tempbuf, outbuf);
Q_snprintf(outbuf, sizeof(outbuf), ",%03i%s", temp, tempbuf); Q_snprintf(outbuf, sizeof(outbuf), ",%03i%s", temp, tempbuf);
} }
@ -924,9 +924,9 @@ NOXREF char *CommatizeNumber(int num, char *pout)
break; break;
if (i == len) if (i == len)
strcpy(pout, "0"); Q_strcpy(pout, "0");
else else
strcpy(pout, &outbuf[i]); //copy from i to get rid of the first comma and leading zeros Q_strcpy(pout, &outbuf[i]); //copy from i to get rid of the first comma and leading zeros
return pout; return pout;
} }