ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Implemented GetModuleBaseName(AW), GetModuleFileNameEx(AW) and 

GetModuleInformation.
This commit is contained in:
Eric Pouech 2003-01-09 00:02:26 +00:00 committed by Alexandre Julliard
parent 2359b57574
commit d93cb70558
1 changed files with 295 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

515
dlls/psapi/psapi_main.c
View File

@ -1,7 +1,8 @@
/* /*
* PSAPI library * PSAPI library
* *
* Copyright 1998 Patrik Stridvall * Copyright 1998 Patrik Stridvall
* Copyright 2003 Eric Pouech
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -23,52 +24,30 @@
#include "winerror.h" #include "winerror.h"
#include "wine/server.h" #include "wine/server.h"
#include "wine/debug.h" #include "wine/debug.h"
#include "tlhelp32.h" #include "winnls.h"
#include "psapi.h" #include "psapi.h"
WINE_DEFAULT_DEBUG_CHANNEL(psapi); WINE_DEFAULT_DEBUG_CHANNEL(psapi);
#include <string.h>
/***********************************************************************
* get pid from hProcess (internal)
*/
static DWORD get_pid_from_process_handle(HANDLE hProcess)
{
DWORD ret = 0;
SERVER_START_REQ( get_process_info )
{
req->handle = hProcess;
if ( !wine_server_call_err( req ) )
ret = (DWORD)reply->pid;
}
SERVER_END_REQ;
return ret;
}
/*********************************************************************** /***********************************************************************
* EmptyWorkingSet (PSAPI.@) * EmptyWorkingSet (PSAPI.@)
*/ */
BOOL WINAPI EmptyWorkingSet(HANDLE hProcess) BOOL WINAPI EmptyWorkingSet(HANDLE hProcess)
{ {
return SetProcessWorkingSetSize(hProcess, 0xFFFFFFFF, 0xFFFFFFFF); return SetProcessWorkingSetSize(hProcess, 0xFFFFFFFF, 0xFFFFFFFF);
} }
/*********************************************************************** /***********************************************************************
* EnumDeviceDrivers (PSAPI.@) * EnumDeviceDrivers (PSAPI.@)
*/ */
BOOL WINAPI EnumDeviceDrivers( BOOL WINAPI EnumDeviceDrivers(LPVOID *lpImageBase, DWORD cb, LPDWORD lpcbNeeded)
LPVOID *lpImageBase, DWORD cb, LPDWORD lpcbNeeded)
{ {
FIXME("(%p, %ld, %p): stub\n", lpImageBase, cb, lpcbNeeded); FIXME("(%p, %ld, %p): stub\n", lpImageBase, cb, lpcbNeeded);
if(lpcbNeeded) if (lpcbNeeded)
*lpcbNeeded = 0; *lpcbNeeded = 0;
return TRUE; return TRUE;
} }
@ -77,315 +56,409 @@ BOOL WINAPI EnumDeviceDrivers(
*/ */
BOOL WINAPI EnumProcesses(DWORD *lpidProcess, DWORD cb, DWORD *lpcbNeeded) BOOL WINAPI EnumProcesses(DWORD *lpidProcess, DWORD cb, DWORD *lpcbNeeded)
{ {
PROCESSENTRY32 pe; HANDLE hSnapshot;
HANDLE hSnapshot; DWORD count;
BOOL res; DWORD countMax;
DWORD count; DWORD pid;
DWORD countMax; int ret;
FIXME("(%p, %ld, %p)\n", lpidProcess,cb, lpcbNeeded); TRACE("(%p, %ld, %p)\n", lpidProcess,cb, lpcbNeeded);
if ( lpidProcess == NULL ) if ( lpidProcess == NULL )
cb = 0; cb = 0;
if ( lpcbNeeded != NULL ) if ( lpcbNeeded != NULL )
*lpcbNeeded = 0; *lpcbNeeded = 0;
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0); SERVER_START_REQ( create_snapshot )
if ( hSnapshot == INVALID_HANDLE_VALUE ) {
{ req->flags = SNAP_PROCESS;
FIXME("cannot create snapshot\n"); req->inherit = FALSE;
return FALSE; req->pid = 0;
} wine_server_call_err( req );
count = 0; hSnapshot = reply->handle;
countMax = cb / sizeof(DWORD); }
while (1) SERVER_END_REQ;
{
ZeroMemory( &pe, sizeof(PROCESSENTRY32) );
pe.dwSize = sizeof(PROCESSENTRY32);
res = (count == 0) ? Process32First( hSnapshot, &pe ) : Process32Next( hSnapshot, &pe );
if ( !res )
break;
TRACE("process 0x%08lx\n",(long)pe.th32ProcessID);
if ( count < countMax )
lpidProcess[count] = pe.th32ProcessID;
count ++;
}
CloseHandle( hSnapshot );
if ( lpcbNeeded != NULL ) if ( hSnapshot == 0 )
*lpcbNeeded = sizeof(DWORD) * count; {
FIXME("cannot create snapshot\n");
return FALSE;
}
count = 0;
countMax = cb / sizeof(DWORD);
for (;;)
{
SERVER_START_REQ( next_process )
{
req->handle = hSnapshot;
req->reset = (count == 0);
wine_server_set_reply( req, NULL, 0);
if ((ret = !wine_server_call_err( req )))
pid = reply->pid;
}
SERVER_END_REQ;
if (!ret) break;
TRACE("process 0x%08lx\n", pid);
if ( count < countMax )
lpidProcess[count] = pid;
count++;
}
CloseHandle( hSnapshot );
TRACE("return %lu processes\n",count); if ( lpcbNeeded != NULL )
*lpcbNeeded = sizeof(DWORD) * count;
return TRUE; TRACE("return %lu processes\n", count);
return TRUE;
} }
/*********************************************************************** /***********************************************************************
* EnumProcessModules (PSAPI.@) * EnumProcessModules (PSAPI.@)
*/ */
BOOL WINAPI EnumProcessModules( BOOL WINAPI EnumProcessModules(HANDLE hProcess, HMODULE *lphModule,
HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded) DWORD cb, LPDWORD lpcbNeeded)
{ {
MODULEENTRY32 me; HANDLE hSnapshot;
HANDLE hSnapshot; DWORD pid;
BOOL res; DWORD count;
DWORD pid; DWORD countMax;
DWORD count; int ret;
DWORD countMax; HMODULE hModule;
FIXME("(hProcess=%p, %p, %ld, %p)\n", TRACE("(hProcess=%p, %p, %ld, %p)\n",
hProcess, lphModule, cb, lpcbNeeded ); hProcess, lphModule, cb, lpcbNeeded );
if ( lphModule == NULL ) if ( lphModule == NULL )
cb = 0; cb = 0;
if ( lpcbNeeded != NULL ) if ( lpcbNeeded != NULL )
*lpcbNeeded = 0; *lpcbNeeded = 0;
pid = get_pid_from_process_handle(hProcess); SERVER_START_REQ( get_process_info )
if ( pid == 0 ) {
{ req->handle = hProcess;
FIXME("no pid for hProcess %p\n",hProcess); if ( !wine_server_call_err( req ) )
return FALSE; pid = (DWORD)reply->pid;
} else
pid = 0;
}
SERVER_END_REQ;
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,pid); if ( pid == 0 )
if ( hSnapshot == INVALID_HANDLE_VALUE ) {
{ FIXME("no pid for hProcess %p\n" ,hProcess);
FIXME("cannot create snapshot\n"); return FALSE;
return FALSE; }
}
count = 0;
countMax = cb / sizeof(HMODULE);
while (1)
{
ZeroMemory( &me, sizeof(MODULEENTRY32) );
me.dwSize = sizeof(MODULEENTRY32);
res = (count == 0) ? Module32First( hSnapshot, &me ) : Module32Next( hSnapshot, &me );
if ( !res )
break;
TRACE("module 0x%08lx\n",(long)me.hModule);
if ( count < countMax )
lphModule[count] = me.hModule;
count ++;
}
CloseHandle( hSnapshot );
if ( lpcbNeeded != NULL ) SERVER_START_REQ( create_snapshot )
*lpcbNeeded = sizeof(HMODULE) * count; {
req->flags = SNAP_MODULE;
req->inherit = FALSE;
req->pid = pid;
wine_server_call_err( req );
hSnapshot = reply->handle;
}
SERVER_END_REQ;
if ( hSnapshot == 0 )
{
FIXME("cannot create snapshot\n");
return FALSE;
}
count = 0;
countMax = cb / sizeof(HMODULE);
for (;;)
{
SERVER_START_REQ( next_module )
{
req->handle = hSnapshot;
req->reset = (count == 0);
wine_server_set_reply( req, NULL, 0 );
if ((ret = !wine_server_call_err( req )))
{
hModule = (HMODULE)reply->base;
}
}
SERVER_END_REQ;
if ( !ret ) break;
TRACE("module 0x%p\n", hModule);
if ( count < countMax )
lphModule[count] = hModule;
count++;
}
CloseHandle( hSnapshot );
TRACE("return %lu modules\n",count); if ( lpcbNeeded != NULL )
*lpcbNeeded = sizeof(HMODULE) * count;
return TRUE; TRACE("return %lu modules\n", count);
return TRUE;
} }
/*********************************************************************** /***********************************************************************
* GetDeviceDriverBaseNameA (PSAPI.@) * GetDeviceDriverBaseNameA (PSAPI.@)
*/ */
DWORD WINAPI GetDeviceDriverBaseNameA( DWORD WINAPI GetDeviceDriverBaseNameA(LPVOID ImageBase, LPSTR lpBaseName,
LPVOID ImageBase, LPSTR lpBaseName, DWORD nSize) DWORD nSize)
{ {
FIXME("(%p, %s, %ld): stub\n", FIXME("(%p, %s, %ld): stub\n",
ImageBase, debugstr_a(lpBaseName), nSize ImageBase, debugstr_a(lpBaseName), nSize);
);
if(lpBaseName && nSize) if (lpBaseName && nSize)
lpBaseName[0] = '\0'; lpBaseName[0] = '\0';
return 0; return 0;
} }
/*********************************************************************** /***********************************************************************
* GetDeviceDriverBaseNameW (PSAPI.@) * GetDeviceDriverBaseNameW (PSAPI.@)
*/ */
DWORD WINAPI GetDeviceDriverBaseNameW( DWORD WINAPI GetDeviceDriverBaseNameW(LPVOID ImageBase, LPWSTR lpBaseName,
LPVOID ImageBase, LPWSTR lpBaseName, DWORD nSize) DWORD nSize)
{ {
FIXME("(%p, %s, %ld): stub\n", FIXME("(%p, %s, %ld): stub\n",
ImageBase, debugstr_w(lpBaseName), nSize ImageBase, debugstr_w(lpBaseName), nSize);
);
if(lpBaseName && nSize) if (lpBaseName && nSize)
lpBaseName[0] = '\0'; lpBaseName[0] = '\0';
return 0; return 0;
} }
/*********************************************************************** /***********************************************************************
* GetDeviceDriverFileNameA (PSAPI.@) * GetDeviceDriverFileNameA (PSAPI.@)
*/ */
DWORD WINAPI GetDeviceDriverFileNameA( DWORD WINAPI GetDeviceDriverFileNameA(LPVOID ImageBase, LPSTR lpFilename,
LPVOID ImageBase, LPSTR lpFilename, DWORD nSize) DWORD nSize)
{ {
FIXME("(%p, %s, %ld): stub\n", FIXME("(%p, %s, %ld): stub\n",
ImageBase, debugstr_a(lpFilename), nSize ImageBase, debugstr_a(lpFilename), nSize);
);
if(lpFilename && nSize) if (lpFilename && nSize)
lpFilename[0] = '\0'; lpFilename[0] = '\0';
return 0; return 0;
} }
/*********************************************************************** /***********************************************************************
* GetDeviceDriverFileNameW (PSAPI.@) * GetDeviceDriverFileNameW (PSAPI.@)
*/ */
DWORD WINAPI GetDeviceDriverFileNameW( DWORD WINAPI GetDeviceDriverFileNameW(LPVOID ImageBase, LPWSTR lpFilename,
LPVOID ImageBase, LPWSTR lpFilename, DWORD nSize) DWORD nSize)
{ {
FIXME("(%p, %s, %ld): stub\n", FIXME("(%p, %s, %ld): stub\n",
ImageBase, debugstr_w(lpFilename), nSize ImageBase, debugstr_w(lpFilename), nSize);
);
if(lpFilename && nSize) if (lpFilename && nSize)
lpFilename[0] = '\0'; lpFilename[0] = '\0';
return 0; return 0;
} }
/*********************************************************************** /***********************************************************************
* GetMappedFileNameA (PSAPI.@) * GetMappedFileNameA (PSAPI.@)
*/ */
DWORD WINAPI GetMappedFileNameA( DWORD WINAPI GetMappedFileNameA(HANDLE hProcess, LPVOID lpv, LPSTR lpFilename,
HANDLE hProcess, LPVOID lpv, LPSTR lpFilename, DWORD nSize) DWORD nSize)
{ {
FIXME("(hProcess=%p, %p, %s, %ld): stub\n", FIXME("(hProcess=%p, %p, %s, %ld): stub\n",
hProcess, lpv, debugstr_a(lpFilename), nSize hProcess, lpv, debugstr_a(lpFilename), nSize);
);
if(lpFilename && nSize) if (lpFilename && nSize)
lpFilename[0] = '\0'; lpFilename[0] = '\0';
return 0; return 0;
} }
/*********************************************************************** /***********************************************************************
* GetMappedFileNameW (PSAPI.@) * GetMappedFileNameW (PSAPI.@)
*/ */
DWORD WINAPI GetMappedFileNameW( DWORD WINAPI GetMappedFileNameW(HANDLE hProcess, LPVOID lpv, LPWSTR lpFilename,
HANDLE hProcess, LPVOID lpv, LPWSTR lpFilename, DWORD nSize) DWORD nSize)
{ {
FIXME("(hProcess=%p, %p, %s, %ld): stub\n", FIXME("(hProcess=%p, %p, %s, %ld): stub\n",
hProcess, lpv, debugstr_w(lpFilename), nSize hProcess, lpv, debugstr_w(lpFilename), nSize);
);
if(lpFilename && nSize) if (lpFilename && nSize)
lpFilename[0] = '\0'; lpFilename[0] = '\0';
return 0; return 0;
} }
/*********************************************************************** /***********************************************************************
* GetModuleBaseNameA (PSAPI.@) * GetModuleBaseNameA (PSAPI.@)
*/ */
DWORD WINAPI GetModuleBaseNameA( DWORD WINAPI GetModuleBaseNameA(HANDLE hProcess, HMODULE hModule,
HANDLE hProcess, HMODULE hModule, LPSTR lpBaseName, DWORD nSize) LPSTR lpBaseName, DWORD nSize)
{ {
FIXME("(hProcess=%p, hModule=%p, %s, %ld): stub\n", char tmp[MAX_PATH];
hProcess, hModule, debugstr_a(lpBaseName), nSize char* ptr;
);
if(lpBaseName && nSize) if (!GetModuleFileNameExA(hProcess, hModule, tmp, sizeof(tmp)))
lpBaseName[0] = '\0'; return 0;
if ((ptr = strrchr(tmp, '\\')) != NULL) ptr++; else ptr = tmp;
return 0; strncpy(lpBaseName, ptr, nSize);
lpBaseName[nSize - 1] = '\0';
return strlen(lpBaseName);
} }
/*********************************************************************** /***********************************************************************
* GetModuleBaseNameW (PSAPI.@) * GetModuleBaseNameW (PSAPI.@)
*/ */
DWORD WINAPI GetModuleBaseNameW( DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess, HMODULE hModule,
HANDLE hProcess, HMODULE hModule, LPWSTR lpBaseName, DWORD nSize) LPWSTR lpBaseName, DWORD nSize)
{ {
FIXME("(hProcess=%p, hModule=%p, %s, %ld): stub\n", char* ptr;
hProcess, hModule, debugstr_w(lpBaseName), nSize); DWORD len;
if(lpBaseName && nSize) TRACE("(hProcess=%p, hModule=%p, %p, %ld)\n",
lpBaseName[0] = '\0'; hProcess, hModule, lpBaseName, nSize);
return 0; if (!lpBaseName || !nSize) return 0;
ptr = HeapAlloc(GetProcessHeap(), 0, nSize / 2);
if (!ptr) return 0;
len = GetModuleBaseNameA(hProcess, hModule, ptr, nSize / 2);
if (len == 0)
{
lpBaseName[0] = '\0';
}
else
{
if (!MultiByteToWideChar( CP_ACP, 0, ptr, -1, lpBaseName, nSize / 2 ))
lpBaseName[nSize / 2 - 1] = 0;
}
return len;
} }
/*********************************************************************** /***********************************************************************
* GetModuleFileNameExA (PSAPI.@) * GetModuleFileNameExA (PSAPI.@)
*/ */
DWORD WINAPI GetModuleFileNameExA( DWORD WINAPI GetModuleFileNameExA(HANDLE hProcess, HMODULE hModule,
HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, DWORD nSize) LPSTR lpFileName, DWORD nSize)
{ {
FIXME("(hProcess=%p,hModule=%p, %s, %ld): stub\n", DWORD len = 0;
hProcess, hModule, debugstr_a(lpFilename), nSize
);
if ( get_pid_from_process_handle(hProcess) == GetCurrentProcessId() ) TRACE("(hProcess=%p, hModule=%p, %p, %ld)\n",
return GetModuleFileNameA( hModule, lpFilename, nSize ); hProcess, hModule, lpFileName, nSize);
if(lpFilename&&nSize) if (!lpFileName || !nSize) return 0;
lpFilename[0]='\0';
return 0; if ( hProcess == GetCurrentProcess() )
return GetModuleFileNameA( hModule, lpFileName, nSize );
lpFileName[0] = 0;
SERVER_START_REQ( get_dll_info )
{
req->handle = hProcess;
req->base_address = (void*)hModule;
wine_server_set_reply( req, lpFileName, nSize - 1);
if (!wine_server_call_err( req ))
{
len = wine_server_reply_size(reply);
lpFileName[len] = 0;
}
}
SERVER_END_REQ;
TRACE("return %s (%lu)\n", lpFileName, len);
return len;
} }
/*********************************************************************** /***********************************************************************
* GetModuleFileNameExW (PSAPI.@) * GetModuleFileNameExW (PSAPI.@)
*/ */
DWORD WINAPI GetModuleFileNameExW( DWORD WINAPI GetModuleFileNameExW(HANDLE hProcess, HMODULE hModule,
HANDLE hProcess, HMODULE hModule, LPWSTR lpFilename, DWORD nSize) LPWSTR lpFileName, DWORD nSize)
{ {
FIXME("(hProcess=%p,hModule=%p, %s, %ld): stub\n", char* ptr;
hProcess, hModule, debugstr_w(lpFilename), nSize DWORD len;
);
if ( get_pid_from_process_handle(hProcess) == GetCurrentProcessId() ) TRACE("(hProcess=%p,hModule=%p, %p, %ld)\n",
return GetModuleFileNameW( hModule, lpFilename, nSize ); hProcess, hModule, lpFileName, nSize);
if(lpFilename && nSize) if (!lpFileName || !nSize) return 0;
lpFilename[0] = '\0';
return 0; if ( hProcess == GetCurrentProcess() )
return GetModuleFileNameW( hModule, lpFileName, nSize );
ptr = HeapAlloc(GetProcessHeap(), 0, nSize / 2);
if (!ptr) return 0;
len = GetModuleFileNameExA(hProcess, hModule, ptr, nSize / 2);
if (len == 0)
{
lpFileName[0] = '\0';
}
else
{
if (!MultiByteToWideChar( CP_ACP, 0, ptr, -1, lpFileName, nSize / 2 ))
lpFileName[nSize / 2 - 1] = 0;
}
return len;
} }
/*********************************************************************** /***********************************************************************
* GetModuleInformation (PSAPI.@) * GetModuleInformation (PSAPI.@)
*/ */
BOOL WINAPI GetModuleInformation( BOOL WINAPI GetModuleInformation(HANDLE hProcess, HMODULE hModule,
HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) LPMODULEINFO lpmodinfo, DWORD cb)
{ {
FIXME("(hProcess=%p, hModule=%p, %p, %ld): stub\n", BOOL ret = FALSE;
hProcess, hModule, lpmodinfo, cb
);
memset(lpmodinfo, 0, cb); TRACE("(hProcess=%p, hModule=%p, %p, %ld)\n",
hProcess, hModule, lpmodinfo, cb);
return TRUE; if (cb < sizeof(MODULEINFO)) return FALSE;
SERVER_START_REQ( get_dll_info )
{
req->handle = hProcess;
req->base_address = (void*)hModule;
if (!wine_server_call_err( req ))
{
ret = TRUE;
lpmodinfo->lpBaseOfDll = (void*)hModule;
lpmodinfo->SizeOfImage = reply->size;
lpmodinfo->EntryPoint = reply->entry_point;
}
}
SERVER_END_REQ;
return TRUE;
} }
/*********************************************************************** /***********************************************************************
* GetProcessMemoryInfo (PSAPI.@) * GetProcessMemoryInfo (PSAPI.@)
*/ */
BOOL WINAPI GetProcessMemoryInfo( BOOL WINAPI GetProcessMemoryInfo(HANDLE Process,
HANDLE Process, PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb) PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb)
{ {
FIXME("(hProcess=%p, %p, %ld): stub\n", FIXME("(hProcess=%p, %p, %ld): stub\n",
Process, ppsmemCounters, cb Process, ppsmemCounters, cb);
);
memset(ppsmemCounters, 0, cb); memset(ppsmemCounters, 0, cb);
return TRUE; return TRUE;
} }
/*********************************************************************** /***********************************************************************
* GetWsChanges (PSAPI.@) * GetWsChanges (PSAPI.@)
*/ */
BOOL WINAPI GetWsChanges( BOOL WINAPI GetWsChanges(HANDLE hProcess,
HANDLE hProcess, PPSAPI_WS_WATCH_INFORMATION lpWatchInfo, DWORD cb) PPSAPI_WS_WATCH_INFORMATION lpWatchInfo, DWORD cb)
{ {
FIXME("(hProcess=%p, %p, %ld): stub\n", FIXME("(hProcess=%p, %p, %ld): stub\n",
hProcess, lpWatchInfo, cb hProcess, lpWatchInfo, cb);
);
memset(lpWatchInfo, 0, cb); memset(lpWatchInfo, 0, cb);
return TRUE; return TRUE;
} }
/*********************************************************************** /***********************************************************************
@ -393,9 +466,9 @@ BOOL WINAPI GetWsChanges(
*/ */
BOOL WINAPI InitializeProcessForWsWatch(HANDLE hProcess) BOOL WINAPI InitializeProcessForWsWatch(HANDLE hProcess)
{ {
FIXME("(hProcess=%p): stub\n", hProcess); FIXME("(hProcess=%p): stub\n", hProcess);
return TRUE; return TRUE;
} }
/*********************************************************************** /***********************************************************************
@ -406,10 +479,10 @@ BOOL WINAPI InitializeProcessForWsWatch(HANDLE hProcess)
*/ */
BOOL WINAPI QueryWorkingSet(HANDLE hProcess, LPVOID pv, DWORD cb) BOOL WINAPI QueryWorkingSet(HANDLE hProcess, LPVOID pv, DWORD cb)
{ {
FIXME("(hProcess=%p, %p, %ld)\n", hProcess, pv, cb); FIXME("(hProcess=%p, %p, %ld)\n", hProcess, pv, cb);
if(pv && cb) if (pv && cb)
((DWORD *) pv)[0] = 0; /* Empty WorkingSet */ ((DWORD *) pv)[0] = 0; /* Empty WorkingSet */
return TRUE; return TRUE;
} }