Icmp.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "HAL/Platform.h"
#include "Templates/Function.h"
 
enum class EIcmpResponseStatus
{
    Success,
    Timeout,
    Unreachable,
    Unresolvable,
    InternalError,
    NotImplemented,
};
 
inline const TCHAR* LexToString(EIcmpResponseStatus ResponseStatus)
{
    switch (ResponseStatus)
    {
        case EIcmpResponseStatus::Success: return TEXT("Success");
        case EIcmpResponseStatus::Timeout: return TEXT("Timeout");
        case EIcmpResponseStatus::Unreachable: return TEXT("Unreachable");
        case EIcmpResponseStatus::Unresolvable: return TEXT("Unresolvable");
        case EIcmpResponseStatus::InternalError: return TEXT("InternalError");
        case EIcmpResponseStatus::NotImplemented: return TEXT("NotImplemented");
        default: return TEXT("Unknown");
    }
}
 
struct FIcmpEchoResult
{
    EIcmpResponseStatus Status;
    FString ResolvedAddress;
    FString ReplyFrom;
    float Time;
 
    FIcmpEchoResult()
        : Status(EIcmpResponseStatus::InternalError)
        , ResolvedAddress()
        , ReplyFrom()
        , Time(-1)
    {}
};
 
typedef TFunction<void(FIcmpEchoResult)> FIcmpEchoResultCallback;
DECLARE_DELEGATE_OneParam(FIcmpEchoResultDelegate, FIcmpEchoResult);
 
struct FIcmpTarget
{
    FString Address;
    int32 Port;
 
    FIcmpTarget()
        : Port(0)
    {}
 
    FIcmpTarget(const FString& InAddress, int32 InPort)
        : Address(InAddress)
        , Port(InPort)
    {}
}; // struct FIcmpTarget
 
struct FIcmpEchoManyResult
{
    FIcmpEchoResult EchoResult;
    FIcmpTarget Target;
 
    FIcmpEchoManyResult() = default;
    FIcmpEchoManyResult(const FIcmpEchoResult& InEchoResult, const FIcmpTarget& InTarget)
        : EchoResult(InEchoResult)
        , Target(InTarget)
    {}
 
}; // struct FIcmpEchoManyResult
 
enum class EIcmpEchoManyStatus : uint8
{
    Invalid,
    Success,
    Failure,
    Canceled
};
 
struct FIcmpEchoManyCompleteResult
{
    TArray<FIcmpEchoManyResult> AllResults;
    EIcmpEchoManyStatus Status;
 
    FIcmpEchoManyCompleteResult()
        : Status(EIcmpEchoManyStatus::Invalid)
    {}
 
}; // struct FIcmpEchoManyCompleteResult
 
typedef TFunction<void(FIcmpEchoManyCompleteResult)> FIcmpEchoManyCompleteCallback;
DECLARE_DELEGATE_OneParam(FIcmpEchoManyCompleteDelegate, FIcmpEchoManyCompleteResult);
 
 
// Simple ping interface that sends an ICMP packet to the given address and returns timing info for the reply if reachable
class FIcmp
{
    public:
 
    static ICMP_API void IcmpEcho(const FString& TargetAddress, float Timeout, FIcmpEchoResultCallback HandleResult);
 
    static void IcmpEcho(const FString& TargetAddress, float Timeout, FIcmpEchoResultDelegate ResultDelegate)
    {
        IcmpEcho(TargetAddress, Timeout, [ResultDelegate](FIcmpEchoResult Result)
        {
            ResultDelegate.ExecuteIfBound(Result);
        });
    }
};
 
// Simple ping interface that sends an ICMP packet over UDP to the given address and returns timing info for the reply if reachable
class FUDPPing
{
public:
 
    static ICMP_API void UDPEcho(const FString& TargetAddress, float Timeout, FIcmpEchoResultCallback HandleResult);
 
    static void UDPEcho(const FString& TargetAddress, float Timeout, FIcmpEchoResultDelegate ResultDelegate)
    {
        UDPEcho(TargetAddress, Timeout, [ResultDelegate](FIcmpEchoResult Result)
        {
            ResultDelegate.ExecuteIfBound(Result);
        });
    }
 
    static ICMP_API void UDPEchoMany(const TArray<FIcmpTarget>& Targets, float Timeout, FIcmpEchoManyCompleteCallback CompletionCallback);
 
    static ICMP_API void UDPEchoMany(const TArray<FIcmpTarget>& Targets, float Timeout, FIcmpEchoManyCompleteDelegate CompletionDelegate);
};
 
 
#define EnumCase(Name) case EIcmpResponseStatus::Name : return TEXT(#Name)
static const TCHAR* ToString(EIcmpResponseStatus Status)
{
    switch (Status)
    {
        EnumCase(Success);
        EnumCase(Timeout);
        EnumCase(Unreachable);
        EnumCase(Unresolvable);
        EnumCase(InternalError);
        EnumCase(NotImplemented);
        default:
            return TEXT("Unknown");
    }
}
 
#undef EnumCase