file
function     void FRPCDoSStateConfig::ValidateConfig

						(RPCRepeatLimitPerPeriod > 0 || RPCRepeatLimitMSPerPeriod > 0));

	if (AutoEscalateTime > 0 && AutoEscalateTime < CooloffTime)
	{
		UE_LOG(LogNet, Warning, TEXT("FRPCDoSStateConfig: AutoEscalateTime must be larger than CooloffTime."));
	}
}

int8 FRPCDoSStateConfig::GetHighestTimePeriod() const

file
function     void FRPCDoSStateConfig::ApplyState

	Target.RPCRepeatLimitMSPerPeriod		= RPCRepeatLimitMSPerPeriod;
	Target.RPCRepeatLimitTimePeriod			= RPCRepeatLimitTimePeriod;
	Target.CooloffTime						= CooloffTime;
	Target.AutoEscalateTime					= AutoEscalateTime;

	Target.ApplyImpliedValues();
}

file
function     void FRPCDoSDetection::InitConfig

						const int8 HighestTimePeriod = CurState.GetHighestTimePeriod();

						HighestHistoryRequirment = FMath::Max(HighestHistoryRequirment, (int32)(CurState.CooloffTime + HighestTimePeriod));
						MaxRPCTrackingPeriod = FMath::Max(MaxRPCTrackingPeriod, HighestTimePeriod);
					}
					else
					{
						UE_LOG(LogNet, Warning, TEXT("RPC DoS Detection failed to load ini section: %s"), *CurSection);
					}

file
function     void FRPCDoSDetection::UpdateSeverity_Private

				FRPCDoSStateConfig& PrevState = DetectionSeverity[NewStateIdx-1];
				FRPCDoSStateConfig& CurState = DetectionSeverity[NewStateIdx];
				int32 CurStateCooloffTime = CurState.CooloffTime;
				const TArray<int8>& CurStateTimePeriods = CurState.GetAllTimePeriods();
				FRPCDoSCounters CurPerPeriodHistory[16] = {};

				check(CounterPerSecHistory.Num() >= CurStateCooloffTime);

				// Count backwards through every second of CounterPerSecHistory, whose starting index wraps around like a circular buffer

file
function     void FRPCDoSDetection::PreTickDispatch

			double ActiveStateTime = TimeSeconds - LastMetEscalationConditions;

			if (CooloffTime > 0 && ActiveStateTime > CooloffTime)
			{
				TickScope.UpdateSeverity(*this, ERPCDoSSeverityUpdate::Deescalate, ERPCDoSEscalateReason::Deescalate);
			}
			else if (AutoEscalateTime > 0 && ActiveStateTime > AutoEscalateTime)
			{
				TickScope.UpdateSeverity(*this, ERPCDoSSeverityUpdate::AutoEscalate, ERPCDoSEscalateReason::AutoEscalate);

	/** The amount of time, in seconds, before the current DoS severity category cools off and de-escalates */
	UPROPERTY(config)
	int16 CooloffTime					= -1;

	/** The amount of time, in seconds, spent in the current DoS severity category before it automatically escalates to the next category */
	UPROPERTY(config)
	int16 AutoEscalateTime				= -1;

	double LastPerSecQuotaBegin										= 0.0;

	/** Stores enough per second quota history, to allow all DetectionSeverity states to recalculate if their CooloffTime is reached */
	TArray<FRPCDoSCounters> CounterPerSecHistory;

	/** The last written index of CounterPerSecHistory */
	int32 LastCounterPerSecHistoryIdx								= 0;

	/** Counter history which is precalculated/cached from CounterPerSecHistory, for tracking per-period time (up to a maximum of 16s) */

file
function     void FEscalationState::ValidateConfigInternal

	Super::ValidateConfigInternal();

	if (AutoEscalateTime > 0 && AutoEscalateTime < CooloffTime)
	{
		UE_LOG(LogNetCore, Warning, TEXT("FEscalationState: AutoEscalateTime must be larger than CooloffTime."));
	}
}

void FEscalationState::ValidateTimePeriod(int8& Value, const TCHAR* PropertyName, EValidateTime Requirement/*=EValidateTime::Optional*/)

file
namespace    UE
namespace    Net
function     EEscalateResult FEscalationManager::UpdateSeverity

					const TStructOnScope<FEscalationState>& PrevState = EscalationSeverity[NewStateIdx-1];
					const TStructOnScope<FEscalationState>& CurState = EscalationSeverity[NewStateIdx];
					int32 CurStateCooloffTime = CurState->CooloffTime;

					check(CountersPerSecHistory.Num() >= CurStateCooloffTime);

					for (FEscalationCounter& CurCounterAlloc : WorkingPerPeriodAlloc)
					{
						CurCounterAlloc.ResetCounters();

file
namespace    UE
namespace    Net
function     void FEscalationManager::TickRealtime

			{
				double ActiveStateTime = TimeSeconds - LastMetEscalationConditions;
				const double& CooloffTime = State->CooloffTime;
				const double& AutoEscalateTime = State->AutoEscalateTime;
				bool bUpdatedState = false;

				if (CooloffTime > 0 && ActiveStateTime > CooloffTime)
				{
					bUpdatedState = UpdateSeverity(ESeverityUpdate::Deescalate, EEscalateReason::Deescalate) != EEscalateResult::NoChange;
				}

				if (!bUpdatedState && AutoEscalateTime > 0 && ActiveStateTime > AutoEscalateTime)
				{

file
namespace    UE
namespace    Net
function     int32 FEscalationManager::GetHighestHistoryRequirement

			const int8 HighestTimePeriod = CurSeverityConfig->GetHighestTimePeriod();

			ReturnVal = FMath::Max(ReturnVal, (int32)(CurSeverityConfig->CooloffTime + HighestTimePeriod));
		}
	}

	return ReturnVal;
}

file
function     EInitStateDefaultsResult FNetFaultState::InitConfigDefaultsInternal

		DescalateQuotaFaultsPerPeriod = 6;
		EscalateQuotaTimePeriod = 8;
		CooloffTime = 10;
		AutoEscalateTime = 11;
	}
	else if (SeverityCategory == TEXT("PersistentFault"))
	{
		EscalateQuotaFaultsPerPeriod = 64;
		EscalateQuotaFaultPercentPerPeriod = 50;

file
function     EInitStateDefaultsResult FNetFaultState::InitConfigDefaultsInternal

		DescalateQuotaFaultPercentPerPeriod = 40;
		EscalateQuotaTimePeriod = 8;
		CooloffTime = 10;
		AutoEscalateTime = 20;
		bLogEscalate = true;
	}
	else if (SeverityCategory == TEXT("DisconnectCountdown"))
	{
		EscalateQuotaFaultPercentPerPeriod = 70;
		DescalateQuotaFaultPercentPerPeriod = 56;
		EscalateQuotaTimePeriod = 16;
		CooloffTime = 10;
		AutoEscalateTime = 60;
		bLogEscalate = true;
	}
	else if (SeverityCategory == TEXT("Disconnect"))
	{
		bCloseConnection = true;

file
function     void FDDoSDetection::InitConfig

				GConfig->GetInt(*CurSection, TEXT("PacketTimeLimitMSPerFrame"), CurState.PacketTimeLimitMSPerFrame, GEngineIni);
				GConfig->GetInt(*CurSection, TEXT("NetConnPacketTimeLimitMSPerFrame"), CurState.NetConnPacketTimeLimitMSPerFrame, GEngineIni);
				GConfig->GetInt(*CurSection, TEXT("CooloffTime"), CurState.CooloffTime, GEngineIni);

				if (GConfig->GetInt(*CurSection, TEXT("EscalateTimeQuotaMSPerFrame"), EscalateTime32, GEngineIni))
				{
					CurState.EscalateTimeQuotaMSPerFrame = IntCastChecked<int16>(EscalateTime32);
				}

				HighestCooloffTime = FMath::Max(HighestCooloffTime, CurState.CooloffTime);
			}
			else
			{
				UE_LOG(LogNetCore, Warning, TEXT("DDoS detection could not find ini section: %s"), *CurSection);
			}
		}

file
function     void FDDoSDetection::UpdateSeverity

			{
				FDDoSStateConfig& PrevState = DetectionSeverity[NewState-1];
				int32 CurStateCooloffTime = DetectionSeverity[NewState].CooloffTime;

				check(CounterPerSecHistory.Num() >= CurStateCooloffTime);

				for (int32 SecondsDelta=0; SecondsDelta<CurStateCooloffTime; SecondsDelta++)
				{
					int32 CurIdx = LastCounterPerSecHistoryIdx - SecondsDelta;

file
function     void FDDoSDetection::PreFrameReceive

		FrameAdjustment = static_cast<float>((HitchFrameCount > 0 && HitchFrameCount > HitchFrameTolerance) ? 1.0 : (double)DeltaTime / ExpectedFrameTime);

		if (ActiveState > 0 && CooloffTime > 0 && (float)(StartFrameRecvTimestamp - LastMetEscalationConditions) > (float)CooloffTime)
		{
			UpdateSeverity(false);
		}

		DetectionSeverity[ActiveState].ApplyAdjustedState(*this, FMath::Max(0.25f, FrameAdjustment));

	/** The amount of time, in seconds, before the current severity state cools off and de-escalates */
	UPROPERTY(config)
	int16 CooloffTime				= -1;

	/** The amount of time, in seconds, spent in the current severity state before it automatically escalates to the next state */
	UPROPERTY(config)
	int16 AutoEscalateTime			= -1;

file
namespace    UE
namespace    Net
class        class FEscalationManager

	double LastPerSecQuotaBegin																	= 0.0;

	/** Stores enough per second quota history, to allow all EscalationSeverity states to recalculate if their CooloffTime is reached */
	TArray<TArrayView<FEscalationCounter>> CountersPerSecHistory;

	/** Allocation for the above array, to reduce indirection */
	TArray<FEscalationCounter> CountersPerSecHistoryAlloc;

	/** The last written index of CountersPerSecHistory */

	/** The amount of time, in seconds, before the current DDoS severity category cools off and de-escalates */
	int32 CooloffTime;


	FDDoSState()
		: bSendEscalateAnalytics(true)
		, EscalateQuotaPacketsPerSec(-1)
		, EscalateQuotaDisconnPacketsPerSec(-1)

file
function     FDDoSState

		, PacketTimeLimitMSPerFrame(-1)
		, NetConnPacketTimeLimitMSPerFrame(-1)
		, CooloffTime(-1)
	{
	}

	/**
	 * Whether or not the specified counters and time passed has hit any of the quota's
	 *

file
function     void ApplyState

		Target.PacketTimeLimitMSPerFrame			= PacketTimeLimitMSPerFrame;
		Target.NetConnPacketTimeLimitMSPerFrame		= NetConnPacketTimeLimitMSPerFrame;
		Target.CooloffTime							= CooloffTime;
	}

	/**
	 * Applies only the per-frame adjusted state (based on expected vs actual framerate), to active DDoS protection.
	 * ApplyState should be called, first.
	 */

file
class        class FDDoSDetection : protected FDDoSPacketCounters, protected FDDoSState

	double LastPerSecQuotaBegin;

	/** Stores enough per second quota history, to allow all DetectionSeverity states to recalculate if their CooloffTime is reached */
	TArray<FDDoSPacketCounters> CounterPerSecHistory;

	/** The last written index of CounterPerSecHistory */
	int32 LastCounterPerSecHistoryIdx;