[bb] Process Tree by BlitzSupport [ 1+ years ago ]

[BlitzBot]

Title : Process Tree
Author : BlitzSupport
Posted : 1+ years ago

Description : This program reads the list of running processes and displays them in a tree view, showing how child processes were spawned.

Code :

Code: BlitzBasic

1. ; -----------------------------------------------------------------------------
2. ; Process list... see which processes spawned which programs!
3. ; -----------------------------------------------------------------------------
4.  
5. ; Works for me under Windows 2000, anyway...
6.  
7. ; -----------------------------------------------------------------------------
8. ; ADD TO kernel32.decls IN USERLIBS FOLDER!
9. ; -----------------------------------------------------------------------------
10.  
11. ; .lib "kernel32.dll"
12.  
13. ; CreateToolhelp32Snapshot% (flags, th32processid)
14. ; Process32First% (snapshot, entry*)
15. ; Process32Next% (snapshot, entry*)
16. ; Module32First% (snapshot, entry*)
17. ; Module32Next% (snapshot, entry*)
18. ; Thread32First% (snapshot, entry*)
19. ; Thread32Next% (snapshot, entry*)
20. ; Heap32First% (snapshot, entry*, th32heapid)
21. ; Heap32Next% (entry*)
22. ; Heap32ListFirst% (snapshot, entry*)
23. ; Heap32ListNext% (snapshot, entry*)
24. ; Toolhelp32ReadProcessMemory% (th32processid, baseaddress, buffer*, ReadBytes, bytesread)
25. ; CloseHandle% (Object)
26.  
27. ; -----------------------------------------------------------------------------
28. ; PROCESSENTRY32 structure hack...
29. ; -----------------------------------------------------------------------------
30. ; Hopefully won't have to do this in BlitzMax... hint hint, Mark... :)
31. ; -----------------------------------------------------------------------------
32.  
33. Const SizeOf_PE32 = 296
34.  
35. Type PE32
36.  
37.         Field bank
38.        
39. ;    dwSize.l
40. ;    cntUsage.l
41. ;    th32ProcessID.l
42. ;    th32DefaultHeapID.l
43. ;    th32ModuleID.l
44. ;    cntThreads.l
45. ;    th32ParentProcessID.l
46. ;    pcPriClassBase.l
47. ;    dwFlags.l
48. ;    szExeFile.b [#MAX_PATH]
49.  
50. End Type
51.  
52. ; -----------------------------------------------------------------------------
53.  
54. ; -----------------------------------------------------------------------------
55. ; Create a new 'process' list entry...
56. ; -----------------------------------------------------------------------------
57.  
58. Function CreatePE32.PE32 ()
59.         p.PE32 = New PE32
60.         pank = CreateBank (SizeOf_PE32)
61.         If pank
62.                 PokeInt pank, 0, SizeOf_PE32
63.         Else
64.                 Delete p
65.                 Return Null
66.         EndIf
67.         Return p
68. End Function
69.  
70. ; -----------------------------------------------------------------------------
71. ; Free process list entry...
72. ; -----------------------------------------------------------------------------
73.  
74. Function FreePE32 (p.PE32)
75.         If pank
76.                 FreeBank pank
77.         EndIf
78.         Delete p
79. End Function
80.  
81. ; -----------------------------------------------------------------------------
82. ; Redundant info...
83. ; -----------------------------------------------------------------------------
84.  
85. Function PrintProc (bank)
86.         Print ""
87.         Print "Name    : " + ProcessName$ (bank)
88.         Print "Usage   : " + PeekInt (bank, 4)
89.         Print "Proc ID : " + PeekInt (bank, 8)
90.         Print "Heap ID : " + PeekInt (bank, 12)
91.         Print "Mod  ID : " + PeekInt (bank, 16)
92.         Print "Threads : " + PeekInt (bank, 20)
93.         Print "Parent  : " + PeekInt (bank, 24)
94.         Print "ClasBas : " + PeekInt (bank, 28)
95.         Print "Flags   : " + PeekInt (bank, 32)
96. End Function
97.  
98. ; -----------------------------------------------------------------------------
99. ; Eeuurrggghhhh... leech process name from bank...
100. ; -----------------------------------------------------------------------------
101.  
102. Function ProcessName$ (bank)
103.         For s = 36 To BankSize (bank) - 1
104.                 byte = PeekByte (bank, s)
105.                 If byte
106.                         result$ = result$ + Chr (byte)
107.                 Else
108.                         Exit
109.                 EndIf
110.         Next
111.         Return result$
112. End Function
113.  
114. Global PROC_COUNT
115.  
116. ; -----------------------------------------------------------------------------
117. ; Constants required by process functions, etc...
118. ; -----------------------------------------------------------------------------
119.  
120. Const TH32CS_SNAPHEAPLIST = $1
121. Const TH32CS_SNAPPROCESS = $2
122. Const TH32CS_SNAPTHREAD = $4
123. Const TH32CS_SNAPMODULE = $8
124. Const TH32CS_SNAPALL = (TH32CS_SNAPHEAPLIST Or TH32CS_SNAPPROCESS Or TH32CS_SNAPTHREAD Or TH32CS_SNAPMODULE)
125. Const TH32CS_INHERIT = $80000000
126. Const INVALID_HANDLE_VALUE = -1
127. Const MAX_PATH = 260
128.  
129. ; -----------------------------------------------------------------------------
130. ; Take snapshot of running processes...
131. ; -----------------------------------------------------------------------------
132.  
133. Function CreateProcessList ()
134.         PROC_COUNT = 0
135.         Return CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0)
136. End Function
137.  
138. ; -----------------------------------------------------------------------------
139. ; Free list of processes (created via CreateProcessList and GetProcesses)...
140. ; -----------------------------------------------------------------------------
141.  
142. Function FreeProcessList (snap)
143.         For p.PE32 = Each PE32
144.                 FreePE32 (p)
145.         Next
146.         CloseHandle (snap)
147.         PROC_COUNT = 0
148. End Function
149.  
150. Function GetProcesses (snap)
151.  
152.         PROC_COUNT = 0
153.        
154.         ; Check snapshot is valid...
155.        
156.         If snap <> INVALID_HANDLE_VALUE
157.                
158.                 ; Hack up a PE32 (PROCESSENTRY32) structure...
159.                
160.                 p.PE32 = CreatePE32 ()
161.                
162.                 ; Find the first process, stick info into PE32 bank...
163.                
164.                 If Process32First (snap, pank)
165.        
166.                         ; Increase global process counter...
167.                        
168.                         PROC_COUNT = PROC_COUNT + 1
169.                        
170.                         Repeat
171.                
172.                                 ; Create a new PE32 structure for every following process...
173.                                
174.                                 p.PE32 = CreatePE32 ()
175.                                
176.                                 ; Find the next process, stick into PE32 bank...
177.                                
178.                                 nextproc = Process32Next (snap, pank)
179.                
180.                                 ; Got one? Increase process count. If not, free the last PE32 structure...
181.                                
182.                                 If nextproc                    
183.                                         PROC_COUNT = PROC_COUNT + 1
184.                                 Else
185.                                         FreePE32 (p)
186.                                 EndIf
187.                                
188.                         ; OK, no more processes...
189.                        
190.                         Until nextproc = 0
191.                        
192.                 Else
193.                
194.                         ; No first process found, so delete the PE32 structure it used...
195.                        
196.                         FreePE32 (p)
197.                         Return False
198.                        
199.                 EndIf
200.                                
201.                 Return True
202.        
203.         Else
204.        
205.                 Return False
206.                
207.         EndIf
208.        
209. End Function
210.  
211. ; -----------------------------------------------------------------------------
212. ; Used to create a list of treeview nodes...
213. ; -----------------------------------------------------------------------------
214.  
215. Type Node
216.         Field node
217. End Type
218.  
219. ; -----------------------------------------------------------------------------
220. ; Fill treeview gadget...
221. ; -----------------------------------------------------------------------------
222.  
223. Function FillProcessTree (root)
224.  
225.         snap = CreateProcessList ()
226.  
227.         If GetProcesses (snap)
228.        
229.                 For p.PE32 = Each PE32
230.                         pid = PeekInt (pank, 8)
231.                         parent = PeekInt (pank, 24)
232.                         proc$ = ProcessName$ (pank)
233.                         n.Node = New Node
234.                         n
235. ode = AddTreeViewNode (proc$, root)
236.                         CompareProcs (p, n
237. ode)
238.                 Next
239.        
240.                 FreeProcessList (snap)
241.  
242.         Else
243.                 Notify "Failed to create process list!", True
244.         EndIf                  
245.  
246. End Function
247.  
248. ; -----------------------------------------------------------------------------
249. ; Find child processes (ah, the joys of trial and error)...
250. ; -----------------------------------------------------------------------------
251.  
252. Function CompareProcs (p.PE32, node)
253.  
254.         For q.PE32 = Each PE32
255.                
256.                 If p <> q
257.                
258.                         pid             = PeekInt (pank, 8)
259.                         qid             = PeekInt (qank, 8)
260.                         qparent = PeekInt (qank, 24)
261.                
262.                         If pid = qparent
263.                        
264.                                 proc$ = ProcessName (qank)
265.                                 n.Node = New Node
266.                                 n
267. ode = AddTreeViewNode (proc$, node)
268.                                 CompareProcs (q, n
269. ode)
270.                                 Delete q
271.                                
272.                         EndIf
273.                
274.                 EndIf
275.                
276.         Next
277.        
278. End Function
279.  
280. ; -----------------------------------------------------------------------------
281. ; D E M O . . .
282. ; -----------------------------------------------------------------------------
283.  
284. ; Slight oddity: if it crashes, try sticking a second's Delay () in here. Seems
285. ; to sometimes do this when run from the IDE (maybe snapshotting while a process
286. ; is being spawned is buggy in Windoze? That's my story and I'm sticking to it)...
287.  
288. AppTitle "Process Tree..."
289.  
290. window = CreateWindow ("Process Tree...", 300, 200, 500, 350)
291.  
292. tree = CreateTreeView (0, 0, ClientWidth (window), ClientHeight (window) - 30, window)
293. root = TreeViewRoot (tree)
294. SetGadgetLayout tree, 1, 1, 1, 1
295.  
296. button = CreateButton ("Refresh list", 0, ClientHeight (window) - 25, 150, 21, window)
297. SetGadgetLayout button, 1, 0, 0, 1
298.  
299. menu = CreateMenu ("&File", 0, WindowMenu (window))
300. CreateMenu "&Refresh", 1, menu
301. CreateMenu "", 2, menu
302. CreateMenu "&About", 3, menu
303. CreateMenu "E&xit", 4, menu
304. UpdateWindowMenu window
305.  
306. FillProcessTree (root)
307.  
308. Repeat
309.  
310.         Select WaitEvent ()
311.        
312.                 Case $803
313.                         End
314.                
315.                 Case $1001
316.                         Select EventData ()
317.                                 Case 1
318.                                         FreeGadget tree
319.                                         tree = CreateTreeView (0, 0, ClientWidth (window), ClientHeight (window) - 30, window)
320.                                         root = TreeViewRoot (tree)
321.                                         SetGadgetLayout tree, 1, 1, 1, 1
322.                                         FillProcessTree (root)
323.  
324.                                 Case 3
325.                                         Notify "Process Tree..." + Chr (10) + Chr (10) + "An amazing Hi-Toro production, public domain 2003."
326.                                        
327.                                 Case 4
328.                                         End
329.  
330.                         End Select
331.                 Case $401
332.                
333.                         Select EventSource ()
334.  
335.                                 Case button
336.                                
337.                                         FreeGadget tree
338.                                         tree = CreateTreeView (0, 0, ClientWidth (window), ClientHeight (window) - 30, window)
339.                                         root = TreeViewRoot (tree)
340.                                         SetGadgetLayout tree, 1, 1, 1, 1
341.                                         FillProcessTree (root)
342.  
343.                         End Select
344.                        
345.         End Select
346.  
347. Forever

Comments : none...