PacketHandler.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Queue.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "HAL/UnrealMemory.h"
#include "IPAddress.h"
#include "Logging/LogMacros.h"
#include "Math/UnrealMathSSE.h"
#include "Misc/AssertionMacros.h"
#include "Modules/ModuleInterface.h"
#include "Net/Common/Packets/PacketTraits.h"
#include "Net/Common/Packets/PacketView.h"
#include "Serialization/Archive.h"
#include "Serialization/BitReader.h"
#include "Serialization/BitWriter.h"
#include "Templates/SharedPointer.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
 
PACKETHANDLER_API DECLARE_LOG_CATEGORY_EXTERN(PacketHandlerLog, Log, All);
 
class FInternetAddr;
class FDDoSDetection;
class FEncryptionComponent;
class FNetAnalyticsAggregator;
// Forward declarations
class HandlerComponent;
class IAnalyticsProvider;
class PacketHandler;
class ReliabilityHandlerComponent;
 
namespace UE
{
    namespace Net
    {
        class FNetConnectionFaultRecoveryBase;
    }
}
 
#if !UE_BUILD_SHIPPING
extern PACKETHANDLER_API bool GPacketHandlerDiscardTimeguardMeasurement;
#endif
 
// Delegate for allowing access to LowLevelSend, without a dependency upon Engine
DECLARE_DELEGATE_ThreeParams(FPacketHandlerLowLevelSendTraits, void* /* Data */, int32 /* CountBits */, FOutPacketTraits& /* Traits */);
 
DECLARE_DELEGATE_ThreeParams(FPacketHandlerLowLevelSend, void* /* Data */, int32 /* CountBytes */, int32 /* CountBits */);
 
// Delegate for allowing adding of packet handlers without defining them in an ini file
DECLARE_DELEGATE_OneParam(FPacketHandlerAddComponentByNameDelegate, TArray<FString>& /* HandlerComponentNames */);
DECLARE_DELEGATE_OneParam(FPacketHandlerAddComponentDelegate, TArray<TSharedPtr<HandlerComponent>>& /* HandlerComponents*/ );
 
DECLARE_DELEGATE_OneParam(FPacketHandlerNotifyAddHandler, TSharedPtr<HandlerComponent>& /*NewHandler*/);
 
DECLARE_DELEGATE(FPacketHandlerHandshakeComplete);
 
 
namespace UE
{
    namespace Handler
    {
        enum class State : uint8
        {
            Uninitialized,          // PacketHandler is uninitialized
            InitializingComponents, // PacketHandler is initializing HandlerComponents
            Initialized             // PacketHandler and all HandlerComponents (if any) are initialized
        };
    
        enum class Mode : uint8
        {
            Client,                 // Clientside PacketHandler
            Server                  // Serverside PacketHandler
        };
    
        namespace Component
        {
            enum class State : uint8
            {
                UnInitialized,      // HandlerComponent not yet initialized
                InitializedOnLocal, // Initialized on local instance
                InitializeOnRemote, // Initialized on remote instance, not on local instance
                Initialized         // Initialized on both local and remote instances
            };
        }
    }
}
 
struct ProcessedPacket
{
    uint8* Data;
 
    int32 CountBits;
 
    bool bError;
 
public:
    ProcessedPacket()
        : Data()
        , CountBits(0)
        , bError(false)
    {
    }
 
    ProcessedPacket(uint8* InData, int32 InCountBits, bool bInError=false)
        : Data(InData)
        , CountBits(InCountBits)
        , bError(bInError)
    {
    }
};
 
struct BufferedPacket
{
    uint8* Data;
 
    uint32 CountBits;
 
    FOutPacketTraits Traits;
 
    double ResendTime;
 
    uint32 Id;
 
    TSharedPtr<const FInternetAddr> Address;
 
    HandlerComponent* FromComponent;
 
private:
    BufferedPacket()
        : Data(nullptr)
        , CountBits(0)
        , Traits()
        , ResendTime(0.0)
        , Id(0)
        , Address(nullptr)
        , FromComponent(nullptr)
    {
    }
 
public:
    BufferedPacket(uint8* InCopyData, uint32 InCountBits, FOutPacketTraits& InTraits, double InResendTime=0.0, uint32 InId=0)
        : CountBits(InCountBits)
        , Traits(InTraits)
        , ResendTime(InResendTime)
        , Id(InId)
        , Address(nullptr)
        , FromComponent(nullptr)
    {
        check(InCopyData != nullptr);
 
        Data = new uint8[FMath::DivideAndRoundUp(InCountBits, 8u)];
        FMemory::Memcpy(Data, InCopyData, FMath::DivideAndRoundUp(InCountBits, 8u));
    }
 
    BufferedPacket(TSharedPtr<const FInternetAddr> InAddress, uint8* InCopyData, uint32 InCountBits, FOutPacketTraits& InTraits, double InResendTime=0.0, uint32 InId=0)
        : BufferedPacket(InCopyData, InCountBits, InTraits, InResendTime, InId)
    {
        Address = InAddress;
    }
 
    PACKETHANDLER_API ~BufferedPacket();
 
    void CountBytes(FArchive& Ar) const
    {
        Ar.CountBytes(sizeof(*this), sizeof(*this));
        Ar.CountBytes(FMath::DivideAndRoundUp(CountBits, 8u), FMath::DivideAndRoundUp(CountBits, 8u));
    }
};
 
struct FIncomingPacketRef
{
    FBitReader&                             Packet;
 
    const TSharedPtr<const FInternetAddr>&  Address;
 
    FInPacketTraits&                        Traits;
};
 
 
enum class EIncomingResult : uint8
{
    Success,
    Error
};
 
class PacketHandler
{
public:
    PACKETHANDLER_API PacketHandler(FDDoSDetection* InDDoS=nullptr);
 
    PACKETHANDLER_API void Initialize(UE::Handler::Mode Mode, uint32 InMaxPacketBits, bool bConnectionlessOnly=false,
                    TSharedPtr<class IAnalyticsProvider> InProvider=nullptr, FDDoSDetection* InDDoS=nullptr, FName InDriverProfile=NAME_None);
 
    PACKETHANDLER_API void InitializeDelegates(FPacketHandlerLowLevelSendTraits InLowLevelSendDel,
                                FPacketHandlerNotifyAddHandler InAddHandlerDel=FPacketHandlerNotifyAddHandler());
 
    PACKETHANDLER_API void InitFaultRecovery(UE::Net::FNetConnectionFaultRecoveryBase* InFaultRecovery);
 
    PACKETHANDLER_API void NotifyAnalyticsProvider(TSharedPtr<IAnalyticsProvider> InProvider, TSharedPtr<FNetAnalyticsAggregator> InAggregator);
 
    PACKETHANDLER_API void InitializeComponents();
 
 
    PACKETHANDLER_API void BeginHandshaking(FPacketHandlerHandshakeComplete InHandshakeDel=FPacketHandlerHandshakeComplete());
 
 
    PACKETHANDLER_API void Tick(float DeltaTime);
 
    PACKETHANDLER_API void AddHandler(TSharedPtr<HandlerComponent>& NewHandler, bool bDeferInitialize=false);
 
    PACKETHANDLER_API TSharedPtr<HandlerComponent> AddHandler(const FString& ComponentStr, bool bDeferInitialize=false);
 
 
    // @todo #JohnB: Add runtime-calculated arrays for each packet pipeline type, to reduce redundant iterations,
    //              (there are 3x iterations now, 1 for each packet pipeline type), and to ignore inactive HandlerComponent's
 
    // @todo #JohnB: The reserved packet bits needs to be handled differently for the 'High' functions, as they use SendBuffer,
    //                  which normally is reduced in size by reserved packet bits.
 
 
    PACKETHANDLER_API void IncomingHigh(FBitReader& Reader);
 
    PACKETHANDLER_API void OutgoingHigh(FBitWriter& Writer);
 
    // @todo: Don't deprecate, until after the NetDriver refactor
    //UE_DEPRECATED(4.26, "Incoming now uses FReceivedPacketView.")
    inline const ProcessedPacket Incoming(uint8* Packet, int32 CountBytes)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        const TSharedPtr<const FInternetAddr> EmptyAddress = nullptr;
        return Incoming_Internal(Packet, CountBytes, false, EmptyAddress);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    inline EIncomingResult Incoming(FReceivedPacketView& PacketView)
    {
        return Incoming_Internal(PacketView);
    }
 
    inline const ProcessedPacket Outgoing(uint8* Packet, int32 CountBits, FOutPacketTraits& Traits)
    {
        const TSharedPtr<const FInternetAddr> EmptyAddress = nullptr;
        return Outgoing_Internal(Packet, CountBits, Traits, false, EmptyAddress);
    }
 
 
    // @todo: Don't deprecate, until after the NetDriver refactor
    //UE_DEPRECATED(4.26, "IncomingConnectionless now uses FReceivedPacketView.")
    inline const ProcessedPacket IncomingConnectionless(const TSharedPtr<const FInternetAddr>& Address, uint8* Packet, int32 CountBytes)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return Incoming_Internal(Packet, CountBytes, true, Address);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    inline EIncomingResult IncomingConnectionless(FReceivedPacketView& PacketView)
    {
        PacketView.Traits.bConnectionlessPacket = true;
 
        return Incoming_Internal(PacketView);
    }
 
    inline const ProcessedPacket OutgoingConnectionless(const TSharedPtr<const FInternetAddr>& Address, uint8* Packet, int32 CountBits, FOutPacketTraits& Traits)
    {
        return Outgoing_Internal(Packet, CountBits, Traits, true, Address);
    }
 
    PACKETHANDLER_API TSharedPtr<FEncryptionComponent> GetEncryptionComponent();
 
    PACKETHANDLER_API TSharedPtr<HandlerComponent> GetComponentByName(FName ComponentName) const;
 
    PACKETHANDLER_API void CountBytes(FArchive& Ar) const;
 
protected:
    UE_DEPRECATED(4.26, "Incoming_Internal now uses FReceivedPacketView")
    const ProcessedPacket Incoming_Internal(uint8* Packet, int32 CountBytes, bool bConnectionless, const TSharedPtr<const FInternetAddr>& Address)
    {
        FReceivedPacketView PacketView;
 
        PacketView.DataView = {Packet, CountBytes, ECountUnits::Bytes};
        PacketView.Address = Address;
        PacketView.Traits.bConnectionlessPacket = bConnectionless;
 
        EIncomingResult Result = Incoming_Internal(PacketView);
 
        if (Result == EIncomingResult::Success)
        {
            return ProcessedPacket(PacketView.DataView.GetMutableData(), PacketView.DataView.NumBits());
        }
        else
        {
            return ProcessedPacket(nullptr, 0, true);
        }
    }
 
    PACKETHANDLER_API EIncomingResult Incoming_Internal(FReceivedPacketView& PacketView);
 
    PACKETHANDLER_API const ProcessedPacket Outgoing_Internal(uint8* Packet, int32 CountBits, FOutPacketTraits& Traits, bool bConnectionless, const TSharedPtr<const FInternetAddr>& Address);
 
public:
 
    PACKETHANDLER_API void SendHandlerPacket(HandlerComponent* InComponent, FBitWriter& Writer, FOutPacketTraits& Traits);
 
 
    PACKETHANDLER_API void HandlerComponentInitialized(HandlerComponent* InComponent);
 
    inline void QueuePacketForRawSending(BufferedPacket* PacketToQueue)
    {
        QueuedRawPackets.Enqueue(PacketToQueue);
    }
 
    inline void QueueHandlerPacketForSending(BufferedPacket* PacketToQueue)
    {
        QueuedHandlerPackets.Enqueue(PacketToQueue);
    }
 
    static PACKETHANDLER_API bool DoesAnyProfileHaveComponent(const FString& InComponentName);
 
    static PACKETHANDLER_API bool DoesProfileHaveComponent(const FName InNetDriverName, const FString& InComponentName);
 
    PACKETHANDLER_API BufferedPacket* GetQueuedPacket();
 
    PACKETHANDLER_API BufferedPacket* GetQueuedRawPacket();
 
    PACKETHANDLER_API BufferedPacket* GetQueuedConnectionlessPacket();
 
    PACKETHANDLER_API int32 GetTotalReservedPacketBits();
 
 
    inline void SetRawSend(bool bInEnabled)
    {
        bRawSend = bInEnabled;
    }
 
    inline bool GetRawSend()
    {
        return bRawSend;
    }
 
    inline bool IsFullyInitialized()
    {
        return State == UE::Handler::State::Initialized;
    }
 
    FDDoSDetection* GetDDoS() const { return DDoS; }
 
    TSharedPtr<IAnalyticsProvider> GetProvider() const { return Provider; }
 
    TSharedPtr<FNetAnalyticsAggregator> GetAggregator() const { return Aggregator; }
 
 
private:
    PACKETHANDLER_API void SetState(UE::Handler::State InState);
 
    PACKETHANDLER_API void UpdateInitialState();
 
    PACKETHANDLER_API void HandlerInitialized();
 
    PACKETHANDLER_API void ReplaceIncomingPacket(FBitReader& ReplacementPacket);
 
    PACKETHANDLER_API void RealignPacket(FBitReader& Packet);
 
 
public:
    UE::Handler::Mode Mode;
 
    UE_DEPRECATED(5.6, "PacketHandler AddComponent delegates are deprecated, use [PacketHandlerComponents] section in .ini file")
    static PACKETHANDLER_API FPacketHandlerAddComponentByNameDelegate& GetAddComponentByNameDelegate();
    UE_DEPRECATED(5.6, "PacketHandler AddComponent delegates are deprecated, use [PacketHandlerComponents] section in .ini file")
    static PACKETHANDLER_API FPacketHandlerAddComponentDelegate& GetAddComponentDelegate();
 
private:
 
    UE::Handler::State State;
 
    uint8 bRawSend:1;
 
    uint8 bBeganHandshaking:1;
 
    uint8 bConnectionlessHandler:1;
 
    uint32 MaxPacketBits;
 
    FDDoSDetection* DDoS;
 
    FPacketHandlerLowLevelSendTraits LowLevelSendDel;
 
    FPacketHandlerHandshakeComplete HandshakeCompleteDel;
 
    FPacketHandlerNotifyAddHandler AddHandlerDel;
 
    FBitWriter OutgoingPacket;
 
    FBitReader IncomingPacket;
 
    TArray<TSharedPtr<HandlerComponent>> HandlerComponents;
 
    TSharedPtr<FEncryptionComponent> EncryptionComponent;
 
    TArray<BufferedPacket*> BufferedPackets;
 
    TQueue<BufferedPacket*> QueuedPackets;
 
    TQueue<BufferedPacket*> QueuedRawPackets;
 
    TQueue<BufferedPacket*> QueuedHandlerPackets;
 
    TArray<BufferedPacket*> BufferedConnectionlessPackets;
 
    TQueue<BufferedPacket*> QueuedConnectionlessPackets;
 
    TSharedPtr<ReliabilityHandlerComponent> ReliabilityComponent;
 
    TSharedPtr<IAnalyticsProvider> Provider;
 
    TSharedPtr<FNetAnalyticsAggregator> Aggregator;
};
 
class HandlerComponent
{
    friend class PacketHandler;
 
public:
    PACKETHANDLER_API HandlerComponent();
 
    PACKETHANDLER_API explicit HandlerComponent(FName InName);
 
    PACKETHANDLER_API virtual ~HandlerComponent();
 
    PACKETHANDLER_API virtual bool IsActive() const;
 
    virtual bool IsValid() const = 0;
 
    PACKETHANDLER_API bool IsInitialized() const;
 
    bool RequiresHandshake() const
    {
        return bRequiresHandshake;
    }
 
    bool RequiresReliability() const
    {
        return bRequiresReliability;
    }
    
    // Delay deprecation for initial checkin
    //UE_DEPRECATED(5.0, "Use the version of 'HandlerComponent::Incoming' which takes 'FIncomingPacketRef' instead")
    virtual void Incoming(FBitReader& Packet)
    {
    }
 
    virtual void Incoming(FIncomingPacketRef PacketRef)
    {
        // By default, call the deprecated version unless overridden (derived classes should NOT call the parent Incoming function)
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        Incoming(PacketRef.Packet);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    virtual void Outgoing(FBitWriter& Packet, FOutPacketTraits& Traits)
    {
    }
 
    virtual void IncomingConnectionless(FIncomingPacketRef PacketRef)
    {
    }
 
    virtual void OutgoingConnectionless(const TSharedPtr<const FInternetAddr>& Address, FBitWriter& Packet, FOutPacketTraits& Traits)
    {
    }
 
 
    virtual bool CanReadUnaligned() const
    {
        return false;
    }
 
 
    virtual void Initialize() = 0;
 
    virtual void InitFaultRecovery(UE::Net::FNetConnectionFaultRecoveryBase* InFaultRecovery)
    {
    }
 
    virtual void NotifyHandshakeBegin()
    {
    }
 
    virtual void Tick(float DeltaTime) {}
 
    PACKETHANDLER_API virtual void SetActive(bool Active);
 
    virtual int32 GetReservedPacketBits() const = 0;
 
    FName GetName() const { return Name; }
 
    virtual void NotifyAnalyticsProvider() {}
 
    PACKETHANDLER_API virtual void CountBytes(FArchive& Ar) const;
 
protected:
    PACKETHANDLER_API void SetState(UE::Handler::Component::State State);
 
    PACKETHANDLER_API void Initialized();
 
 
public:
    PacketHandler* Handler; 
 
protected:
    UE::Handler::Component::State State;
 
    uint32 MaxOutgoingBits;
 
    bool bRequiresHandshake;
 
    bool bRequiresReliability;
 
private:
    bool bActive;
 
    bool bInitialized;
 
    /* The name of this component */
    FName Name;
};
 
class FPacketHandlerComponentModuleInterface : public IModuleInterface
{
public:
    /* Creates an instance of this component */
    virtual TSharedPtr<HandlerComponent> CreateComponentInstance(FString& Options)
    {
        return nullptr;
    }
 
    PACKETHANDLER_API virtual void StartupModule() override;
 
    PACKETHANDLER_API virtual void ShutdownModule() override;
};