Moved GlobalMasterHandle to global16.c.
[wine] / dlls / kernel / toolhelp.c
1 /*
2  * Misc Toolhelp functions
3  *
4  * Copyright 1996 Marcus Meissner
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #ifdef HAVE_UNISTD_H
27 # include <unistd.h>
28 #endif
29 #include <ctype.h>
30 #include <assert.h>
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winerror.h"
34 #include "tlhelp32.h"
35 #include "wine/server.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(toolhelp);
40
41
42 /***********************************************************************
43  *           CreateToolhelp32Snapshot                   (KERNEL32.@)
44  */
45 HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
46 {
47     HANDLE ret;
48
49     TRACE("%lx,%lx\n", flags, process );
50     if (!(flags & (TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)))
51     {
52         FIXME("flags %lx not implemented\n", flags );
53         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
54         return INVALID_HANDLE_VALUE;
55     }
56
57     /* Now do the snapshot */
58     SERVER_START_REQ( create_snapshot )
59     {
60         req->flags = 0;
61         if (flags & TH32CS_SNAPMODULE)   req->flags |= SNAP_MODULE;
62         if (flags & TH32CS_SNAPPROCESS)  req->flags |= SNAP_PROCESS;
63         if (flags & TH32CS_SNAPTHREAD)   req->flags |= SNAP_THREAD;
64     
65         req->inherit = (flags & TH32CS_INHERIT) != 0;
66         req->pid     = process;
67         wine_server_call_err( req );
68         ret = reply->handle;
69     }
70     SERVER_END_REQ;
71     if (!ret) ret = INVALID_HANDLE_VALUE;
72     return ret;
73 }
74
75
76 /***********************************************************************
77  *              TOOLHELP_Thread32Next
78  *
79  * Implementation of Thread32First/Next
80  */
81 static BOOL TOOLHELP_Thread32Next( HANDLE handle, LPTHREADENTRY32 lpte, BOOL first )
82 {
83     BOOL ret;
84
85     if (lpte->dwSize < sizeof(THREADENTRY32))
86     {
87         SetLastError( ERROR_INSUFFICIENT_BUFFER );
88         ERR("Result buffer too small (%ld)\n", lpte->dwSize);
89         return FALSE;
90     }
91     SERVER_START_REQ( next_thread )
92     {
93         req->handle = handle;
94         req->reset = first;
95         if ((ret = !wine_server_call_err( req )))
96         {
97             lpte->cntUsage           = reply->count;
98             lpte->th32ThreadID       = (DWORD)reply->tid;
99             lpte->th32OwnerProcessID = (DWORD)reply->pid;
100             lpte->tpBasePri          = reply->base_pri;
101             lpte->tpDeltaPri         = reply->delta_pri;
102             lpte->dwFlags            = 0;  /* SDK: "reserved; do not use" */
103         }
104     }
105     SERVER_END_REQ;
106     return ret;
107 }
108
109 /***********************************************************************
110  *              Thread32First    (KERNEL32.@)
111  *
112  * Return info about the first thread in a toolhelp32 snapshot
113  */
114 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
115 {
116     return TOOLHELP_Thread32Next(hSnapshot, lpte, TRUE);
117 }
118
119 /***********************************************************************
120  *              Thread32Next   (KERNEL32.@)
121  *
122  * Return info about the "next" thread in a toolhelp32 snapshot
123  */
124 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
125 {
126     return TOOLHELP_Thread32Next(hSnapshot, lpte, FALSE);
127 }
128
129 /***********************************************************************
130  *              TOOLHELP_Process32Next
131  *
132  * Implementation of Process32First/Next. Note that the ANSI / Unicode
133  * version check is a bit of a hack as it relies on the fact that only
134  * the last field is actually different.
135  */
136 static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32W lppe, BOOL first, BOOL unicode )
137 {
138     BOOL ret;
139     WCHAR exe[MAX_PATH-1];
140     DWORD len, sz;
141
142     sz = unicode ? sizeof(PROCESSENTRY32W) : sizeof(PROCESSENTRY32);
143     if (lppe->dwSize < sz)
144     {
145         SetLastError( ERROR_INSUFFICIENT_BUFFER );
146         ERR("Result buffer too small (req: %ld, was: %ld)\n", sz, lppe->dwSize);
147         return FALSE;
148     }
149
150     SERVER_START_REQ( next_process )
151     {
152         req->handle = handle;
153         req->reset = first;
154         wine_server_set_reply( req, exe, sizeof(exe) );
155         if ((ret = !wine_server_call_err( req )))
156         {
157             lppe->cntUsage            = reply->count;
158             lppe->th32ProcessID       = reply->pid;
159             lppe->th32DefaultHeapID   = (DWORD)reply->heap;
160             lppe->th32ModuleID        = (DWORD)reply->module;
161             lppe->cntThreads          = reply->threads;
162             lppe->th32ParentProcessID = reply->ppid;
163             lppe->pcPriClassBase      = reply->priority;
164             lppe->dwFlags             = -1; /* FIXME */
165             if (unicode)
166             {
167                 len = wine_server_reply_size(reply) / sizeof(WCHAR);
168                 memcpy(lppe->szExeFile, reply, wine_server_reply_size(reply));
169                 lppe->szExeFile[len] = 0;
170             }
171             else
172             {
173                 LPPROCESSENTRY32 lppe_a = (LPPROCESSENTRY32) lppe;
174
175                 len = WideCharToMultiByte( CP_ACP, 0, exe, wine_server_reply_size(reply) / sizeof(WCHAR),
176                                            lppe_a->szExeFile, sizeof(lppe_a->szExeFile)-1, NULL, NULL );
177                 lppe_a->szExeFile[len] = 0;
178             }
179         }
180     }
181     SERVER_END_REQ;
182     return ret;
183 }
184
185
186 /***********************************************************************
187  *              Process32First    (KERNEL32.@)
188  *
189  * Return info about the first process in a toolhelp32 snapshot
190  */
191 BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
192 {
193     return TOOLHELP_Process32Next( hSnapshot, (LPPROCESSENTRY32W) lppe, TRUE, FALSE /* ANSI */ );
194 }
195
196 /***********************************************************************
197  *              Process32Next   (KERNEL32.@)
198  *
199  * Return info about the "next" process in a toolhelp32 snapshot
200  */
201 BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
202 {
203     return TOOLHELP_Process32Next( hSnapshot, (LPPROCESSENTRY32W) lppe, FALSE, FALSE /* ANSI */ );
204 }
205
206 /***********************************************************************
207  *              Process32FirstW    (KERNEL32.@)
208  *
209  * Return info about the first process in a toolhelp32 snapshot
210  */
211 BOOL WINAPI Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
212 {
213     return TOOLHELP_Process32Next( hSnapshot, lppe, TRUE, TRUE /* Unicode */ );
214 }
215
216 /***********************************************************************
217  *              Process32NextW   (KERNEL32.@)
218  *
219  * Return info about the "next" process in a toolhelp32 snapshot
220  */
221 BOOL WINAPI Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
222 {
223     return TOOLHELP_Process32Next( hSnapshot, lppe, FALSE, TRUE /* Unicode */ );
224 }
225
226
227 /***********************************************************************
228  *              TOOLHELP_Module32NextW
229  *
230  * Implementation of Module32First/Next
231  */
232 static BOOL TOOLHELP_Module32NextW( HANDLE handle, LPMODULEENTRY32W lpme, BOOL first )
233 {
234     BOOL ret;
235     WCHAR exe[MAX_PATH];
236     DWORD len;
237
238     if (lpme->dwSize < sizeof (MODULEENTRY32W))
239     {
240         SetLastError( ERROR_INSUFFICIENT_BUFFER );
241         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32W), lpme->dwSize);
242         return FALSE;
243     }
244     SERVER_START_REQ( next_module )
245     {
246         req->handle = handle;
247         req->reset = first;
248         wine_server_set_reply( req, exe, sizeof(exe) );
249         if ((ret = !wine_server_call_err( req )))
250         {
251             const WCHAR* ptr;
252             lpme->th32ModuleID   = 1; /* toolhelp internal id, never used */
253             lpme->th32ProcessID  = reply->pid;
254             lpme->GlblcntUsage   = 0xFFFF; /* FIXME */
255             lpme->ProccntUsage   = 0xFFFF; /* FIXME */
256             lpme->modBaseAddr    = reply->base;
257             lpme->modBaseSize    = reply->size;
258             lpme->hModule        = reply->base;
259             len = wine_server_reply_size(reply) / sizeof(WCHAR);
260             memcpy(lpme->szExePath, exe, wine_server_reply_size(reply));
261             lpme->szExePath[len] = 0;
262             if ((ptr = strrchrW(lpme->szExePath, '\\'))) ptr++;
263             else ptr = lpme->szExePath;
264             lstrcpynW( lpme->szModule, ptr, sizeof(lpme->szModule)/sizeof(lpme->szModule[0]));
265         }
266     }
267     SERVER_END_REQ;
268     return ret;
269 }
270
271 /***********************************************************************
272  *              TOOLHELP_Module32NextA
273  *
274  * Implementation of Module32First/Next
275  */
276 static BOOL TOOLHELP_Module32NextA( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
277 {
278     BOOL ret;
279     MODULEENTRY32W mew;
280     
281     if (lpme->dwSize < sizeof (MODULEENTRY32))
282     {
283         SetLastError( ERROR_INSUFFICIENT_BUFFER );
284         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
285         return FALSE;
286     }
287     
288     mew.dwSize = sizeof(mew);
289     if ((ret = TOOLHELP_Module32NextW( handle, &mew, first )))
290     {
291         lpme->th32ModuleID  = mew.th32ModuleID;
292         lpme->th32ProcessID = mew.th32ProcessID;
293         lpme->GlblcntUsage  = mew.GlblcntUsage;
294         lpme->ProccntUsage  = mew.ProccntUsage;
295         lpme->modBaseAddr   = mew.modBaseAddr;
296         lpme->hModule       = mew.hModule;
297         WideCharToMultiByte( CP_ACP, 0, mew.szModule, -1, lpme->szModule, sizeof(lpme->szModule), NULL, NULL );
298         WideCharToMultiByte( CP_ACP, 0, mew.szExePath, -1, lpme->szExePath, sizeof(lpme->szExePath), NULL, NULL );
299     }
300     return ret;
301 }
302
303 /***********************************************************************
304  *              Module32FirstW   (KERNEL32.@)
305  *
306  * Return info about the "first" module in a toolhelp32 snapshot
307  */
308 BOOL WINAPI Module32FirstW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
309 {
310     return TOOLHELP_Module32NextW( hSnapshot, lpme, TRUE );
311 }
312
313 /***********************************************************************
314  *              Module32First   (KERNEL32.@)
315  *
316  * Return info about the "first" module in a toolhelp32 snapshot
317  */
318 BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
319 {
320     return TOOLHELP_Module32NextA( hSnapshot, lpme, TRUE );
321 }
322
323 /***********************************************************************
324  *              Module32NextW   (KERNEL32.@)
325  *
326  * Return info about the "next" module in a toolhelp32 snapshot
327  */
328 BOOL WINAPI Module32NextW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
329 {
330     return TOOLHELP_Module32NextW( hSnapshot, lpme, FALSE );
331 }
332
333 /***********************************************************************
334  *              Module32Next   (KERNEL32.@)
335  *
336  * Return info about the "next" module in a toolhelp32 snapshot
337  */
338 BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
339 {
340     return TOOLHELP_Module32NextA( hSnapshot, lpme, FALSE );
341 }
342
343 /************************************************************************
344  *              Heap32ListFirst (KERNEL32.@)
345  *
346  */
347 BOOL WINAPI Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
348 {
349     FIXME(": stub\n");
350     return FALSE;
351 }
352
353 /******************************************************************
354  *              Toolhelp32ReadProcessMemory (KERNEL32.@)
355  *
356  *
357  */
358 BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD pid, const void* base,
359                                         void* buf, SIZE_T len, SIZE_T* r)
360 {
361     HANDLE h;
362     BOOL   ret = FALSE;
363
364     h = (pid) ? OpenProcess(PROCESS_VM_READ, FALSE, pid) : GetCurrentProcess();
365     if (h != NULL)
366     {
367         ret = ReadProcessMemory(h, base, buf, len, r);
368         if (pid) CloseHandle(h);
369     }
370     return ret;
371 }