RPCDoSDetectionAnalytics.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
 
// Include
#include "Net/Core/Analytics/NetAnalytics.h"
#include "AnalyticsEventAttribute.h"
 
 
// Forward Declarations
 
class UWorld;
 
 
// Typedefs
 
using FGetWorld = TUniqueFunction<UWorld*()>;
 
 
// Delegates
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FModifyRPCDoSAnalytics, UWorld* /*World*/, TArray<FAnalyticsEventAttribute>& /*InOutAttrs*/);
 
 
// Globals
 
ENGINE_API extern FModifyRPCDoSAnalytics GModifyRPCDoSAnalytics;
 
ENGINE_API extern FModifyRPCDoSAnalytics GModifyRPCDoSEscalationAnalytics;
 
 
// Structs
 
struct FMaxRPCDoSEscalation
{
    FString PlayerIP;
 
    FString PlayerUID;
 
    int32 MaxSeverityIndex = 0;
 
    FString MaxSeverityCategory;
 
    int32 MaxAnalyticsSeverityIndex = 0;
 
    FString MaxAnalyticsSeverityCategory;
 
 
public:
    bool operator == (const FMaxRPCDoSEscalation& A) const
    {
        return PlayerIP == A.PlayerIP && PlayerUID == A.PlayerUID && MaxSeverityIndex == A.MaxSeverityIndex &&
                MaxSeverityCategory == A.MaxSeverityCategory && MaxAnalyticsSeverityIndex == A.MaxAnalyticsSeverityIndex &&
                MaxAnalyticsSeverityCategory == A.MaxAnalyticsSeverityCategory;
    }
};
 
 
struct FRPCAnalytics
{
    FName RPCName;
 
    int32 MaxCountPerSec = 0;
 
 
    double MaxTimePerSec = 0.0;
 
    uint8 MaxTimeGameThreadCPU = 0;
 
 
    double MaxSinglePacketRPCTime = 0.0;
 
    int32 SinglePacketRPCCount = 0;
 
    uint8 SinglePacketGameThreadCPU = 0;
 
 
    int32 BlockedCount = 0;
 
 
    FString PlayerIP;
 
    FString PlayerUID;
 
 
public:
    bool operator == (const FRPCAnalytics& A) const
    {
        return RPCName == A.RPCName && MaxCountPerSec == A.MaxCountPerSec && MaxTimePerSec == A.MaxTimePerSec &&
                MaxTimeGameThreadCPU == A.MaxTimeGameThreadCPU && MaxSinglePacketRPCTime == A.MaxSinglePacketRPCTime &&
                SinglePacketRPCCount == A.SinglePacketRPCCount && SinglePacketGameThreadCPU == A.SinglePacketGameThreadCPU &&
                BlockedCount == A.BlockedCount && PlayerIP == A.PlayerIP && PlayerUID == A.PlayerUID;
    }
 
 
    bool WithinMinAnalyticsThreshold() const
    {
        return  MaxCountPerSec > 10 ||
                MaxTimePerSec > 0.0001 ||
                MaxSinglePacketRPCTime > 0.0001 ||
                SinglePacketRPCCount > 10 ||
                BlockedCount > 0;
    }
};
 
struct FRPCDoSAnalyticsVars
{
public:
 
    FRPCDoSAnalyticsVars();
 
    bool operator == (const FRPCDoSAnalyticsVars& A) const;
 
    void CommitAnalytics(FRPCDoSAnalyticsVars& AggregatedData);
 
 
public:
    FString PlayerIP;
 
    FString PlayerUID;
 
    int32 MaxSeverityIndex = 0;
 
    FString MaxSeverityCategory;
 
    int32 MaxAnalyticsSeverityIndex = 0;
 
    FString MaxAnalyticsSeverityCategory;
 
 
    TArray<TSharedPtr<FRPCAnalytics>> RPCTrackingAnalytics;
 
    const int32 MaxRPCAnalytics;
 
 
    TArray<FMaxRPCDoSEscalation> MaxPlayerSeverity;
};
 
 
struct FRPCDoSAnalyticsData : public TBasicNetAnalyticsData<FRPCDoSAnalyticsVars>
{
    FGetWorld WorldFunc;
 
    int8 WorstAnalyticsState = 0;
 
 
public:
    virtual void SendAnalytics() override;
 
    void FireEvent_ServerRPCDoSEscalation(int32 SeverityIndex, const FString& SeverityCategory, int32 WorstCountPerSec,
                                            double WorstTimePerSec, const FString& InPlayerIP, const FString& InPlayerUID,
                                            const TArray<FName>& InRPCGroup, double InRPCGroupTime=0.0);
};