CoreNet.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/BitArray.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformMath.h"
#include "Misc/AssertionMacros.h"
#include "Misc/NetworkGuid.h"
#include "Serialization/BitReader.h"
#include "Serialization/BitWriter.h"
#include "Templates/PimplPtr.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTypeTraits.h"
#include "Trace/Config.h"
#include "UObject/Class.h"
#include "UObject/CoreNetTypes.h"
#include "UObject/Field.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "CoreNet.generated.h"
 
class FArchive;
class FName;
class FNetTraceCollector;
class FGuidReferences;
class FOutBunch;
class FOutputDevice;
class FProperty;
class INetDeltaBaseState;
class UClass;
class UField;
class UFunction;
class UPackageMap;
class UStruct;
struct FObjectPtr;
struct FSoftObjectPath;
struct FSoftObjectPtr;
 
namespace UE::Net
{
    struct FNetResult;
 
    class FReplicationFragment;
    struct FReplicationStateDescriptor;
    typedef FReplicationFragment* (*CreateAndRegisterReplicationFragmentFunc)(UObject* Owner, const FReplicationStateDescriptor* Descriptor, FFragmentRegistrationContext& Context);
    
    class FNetTokenExportContext;
    class FNetTokenResolveContext;
 
    namespace Private
    {
        class FNetPropertyConditionManager;
    };
}
 
 
DECLARE_DELEGATE_RetVal_OneParam( bool, FNetObjectIsDynamic, const UObject*);
 
//
// Information about a field.
//
class FFieldNetCache
{
public:
    FFieldVariant           Field;
    int32           FieldNetIndex;
    uint32          FieldChecksum;
    mutable bool    bIncompatible;
 
    FFieldNetCache()
    {}
    FFieldNetCache(FFieldVariant InField, int32 InFieldNetIndex, uint32 InFieldChecksum )
        : Field(InField), FieldNetIndex(InFieldNetIndex), FieldChecksum(InFieldChecksum), bIncompatible(false)
    {}
};
 
//
// Information about a class, cached for network coordination.
//
class FClassNetCache
{
    friend class FClassNetCacheMgr;
public:
    COREUOBJECT_API FClassNetCache();
    COREUOBJECT_API FClassNetCache( const UClass* Class );
 
    int32 GetMaxIndex() const
    {
        return FieldsBase + Fields.Num();
    }
 
    const FFieldNetCache* GetFromField( FFieldVariant Field ) const
    {
        FFieldNetCache* Result = NULL;
 
        for ( const FClassNetCache* C= this; C; C = C->Super )
        {
            if ( ( Result = C->FieldMap.FindRef( Field.GetRawPointer() ) ) != NULL )
            {
                break;
            }
        }
        return Result;
    }
 
    const FFieldNetCache* GetFromChecksum( const uint32 Checksum ) const
    {
        FFieldNetCache* Result = NULL;
 
        for ( const FClassNetCache* C = this; C; C = C->Super )
        {
            if ( ( Result = C->FieldChecksumMap.FindRef( Checksum ) ) != NULL )
            {
                break;
            }
        }
        return Result;
    }
 
    const FFieldNetCache* GetFromIndex( const int32 Index ) const
    {
        for ( const FClassNetCache* C = this; C; C = C->Super )
        {
            if ( Index >= C->FieldsBase && Index < C->FieldsBase + C->Fields.Num() )
            {
                return &C->Fields[Index-C->FieldsBase];
            }
        }
        return NULL;
    }
 
    uint32 GetClassChecksum() const { return ClassChecksum; }
 
    const FClassNetCache* GetSuper() const { return Super; }
    const TArray< FFieldNetCache >& GetFields() const { return Fields; }
 
    COREUOBJECT_API void CountBytes(FArchive& Ar) const;
 
private:
    int32                               FieldsBase;
    const FClassNetCache*               Super;
    TWeakObjectPtr< const UClass >      Class;
    uint32                              ClassChecksum;
    TArray< FFieldNetCache >            Fields;
    TMap< void*, FFieldNetCache* >  FieldMap;
    TMap< uint32, FFieldNetCache* >     FieldChecksumMap;
};
 
 
class FClassNetCacheMgr
{
public:
    FClassNetCacheMgr() : bDebugChecksum( false ), DebugChecksumIndent( 0 ) { }
    ~FClassNetCacheMgr() { ClearClassNetCache(); }
 
    COREUOBJECT_API const FClassNetCache*   GetClassNetCache( UClass* Class );
    COREUOBJECT_API void                    ClearClassNetCache();
 
    COREUOBJECT_API void                SortProperties( TArray< FProperty* >& Properties ) const;
    COREUOBJECT_API uint32              SortedStructFieldsChecksum( const UStruct* Struct, uint32 Checksum ) const;
    COREUOBJECT_API uint32              GetPropertyChecksum( const FProperty* Property, uint32 Checksum, const bool bIncludeChildren ) const;
    COREUOBJECT_API uint32              GetFunctionChecksum( const UFunction* Function, uint32 Checksum ) const;
    COREUOBJECT_API uint32              GetFieldChecksum( const UField* Field, uint32 Checksum ) const;
 
    bool                bDebugChecksum;
    int                 DebugChecksumIndent;
 
    COREUOBJECT_API void CountBytes(FArchive& Ar) const;
 
private:
    TMap< TWeakObjectPtr< const UClass >, FClassNetCache* > ClassFieldIndices;
};
 
 
//
// Maps objects and names to and from indices for network communication.
//
UCLASS(Transient, Abstract, MinimalAPI, Config=Engine)
class UPackageMap : public UObject
{
    GENERATED_BODY()
public:
 
    virtual bool        WriteObject( FArchive & Ar, UObject* InOuter, FNetworkGUID NetGUID, FString ObjName ) { return false; }
 
    // @todo document
    virtual bool        SerializeObject( FArchive& Ar, UClass* InClass, UObject*& Obj, FNetworkGUID *OutNetGUID = NULL ) { return false; }
 
    // @todo document
    COREUOBJECT_API virtual bool        SerializeName( FArchive& Ar, FName& InName );
 
    static COREUOBJECT_API bool         StaticSerializeName( FArchive& Ar, FName& InName );
 
    virtual UObject*    ResolvePathAndAssignNetGUID( const FNetworkGUID& NetGUID, const FString& PathName ) { return NULL; }
 
    virtual bool        SerializeNewActor(FArchive & Ar, class UActorChannel * Channel, class AActor *& Actor) { return false; }
 
    virtual void        ReceivedNak( const int32 NakPacketId ) { }
    virtual void        ReceivedAck( const int32 AckPacketId ) { }
    virtual void        NotifyBunchCommit( const int32 OutPacketId, const FOutBunch* OutBunch ) { }
 
    virtual void        GetNetGUIDStats(int32& AckCount, int32& UnAckCount, int32& PendingCount) { }
 
    virtual void        NotifyStreamingLevelUnload( UObject* UnloadedLevel ) { }
 
    virtual bool        PrintExportBatch() { return false; }
 
    void                SetDebugContextString( const FString& Str ) { DebugContextString = Str; }
    void                ClearDebugContextString() { DebugContextString.Empty(); }
 
    void                            ResetTrackedGuids( bool bShouldTrack ) { TrackedUnmappedNetGuids.Empty(); TrackedMappedDynamicNetGuids.Empty(); bShouldTrackUnmappedGuids = bShouldTrack; }
    const TSet< FNetworkGUID > &    GetTrackedUnmappedGuids() const { return TrackedUnmappedNetGuids; }
    const TSet< FNetworkGUID > &    GetTrackedDynamicMappedGuids() const { return TrackedMappedDynamicNetGuids; }
 
    virtual void AddUnmappedNetGUIDReference(FNetworkGUID UnmappedGUID) {}
    virtual void RemoveUnmappedNetGUIDReference(FNetworkGUID UnmappedGUID) {}
 
    // For sync load debugging with LogNetSyncLoads
    virtual void            ResetTrackedSyncLoadedGuids() {}
    virtual void            ReportSyncLoadsForProperty(const FProperty* Property, const UObject* Object) {}
 
    virtual void            LogDebugInfo( FOutputDevice & Ar) { }
    virtual UObject*        GetObjectFromNetGUID( const FNetworkGUID& NetGUID, const bool bIgnoreMustBeMapped ) { return NULL; }
    virtual FNetworkGUID    GetNetGUIDFromObject( const UObject* InObject) const { return FNetworkGUID(); }
    virtual bool            IsGUIDBroken( const FNetworkGUID& NetGUID, const bool bMustBeRegistered ) const { return false; }
    virtual bool            IsUsingRemoteObjectReferences() const { return false; }
 
    COREUOBJECT_API virtual void Serialize(FArchive& Ar) override;
 
    // Provides access to the context required to resolve received NetTokens.
    virtual const UE::Net::FNetTokenResolveContext* GetNetTokenResolveContext() const { return nullptr; }
 
    COREUOBJECT_API UPackageMap();
    COREUOBJECT_API UPackageMap(const FObjectInitializer& ObjectInitializer);
    COREUOBJECT_API virtual ~UPackageMap();
 
protected:
    bool                    bShouldTrackUnmappedGuids;
    TSet< FNetworkGUID >    TrackedUnmappedNetGuids;
    TSet< FNetworkGUID >    TrackedMappedDynamicNetGuids;
 
    FString                 DebugContextString;
};
 
 
struct FPacketIdRange
{
    FPacketIdRange(int32 _First, int32 _Last) : First(_First), Last(_Last) { }
    FPacketIdRange(int32 PacketId) : First(PacketId), Last(PacketId) { }
    FPacketIdRange() : First(INDEX_NONE), Last(INDEX_NONE) { }
    int32 First;
    int32 Last;
 
    bool InRange(int32 PacketId) const
    {
        return (First <= PacketId && PacketId <= Last);
    }
};
 
 
struct FPropertyRetirement
{
    FPropertyRetirement* Next;
 
    TSharedPtr<class INetDeltaBaseState> DynamicState;
 
    FPacketIdRange OutPacketIdRange;
    uint32 FastArrayChangelistHistory;
 
    FPropertyRetirement() :
         Next(nullptr)
        , DynamicState(nullptr)
        , FastArrayChangelistHistory(0)
    {}
 
    void CountBytes(FArchive& Ar) const;
};
 
 
class FLifetimeProperty
{
public:
 
    uint16 RepIndex = 0;
 
    ELifetimeCondition Condition = COND_None;
 
    ELifetimeRepNotifyCondition RepNotifyCondition = REPNOTIFY_OnChanged;
 
    bool bIsPushBased = false;
 
    UE::Net::CreateAndRegisterReplicationFragmentFunc CreateAndRegisterReplicationFragmentFunction = nullptr;
 
    FLifetimeProperty() = default;
 
    FLifetimeProperty(int32 InRepIndex)
        : RepIndex((uint16)InRepIndex)
    {
        check(InRepIndex <= 65535);
    }
 
    FLifetimeProperty(int32 InRepIndex, ELifetimeCondition InCondition, ELifetimeRepNotifyCondition InRepNotifyCondition=REPNOTIFY_OnChanged, bool bInIsPushBased=false)
        : RepIndex((uint16)InRepIndex)
        , Condition(InCondition)
        , RepNotifyCondition(InRepNotifyCondition)
        , bIsPushBased(bInIsPushBased)
    {
        check(InRepIndex <= 65535);
    }
 
    inline bool operator==(const FLifetimeProperty& Other) const
    {
        if (RepIndex == Other.RepIndex)
        {
            // Can't have different conditions if the RepIndex matches, doesn't make sense
            check(Condition == Other.Condition);
            check(RepNotifyCondition == Other.RepNotifyCondition);
            check(bIsPushBased == Other.bIsPushBased);
            check(CreateAndRegisterReplicationFragmentFunction == Other.CreateAndRegisterReplicationFragmentFunction);
            return true;
        }
 
        return false;
    }
};
 
template <> struct TIsZeroConstructType<FLifetimeProperty> { enum { Value = true }; };
 
GENERATE_MEMBER_FUNCTION_CHECK(GetLifetimeReplicatedProps, void, const, TArray<FLifetimeProperty>&)
 
 
template<typename T>
class TNetDoNotCopyPtr
{
public:
    TNetDoNotCopyPtr() : Ptr(nullptr) {}
    TNetDoNotCopyPtr(const TNetDoNotCopyPtr&) : Ptr(nullptr) {}
    TNetDoNotCopyPtr(TNetDoNotCopyPtr&&) { Ptr = nullptr; }
    TNetDoNotCopyPtr& operator=(const TNetDoNotCopyPtr& Other) { Ptr = nullptr; return *this; }
    TNetDoNotCopyPtr& operator=(TNetDoNotCopyPtr&&) { Ptr = nullptr; return *this; }
    void Set(T* InPtr) { Ptr = InPtr; }
    T* Get() const { return Ptr; }
private:
    T* Ptr;
};
 
#if UE_TRACE_ENABLED
using FNetTraceCollectorDoNotCopyWrapper = TNetDoNotCopyPtr<FNetTraceCollector>;
#endif
 
class FNetBitWriter : public FBitWriter
{
public:
    COREUOBJECT_API FNetBitWriter(UPackageMap* InPackageMap, int64 InMaxBits);
    COREUOBJECT_API FNetBitWriter(int64 InMaxBits);
    COREUOBJECT_API FNetBitWriter();
 
    class UPackageMap * PackageMap;
 
#if UE_TRACE_ENABLED
    FNetTraceCollectorDoNotCopyWrapper TraceCollector;
#endif
 
    COREUOBJECT_API virtual FArchive& operator<<(FName& Name) override;
    COREUOBJECT_API virtual FArchive& operator<<(UObject*& Object) override;
    COREUOBJECT_API virtual FArchive& operator<<(FSoftObjectPath& Value) override;
    COREUOBJECT_API virtual FArchive& operator<<(FSoftObjectPtr& Value) override;
    COREUOBJECT_API virtual FArchive& operator<<(FObjectPtr& Value) override;
    COREUOBJECT_API virtual FArchive& operator<<(struct FWeakObjectPtr& Value) override;
 
    COREUOBJECT_API virtual void CountMemory(FArchive& Ar) const override;
 
    /* Context allowing exports of NetTokens from NetSerialize(), the context will not be copied when copying NetBitWriter */
    TNetDoNotCopyPtr<UE::Net::FNetTokenExportContext> NetTokenExportContext;
};
 
class FNetBitReader : public FBitReader
{
public:
    UPackageMap*                                                    PackageMap      = nullptr;
 
    TPimplPtr<UE::Net::FNetResult, EPimplPtrMode::DeepCopy> ExtendedError;
 
 
public:
    COREUOBJECT_API FNetBitReader(UPackageMap* InPackageMap=nullptr, const uint8* Src=nullptr, int64 CountBits=0);
    COREUOBJECT_API FNetBitReader(const FNetBitReader&);
    COREUOBJECT_API FNetBitReader& operator=(const FNetBitReader&);
    COREUOBJECT_API FNetBitReader(FNetBitReader&&);
    COREUOBJECT_API FNetBitReader& operator=(FNetBitReader&&);
    COREUOBJECT_API virtual ~FNetBitReader();
 
    COREUOBJECT_API virtual FArchive& operator<<(FName& Name) override;
    COREUOBJECT_API virtual FArchive& operator<<(UObject*& Object) override;
    COREUOBJECT_API virtual FArchive& operator<<(FSoftObjectPath& Value) override;
    COREUOBJECT_API virtual FArchive& operator<<(FSoftObjectPtr& Value) override;
    COREUOBJECT_API virtual FArchive& operator<<(FObjectPtr& Value) override;
    COREUOBJECT_API virtual FArchive& operator<<(struct FWeakObjectPtr& Value) override;
 
    COREUOBJECT_API virtual void CountMemory(FArchive& Ar) const override;
};
 
inline uint32 GetBitStreamPositionForNetTrace(const FBitWriter& Stream) { return (uint32)Stream.GetNumBits(); }
inline uint32 GetBitStreamPositionForNetTrace(const FBitReader& Stream) { return (uint32)Stream.GetPosBits(); }
 
#if UE_TRACE_ENABLED
inline FNetTraceCollector* GetTraceCollector(const FNetBitWriter& BitWriter) { return BitWriter.TraceCollector.Get(); }
inline void SetTraceCollector(FNetBitWriter& BitWriter, FNetTraceCollector* Collector) { BitWriter.TraceCollector.Set(Collector); }
#else
inline FNetTraceCollector* GetTraceCollector(const FNetBitWriter& BitWriter) { return nullptr; }
inline void SetTraceCollector(FNetBitWriter& BitWriter, FNetTraceCollector* Collector) {}
#endif
 
bool inline NetworkGuidSetsAreSame( const TSet< FNetworkGUID >& A, const TSet< FNetworkGUID >& B )
{
    if ( A.Num() != B.Num() )
    {
        return false;
    }
 
    for ( const FNetworkGUID& CompareGuid : A )
    {
        if ( !B.Contains( CompareGuid ) )
        {
            return false;
        }
    }
 
    return true;
}
 
class INetDeltaBaseState : public TSharedFromThis<INetDeltaBaseState>
{
public:
    INetDeltaBaseState()
        : LastAckedHistory(0)
        , ChangelistHistory(0)
    {
 
    }
 
    virtual ~INetDeltaBaseState() { }
 
    virtual bool IsStateEqual(INetDeltaBaseState* Otherstate) = 0;
 
    virtual void CountBytes(FArchive& Ar) const {}
 
    uint32 GetLastAckedHistory() const { return LastAckedHistory; }
    void SetLastAckedHistory(uint32 InAckedHistory) { LastAckedHistory = InAckedHistory; }
 
    uint32 GetChangelistHistory() const { return ChangelistHistory; }
    void SetChangelistHistory(uint32 InChangelistHistory) { ChangelistHistory = InChangelistHistory; }
 
private:
    uint32 LastAckedHistory;
    uint32 ChangelistHistory;
};
 
struct FNetDeltaSerializeInfo;
 
class INetSerializeCB
{
protected:
 
    using FGuidReferencesMap = TMap<int32, FGuidReferences>;
 
public:
 
    INetSerializeCB() { }
 
    virtual ~INetSerializeCB() {}
 
    virtual void NetSerializeStruct(FNetDeltaSerializeInfo& Params) = 0;
 
    virtual void GatherGuidReferencesForFastArray(struct FFastArrayDeltaSerializeParams& Params) = 0;
 
    virtual bool MoveGuidToUnmappedForFastArray(struct FFastArrayDeltaSerializeParams& Params) = 0;
 
    virtual void UpdateUnmappedGuidsForFastArray(struct FFastArrayDeltaSerializeParams& Params) = 0;
 
    virtual bool NetDeltaSerializeForFastArray(struct FFastArrayDeltaSerializeParams& Params) = 0;
};
 
 
class IRepChangedPropertyTracker
{
public:
    UE_DEPRECATED(5.5, "Will be removed or renamed and used to pass paramters.")
    IRepChangedPropertyTracker() { }
    virtual ~IRepChangedPropertyTracker() { }
};
 
class FCustomPropertyConditionState
{
public:
    FCustomPropertyConditionState() = delete;
    FCustomPropertyConditionState(int32 NumProperties)
    : CurrentState(true /* initial value of all bits */, NumProperties)
    , DynamicConditionChangeCounter(0)
    {
    }
 
    void SetActiveState(const uint16 RepIndex, const bool bIsActive)
    {
        CurrentState[RepIndex] = bIsActive;
    }
 
    bool GetActiveState(const uint16 RepIndex) const
    {
        return CurrentState[RepIndex];
    }
 
    void SetDynamicCondition(const uint16 RepIndex, const ELifetimeCondition Condition)
    {
        static_assert(static_cast<__underlying_type(ELifetimeCondition)>(ELifetimeCondition::COND_Max - 1) <= int16(32767), "Unable to use int16 for ELifetimeCondition values");
 
        ++DynamicConditionChangeCounter;
        DynamicConditions.Emplace(RepIndex, static_cast<int16>(Condition));
    }
 
    ELifetimeCondition GetDynamicCondition(const uint16 RepIndex) const
    {
        if (const int16* Condition = DynamicConditions.Find(RepIndex))
        {
            return static_cast<const ELifetimeCondition>(*Condition);
        }
 
        return COND_Dynamic;
    }
 
 
    int32 GetNumProperties() const
    {
        return CurrentState.Num();
    }
 
    uint32 GetDynamicConditionChangeCounter() const
    {
        return DynamicConditionChangeCounter;
    }
 
    void CountBytes(FArchive& Ar) const
    {
        CurrentState.CountBytes(Ar);
    }
 
private:
    TBitArray<> CurrentState;
    // Storing int16 instead of int-sized ELifetimeCondition to save some memory.
    TMap<uint16, int16> DynamicConditions;
    uint32 DynamicConditionChangeCounter;
};
 
struct FNetDeltaSerializeInfo
{
    FBitWriter* Writer = nullptr;
 
    FBitReader* Reader = nullptr;
 
    TSharedPtr<INetDeltaBaseState>* NewState = nullptr;
 
    INetDeltaBaseState* OldState = nullptr;
 
    class UPackageMap* Map = nullptr;
 
    class UNetConnection* Connection = nullptr;
 
    void* Data = nullptr;
 
    class UStruct* Struct = nullptr;
 
    INetSerializeCB* NetSerializeCB = nullptr;
 
    bool bUpdateUnmappedObjects = false;
 
    bool bOutSomeObjectsWereMapped = false;
 
    bool bCalledPreNetReceive = false;
 
    bool bOutHasMoreUnmapped = false;
 
    bool bGuidListsChanged = false;
 
    bool bIsWritingOnClient = false;
 
    //~ TODO: This feels hacky, and a better alternative might be something like connection specific
    //~ capabilities.
 
    bool bIsInitializingBaseFromDefault = false;
 
    bool bSupportsFastArrayDeltaStructSerialization = false;
    
#if UE_SUPPORT_FOR_ACTOR_TICK_DISABLE
    bool bCallFastArrayClientCallbacks = true;
#endif
 
    bool bInternalAck = false;
 
    UObject* Object = nullptr;
 
    UObject* CustomDeltaObject = nullptr;
 
    TSet<FNetworkGUID>* GatherGuidReferences = nullptr;
 
    int32* TrackedGuidMemoryBytes = nullptr;
 
    const FNetworkGUID* MoveGuidToUnmapped = nullptr;
 
    uint16 CustomDeltaIndex = uint16(INDEX_NONE);
 
    // Debugging variables
    FString DebugName;
};
 
struct FEncryptionData
{
    TArray<uint8> Key;
    TArray<uint8> Fingerprint;
    FString Identifier;
};
 
COREUOBJECT_API void SerializeChecksum(FArchive &Ar, uint32 x, bool ErrorOK);
 
#define NET_ENABLE_CHECKSUMS 0
 
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) && NET_ENABLE_CHECKSUMS
 
#define NET_CHECKSUM_OR_END(Ser) \
{ \
    SerializeChecksum(Ser,0xE282FA84, true); \
}
 
#define NET_CHECKSUM(Ser) \
{ \
    SerializeChecksum(Ser,0xE282FA84, false); \
}
 
#define NET_CHECKSUM_CUSTOM(Ser, x) \
{ \
    SerializeChecksum(Ser,x, false); \
}
 
// There are cases where a checksum failure is expected, but we still need to eat the next word (just dont without erroring)
#define NET_CHECKSUM_IGNORE(Ser) \
{ \
    uint32 Magic = 0; \
    Ser << Magic; \
}
 
#else
 
// No ops in shipping builds
#define NET_CHECKSUM(Ser)
#define NET_CHECKSUM_IGNORE(Ser)
#define NET_CHECKSUM_CUSTOM(Ser, x)
#define NET_CHECKSUM_OR_END(ser)
 
 
#endif
 
enum { MAX_PACKET_SIZE = 1024 }; // MTU for the connection
enum { LAN_BEACON_MAX_PACKET_SIZE = 1024 }; // MTU for the connection
 
COREUOBJECT_API void            RPC_ResetLastFailedReason();
COREUOBJECT_API void            RPC_ValidateFailed( const TCHAR* Reason );
COREUOBJECT_API const TCHAR *   RPC_GetLastFailedReason();