Added more pipe tests.
[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 "toolhelp.h"
36 #include "wine/server.h"
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(toolhelp);
41
42
43 /***********************************************************************
44  *           CreateToolhelp32Snapshot                   (KERNEL32.@)
45  */
46 HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
47 {
48     HANDLE ret;
49
50     TRACE("%lx,%lx\n", flags, process );
51     if (!(flags & (TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)))
52     {
53         FIXME("flags %lx not implemented\n", flags );
54         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
55         return INVALID_HANDLE_VALUE;
56     }
57
58     /* Now do the snapshot */
59     SERVER_START_REQ( create_snapshot )
60     {
61         req->flags = 0;
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;
65     
66         req->inherit = (flags & TH32CS_INHERIT) != 0;
67         req->pid     = process;
68         wine_server_call_err( req );
69         ret = reply->handle;
70     }
71     SERVER_END_REQ;
72     if (!ret) ret = INVALID_HANDLE_VALUE;
73     return ret;
74 }
75
76
77 /***********************************************************************
78  *              TOOLHELP_Thread32Next
79  *
80  * Implementation of Thread32First/Next
81  */
82 static BOOL TOOLHELP_Thread32Next( HANDLE handle, LPTHREADENTRY32 lpte, BOOL first )
83 {
84     BOOL ret;
85
86     if (lpte->dwSize < sizeof(THREADENTRY32))
87     {
88         SetLastError( ERROR_INSUFFICIENT_BUFFER );
89         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(THREADENTRY32), lpte->dwSize);
90         return FALSE;
91     }
92     SERVER_START_REQ( next_thread )
93     {
94         req->handle = handle;
95         req->reset = first;
96         if ((ret = !wine_server_call_err( req )))
97         {
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" */
104         }
105     }
106     SERVER_END_REQ;
107     return ret;
108 }
109
110 /***********************************************************************
111  *              Thread32First    (KERNEL32.@)
112  *
113  * Return info about the first thread in a toolhelp32 snapshot
114  */
115 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
116 {
117     return TOOLHELP_Thread32Next(hSnapshot, lpte, TRUE);
118 }
119
120 /***********************************************************************
121  *              Thread32Next   (KERNEL32.@)
122  *
123  * Return info about the "next" thread in a toolhelp32 snapshot
124  */
125 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
126 {
127     return TOOLHELP_Thread32Next(hSnapshot, lpte, FALSE);
128 }
129
130 /***********************************************************************
131  *              TOOLHELP_Process32Next
132  *
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.
136  */
137 static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32W lppe, BOOL first, BOOL unicode )
138 {
139     BOOL ret;
140     WCHAR exe[MAX_PATH-1];
141     DWORD len;
142
143     if (unicode)
144     {
145         if (lppe->dwSize < sizeof(PROCESSENTRY32W))
146         {
147             SetLastError( ERROR_INSUFFICIENT_BUFFER );
148             ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32W), lppe->dwSize);
149             return FALSE;
150         }
151     }
152     else
153     {
154         if (lppe->dwSize < sizeof(PROCESSENTRY32))
155         {
156             SetLastError( ERROR_INSUFFICIENT_BUFFER );
157             ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32), lppe->dwSize);
158             return FALSE;
159         }
160     }
161     SERVER_START_REQ( next_process )
162     {
163         req->handle = handle;
164         req->reset = first;
165         wine_server_set_reply( req, exe, sizeof(exe) );
166         if ((ret = !wine_server_call_err( req )))
167         {
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 */
176             if (unicode)
177             {
178                 len = wine_server_reply_size(reply) / sizeof(WCHAR);
179                 memcpy(lppe->szExeFile, reply, wine_server_reply_size(reply));
180                 lppe->szExeFile[len] = 0;
181             }
182             else
183             {
184                 LPPROCESSENTRY32 lppe_a = (LPPROCESSENTRY32) lppe;
185
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;
189             }
190         }
191     }
192     SERVER_END_REQ;
193     return ret;
194 }
195
196
197 /***********************************************************************
198  *              Process32First    (KERNEL32.@)
199  *
200  * Return info about the first process in a toolhelp32 snapshot
201  */
202 BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
203 {
204     return TOOLHELP_Process32Next( hSnapshot, (LPPROCESSENTRY32W) lppe, TRUE, FALSE /* ANSI */ );
205 }
206
207 /***********************************************************************
208  *              Process32Next   (KERNEL32.@)
209  *
210  * Return info about the "next" process in a toolhelp32 snapshot
211  */
212 BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
213 {
214     return TOOLHELP_Process32Next( hSnapshot, (LPPROCESSENTRY32W) lppe, FALSE, FALSE /* ANSI */ );
215 }
216
217 /***********************************************************************
218  *              Process32FirstW    (KERNEL32.@)
219  *
220  * Return info about the first process in a toolhelp32 snapshot
221  */
222 BOOL WINAPI Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
223 {
224     return TOOLHELP_Process32Next( hSnapshot, lppe, TRUE, TRUE /* Unicode */ );
225 }
226
227 /***********************************************************************
228  *              Process32NextW   (KERNEL32.@)
229  *
230  * Return info about the "next" process in a toolhelp32 snapshot
231  */
232 BOOL WINAPI Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe)
233 {
234     return TOOLHELP_Process32Next( hSnapshot, lppe, FALSE, TRUE /* Unicode */ );
235 }
236
237
238 /***********************************************************************
239  *              TOOLHELP_Module32NextW
240  *
241  * Implementation of Module32First/Next
242  */
243 static BOOL TOOLHELP_Module32NextW( HANDLE handle, LPMODULEENTRY32W lpme, BOOL first )
244 {
245     BOOL ret;
246     WCHAR exe[MAX_PATH];
247     DWORD len;
248
249     if (lpme->dwSize < sizeof (MODULEENTRY32W))
250     {
251         SetLastError( ERROR_INSUFFICIENT_BUFFER );
252         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32W), lpme->dwSize);
253         return FALSE;
254     }
255     SERVER_START_REQ( next_module )
256     {
257         req->handle = handle;
258         req->reset = first;
259         wine_server_set_reply( req, exe, sizeof(exe) );
260         if ((ret = !wine_server_call_err( req )))
261         {
262             const WCHAR* ptr;
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]));
276         }
277     }
278     SERVER_END_REQ;
279     return ret;
280 }
281
282 /***********************************************************************
283  *              TOOLHELP_Module32NextA
284  *
285  * Implementation of Module32First/Next
286  */
287 static BOOL TOOLHELP_Module32NextA( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
288 {
289     BOOL ret;
290     MODULEENTRY32W mew;
291     
292     if (lpme->dwSize < sizeof (MODULEENTRY32))
293     {
294         SetLastError( ERROR_INSUFFICIENT_BUFFER );
295         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
296         return FALSE;
297     }
298     
299     mew.dwSize = sizeof(mew);
300     if ((ret = TOOLHELP_Module32NextW( handle, &mew, first )))
301     {
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 );
310     }
311     return ret;
312 }
313
314 /***********************************************************************
315  *              Module32FirstW   (KERNEL32.@)
316  *
317  * Return info about the "first" module in a toolhelp32 snapshot
318  */
319 BOOL WINAPI Module32FirstW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
320 {
321     return TOOLHELP_Module32NextW( hSnapshot, lpme, TRUE );
322 }
323
324 /***********************************************************************
325  *              Module32First   (KERNEL32.@)
326  *
327  * Return info about the "first" module in a toolhelp32 snapshot
328  */
329 BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
330 {
331     return TOOLHELP_Module32NextA( hSnapshot, lpme, TRUE );
332 }
333
334 /***********************************************************************
335  *              Module32NextW   (KERNEL32.@)
336  *
337  * Return info about the "next" module in a toolhelp32 snapshot
338  */
339 BOOL WINAPI Module32NextW(HANDLE hSnapshot, LPMODULEENTRY32W lpme)
340 {
341     return TOOLHELP_Module32NextW( hSnapshot, lpme, FALSE );
342 }
343
344 /***********************************************************************
345  *              Module32Next   (KERNEL32.@)
346  *
347  * Return info about the "next" module in a toolhelp32 snapshot
348  */
349 BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
350 {
351     return TOOLHELP_Module32NextA( hSnapshot, lpme, FALSE );
352 }
353
354 /************************************************************************
355  *              GlobalMasterHandle (KERNEL.28)
356  *
357  *
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"
363  */
364 DWORD WINAPI GlobalMasterHandle16(void)
365 {
366     FIXME(": stub\n");
367     return 0;
368 }
369
370 /************************************************************************
371  *              Heap32ListFirst (KERNEL.@)
372  *
373  */
374 BOOL WINAPI Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl)
375 {
376     FIXME(": stub\n");
377     return FALSE;
378 }
379
380 /******************************************************************
381  *              Toolhelp32ReadProcessMemory (KERNEL.@)
382  *
383  *
384  */
385 BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD pid, const void* base,
386                                         void* buf, SIZE_T len, SIZE_T* r)
387 {
388     HANDLE h;
389     BOOL   ret = FALSE;
390
391     h = (pid) ? OpenProcess(PROCESS_VM_READ, FALSE, pid) : GetCurrentProcess();
392     if (h != NULL)
393     {
394         ret = ReadProcessMemory(h, base, buf, len, r);
395         if (pid) CloseHandle(h);
396     }
397     return ret;
398 }