UdpSocketBuilder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/OutputDeviceRedirector.h"
#include "Sockets.h"
#include "SocketSubsystem.h"
#include "Interfaces/IPv4/IPv4Address.h"
#include "Interfaces/IPv4/IPv4Endpoint.h"
 
class Error;
 
class FUdpSocketBuilder
{
public:
 
    FUdpSocketBuilder(const FString& InDescription)
        : AllowBroadcast(false)
        , Blocking(false)
        , Bound(false)
        , BoundEndpoint(FIPv4Address::Any, 0)
        , Description(InDescription)
        , MulticastInterface(FIPv4Address::Any)
        , MulticastLoopback(false)
        , MulticastTtl(1)
        , ReceiveBufferSize(0)
        , Reusable(false)
        , SendBufferSize(0)
    { }
 
public:
 
    FUdpSocketBuilder& AsBlocking()
    {
        Blocking = true;
 
        return *this;
    }
 
    FUdpSocketBuilder& AsNonBlocking()
    {
        Blocking = false;
 
        return *this;
    }
 
    FUdpSocketBuilder& AsReusable()
    {
        Reusable = true;
 
        return *this;
    }
 
    FUdpSocketBuilder& BoundToAddress(const FIPv4Address& Address)
    {
        BoundEndpoint = FIPv4Endpoint(Address, BoundEndpoint.Port);
        Bound = true;
 
        return *this;
    }
 
    FUdpSocketBuilder& BoundToEndpoint(const FIPv4Endpoint& Endpoint)
    {
        BoundEndpoint = Endpoint;
        Bound = true;
 
        return *this;
    }
 
    FUdpSocketBuilder& BoundToPort(uint16 Port)
    {
        BoundEndpoint = FIPv4Endpoint(BoundEndpoint.Address, Port);
        Bound = true;
 
        return *this;
    }
 
    FUdpSocketBuilder& JoinedToGroup(const FIPv4Address& GroupAddress)
    {
        return JoinedToGroup(GroupAddress, FIPv4Address::Any);
    }
 
    FUdpSocketBuilder& JoinedToGroup(const FIPv4Address& GroupAddress, const FIPv4Address& InterfaceAddress)
    {
        JoinedGroups.Add({ GroupAddress, InterfaceAddress });
 
        return *this;
    }
 
    FUdpSocketBuilder& WithBroadcast()
    {
        AllowBroadcast = true;
 
        return *this;
    }
 
    FUdpSocketBuilder& WithMulticastLoopback()
    {
        MulticastLoopback = true;
 
        return *this;
    }
 
    FUdpSocketBuilder& WithMulticastTtl(uint8 TimeToLive)
    {
        MulticastTtl = TimeToLive;
 
        return *this;
    }
 
    FUdpSocketBuilder& WithMulticastInterface(const FIPv4Address& InterfaceAddress)
    {
        MulticastInterface = InterfaceAddress;
 
        return *this;
    }
 
 
    FUdpSocketBuilder& WithReceiveBufferSize(int32 SizeInBytes)
    {
        ReceiveBufferSize = SizeInBytes;
 
        return *this;
    }
 
    FUdpSocketBuilder& WithSendBufferSize(int32 SizeInBytes)
    {
        SendBufferSize = SizeInBytes;
 
        return *this;
    }
 
public:
 
    operator FSocket*() const
    {
        return Build();
    }
 
    FSocket* Build() const
    {
        // load socket subsystem
        ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
 
        if (SocketSubsystem == nullptr)
        {
            GLog->Log(TEXT("FUdpSocketBuilder: Failed to load socket subsystem"));
            return nullptr;
        }
 
        // create socket
        TSharedRef<FInternetAddr> RemoteAddr = BoundEndpoint.ToInternetAddr();
        FSocket* Socket = SocketSubsystem->CreateSocket(NAME_DGram, *Description, RemoteAddr->GetProtocolType());
 
        if (Socket == nullptr)
        {
            GLog->Logf(TEXT("FUdpSocketBuilder: Failed to create socket %s"), *Description);
            return nullptr;
        }
 
        // configure socket
 
        if (!Socket->SetNonBlocking(!Blocking) ||
            !Socket->SetReuseAddr(Reusable) ||
            !Socket->SetBroadcast(AllowBroadcast) ||
            !Socket->SetRecvErr())
        {
            const ESocketErrors SocketError = SocketSubsystem->GetLastErrorCode();
 
            GLog->Logf(TEXT("FUdpSocketBuilder: Failed to configure %s (blocking: %i, reusable: %i, broadcast: %i). Error code %d."), 
                *Description, Blocking, Reusable, AllowBroadcast, int32(SocketError));
 
            SocketSubsystem->DestroySocket(Socket);
            return nullptr;
        }
 
        // bind socket
 
        if (Bound && !Socket->Bind(*RemoteAddr))
        {
            const ESocketErrors SocketError = SocketSubsystem->GetLastErrorCode();
 
            GLog->Logf(TEXT("FUdpSocketBuilder: Failed to bind %s to %s. Error code %d."),
                *Description, *BoundEndpoint.ToString(), int32(SocketError));
 
            SocketSubsystem->DestroySocket(Socket);
            return nullptr;
        }
 
        // configure multicast
 
        if (!Socket->SetMulticastLoopback(MulticastLoopback) || !Socket->SetMulticastTtl(MulticastTtl))
        {
            const ESocketErrors SocketError = SocketSubsystem->GetLastErrorCode();
 
            GLog->Logf(TEXT("FUdpSocketBuilder: Failed to configure multicast for %s (loopback: %i, ttl: %i). Error code %d."),
                *Description, MulticastLoopback, MulticastTtl, int32(SocketError));
 
            SocketSubsystem->DestroySocket(Socket);
            return nullptr;
        }
 
        // join multicast groups
 
        TSharedRef<FInternetAddr> MulticastAddress = SocketSubsystem->CreateInternetAddr(RemoteAddr->GetProtocolType());
        MulticastAddress->SetBroadcastAddress();
        TSharedPtr<FInternetAddr> AddressToUse = nullptr;
 
        for (const auto& Group : JoinedGroups)
        {
            // The Socket code no longer has the multicast address hack handled anymore, as such, we need to properly determine the address ourselves.
            if (Group.GroupAddress.IsSessionFrontendMulticast() && MulticastAddress->GetProtocolType() != FNetworkProtocolTypes::IPv4)
            {
                // This will use the address protocol that we figured out earlier.
                AddressToUse = MulticastAddress;
            }
            else
            {
                // Otherwise, we'll use the address we use all the time.
                AddressToUse = FIPv4Endpoint(Group.GroupAddress, 0).ToInternetAddr();
            }
 
            if (!Socket->JoinMulticastGroup(*AddressToUse, *FIPv4Endpoint(Group.InterfaceAddress, 0).ToInternetAddr()))
            {
                const ESocketErrors SocketError = SocketSubsystem->GetLastErrorCode();
 
                GLog->Logf(TEXT("FUdpSocketBuilder: Failed to subscribe %s to multicast group %s on interface %s. Error code %d."),
                    *Description, *Group.GroupAddress.ToString(), *Group.InterfaceAddress.ToString(), int32(SocketError));
 
                SocketSubsystem->DestroySocket(Socket);
                return nullptr;
            }
        }
 
        // set multicast outgoing interface
        if (MulticastInterface != FIPv4Address::Any)
        {
            if (!Socket->SetMulticastInterface(*FIPv4Endpoint(MulticastInterface, 0).ToInternetAddr()))
            {
                const ESocketErrors SocketError = SocketSubsystem->GetLastErrorCode();
 
                GLog->Logf(TEXT("FUdpSocketBuilder: Failed to set multicast outgoing interface for %s to %s. Error code %d."),
                    *Description, *MulticastInterface.ToString(), int32(SocketError));
 
                SocketSubsystem->DestroySocket(Socket);
                return nullptr;
            }
        }
 
        // set buffer sizes
        {
            int32 OutNewSize;
 
            if (ReceiveBufferSize > 0)
            {
                if (!Socket->SetReceiveBufferSize(ReceiveBufferSize, OutNewSize))
                {
                    const ESocketErrors SocketError = SocketSubsystem->GetLastErrorCode();
 
                    GLog->Logf(TEXT("FUdpSocketBuilder: Warning - could not set receive buffer size to %d for %s. Error code %d."),
                        ReceiveBufferSize, *Description, int32(SocketError));
                }
            }
 
            if (SendBufferSize > 0)
            {
                if (!Socket->SetSendBufferSize(SendBufferSize, OutNewSize))
                {
                    const ESocketErrors SocketError = SocketSubsystem->GetLastErrorCode();
 
                    GLog->Logf(TEXT("FUdpSocketBuilder: Warning - could not set send buffer size to %d for %s. Error code %d."),
                        SendBufferSize, *Description, int32(SocketError));
                }
            }
        }
 
        return Socket;
    }
 
private:
 
    bool AllowBroadcast;
 
    bool Blocking;
 
    bool Bound;
 
    FIPv4Endpoint BoundEndpoint;
 
    FString Description;
 
    FIPv4Address MulticastInterface;
 
    struct FMulticastGroup
    {
        FIPv4Address GroupAddress;
        FIPv4Address InterfaceAddress;
    };
    TArray<FMulticastGroup> JoinedGroups;
 
    bool MulticastLoopback;
 
    uint8 MulticastTtl;
 
    int32 ReceiveBufferSize;
 
    bool Reusable;
 
    int32 SendBufferSize;
};