TcpListener.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/PlatformProcess.h"
#include "HAL/Runnable.h"
#include "IPAddress.h"
#include "SocketSubsystem.h"
#include "Interfaces/IPv4/IPv4Endpoint.h"
#include "HAL/RunnableThread.h"
#include "Common/TcpSocketBuilder.h"
 
DECLARE_DELEGATE_RetVal_TwoParams(bool, FOnTcpListenerConnectionAccepted, FSocket*, const FIPv4Endpoint&)
 
 
 
class FTcpListener
    : public FRunnable
{
public:
 
    FTcpListener(const FIPv4Endpoint& LocalEndpoint, const FTimespan& InSleepTime = FTimespan::FromSeconds(1), bool bInReusable = true)
        : bDeleteSocket(true)
        , Endpoint(LocalEndpoint)
        , SleepTime(InSleepTime)
        , Socket(nullptr)
        , bStopping(false)
        , bSocketReusable(bInReusable)
    {
        Thread = FRunnableThread::Create(this, TEXT("FTcpListener"), 8 * 1024, TPri_Normal);
    }
 
    FTcpListener(FSocket& InSocket, const FTimespan& InSleepTime = FTimespan::FromSeconds(1), bool bInReusable = true)
        : bDeleteSocket(false)
        , SleepTime(InSleepTime)
        , Socket(&InSocket)
        , bStopping(false)
        , bSocketReusable(bInReusable)
    {
        TSharedRef<FInternetAddr> LocalAddress = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
        Socket->GetAddress(*LocalAddress);
        Endpoint = FIPv4Endpoint(LocalAddress);
 
        Thread = FRunnableThread::Create(this, TEXT("FTcpListener"), 8 * 1024, TPri_Normal);
    }
 
    ~FTcpListener()
    {
        if (Thread != nullptr)
        {
            Thread->Kill(true);
            delete Thread;
        }
 
        if (bDeleteSocket && (Socket != nullptr))
        {
            ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(Socket);
            Socket = nullptr;
        }
    }
 
public:
 
    const FIPv4Endpoint& GetLocalEndpoint() const
    {
        return Endpoint;
    }
 
    FSocket* GetSocket() const
    {
        return Socket;
    }
 
    bool IsActive() const
    {
        return ((Socket != nullptr) && !bStopping);
    }
 
public:
 
    FOnTcpListenerConnectionAccepted& OnConnectionAccepted()
    {
        return ConnectionAcceptedDelegate;
    }
 
public:
 
    // FRunnable interface
 
    virtual bool Init() override
    {
        if (Socket == nullptr)
        {
            Socket = FTcpSocketBuilder(TEXT("FTcpListener server"))
                .AsReusable(bSocketReusable)
                .BoundToEndpoint(Endpoint)
                .Listening(8)
                .WithSendBufferSize(2 * 1024 * 1024);
        }
 
        return (Socket != nullptr);
    }
 
    virtual uint32 Run() override
    {
        TSharedRef<FInternetAddr> RemoteAddress = ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->CreateInternetAddr();
 
        const bool bHasZeroSleepTime = (SleepTime == FTimespan::Zero());
 
        while (!bStopping)
        {
            bool Pending = false;
 
            // handle incoming connections
            if (Socket->WaitForPendingConnection(Pending, SleepTime))
            {
                if (Pending)
                {
                    FSocket* ConnectionSocket = Socket->Accept(*RemoteAddress, TEXT("FTcpListener client"));
 
                    if (ConnectionSocket != nullptr)
                    {
                        bool Accepted = false;
 
                        if (ConnectionAcceptedDelegate.IsBound())
                        {
                            Accepted = ConnectionAcceptedDelegate.Execute(ConnectionSocket, FIPv4Endpoint(RemoteAddress));
                        }
 
                        if (!Accepted)
                        {
                            ConnectionSocket->Close();
                            ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM)->DestroySocket(ConnectionSocket);
                        }
                    }
                }
                else if(bHasZeroSleepTime)
                {
                    FPlatformProcess::Sleep(0.f);
                }
            }
            else
            {
                FPlatformProcess::Sleep(static_cast<float>(SleepTime.GetSeconds()));
            }
        }
 
        return 0;
    }
 
    virtual void Stop() override
    {
        bStopping = true;
    }
 
    virtual void Exit() override { }
 
private:
 
    bool bDeleteSocket;
 
    FIPv4Endpoint Endpoint;
 
    FTimespan SleepTime;
 
    FSocket* Socket;
 
    bool bStopping;
 
    bool bSocketReusable;
 
    FRunnableThread* Thread;
 
private:
 
    FOnTcpListenerConnectionAccepted ConnectionAcceptedDelegate;
};