dlls/psapi/psapi_main.c

   1 /*
   2  *      PSAPI library
   3  *
   4  * Copyright 1998 Patrik Stridvall
   5  * Copyright 2003 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "winbase.h"
  23 #include "windef.h"
  24 #include "winerror.h"
  25 #include "wine/server.h"
  26 #include "wine/debug.h"
  27 #include "winnls.h"
  28 #include "psapi.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(psapi);
  31
  32 /***********************************************************************
  33  *           EmptyWorkingSet (PSAPI.@)
  34  */
  35 BOOL WINAPI EmptyWorkingSet(HANDLE hProcess)
  36 {
  37     return SetProcessWorkingSetSize(hProcess, 0xFFFFFFFF, 0xFFFFFFFF);
  38 }
  39
  40 /***********************************************************************
  41  *           EnumDeviceDrivers (PSAPI.@)
  42  */
  43 BOOL WINAPI EnumDeviceDrivers(LPVOID *lpImageBase, DWORD cb, LPDWORD lpcbNeeded)
  44 {
  45     FIXME("(%p, %ld, %p): stub\n", lpImageBase, cb, lpcbNeeded);
  46
  47     if (lpcbNeeded)
  48         *lpcbNeeded = 0;
  49
  50     return TRUE;
  51 }
  52
  53
  54 /***********************************************************************
  55  *           EnumProcesses (PSAPI.@)
  56  */
  57 BOOL WINAPI EnumProcesses(DWORD *lpidProcess, DWORD cb, DWORD *lpcbNeeded)
  58 {
  59     HANDLE      hSnapshot;
  60     DWORD       count;
  61     DWORD       countMax;
  62     DWORD       pid;
  63     int         ret;
  64
  65     TRACE("(%p, %ld, %p)\n", lpidProcess,cb, lpcbNeeded);
  66
  67     if ( lpidProcess == NULL )
  68         cb = 0;
  69     if ( lpcbNeeded != NULL )
  70         *lpcbNeeded = 0;
  71
  72     SERVER_START_REQ( create_snapshot )
  73     {
  74         req->flags   = SNAP_PROCESS;
  75         req->inherit = FALSE;
  76         req->pid     = 0;
  77         wine_server_call_err( req );
  78         hSnapshot = reply->handle;
  79     }
  80     SERVER_END_REQ;
  81
  82     if ( hSnapshot == 0 )
  83     {
  84         FIXME("cannot create snapshot\n");
  85         return FALSE;
  86     }
  87     count = 0;
  88     countMax = cb / sizeof(DWORD);
  89     for (;;)
  90     {
  91         SERVER_START_REQ( next_process )
  92         {
  93             req->handle = hSnapshot;
  94             req->reset = (count == 0);
  95             wine_server_set_reply( req, NULL, 0);
  96             if ((ret = !wine_server_call_err( req )))
  97                 pid = reply->pid;
  98         }
  99         SERVER_END_REQ;
 100         if (!ret) break;
 101         TRACE("process 0x%08lx\n", pid);
 102         if ( count < countMax )
 103             lpidProcess[count] = pid;
 104         count++;
 105     }
 106     CloseHandle( hSnapshot );
 107
 108     if ( lpcbNeeded != NULL )
 109         *lpcbNeeded = sizeof(DWORD) * count;
 110
 111     TRACE("return %lu processes\n", count);
 112
 113     return TRUE;
 114 }
 115
 116 /***********************************************************************
 117  *           EnumProcessModules (PSAPI.@)
 118  */
 119 BOOL WINAPI EnumProcessModules(HANDLE hProcess, HMODULE *lphModule,
 120                                DWORD cb, LPDWORD lpcbNeeded)
 121 {
 122     HANDLE      hSnapshot;
 123     DWORD       pid;
 124     DWORD       count;
 125     DWORD       countMax;
 126     int         ret;
 127     HMODULE     hModule;
 128
 129     TRACE("(hProcess=%p, %p, %ld, %p)\n",
 130           hProcess, lphModule, cb, lpcbNeeded );
 131
 132     if ( lphModule == NULL )
 133         cb = 0;
 134     if ( lpcbNeeded != NULL )
 135         *lpcbNeeded = 0;
 136
 137     SERVER_START_REQ( get_process_info )
 138     {
 139         req->handle = hProcess;
 140         if ( !wine_server_call_err( req ) )
 141             pid = (DWORD)reply->pid;
 142         else
 143             pid = 0;
 144     }
 145     SERVER_END_REQ;
 146
 147     if ( pid == 0 )
 148     {
 149         FIXME("no pid for hProcess %p\n" ,hProcess);
 150         return FALSE;
 151     }
 152
 153     SERVER_START_REQ( create_snapshot )
 154     {
 155         req->flags   = SNAP_MODULE;
 156         req->inherit = FALSE;
 157         req->pid     = pid;
 158         wine_server_call_err( req );
 159         hSnapshot = reply->handle;
 160     }
 161     SERVER_END_REQ;
 162     if ( hSnapshot == 0 )
 163     {
 164         FIXME("cannot create snapshot\n");
 165         return FALSE;
 166     }
 167     count = 0;
 168     countMax = cb / sizeof(HMODULE);
 169     for (;;)
 170     {
 171         SERVER_START_REQ( next_module )
 172         {
 173             req->handle = hSnapshot;
 174             req->reset = (count == 0);
 175             wine_server_set_reply( req, NULL, 0 );
 176             if ((ret = !wine_server_call_err( req )))
 177             {
 178                 hModule = (HMODULE)reply->base;
 179             }
 180         }
 181         SERVER_END_REQ;
 182         if ( !ret ) break;
 183         TRACE("module 0x%p\n", hModule);
 184         if ( count < countMax )
 185             lphModule[count] = hModule;
 186         count++;
 187     }
 188     CloseHandle( hSnapshot );
 189
 190     if ( lpcbNeeded != NULL )
 191         *lpcbNeeded = sizeof(HMODULE) * count;
 192
 193     TRACE("return %lu modules\n", count);
 194
 195     return TRUE;
 196 }
 197
 198 /***********************************************************************
 199  *          GetDeviceDriverBaseNameA (PSAPI.@)
 200  */
 201 DWORD WINAPI GetDeviceDriverBaseNameA(LPVOID ImageBase, LPSTR lpBaseName,
 202                                       DWORD nSize)
 203 {
 204     FIXME("(%p, %s, %ld): stub\n",
 205           ImageBase, debugstr_a(lpBaseName), nSize);
 206
 207     if (lpBaseName && nSize)
 208         lpBaseName[0] = '\0';
 209
 210     return 0;
 211 }
 212
 213 /***********************************************************************
 214  *           GetDeviceDriverBaseNameW (PSAPI.@)
 215  */
 216 DWORD WINAPI GetDeviceDriverBaseNameW(LPVOID ImageBase, LPWSTR lpBaseName,
 217                                       DWORD nSize)
 218 {
 219     FIXME("(%p, %s, %ld): stub\n",
 220           ImageBase, debugstr_w(lpBaseName), nSize);
 221
 222     if (lpBaseName && nSize)
 223         lpBaseName[0] = '\0';
 224
 225     return 0;
 226 }
 227
 228 /***********************************************************************
 229  *           GetDeviceDriverFileNameA (PSAPI.@)
 230  */
 231 DWORD WINAPI GetDeviceDriverFileNameA(LPVOID ImageBase, LPSTR lpFilename,
 232                                       DWORD nSize)
 233 {
 234     FIXME("(%p, %s, %ld): stub\n",
 235           ImageBase, debugstr_a(lpFilename), nSize);
 236
 237     if (lpFilename && nSize)
 238         lpFilename[0] = '\0';
 239
 240     return 0;
 241 }
 242
 243 /***********************************************************************
 244  *           GetDeviceDriverFileNameW (PSAPI.@)
 245  */
 246 DWORD WINAPI GetDeviceDriverFileNameW(LPVOID ImageBase, LPWSTR lpFilename,
 247                                       DWORD nSize)
 248 {
 249     FIXME("(%p, %s, %ld): stub\n",
 250           ImageBase, debugstr_w(lpFilename), nSize);
 251
 252     if (lpFilename && nSize)
 253         lpFilename[0] = '\0';
 254
 255     return 0;
 256 }
 257
 258 /***********************************************************************
 259  *           GetMappedFileNameA (PSAPI.@)
 260  */
 261 DWORD WINAPI GetMappedFileNameA(HANDLE hProcess, LPVOID lpv, LPSTR lpFilename,
 262                                 DWORD nSize)
 263 {
 264     FIXME("(hProcess=%p, %p, %s, %ld): stub\n",
 265           hProcess, lpv, debugstr_a(lpFilename), nSize);
 266
 267     if (lpFilename && nSize)
 268         lpFilename[0] = '\0';
 269
 270     return 0;
 271 }
 272
 273 /***********************************************************************
 274  *           GetMappedFileNameW (PSAPI.@)
 275  */
 276 DWORD WINAPI GetMappedFileNameW(HANDLE hProcess, LPVOID lpv, LPWSTR lpFilename,
 277                                 DWORD nSize)
 278 {
 279     FIXME("(hProcess=%p, %p, %s, %ld): stub\n",
 280           hProcess, lpv, debugstr_w(lpFilename), nSize);
 281
 282     if (lpFilename && nSize)
 283         lpFilename[0] = '\0';
 284
 285     return 0;
 286 }
 287
 288 /***********************************************************************
 289  *           GetModuleBaseNameA (PSAPI.@)
 290  */
 291 DWORD WINAPI GetModuleBaseNameA(HANDLE hProcess, HMODULE hModule,
 292                                 LPSTR lpBaseName, DWORD nSize)
 293 {
 294     char        tmp[MAX_PATH];
 295     char*       ptr;
 296
 297     if (!GetModuleFileNameExA(hProcess, hModule, tmp, sizeof(tmp)))
 298         return 0;
 299     if ((ptr = strrchr(tmp, '\\')) != NULL) ptr++; else ptr = tmp;
 300     strncpy(lpBaseName, ptr, nSize);
 301     lpBaseName[nSize - 1] = '\0';
 302     return strlen(lpBaseName);
 303 }
 304
 305 /***********************************************************************
 306  *           GetModuleBaseNameW (PSAPI.@)
 307  */
 308 DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule,
 309                                 LPWSTR lpBaseName, DWORD nSize)
 310 {
 311     char*       ptr;
 312     DWORD       len;
 313
 314     TRACE("(hProcess=%p, hModule=%p, %p, %ld)\n",
 315           hProcess, hModule, lpBaseName, nSize);
 316
 317     if (!lpBaseName || !nSize) return 0;
 318
 319     ptr = HeapAlloc(GetProcessHeap(), 0, nSize / 2);
 320     if (!ptr) return 0;
 321
 322     len = GetModuleBaseNameA(hProcess, hModule, ptr, nSize / 2);
 323     if (len == 0)
 324     {
 325         lpBaseName[0] = '\0';
 326     }
 327     else
 328     {
 329         if (!MultiByteToWideChar( CP_ACP, 0, ptr, -1, lpBaseName, nSize / 2 ))
 330             lpBaseName[nSize / 2 - 1] = 0;
 331     }
 332
 333     return len;
 334 }
 335
 336 /***********************************************************************
 337  *           GetModuleFileNameExA (PSAPI.@)
 338  */
 339 DWORD WINAPI GetModuleFileNameExA(HANDLE hProcess, HMODULE hModule,
 340                                   LPSTR lpFileName, DWORD nSize)
 341 {
 342     DWORD       len = 0;
 343
 344     TRACE("(hProcess=%p, hModule=%p, %p, %ld)\n",
 345           hProcess, hModule, lpFileName, nSize);
 346
 347     if (!lpFileName || !nSize) return 0;
 348
 349     if ( hProcess == GetCurrentProcess() )
 350         return GetModuleFileNameA( hModule, lpFileName, nSize );
 351
 352     lpFileName[0] = 0;
 353
 354     SERVER_START_REQ( get_dll_info )
 355     {
 356         req->handle       = hProcess;
 357         req->base_address = (void*)hModule;
 358         wine_server_set_reply( req, lpFileName, nSize - 1);
 359         if (!wine_server_call_err( req ))
 360         {
 361             len = wine_server_reply_size(reply);
 362             lpFileName[len] = 0;
 363         }
 364     }
 365     SERVER_END_REQ;
 366
 367     TRACE("return %s (%lu)\n", lpFileName, len);
 368
 369     return len;
 370 }
 371
 372 /***********************************************************************
 373  *           GetModuleFileNameExW (PSAPI.@)
 374  */
 375 DWORD WINAPI GetModuleFileNameExW(HANDLE hProcess, HMODULE hModule,
 376                                   LPWSTR lpFileName, DWORD nSize)
 377 {
 378     char*       ptr;
 379     DWORD       len;
 380
 381     TRACE("(hProcess=%p,hModule=%p, %p, %ld)\n",
 382           hProcess, hModule, lpFileName, nSize);
 383
 384     if (!lpFileName || !nSize) return 0;
 385
 386     if ( hProcess == GetCurrentProcess() )
 387         return GetModuleFileNameW( hModule, lpFileName, nSize );
 388
 389     ptr = HeapAlloc(GetProcessHeap(), 0, nSize / 2);
 390     if (!ptr) return 0;
 391
 392     len = GetModuleFileNameExA(hProcess, hModule, ptr, nSize / 2);
 393     if (len == 0)
 394     {
 395         lpFileName[0] = '\0';
 396     }
 397     else
 398     {
 399         if (!MultiByteToWideChar( CP_ACP, 0, ptr, -1, lpFileName, nSize / 2 ))
 400             lpFileName[nSize / 2 - 1] = 0;
 401     }
 402
 403     return len;
 404 }
 405
 406 /***********************************************************************
 407  *           GetModuleInformation (PSAPI.@)
 408  */
 409 BOOL WINAPI GetModuleInformation(HANDLE hProcess, HMODULE hModule,
 410                                  LPMODULEINFO lpmodinfo, DWORD cb)
 411 {
 412     BOOL ret = FALSE;
 413
 414     TRACE("(hProcess=%p, hModule=%p, %p, %ld)\n",
 415           hProcess, hModule, lpmodinfo, cb);
 416
 417     if (cb < sizeof(MODULEINFO)) return FALSE;
 418
 419     SERVER_START_REQ( get_dll_info )
 420     {
 421         req->handle       = hProcess;
 422         req->base_address = (void*)hModule;
 423         if (!wine_server_call_err( req ))
 424         {
 425             ret = TRUE;
 426             lpmodinfo->lpBaseOfDll = (void*)hModule;
 427             lpmodinfo->SizeOfImage = reply->size;
 428             lpmodinfo->EntryPoint  = reply->entry_point;
 429         }
 430     }
 431     SERVER_END_REQ;
 432
 433     return TRUE;
 434 }
 435
 436 /***********************************************************************
 437  *           GetProcessMemoryInfo (PSAPI.@)
 438  */
 439 BOOL WINAPI GetProcessMemoryInfo(HANDLE Process,
 440                                  PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb)
 441 {
 442     FIXME("(hProcess=%p, %p, %ld): stub\n",
 443           Process, ppsmemCounters, cb);
 444
 445     memset(ppsmemCounters, 0, cb);
 446
 447     return TRUE;
 448 }
 449
 450 /***********************************************************************
 451  *           GetWsChanges (PSAPI.@)
 452  */
 453 BOOL WINAPI GetWsChanges(HANDLE hProcess,
 454                          PPSAPI_WS_WATCH_INFORMATION lpWatchInfo, DWORD cb)
 455 {
 456     FIXME("(hProcess=%p, %p, %ld): stub\n",
 457           hProcess, lpWatchInfo, cb);
 458
 459     memset(lpWatchInfo, 0, cb);
 460
 461     return TRUE;
 462 }
 463
 464 /***********************************************************************
 465  *           InitializeProcessForWsWatch (PSAPI.@)
 466  */
 467 BOOL WINAPI InitializeProcessForWsWatch(HANDLE hProcess)
 468 {
 469     FIXME("(hProcess=%p): stub\n", hProcess);
 470
 471     return TRUE;
 472 }
 473
 474 /***********************************************************************
 475  *           QueryWorkingSet (PSAPI.?)
 476  * FIXME
 477  *     I haven't been able to find the ordinal for this function,
 478  *     This means it can't be called from outside the DLL.
 479  */
 480 BOOL WINAPI QueryWorkingSet(HANDLE hProcess, LPVOID pv, DWORD cb)
 481 {
 482     FIXME("(hProcess=%p, %p, %ld)\n", hProcess, pv, cb);
 483
 484     if (pv && cb)
 485         ((DWORD *) pv)[0] = 0; /* Empty WorkingSet */
 486
 487     return TRUE;
 488 }