PacketAudit.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
 
// Includes
#include "Containers/UnrealString.h"
#include "HAL/PlatformMemory.h"
#include "HAL/PlatformProcess.h"
#include "Serialization/BitReader.h"
#include "Serialization/BitWriter.h"
 
// Forward declarations
class FPacketAudit;
 
 
// Globals
 
#if !UE_BUILD_SHIPPING
extern NETCORE_API FPacketAudit* GPacketAuditor;
#endif
 
 
class FPacketAudit
{
#if !UE_BUILD_SHIPPING
protected:
    struct FScopedAuditAccess
    {
        FScopedAuditAccess(FPacketAudit& InAudtor);
 
        ~FScopedAuditAccess();
 
    private:
        FPacketAudit& Auditor;
    };
#endif
 
private:
    FPacketAudit()
    {
    }
 
    NETCORE_API FPacketAudit(FPlatformProcess::FSemaphore* InGameMutex);
 
    NETCORE_API ~FPacketAudit();
 
public:
    static NETCORE_API void Init();
 
    static NETCORE_API void Destruct();
 
    static inline void AddStage(FString StageName, FBitWriter& OutPacket, bool bByteAligned=false)
    {
#if !UE_BUILD_SHIPPING
        if (GPacketAuditor != nullptr)
        {
            GPacketAuditor->AddStage_Internal(StageName, OutPacket, bByteAligned);
        }
#endif
    }
 
    static inline void CheckStage(FString StageName, FBitReader& InPacket, bool bByteAligned=false)
    {
#if !UE_BUILD_SHIPPING
        if (GPacketAuditor != nullptr)
        {
            GPacketAuditor->CheckStage_Internal(StageName, InPacket, bByteAligned);
        }
#endif
    }
 
    static inline void NotifyLowLevelSend(FBitWriter& OutPacket)
    {
#if !UE_BUILD_SHIPPING
        if (GPacketAuditor != nullptr)
        {
            GPacketAuditor->NotifyLowLevelSend_Internal(OutPacket);
        }
#endif
    }
 
    static inline void NotifyLowLevelReceive(FBitReader& InPacket)
    {
#if !UE_BUILD_SHIPPING
        if (GPacketAuditor != nullptr)
        {
            GPacketAuditor->NotifyLowLevelReceive_Internal(InPacket);
        }
#endif
    }
 
    // @todo #JohnB: Deprecate, once the pipeline uses FBitReader/Writers all the way
#if 1
    static inline void NotifyLowLevelSend(uint8* Data, uint32 DataLen, uint32 DataLenBits)
    {
#if !UE_BUILD_SHIPPING
        if (GPacketAuditor != nullptr)
        {
            FBitWriter OutPacket(DataLenBits);
 
            OutPacket.SerializeBits(Data, DataLenBits);
 
            GPacketAuditor->NotifyLowLevelSend_Internal(OutPacket);
        }
#endif
    }
 
    static inline void NotifyLowLevelReceive(uint8* Data, uint32 DataLen)
    {
#if !UE_BUILD_SHIPPING
        if (GPacketAuditor != nullptr)
        {
            FBitReader InPacket(Data, DataLen * 8);
 
            NotifyLowLevelReceive(InPacket);
        }
#endif
    }
#endif
 
protected:
    NETCORE_API void AddStage_Internal(FString StageName, FBitWriter& OutPacket, bool bByteAligned);
 
    NETCORE_API void CheckStage_Internal(FString StageName, FBitReader& InPacket, bool bByteAligned);
 
    NETCORE_API void NotifyLowLevelSend_Internal(FBitWriter& OutPacket);
 
    NETCORE_API void NotifyLowLevelReceive_Internal(FBitReader& InPacket);
 
 
    static NETCORE_API uint32 PacketCRC(uint8* Data, uint32 DataLenBits);
 
#if !UE_BUILD_SHIPPING
    NETCORE_API void DumpAuditData(FScopedAuditAccess& AuditLock, uint32 InPacketCRC=0);
#endif
 
 
protected:
    FPlatformProcess::FSemaphore*           GameMutex;
 
    FPlatformProcess::FSemaphore*           SharedMutex;
 
    FPlatformMemory::FSharedMemoryRegion*   SendSharedMemory;
 
    FPlatformMemory::FSharedMemoryRegion*   ReceiveSharedMemory;
};