TnbProcessHandle.h

[詳解]

#pragma once
#define __TNBPROCESSHANDLE_H__ 
#include "TnbHandleHandle.h"
#ifdef _TnbPROCESS_PipeInOut_ENABLE
 #include "TnbPipe.h"
#endif
#ifdef _TnbPROCESS_EnumProcesses_ENABLE
 #include "TnbVector.h"
 #include <Tlhelp32.h>
 #include <Psapi.h>
 #pragma comment( lib, "Psapi.lib" )
#endif
#ifdef _DEBUG
 #include <TnbTime.h>
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CProcessHandle
{
public:
 
    CProcessHandle(void)
    {
    }
 
    bool Terminate(UINT uExitCode = 0)
    {
        bool r = false;
        if ( ! m_hhProcess.IsNull() )
        {
            r = !! ::TerminateProcess(m_hhProcess, uExitCode);
        }
        return r;
    }
 
    DWORD WaitForExit(DWORD dwWait = INFINITE)
    {
        DWORD r = WAIT_ABANDONED;
        if ( ! m_hhProcess.IsNull() )
        {
            r = ::WaitForSingleObject(m_hhProcess, dwWait); //プロセス待機
        }
        return r;
    }
 
    bool IsAlive(void) const
    {
        DWORD r = WAIT_ABANDONED;
        if ( ! m_hhProcess.IsNull() )
        {
            r = ::WaitForSingleObject(m_hhProcess, 0);
        }
        return r == WAIT_TIMEOUT;
    }
 
    operator HANDLE(void) const
    {
        return m_hhProcess;
    }
 
    HANDLE GetProcessHandle(void) const
    {
        return m_hhProcess;
    }
 
    HANDLE GetThreadHandle(void) const
    {
        return m_hhThread;
    }
 
    DWORD GetProcessId(void) const
    {
        return m_processId;
    }
 
    LONGLONG GetExitCode(void) const
    {
        DWORD dw;
        if ( ! ::GetExitCodeProcess(m_hhProcess, &dw) )
        {
            return -1;
        }
        return dw;
    }
 
    void Attach(HANDLE hProcess, HANDLE hThread)
    {
        m_hhProcess = hProcess;
        m_hhThread = hThread;
        m_processId = 0;
    }
 
    void Detach(void)
    {
        m_hhProcess.Null();
        m_hhThread.Null();
        m_processId = 0;
    }
 
#ifndef _WIN32_WCE
    bool Create(LPCTSTR lpszExecName, LPCTSTR lpszCommand, STARTUPINFO& si)
    {
        Detach();
        //
        PROCESS_INFORMATION pi;
        CSimpleStr s = lpszCommand;
        if ( ::CreateProcess(lpszExecName, s, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi) )
        {
            ::WaitForInputIdle(pi.hProcess, INFINITE);
            m_hhProcess = pi.hProcess;
            m_hhThread = pi.hThread;
            m_processId = pi.dwProcessId;
            return true;
        }
        _GetLastError("CreateProcess");
        return false;
    }
 
    bool Create(LPCTSTR lpszExecName, LPCTSTR lpszCommand, bool boIsShowWindow = true)
    {
        STARTUPINFO si;
        memset(&si, 0, sizeof(STARTUPINFO));
        si.cb = sizeof(STARTUPINFO);
        si.dwFlags = STARTF_USESHOWWINDOW;
        si.wShowWindow = static_cast<WORD>(boIsShowWindow ? SW_SHOWDEFAULT : SW_HIDE);
        return Create(lpszExecName, lpszCommand, si);
    }
#else
    bool Create(LPCTSTR lpszExecName, LPCTSTR lpszCommand, bool boDummy = true)
    {
        Detach();
        //
        PROCESS_INFORMATION pi;
        if ( ::CreateProcess(lpszExecName, lpszCommand, NULL, NULL, FALSE, 0, NULL, NULL, NULL, &pi) )
        {
            m_hhProcess = pi.hProcess;
            m_hhThread = pi.hThread;
            m_processId = pi.dwProcessId;
            return true;
        }
        return false;
    }
#endif // _WIN32_WCE
 
    #ifdef _TnbPROCESS_PipeInOut_ENABLE
    bool Create(LPCTSTR lpszCommand, CPipe* pInputPipe, CPipe* pOutputPipe, 
                CPipe* pErrorPipe = NULL, bool boIsShowWindow = true)
    {
        Detach();
        //
        if ( pErrorPipe == NULL ) { pErrorPipe = pOutputPipe; }
        if ( pInputPipe == NULL || ! pInputPipe->IsOpened() ) { return false; }
        if ( pOutputPipe == NULL || ! pOutputPipe->IsOpened() ) { return false; }
        if ( ! pErrorPipe->IsOpened() ) { return false; }
        //
        STARTUPINFO si;
        memset(&si, 0, sizeof(STARTUPINFO));
        si.cb = sizeof(STARTUPINFO);
        si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
        si.hStdInput = pInputPipe->GetReadHandle();
        si.hStdOutput = pOutputPipe->GetWriteHandle();
        si.hStdError = pErrorPipe->GetWriteHandle();
        si.wShowWindow = static_cast<WORD>(boIsShowWindow ? SW_SHOWDEFAULT : SW_HIDE);
        //
        PROCESS_INFORMATION pi;
        CSimpleStr s = lpszCommand;
        if ( ::CreateProcess(NULL, s, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi) )
        {
            ::WaitForInputIdle(pi.hProcess, INFINITE);
            m_hhProcess = pi.hProcess;
            m_hhThread = pi.hThread;
            m_processId = pi.dwProcessId;
            return true;
        }
        _GetLastError("CreateProcess");
        return false;
    }
    #endif
 
    static bool TerminateProcessId(DWORD processId, UINT uExitCode = 0)
    {
        CHandleHandle hhProcess = ::OpenProcess(PROCESS_TERMINATE, FALSE, processId);
        if ( hhProcess != INVALID_HANDLE_VALUE )
        {
            return !! ::TerminateProcess(hhProcess, uExitCode);
        }
        return false;
    }
 
    #ifdef _TnbPROCESS_EnumProcesses_ENABLE
    static bool GetProcessName(CSimpleStr& _name, DWORD processId, ::FILETIME* pCreateTime = NULL)
    {
        CHandleHandle hhProcess = ::OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processId);
        if ( hhProcess != INVALID_HANDLE_VALUE )
        {
            HMODULE hMod;
            DWORD cbNeeded;
            if ( ::EnumProcessModules(hhProcess, &hMod, sizeof(hMod), &cbNeeded) )
            {
                CWorkMemT<TCHAR> s(MAX_PATH);
                if ( ::GetModuleBaseName(hhProcess, hMod, s, MAX_PATH) )
                {
                    _name = s;
                    if ( pCreateTime != NULL )
                    {
                        ::FILETIME ft;
                        ::GetProcessTimes(hhProcess, pCreateTime, &ft, &ft, &ft);
                    }
                    return true;
                }
            }
        }
        return false;
    }
 
    static bool EnumProcesses(CWorkMemT<DWORD>& _ids)
    {
        const int MAX_CNT = 1024;
        CWorkMemT<DWORD> procs(MAX_CNT);
        DWORD cbNeeded = 0;
        if ( ! ::EnumProcesses(procs.Ref(), MAX_CNT * sizeof(DWORD), &cbNeeded) )
        {
            return false;
        }
        int len = cbNeeded / sizeof(DWORD);
        _ids.Reset(len, procs.Ref());
        return true;
    }
 
    static bool EnumProcesses(CWorkMemT<DWORD>& _ids, LPCTSTR lpszProcessName)
    {
        const int MAX_CNT = 1024;
        INDEX cnt = 0;
        ::FILETIME ft;
        CWorkMemT<TParam> w1;
        w1.Resize(MAX_CNT);
        CWorkMemT<DWORD> w2;
        if ( EnumProcesses(w2) )
        {
            CSimpleStr s;
            loop ( i, w2.GetSize() )
            {
                if ( GetProcessName(s, w2[i], &ft) )
                {
                    if ( STRLIB::Compare(s, lpszProcessName, -1, NORM_IGNORECASE) == 0 )
                    {
                        w1[cnt].processId = w2[i];
                        w1[cnt].createTime = ft;
                        cnt++;
                        if ( cnt >= MAX_CNT )
                        {
                            break;
                        }
                    }
                }
            }
            ::qsort(w1, cnt, sizeof(TParam), ms_CompareParam);
            _ids.Resize(cnt);
            loop ( i, cnt )
            {
                TRACE2("found %d, %s\n", w1[i].processId, CSystemTime(w1[i].createTime).Format());
                _ids[i] = w1[i].processId;
            }
            return true;
        }
        return false;
    }
 
    static CVectorT<PROCESSENTRY32> EnumProcessesEntry(void)
    {
        CVectorT<PROCESSENTRY32> v;
        HANDLE hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        PROCESSENTRY32 entry;
        entry.dwSize = sizeof(PROCESSENTRY32);
        if ( ::Process32First(hSnapshot, &entry) )
        {
            do {
                v.Add(entry);
            } while( ::Process32Next(hSnapshot, &entry) );
        }
        ::CloseHandle(hSnapshot);
        return v;
    }
 
private:
    struct TParam
    {
        DWORD       processId;      
        ::FILETIME  createTime;     
    };
    static int ms_CompareParam(const void* P1, const void* P2)
    {
        const TParam* Q1 = static_cast<const TParam*>(P1);
        const TParam* Q2 = static_cast<const TParam*>(P2);
        return CompareFileTime(&Q2->createTime, &Q1->createTime);
    }
    #endif // _TnbPROCESS_EnumProcesses_ENABLE
 
private:
    CHandleHandle   m_hhProcess;    
    CHandleHandle   m_hhThread;     
    DWORD           m_processId;    
};
 
 
 
}; //TNB