Come gestire il thread principale del processo

Question

Ho creato un thread aggiuntivo in alcune piccole applicazioni di test e desidero sospendere il thread principale da questo thread aggiuntivo. Il thread aggiuntivo viene creato tramite CreateRemoteThread da un processo esterno.

Dato che SuspendThread ha bisogno di un HANDLE per il thread che deve essere sospeso, voglio sapere come ottenere questo HANDLE dal codice in esecuzione nel mio thread aggiuntivo.

Answer 1

DWORD GetMainThreadId() { 
    const std::tr1::shared_ptr<void> hThreadSnapshot(
     CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0), CloseHandle); 
    if (hThreadSnapshot.get() == INVALID_HANDLE_VALUE) { 
     throw std::runtime_error("GetMainThreadId failed"); 
    } 
    THREADENTRY32 tEntry; 
    tEntry.dwSize = sizeof(THREADENTRY32); 
    DWORD result = 0; 
    DWORD currentPID = GetCurrentProcessId(); 
    for (BOOL success = Thread32First(hThreadSnapshot.get(), &tEntry); 
     !result && success && GetLastError() != ERROR_NO_MORE_FILES; 
     success = Thread32Next(hThreadSnapshot.get(), &tEntry)) 
    { 
     if (tEntry.th32OwnerProcessID == currentPID) { 
      result = tEntry.th32ThreadID; 
     } 
    } 
    return result; 
} 

Answer 2

Non penso che ci sia qualcosa che distingue il thread principale da altri thread una volta avviato il processo. Tuttavia, è possibile enumerate all threads in the process e utilizzare GetThreadTimes per trovare il thread con la prima ora di creazione. Chiama OpenThread per ottenere un HANDLE da un ID thread.

Answer 3

Un numero di funzioni API utili di questo tipo si trovano nella suite (ovviamente!) Tool Help. L'API CreateToolhelp32Snapshot() acquisirà un'istantanea dei thread in esecuzione per un processo specificato.

// Take a snapshot of all running threads 
hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); 
if(hThreadSnap == INVALID_HANDLE_VALUE) 
    return(FALSE); 

codice here.

struttura restituita non distingue thread primario dagli altri esempio completo. Non conosco un meccanismo per farlo; mentre alcune versioni del runtime C saranno tutte ExitProcess() alla fine del thread primario, in tutte le versioni recenti il ​​processo continua a essere eseguito fino all'uscita dell'ultimo thread.

La raccomandazione di Interjay di utilizzare GetThreadTimes potrebbe essere la soluzione migliore. Se è possibile eseguire il processo di destinazione CreateProcess(), il membro hThread del blocco PROCESS_INFORMATION contiene il tid per il thread primario. Accogli le idee degli altri.

Answer 4

Perché non basta creare un ampio programma globale (uso extern se si deve)

HANDLE mainThread ; 
DWORD mainThreadId ; 

Nella prima riga del principale (prima di creare qualsiasi thread) fare

mainThread = GetCurrentThread() ; 
mainThreadId = GetCurrentThreadId() ; 

è possibile utilizzare any form of IPC per condividere l'ID o la maniglia con il processo a distanza (non hanno verificato condividere la maniglia funzionerà, ma dovrebbe!)

Answer 5

ottenere l'ID filo con questa funzione:

/* CAUTION: ONLY x86 TESTED 
* get the thread id of the main thread of a target process 
* 
* params: 
*  DWORD dwPid process id of the target process 
* 
* return: 
*  Success  thread id 
*  Error  NULL 
*/ 
DWORD GetMainThreadId(DWORD dwPid) 
{ 
    LPVOID lpTid; 

    _asm 
    { 
     mov eax, fs:[18h] 
     add eax, 36 
     mov [lpTid], eax 
    } 

    HANDLE hProcess = OpenProcess(PROCESS_VM_READ, FALSE, dwPid); 
    if(hProcess == NULL) 
     return NULL; 

    DWORD dwTid; 
    if(ReadProcessMemory(hProcess, lpTid, &dwTid, sizeof(dwTid), NULL) == FALSE) 
    { 
     CloseHandle(hProcess); 
     return NULL; 
    } 

    CloseHandle(hProcess); 

    return dwTid; 
} 

semplice aprire la discussione per ottenere la maniglia:

/* 
* get a handle to the main thread of a target process 
* if successfull, the returned handle must be closed with CloseHandle() 
* 
* params: 
*  DWORD dwPid    process id of the target process 
*  DWORD dwDesiredAccess desired access rights to the thread 
* 
* return: 
*  Success  thread handle with desired access rights 
*  Error  NULL 
*/ 
HANDLE GetMainThreadHandle(DWORD dwPid, DWORD dwDesiredAccess) 
{ 
    DWORD dwTid = GetMainThreadId(dwPid); 
    if(dwTid == FALSE) 
     return NULL; 

    return OpenThread(dwDesiredAccess, FALSE, dwTid); 
}