WindowsPlatformProcess.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "GenericPlatform/GenericPlatformProcess.h"
#include "Windows/WindowsSystemIncludes.h"
 
class FEvent;
class FRunnableThread;
 
/** Windows implementation of the process handle. */
struct FProcHandle : public TProcHandle<Windows::HANDLE, nullptr>
{
public:
    /** Default constructor. */
    FORCEINLINE FProcHandle()
        : TProcHandle()
    {}
 
    /** Initialization constructor. */
    FORCEINLINE explicit FProcHandle( HandleType Other )
        : TProcHandle( Other )
    {}
};
 
 
/**
* Windows implementation of the Process OS functions.
**/
struct FWindowsPlatformProcess
    : public FGenericPlatformProcess
{
    /**
     * Windows representation of a interprocess semaphore
     */
    struct FWindowsSemaphore : public FSemaphore
    {
        virtual void    Lock();
        virtual bool    TryLock(uint64 NanosecondsToWait);
        virtual void    Unlock();
 
        /** Returns the OS handle */
        Windows::HANDLE GetSemaphore() { return Semaphore; }
 
        /** Constructor */
        FWindowsSemaphore(const FString& InName, Windows::HANDLE InSemaphore);
 
        /** Allocation free constructor */
        FWindowsSemaphore(const TCHAR* InName, Windows::HANDLE InSemaphore);
 
        /** Destructor */
        virtual ~FWindowsSemaphore();
 
    protected:
 
        /** OS handle */
        Windows::HANDLE Semaphore;
    };
 
    struct FProcEnumInfo;
 
    /**
     * Process enumerator.
     */
    class FProcEnumerator
    {
    public:
        // Constructor
        FProcEnumerator();
        FProcEnumerator(const FProcEnumerator&) = delete;
        FProcEnumerator& operator=(const FProcEnumerator&) = delete;
 
        // Destructor
        ~FProcEnumerator();
 
        // Gets current process enumerator info.
        FProcEnumInfo GetCurrent() const;
 
        /**
         * Moves current to the next process.
         *
         * @returns True if succeeded. False otherwise.
         */
        bool MoveNext();
    private:
        // Process info structure for current process.
        Windows::PROCESSENTRY32* CurrentEntry;
 
        // Processes state snapshot handle.
        Windows::HANDLE SnapshotHandle;
    };
 
    /**
     * Process enumeration info structure.
     */
    struct FProcEnumInfo
    {
        friend FProcEnumInfo FProcEnumerator::GetCurrent() const;
    public:
        // Destructor
        ~FProcEnumInfo();
 
        // Gets process PID.
        uint32 GetPID() const;
 
        // Gets parent process PID.
        uint32 GetParentPID() const;
 
        // Gets process name. I.e. exec name.
        FString GetName() const;
 
        // Gets process full image path. I.e. full path of the exec file.
        FString GetFullPath() const;
 
    private:
        // Private constructor.
        FProcEnumInfo(const Windows::PROCESSENTRY32& InInfo);
 
        // Process info structure.
        Windows::PROCESSENTRY32* Info;
    };
 
public:
 
    // FGenericPlatformProcess interface
 
    static void* GetDllHandle( const TCHAR* Filename );
    static void FreeDllHandle( void* DllHandle );
    static void* GetDllExport( void* DllHandle, const TCHAR* ProcName );
    static void AddDllDirectory(const TCHAR* Directory);
    static void GetDllDirectories(TArray<FString>& OutDllDirectories);
    static void PushDllDirectory(const TCHAR* Directory);
    static void PopDllDirectory(const TCHAR* Directory);
    static uint32 GetCurrentProcessId();
    static uint32 GetCurrentCoreNumber();
    static void SetThreadAffinityMask( uint64 AffinityMask );
    static void SetThreadName( const TCHAR* ThreadName );
    static const TCHAR* BaseDir();
    static const TCHAR* UserDir();
    static const TCHAR* UserTempDir();
    static const TCHAR* UserSettingsDir();
    static const TCHAR* ApplicationSettingsDir();
    static const TCHAR* ComputerName();
    static const TCHAR* UserName(bool bOnlyAlphaNumeric = true);
    static void SetCurrentWorkingDirectoryToBaseDir();
    static FString GetCurrentWorkingDirectory();
    static const FString ShaderWorkingDir();
    static const TCHAR* ExecutablePath();
    static const TCHAR* ExecutableName(bool bRemoveExtension = true);
    static FString GenerateApplicationPath( const FString& AppName, EBuildConfiguration BuildConfiguration);
    static const TCHAR* GetModuleExtension();
    static const TCHAR* GetBinariesSubdirectory();
    static const FString GetModulesDirectory();
    static bool CanLaunchURL(const TCHAR* URL);
    static void LaunchURL( const TCHAR* URL, const TCHAR* Parms, FString* Error );
    static 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 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 bool SetProcPriority(FProcHandle & InProcHandle, int32 PriorityModifier);
    static FProcHandle OpenProcess(uint32 ProcessID);
    static bool IsProcRunning( FProcHandle & ProcessHandle );
    static void WaitForProc( FProcHandle & ProcessHandle );
    static void CloseProc( FProcHandle & ProcessHandle );
    static void TerminateProc( FProcHandle & ProcessHandle, bool KillTree = false );
    static void TerminateProcTreeWithPredicate(
            FProcHandle& ProcessHandle,
            TFunctionRef<bool(uint32 ProcessId, const TCHAR* ApplicationName)> Predicate);
    static bool GetProcReturnCode( FProcHandle & ProcHandle, int32* ReturnCode );
    static bool GetApplicationMemoryUsage(uint32 ProcessId, SIZE_T* OutMemoryUsage);
    static bool GetPerFrameProcessorUsage(uint32 ProcessId, float& ProcessUsageFraction, float& IdleUsageFraction);
    static bool IsApplicationRunning( uint32 ProcessId );
    static bool IsApplicationRunning( const TCHAR* ProcName );
    static FString GetApplicationName( uint32 ProcessId );
    static bool ExecProcess(const TCHAR* URL, const TCHAR* Params, int32* OutReturnCode, FString* OutStdOut, FString* OutStdErr, const TCHAR* OptionalWorkingDirectory = NULL, bool bShouldEndWithParentProcess  = false);
    static bool ExecElevatedProcess(const TCHAR* URL, const TCHAR* Params, int32* OutReturnCode);
    static FProcHandle CreateElevatedProcess(const TCHAR* URL, const TCHAR* Params);
    static bool LaunchFileInDefaultExternalApplication( const TCHAR* FileName, const TCHAR* Parms = NULL, ELaunchVerb::Type Verb = ELaunchVerb::Open, bool bPromptToOpenOnFailure = true );
    static void ExploreFolder( const TCHAR* FilePath );
    static bool ResolveNetworkPath( FString InUNCPath, FString& OutPath );
    static void Sleep(float Seconds);
    static void SleepNoStats(float Seconds);
    [[noreturn]] static void SleepInfinite();
    static void YieldThread();
    UE_DEPRECATED(5.0, "Please use GetSynchEventFromPool to create a new event, and ReturnSynchEventToPool to release the event.")
    static class FEvent* CreateSynchEvent(bool bIsManualReset = false);
    static class FRunnableThread* CreateRunnableThread();
    static void ClosePipe( void* ReadPipe, void* WritePipe );
    static bool CreatePipe(void*& ReadPipe, void*& WritePipe, bool bWritePipeLocal = false);
    static FString ReadPipe( void* ReadPipe );
    static bool ReadPipeToArray(void* ReadPipe, TArray<uint8> & Output);
    static bool WritePipe(void* WritePipe, const FString& Message, FString* OutWritten = nullptr);
    static bool WritePipe(void* WritePipe, const uint8* Data, const int32 DataLength, int32* OutDataLength = nullptr);
    static FSemaphore* NewInterprocessSynchObject(const FString& Name, bool bCreate, uint32 MaxLocks = 1);
    static FSemaphore* NewInterprocessSynchObject(const TCHAR* Name, bool bCreate, uint32 MaxLocks = 1);
    static bool DeleteInterprocessSynchObject(FSemaphore * Object);
    static bool Daemonize();
    static void SetupGameThread();
    static void SetupAudioThread();
    static void TeardownAudioThread();
    static bool IsFirstInstance();
 
    /**
     * @brief Releases locks that we held for IsFirstInstance check
     */
    static void CeaseBeingFirstInstance();
 
protected:
 
    /**
     * Reads from a collection of anonymous pipes.
     *
     * @param OutStrings Will hold the read data.
     * @param InPipes The pipes to read from.
     * @param PipeCount The number of pipes.
     */
    static void ReadFromPipes(FString* OutStrings[], Windows::HANDLE InPipes[], int32 PipeCount);
 
private:
 
    /**
     * Since Windows can only have one directory at a time,
     * this stack is used to reset the previous DllDirectory.
     */
    static TArray<FString> DllDirectoryStack;
 
    /**
     * All the DLL directories we want to load from. 
     */
    static TArray<FString> DllDirectories;
 
    /**
     * A cache of the dlls found in each directory in DllDirectories. 
     */
    static TMap<FName, TArray<FString>> SearchPathDllCache;
 
    /**
     * Replacement implementation of the Win32 LoadLibrary function which searches the given list of directories for dependent imports, and attempts
     * to load them from the correct location first. The normal LoadLibrary function (pre-Win8) only searches a limited list of locations. 
     *
     * @param FileName Path to the library to load
     * @param SearchPaths Search directories to scan for imports
     */
    static void* LoadLibraryWithSearchPaths(const FString& FileName, const TArray<FString>& SearchPaths);
 
    /**
     * Resolve an individual import.
     *
     * @param ImportName Name of the imported module
     * @param OutFileName On success, receives the path to the imported file
     * @return true if an import was found.
     */
    static bool ResolveImport(const FString& Name, const TArray<FString>& SearchPaths, FString& OutFileName);
 
    /**
     * Resolve all the imports for the given library, searching through a set of directories.
     *
     * @param FileName Path to the library to load
     * @param SearchPaths Search directories to scan for imports
     * @param ImportFileNames Array which is filled with a list of the resolved imports found in the given search directories
     * @param VisitedImportNames Array which stores a list of imports which have been checked
     */
    static void ResolveMissingImportsRecursive(const FString& FileName, const TArray<FString>& SearchPaths, TArray<FString>& ImportFileNames, TSet<FString>& VisitedImportNames);
};
 
#if WINDOWS_USE_FEATURE_PLATFORMPROCESS_CLASS
typedef FWindowsPlatformProcess FPlatformProcess;
#endif