file
namespace    DatasmithDispatcher
function     void FDatasmithWorkerHandler::StartWorkerProcess

	if (FPaths::FileExists(ProcessorPath))
	{
		int32 ListenPort = NetworkInterface.GetListeningPort();
		if (ListenPort == 0)
		{
			ErrorState = EWorkerErrorState::ConnectionFailed_NotBound;
			return;
		}

		FString CommandToProcess;

file
namespace    DatasmithDispatcher
function     void FDatasmithWorkerHandler::StartWorkerProcess

		CommandToProcess += TEXT(" -ServerPID ") + FString::FromInt(FPlatformProcess::GetCurrentProcessId());
		CommandToProcess += TEXT(" -ServerPort ") + FString::FromInt(ListenPort);
		CommandToProcess += TEXT(" -CacheDir \"") + CachePath + TEXT('"');
		CommandToProcess += TEXT(" -CacheVersion ") + FString::FromInt(FCADToolsModule::GetCacheVersion());
		CommandToProcess += TEXT(" -EnginePluginsDir \"") + FPaths::EnginePluginsDir() + TEXT('"');
		UE_LOG(LogDatasmithDispatcher, Verbose, TEXT("CommandToProcess: %s"), *CommandToProcess);

		WorkerHandle = FPlatformProcess::CreateProc(*ProcessorPath, *CommandToProcess, true, false, false, &WorkerProcessId, 0, nullptr, nullptr);

file
namespace    UE
namespace    Interchange
function     void FInterchangeWorkerHandler::StartWorkerProcess

			if (FPaths::FileExists(ProcessorPath))
			{
				int32 ListenPort = NetworkInterface.GetListeningPort();
				if (ListenPort == 0)
				{
					ErrorState = EWorkerErrorState::ConnectionFailed_NotBound;
					return;
				}

				FString CommandToProcess;

file
namespace    UE
namespace    Interchange
function     void FInterchangeWorkerHandler::StartWorkerProcess

				CommandToProcess += TEXT(" -basedir=\"") + BaseDir + TEXT("\"");
				CommandToProcess += TEXT(" -ServerPID ") + FString::FromInt(FPlatformProcess::GetCurrentProcessId());
				CommandToProcess += TEXT(" -ServerPort ") + FString::FromInt(ListenPort);
				CommandToProcess += TEXT(" -InterchangeDispatcherVersion \"") + DispatcherCommandVersion::ToString() + TEXT('"');
				CommandToProcess += TEXT(" -ResultFolder \"") + ResultFolder + TEXT("\"");
				UE_LOG(LogInterchangeDispatcher, Verbose, TEXT("CommandToProcess: %s"), *CommandToProcess);
				WorkerHandle = FPlatformProcess::CreateProc(*ProcessorPath, *CommandToProcess, true, false, false, &WorkerProcessId, 0, nullptr, nullptr);
			}

file
function     bool AOnlineBeaconHost::InitHost

	if (FParse::Value(FCommandLine::Get(), TEXT("BeaconPort="), PortOverride) && PortOverride != 0)
	{
		ListenPort = PortOverride;
	}

	URL.Port = ListenPort;
	if(URL.Valid)
	{
		if (InitBase() && NetDriver)
		{
			FString Error;
			if (NetDriver->InitListen(this, URL, bReuseAddressAndPort, Error))
			{
				ListenPort = URL.Port;
				NetDriver->SetWorld(GetWorld());
				NetDriver->Notify = this;
				NetDriver->InitialConnectTimeout = BeaconConnectionInitialTimeout;
				NetDriver->ConnectionTimeout = BeaconConnectionTimeout;
				return true;
			}

file
class        class AOnlineBeaconHost : public AOnlineBeacon

	/** Configured listen port for this beacon host */
	UPROPERTY(Config)
	int32 ListenPort;

	/**
	 * Whether to configure the listening socket to allow reuse of the address and port. If this is true, be sure no other
	 * servers can run on the same port, otherwise this can lead to undefined behavior since packets will go to two servers.
	 */
	UPROPERTY(Config)

file
class        class AOnlineBeaconHost : public AOnlineBeacon
function     virtual int32 GetListenPort

	 * @return beacon listen port
	 */
	virtual int32 GetListenPort() { return ListenPort; }

	/**
	 * Register a beacon host and its client actor factory
	 *
	 * @param NewHostObject new 
	 */

file
function     void FSteamSocketsSubsystem::OnServerLoginComplete

		{
			// Push in the new valid information.
			int32 ListenPort = DelayedListener.Socket->BindAddress.GetPlatformPort();
			TSharedPtr<FInternetAddrSteamSockets> ListenerAddress = StaticCastSharedRef<FInternetAddrSteamSockets>(SteamIdentityAddr->Clone());
			ListenerAddress->SetPlatformPort(ListenPort);

			// Update the socket and netdriver addresses
			DelayedListener.Socket->BindAddress = *ListenerAddress;
			SteamNetDriver->LocalAddr = ListenerAddress;

			// Actually start the listen call

file
function     void FUbaHordeAgentManager::ThreadAgent

		}

		uint32 ListenPort = 7001;

		// Start the UBA Agent that will connect to us, requesting for work
		const std::string ListenPortArg = "-listen=" + std::to_string(ListenPort);

		const char* UbaAgentArgs[] =
		{
			ListenPortArg.c_str(),
			"-nopoll",				// -nopoll recommended when running on remote Horde agents to make sure they exit after completion. Otherwise, it keeps running.
			"-listenTimeout=5",		// Agent will wait 5 seconds for this thread to connect (Server_AddClient does the connect)

file
function     void FUbaHordeAgentManager::ThreadAgent

		const FString& IpAddress = Agent->GetMachineInfo().Ip;
		auto IpAddressStr = StringCast<uba::tchar>(*IpAddress);
		const bool bAddClientSuccess = Server_AddClient(UbaServer, IpAddressStr.Get(), ListenPort, nullptr);

		if (!bAddClientSuccess)
		{
			UE_LOG(LogUbaController, Display, TEXT("Server_AddClient(%s:%d) failed"), *IpAddress, ListenPort);
			return;
		}

		// Log remote execution
		FString UbaAgentCmdArgs = TEXT("UbaAgent.exe");
		for (const char* Arg : UbaAgentArgs)

file
function     void FUbaHordeAgentManager::ThreadAgent

			UbaAgentCmdArgs += ANSI_TO_TCHAR(Arg);
		}
		UE_LOG(LogUbaController, Log, TEXT("Remote execution on Horde machine [%s:%d]: %s"), *IpAddress, ListenPort, *UbaAgentCmdArgs);

		MachineCoreCount = MachineInfo.LogicalCores;
		EstimatedCoreCount += MachineCoreCount;
		ActiveCoreCount += MachineCoreCount;
	}

file
function     bool FEditorDomainSaveServer::TryInitialize

	TSharedPtr<FJsonObject> SettingsObject;
	if (!TryRefreshAuthority(nullptr /* bOutOwnsSettingFile */, &SettingsObject, &ListenPort))
	{
		// Log statement sent by TryRefreshAuthority
		return false;
	}

	ISocketSubsystem* SocketSubsystem = ISocketSubsystem::Get();

file
function     bool FEditorDomainSaveServer::TryInitialize

	}
	TSharedRef<FInternetAddr> ListenAddr = SocketSubsystem->GetLocalBindAddr(*GLog);
	ListenAddr->SetPort(ListenPort);
	ListenSocket = SocketSubsystem->CreateSocket(NAME_Stream, TEXT("FEditorDomainSaveServer tcp-listen"),
		ListenAddr->GetProtocolType());
	if (!ListenSocket)
	{
		UE_LOG(LogEditorDomainSave, Error, TEXT("CreateSocket failed, aborting creation of EditorDomainServer."));
		return false;

file
function     bool FEditorDomainSaveServer::TryInitialize

		return false;
	}
	ListenPort = ListenSocket->GetPortNo();
	ListenAddr->SetPort(ListenPort);
	UE_LOG(LogEditorDomainSave, Display, TEXT("EditorDomainSaveServer is listening for client connections on %s."),
		*ListenAddr->ToString(true));

	SettingsObject->SetNumberField(SettingNames::ListenPortFieldName, ListenPort);
	if (!TryWriteServerSettings(SettingsObject))
	{
		UE_LOG(LogEditorDomainSave, Warning,
			TEXT("Failed to write ServerSettings file %s, aborting creation of EditorDomainServer."),
			*GetServerSettingsFilename());
		return false;

file
function     bool FEditorDomainSaveServer::TryRefreshAuthority

	}

	bool bIsInitialAcquisition = ListenPort == 0;
	const TCHAR* ErrorActionDesc = bIsInitialAcquisition
		? TEXT("aborting creation")
		: TEXT("relinquishing ownership and shutting down");

	int32 ServerProcessId = 0;
	int32 LocalListenPort = 0;

file
function     bool FEditorDomainSaveServer::TryRefreshAuthority

	}

	if (!bIsInitialAcquisition && LocalListenPort != ListenPort)
	{
		UE_LOG(LogEditorDomainSave, Error,
			TEXT("Listen port has changed from %d to %d. Change in listen port is unsupported; %s."),
			ListenPort, LocalListenPort, ErrorActionDesc);
		return false;
	}
	if (OutListenPort)
	{
		*OutListenPort = LocalListenPort;
	}

file
function     bool FEditorDomainSaveClient::TryConnectProcess

	}

	// We are not successful until we the server has written the ListenPort for us to read; retry the read again on next tick
	return false;
}

bool FEditorDomainSaveClient::TryReadConnectionData(uint32& OutLocalServerProcessId, uint32& OutLocalServerListenPort,
	FDateTime& OutServerSettingsTimestamp)
{

file
class        class FEditorDomainSaveServer

	int32 CreatorProcessId = 0;
	/** The port to listen on. */
	int32 ListenPort = 0;
	/** True if the server was idle (no pending messages, no pending packages) in its previous tick. */
	bool bIdle = false;
	/** True if any client has so-far connected. Used to decide abdication. */
	bool bHasEverConnected = false;
	/** True if the server has abdicated and should shutdown. */
	bool bAbdicated = false;

file
function     FGameInstancePIEResult UGameInstance::StartPlayInEditorGameInstance

		{
			// Add port
			uint32 ListenPort = 0;
			uint16 ServerPort = 0;
			if (Params.EditorPlaySettings->GetServerPort(ServerPort))
			{
				ListenPort = ServerPort;
			}

			// Start a listen server
			ensureMsgf(EnableListenServer(true, ListenPort), TEXT("Starting Listen Server for Play in Editor failed!"));
		}

		SlowTask.EnterProgressFrame(10, NSLOCTEXT("UnrealEd", "PIEBeginPlay", "Starting PIE (Begin play)..."));
		PlayWorld->BeginPlay();

		SlowTask.EnterProgressFrame(10);

file
function     FHttpListener::FHttpListener

{ 
	check(InListenPort > 0);
	ListenPort = InListenPort;
	Router = MakeShared<FHttpRouter>();
}

FHttpListener::~FHttpListener() 
{ 
	check(!ListenSocket);

file
function     bool FHttpListener::StartListening

	// Bind to config-driven address
	TSharedRef<FInternetAddr> BindAddress = SocketSubsystem->CreateInternetAddr();
	Config = FHttpServerConfig::GetListenerConfig(ListenPort);
	if (0 == Config.BindAddress.Compare(TEXT("any"), ESearchCase::IgnoreCase))
	{
		BindAddress->SetAnyAddress();
	}
	else if (0 == Config.BindAddress.Compare(TEXT("localhost"), ESearchCase::IgnoreCase))
	{

file
function     bool FHttpListener::StartListening

			UE_LOG(LogHttpListener, Error,
				TEXT("HttpListener detected invalid bind address (%s:%u)"),
				*Config.BindAddress, ListenPort);
			return false;
		}
	}

	if (!BindAddress->IsPortValid(ListenPort))
	{
		UE_LOG(LogHttpListener, Error,
			TEXT("HttpListener detected invalid port %u"),
			ListenPort, *Config.BindAddress, ListenPort);
		return false;
	}
	BindAddress->SetPort(ListenPort);

	if (Config.bReuseAddressAndPort)
	{
		NewSocket->SetReuseAddr(true);
	}

file
function     void FHttpListener::StopListening

	{
		UE_LOG(LogHttpListener, Log,
			TEXT("HttListener stopping listening on Port %u"), ListenPort);

		ListenSocket.Reset();
	}
	bIsListening = false;

	const bool bRequestGracefulExit = true;

file
function     void FHttpListener::AcceptConnections

			IncomingConnection->SetNonBlocking(true);
			TSharedPtr<FHttpConnection> Connection = 
				MakeShared<FHttpConnection>(IncomingConnection, Router, ListenPort, NumConnectionsAccepted++);
			Connections.Add(Connection);
		}
	}
}

void FHttpListener::TickConnections(float DeltaTime)

file
class        class FHttpListener final

	/** The port on which the binding socket listens */
	uint32 ListenPort = 0;

	/** The binding socket which accepts incoming connections */
	FUniqueSocket ListenSocket;

	/** The mechanism that routes requests to respective handlers  */
	TSharedPtr<FHttpRouter> Router = nullptr;