arborescence des processus

Fred a écrit :

Bonjour,

J'aurais aimé savoir s'il y avait une façon sioux de réccupérer la liste
des PID des ascendants d'un process?
Je comptais utiliser Process32First et Process32Next, mais ça n'est pas
dispo sur NT. Or, je cherche quelque chose qui serait valable de Windows
95 à nos jours...

Merci d'avance pour votre aide.

Fred

J'ai oublié de préciser que je souhaitais le coder en C...

Merci encore

Fred

Fred wrote:

Bonjour,

J'aurais aimé savoir s'il y avait une façon sioux de réccupérer la
liste des PID des ascendants d'un process?
Je comptais utiliser Process32First et Process32Next, mais ça n'est
pas dispo sur NT.

Ben si ça marche sous NT.
http://msdn.microsoft.com/library/en-us/perfmon/base/taking_a_snapshot_and_viewing_processes.asp

--
Aurélien REGAT-BARREL

Aurélien REGAT-BARREL a écrit :

Fred wrote:

Bonjour,

J'aurais aimé savoir s'il y avait une façon sioux de réccupérer la
liste des PID des ascendants d'un process?
Je comptais utiliser Process32First et Process32Next, mais ça n'est
pas dispo sur NT.

Ben si ça marche sous NT.
http://msdn.microsoft.com/library/en-us/perfmon/base/taking_a_snapshot_and_viewing_processes.asp

Non, la Tool Help Library n'est pas disponible sous NT 4

Requirements
Client Requires Windows XP, Windows 2000 Professional, Windows Me,
Windows 98, or Windows 95.
Server Requires Windows Server 2003 or Windows 2000 Server.

Fred

Fred wrote:

Non, la Tool Help Library n'est pas disponible sous NT 4

Oui.

Sous NT4, il ta faut faire avec la PSAPI.DLL, via EnumProcesses() pour
obtenir la liste des processus en cours.

--
AMcD®

http://arnold.mcdonald.free.fr/

Dans le message news:4236ddee$0$4789$626a14ce@news.free.fr ,
Fred <fred@laposte.net> s'est ainsi exprimé:

Bonjour,

J'aurais aimé savoir s'il y avait une façon sioux de réccupérer la
liste des PID des ascendants d'un process?
Je comptais utiliser Process32First et Process32Next, mais ça n'est
pas dispo sur NT.

Sous NT x seulement (3.1, 3.5x et 4) !
Car c'est de nouveau disponible à partir de Windows 2000 !

Or, je cherche quelque chose qui serait valable de
Windows 95 à nos jours...

Il faudra que tu prévoies un cas particulier pour NT4 (uniquement).
Je sais, c'est facilitant le transit intestinal, mais c'est ainsi ..

Le procédé d'exploration des processus sous NT4 est totalement différent de
celui utilisé dans les autres OS (Win95 à W2K3).
On se demande pourquoi, d'ailleurs!

Les fonctions "CreateToolhelp32Snapshot", "Process32First" et
"Process32Next" N'EXISTENT PAS sous NT4.
Sous Win9x/ME et W2k/XP/W2K3 elles font partie de la DLL "KERNEL32.DLL"

Sous NT4 il faut utiliser les fonctions contenues dans la DLL "PSAPI.DLL".
NB: "PS" = "Process Status"
Cette DLL NE FAIT PAS PARTIE nativement de NT, mais est fournie seulement
avec le SDK32.
Elle est cependant librement redistribuable.

Ses principales fonctions sont (en réalité, il y en a 17) :
EnumProcesses
OpenProcess
EnumProcessModules
GetModuleFileNameEx

La fonction qui retourne les DLL en mémoire est "EnumProcessModules"
(mais il faut énumérer les Process auparavant avec "EnumProcesses")

(au passage, c'est la méthode que j'utilise dans "SCANBIN", qui marche très
bien sous NT4!)

L'énumération de process est effectuée en réalité dans la NTDLL.DLL, avec
des API du style "NtQueryInformationProcess" qui NE SONT PAS DOCUMENTÉES
officiellement !

PSAPI sert de passerelle.


EnumProcesses
-------------
The EnumProcesses function retrieves the process identifier for each process
object in the system.

BOOL EnumProcesses(
DWORD * lpidProcess, // array to receive the process identifiers
DWORD cb, // size of the array
DWORD * cbNeeded // receives the number of bytes returned
);

Parameters
lpidProcess
Pointer to an array that receives the list of process identifiers.
cb
Specifies the size, in bytes, of the lpidProcess array.
cbNeeded
Receives the number of bytes returned in the lpidProcess array.

Return Value
If the function succeeds, the return value is nonzero.
If the function fails, the return value is zero.
To get extended error information, call GetLastError.

Remarks
It is a good idea to give EnumProcesses a large array
of DWORD values, because it is hard to predict how many
processes there will be at the time you call EnumProcesses.
To determine how many processes were enumerated by the
call to EnumProcesses, divide the resulting value in
the cbNeeded parameter by sizeof(DWORD).
To obtain process handles for the processes whose
identifiers you have just obtained, call the OpenProcess
function.

OpenProcess
-----------
The OpenProcess function returns a handle
of an existing process object.

HANDLE OpenProcess(
DWORD dwDesiredAccess, // access flag
BOOL bInheritHandle, // handle inheritance flag
DWORD dwProcessId // process identifier
);


Parameters
dwDesiredAccess
Specifies the access to the process object.
For operating systems that support security
checking, this access is checked against any
security descriptor for the target process.
Any combination of the following access flags
can be specified in addition to the
STANDARD_RIGHTS_REQUIRED
access flags:
- PROCESS_ALL_ACCESS
Specifies all possible access flags
for the process object.
- PROCESS_CREATE_PROCESS
Used internally.
- PROCESS_CREATE_THREAD
Enables using the process handle in the
CreateRemoteThread function to create
a thread in the process.
- PROCESS_DUP_HANDLE
Enables using the process handle as
either the source or target process in
the DuplicateHandle function to duplicate
a handle.
- PROCESS_QUERY_INFORMATION
Enables using the process handle in the
GetExitCodeProcess and GetPriorityClass
functions to read information from the
process object.
- PROCESS_SET_INFORMATION
Enables using the process handle in the
SetPriorityClass function to set the
priority class of the process.
- PROCESS_TERMINATE
Enables using the process handle in the
TerminateProcess function to terminate
the process.
- PROCESS_VM_OPERATION
Enables using the process handle in the
VirtualProtectEx and WriteProcessMemory
functions to modify the virtual memory
of the process.
- PROCESS_VM_READ
Enables using the process handle in the
ReadProcessMemory function to read from
the virtual memory of the process.
- PROCESS_VM_WRITE
Enables using the process handle in the
WriteProcessMemory function to write to
the virtual memory of the process.
- SYNCHRONIZE
Windows NT only: Enables using the process
handle in any of the wait functions to wait
for the process to terminate.

bInheritHandle
Specifies whether the returned handle can be
inherited by a new process created by the
current process. If TRUE, the handle is
inheritable.

dwProcessId
Specifies the process identifier of the
process to open.

Return Values
If the function succeeds, the return value is
an open handle of the specified process.
If the function fails, the return value is NULL.
To get extended error information, call GetLastError.

Remarks
The handle returned by the OpenProcess function
can be used in any function that requires a handle
to a process, such as the wait functions, provided
the appropriate access rights were requested.
When you are finished with the handle, be sure to
close it using the CloseHandle function.

EnumProcessModules
------------------
The EnumProcessModules function retrieves a handle for
each module in the specified process.

BOOL EnumProcessModules(
HANDLE hProcess, // handle to the process
HMODULE * lphModule, // array to receive the module handles
DWORD cb, // size of the array
LPDWORD lpcbNeeded // receives the number of bytes returned
);

Parameters
hProcess
Handle to the process.

lphModule
Pointer to the array that receives the list of module handles.

cb
Specifies the size, in bytes, of the lphModule array.

lpcbNeeded
Receives the number of bytes returned
in the lphModule array.

Return Value
If the function succeeds, the return value is nonzero.
If the function fails, the return value is zero.
To get extended error information, call GetLastError.

Remarks
It is a good idea to give EnumProcessModules a large
array of HMODULE values, because it is hard to predict
how many modules there will be in the process at the
time you call EnumProcessModules. To determine how
many modules were enumerated by the call to
EnumProcessModules, divide the resulting value in the
lpcbNeeded parameter by sizeof(HMODULE).

GetModuleFileNameEx
-------------------
The GetModuleFileNameEx function retrieves the
fully qualified path for the specified module.

DWORD GetModuleFileNameEx(
HANDLE hProcess, // handle to the process
HMODULE hModule, // handle to the module
LPTSTR lpFilename, // buffer that receives the path
DWORD nSize // size of the buffer
);

Parameters
hProcess
Handle to the process that contains the module.

hModule
Handle to the module.

lpFilename
Pointer to the buffer that receives the
fully qualified path to the module.

nSize
Specifies the size, in bytes, of the
lpFilename buffer.

Return Value
If the function succeeds, the return value specifies
the length of the string copied to the buffer.
If the function fails, the return value is zero.
To get extended error information, call GetLastError.


Mode opératoire (principe!) :
============================ 1) Enumération de tous les process à l'aide de "EnumProcesses"
2) Le nombre NbProcess de process est obtenu à partir de cbneeded
3) Boucle de 1 à NbProcess d'analyse de chaque process, à l'aide de
"OpenProcess"
3.1) Enumération des modules du process courant à l'aide de
"EnumProcessModules"
3.2) Le nombre NbModules de modules est obtenu à partir de
lpcbNeeded
3.3) Boucle de 1 à NbModules d'extraction du nom de chaque
module à l'aide de "GetModuleFileNameEx"

Pour plus d'infos :
============ http://msdn.microsoft.com/library/default.asp?url=/library/en-us/perfmon/base/about_psapi.asp


Enumération de processus :
http://msdn.microsoft.com/library/en-us/perfmon/base/enumerating_all_processes.asp


Enumération de modules :
http://msdn.microsoft.com/library/en-us/perfmon/base/enumerating_all_modules_for_a_process.asp

Les fonctions de PSAPI :
http://msdn.microsoft.com/library/en-us/perfmon/base/psapi_functions.asp


Les structures utilisées avec PSAPI :
http://msdn.microsoft.com/library/en-us/perfmon/base/psapi_structures.asp

Téléchargement de PSAPI.DLL :
http://www.microsoft.com/downloads/release.asp?releaseid0337 (122 ko)


NB: j'ai vérifé, tous ces liens sont actifs à ce jour (avec Microsoft, il
faut toujours se méfier, surtout avec des liens qui datent de 6 ans !)


PS : PSAPI.DLL est par contre fournie d'origine avec W2K et au delà !

Donc si on veut développer une appli uniquement "famille NT" (de NT4 à
W2K3), on peut décider de n'utiliser que les fonctions de PSAPI (en laissant
tomber Process32First, ...) , ainsi on n'aura pas de test à effectuer sur la
version de l'OS.

--
May the Force be with You!
La Connaissance s'accroît quand on la partage
----------------------------------------------------------
Jean-Claude BELLAMY [MVP] - http://www.bellamyjc.org
Jean-Claude.Bellamy@wanadoo.fr * JC.Bellamy@free.fr

> Non, la Tool Help Library n'est pas disponible sous NT 4

Ah oui NT4, j'avais pas vu.
A ma connaissance on peut pas connaitre de manière directe en Win32 le
parent d'un process donné. Faut passer par l'API native sous NT
(NtQueryInformationProcess).
http://www.codeguru.com/Cpp/W-P/win32/article.php/c1437/

--
Aurélien REGAT-BARREL

Aurélien REGAT-BARREL a écrit :

Non, la Tool Help Library n'est pas disponible sous NT 4

Ah oui NT4, j'avais pas vu.
A ma connaissance on peut pas connaitre de manière directe en Win32 le
parent d'un process donné. Faut passer par l'API native sous NT
(NtQueryInformationProcess).
http://www.codeguru.com/Cpp/W-P/win32/article.php/c1437/

Génial!
Merci à tous pour vos réponses...

Je vais essayer ça de ce pas.

Fred

Fred wrote:

Bonjour,

J'aurais aimé savoir s'il y avait une façon sioux de réccupérer

la liste

des PID des ascendants d'un process?

Juste une remarque : sous NT, il n'y a pas de notion de relation
père/fils entre processus comme sous Unix (la notion de process zombie
n'existe pas par exemple), donc ta question n'a quelque part pas de
sens.
La structure qui décrit un processus au niveau du kernel (EPROCESS) a
bien un champ "Parent Process ID", mais il contient juste le PID du
processus qui a créé le procesus courant : c'est bien le processus
"père" en un sens, sauf qu'il se peut très bien que le processus
père en question soit terminé depuis belle lurette au moment où tu
fais ton énumération, et que son PID ait été recyclé et utilisé
pour un autre processus qui a été démarré après : tu ne peux donc
pas être sûr de la justesse de ton arbre de processus.

Je ne connais pas les détails sous 95/98/Me, mais ce doit être assez
similaire.

Arnaud

Jean-Claude BELLAMY wrote:

L'énumération de process est effectuée en réalité dans la NTDLL.DLL, avec
des API du style "NtQueryInformationProcess" qui NE SONT PAS DOCUMENTÉES
officiellement !

NtQueryInformationProcess() et quelques autres sont "documentées" ds
MSDN depuis fin 2002-début 2003 (Antitrust Settlement),
mais la doc est incomplète et fausse (par ex, c'est soi-disant
uniquement 2K/XP alors que NT l'utilise depuis les premières versions
(Gina par ex))

> Juste une remarque : sous NT, il n'y a pas de notion de relation
père/fils entre processus comme sous Unix (la notion de process zombie
n'existe pas par exemple), donc ta question n'a quelque part pas de
sens.
La structure qui décrit un processus au niveau du kernel (EPROCESS) a
bien un champ "Parent Process ID", mais il contient juste le PID du
processus qui a créé le procesus courant : c'est bien le processus
"père" en un sens, sauf qu'il se peut très bien que le processus
père en question soit terminé depuis belle lurette au moment où tu
fais ton énumération, et que son PID ait été recyclé et utilisé
pour un autre processus qui a été démarré après : tu ne peux donc
pas être sûr de la justesse de ton arbre de processus.

Je ne connais pas les détails sous 95/98/Me, mais ce doit être assez
similaire.

Arnaud a raison et sous Win9X, c'est pareil. Sous Win32, il y a une
notion d'héritage des handles mais pas de filiation.

Le risque de recyclage peu être éliminé par programme si le processus
"fils" garde une référence en permanence sur le processus "parent". Tant
que le CloseHandle sur le handle du processus "parent" n'est pas fait,
l'objet kernel n'est pas détruit et le PID ne sera pas recyclé même si
le programme en question est terminé.

--
Patrick Philippot - Microsoft MVP
MainSoft Consulting Services
www.mainsoft.fr