Newsgroup: it.comp.programmare.win32
Titolo: Handle ad un Thread di un processo esterno (W98)

Salve a tutti.
Come posso ottenere un handle ad un thread di un processo esterno, dato
il suo ThreadID ?
Ho provato con DuplicateHandle ma, o non ho capito bene cosa passargli, o 
non è la funzione giusta...
Grazie in anticipo!! Ciao, Davide DG.

 ha scritto nel messaggio
news:jK1F6.85660$s93.8...@news.infostrada.it...

OpenThread ?
Porlock.

 OpenThread ?
Ma perchè tale funzione NON è documentata nel mio SDK?
Pensavo non esistesse tale funzione, in quanto OpenProcess è presente
sull'SDK mentre OpenThread NO!
Vabbè, ho imparato una cosa nuova anche se sono dovuto andare su msdn a
vederla!
Ciao! :)
--
- Carlo -
c.b...@libero.it

OpenThread ?
Scusa il secondo messaggio, ma ho notato un particolare proprio ora ...
Requirements
  Windows NT/2000: Requires Windows 2000 or later.
  Windows 95/98: Requires Windows Me.
  Header: Declared in Winbase.h; include Windows.h.
  Library: Use Kernel32.lib.
Per cui sotto Win98 tale funzione non funziona (non dovrebbe funzionare)!


 ha scritto nel messaggio
news:rRbF6.43$PE....@news.infostrada.it...

Effettivamente pare che sia una cosa tutt'altro che semplice ottenere
l'handle di un thread.
Su MSDN ho trovato questo:
INFO: Thread Handles and Thread IDs
ID: Q127992
----------------------------------------------------------------------------
----
The information in this article applies to:
Microsoft Win32 Application Programming Interface (API), used with:
Microsoft Windows NT Server versions 3.5, 3.51
Microsoft Windows NT Workstation versions 3.5, 3.51
Microsoft Windows 95
----------------------------------------------------------------------------
----
SUMMARY
The CreateThread() API is used to create threads. The API returns both a
thread handle and a thread identifier (ID). The thread handle has full
access rights to the thread object created. The thread ID uniquely
identifies the thread on the system level while the thread is running. The
ID can be recycled after the thread has been terminated. This relationship
is similar to that of the process handle and the process ID (PID).
There is no way to get the thread handle from the thread ID. While there is
an OpenProcess() API that takes a PID and returns the handle to the process,
there is no corresponding OpenThread() that takes a thread ID and returns a
thread handle.
The reason that the Win32 API does not make thread handles available this
way is that it can cause damage to an application. The APIs that take a
thread handle allow suspending/resuming threads, adjusting priority of a
thread relative to its process, reading/writing registers, limiting a thread
to a set of processors, terminating a thread, and so forth. Performing any
one of these operations on a thread without the knowledge of the owning
process is dangerous, and may cause the process to fail.
If you will need a thread handle, then you need to request it from the
thread creator or the thread itself. Both the creator or the thread will
have a handle to the thread and can give it to you using DuplicateHandle().
This requirement allows both applications to coordinate their actions.
NOTE: You can also take full control of the application by calling
DebugActiveProcess(). Debuggers receive the thread handles for a process
when the threads are created. These handles have THREAD_GET_CONTEXT,
THREAD_SET_CONTEXT, and THREAD_SUSPEND_RESUME access to the thread.
Additional query words: 3.50 4.00
Keywords : kbAPI kbKernBase kbNTOS350 kbNTOS351 kbThread kbWinOS95
kbDSupport kbGrpKernBase
Version : winnt:3.5,3.51
Platform : winnt
Issue type : kbinfo
Technology : kbvcSearch
Ciao
Porlock.
Last Reviewed: August 16, 2000
© 2000 Microsoft Corporation. All rights reserved. Terms of Use.

 There is no way to get the thread handle from the thread ID
Qui non sono molto d'accordo con msdn ... casomai non esiste una via pulita
per ottenerlo, ma penso che una strada rischiosa e alternativa ci sia! ;)
Leggi la risposta che ho dato su ICL.Delphi alla stessa richiesta, vorrei
sapere cosa ne pensate ...
---
DuplicateHandle serve, ma dovrebbe essere chiamata solo internamente al
thread stesso! In poche parole DuplicateHandle dovrebbe creare un Handle
REALE di un oggetto (nel caso specifico, Thread), e non uno PseudoHandle! Mi
spiego meglio: la funzione che può essere interessante è GetCurrentThread,
che restituisce uno PseudoHandle del thread stesso ... ora iniettando un
Hook nel Thread interessato e poi richiamando GetCurrentThread ottieni
questo famoso PseudoHandle, solo che il PHandle è un valore valido solo
all'interno del Thread stesso, quindi se "catturi" questo valore e lo usi
all'esterno la funzione a cui lo passi ti risponde 2 di picche! Leggi però
l'SDK alla voce GetCurrentThread :"A thread can create a "real" handle of
itself that can be used by other threads, or inherited by other
processes, by specifying the pseudohandle as the source handle in a call to
the DuplicateHandle function."
Ecco quindi la mia soluzione "sporca":
1 - Inietti l'Hook nell'indirizzamento del Thread di cui possiedi il TID.
2 - Dalla funzione di Callback (il filtro dell'Hook) richiami
GetCurrentThread per ottenere lo PseudoHandle
3 - Dall'interno della Callback richiami DuplicateHandle secondo quanto
sopra specificato (passandole lo PseudoHandle)
4 - Esporti (mediante una qualsiasi tecnica IPC) l'handle REALE creato da
DuplicateHandle e hai quindi il tuo hThread.
Se le operazioni che devi fare con questo Handle del thread non sono troppo
pesanti c'è una seconda via "sporca" e "semplificata".
1 - Inietti l'Hook nell'indirizzamento del Thread di cui possiedi il TID
2 - Dalla funzione di Callback richiami GetCurrentThread per ottenere
pHandle
3 - Sempre dalla Callback sfrutti lo PseudoHandle ed effettui tutte le
chiamate necessarie (ti ricordo che sei nello spazio di indirizzamento
remoto, per cui lo PseudoHandle è un valore "lecito")
A te la scelta ... non ho trovato (e non credo esista per motivi di
sicurezza) alcuna funzione che ti restituisce un Real-Handle di un oggetto
Kernel di tipo Thread che sia esso esterno o interno al processo!
Neppure uno snapshot dei Thread mediante Tool Help (vedi TThreadEntry32)
fornisce l'handle reale di un Thread, ma sempre il Thread ID.
---
Il discorso della sicurezza viene confermato dall'articolo su MSDN, però a
mio avviso una di queste 2 strade dovrebbe portare alla soluzione!
