PVROBeacon.cpp

Go to the documentation of this file.

// Copyright(c) 2023 PixoVR, LLC. All Rights Reserved.
 
#include "PVROBeacon.h"
#include "Misc/FeedbackContext.h"
#include "UObject/CoreNet.h"
#include "OnlineSubsystem.h"
#include "SocketSubsystem.h"
#include "Sockets.h"
#if ENGINE_MAJOR_VERSION >= 5
#include "Online/NboSerializer.h"
#else
#include "NboSerializer.h"
#endif
 
FPVROBeacon::FPVROBeacon(void) 
    : ListenSocket(NULL),
      SockAddr(ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr())
{
}
 
FPVROBeacon::~FPVROBeacon(void)
{
    ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
    SocketSubsystem->DestroySocket(ListenSocket);
}
 
bool FPVROBeacon::IsListenSocketValid() const
{
    return (ListenSocket ? true : false);
}
 
bool FPVROBeacon::Init(int32 Port)
{
    ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
    bool bSuccess = false;
    // Set our broadcast address
    BroadcastAddr = SocketSubsystem->CreateInternetAddr();
    BroadcastAddr->SetBroadcastAddress();
    BroadcastAddr->SetPort(Port);
    // Now the listen address
    ListenAddr = SocketSubsystem->GetLocalBindAddr(*GWarn);
    ListenAddr->SetPort(Port);
    // A temporary "received from" address
    SockAddr = SocketSubsystem->CreateInternetAddr();
    // Now create and set up our sockets (no VDP)
    ListenSocket = SocketSubsystem->CreateSocket(NAME_DGram, TEXT("LAN beacon"), true);
    if (ListenSocket != NULL)
    {
        ListenSocket->SetReuseAddr();
        ListenSocket->SetNonBlocking();
        ListenSocket->SetRecvErr();
        // Bind to our listen port
        if (ListenSocket->Bind(*ListenAddr))
        {
            // Set it to broadcast mode, so we can send on it
            // NOTE: You must set this to broadcast mode on Xbox 360 or the
            // secure layer will eat any packets sent
            bSuccess = ListenSocket->SetBroadcast();
        }
        else
        {
            UE_LOG_ONLINE(Error, TEXT("Failed to bind listen socket to addr (%s) for LAN beacon"),
                *ListenAddr->ToString(true));
        }
    }
    else
    {
        UE_LOG_ONLINE(Error, TEXT("Failed to create listen socket for LAN beacon"));
    }
    return bSuccess && ListenSocket;
}
 
bool FPVROBeacon::InitHost(int32 Port)
{
    ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
 
    ListenAddr = SocketSubsystem->GetLocalBindAddr(*GLog);
    ListenAddr->SetPort(Port);
    SockAddr = SocketSubsystem->CreateInternetAddr();
 
    bool bSuccess = false;
    ListenSocket = SocketSubsystem->CreateSocket(NAME_DGram, TEXT("Internet beacon"), true);
    if (ListenSocket != nullptr)
    {
        ListenSocket->SetReuseAddr();
        ListenSocket->SetNonBlocking();
        ListenSocket->SetRecvErr();
        if (ListenSocket->Bind(*ListenAddr))
        {
            // Set it to broadcast mode, so we can send on it
            // NOTE: You must set this to broadcast mode on Xbox 360 or the
            // secure layer will eat any packets sent
            bSuccess = ListenSocket->SetBroadcast();
        }
        else
        {
            if(SocketSubsystem->BindNextPort(ListenSocket,*ListenAddr,8000,1) != 0)
            {
                bSuccess = true; // ListenSocket->SetBroadcast();
 
                TriggerOnPortChangedDelegates(ListenAddr->GetPort());
            }
            else
            {
                UE_LOG(LogTemp, Error, TEXT("Failed to bind listen socket to addr (%s) for LAN beacon"), *ListenAddr->ToString(true));
            }
        }
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to create listen socket for LAN beacon"));
    }
 
    return bSuccess && ListenSocket;
}
 
bool FPVROBeacon::InitClient(int32 IP, int32 Port, int32 ListenPort)
{
    ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM);
 
    BroadcastAddr = SocketSubsystem->CreateInternetAddr();
    BroadcastAddr->SetIp(IP);
    BroadcastAddr->SetPort(Port);
 
    ListenAddr = SocketSubsystem->GetLocalBindAddr(*GLog);
    ListenAddr->SetPort(ListenPort);
    SockAddr = SocketSubsystem->CreateInternetAddr();
 
    bool bSuccess = false;
    ListenSocket = SocketSubsystem->CreateSocket(NAME_DGram, TEXT("Internet beacon"), true);
    if (ListenSocket != NULL)
    {
        ListenSocket->SetReuseAddr();
        ListenSocket->SetNonBlocking();
        ListenSocket->SetRecvErr();
 
        //bSuccess = true;
        if (ListenSocket->Bind(*ListenAddr))
        {
            // Set it to broadcast mode, so we can send on it
            // NOTE: You must set this to broadcast mode on Xbox 360 or the
            // secure layer will eat any packets sent
 
            bSuccess = ListenSocket->SetBroadcast();
            //bSuccess = true;
        }
        else
        {
            if (SocketSubsystem->BindNextPort(ListenSocket, *ListenAddr, 8000, 1) != 0)
            {
                bSuccess = true; // ListenSocket->SetBroadcast();
 
                //ToDo: Make Output in Blueprint node so user knows which ports to open (also in else)
                TriggerOnPortChangedDelegates(ListenAddr->GetPort());
            }
            else
            {
                UE_LOG(LogTemp, Error, TEXT("Failed to bind listen socket to addr (%s) for LAN beacon"), *ListenAddr->ToString(true));
            }
        }
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("Failed to create listen socket for LAN beacon"));
    }
 
    UE_LOG(LogTemp, Warning, TEXT("FPVROBeacon:InitClient: %d %d"), IP, Port);
 
    return bSuccess && ListenSocket;
}
 
int32 FPVROBeacon::ReceivePacket(uint8* PacketData, int32 BufferSize)
{
    check(PacketData && BufferSize);
    // Default to no data being read
    int32 BytesRead = 0;
    if (ListenSocket != NULL)
    {
        // Read from the socket
        ListenSocket->RecvFrom(PacketData, BufferSize, BytesRead, *SockAddr);
        if (BytesRead > 0)
        {
            UE_LOG_ONLINE(Verbose, TEXT("Received %d bytes from %s"), BytesRead, *SockAddr->ToString(true));
        }
    }
 
    return BytesRead;
}
 
bool FPVROBeacon::BroadcastPacket(uint8* Packet, int32 Length)
{
    int32 BytesSent = 0;
    UE_LOG_ONLINE(Verbose, TEXT("Sending %d bytes to %s"), Length, *BroadcastAddr->ToString(true));
    return ListenSocket->SendTo(Packet, Length, BytesSent, *BroadcastAddr) && (BytesSent == Length);
}
 
bool FPVROBeacon::BroadcastPacketFromSocket(uint8* Packet, int32 Length)
{
    int32 BytesSent = 16;
    return ListenSocket->SendTo(Packet, Length, BytesSent, *SockAddr) && (BytesSent == Length);
 
}
 
bool FPVROSession::Host(FOnValidQueryPacketDelegate& QueryDelegate, int32 Port)
{
    if (LanBeacon != NULL)
    {
        StopLANSession();
    }
 
    // Bind a socket for LAN beacon activity
    LanBeacon = new FPVROBeacon();
 
    // If its LAN Connection
    bool bSuccess = false;
    if (Port == -1)
    {
        if (LanBeacon->Init(LanAnnouncePort))
        {
 
            AddOnValidQueryPacketDelegate_Handle(QueryDelegate);
            // We successfully created everything so mark the socket as needing polling
            LanBeaconState = ELanBeaconState::Hosting;
            bSuccess = true;
            UE_LOG(LogTemp, Warning, TEXT("Listening for LAN beacon requests on %d"),   LanAnnouncePort);
        }
        else
        {
            UE_LOG(LogTemp, VeryVerbose, TEXT("Failed to init LAN beacon %s"), ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetSocketError());
        }
    }
    else
    {
        if (LanBeacon->InitHost(Port))
        {
 
            AddOnValidQueryPacketDelegate_Handle(QueryDelegate);
            // We successfully created everything so mark the socket as needing polling
            LanBeaconState = ELanBeaconState::Hosting;
            bSuccess = true;
        }
        else
        {
            UE_LOG(LogTemp, Warning, TEXT("Failed to init Online beacon %s"), ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetSocketError());
        }
    }
    
    return bSuccess;
}
 
bool FPVROSession::Search(FNboSerializeToBuffer& Packet, FOnValidResponsePacketDelegate& ResponseDelegate, FOnSearchingTimeoutDelegate& TimeoutDelegate)
{
    bool bSuccess = true;
    if (LanBeacon != NULL)
    {
        UE_LOG(LogTemp, Warning, TEXT("LanBeacon Search LanBeacon already exists stopping session"));
        StopLANSession();
    }
 
    // Bind a socket for LAN beacon activity
    LanBeacon = new FPVROBeacon();
    if (IsLANMatch)
    {
        // Bind a socket for LAN beacon activity
        if (LanBeacon->Init(LanAnnouncePort) == false)
        {
            UE_LOG(LogTemp, Warning, TEXT("Failed to create socket for lan announce port %s"), ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetSocketError());
            bSuccess = false;
        }
    }
    else
    {
        // Bind a socket for Online beacon activity
        if (LanBeacon->InitClient(HostSessionAddress, HostSessionPort, ClientSessionPort) == false)
        {
            UE_LOG(LogTemp, VeryVerbose, TEXT("Failed to create socket for lan announce port %s"), ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetSocketError());
            bSuccess = false;
        }
    }
 
    // If we have a socket and a nonce, broadcast a discovery packet
    if (LanBeacon && bSuccess)
    {
#if ENGINE_MAJOR_VERSION >= 5
        if (LanBeacon->BroadcastPacket(Packet.GetRawBuffer(0), Packet.GetByteCount()))
#else
        if (LanBeacon->BroadcastPacket(Packet, Packet.GetByteCount()))
#endif
        {
            UE_LOG_ONLINE(Verbose, TEXT("Sent query packet..."));
            // We need to poll for the return packets
            LanBeaconState = ELanBeaconState::Searching;
            // Set the timestamp for timing out a search
            LanQueryTimeLeft = LanQueryTimeout;
 
            AddOnValidResponsePacketDelegate_Handle(ResponseDelegate);
            AddOnSearchingTimeoutDelegate_Handle(TimeoutDelegate);
        }
        else
        {
            UE_LOG_ONLINE(Warning, TEXT("Failed to send discovery broadcast %s"), ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetSocketError());
            bSuccess = false;
        }
    }
    else
    {
        UE_LOG(LogTemp, VeryVerbose, TEXT("LanBeacon Search LanBeacon not valid or bSucces false"));
    }
 
    return bSuccess;
}
 
void FPVROSession::StopLANSession()
{
    // Don't poll anymore since we are shutting it down
    LanBeaconState = ELanBeaconState::NotUsingLanBeacon;
 
    // Unbind the LAN beacon object
    if (LanBeacon)
    {   
        delete LanBeacon;
        LanBeacon = NULL;
    }
 
    // Clear delegates
    OnValidQueryPacketDelegates.Clear();
    OnValidResponsePacketDelegates.Clear();
    OnSearchingTimeoutDelegates.Clear();
}
 
void FPVROSession::Tick(float DeltaTime)
{
    if (LanBeaconState == ELanBeaconState::NotUsingLanBeacon)
    {
        return;
    }
 
    uint8 PacketData[LAN_BEACON_MAX_PACKET_SIZE];
    bool bShouldRead = true;
    // Read each pending packet and pass it out for processing
    while (bShouldRead)
    {
        int32 NumRead = LanBeacon->ReceivePacket(PacketData, LAN_BEACON_MAX_PACKET_SIZE);
        if (NumRead > 0)
        {
            // Check our mode to determine the type of allowed packets
            if (LanBeaconState == ELanBeaconState::Hosting)
            {
                uint64 ClientNonce;
                // We can only accept Server Query packets
                if (IsValidLanQueryPacket(PacketData, NumRead, ClientNonce))
                {
                    // Strip off the header
                    TriggerOnValidQueryPacketDelegates(&PacketData[PIXOVR_BEACON_PACKET_HEADER_SIZE], NumRead - PIXOVR_BEACON_PACKET_HEADER_SIZE, ClientNonce);
                }
            }
            else if (LanBeaconState == ELanBeaconState::Searching)
            {
                // We can only accept Server Response packets
                if (IsValidLanResponsePacket(PacketData, NumRead))
                {
                    // Strip off the header
                    TriggerOnValidResponsePacketDelegates(&PacketData[PIXOVR_BEACON_PACKET_HEADER_SIZE], NumRead - PIXOVR_BEACON_PACKET_HEADER_SIZE);
                }
            }
        }
        else
        {
            if (LanBeaconState == ELanBeaconState::Searching)
            {
                // Decrement the amount of time remaining
                LanQueryTimeLeft -= DeltaTime;
                // Check for a timeout on the search packet
                if (LanQueryTimeLeft <= 0.f)
                {
                    TriggerOnSearchingTimeoutDelegates();
                }
            }
            bShouldRead = false;
        }
    }
}
 
void FPVROSession::CreateHostResponsePacket(FNboSerializeToBuffer& Packet, uint64 ClientNonce)
{
    // Add the supported version
    Packet << PIXOVR_BEACON_PACKET_VERSION
        // Platform information
        << (uint8)FPlatformProperties::IsLittleEndian()
        // Game id to prevent cross game lan packets
        << LanGameUniqueId
        // Add the packet type
        << PIXOVR_SERVER_RESPONSE1 << PIXOVR_SERVER_RESPONSE2
        // Append the client nonce as a uint64
        << ClientNonce;
}
 
void FPVROSession::CreateClientQueryPacket(FNboSerializeToBuffer& Packet, uint64 ClientNonce)
{
    // Build the discovery packet
    Packet << PIXOVR_BEACON_PACKET_VERSION
        // Platform information
        << (uint8)FPlatformProperties::IsLittleEndian()
        // Game id to prevent cross game lan packets
        << LanGameUniqueId
        // Identify the packet type
        << PIXOVR_SERVER_QUERY1 << PIXOVR_SERVER_QUERY2
        // Append the nonce as a uint64
        << ClientNonce;
}
 
bool FPVROSession::BroadcastPacket(uint8* Packet, int32 Length)
{
    bool bSuccess = false;
    if (LanBeacon)
    {
        bSuccess = LanBeacon->BroadcastPacket(Packet, Length);
        if (!bSuccess)
        {
            UE_LOG_ONLINE(Warning, TEXT("Failed to send broadcast packet %d"), (int32)ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetLastErrorCode());
        }
    }
 
    return bSuccess;
}
 
bool FPVROSession::BroadcastPacketFromSocket(uint8* Packet, int32 Length)
{
    bool bSuccess = false;
    if (LanBeacon)
    {
        bSuccess = LanBeacon->BroadcastPacketFromSocket(Packet, Length);
        if (!bSuccess)
        {
            UE_LOG(LogTemp, VeryVerbose, TEXT("Failed to send broadcast packet %d"), (int32)ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->GetLastErrorCode());
        }
    }
    
    return bSuccess;
}
 
bool FPVROSession::IsValidLanQueryPacket(const uint8* Packet, uint32 Length, uint64& ClientNonce)
{
    ClientNonce = 0;
    bool bIsValid = false;
    // Serialize out the data if the packet is the right size
    if (Length == PIXOVR_BEACON_PACKET_HEADER_SIZE)
    {
        FNboSerializeFromBuffer PacketReader(Packet,Length);
        uint8 Version = 0;
        PacketReader >> Version;
        // Do the versions match?
        if (Version == PIXOVR_BEACON_PACKET_VERSION)
        {
            uint8 Platform = 255;
            PacketReader >> Platform;
            // Can we communicate with this platform?
            if (Platform & LanPacketPlatformMask)
            {
                int32 GameId = -1;
                PacketReader >> GameId;
                // Is this our game?
                if (GameId == LanGameUniqueId)
                {
                    uint8 SQ1 = 0;
                    PacketReader >> SQ1;
                    uint8 SQ2 = 0;
                    PacketReader >> SQ2;
                    // Is this a server query?
                    bIsValid = (SQ1 == PIXOVR_SERVER_QUERY1 && SQ2 == PIXOVR_SERVER_QUERY2);
                    // Read the client nonce as the outvalue
                    PacketReader >> ClientNonce;
                }
            }
        }
    }
    return bIsValid;
}
 
bool FPVROSession::IsValidLanResponsePacket(const uint8* Packet, uint32 Length)
{
    bool bIsValid = false;
    // Serialize out the data if the packet is the right size
    if (Length > PIXOVR_BEACON_PACKET_HEADER_SIZE)
    {
        FNboSerializeFromBuffer PacketReader(Packet,Length);
        uint8 Version = 0;
        PacketReader >> Version;
        // Do the versions match?
        if (Version == PIXOVR_BEACON_PACKET_VERSION)
        {
            uint8 Platform = 255;
            PacketReader >> Platform;
            // Can we communicate with this platform?
            if (Platform & LanPacketPlatformMask)
            {
                int32 GameId = -1;
                PacketReader >> GameId;
                // Is this our game?
                if (GameId == LanGameUniqueId)
                {
                    uint8 SQ1 = 0;
                    PacketReader >> SQ1;
                    uint8 SQ2 = 0;
                    PacketReader >> SQ2;
                    // Is this a server response?
                    if (SQ1 == PIXOVR_SERVER_RESPONSE1 && SQ2 == PIXOVR_SERVER_RESPONSE2)
                    {
                        uint64 Nonce = 0;
                        PacketReader >> Nonce;
                        bIsValid = (Nonce == LanNonce);
                    }
                }
            }
        }
    }
    return bIsValid;
}