Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-28 02:02:01 +00:00
Code Issues Projects Releases Packages Wiki Activity

Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers into modules, and delete rossubsys.

Browse source
This commit is contained in:
Colin Finck 2017-10-03 07:45:34 +00:00
parent b94e2d8ca0
commit c2c66aff7d
24198 changed files with 0 additions and 37285 deletions
Download patch file Download diff file Expand all files Collapse all files

190
sdk/lib/epsapi/enum/drivers.c Normal file
View file

@ -0,0 +1,190 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* LICENSE: See LGPL.txt in the top level directory
* PROJECT: ReactOS system libraries
* FILE: reactos/lib/epsapi/enum/drivers.c
* PURPOSE: Enumerate system modules
* PROGRAMMER: KJK::Hyperion <noog@libero.it>
* UPDATE HISTORY:
* 02/04/2003: Created
* 12/04/2003: internal PSAPI renamed EPSAPI (Extended PSAPI) and
* isolated in its own library to clear the confusion
* and improve reusability
*/
#include "precomp.h"
#define NDEBUG
#include <debug.h>
NTSTATUS NTAPI
PsaEnumerateSystemModules(IN PSYSMOD_ENUM_ROUTINE Callback,
IN OUT PVOID CallbackContext)
{
PRTL_PROCESS_MODULES psmModules;
NTSTATUS Status = STATUS_SUCCESS;
#if 0
__try
{
#else
do
{
#endif
/* capture the system modules */
Status = PsaCaptureSystemModules(&psmModules);
if(!NT_SUCCESS(Status))
{
break;
}
/* walk the system modules */
Status = PsaWalkSystemModules(psmModules, Callback, CallbackContext);
#if 0
}
__finally
{
#else
} while(0);
#endif
/* free the capture */
PsaFreeCapture(psmModules);
#if 0
}
#endif
return Status;
}
NTSTATUS NTAPI
PsaCaptureSystemModules(OUT PRTL_PROCESS_MODULES *SystemModules)
{
SIZE_T nSize = 0;
PRTL_PROCESS_MODULES psmModules = NULL;
NTSTATUS Status;
#if 0
__try
{
#else
do
{
#endif
/* initial probe. We just get the count of system modules */
Status = NtQuerySystemInformation(SystemModuleInformation,
&nSize,
sizeof(nSize),
NULL);
if(!NT_SUCCESS(Status) && (Status != STATUS_INFO_LENGTH_MISMATCH))
{
DPRINT(FAILED_WITH_STATUS, "NtQuerySystemInformation", Status);
break;
}
/* RATIONALE: the loading of a system module is a rare occurrence. To
minimize memory operations that could be expensive, or fragment the
pool/heap, we try to determine the buffer size in advance, knowing that
the number of elements is unlikely to change */
nSize = sizeof(RTL_PROCESS_MODULES) +
(nSize * sizeof(RTL_PROCESS_MODULES));
psmModules = NULL;
do
{
PVOID pTmp;
/* free the buffer, and reallocate it to the new size. RATIONALE: since we
ignore the buffer's content at this point, there's no point in a realloc,
that could end up copying a large chunk of data we'd discard anyway */
PsaiFree(psmModules);
psmModules = NULL;
pTmp = PsaiMalloc(nSize);
if(pTmp == NULL)
{
Status = STATUS_NO_MEMORY;
DPRINT(FAILED_WITH_STATUS, "PsaiMalloc", Status);
break;
}
psmModules = pTmp;
/* query the information */
Status = NtQuerySystemInformation(SystemModuleInformation,
psmModules,
nSize,
NULL);
/* double the buffer for the next loop */
nSize *= 2;
} while(Status == STATUS_INFO_LENGTH_MISMATCH);
if(!NT_SUCCESS(Status))
{
DPRINT(FAILED_WITH_STATUS, "NtQuerySystemInformation", Status);
break;
}
*SystemModules = psmModules;
Status = STATUS_SUCCESS;
#if 0
}
__finally
{
#else
} while(0);
#endif
/* in case of failure, free the buffer */
if(!NT_SUCCESS(Status) && psmModules != NULL)
{
PsaiFree(psmModules);
}
#if 0
}
#endif
return Status;
}
NTSTATUS NTAPI
PsaWalkSystemModules(IN PRTL_PROCESS_MODULES SystemModules,
IN PSYSMOD_ENUM_ROUTINE Callback,
IN OUT PVOID CallbackContext)
{
ULONG i;
NTSTATUS Status;
/* repeat until all modules have been returned */
for(i = 0; i < SystemModules->NumberOfModules; i++)
{
/* return current module to the callback */
Status = Callback(&(SystemModules->Modules[i]), CallbackContext);
if(!NT_SUCCESS(Status))
{
return Status;
}
}
return STATUS_SUCCESS;
}
PRTL_PROCESS_MODULE_INFORMATION FASTCALL
PsaWalkFirstSystemModule(IN PRTL_PROCESS_MODULES SystemModules)
{
return &(SystemModules->Modules[0]);
}
PRTL_PROCESS_MODULE_INFORMATION FASTCALL
PsaWalkNextSystemModule(IN PRTL_PROCESS_MODULES CurrentSystemModule)
{
return (PRTL_PROCESS_MODULE_INFORMATION)((ULONG_PTR)CurrentSystemModule +
(FIELD_OFFSET(RTL_PROCESS_MODULES, Modules[1]) -
FIELD_OFFSET(RTL_PROCESS_MODULES, Modules[0])));
}
/* EOF */

148
sdk/lib/epsapi/enum/modules.c Normal file
View file

@ -0,0 +1,148 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* LICENSE: See LGPL.txt in the top level directory
* PROJECT: ReactOS system libraries
* FILE: reactos/lib/epsapi/enum/module.c
* PURPOSE: Enumerate process modules
* PROGRAMMER: KJK::Hyperion <noog@libero.it>
* UPDATE HISTORY:
* 10/06/2002: Created
* 29/08/2002: Generalized the interface to improve reusability,
* more efficient use of memory operations
* 12/02/2003: malloc and free renamed to PsaiMalloc and PsaiFree,
* for better reusability
* 02/04/2003: System modules enumeration moved into its own file
* 12/04/2003: internal PSAPI renamed EPSAPI (Extended PSAPI) and
* isolated in its own library to clear the confusion
* and improve reusability
*/
#include "precomp.h"
#include <ndk/mmfuncs.h>
#include <ndk/psfuncs.h>
#include <ndk/rtlfuncs.h>
#define NDEBUG
#include <debug.h>
NTSTATUS NTAPI
PsaEnumerateProcessModules(IN HANDLE ProcessHandle,
IN PPROCMOD_ENUM_ROUTINE Callback,
IN OUT PVOID CallbackContext)
{
NTSTATUS Status;
/* current process - use direct memory copy */
/* FIXME - compare process id instead of a handle */
if(ProcessHandle == NtCurrentProcess())
{
PLIST_ENTRY ListHead, Current;
#if 0
__try
{
#endif
ListHead = &(NtCurrentPeb()->Ldr->InLoadOrderModuleList);
Current = ListHead->Flink;
while(Current != ListHead)
{
PLDR_DATA_TABLE_ENTRY LoaderModule = CONTAINING_RECORD(Current, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
/* return the current module to the callback */
Status = Callback(ProcessHandle, LoaderModule, CallbackContext);
if(!NT_SUCCESS(Status))
{
goto Failure;
}
Current = LoaderModule->InLoadOrderLinks.Flink;
}
#if 0
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
return GetExceptionCode();
}
#endif
}
else
{
PROCESS_BASIC_INFORMATION BasicInformation;
PPEB_LDR_DATA LoaderData;
LDR_DATA_TABLE_ENTRY LoaderModule;
PLIST_ENTRY ListHead, Current;
/* query the process basic information (includes the PEB address) */
Status = NtQueryInformationProcess(ProcessHandle,
ProcessBasicInformation,
&BasicInformation,
sizeof(BasicInformation),
NULL);
if(!NT_SUCCESS(Status))
{
DPRINT(FAILED_WITH_STATUS, "NtQueryInformationProcess", Status);
goto Failure;
}
/* get the address of the PE Loader data */
Status = NtReadVirtualMemory(ProcessHandle,
&(BasicInformation.PebBaseAddress->Ldr),
&LoaderData,
sizeof(LoaderData),
NULL);
if(!NT_SUCCESS(Status))
{
DPRINT(FAILED_WITH_STATUS, "NtReadVirtualMemory", Status);
goto Failure;
}
/* head of the module list: the last element in the list will point to this */
ListHead = &LoaderData->InLoadOrderModuleList;
/* get the address of the first element in the list */
Status = NtReadVirtualMemory(ProcessHandle,
&(LoaderData->InLoadOrderModuleList.Flink),
&Current,
sizeof(Current),
NULL);
while(Current != ListHead)
{
/* read the current module */
Status = NtReadVirtualMemory(ProcessHandle,
CONTAINING_RECORD(Current, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks),
&LoaderModule,
sizeof(LoaderModule),
NULL);
if(!NT_SUCCESS(Status))
{
DPRINT(FAILED_WITH_STATUS, "NtReadVirtualMemory", Status);
goto Failure;
}
/* return the current module to the callback */
Status = Callback(ProcessHandle, &LoaderModule, CallbackContext);
if(!NT_SUCCESS(Status))
{
goto Failure;
}
/* address of the next module in the list */
Current = LoaderModule.InLoadOrderLinks.Flink;
}
}
return STATUS_SUCCESS;
Failure:
return Status;
}
/* EOF */

9
sdk/lib/epsapi/enum/precomp.h Normal file
View file

@ -0,0 +1,9 @@
#ifndef _EPSAPI_PCH_
#define _EPSAPI_PCH_
#define NTOS_MODE_USER
#include <ndk/exfuncs.h>
#include <epsapi/epsapi.h>
#endif /* _EPSAPI_PCH_ */

275
sdk/lib/epsapi/enum/processes.c Normal file
View file

@ -0,0 +1,275 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* LICENSE: See LGPL.txt in the top level directory
* PROJECT: ReactOS system libraries
* FILE: reactos/lib/epsapi/enum/processes.c
* PURPOSE: Enumerate processes and threads
* PROGRAMMER: KJK::Hyperion <noog@libero.it>
* UPDATE HISTORY:
* 10/06/2002: Created
* 29/08/2002: Generalized the interface to improve reusability,
* more efficient use of memory operations
* 12/02/2003: malloc and free renamed to PsaiMalloc and PsaiFree,
* for better reusability. PsaEnumerateProcesses now
* expanded into:
* - PsaCaptureProcessesAndThreads
* - PsaFreeCapture
* - PsaWalkProcessesAndThreads
* - PsaWalkProcesses
* - PsaWalkThreads
* - PsaWalkFirstProcess
* - PsaWalkNextProcess
* - PsaWalkFirstThread
* - PsaWalkNextThread
* - PsaEnumerateProcessesAndThreads
* - PsaEnumerateProcesses
* - PsaEnumerateThreads
* 12/04/2003: internal PSAPI renamed EPSAPI (Extended PSAPI) and
* isolated in its own library to clear the confusion
* and improve reusability
*/
#include "precomp.h"
#define NDEBUG
#include <debug.h>
NTSTATUS NTAPI
PsaCaptureProcessesAndThreads(OUT PSYSTEM_PROCESS_INFORMATION *ProcessesAndThreads)
{
PSYSTEM_PROCESS_INFORMATION pInfoBuffer = NULL;
SIZE_T nSize = 0x8000;
NTSTATUS Status;
if(ProcessesAndThreads == NULL)
{
return STATUS_INVALID_PARAMETER_1;
}
/* FIXME: if the system has loaded several processes and threads, the buffer
could get really big. But if there's several processes and threads, the
system is already under stress, and a huge buffer could only make things
worse. The function should be profiled to see what's the average minimum
buffer size, to succeed on the first shot */
do
{
PVOID pTmp;
/* free the buffer, and reallocate it to the new size. RATIONALE: since we
ignore the buffer's contents at this point, there's no point in a realloc()
that could end up copying a large chunk of data we'd discard anyway */
PsaiFree(pInfoBuffer);
pTmp = PsaiMalloc(nSize);
if(pTmp == NULL)
{
DPRINT(FAILED_WITH_STATUS, "PsaiMalloc", STATUS_NO_MEMORY);
Status = STATUS_NO_MEMORY;
break;
}
pInfoBuffer = pTmp;
/* query the information */
Status = NtQuerySystemInformation(SystemProcessInformation,
pInfoBuffer,
nSize,
NULL);
/* double the buffer size */
nSize *= 2;
} while(Status == STATUS_INFO_LENGTH_MISMATCH);
if(!NT_SUCCESS(Status))
{
DPRINT(FAILED_WITH_STATUS, "NtQuerySystemInformation", Status);
return Status;
}
*ProcessesAndThreads = pInfoBuffer;
return STATUS_SUCCESS;
}
NTSTATUS NTAPI
PsaWalkProcessesAndThreads(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads,
IN PPROC_ENUM_ROUTINE ProcessCallback,
IN OUT PVOID ProcessCallbackContext,
IN PTHREAD_ENUM_ROUTINE ThreadCallback,
IN OUT PVOID ThreadCallbackContext)
{
NTSTATUS Status;
if(ProcessCallback == NULL && ThreadCallback == NULL)
{
return STATUS_INVALID_PARAMETER;
}
Status = STATUS_SUCCESS;
ProcessesAndThreads = PsaWalkFirstProcess(ProcessesAndThreads);
/* scan the process list */
do
{
if(ProcessCallback)
{
Status = ProcessCallback(ProcessesAndThreads, ProcessCallbackContext);
if(!NT_SUCCESS(Status))
{
break;
}
}
/* if the caller provided a thread callback */
if(ThreadCallback)
{
ULONG i;
PSYSTEM_THREAD_INFORMATION pCurThread;
/* scan the current process's thread list */
for(i = 0, pCurThread = PsaWalkFirstThread(ProcessesAndThreads);
i < ProcessesAndThreads->NumberOfThreads;
i++, pCurThread = PsaWalkNextThread(pCurThread))
{
Status = ThreadCallback(pCurThread, ThreadCallbackContext);
if(!NT_SUCCESS(Status))
{
goto Bail;
}
}
}
/* move to the next process */
ProcessesAndThreads = PsaWalkNextProcess(ProcessesAndThreads);
} while(ProcessesAndThreads);
Bail:
return Status;
}
NTSTATUS NTAPI
PsaEnumerateProcessesAndThreads(IN PPROC_ENUM_ROUTINE ProcessCallback,
IN OUT PVOID ProcessCallbackContext,
IN PTHREAD_ENUM_ROUTINE ThreadCallback,
IN OUT PVOID ThreadCallbackContext)
{
PSYSTEM_PROCESS_INFORMATION pInfoBuffer = NULL;
NTSTATUS Status;
if(ProcessCallback == NULL && ThreadCallback == NULL)
{
return STATUS_INVALID_PARAMETER;
}
/* get the processes and threads list */
Status = PsaCaptureProcessesAndThreads(&pInfoBuffer);
if(!NT_SUCCESS(Status))
{
goto Bail;
}
/* walk the processes and threads list */
Status = PsaWalkProcessesAndThreads(pInfoBuffer,
ProcessCallback,
ProcessCallbackContext,
ThreadCallback,
ThreadCallbackContext);
Bail:
PsaFreeCapture(pInfoBuffer);
return Status;
}
VOID NTAPI
PsaFreeCapture(IN PVOID Capture)
{
PsaiFree(Capture);
}
NTSTATUS NTAPI
PsaWalkProcesses(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads,
IN PPROC_ENUM_ROUTINE Callback,
IN OUT PVOID CallbackContext)
{
return PsaWalkProcessesAndThreads(ProcessesAndThreads,
Callback,
CallbackContext,
NULL,
NULL);
}
NTSTATUS NTAPI
PsaWalkThreads(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads,
IN PTHREAD_ENUM_ROUTINE Callback,
IN OUT PVOID CallbackContext)
{
return PsaWalkProcessesAndThreads(ProcessesAndThreads,
NULL,
NULL,
Callback,
CallbackContext);
}
NTSTATUS NTAPI
PsaEnumerateProcesses(IN PPROC_ENUM_ROUTINE Callback,
IN OUT PVOID CallbackContext)
{
return PsaEnumerateProcessesAndThreads(Callback,
CallbackContext,
NULL,
NULL);
}
NTSTATUS NTAPI
PsaEnumerateThreads(IN PTHREAD_ENUM_ROUTINE Callback,
IN OUT PVOID CallbackContext)
{
return PsaEnumerateProcessesAndThreads(NULL,
NULL,
Callback,
CallbackContext);
}
PSYSTEM_PROCESS_INFORMATION FASTCALL
PsaWalkFirstProcess(IN PSYSTEM_PROCESS_INFORMATION ProcessesAndThreads)
{
return ProcessesAndThreads;
}
PSYSTEM_PROCESS_INFORMATION FASTCALL
PsaWalkNextProcess(IN PSYSTEM_PROCESS_INFORMATION CurrentProcess)
{
if(CurrentProcess->NextEntryOffset == 0)
{
return NULL;
}
else
{
return (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)CurrentProcess + CurrentProcess->NextEntryOffset);
}
}
PSYSTEM_THREAD_INFORMATION FASTCALL
PsaWalkFirstThread(IN PSYSTEM_PROCESS_INFORMATION CurrentProcess)
{
static SIZE_T nOffsetOfThreads = 0;
/* get the offset of the Threads field */
nOffsetOfThreads = sizeof(SYSTEM_PROCESS_INFORMATION);
return (PSYSTEM_THREAD_INFORMATION)((ULONG_PTR)CurrentProcess + nOffsetOfThreads);
}
PSYSTEM_THREAD_INFORMATION FASTCALL
PsaWalkNextThread(IN PSYSTEM_THREAD_INFORMATION CurrentThread)
{
return (PSYSTEM_THREAD_INFORMATION)((ULONG_PTR)CurrentThread +
((sizeof(SYSTEM_PROCESS_INFORMATION) + sizeof(SYSTEM_THREAD_INFORMATION)) -
sizeof(SYSTEM_PROCESS_INFORMATION)));
}
/* EOF */