DuplicateHandle (), utilizzare nel primo o nel secondo processo?

Question

L'API di Windows DuplicateHandle () http://msdn.microsoft.com/en-us /library/ms724251(VS.85).aspx Richiede la duplicazione dell'handle Object e dell'handle sia del processo originale sia dell'altro processo in cui si desidera utilizzare l'handle duplicato.

Suppongo che se avessi due processi UNRELATED, potrei chiamare DuplicateHandle () in uno solo se avessi a disposizione gli handle richiesti?

La mia domanda riguarda l'uso di una pipe per comunicare tra i due processi per raggiungere questo obiettivo con un evento.

Nel primo processo ho creatoEvent (). Ora voglio usare WaitForSingleObject () nel secondo processo.

Se provo a duplicare l'handle nel primo processo, dovrò prima inviare il secondo handle di processo al primo processo tramite il pipe, duplicare l'handle e quindi inviare l'handle al secondo processo?

In alternativa, potrei iniziare inviando il primo handle di processo e l'handle Event al secondo processo e duplicarlo lì.

C'è un motivo per cui dovrei scegliere l'uno rispetto all'altro?

Per aggiungere una ruga, l'handle Event è effettivamente ereditato dal processo parent che in realtà ha chiamato il primo processo (che è un'applicazione CGI). Se quell'handle di eventi è stato creato con HANDLE_DO_NOT_DUPLICATE (qualcosa del genere), allora posso effettivamente utilizzare DuplicateHandle () per duplicarlo per il secondo processo?

Risposta:

Beh, potrei creare un nuovo evento NAMED nel primo processo e trovarlo nel secondo processo come suggerito, ma sto cercando di DUPLICARE l'evento che è stato creato nel genitore del primo processo e inoltrarlo al secondo processo . Questo evento non è un evento denominato, quindi è necessario utilizzare DuplicateHandle ().

Sto usando una pipe per l'IPC. Sto realizzando che DuplicateHandle () dovrà essere chiamato nel primo processo perché l'handle dell'evento è fuori contesto quando inviato al secondo processo.

        hProcPseudo  = GetCurrentProcess() 

    //Then call either:
        lpRealHandle = OpenProcess( PROCESS_DUP_HANDLE, 0, hProcPseudo ) 
//This fails with GetLastError= 87 - The parameter is incorrect ???
// same thing with PROCESS_ALL_ACCESS ??


    //OR
        lRet = DuplicateHandle( hProcPseudo, hProcPseudo, hProcPseudo, lpRealHandle, DUPLICATE_SAME_ACCESS, 0, 0 )

    //then I can Duplicate my Event Handle in the first thread with:
        lRet = DuplicateHandle( hLocalProcess, hEvent, lpRealHandle, hDupEvent, DUPLICATE_SAME_ACCESS, 0, 0)

Il secondo processo converte il suo handle con DuplicateHandle () dettagliato sopra la conversione

hProcPseudo = 4294967295

a

hProcess = 152

Quindi passo questo handle di processo al primo processo tramite la pipe denominata. Nel primo processo (dove l'handle dell'evento è valido) chiamo handle duplicato:

DuplicateHandle( hFirstProcess, hEvent, hSecondProc, hDupEvent, DUPLICATE_SAME_ACCESS, 0, 0)

Purtroppo ho ricevuto l'errore:

DuplicateHandle hPipeFCGI GetLastError = 6 - L'handle non è valido.

Ulteriori test (sostituendo hFirstProcess) rivelano che hSecondProc non è valido! ??

Grande mistero.

Answer 1

Utilizza un named pipe o < a href = "http://msdn.microsoft.com/en-us/library/aa365576(VS.85).aspx" rel = "nofollow noreferrer"> mailslot per IPC, questo dovrebbe funzionare in modo affidabile per il tuo scopo. Se devi aspettare, usa le maniglie di attesa denominate.

Altrimenti, sceglierei di eseguire DuplicateHandle nel secondo processo per impostare correttamente la proprietà dell'handle.

Answer 2

L'handle del processo è diverso dall'ID del processo. OpenProcess accetta l'ID di processo. Usa qualcosa come ...

HANDLE hProcess = OpenProcess (PROCESS_DUP_HANDLE, FALSE, GetCurrentProcessId ());

Answer 3

Se ho capito correttamente, vuoi sincronizzare due processi non correlati attraverso lo stesso evento. In tal caso, puoi utilizzare eventi denominati.

Creane uno usando CreateEvent API , dagli un nome, quindi dal secondo processo usa OpenEvent funzione API, specificando il nome dell'evento.

Hai funzioni simili per altri oggetti di sincronizzazione, come i mutex ( OpenMutex ) o semafori ( OpenSemaphore ) .

Answer 4

1. In qualche modo, il secondo processo deve ottenere l'ID del processo al primo processo. Questo può essere ottenuto tramite GetCurrentProcessId ()
2. Il primo processo ora deve utilizzare questo ID per ottenere un HANDLE al secondo processo: hProcess = OpenProcess (PROCESS_DUP_HANDLE, FALSE, dwProcessId);
3. Ora puoi duplicare l'handle nel primo processo, usando l'handle del processo REAL del secondo processo e lo pseudo-handle del primo processo: DuplicateHandle (GetCurrentProcess (), hEvent, hProcess e & amp; hDupEvent, 0, FALSE, DUPLICATE_SAME_ACCESS);
4. Ricorda di rilasciare eventualmente l'handle che hai creato con OpenProcess (non so che differenza farebbe, ma dovresti ...). Inoltre, rilasciare ENTRAMBI gli handle per l'evento: quello assegnato al secondo processo e l'handle iniziale.