SocketSubsystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AddressInfoTypes.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/StringConv.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "HAL/CriticalSection.h"
#include "IPAddress.h"
#include "Logging/LogMacros.h"
#include "Net/Common/Sockets/SocketErrors.h"
#include "SocketTypes.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
class Error;
class FInternetAddr;
class FOutputDevice;
class FSocket;
struct FPacketTimestamp;
 
SOCKETS_API DECLARE_LOG_CATEGORY_EXTERN(LogSockets, Log, All);
 
// Need to guarantee the "default" socket subsystem on these platforms
// as other subsystems (ie Steam) might override the default
#ifndef PLATFORM_SOCKETSUBSYSTEM
    #if PLATFORM_WINDOWS
        #define PLATFORM_SOCKETSUBSYSTEM FName(TEXT("WINDOWS"))
    #elif PLATFORM_MAC
        #define PLATFORM_SOCKETSUBSYSTEM FName(TEXT("MAC"))
    #elif PLATFORM_IOS
        #define PLATFORM_SOCKETSUBSYSTEM FName(TEXT("IOS"))
    #elif PLATFORM_UNIX
        #define PLATFORM_SOCKETSUBSYSTEM FName(TEXT("UNIX"))
    #elif PLATFORM_ANDROID
        #define PLATFORM_SOCKETSUBSYSTEM FName(TEXT("ANDROID"))
    #else
        #define PLATFORM_SOCKETSUBSYSTEM FName(TEXT(""))
    #endif
#endif
 
class FSocketDeleter;
 
using FUniqueSocket = TUniquePtr<FSocket, FSocketDeleter>;
 
class ISocketSubsystem
{
public:
 
    static SOCKETS_API ISocketSubsystem* Get(const FName& SubsystemName=NAME_None);
 
    static SOCKETS_API void ShutdownAllSystems();
 
 
    SOCKETS_API ISocketSubsystem();
    SOCKETS_API virtual ~ISocketSubsystem();
 
    virtual bool Init(FString& Error) = 0;
 
    virtual void Shutdown() = 0;
 
    virtual FSocket* CreateSocket(const FName& SocketType, const FString& SocketDescription, bool bForceUDP = false)
    {
        const FName NoProtocolTypeName(NAME_None);
        return CreateSocket(SocketType, SocketDescription, NoProtocolTypeName);
    }
 
    UE_DEPRECATED(4.23, "Use the CreateSocket with the FName parameter for support for multiple protocol types.")
    virtual FSocket* CreateSocket(const FName& SocketType, const FString& SocketDescription, ESocketProtocolFamily ProtocolType)
    {
        return CreateSocket(SocketType, SocketDescription, GetProtocolNameFromFamily(ProtocolType));
    }
 
    virtual FSocket* CreateSocket(const FName& SocketType, const FString& SocketDescription, const FName& ProtocolName) = 0;
 
    SOCKETS_API FUniqueSocket CreateUniqueSocket(const FName& SocketType, const FString& SocketDescription, bool bForceUDP = false);
 
    SOCKETS_API FUniqueSocket CreateUniqueSocket(const FName& SocketType, const FString& SocketDescription, const FName& ProtocolName);
 
    SOCKETS_API virtual class FResolveInfoCached* CreateResolveInfoCached(TSharedPtr<FInternetAddr> Addr) const;
 
    virtual void DestroySocket(FSocket* Socket) = 0;
 
    UE_DEPRECATED(4.23, "Migrate to GetAddressInfo that takes an FName as the protocol specification.")
    virtual FAddressInfoResult GetAddressInfo(const TCHAR* HostName, const TCHAR* ServiceName = nullptr,
        EAddressInfoFlags QueryFlags = EAddressInfoFlags::Default,
        ESocketProtocolFamily ProtocolType = ESocketProtocolFamily::None,
        ESocketType SocketType = ESocketType::SOCKTYPE_Unknown)
    {
        return GetAddressInfo(HostName, ServiceName, QueryFlags, GetProtocolNameFromFamily(ProtocolType), SocketType);
    }
 
    virtual FAddressInfoResult GetAddressInfo(const TCHAR* HostName, const TCHAR* ServiceName = nullptr,
        EAddressInfoFlags QueryFlags = EAddressInfoFlags::Default,
        const FName ProtocolTypeName = NAME_None,
        ESocketType SocketType = ESocketType::SOCKTYPE_Unknown) = 0;
 
    SOCKETS_API virtual void GetAddressInfoAsync(FAsyncGetAddressInfoCallback Callback, const TCHAR* HostName,
        const TCHAR* ServiceName = nullptr, EAddressInfoFlags QueryFlags = EAddressInfoFlags::Default,
        const FName ProtocolTypeName = NAME_None,
        ESocketType SocketType = ESocketType::SOCKTYPE_Unknown);
 
    virtual TSharedPtr<FInternetAddr> GetAddressFromString(const FString& InAddress) = 0;
 
    UE_DEPRECATED(4.23, "Please use GetAddressInfo to query hostnames")
    virtual ESocketErrors GetHostByName(const ANSICHAR* HostName, FInternetAddr& OutAddr)
    {
        FAddressInfoResult GAIResult = GetAddressInfo(ANSI_TO_TCHAR(HostName), nullptr, EAddressInfoFlags::Default, NAME_None);
        if (GAIResult.Results.Num() > 0)
        {
            OutAddr.SetRawIp(GAIResult.Results[0].Address->GetRawIp());
            return SE_NO_ERROR;
        }
 
        return SE_HOST_NOT_FOUND;
    }
 
    SOCKETS_API virtual class FResolveInfo* GetHostByName(const ANSICHAR* HostName);
 
    virtual bool RequiresChatDataBeSeparate() = 0;
 
    virtual bool RequiresEncryptedPackets() = 0;
 
    virtual bool GetHostName(FString& HostName) = 0;
 
    UE_DEPRECATED(4.23, "To support different address sizes, use CreateInternetAddr with no arguments and call SetIp/SetRawIp and SetPort on the returned object")
    virtual TSharedRef<FInternetAddr> CreateInternetAddr(uint32 Address, uint32 Port = 0)
    {
        TSharedRef<FInternetAddr> ReturnAddr = CreateInternetAddr();
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        ReturnAddr->SetIp(Address);
        ReturnAddr->SetPort(Port);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        return ReturnAddr;
    }
 
    virtual TSharedRef<FInternetAddr> CreateInternetAddr() = 0;
 
    virtual TSharedRef<FInternetAddr> CreateInternetAddr(const FName ProtocolType)
    {
        // If not implemented, returns the base version
        return CreateInternetAddr();
    }
 
    SOCKETS_API virtual TUniquePtr<FRecvMulti> CreateRecvMulti(int32 MaxNumPackets, int32 MaxPacketSize,
                                                    ERecvMultiFlags Flags=ERecvMultiFlags::None);
 
    virtual bool HasNetworkDevice() = 0;
 
    virtual const TCHAR* GetSocketAPIName() const = 0;
 
    virtual ESocketErrors GetLastErrorCode() = 0;
 
    virtual ESocketErrors TranslateErrorCode(int32 Code) = 0;
 
 
    // The following functions are not expected to be overridden
 
    SOCKETS_API const TCHAR* GetSocketError(ESocketErrors Code = SE_GET_LAST_ERROR_CODE);
 
    SOCKETS_API virtual bool GetLocalAdapterAddresses(TArray<TSharedPtr<FInternetAddr>>& OutAddresses);
 
    SOCKETS_API virtual TSharedRef<FInternetAddr> GetLocalBindAddr(FOutputDevice& Out);
 
    SOCKETS_API virtual TArray<TSharedRef<FInternetAddr>> GetLocalBindAddresses();
 
    SOCKETS_API int32 BindNextPort(FSocket* Socket, FInternetAddr& Addr, int32 PortCount, int32 PortIncrement);
 
    SOCKETS_API virtual TSharedRef<FInternetAddr> GetLocalHostAddr(FOutputDevice& Out, bool& bCanBindAll);
 
    SOCKETS_API virtual bool GetMultihomeAddress(TSharedRef<FInternetAddr>& Addr);
 
    SOCKETS_API bool GetHostByNameFromCache(const ANSICHAR* HostName, TSharedPtr<class FInternetAddr>& Addr);
 
    SOCKETS_API void AddHostNameToCache(const ANSICHAR* HostName, TSharedPtr<class FInternetAddr> Addr);
 
    SOCKETS_API void RemoveHostNameFromCache(const ANSICHAR* HostName);
 
    SOCKETS_API virtual bool IsSocketRecvMultiSupported() const;
 
 
    virtual bool IsSocketWaitSupported() const = 0;
 
 
    SOCKETS_API virtual double TranslatePacketTimestamp(const FPacketTimestamp& Timestamp,
                                            ETimestampTranslation Translation=ETimestampTranslation::LocalTimestamp);
 
    SOCKETS_API virtual bool IsRecvFromWithPktInfoSupported() const;
 
protected:
 
    SOCKETS_API virtual ESocketProtocolFamily GetProtocolFamilyFromName(const FName& InProtocolName) const;
    SOCKETS_API virtual FName GetProtocolNameFromFamily(ESocketProtocolFamily InProtocolFamily) const;
 
private:
 
    FCriticalSection HostNameCacheSync;
 
    TMap<FString, TSharedPtr<FInternetAddr> > HostNameCache;
};
 
class FSocketDeleter
{
public:
    FSocketDeleter()
        : Subsystem(nullptr)
    {
    }
 
    FSocketDeleter(ISocketSubsystem* InSubsystem)
        : Subsystem(InSubsystem)
    {
    }
 
    void operator()(FSocket* Socket) const
    {
        if (Subsystem && Socket)
        {
            Subsystem->DestroySocket(Socket);
        }
    }
 
private:
    ISocketSubsystem* Subsystem;
};
 
typedef TSharedPtr<ISocketSubsystem> IOnlineSocketPtr;