564 lines
16 KiB
C++
564 lines
16 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
UnCoreNet.cpp: Core networking support.
|
|
=============================================================================*/
|
|
|
|
#include "UObject/CoreNet.h"
|
|
#include "UObject/UnrealType.h"
|
|
#include "Misc/NetworkVersion.h"
|
|
|
|
DEFINE_LOG_CATEGORY_STATIC(LogCoreNet, Log, All);
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
FClassNetCache implementation.
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
FClassNetCache::FClassNetCache()
|
|
{
|
|
}
|
|
|
|
FClassNetCache::FClassNetCache(const UClass* InClass): Class(InClass)
|
|
{
|
|
}
|
|
|
|
void FClassNetCacheMgr::SortProperties(TArray<FProperty*>& Properties) const
|
|
{
|
|
// Sort NetProperties so that their ClassReps are sorted by memory offset
|
|
struct FCompareUFieldOffsets
|
|
{
|
|
FORCEINLINE bool operator()(FProperty& A, FProperty& B) const
|
|
{
|
|
// Ensure stable sort
|
|
if (A.GetOffset_ForGC() == B.GetOffset_ForGC())
|
|
{
|
|
return A.GetName() < B.GetName();
|
|
}
|
|
|
|
return A.GetOffset_ForGC() < B.GetOffset_ForGC();
|
|
}
|
|
};
|
|
|
|
Sort(Properties.GetData(), Properties.Num(), FCompareUFieldOffsets());
|
|
}
|
|
|
|
uint32 FClassNetCacheMgr::SortedStructFieldsChecksum(const UStruct* Struct, uint32 Checksum) const
|
|
{
|
|
// Generate a list that we can sort, to make sure we process these deterministically
|
|
TArray<FProperty*> Fields;
|
|
|
|
for (TFieldIterator<FProperty> It(Struct); It; ++It)
|
|
{
|
|
if (It->PropertyFlags & CPF_RepSkip)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Fields.Add(*It);
|
|
}
|
|
|
|
// Sort them
|
|
SortProperties(Fields);
|
|
|
|
// Evolve the checksum on the sorted list
|
|
for (auto Field: Fields)
|
|
{
|
|
Checksum = GetPropertyChecksum(Field, Checksum, true);
|
|
}
|
|
|
|
return Checksum;
|
|
}
|
|
|
|
uint32 FClassNetCacheMgr::GetPropertyChecksum(const FProperty* Property, uint32 Checksum, const bool bIncludeChildren) const
|
|
{
|
|
if (bDebugChecksum)
|
|
{
|
|
UE_LOG(LogCoreNet, Warning, TEXT("%s%s [%s] [%u] [%u]"), FCString::Spc(2 * DebugChecksumIndent), *Property->GetName().ToLower(), *Property->GetClass()->GetName().ToLower(), Property->ArrayDim, Checksum);
|
|
}
|
|
|
|
Checksum = FCrc::StrCrc32(*Property->GetName().ToLower(), Checksum); // Evolve checksum on name
|
|
Checksum = FCrc::StrCrc32(*Property->GetCPPType(nullptr, 0).ToLower(), Checksum); // Evolve by property type
|
|
Checksum = FCrc::StrCrc32(*FString::Printf(TEXT("%u"), Property->ArrayDim), Checksum); // Evolve checksum on array dim (to detect when static arrays change size)
|
|
|
|
if (bIncludeChildren)
|
|
{
|
|
const FArrayProperty* ArrayProperty = CastField<FArrayProperty>(Property);
|
|
|
|
// Evolve checksum on array inner
|
|
if (ArrayProperty != NULL)
|
|
{
|
|
return GetPropertyChecksum(ArrayProperty->Inner, Checksum, bIncludeChildren);
|
|
}
|
|
|
|
const FStructProperty* StructProperty = CastField<FStructProperty>(Property);
|
|
|
|
// Evolve checksum on property struct fields
|
|
if (StructProperty != NULL)
|
|
{
|
|
if (bDebugChecksum)
|
|
{
|
|
UE_LOG(LogCoreNet, Warning, TEXT("%s [%s] [%u]"), FCString::Spc(2 * DebugChecksumIndent), *StructProperty->Struct->GetName().ToLower(), Checksum);
|
|
}
|
|
|
|
// Evolve checksum on struct name
|
|
Checksum = FCrc::StrCrc32(*StructProperty->Struct->GetName().ToLower(), Checksum);
|
|
|
|
const_cast<FClassNetCacheMgr*>(this)->DebugChecksumIndent++;
|
|
|
|
Checksum = SortedStructFieldsChecksum(StructProperty->Struct, Checksum);
|
|
|
|
const_cast<FClassNetCacheMgr*>(this)->DebugChecksumIndent--;
|
|
}
|
|
}
|
|
|
|
return Checksum;
|
|
}
|
|
|
|
uint32 FClassNetCacheMgr::GetFunctionChecksum(const UFunction* Function, uint32 Checksum) const
|
|
{
|
|
// Evolve checksum on function name
|
|
Checksum = FCrc::StrCrc32(*Function->GetName().ToLower(), Checksum);
|
|
|
|
// Evolve the checksum on function flags
|
|
Checksum = FCrc::StrCrc32(*FString::Printf(TEXT("%u"), (uint32)Function->FunctionFlags), Checksum);
|
|
|
|
#if 0 // This is disabled now that we have backwards compatibility for RPC parameters working in replays
|
|
TArray< FProperty * > Parms;
|
|
|
|
for ( TFieldIterator< FProperty > It( Function ); It && ( It->PropertyFlags & ( CPF_Parm | CPF_ReturnParm ) ) == CPF_Parm; ++It )
|
|
{
|
|
Parms.Add( *It );
|
|
}
|
|
|
|
// Sort parameters by offset/name
|
|
SortProperties( Parms );
|
|
|
|
// Evolve checksum on sorted function parameters
|
|
for ( FProperty* Parm : Parms )
|
|
{
|
|
Checksum = GetPropertyChecksum( Parm, Checksum, true );
|
|
}
|
|
#endif
|
|
|
|
return Checksum;
|
|
}
|
|
|
|
uint32 FClassNetCacheMgr::GetFieldChecksum(const UField* Field, uint32 Checksum) const
|
|
{
|
|
if (Cast<UFunction>(Field) != NULL)
|
|
{
|
|
return GetFunctionChecksum((UFunction*)Field, Checksum);
|
|
}
|
|
|
|
UE_LOG(LogCoreNet, Warning, TEXT("GetFieldChecksum: Unknown field: %s"), *Field->GetName());
|
|
|
|
return Checksum;
|
|
}
|
|
|
|
const FClassNetCache* FClassNetCacheMgr::GetClassNetCache(UClass* Class)
|
|
{
|
|
FClassNetCache* Result = ClassFieldIndices.FindRef(Class);
|
|
|
|
if (!Result)
|
|
{
|
|
Class->SetUpRuntimeReplicationData();
|
|
|
|
Result = ClassFieldIndices.Add(Class, new FClassNetCache(Class));
|
|
Result->Super = NULL;
|
|
Result->FieldsBase = 0;
|
|
Result->ClassChecksum = 0;
|
|
|
|
if (Class->GetSuperClass())
|
|
{
|
|
Result->Super = GetClassNetCache(Class->GetSuperClass());
|
|
Result->FieldsBase = Result->Super->GetMaxIndex();
|
|
Result->ClassChecksum = Result->Super->ClassChecksum;
|
|
}
|
|
|
|
Result->Fields.Empty(Class->NetFields.Num());
|
|
|
|
TArray<FProperty*> Properties;
|
|
Properties.Empty(Class->ClassReps.Num() - Class->FirstOwnedClassRep);
|
|
|
|
for (int32 i = Class->FirstOwnedClassRep; i < Class->ClassReps.Num(); i++)
|
|
{
|
|
// Add each net field to cache, and assign index/checksum
|
|
FProperty* Property = Class->ClassReps[i].Property;
|
|
check(Property);
|
|
Properties.Add(Property);
|
|
|
|
// Get individual checksum
|
|
const uint32 Checksum = GetPropertyChecksum(Property, 0, false);
|
|
|
|
// Get index
|
|
const int32 ThisIndex = Result->GetMaxIndex();
|
|
|
|
// Add to cached fields on this class
|
|
Result->Fields.Add(FFieldNetCache(Property, ThisIndex, Checksum));
|
|
|
|
// Skip over static array properties.
|
|
i += (Property->ArrayDim - 1);
|
|
}
|
|
|
|
for (int32 i = 0; i < Class->NetFields.Num(); i++)
|
|
{
|
|
// Add each net field to cache, and assign index/checksum
|
|
UField* Field = Class->NetFields[i];
|
|
|
|
// Get individual checksum
|
|
const uint32 Checksum = GetFieldChecksum(Field, 0);
|
|
|
|
// Get index
|
|
const int32 ThisIndex = Result->GetMaxIndex();
|
|
|
|
// Add to cached fields on this class
|
|
Result->Fields.Add(FFieldNetCache(Field, ThisIndex, Checksum));
|
|
}
|
|
|
|
Result->Fields.Shrink();
|
|
|
|
// Add fields to the appropriate hash maps
|
|
for (TArray<FFieldNetCache>::TIterator It(Result->Fields); It; ++It)
|
|
{
|
|
Result->FieldMap.Add(It->Field.GetRawPointer(), &*It);
|
|
|
|
if (Result->FieldChecksumMap.Contains(It->FieldChecksum))
|
|
{
|
|
UE_LOG(LogCoreNet, Error, TEXT("Duplicate checksum: %s, %u"), *It->Field.GetFullName(), It->FieldChecksum);
|
|
}
|
|
|
|
Result->FieldChecksumMap.Add(It->FieldChecksum, &*It);
|
|
}
|
|
|
|
// Initialize class checksum (just use properties for this)
|
|
SortProperties(Properties);
|
|
|
|
for (auto Property: Properties)
|
|
{
|
|
Result->ClassChecksum = GetPropertyChecksum(Property, Result->ClassChecksum, true);
|
|
}
|
|
}
|
|
return Result;
|
|
}
|
|
|
|
void FClassNetCacheMgr::ClearClassNetCache()
|
|
{
|
|
for (auto It = ClassFieldIndices.CreateIterator(); It; ++It)
|
|
{
|
|
delete It.Value();
|
|
}
|
|
|
|
ClassFieldIndices.Empty();
|
|
}
|
|
|
|
void FClassNetCacheMgr::CountBytes(FArchive& Ar) const
|
|
{
|
|
ClassFieldIndices.CountBytes(Ar);
|
|
for (const auto& ClassFieldPair: ClassFieldIndices)
|
|
{
|
|
if (ClassFieldPair.Value != nullptr)
|
|
{
|
|
Ar.CountBytes(sizeof(FClassNetCache), sizeof(FClassNetCache));
|
|
ClassFieldPair.Value->CountBytes(Ar);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FClassNetCache::CountBytes(FArchive& Ar) const
|
|
{
|
|
Fields.CountBytes(Ar);
|
|
FieldMap.CountBytes(Ar);
|
|
FieldChecksumMap.CountBytes(Ar);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
UPackageMap implementation.
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
bool UPackageMap::SerializeName(FArchive& Ar, FName& InName)
|
|
{
|
|
return StaticSerializeName(Ar, InName);
|
|
}
|
|
|
|
bool UPackageMap::StaticSerializeName(FArchive& Ar, FName& InName)
|
|
{
|
|
if (Ar.IsLoading())
|
|
{
|
|
uint8 bHardcoded = 0;
|
|
Ar.SerializeBits(&bHardcoded, 1);
|
|
if (bHardcoded)
|
|
{
|
|
// replicated by hardcoded index
|
|
uint32 NameIndex;
|
|
if (Ar.EngineNetVer() < HISTORY_CHANNEL_NAMES)
|
|
{
|
|
Ar.SerializeInt(NameIndex, MAX_NETWORKED_HARDCODED_NAME + 1);
|
|
}
|
|
else
|
|
{
|
|
Ar.SerializeIntPacked(NameIndex);
|
|
}
|
|
|
|
if (NameIndex < NAME_MaxHardcodedNameIndex)
|
|
{
|
|
InName = EName(NameIndex);
|
|
// hardcoded names never have a Number
|
|
}
|
|
else
|
|
{
|
|
Ar.SetError();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// replicated by string
|
|
FString InString;
|
|
int32 InNumber;
|
|
Ar << InString << InNumber;
|
|
InName = FName(*InString, InNumber);
|
|
}
|
|
}
|
|
else if (Ar.IsSaving())
|
|
{
|
|
const EName* InEName = InName.ToEName();
|
|
uint8 bHardcoded = InEName && ShouldReplicateAsInteger(*InEName);
|
|
Ar.SerializeBits(&bHardcoded, 1);
|
|
if (bHardcoded && /* silence static analyzer */ InEName)
|
|
{
|
|
// send by hardcoded index
|
|
checkSlow(InName.GetNumber() <= 0); // hardcoded names should never have a Number
|
|
uint32 NameIndex = *InEName;
|
|
Ar.SerializeIntPacked(NameIndex);
|
|
}
|
|
else
|
|
{
|
|
// send by string
|
|
FString OutString = InName.GetPlainNameString();
|
|
int32 OutNumber = InName.GetNumber();
|
|
Ar << OutString << OutNumber;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
IMPLEMENT_CORE_INTRINSIC_CLASS(UPackageMap, UObject,
|
|
{});
|
|
|
|
void UPackageMap::Serialize(FArchive& Ar)
|
|
{
|
|
Super::Serialize(Ar);
|
|
|
|
if (Ar.IsCountingMemory())
|
|
{
|
|
TrackedUnmappedNetGuids.CountBytes(Ar);
|
|
TrackedMappedDynamicNetGuids.CountBytes(Ar);
|
|
Ar << DebugContextString;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
|
|
void SerializeChecksum(FArchive& Ar, uint32 x, bool ErrorOK)
|
|
{
|
|
if (Ar.IsLoading())
|
|
{
|
|
uint32 Magic = 0;
|
|
Ar << Magic;
|
|
if ((!ErrorOK || !Ar.IsError()) && !ensure(Magic == x))
|
|
{
|
|
UE_LOG(LogCoreNet, Warning, TEXT("%d == %d"), Magic, x);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint32 Magic = x;
|
|
Ar << Magic;
|
|
}
|
|
}
|
|
|
|
void FPropertyRetirement::CountBytes(FArchive& Ar) const
|
|
{
|
|
for (const FPropertyRetirement* NextRetirement = Next; NextRetirement; NextRetirement = NextRetirement->Next)
|
|
{
|
|
Ar.CountBytes(sizeof(FPropertyRetirement), sizeof(FPropertyRetirement));
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// FNetBitWriter
|
|
// ----------------------------------------------------------------
|
|
FNetBitWriter::FNetBitWriter()
|
|
: FBitWriter(0), PackageMap(nullptr)
|
|
{}
|
|
|
|
FNetBitWriter::FNetBitWriter(int64 InMaxBits)
|
|
: FBitWriter(InMaxBits, true), PackageMap(nullptr)
|
|
{
|
|
}
|
|
|
|
FNetBitWriter::FNetBitWriter(UPackageMap* InPackageMap, int64 InMaxBits)
|
|
: FBitWriter(InMaxBits, true), PackageMap(InPackageMap)
|
|
{
|
|
}
|
|
|
|
FArchive& FNetBitWriter::operator<<(class FName& N)
|
|
{
|
|
if (PackageMap)
|
|
{
|
|
PackageMap->SerializeName(*this, N);
|
|
}
|
|
else
|
|
{
|
|
UPackageMap::StaticSerializeName(*this, N);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
FArchive& FNetBitWriter::operator<<(UObject*& Object)
|
|
{
|
|
PackageMap->SerializeObject(*this, UObject::StaticClass(), Object);
|
|
return *this;
|
|
}
|
|
|
|
FArchive& FNetBitWriter::operator<<(FSoftObjectPath& Value)
|
|
{
|
|
// It's more efficient to serialize as a string then name+string
|
|
FString Path = Value.ToString();
|
|
*this << Path;
|
|
|
|
return *this;
|
|
}
|
|
|
|
FArchive& FNetBitWriter::operator<<(FSoftObjectPtr& Value)
|
|
{
|
|
return FArchiveUObject::SerializeSoftObjectPtr(*this, Value);
|
|
}
|
|
|
|
FArchive& FNetBitWriter::operator<<(struct FWeakObjectPtr& WeakObjectPtr)
|
|
{
|
|
return FArchiveUObject::SerializeWeakObjectPtr(*this, WeakObjectPtr);
|
|
}
|
|
|
|
void FNetBitWriter::CountMemory(FArchive& Ar) const
|
|
{
|
|
FBitWriter::CountMemory(Ar);
|
|
const SIZE_T MemberSize = sizeof(*this) - sizeof(FBitWriter);
|
|
Ar.CountBytes(MemberSize, MemberSize);
|
|
}
|
|
|
|
// ----------------------------------------------------------------
|
|
// FNetBitReader
|
|
// ----------------------------------------------------------------
|
|
FNetBitReader::FNetBitReader(UPackageMap* InPackageMap, uint8* Src, int64 CountBits)
|
|
: FBitReader(Src, CountBits), PackageMap(InPackageMap)
|
|
{
|
|
}
|
|
|
|
FArchive& FNetBitReader::operator<<(UObject*& Object)
|
|
{
|
|
PackageMap->SerializeObject(*this, UObject::StaticClass(), Object);
|
|
return *this;
|
|
}
|
|
|
|
FArchive& FNetBitReader::operator<<(class FName& N)
|
|
{
|
|
if (PackageMap)
|
|
{
|
|
PackageMap->SerializeName(*this, N);
|
|
}
|
|
else
|
|
{
|
|
UPackageMap::StaticSerializeName(*this, N);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
FArchive& FNetBitReader::operator<<(FSoftObjectPath& Value)
|
|
{
|
|
FString Path;
|
|
*this << Path;
|
|
|
|
Value.SetPath(MoveTemp(Path));
|
|
|
|
return *this;
|
|
}
|
|
|
|
FArchive& FNetBitReader::operator<<(FSoftObjectPtr& Value)
|
|
{
|
|
return FArchiveUObject::SerializeSoftObjectPtr(*this, Value);
|
|
}
|
|
|
|
FArchive& FNetBitReader::operator<<(struct FWeakObjectPtr& WeakObjectPtr)
|
|
{
|
|
return FArchiveUObject::SerializeWeakObjectPtr(*this, WeakObjectPtr);
|
|
return *this;
|
|
}
|
|
|
|
void FNetBitReader::CountMemory(FArchive& Ar) const
|
|
{
|
|
FBitReader::CountMemory(Ar);
|
|
const SIZE_T MemberSize = sizeof(*this) - sizeof(FBitReader);
|
|
Ar.CountBytes(MemberSize, MemberSize);
|
|
}
|
|
|
|
static const TCHAR* GLastRPCFailedReason = NULL;
|
|
|
|
void RPC_ResetLastFailedReason()
|
|
{
|
|
GLastRPCFailedReason = NULL;
|
|
}
|
|
void RPC_ValidateFailed(const TCHAR* Reason)
|
|
{
|
|
GLastRPCFailedReason = Reason;
|
|
}
|
|
|
|
const TCHAR* RPC_GetLastFailedReason()
|
|
{
|
|
return GLastRPCFailedReason;
|
|
}
|
|
|
|
const TCHAR* LexToString(const EChannelCloseReason Value)
|
|
{
|
|
switch (Value)
|
|
{
|
|
case EChannelCloseReason::Destroyed:
|
|
return TEXT("Destroyed");
|
|
case EChannelCloseReason::Dormancy:
|
|
return TEXT("Dormancy");
|
|
case EChannelCloseReason::LevelUnloaded:
|
|
return TEXT("LevelUnloaded");
|
|
case EChannelCloseReason::Relevancy:
|
|
return TEXT("Relevancy");
|
|
case EChannelCloseReason::TearOff:
|
|
return TEXT("TearOff");
|
|
}
|
|
|
|
return TEXT("Unknown");
|
|
}
|
|
|
|
void INetSerializeCB::NetSerializeStruct(
|
|
class UScriptStruct* Struct,
|
|
class FBitArchive& Ar,
|
|
class UPackageMap* Map,
|
|
void* Data,
|
|
bool& bHasUnmapped)
|
|
{
|
|
FNetDeltaSerializeInfo Params;
|
|
Params.Struct = Struct;
|
|
Params.Map = Map;
|
|
Params.Data = Data;
|
|
|
|
if (Ar.IsSaving())
|
|
{
|
|
Params.Writer = static_cast<FBitWriter*>(&Ar);
|
|
}
|
|
else
|
|
{
|
|
Params.Reader = static_cast<FBitReader*>(&Ar);
|
|
}
|
|
|
|
NetSerializeStruct(Params);
|
|
bHasUnmapped = Params.bOutHasMoreUnmapped;
|
|
} |