2 * Misc Toolhelp functions
4 * Copyright 1996 Marcus Meissner
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.
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.
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
36 #include "wine/server.h"
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(toolhelp);
43 /***********************************************************************
44 * CreateToolhelp32Snapshot (KERNEL32.@)
46 HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
50 TRACE("%lx,%lx\n", flags, process );
51 if (!(flags & (TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)))
53 FIXME("flags %lx not implemented\n", flags );
54 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
55 return INVALID_HANDLE_VALUE;
58 /* Now do the snapshot */
59 SERVER_START_REQ( create_snapshot )
62 if (flags & TH32CS_SNAPMODULE) req->flags |= SNAP_MODULE;
63 if (flags & TH32CS_SNAPPROCESS) req->flags |= SNAP_PROCESS;
64 if (flags & TH32CS_SNAPTHREAD) req->flags |= SNAP_THREAD;
66 req->inherit = (flags & TH32CS_INHERIT) != 0;
68 wine_server_call_err( req );
72 if (!ret) ret = INVALID_HANDLE_VALUE;
77 /***********************************************************************
78 * TOOLHELP_Thread32Next
80 * Implementation of Thread32First/Next
82 static BOOL TOOLHELP_Thread32Next( HANDLE handle, LPTHREADENTRY32 lpte, BOOL first )
86 if (lpte->dwSize < sizeof(THREADENTRY32))
88 SetLastError( ERROR_INSUFFICIENT_BUFFER );
89 ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(THREADENTRY32), lpte->dwSize);
92 SERVER_START_REQ( next_thread )
96 if ((ret = !wine_server_call_err( req )))
98 lpte->cntUsage = reply->count;
99 lpte->th32ThreadID = (DWORD)reply->tid;
100 lpte->th32OwnerProcessID = (DWORD)reply->pid;
101 lpte->tpBasePri = reply->base_pri;
102 lpte->tpDeltaPri = reply->delta_pri;
103 lpte->dwFlags = 0; /* SDK: "reserved; do not use" */
110 /***********************************************************************
111 * Thread32First (KERNEL32.@)
113 * Return info about the first thread in a toolhelp32 snapshot
115 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
117 return TOOLHELP_Thread32Next(hSnapshot, lpte, TRUE);
120 /***********************************************************************
121 * Thread32Next (KERNEL32.@)
123 * Return info about the "next" thread in a toolhelp32 snapshot
125 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
127 return TOOLHELP_Thread32Next(hSnapshot, lpte, FALSE);
130 /***********************************************************************
131 * TOOLHELP_Process32Next
133 * Implementation of Process32First/Next. Note that the ANSI / Unicode
134 * version check is a bit of a hack as it relies on the fact that only
135 * the last field is actually different.
137 static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32W lppe, BOOL first, BOOL unicode )
140 WCHAR exe[MAX_PATH-1];
145 if (lppe->dwSize < sizeof(PROCESSENTRY32W))
147 SetLastError( ERROR_INSUFFICIENT_BUFFER );
148 ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32W), lppe->dwSize);
154 if (lppe->dwSize < sizeof(PROCESSENTRY32))
156 SetLastError( ERROR_INSUFFICIENT_BUFFER );
157 ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32), lppe->dwSize);
161 SERVER_START_REQ( next_process )
163 req->handle = handle;
165 wine_server_set_reply( req, exe, sizeof(exe) );
166 if ((ret = !wine_server_call_err( req )))
168 lppe->cntUsage = reply->count;
169 lppe->th32ProcessID = reply->pid;
170 lppe->th32DefaultHeapID = (DWORD)reply->heap;
171 lppe->th32ModuleID = (DWORD)reply->module;
172 lppe->cntThreads = reply->threads;
173 lppe->th32ParentProcessID = reply->ppid;
174 lppe->pcPriClassBase = reply->priority;
175 lppe->dwFlags = -1; /* FIXME */
178 len = wine_server_reply_size(reply) / sizeof(WCHAR);
179 memcpy(lppe->szExeFile, reply, wine_server_reply_size(reply));
180 lppe->szExeFile[len] = 0;
184 LPPROCESSENTRY32 lppe_a = (LPPROCESSENTRY32) lppe;
186 len = WideCharToMultiByte( CP_ACP, 0, exe, wine_server_reply_size(reply) / sizeof(WCHAR),
187 lppe_a->szExeFile, sizeof(lppe_a->szExeFile)-1, NULL, NULL );
188 lppe_a->szExeFile[len] = 0;
197 /***********************************************************************
198 * Process32First (KERNEL32.@)
200 * Return info about the first process in a toolhelp32 snapshot
202 BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
204 return TOOLHELP_Process32Next( hSnapshot, (LPPROCESSENTRY32W) lppe, TRUE, FALSE /* ANSI */ );
207 /***********************************************************************
208 * Process32Next (KERNEL32.@)
210 * Return info about the "next" process in a toolhelp32 snapshot
212 BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
214 return TOOLHELP_Process32Next( hSnapshot, (LPPROCESSENTRY32W) lppe, FALSE, FALSE /* ANSI */ );
217 /***********************************************************************
218 * Process32FirstW (KERNEL32.@)
220 * Return info about the first process in a toolhelp32 snapshot
222 BOOL WINAPI Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
224 return TOOLHELP_Process32Next( hSnapshot, lppe, TRUE, TRUE /* Unicode */ );
227 /***********************************************************************
228 * Process32NextW (KERNEL32.@)
230 * Return info about the "next" process in a toolhelp32 snapshot
232 BOOL WINAPI Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
234 return TOOLHELP_Process32Next( hSnapshot, lppe, FALSE, TRUE /* Unicode */ );
238 /***********************************************************************
239 * TOOLHELP_Module32NextW
241 * Implementation of Module32First/Next
243 static BOOL TOOLHELP_Module32NextW( HANDLE handle, LPMODULEENTRY32W lpme, BOOL first )
249 if (lpme->dwSize < sizeof (MODULEENTRY32W))
251 SetLastError( ERROR_INSUFFICIENT_BUFFER );
252 ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32W), lpme->dwSize);
255 SERVER_START_REQ( next_module )
257 req->handle = handle;
259 wine_server_set_reply( req, exe, sizeof(exe) );
260 if ((ret = !wine_server_call_err( req )))
263 lpme->th32ModuleID = 1; /* toolhelp internal id, never used */
264 lpme->th32ProcessID = reply->pid;
265 lpme->GlblcntUsage = 0xFFFF; /* FIXME */
266 lpme->ProccntUsage = 0xFFFF; /* FIXME */
267 lpme->modBaseAddr = reply->base;
268 lpme->modBaseSize = reply->size;
269 lpme->hModule = reply->base;
270 len = wine_server_reply_size(reply) / sizeof(WCHAR);
271 memcpy(lpme->szExePath, exe, wine_server_reply_size(reply));
272 lpme->szExePath[len] = 0;
273 if ((ptr = strrchrW(lpme->szExePath, '\\'))) ptr++;
274 else ptr = lpme->szExePath;
275 lstrcpynW( lpme->szModule, ptr, sizeof(lpme->szModule)/sizeof(lpme->szModule[0]));
282 /***********************************************************************
283 * TOOLHELP_Module32NextA
285 * Implementation of Module32First/Next
287 static BOOL TOOLHELP_Module32NextA( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
292 if (lpme->dwSize < sizeof (MODULEENTRY32))
294 SetLastError( ERROR_INSUFFICIENT_BUFFER );
295 ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
299 mew.dwSize = sizeof(mew);
300 if ((ret = TOOLHELP_Module32NextW( handle, &mew, first )))
302 lpme->th32ModuleID = mew.th32ModuleID;
303 lpme->th32ProcessID = mew.th32ProcessID;
304 lpme->GlblcntUsage = mew.GlblcntUsage;
305 lpme->ProccntUsage = mew.ProccntUsage;
306 lpme->modBaseAddr = mew.modBaseAddr;
307 lpme->hModule = mew.hModule;
308 WideCharToMultiByte( CP_ACP, 0, mew.szModule, -1, lpme->szModule, sizeof(lpme->szModule), NULL, NULL );
309 WideCharToMultiByte( CP_ACP, 0, mew.szExePath, -1, lpme->szExePath, sizeof(lpme->szExePath), NULL, NULL );
314 /***********************************************************************
315 * Module32FirstW (KERNEL32.@)
317 * Return info about the "first" module in a toolhelp32 snapshot
319 BOOL WINAPI Module32FirstW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
321 return TOOLHELP_Module32NextW( hSnapshot, lpme, TRUE );
324 /***********************************************************************
325 * Module32First (KERNEL32.@)
327 * Return info about the "first" module in a toolhelp32 snapshot
329 BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
331 return TOOLHELP_Module32NextA( hSnapshot, lpme, TRUE );
334 /***********************************************************************
335 * Module32NextW (KERNEL32.@)
337 * Return info about the "next" module in a toolhelp32 snapshot
339 BOOL WINAPI Module32NextW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
341 return TOOLHELP_Module32NextW( hSnapshot, lpme, FALSE );
344 /***********************************************************************
345 * Module32Next (KERNEL32.@)
347 * Return info about the "next" module in a toolhelp32 snapshot
349 BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
351 return TOOLHELP_Module32NextA( hSnapshot, lpme, FALSE );
354 /************************************************************************
355 * GlobalMasterHandle (KERNEL.28)
358 * Should return selector and handle of the information structure for
359 * the global heap. selector and handle are stored in the THHOOK as
360 * pGlobalHeap and hGlobalHeap.
361 * As Wine doesn't have this structure, we return both values as zero
362 * Applications should interpret this as "No Global Heap"
364 DWORD WINAPI GlobalMasterHandle16(void)
370 /************************************************************************
371 * Heap32ListFirst (KERNEL.@)
374 BOOL WINAPI Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
380 /******************************************************************
381 * Toolhelp32ReadProcessMemory (KERNEL.@)
385 BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD pid, const void* base,
386 void* buf, SIZE_T len, SIZE_T* r)
391 h = (pid) ? OpenProcess(PROCESS_VM_READ, FALSE, pid) : GetCurrentProcess();
394 ret = ReadProcessMemory(h, base, buf, len, r);
395 if (pid) CloseHandle(h);