edg-l/ddnet
1
0
Fork 0
mirror of https://github.com/ddnet/ddnet.git synced 2024-11-10 10:08:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use sizeof(int32_t) instead of 4

Browse source
This commit is contained in:
Robert Müller 2023-02-04 01:22:49 +01:00
parent 64081ad3e4
commit be6862e997
11 changed files with 52 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/engine/client/client.cpp
View file

@ -4086,8 +4086,8 @@ int CClient::HandleChecksum(int Conn, CUuid Uuid, CUnpacker *pUnpacker)
int End = Start + Length;
int ChecksumBytesEnd = minimum(End, (int)sizeof(m_Checksum.m_aBytes));
int FileStart = maximum(Start, (int)sizeof(m_Checksum.m_aBytes));
unsigned char aStartBytes[4];
unsigned char aEndBytes[4];
unsigned char aStartBytes[sizeof(int32_t)];
unsigned char aEndBytes[sizeof(int32_t)];
uint_to_bytes_be(aStartBytes, Start);
uint_to_bytes_be(aEndBytes, End);

8
src/engine/client/ghost.cpp
View file

@ -83,7 +83,7 @@ void CGhostRecorder::WriteData(int Type, const void *pData, int Size)
mem_copy(Data.m_aData, pData, Size);
if(m_LastItem.m_Type == Data.m_Type)
DiffItem((int *)m_LastItem.m_aData, (int *)Data.m_aData, (int *)m_pBufferPos, Size / 4);
DiffItem((int *)m_LastItem.m_aData, (int *)Data.m_aData, (int *)m_pBufferPos, Size / sizeof(int32_t));
else
{
FlushChunk();
@ -144,11 +144,11 @@ int CGhostRecorder::Stop(int Ticks, int Time)
// write down num shots and time
io_seek(m_File, gs_NumTicksOffset, IOSEEK_START);
unsigned char aNumTicks[4];
unsigned char aNumTicks[sizeof(int32_t)];
uint_to_bytes_be(aNumTicks, Ticks);
io_write(m_File, aNumTicks, sizeof(aNumTicks));
unsigned char aTime[4];
unsigned char aTime[sizeof(int32_t)];
uint_to_bytes_be(aTime, Time);
io_write(m_File, aTime, sizeof(aTime));
@ -341,7 +341,7 @@ bool CGhostLoader::ReadData(int Type, void *pData, int Size)
CGhostItem Data(Type);
if(m_LastItem.m_Type == Data.m_Type)
UndiffItem((int *)m_LastItem.m_aData, (int *)m_pBufferPos, (int *)Data.m_aData, Size / 4);
UndiffItem((int *)m_LastItem.m_aData, (int *)m_pBufferPos, (int *)Data.m_aData, Size / sizeof(int32_t));
else
mem_copy(Data.m_aData, m_pBufferPos, Size);

6
src/engine/client/ghost.h
View file

@ -16,9 +16,9 @@ struct CGhostHeader
unsigned char m_Version;
char m_aOwner[MAX_NAME_LENGTH];
char m_aMap[64];
unsigned char m_aZeroes[4]; // Crc before version 6
unsigned char m_aNumTicks[4];
unsigned char m_aTime[4];
unsigned char m_aZeroes[sizeof(int32_t)]; // Crc before version 6
unsigned char m_aNumTicks[sizeof(int32_t)];
unsigned char m_aTime[sizeof(int32_t)];
SHA256_DIGEST m_MapSha256;
int GetTicks() const

10
src/engine/demo.h
View file

@ -29,17 +29,17 @@ struct CDemoHeader
unsigned char m_Version;
char m_aNetversion[64];
char m_aMapName[64];
unsigned char m_aMapSize[4];
unsigned char m_aMapCrc[4];
unsigned char m_aMapSize[sizeof(int32_t)];
unsigned char m_aMapCrc[sizeof(int32_t)];
char m_aType[8];
unsigned char m_aLength[4];
unsigned char m_aLength[sizeof(int32_t)];
char m_aTimestamp[20];
};
struct CTimelineMarkers
{
unsigned char m_aNumTimelineMarkers[4];
unsigned char m_aTimelineMarkers[MAX_TIMELINE_MARKERS][4];
unsigned char m_aNumTimelineMarkers[sizeof(int32_t)];
unsigned char m_aTimelineMarkers[MAX_TIMELINE_MARKERS][sizeof(int32_t)];
};
struct CMapInfo

2
src/engine/server/register.cpp
View file

@ -498,7 +498,7 @@ CRegister::CRegister(CConfig *pConfig, IConsole *pConsole, IEngine *pEngine, int
m_aVerifyPacketPrefix[HEADER_LEN + UUID_MAXSTRSIZE - 1] = ':';
// The DDNet code uses the `unsigned` security token in memory byte order.
unsigned char aTokenBytes[4];
unsigned char aTokenBytes[sizeof(int32_t)];
mem_copy(aTokenBytes, &SixupSecurityToken, sizeof(aTokenBytes));
str_format(m_aConnlessTokenHex, sizeof(m_aConnlessTokenHex), "%08x", bytes_be_to_uint(aTokenBytes));

10
src/engine/shared/datafile.cpp
View file

@ -22,21 +22,21 @@ enum
struct CItemEx
{
int m_aUuid[sizeof(CUuid) / 4];
int m_aUuid[sizeof(CUuid) / sizeof(int32_t)];
static CItemEx FromUuid(CUuid Uuid)
{
CItemEx Result;
for(int i = 0; i < (int)sizeof(CUuid) / 4; i++)
Result.m_aUuid[i] = bytes_be_to_uint(&Uuid.m_aData[i * 4]);
for(size_t i = 0; i < sizeof(CUuid) / sizeof(int32_t); i++)
Result.m_aUuid[i] = bytes_be_to_uint(&Uuid.m_aData[i * sizeof(int32_t)]);
return Result;
}
CUuid ToUuid() const
{
CUuid Result;
for(int i = 0; i < (int)sizeof(CUuid) / 4; i++)
uint_to_bytes_be(&Result.m_aData[i * 4], m_aUuid[i]);
for(size_t i = 0; i < sizeof(CUuid) / sizeof(int32_t); i++)
uint_to_bytes_be(&Result.m_aData[i * sizeof(int32_t)], m_aUuid[i]);
return Result;
}
};

10
src/engine/shared/demo.cpp
View file

@ -225,7 +225,7 @@ void CDemoRecorder::WriteTickMarker(int Tick, int Keyframe)
{
if(m_LastTickMarker == -1 || Tick - m_LastTickMarker > CHUNKMASK_TICK || Keyframe)
{
unsigned char aChunk[5];
unsigned char aChunk[sizeof(int32_t) + 1];
aChunk[0] = CHUNKTYPEFLAG_TICKMARKER;
uint_to_bytes_be(aChunk + 1, Tick);
@ -347,18 +347,18 @@ int CDemoRecorder::Stop()
// add the demo length to the header
io_seek(m_File, gs_LengthOffset, IOSEEK_START);
unsigned char aLength[4];
unsigned char aLength[sizeof(int32_t)];
uint_to_bytes_be(aLength, Length());
io_write(m_File, aLength, sizeof(aLength));
// add the timeline markers to the header
io_seek(m_File, gs_NumMarkersOffset, IOSEEK_START);
unsigned char aNumMarkers[4];
unsigned char aNumMarkers[sizeof(int32_t)];
uint_to_bytes_be(aNumMarkers, m_NumTimelineMarkers);
io_write(m_File, aNumMarkers, sizeof(aNumMarkers));
for(int i = 0; i < m_NumTimelineMarkers; i++)
{
unsigned char aMarker[4];
unsigned char aMarker[sizeof(int32_t)];
uint_to_bytes_be(aMarker, m_aTimelineMarkers[i]);
io_write(m_File, aMarker, sizeof(aMarker));
}
@ -454,7 +454,7 @@ int CDemoPlayer::ReadChunkHeader(int *pType, int *pSize, int *pTick)
}
else
{
unsigned char aTickdata[4];
unsigned char aTickdata[sizeof(int32_t)];
if(io_read(m_File, aTickdata, sizeof(aTickdata)) != sizeof(aTickdata))
return -1;
*pTick = bytes_be_to_uint(aTickdata);

4
src/engine/shared/network_server.cpp
View file

@ -564,8 +564,8 @@ int CNetServer::OnSixupCtrlMsg(NETADDR &Addr, CNetChunk *pChunk, int ControlMsg,
else if(ControlMsg == NET_CTRLMSG_CONNECT)
{
SECURITY_TOKEN MyToken = GetToken(Addr);
unsigned char aToken[4];
mem_copy(aToken, &MyToken, 4);
unsigned char aToken[sizeof(SECURITY_TOKEN)];
mem_copy(aToken, &MyToken, sizeof(aToken));
CNetBase::SendControlMsg(m_Socket, &Addr, 0, NET_CTRLMSG_CONNECTACCEPT, aToken, sizeof(aToken), ResponseToken, true);
if(Token == MyToken)

38
src/engine/shared/snapshot.cpp
View file

@ -46,8 +46,8 @@ int CSnapshot::GetExternalItemType(int InternalType) const
}
const CSnapshotItem *pTypeItem = GetItem(TypeItemIndex);
CUuid Uuid;
for(int i = 0; i < (int)sizeof(CUuid) / 4; i++)
uint_to_bytes_be(&Uuid.m_aData[i * 4], pTypeItem->Data()[i]);
for(size_t i = 0; i < sizeof(CUuid) / sizeof(int32_t); i++)
uint_to_bytes_be(&Uuid.m_aData[i * sizeof(int32_t)], pTypeItem->Data()[i]);
return g_UuidManager.LookupUuid(Uuid);
}
@ -69,9 +69,9 @@ const void *CSnapshot::FindItem(int Type, int ID) const
if(Type >= OFFSET_UUID)
{
CUuid TypeUuid = g_UuidManager.GetUuid(Type);
int aTypeUuidItem[sizeof(CUuid) / 4];
for(int i = 0; i < (int)sizeof(CUuid) / 4; i++)
aTypeUuidItem[i] = bytes_be_to_uint(&TypeUuid.m_aData[i * 4]);
int aTypeUuidItem[sizeof(CUuid) / sizeof(int32_t)];
for(size_t i = 0; i < sizeof(CUuid) / sizeof(int32_t); i++)
aTypeUuidItem[i] = bytes_be_to_uint(&TypeUuid.m_aData[i * sizeof(int32_t)]);
bool Found = false;
for(int i = 0; i < m_NumItems; i++)
@ -105,7 +105,7 @@ unsigned CSnapshot::Crc()
const CSnapshotItem *pItem = GetItem(i);
int Size = GetItemSize(i);
for(int b = 0; b < Size / 4; b++)
for(size_t b = 0; b < Size / sizeof(int32_t); b++)
Crc += pItem->Data()[b];
}
return Crc;
@ -119,8 +119,8 @@ void CSnapshot::DebugDump()
const CSnapshotItem *pItem = GetItem(i);
int Size = GetItemSize(i);
dbg_msg("snapshot", "\ttype=%d id=%d", pItem->Type(), pItem->ID());
for(int b = 0; b < Size / 4; b++)
dbg_msg("snapshot", "\t\t%3d %12d\t%08x", b, pItem->Data()[b], pItem->Data()[b]);
for(size_t b = 0; b < Size / sizeof(int32_t); b++)
dbg_msg("snapshot", "\t\t%3d %12d\t%08x", (int)b, pItem->Data()[b], pItem->Data()[b]);
}
}
@ -320,13 +320,13 @@ int CSnapshotDelta::CreateDelta(CSnapshot *pFrom, CSnapshot *pTo, void *pDstData
if(!IncludeSize)
pItemDataDst = pData + 2;
if(DiffItem(pPastItem->Data(), pCurItem->Data(), pItemDataDst, ItemSize / 4))
if(DiffItem(pPastItem->Data(), pCurItem->Data(), pItemDataDst, ItemSize / sizeof(int32_t)))
{
*pData++ = pCurItem->Type();
*pData++ = pCurItem->ID();
if(IncludeSize)
*pData++ = ItemSize / 4;
pData += ItemSize / 4;
*pData++ = ItemSize / sizeof(int32_t);
pData += ItemSize / sizeof(int32_t);
pDelta->m_NumUpdateItems++;
}
}
@ -335,10 +335,10 @@ int CSnapshotDelta::CreateDelta(CSnapshot *pFrom, CSnapshot *pTo, void *pDstData
*pData++ = pCurItem->Type();
*pData++ = pCurItem->ID();
if(IncludeSize)
*pData++ = ItemSize / 4;
*pData++ = ItemSize / sizeof(int32_t);
mem_copy(pData, pCurItem->Data(), ItemSize);
pData += ItemSize / 4;
pData += ItemSize / sizeof(int32_t);
pDelta->m_NumUpdateItems++;
}
}
@ -420,9 +420,9 @@ int CSnapshotDelta::UnpackDelta(CSnapshot *pFrom, CSnapshot *pTo, const void *pS
{
if(pData + 1 > pEnd)
return -103;
if(*pData < 0 || *pData > INT_MAX / 4)
if(*pData < 0 || (size_t)*pData > INT_MAX / sizeof(int32_t))
return -204;
ItemSize = (*pData++) * 4;
ItemSize = (*pData++) * sizeof(int32_t);
}
if(ItemSize < 0 || RangeCheck(pEnd, pData, ItemSize))
@ -442,7 +442,7 @@ int CSnapshotDelta::UnpackDelta(CSnapshot *pFrom, CSnapshot *pTo, const void *pS
if(FromIndex != -1)
{
// we got an update so we need to apply the diff
UndiffItem(pFrom->GetItem(FromIndex)->Data(), pData, pNewData, ItemSize / 4, &m_aSnapshotDataRate[Type]);
UndiffItem(pFrom->GetItem(FromIndex)->Data(), pData, pNewData, ItemSize / sizeof(int32_t), &m_aSnapshotDataRate[Type]);
}
else // no previous, just copy the pData
{
@ -451,7 +451,7 @@ int CSnapshotDelta::UnpackDelta(CSnapshot *pFrom, CSnapshot *pTo, const void *pS
}
m_aSnapshotDataUpdates[Type]++;
pData += ItemSize / 4;
pData += ItemSize / sizeof(int32_t);
}
// finish up
@ -629,8 +629,8 @@ void CSnapshotBuilder::AddExtendedItemType(int Index)
int *pUuidItem = (int *)NewItem(0, GetTypeFromIndex(Index), sizeof(Uuid)); // NETOBJTYPE_EX
if(pUuidItem)
{
for(int i = 0; i < (int)sizeof(CUuid) / 4; i++)
pUuidItem[i] = bytes_be_to_uint(&Uuid.m_aData[i * 4]);
for(size_t i = 0; i < sizeof(CUuid) / sizeof(int32_t); i++)
pUuidItem[i] = bytes_be_to_uint(&Uuid.m_aData[i * sizeof(int32_t)]);
}
}

4
src/game/server/teehistorian.cpp
View file

@ -423,7 +423,7 @@ void CTeeHistorian::RecordPlayerInput(int ClientID, uint32_t UniqueClientID, con
Buffer.Reset();
Buffer.AddInt(-TEEHISTORIAN_INPUT_DIFF);
CSnapshotDelta::DiffItem((int *)&pPrev->m_Input, (int *)pInput, (int *)&DiffInput, sizeof(DiffInput) / sizeof(int));
CSnapshotDelta::DiffItem((int *)&pPrev->m_Input, (int *)pInput, (int *)&DiffInput, sizeof(DiffInput) / sizeof(int32_t));
if(m_Debug)
{
const int *pData = (const int *)&DiffInput;
@ -444,7 +444,7 @@ void CTeeHistorian::RecordPlayerInput(int ClientID, uint32_t UniqueClientID, con
}
}
Buffer.AddInt(ClientID);
for(int i = 0; i < (int)(sizeof(DiffInput) / sizeof(int)); i++)
for(size_t i = 0; i < sizeof(DiffInput) / sizeof(int32_t); i++)
{
Buffer.AddInt(((int *)&DiffInput)[i]);
}

8
src/test/bytes_be.cpp
View file

@ -4,14 +4,14 @@
#include <base/system.h>
static const int INT_DATA[] = {0, 1, -1, 32, 64, 256, -512, 12345, -123456, 1234567, 12345678, 123456789, 2147483647, (-2147483647 - 1)};
static const unsigned UINT_DATA[] = {0u, 1u, 2u, 32u, 64u, 256u, 512u, 12345u, 123456u, 1234567u, 12345678u, 123456789u, 2147483647u, 2147483648u, 4294967295u};
static const int32_t INT_DATA[] = {0, 1, -1, 32, 64, 256, -512, 12345, -123456, 1234567, 12345678, 123456789, 2147483647, (-2147483647 - 1)};
static const uint32_t UINT_DATA[] = {0u, 1u, 2u, 32u, 64u, 256u, 512u, 12345u, 123456u, 1234567u, 12345678u, 123456789u, 2147483647u, 2147483648u, 4294967295u};
TEST(BytePacking, RoundtripInt)
{
for(auto i : INT_DATA)
{
unsigned char aPacked[4];
unsigned char aPacked[sizeof(int32_t)];
uint_to_bytes_be(aPacked, i);
EXPECT_EQ(bytes_be_to_uint(aPacked), i);
}
@ -21,7 +21,7 @@ TEST(BytePacking, RoundtripUnsigned)
{
for(auto u : UINT_DATA)
{
unsigned char aPacked[4];
unsigned char aPacked[sizeof(uint32_t)];
uint_to_bytes_be(aPacked, u);
EXPECT_EQ(bytes_be_to_uint(aPacked), u);
}