cOSProcess.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cOSProcess_H
#define _INC_cOSProcess_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cOSHandle.h"
#include "cFilePath.h"
#include "cThreadLock.h"
 
namespace Gray
{
        class cFile;
 
#ifdef _WIN32
        typedef int SHOWWINDOW_t;       
#elif defined(__linux__)
        enum SHOWWINDOW_t
        {
                SW_HIDE = 0,
                SW_SHOWNORMAL = 1,
                SW_SHOWMINIMIZED,
                SW_SHOWMAXIMIZED,       
                SW_SHOWDEFAULT = 10,
        };
#else
#error NOOS
#endif
 
#ifdef _WIN32
        typedef DWORD PROCESSID_t;              
        typedef DWORD APP_EXITCODE_t;   
#elif defined(__linux__)
        typedef pid_t PROCESSID_t;              
        typedef int APP_EXITCODE_t;             
#endif
        constexpr PROCESSID_t PROCESSID_BAD = 0;        
 
        enum APP_EXITCODE_TYPE
        {
 
                APP_EXITCODE_ERRNO = -1,                        
                APP_EXITCODE_OK = EXIT_SUCCESS,         
                APP_EXITCODE_FAIL = EXIT_FAILURE,       
                APP_EXITCODE_ABORT = 3,                         
 
                // .. some other condition.
#ifdef _WIN32
                APP_EXITCODE_STILL_ACTIVE = STILL_ACTIVE,       
#elif defined(__linux__)
                APP_EXITCODE_STILL_ACTIVE = 0x103,                      
#endif
                APP_EXITCODE_UNK = SHRT_MAX,            
        };
 
        class GRAYCORE_LINK cOSProcess
        {
 
        protected:
                PROCESSID_t m_nPid;             
 
#ifdef _WIN32
                cOSHandle m_hProcess;   
        public:
                cOSHandle m_hThread;    
#elif defined(__linux__)
        protected:
                cStringF m_sPath;               
#else
#error NOOS
#endif
 
        public:
                cOSProcess() noexcept;
                virtual ~cOSProcess();
 
#ifdef _WIN32
                cOSProcess(PROCESSID_t nPid, HANDLE h) noexcept
                        : m_nPid(nPid)
                        , m_hProcess(h)
                {
                        // _WIN32 = ::GetCurrentProcess() = 0xFFFFFFFF as a shortcut.
                }
                HANDLE get_ProcessHandle() const noexcept
                {
                        return m_hProcess.get_Handle();
                }
                void CloseProcessHandle();
#endif
                HRESULT CreateProcessX(const FILECHAR_t* pszExeName, const FILECHAR_t* pszArgs = nullptr, SHOWWINDOW_t nShowCmd = SW_SHOWNORMAL, const FILECHAR_t* pszCurrentDir = nullptr, cFile* pFileOutPipe = nullptr);
 
                static inline bool GRAYCALL IsSystemPID(PROCESSID_t nProcessID) noexcept
                {
                        if (nProcessID == 0)    // PROCESSID_BAD
                                return true;
#ifdef _WIN32
                        if (nProcessID == 4)
                                return true;
#endif
                        return false;
                }
 
                bool isValidProcess() const noexcept
                {
                        // Is the process in memory/valid/active now ?
#ifdef _WIN32
                        return m_hProcess.isValidHandle();
#elif defined(__linux__)
                        return m_nPid != 0;
#endif
        }
 
                PROCESSID_t get_ProcessId() const noexcept
                {
                        return m_nPid;
                }
                virtual cStringF get_ProcessPath() const;
                cStringF get_ProcessName() const;
                HRESULT OpenProcessId(PROCESSID_t dwProcessID, DWORD dwDesiredAccess = 0, bool bInheritHandle = false);
 
#ifdef _WIN32
                HRESULT GetProcessCommandLine(OUT wchar_t* pwText, _Inout_ size_t* pdwTextSize) const;
#endif
                cStringF get_CommandLine() const;
 
                HRESULT WaitForProcessExit(TIMESYSD_t nTimeWait, APP_EXITCODE_t* pnExitCode = nullptr);
 
                void AttachCurrentProcess() noexcept
                {
#ifdef _WIN32
                        // 0xFFFFFFFF = current process. https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getcurrentprocess
                        m_nPid = ::GetCurrentProcessId();
                        m_hProcess.AttachHandle(::GetCurrentProcess());
#elif defined(__linux__)
                        m_nPid = ::getpid();
#endif
                }
 
                HRESULT TerminateProcess(APP_EXITCODE_t uExitCode)
                {
 
                        if (!isValidProcess())
                                return S_FALSE;
#ifdef _WIN32
                        if (!::TerminateProcess(get_ProcessHandle(), uExitCode))
#elif defined(__linux__)
                        if (::kill(get_ProcessId(), SIGTERM) != 0) // send a signal(SIGTERM) to the process.
#endif
                        {
                                return HResult::GetLastDef();
                        }
                        return S_OK;
                }
 
                DWORD get_PriorityClass() const noexcept
                {
#if defined(_WIN32) && ! defined(UNDER_CE)
                        return ::GetPriorityClass(get_ProcessHandle());
#elif defined(__linux__)
                        ASSERT(0);
                        // TODO __linux__
                        return 0;
#endif
}
                bool put_PriorityClass(DWORD dwPriorityClass) noexcept
                {
#if defined(_WIN32) && ! defined(UNDER_CE)
                        return ::SetPriorityClass(get_ProcessHandle(), dwPriorityClass) ? true : false;
#elif defined(__linux__)
                        ASSERT(0);
                        // TODO __linux__
                        return false;
#endif
                }
 
#ifdef _WIN32
 
                HRESULT CreateRemoteThread(THREAD_FUNC_t pvFunc, const void* pvArgs, OUT cOSHandle& thread);
 
                void* AllocMemory(size_t nSize)
                {
                        // Allocate space in the process memory.
                        return ::VirtualAllocEx(get_ProcessHandle(), NULL, nSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
                }
 
                HRESULT WriteProcessMemory(void* pBaseAddress, const void* pData, size_t nSize)
                {
 
                        SIZE_T nSizeWrite = nSize;
                        const BOOL bSuccess = ::WriteProcessMemory(get_ProcessHandle(), pBaseAddress, pData, nSize, &nSizeWrite);
                        if (!bSuccess)
                        {
                                return HResult::GetLastDef(HRESULT_WIN32_C(ERROR_WRITE_FAULT));
                        }
                        return (HRESULT)nSizeWrite;
                }
 
                HRESULT ReadProcessMemory(const void* pBaseAddress, void* pDataIn, size_t nSize) const
                {
 
                        SIZE_T nSizeRead = nSize;
                        const BOOL bSuccess = ::ReadProcessMemory(get_ProcessHandle(), pBaseAddress, pDataIn, nSize, &nSizeRead);
                        if (!bSuccess)
                        {
                                return HResult::GetLastDef(HRESULT_WIN32_C(ERROR_READ_FAULT));
                        }
                        return (HRESULT)nSizeRead;
                }
 
                bool GetExitCodeProcess(OUT APP_EXITCODE_t* pnExitCode)
                {
                        return ::GetExitCodeProcess(get_ProcessHandle(), pnExitCode) ? true : false;
                }
 
                static inline PROCESSID_t FindProcessIdForWindow(HWND hWnd) noexcept
                {
                        PROCESSID_t dwProcessIDRet = PROCESSID_BAD;
                        const THREADID_t dwThreadID = ::GetWindowThreadProcessId(hWnd, &dwProcessIDRet);
                        UNREFERENCED_PARAMETER(dwThreadID);
                        return dwProcessIDRet;
                }
 
                // Stats
#ifndef UNDER_CE
                bool GetStatTimes(OUT FILETIME* pCreationTime, OUT FILETIME* pExitTime, OUT FILETIME* pKernelTime, OUT FILETIME* pUserTime) const
                {
                        return ::GetProcessTimes(get_ProcessHandle(), pCreationTime, pExitTime, pKernelTime, pUserTime) ? true : false;
                }
 
                bool GetStatIoCounters(OUT IO_COUNTERS* pIoCounters) const
                {
                        return ::GetProcessIoCounters(get_ProcessHandle(), pIoCounters) ? true : false;
                }
#endif // UNDER_CE
 
#if ( _WIN32_WINNT >= 0x0501 ) && ! defined(UNDER_CE)
                bool GetStatHandleCount(OUT DWORD* pdwHandleCount) const
                {
                        return ::GetProcessHandleCount(get_ProcessHandle(), pdwHandleCount);
                }
#endif
                static HWND GRAYCALL FindWindowForProcessID(PROCESSID_t nProcessID, DWORD dwStyleFlags, const GChar_t* pszClassName = nullptr); // WS_VISIBLE
#endif // _WIN32
 
                UNITTEST_FRIEND(cOSProcess);
        };
}
 
#endif // _INC_cOSProcess_H