mirrors/sapphire
1
Fork 0
mirror of https://github.com/SapphireServer/Sapphire.git synced 2025-05-04 01:37:47 +00:00
Code Activity

code style

Browse source
This commit is contained in:
NotAdam 2019-03-25 00:09:01 +11:00
parent 9eb765e85a
commit abb4220409
1 changed files with 126 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

252
src/common/Network/GamePacketParser.cpp
View file

@ -1,126 +1,126 @@
#include "CommonNetwork.h" #include "CommonNetwork.h"
#include "GamePacketParser.h" #include "GamePacketParser.h"
#include <string.h> // memcpy #include <string.h> // memcpy
using namespace Sapphire::Network::Packets; using namespace Sapphire::Network::Packets;
PacketParseResult Sapphire::Network::Packets::getHeader( const std::vector< uint8_t >& buffer, PacketParseResult Sapphire::Network::Packets::getHeader( const std::vector< uint8_t >& buffer,
const uint32_t offset, const uint32_t offset,
FFXIVARR_PACKET_HEADER& header ) FFXIVARR_PACKET_HEADER& header )
{ {
const auto headerSize = sizeof( FFXIVARR_PACKET_HEADER ); const auto headerSize = sizeof( FFXIVARR_PACKET_HEADER );
// Check if we have enough bytes in the buffer. // Check if we have enough bytes in the buffer.
auto remainingBytes = buffer.size() - offset; auto remainingBytes = buffer.size() - offset;
if( remainingBytes < headerSize ) if( remainingBytes < headerSize )
return Incomplete; return Incomplete;
// Copy packet header. // Copy packet header.
memcpy( &header, buffer.data() + offset, headerSize ); memcpy( &header, buffer.data() + offset, headerSize );
if( !checkHeader( header ) ) if( !checkHeader( header ) )
return Malformed; return Malformed;
return Success; return Success;
} }
PacketParseResult Sapphire::Network::Packets::getSegmentHeader( const std::vector< uint8_t >& buffer, PacketParseResult Sapphire::Network::Packets::getSegmentHeader( const std::vector< uint8_t >& buffer,
const uint32_t offset, const uint32_t offset,
FFXIVARR_PACKET_SEGMENT_HEADER& header ) FFXIVARR_PACKET_SEGMENT_HEADER& header )
{ {
const auto headerSize = sizeof( FFXIVARR_PACKET_SEGMENT_HEADER ); const auto headerSize = sizeof( FFXIVARR_PACKET_SEGMENT_HEADER );
// Check if we have enough bytes in the buffer. // Check if we have enough bytes in the buffer.
auto remainingBytes = buffer.size() - offset; auto remainingBytes = buffer.size() - offset;
if( remainingBytes < headerSize ) if( remainingBytes < headerSize )
return Incomplete; return Incomplete;
// Copy segment header // Copy segment header
memcpy( &header, buffer.data() + offset, headerSize ); memcpy( &header, buffer.data() + offset, headerSize );
return Success; return Success;
} }
PacketParseResult Sapphire::Network::Packets::getPackets( const std::vector< uint8_t >& buffer, PacketParseResult Sapphire::Network::Packets::getPackets( const std::vector< uint8_t >& buffer,
const uint32_t offset, const uint32_t offset,
const FFXIVARR_PACKET_HEADER& packetHeader, const FFXIVARR_PACKET_HEADER& packetHeader,
std::vector< FFXIVARR_PACKET_RAW >& packets ) std::vector< FFXIVARR_PACKET_RAW >& packets )
{ {
// sanity check: check there's enough bytes in the buffer // sanity check: check there's enough bytes in the buffer
const auto bytesExpected = packetHeader.size - sizeof( struct FFXIVARR_PACKET_HEADER ); const auto bytesExpected = packetHeader.size - sizeof( struct FFXIVARR_PACKET_HEADER );
if( buffer.size() - offset < bytesExpected ) if( buffer.size() - offset < bytesExpected )
return Incomplete; return Incomplete;
// Loop each message // Loop each message
uint32_t count = 0; uint32_t count = 0;
uint32_t bytesProcessed = 0; uint32_t bytesProcessed = 0;
while( count < packetHeader.count ) while( count < packetHeader.count )
{ {
FFXIVARR_PACKET_RAW rawPacket; FFXIVARR_PACKET_RAW rawPacket;
// Copy ipc packet message // Copy ipc packet message
const auto packetResult = getPacket( buffer, offset + bytesProcessed, rawPacket ); const auto packetResult = getPacket( buffer, offset + bytesProcessed, rawPacket );
if( packetResult != Success ) if( packetResult != Success )
return packetResult; return packetResult;
// NOTE: isn't rawPacket is allocated on stack? // NOTE: isn't rawPacket is allocated on stack?
// why is okay to do this? // why is okay to do this?
packets.push_back( rawPacket ); packets.push_back( rawPacket );
// Add message size and count // Add message size and count
bytesProcessed += rawPacket.segHdr.size; bytesProcessed += rawPacket.segHdr.size;
count += 1; count += 1;
} }
// sanity check: check if we processed all bytes. // sanity check: check if we processed all bytes.
// this check can fail if size of messages don't add up to size reported from packet header. // this check can fail if size of messages don't add up to size reported from packet header.
if( bytesExpected != bytesProcessed ) if( bytesExpected != bytesProcessed )
return Malformed; return Malformed;
return Success; return Success;
} }
PacketParseResult Sapphire::Network::Packets::getPacket( const std::vector< uint8_t >& buffer, const uint32_t offset, PacketParseResult Sapphire::Network::Packets::getPacket( const std::vector< uint8_t >& buffer, const uint32_t offset,
FFXIVARR_PACKET_RAW& packet ) FFXIVARR_PACKET_RAW& packet )
{ {
// Copy segment header // Copy segment header
const auto headerResult = getSegmentHeader( buffer, offset, packet.segHdr ); const auto headerResult = getSegmentHeader( buffer, offset, packet.segHdr );
if( headerResult != Success ) if( headerResult != Success )
return headerResult; return headerResult;
// Check header sanity and it's size // Check header sanity and it's size
if( !checkSegmentHeader( packet.segHdr ) ) if( !checkSegmentHeader( packet.segHdr ) )
return Malformed; return Malformed;
const auto dataOffset = offset + sizeof( struct FFXIVARR_PACKET_SEGMENT_HEADER ); const auto dataOffset = offset + sizeof( struct FFXIVARR_PACKET_SEGMENT_HEADER );
const auto dataSize = packet.segHdr.size; const auto dataSize = packet.segHdr.size;
// Allocate data buffer and copy // Allocate data buffer and copy
packet.data.resize( dataSize ); packet.data.resize( dataSize );
memcpy( packet.data.data(), buffer.data() + dataOffset, dataSize ); memcpy( packet.data.data(), buffer.data() + dataOffset, dataSize );
return Success; return Success;
} }
bool Sapphire::Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& header ) bool Sapphire::Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& header )
{ {
// Max size of the packet is capped at 1MB for now. // Max size of the packet is capped at 1MB for now.
if( header.size > 1 * 1024 * 1024 ) if( header.size > 1 * 1024 * 1024 )
return false; return false;
// Max number of message is capped at 255 for now. // Max number of message is capped at 255 for now.
if( header.count > 255 ) if( header.count > 255 )
return false; return false;
return true; return true;
} }
bool Sapphire::Network::Packets::checkSegmentHeader( const FFXIVARR_PACKET_SEGMENT_HEADER& header ) bool Sapphire::Network::Packets::checkSegmentHeader( const FFXIVARR_PACKET_SEGMENT_HEADER& header )
{ {
// Max size of individual message is capped at 256KB for now. // Max size of individual message is capped at 256KB for now.
if( header.size > 256 * 1024 ) if( header.size > 256 * 1024 )
return false; return false;
return true; return true;
} }