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 }