WindowsPlatformProcess.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "GenericPlatform/GenericPlatformProcess.h"
#include "Windows/WindowsSystemIncludes.h"
 
class FEvent;
class FRunnableThread;
 
DECLARE_DELEGATE_OneParam(FLaunchURLOverride, const TCHAR*)
 
 
struct FProcHandle : public TProcHandle<Windows::HANDLE, nullptr>
{
public:
    UE_FORCEINLINE_HINT constexpr FProcHandle()
        : TProcHandle()
    {}
 
    UE_FORCEINLINE_HINT explicit FProcHandle( HandleType Other )
        : TProcHandle( Other )
    {}
};
 
 
struct FWindowsPlatformProcess
    : public FGenericPlatformProcess
{
    struct FWindowsSemaphore : public FSemaphore
    {
        virtual void    Lock();
        virtual bool    TryLock(uint64 NanosecondsToWait);
        virtual void    Unlock();
 
        Windows::HANDLE GetSemaphore() { return Semaphore; }
 
        FWindowsSemaphore(const FString& InName, Windows::HANDLE InSemaphore);
 
        FWindowsSemaphore(const TCHAR* InName, Windows::HANDLE InSemaphore);
 
        virtual ~FWindowsSemaphore();
 
    protected:
 
        Windows::HANDLE Semaphore;
    };
 
    struct FProcEnumInfo;
 
    class FProcEnumerator
    {
    public:
        // Constructor
        CORE_API FProcEnumerator();
        FProcEnumerator(const FProcEnumerator&) = delete;
        FProcEnumerator& operator=(const FProcEnumerator&) = delete;
 
        // Destructor
        CORE_API ~FProcEnumerator();
 
        // Gets current process enumerator info.
        CORE_API FProcEnumInfo GetCurrent() const;
 
        CORE_API bool MoveNext();
    private:
        // Process info structure for current process.
        Windows::PROCESSENTRY32* CurrentEntry;
 
        // Processes state snapshot handle.
        Windows::HANDLE SnapshotHandle;
    };
 
    struct FProcEnumInfo
    {
        friend FProcEnumInfo FProcEnumerator::GetCurrent() const;
    public:
        // Destructor
        CORE_API ~FProcEnumInfo();
 
        // Gets process PID.
        CORE_API uint32 GetPID() const;
 
        // Gets parent process PID.
        CORE_API uint32 GetParentPID() const;
 
        // Gets process name. I.e. exec name.
        CORE_API FString GetName() const;
 
        // Gets process full image path. I.e. full path of the exec file.
        CORE_API FString GetFullPath() const;
 
    private:
        // Private constructor.
        FProcEnumInfo(const Windows::PROCESSENTRY32& InInfo);
 
        // Process info structure.
        Windows::PROCESSENTRY32* Info;
    };
 
public:
 
    static CORE_API bool SetProcessAffinity(uint32 NumCoresForAffinity, bool bPhysicalCoresOnly);
    static CORE_API bool IsProcessAffinitySet();
 
    // FGenericPlatformProcess interface
 
    static CORE_API void* GetDllHandle( const TCHAR* Filename );
    static CORE_API void FreeDllHandle( void* DllHandle );
    static CORE_API void* GetDllExport( void* DllHandle, const TCHAR* ProcName );
    static CORE_API void AddDllDirectory(const TCHAR* Directory);
    static CORE_API void GetDllDirectories(TArray<FString>& OutDllDirectories);
    static CORE_API void PushDllDirectory(const TCHAR* Directory);
    static CORE_API void PopDllDirectory(const TCHAR* Directory);
    static CORE_API uint32 GetCurrentProcessId();
    static CORE_API uint32 GetCurrentCoreNumber();
    static CORE_API void SetThreadAffinityMask( uint64 AffinityMask );
    static CORE_API void SetThreadName( const TCHAR* ThreadName );
    static CORE_API void SetThreadPriority(EThreadPriority NewPriority);
    static CORE_API const TCHAR* BaseDir();
    static CORE_API const TCHAR* UserDir();
    static CORE_API const TCHAR* UserTempDir();
    static CORE_API const TCHAR* UserSettingsDir();
    static CORE_API const TCHAR* UserHomeDir();
    static CORE_API const TCHAR* UserSettingsDirMediumIntegrity();
    static CORE_API const TCHAR* ApplicationSettingsDir();
    static CORE_API FString GetApplicationSettingsDir(const ApplicationSettingsContext& Settings);
    static CORE_API const TCHAR* WindowsSystemDir();
    static CORE_API const TCHAR* ComputerName();
    static CORE_API const TCHAR* UserName(bool bOnlyAlphaNumeric = true);
    static CORE_API void SetCurrentWorkingDirectoryToBaseDir();
    static CORE_API FString GetCurrentWorkingDirectory();
    static CORE_API const FString ShaderWorkingDir();
    static CORE_API const TCHAR* ExecutablePath();
    static CORE_API const TCHAR* ExecutableName(bool bRemoveExtension = true);
    static CORE_API FString GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration);
    static CORE_API const TCHAR* GetArchitectureSuffix();
    static CORE_API const TCHAR* GetModuleExtension();
    static CORE_API const TCHAR* GetBinariesSubdirectory();
    static CORE_API const FString GetModulesDirectory();
    static CORE_API FProcHandle CreateProc(const TCHAR* URL, const TCHAR* Parms, bool bLaunchDetached, bool bLaunchHidden, bool bLaunchReallyHidden, uint32* OutProcessID, int32 PriorityModifier, const TCHAR* OptionalWorkingDirectory, void* PipeWriteChild, void* PipeReadChild = nullptr);
    static CORE_API FProcHandle CreateProc(const TCHAR* URL, const TCHAR* Parms, bool bLaunchDetached, bool bLaunchHidden, bool bLaunchReallyHidden, uint32* OutProcessID, int32 PriorityModifier, const TCHAR* OptionalWorkingDirectory, void* PipeWriteChild, void* PipeReadChild, void* PipeStdErrChild);
    static CORE_API TTuple<FProcHandle, UE::HAL::EProcessId> CreateProc(const UE::HAL::FProcessStartInfo& StartInfo);
    static CORE_API bool SetProcPriority(FProcHandle & InProcHandle, int32 PriorityModifier);
    static CORE_API FProcHandle OpenProcess(uint32 ProcessID);
    static CORE_API bool IsProcRunning( FProcHandle & ProcessHandle );
    static CORE_API void WaitForProc( FProcHandle & ProcessHandle );
    static CORE_API void CloseProc( FProcHandle & ProcessHandle );
    static CORE_API void TerminateProc( FProcHandle & ProcessHandle, bool KillTree = false );
    static CORE_API void TerminateProcTreeWithPredicate(
            FProcHandle& ProcessHandle,
            TFunctionRef<bool(uint32 ProcessId, const TCHAR* ApplicationName)> Predicate);
    static CORE_API bool GetProcReturnCode( FProcHandle & ProcHandle, int32* ReturnCode );
    static CORE_API bool GetApplicationMemoryUsage(uint32 ProcessId, SIZE_T* OutMemoryUsage);
    static CORE_API bool GetPerFrameProcessorUsage(uint32 ProcessId, float& ProcessUsageFraction, float& IdleUsageFraction);
    static CORE_API bool IsApplicationRunning( uint32 ProcessId );
    static CORE_API bool IsApplicationRunning( const TCHAR* ProcName );
    static CORE_API FString GetApplicationName( uint32 ProcessId ); 
    static CORE_API bool ExecProcess(const TCHAR* URL, const TCHAR* Params, int32* OutReturnCode, FString* OutStdOut, FString* OutStdErr, const TCHAR* OptionalWorkingDirectory = NULL, bool bShouldEndWithParentProcess  = false);
    static CORE_API bool ExecElevatedProcess(const TCHAR* URL, const TCHAR* Params, int32* OutReturnCode);
    static CORE_API FProcHandle CreateElevatedProcess(const TCHAR* URL, const TCHAR* Params);
    static CORE_API bool LaunchFileInDefaultExternalApplication( const TCHAR* FileName, const TCHAR* Parms = NULL, ELaunchVerb::Type Verb = ELaunchVerb::Open, bool bPromptToOpenOnFailure = true );
    static CORE_API void ExploreFolder( const TCHAR* FilePath );
    static CORE_API bool ResolveNetworkPath( FString InUNCPath, FString& OutPath ); 
    static CORE_API void Sleep(float Seconds);
    static CORE_API void SleepNoStats(float Seconds);
    [[noreturn]] static CORE_API void SleepInfinite();
    static CORE_API void YieldThread();
    UE_DEPRECATED(5.0, "Please use GetSynchEventFromPool to create a new event, and ReturnSynchEventToPool to release the event.")
    static CORE_API class FEvent* CreateSynchEvent(bool bIsManualReset = false);
    static CORE_API class FRunnableThread* CreateRunnableThread();
    static CORE_API void ClosePipe( void* ReadPipe, void* WritePipe );
    static CORE_API bool CreatePipe(void*& ReadPipe, void*& WritePipe, bool bWritePipeLocal = false);
    static CORE_API FString ReadPipe( void* ReadPipe );
    static CORE_API bool ReadPipeToArray(void* ReadPipe, TArray<uint8> & Output);
    static CORE_API bool WritePipe(void* WritePipe, const FString& Message, FString* OutWritten = nullptr);
    static CORE_API bool WritePipe(void* WritePipe, const uint8* Data, const int32 DataLength, int32* OutDataLength = nullptr);
    static CORE_API FSemaphore* NewInterprocessSynchObject(const FString& Name, bool bCreate, uint32 MaxLocks = 1);
    static CORE_API FSemaphore* NewInterprocessSynchObject(const TCHAR* Name, bool bCreate, uint32 MaxLocks = 1);
    static CORE_API bool DeleteInterprocessSynchObject(FSemaphore * Object);
    static CORE_API bool Daemonize();
    static CORE_API void SetupGameThread();
    static CORE_API void SetupAudioThread();
    static CORE_API void TeardownAudioThread();
    static CORE_API bool IsFirstInstance();
    static CORE_API TSharedPtr<IProcessSentinel> CreateProcessSentinelObject();
 
    static CORE_API void CeaseBeingFirstInstance();
 
    static CORE_API bool TryGetMemoryUsage(FProcHandle& ProcessHandle, FPlatformProcessMemoryStats& OutStats);
    static CORE_API bool ShouldExpectLowIntegrityLevel();
 
    /*
    * Allows us to add an alternative route for launching URLs
    */
    static CORE_API FLaunchURLOverride LaunchURLOverrideDelegate;
    static CORE_API bool CanLaunchURL(const TCHAR* URL);    
    static CORE_API void LaunchURL(const TCHAR* URL, const TCHAR* Parms, FString* Error);
 
protected:
 
    static CORE_API void ReadFromPipes(FString* OutStrings[], Windows::HANDLE InPipes[], int32 PipeCount);
 
private:
 
    static FProcHandle CreateProcInternal(const TCHAR* URL, const TCHAR* Parms, bool bLaunchDetached, bool bLaunchHidden, bool bLaunchReallyHidden, uint32* OutProcessID, int32 PriorityModifier, const TCHAR* OptionalWorkingDirectory, void* PipeWriteChild, void* PipeReadChild, void* PipeStdErrChild, bool bInheritHandles);
    
    static void LaunchURLInternal(const TCHAR* URL, const TCHAR* Parms, FString* Error);
 
    static TArray<FString> DllDirectoryStack;
 
    static TArray<FString> DllDirectories;
    
    static TMap<FName, TArray<FString>> SearchPathDllCache;
 
    static void* LoadLibraryWithSearchPaths(const FString& FileName, TConstArrayView<FString> SearchPaths);
 
    static bool ResolveImport(const FString& Name, TConstArrayView<FString> SearchPaths, FString& OutFileName);
 
    static void ResolveMissingImportsRecursive(const FString& FileName, TConstArrayView<FString> SearchPaths, TArray<FString>& ImportFileNames, TSet<FString>& VisitedImportNames);
};
 
typedef FWindowsPlatformProcess FPlatformProcess;