git.oblomov.eu Git - wine/blob - 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 }