NetworkMessage.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "Misc/ByteSwap.h"
#include "Misc/Crc.h"
#include "Misc/DateTime.h"
#include "Misc/EnumClassFlags.h"
#include "Serialization/Archive.h"
#include "Serialization/ArrayReader.h"
#include "Serialization/BufferArchive.h"
 
class FArrayReader;
class FString;
 
enum
{ 
    DEFAULT_TCP_FILE_SERVING_PORT=41899, // default port to use when making file server tcp connections (used if no protocol is specified)
    DEFAULT_HTTP_FILE_SERVING_PORT=41898 // port that the network file server uses
};
 
// transitional define. Set to zero to avoid using multichannel TCP for the file server and client.
#define USE_MCSOCKET_FOR_NFS (0)
 
// Message commands, these correspond to the operations of the low level file system
namespace NFS_Messages
{
    enum Type
    {
        SyncFile,
        DeleteFile,
        MoveFile,
        SetReadOnly,
        OpenRead,
        OpenWrite,
        OpenAppend,
        CreateDirectory,
        DeleteDirectory,
        IterateDirectory,
        IterateDirectoryRecursively,
        DeleteDirectoryRecursively,     
        CopyFile,
        GetFileInfo,
        Read,
        ReadAt,
        Write,
        Close,
        Seek,
        SetTimeStamp,
        ToAbsolutePathForRead,
        ToAbsolutePathForWrite,
        ReportLocalFiles,
        GetFileList,
        Heartbeat,
        RecompileShaders,
    };
}
 
// Reserved channels for the network file system over multichannel tcp
namespace NFS_Channels
{
    enum Type
    {
        Main = 100,
        UnsolicitedFiles = 101,
        Heatbeat = 102,
    };
}
 
 
 
enum class EConnectionFlags : uint8
{
    None = 0x00000000,
    Streaming = 0x00000001,
    PreCookedIterative = 0x00000002, //DEPRECATED
};
ENUM_CLASS_FLAGS(EConnectionFlags);
 
 
 
class FSimpleAbstractSocket
{
public:
    virtual bool Receive(uint8 *Results, int32 Size) const = 0;
    virtual bool Send(const uint8 *Buffer, int32 Size) const = 0;
    virtual uint32 GetMagic() const = 0;
    virtual ~FSimpleAbstractSocket() { }
};
 
class FSimpleAbstractSocket_FSocket : public FSimpleAbstractSocket
{
    class FSocket* Socket;
public:
    FSimpleAbstractSocket_FSocket(class FSocket* InSocket)
        : Socket(InSocket)
    {
    }
    SOCKETS_API virtual bool Receive(uint8 *Results, int32 Size) const;
    SOCKETS_API virtual bool Send(const uint8 *Buffer, int32 Size) const;
    virtual uint32 GetMagic() const
    {
        return 0x9E2B83C1;
    }
};
 
class FSimpleAbstractSocket_FMultichannelTCPSocket : public FSimpleAbstractSocket
{
    class FMultichannelTcpSocket* Socket;
    uint32 SendChannel;
    uint32 ReceiveChannel;
public:
    FSimpleAbstractSocket_FMultichannelTCPSocket(class FMultichannelTcpSocket* InSocket, uint32 InSendChannel, uint32 InReceiveChannel = 0)
        : Socket(InSocket)
        , SendChannel(InSendChannel)
        , ReceiveChannel(InReceiveChannel ? InReceiveChannel : InSendChannel)
    {
        check(SendChannel);
        check(ReceiveChannel);
    }
    SOCKETS_API virtual bool Receive(uint8 *Results, int32 Size) const;
    SOCKETS_API virtual bool Send(const uint8 *Buffer, int32 Size) const;
    virtual uint32 GetMagic() const
    {
        return 0x9E2B83C2;
    }
};
 
struct FNFSMessageHeader
{
    uint32 Magic;
    uint32 PayloadSize;
    uint32 PayloadCrc;
 
    FNFSMessageHeader(const FSimpleAbstractSocket& InSocket)
        : Magic(InSocket.GetMagic())
        , PayloadSize(0)
        , PayloadCrc(0)
    {
    }
 
    FNFSMessageHeader(const FSimpleAbstractSocket& InSocket, const TArray<uint8>& Payload)
        : Magic(InSocket.GetMagic())
    {
        // make a header for the given payload
        PayloadSize = Payload.Num();
        check(PayloadSize);
        PayloadCrc = FCrc::MemCrc_DEPRECATED(Payload.GetData(), Payload.Num());
    }
 
    friend FArchive& operator<<(FArchive& Ar, FNFSMessageHeader& Header)
    {
        uint32 DesiredMagic = Header.Magic;
        Ar << Header.Magic;
        if (Ar.IsLoading())
        {
            check(DesiredMagic);
            if (Header.Magic != DesiredMagic)
            {
                uint32 DesiredMagicSwapped = BYTESWAP_ORDER32(DesiredMagic);
                check(DesiredMagic != DesiredMagicSwapped);
                if (Header.Magic == DesiredMagicSwapped)
                {
                    Ar.SetByteSwapping(!Ar.ForceByteSwapping());
                    Header.Magic = DesiredMagic;
                }
            }
        }
        if (Header.Magic == DesiredMagic)
        {
            Ar << Header.PayloadSize;
            Ar << Header.PayloadCrc;
        }
        return Ar;
    }
 
 
    static SOCKETS_API bool WrapAndSendPayload(const TArray<uint8>& Payload, const FSimpleAbstractSocket& Socket);
 
    static SOCKETS_API bool ReceivePayload(FArrayReader& OutPayload, const FSimpleAbstractSocket& Socket);
 
    static SOCKETS_API bool SendPayloadAndReceiveResponse(const TArray<uint8>& Payload, class FArrayReader& Response, const FSimpleAbstractSocket& Socket);
 
};
 
 
struct FFileInfo
{
    bool FileExists;
    bool ReadOnly;
    FDateTime TimeStamp;
    FDateTime AccessTimeStamp;
    int64 Size;
 
    FFileInfo()
        : FileExists(false)
        , ReadOnly(false)
        , TimeStamp(FDateTime::MinValue())
        , AccessTimeStamp(FDateTime::MinValue())
        , Size(-1)
    {
    }
};
 
class FNetworkFileArchive : public FBufferArchive
{
public:
    FNetworkFileArchive(uint32 Command)
    {
        // make sure the command is at the start
        *this << Command;
    }
 
    // helper to serialize TCHAR* (there are a lot)
    inline friend FNetworkFileArchive& operator<<(FNetworkFileArchive& Ar, const TCHAR*& Str)
    {
        FString Temp(Str);
        Ar << Temp;
        return Ar;
    }
};