file
class        class FTCPServer : public FRunnable

	FString LocalHostIP = "127.0.0.1";
	int32 PortNum = 13429; 
	int32 ConnectionTimeout;
	TArray<class FSocket*> Clients;

	void HandleIncomingSocket(FSocket* IncomingConnection);
	static TQueue<FString> ImportQueue;

private:	

file
namespace    QuicUtils
function     EQuicEndpointError ConvertQuicStatus

		case QUIC_STATUS_CONNECTION_TIMEOUT:

			EndpointError = EQuicEndpointError::ConnectionTimeout;
			break;

		case QUIC_STATUS_CONNECTION_IDLE:

			EndpointError = EQuicEndpointError::ConnectionIdle;
			break;

file
namespace    QuicUtils
function     FString GetEndpointErrorString

			break;

		case EQuicEndpointError::ConnectionTimeout:

			ErrorMessage = "Connection timed out while waiting for a response from peer";
			break;

		case EQuicEndpointError::ConnectionIdle:

	/** Connection timed out while waiting for a response from peer. */
	ConnectionTimeout,

	/** Connection timed out from inactivity. */
	ConnectionIdle,

	/** Internal error. */
	InternalError,

file
function     FRemoteSessionClient::FRemoteSessionClient

	ConnectionAttemptTimer = FLT_MAX;		// attempt a connection asap
	TimeConnectionAttemptStarted = 0;
    ConnectionTimeout = 5;

	IsConnecting = false;

	if (HostAddress.Contains(TEXT(":")) == false)
	{
		HostAddress += FString::Printf(TEXT(":%d"), (int32)IRemoteSessionModule::kDefaultPort);

file
function     void FRemoteSessionClient::CheckConnection

	if (IsConnected() == false)
	{
		if (Success == false || TimeSpentConnecting >= ConnectionTimeout)
		{
			IsConnecting = false;
			
			FString Msg;
			
			if (TimeSpentConnecting >= ConnectionTimeout)
			{
				Msg = FString::Printf(TEXT("Timing out connection attempt after %.02f seconds"), TimeSpentConnecting);
			}
			else
			{
				Msg = TEXT("Failed to check for connection. Aborting.");

file
class        class FRemoteSessionClient : public FRemoteSessionRole

	
	bool				IsConnecting;
    float               ConnectionTimeout;

	double				ConnectionAttemptTimer;
	double				TimeConnectionAttemptStarted;
	
	FDelegateHandle		ChannelCallbackHandle;

file
function     void FRemoteSessionRole::Tick

	const URemoteSessionSettings* ConnectionSettings = GetDefault<URemoteSessionSettings>();

	const float kTimeout = FPlatformMisc::IsDebuggerPresent() ? ConnectionSettings->ConnectionTimeoutWhenDebugging : ConnectionSettings->ConnectionTimeout;
	const float kPingTime = ConnectionSettings->PingTime;

	if (PendingState != ConnectionState::Unknown)
	{
		UE_LOG(LogRemoteSession, Log, TEXT("Processing change from %s to %s"), LexToString(CurrentState), LexToString(PendingState));
		// pass this in so code can know where we came from if needed

file
class        class URemoteSessionSettings : public UObject

	/* Time until a connection will timeout  */
	UPROPERTY(config)
	int32 ConnectionTimeout = 7;

	/* Time until a connection will timeout when a debugger is attached  */
	UPROPERTY(config)
	int32 ConnectionTimeoutWhenDebugging = 30;

	/* Time between pings  */

file
namespace    Electra
function     bool FHTTPResourceRequest::SetFromJSON

			if (JSONParams->TryGetNumberField(TEXT("ctoms"), TimeOutMS))
			{
				ConnectionTimeout(FTimeValue(FTimeValue::MillisecondsToHNS(TimeOutMS)));
			}

			// No-data timeout in milliseconds
			TimeOutMS = 0;
			if (JSONParams->TryGetNumberField(TEXT("ndtoms"), TimeOutMS))
			{

file
namespace    Electra
class        class FHTTPResourceRequest : public TSharedFromThis<FHTTPResourceRequest, ESPMode::ThreadSafe>
function     virtual FHTTPResourceRequest& ConnectionTimeout

	{ Request->Parameters.AcceptEncoding.Set(InAcceptEncoding); return *this; }
	
	virtual FHTTPResourceRequest& ConnectionTimeout(const FTimeValue& InTimeoutAfter)
	{ Request->Parameters.ConnectTimeout = InTimeoutAfter; return *this; }
	
	virtual FHTTPResourceRequest& NoDataTimeout(const FTimeValue& InTimeoutAfter)
	{ Request->Parameters.NoDataTimeout = InTimeoutAfter; return *this; }
	
	virtual FHTTPResourceRequest& AllowStaticQuery(IAdaptiveStreamingPlayerResourceRequest::EPlaybackResourceType InStaticQueryType)

file
namespace    Electra
function     void FPlaylistReaderDASH::SetupRequestTimeouts

		case FMPDLoadRequestDASH::ELoadType::MPD:
		{
			InRequest->Request->ConnectionTimeout(PlayerSessionServices->GetOptionValue(DASH::OptionKeyMPDLoadConnectTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 8)));
			InRequest->Request->NoDataTimeout(PlayerSessionServices->GetOptionValue(DASH::OptionKeyMPDLoadNoDataTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 5)));
			break;
		}
		case FMPDLoadRequestDASH::ELoadType::MPDUpdate:
		{
			InRequest->Request->ConnectionTimeout(PlayerSessionServices->GetOptionValue(DASH::OptionKeyMPDReloadConnectTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 2)));
			InRequest->Request->NoDataTimeout(PlayerSessionServices->GetOptionValue(DASH::OptionKeyMPDReloadNoDataTimeout).SafeGetTimeValue(FTimeValue().SetFromMilliseconds(1000 * 2)));
			break;
		}
		case FMPDLoadRequestDASH::ELoadType::Segment:
		{
			InRequest->Request->ConnectionTimeout(FTimeValue(FTimeValue::MillisecondsToHNS(1000 * 5)));
			InRequest->Request->NoDataTimeout(FTimeValue(FTimeValue::MillisecondsToHNS(1000 * 2)));
			InRequest->Request->AcceptEncoding(TEXT("identity"));
			InRequest->Request->StreamTypeAndQuality(InRequest->SegmentStreamType, InRequest->SegmentQualityIndex, InRequest->SegmentQualityIndexMax);
			InRequest->Request->GetRequest()->ResponseCache = PlayerSessionServices->GetHTTPResponseCache();
		}
		case FMPDLoadRequestDASH::ELoadType::XLink_Period:

file
function     bool UMinimalClient::ConnectMinimalClient

		UnitNetDriver->InitialConnectTimeout = FMath::Max(UnitNetDriver->InitialConnectTimeout, (float)Timeout);
		UnitNetDriver->ConnectionTimeout = FMath::Max(UnitNetDriver->ConnectionTimeout, (float)Timeout);

#if !UE_BUILD_SHIPPING
		if (!(MinClientFlags & EMinClientFlags::SendRPCs) || !!(MinClientFlags & EMinClientFlags::DumpSendRPC))
		{
			UnitNetDriver->SendRPCDel.BindUObject(this, &UMinimalClient::NotifySendRPC);
		}

file
function     void ANUTActor::HookNetDriver

			TargetNetDriver->InitialConnectTimeout = static_cast<float>(CustomTimeout);
			TargetNetDriver->ConnectionTimeout = static_cast<float>(CustomTimeout);
		}
	}
}

bool ANUTActor::Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar)
{

file
function     bool UOculusNetDriver::InitBase

	}

	if (ConnectionTimeout == 0.0)
	{
		UE_LOG(LogNet, Warning, TEXT("ConnectionTimeout was set to %f"), ConnectionTimeout);
		ConnectionTimeout = 120.0;
	}

	if (KeepAliveTime == 0.0)
	{
		UE_LOG(LogNet, Warning, TEXT("KeepAliveTime was set to %f"), KeepAliveTime);
		KeepAliveTime = 0.2;

file
class        class FSocketSubsystemSteam : public ISocketSubsystem, public FTSTickerObjectBase, public FSelfRegisteringExec

     * Timeout (in seconds) period for any P2P session
	 * read from [OnlineSubsystemSteam.P2PConnectionTimeout]
     * (should be at least as long as NetDriver::ConnectionTimeout) 
     */
	float P2PConnectionTimeout;
	/** Accumulated time before next dump of connection info */
	double P2PDumpCounter;
	/** Connection info output interval */
	double P2PDumpInterval;
	/**
	 * The timeout (in seconds) between when a connection/channel is marked as destroyed
	 * and when it's cleaned up. This allows for catching lingering messages
	 * from other users.

file
function     bool AOnlineBeaconClient::InitClient

						NetDriver->Notify = this;
						NetDriver->InitialConnectTimeout = BeaconConnectionInitialTimeout;
						NetDriver->ConnectionTimeout = BeaconConnectionTimeout;

						if (!bSentHandshake)
						{
							SendInitialJoin();
						}

file
function     bool AOnlineBeaconHost::InitHost

				NetDriver->Notify = this;
				NetDriver->InitialConnectTimeout = BeaconConnectionInitialTimeout;
				NetDriver->ConnectionTimeout = BeaconConnectionTimeout;
				return true;
			}
			else
			{
				// error initializing the network stack...
				UE_LOG(LogBeacon, Log, TEXT("%s: AOnlineBeaconHost::InitHost failed"), *GetName());

file
function     void AOnlineBeaconHost::HandleNetworkFailure

	{
		// Timeouts from clients are ignored
		if (FailureType != ENetworkFailure::ConnectionTimeout)
		{
			Super::HandleNetworkFailure(World, InNetDriver, FailureType, ErrorString);
		}
	}
}

file
function     uint32 FPrestonMDRMessageThread::Run

	while (Socket->GetConnectionState() != ESocketConnectionState::SCS_Connected)
	{
		if ((FPlatformTime::Seconds() - LastTimeDataReceived) > ConnectionTimeout)
		{
			ConnectionFailedDelegate.ExecuteIfBound();
			bIsFinished = true;
			return 0;
		}

file
class        class FPrestonMDRMessageThread : public FRunnable

	static constexpr float ConnectionWaitInterval = 0.02f; // 20ms
	static constexpr double ConnectionTimeout = 5.0; // 3sec
	static constexpr double DataReceivedTimeout = 2.0; // 2sec
};

file
class        class UNetDriver : public UObject, public FExec

	 */
	UPROPERTY(Config)
	float ConnectionTimeout;

	/**
	* A multiplier that is applied to the above values when we are running with unoptimized builds (debug)
	* or data (uncooked). This allows us to retain normal timeout behavior while debugging without resorting
	* to the nuclear 'notimeouts' option or bumping the values above. If ==0 multiplier = 1
	*/

	 * Used by the net connection to determine if a net owning actor should switch to using the shortened timeout value
	 * 
	 * @return true to switch from InitialConnectTimeout to ConnectionTimeout values on the net driver
	 */
	virtual bool UseShortConnectTimeout() const { return false; }

	/**
	 * SerializeNewActor has just been called on the actor before network replication (server side)
	 * @param OutBunch Bunch containing serialized contents of actor prior to replication
	 */
	virtual void OnSerializeNewActor(class FOutBunch& OutBunch) {};

	/** 

	/**
	 * When true, reduces connect timeout from InitialConnectionTimeOut to ConnectionTimeout.  
	 * Set once initial level load is complete (client may be unresponsive during level loading).
	 */
	uint32 bShortConnectTimeOut:1;

	/** Is this player currently in cinematic mode?  Prevents rotation/movement/firing/etc */
	uint32 bCinematicMode:1;
	
	/** When cinematic mode is true, signifies that this controller's pawn should be hidden */
	uint32 bHidePawnInCinematicMode:1;

file
function     float UNetConnection::GetTimeoutValue

	if ((GetConnectionState() != USOCK_Pending) && (bPendingDestroy || (OwningActor && OwningActor->UseShortConnectTimeout())))
	{
		const float ConnectionTimeout = Driver->ConnectionTimeout;

		// If the connection is pending destroy give it 2 seconds to try to finish sending any reliable packets
		Timeout = bPendingDestroy ? 2.f : ConnectionTimeout;
	}

	// Longtimeouts allows a multiplier to be added to get correct disconnection behavior
	// with with additional leniancy when required. Implicit in debug/editor builds
	static bool LongTimeouts = FParse::Param(FCommandLine::Get(), TEXT("longtimeouts"));

file
function     void UNetConnection::HandleConnectionTimeout

	if (!bPendingDestroy)
	{
		GEngine->BroadcastNetworkFailure(Driver->GetWorld(), Driver, ENetworkFailure::ConnectionTimeout, Error);
	}

	Close(ENetCloseResult::ConnectionTimeout);

#if USE_SERVER_PERF_COUNTERS
	PerfCountersIncrement(TEXT("TimedoutConnections"));
#endif

}

file
function     bool UNetDriver::InitBase

		if (ParsedValue != 0.0f)
		{
			ConnectionTimeout = ParsedValue;
		}
	}
	if (URL.HasOption(TEXT("NoTimeouts")))
	{
		bNoTimeouts = true;
	}

file
function     void UEngine::HandleNetworkFailure

			bShouldTravel = (FailureNetMode == NM_Client);
			break;
		case ENetworkFailure::ConnectionTimeout:
			// Hosts don't travel when clients disconnect
			bShouldTravel = (FailureNetMode == NM_Client);
			break;
		case ENetworkFailure::NetGuidMismatch:
		case ENetworkFailure::NetChecksumMismatch:
			// Hosts don't travel when clients have actor issues

	/** A connection to the net driver has timed out */
	ConnectionTimeout,

	/** The net driver received an NMT_Failure message */
	FailureReceived,

	/** The client needs to upgrade their game */
	OutdatedClient,

file
namespace    ENetworkFailure

		ConnectionLost,
		/** A connection to the net driver has timed out */
		ConnectionTimeout,
		/** The net driver received an NMT_Failure message */
		FailureReceived,
		/** The client needs to upgrade their game */
		OutdatedClient,
		/** The server needs to upgrade their game */
		OutdatedServer,

file
namespace    ENetworkFailure
function     inline const TCHAR* ToString

		case ConnectionLost:
			return TEXT("ConnectionLost");
		case ConnectionTimeout:
			return TEXT("ConnectionTimeout");
		case FailureReceived:
			return TEXT("FailureReceived");
		case OutdatedClient:
			return TEXT("OutdatedClient");
		case OutdatedServer:

file
function     FWinHttpSession::FWinHttpSession

	FHttpModule& HttpModule = FHttpModule::Get();
	const FTimespan ConnectionTimeout = FTimespan::FromSeconds(HttpModule.GetHttpConnectionTimeout() > 0 ? HttpModule.GetHttpConnectionTimeout() : 0);
	const FTimespan ResolveTimeout = ConnectionTimeout;
	const FTimespan ReceiveTimeout = FTimespan::FromSeconds(HttpModule.GetHttpActivityTimeout() > 0 ? HttpModule.GetHttpActivityTimeout() : 0);
	const FTimespan SendTimeout = ReceiveTimeout;

	if (!WinHttpSetTimeouts(SessionHandle.Get(), ResolveTimeout.GetTotalMilliseconds(), ConnectionTimeout.GetTotalMilliseconds(), SendTimeout.GetTotalMilliseconds(), ReceiveTimeout.GetTotalMilliseconds()))
	{
		// Get last error
		const DWORD ErrorCode = GetLastError();
		FWinHttpErrorHelper::LogWinHttpSetTimeoutsFailure(ErrorCode);
	}

file
function     void FHttpConnection::Tick

	QUICK_SCOPE_CYCLE_COUNTER(STAT_FHttpConnection_Tick);
	const float AwaitReadTimeout = bKeepAlive ?
		ConnectionKeepAliveTimeout : ConnectionTimeout;

	switch (State)
	{
	case EHttpConnectionState::AwaitingRead:
		if (ReadContext.GetElapsedIdleTime() > AwaitReadTimeout || ReadContext.GetSecondsWaitingForReadableSocket() > AwaitReadTimeout)
		{

file
function     void FHttpConnection::Tick

	case EHttpConnectionState::Reading:
		if (ReadContext.GetElapsedIdleTime() > ConnectionTimeout)
		{
			Destroy(EConnectionDestroyReason::ReadTimeout);
			return;
		}
		ContinueRead(DeltaTime);
		break;

file
function     void FHttpConnection::Tick

	case EHttpConnectionState::Writing:
		if (WriteContext.GetElapsedIdleTime() > ConnectionTimeout)
		{
			Destroy(EConnectionDestroyReason::WriteTimeout);
			return;
		}
		ContinueWrite(DeltaTime);
		break;

	/** The duration (seconds) at which connections are forcefully timed out */
	static constexpr float ConnectionTimeout = 5.0f;

	/** The duration (seconds) at which idle keep-alive connections are forcefully timed out */
	static constexpr float ConnectionKeepAliveTimeout = 15.0f;

	/** Connection configuration data */
	FHttpServerConnectionConfig Config;

file
function     EStropheErrorType FStropheError::ConvertStropheError

		return EStropheErrorType::Conflict;
	case XMPP_SE_CONN_TIMEOUT:
		return EStropheErrorType::ConnectionTimeout;
	case XMPP_SE_HOST_GONE:
		return EStropheErrorType::HostGone;
	case XMPP_SE_HOST_UNKNOWN:
		return EStropheErrorType::HostUnknown;
	case XMPP_SE_IMPROPER_ADDR:
		return EStropheErrorType::ImproperAddr;

	BadNSPrefix,
	Conflict,
	ConnectionTimeout,
	HostGone,
	HostUnknown,
	ImproperAddr,
	InternalServerError,
	InvalidFrom,
	InvalidId,