/*
* Driver cancel declaration
*/
-typedef NTSTATUS (*PDRIVER_CANCEL)(struct _DRIVER_OBJECT* DriverObject,
- PUNICODE_STRING RegistryPath);
+typedef NTSTATUS (*PDRIVER_CANCEL)(struct _DEVICE_OBJECT* DeviceObject,
+ struct _IRP* RegistryPath);
typedef struct _SECTION_OBJECT_POINTERS
#define SET_LARGE_INTEGER_LOW_PART(LI, LP) \
( (LI) = ((LI) & 0xFFFFFFFF00000000L) | (LP) )
#define LARGE_INTEGER_QUAD_PART(LI) (LI)
+#define INITIALIZE_LARGE_INTEGER (0)
typedef long long int LONGLONG, *PLONGLONG;
typedef unsigned long long int ULONGLONG, *PULONGLONG;
#define SET_LARGE_INTEGER_LOW_PART(LargeInteger,Unsigned_Long) \
((LargeInteger).LowPart = (Unsigned_Long))
#define LARGE_INTEGER_QUAD_PART(LI) (*(LONGLONG *)(&(LI)))
+#define INITIALIZE_LARGE_INTEGER ({0,0})
typedef double LONGLONG, *PLONGLONG;
typedef double ULONGLONG, *PULONGLONG;
LARGE_INTEGER RtlConvertLongToLargeInteger(LONG SignedInteger);
LARGE_INTEGER RtlConvertUlongToLargeInteger(ULONG UnsignedInteger);
VOID RtlCopyBytes(PVOID Destination, CONST VOID* Source, ULONG Length);
-VOID RtlCopyMemory(VOID* Destination, VOID* Source, ULONG Length);
+VOID RtlCopyMemory(VOID* Destination, CONST VOID* Source, ULONG Length);
VOID RtlCopyString(PSTRING DestinationString, PSTRING SourceString);
VOID RtlCopyUnicodeString(PUNICODE_STRING DestinationString,
PUNICODE_STRING SourceString);
VOID IoInitCancelHandling(VOID);
VOID IoInitSymbolicLinkImplementation(VOID);
+VOID IoInitFileSystemImplementation(VOID);
NTSTATUS IoTryToMountStorageDevice(PDEVICE_OBJECT DeviceObject);
POBJECT IoOpenSymlink(POBJECT SymbolicLink);
PVOID Parent,
PWSTR RemainingPath,
POBJECT_ATTRIBUTES ObjectAttributes);
+NTSTATUS IoAttachVpb(PDEVICE_OBJECT DeviceObject);
#endif
VOID KeAcquireDispatcherDatabaseLock(BOOLEAN Wait);
VOID KeReleaseDispatcherDatabaseLock(BOOLEAN Wait);
VOID KeDispatcherObjectWake(DISPATCHER_HEADER* hdr);
+VOID KeDispatcherObjectWakeAll(DISPATCHER_HEADER* hdr);
VOID KiInterruptDispatch(ULONG irq);
VOID KiDispatchInterrupt(ULONG irq);
VOID KeInitIRQ(VOID);
VOID KeInitTimer(VOID);
VOID KeInitDpc(VOID);
-VOID KeInitBugCheck(VOID);
VOID KeInitDispatcher(VOID);
VOID KeCalibrateTimerLoop(VOID);
VOID KeInitializeDispatcher(VOID);
VOID KeInitializeTimerImpl(VOID);
+VOID KeInitializeBugCheck(VOID);
#endif
NTSTATUS LdrLoadDriver(PUNICODE_STRING Filename);
NTSTATUS LdrLoadInitialProcess(VOID);
VOID LdrLoadAutoConfigDrivers(VOID);
+VOID LdrInitModuleManagement(VOID);
+NTSTATUS LdrProcessDriver(PVOID ModuleLoadBase);
--- /dev/null
+VOID NtInitializeEventImplementation(VOID);
POBJECT_ATTRIBUTES ObjectAttributes,
POBJECT_TYPE Type);
VOID ObRemoveEntry(POBJECT_HEADER Header);
+NTSTATUS ObPerformRetentionChecks(POBJECT_HEADER Header);
/*
* FUNCTION: Creates an entry within a directory
VOID ObCreateHandleTable(PEPROCESS Parent,
BOOLEAN Inherit,
PEPROCESS Process);
+NTSTATUS ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
+ PVOID* ReturnedObject,
+ PWSTR* RemainingPath);
#endif /* __INCLUDE_INTERNAL_OBJMGR_H */
VOID PsInitIdleThread(VOID);
VOID PsDispatchThread(VOID);
VOID PiTerminateProcessThreads(PEPROCESS Process, NTSTATUS ExitStatus);
+VOID PsTerminateOtherThread(PETHREAD Thread, NTSTATUS ExitStatus);
+VOID PsReleaseThread(PETHREAD Thread);
/*
* PURPOSE: Thread states
BOOLEAN HalInitTask(PETHREAD thread, PKSTART_ROUTINE fn, PVOID StartContext);
void HalTaskSwitch(PKTHREAD thread);
NTSTATUS HalInitTaskWithContext(PETHREAD Thread, PCONTEXT Context);
+NTSTATUS HalReleaseTask(PETHREAD Thread);
#endif
-#ifndef _LINUX_TYPES_H
-#define _LINUX_TYPES_H
-
-#ifndef NULL
-# define NULL ((void *) 0)
-#endif
-
-
-#ifndef _I386_TYPES_H
-#define _I386_TYPES_H
-
-/*
- * __xx is ok: it doesn't pollute the POSIX namespace. Use these in the
- * header files exported to user space
- */
-
-typedef __signed__ char __s8;
-typedef unsigned char __u8;
-
-typedef __signed__ short __s16;
-typedef unsigned short __u16;
-
-typedef __signed__ int __s32;
-typedef unsigned int __u32;
-
-#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
-typedef __signed__ long long __s64;
-typedef unsigned long long __u64;
-#endif
-
-/*
- * These aren't exported outside the kernel to avoid name space clashes
- */
-#ifdef __KERNEL__
-
-typedef signed char s8;
-typedef unsigned char u8;
-
-typedef signed short s16;
-typedef unsigned short u16;
-
-typedef signed int s32;
-typedef unsigned int u32;
-
-typedef signed long long s64;
-typedef unsigned long long u64;
-
-#endif /* __KERNEL__ */
-
-#endif
-
-
-#ifndef SIZE_T_DEFINED
-#define SIZE_T_DEFINED
-typedef unsigned int size_t;
-#endif
-
-typedef size_t __kernel_size_t;
-
-#endif /* _LINUX_TYPES_H */
--- /dev/null
+typedef NTSTATUS (*PEPFUNC)(VOID);
+
+typedef struct _DLL
+{
+ PIMAGE_NT_HEADERS Headers;
+ PVOID BaseAddress;
+ HANDLE SectionHandle;
+ struct _DLL* Prev;
+ struct _DLL* Next;
+} DLL, *PDLL;
+
+#define RVA(m, b) ((ULONG)b + m)
+
+extern DLL LdrDllListHead;
+
+PEPFUNC LdrPEStartup(PVOID ImageBase, HANDLE SectionHandle);
extern void dprintf(char* fmt,...);
+#define UNIMPLEMENTED dprintf("%s in %s:%d is unimplemented\n",__FUNCTION__,__FILE__,__LINE__);
+
#ifdef NDEBUG
#define DPRINT(args...)
#else
--- /dev/null
+VOID WINAPI __RtlInitHeap(PVOID base, ULONG minsize, ULONG maxsize);
+
+#define HEAP_BASE (0xa0000000)
+
+VOID RtlDeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
+VOID RtlEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
+VOID RtlInitializeCriticalSection(LPCRITICAL_SECTION pcritical);
+VOID RtlLeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
+WINBOOL RtlTryEntryCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
RtlValidateHeap@12
RtlInitAnsiString
RtlInitUnicodeString
-RtlLargeIntegerDivide
RtlLargeIntegerAdd
+RtlLargeIntegerDivide
RtlEnlargedIntegerMultiply
RtlEnlargedUnsignedMultiply
RtlExtendedIntegerMultiply
wcschr
wcscat
wcscmp
-wcsicmp
-wcsnicmp
wcsncpy
wcslen
wcsrchr
+wcsicmp
+wcsnicmp
vsprintf
#include <ddk/ntddk.h>
#include <pe.h>
#include <string.h>
-#include <internal/string.h>
#include <wchar.h>
+#include <ntdll/ldr.h>
+#include <ntdll/rtl.h>
//#define NDEBUG
#include <ntdll/ntdll.h>
-PVOID WINAPI __RtlInitHeap(LPVOID base, ULONG minsize, ULONG maxsize);
-
-/* MACROS ********************************************************************/
-
-#define RVA(m, b) ((ULONG)b + m)
-
-/* TYPEDEFS ******************************************************************/
-
-typedef NTSTATUS (*PEPFUNC)(VOID);
-
-typedef struct _DLL
-{
- PIMAGE_NT_HEADERS Headers;
- PVOID BaseAddress;
- struct _DLL* Prev;
- struct _DLL* Next;
-} DLL, *PDLL;
-
/* GLOBALS *******************************************************************/
-static DLL DllListHead;
-
-#define HEAP_BASE (0xa0000000)
-
-/* FORWARD DECLARATIONS ******************************************************/
-
-static PEPFUNC LdrPEStartup(DWORD ImageBase, HANDLE SectionHandle);
+DLL LdrDllListHead;
+extern unsigned int _image_base__;
/* FUNCTIONS *****************************************************************/
-static NTSTATUS LdrMapSections(PVOID ImageBase, HANDLE SectionHandle,
- PIMAGE_NT_HEADERS NTHeaders)
-{
- ULONG i;
- NTSTATUS Status;
-
- for (i=0; i<NTHeaders->FileHeader.NumberOfSections; i++)
- {
- PIMAGE_SECTION_HEADER Sections;
- LARGE_INTEGER Offset;
- ULONG Base;
-
- Sections = (PIMAGE_SECTION_HEADER)SECHDROFFSET(ImageBase);
- Base = Sections[i].VirtualAddress + ImageBase;
- SET_LARGE_INTEGER_HIGH_PART(Offset,0);
- SET_LARGE_INTEGER_LOW_PART(Offset,Sections[i].PointerToRawData);
- Status = ZwMapViewOfSection(SectionHandle,
- NtCurrentProcess(),
- (PVOID *)&Base,
- 0,
- Sections[i].Misc.VirtualSize,
- &Offset,
- &Sections[i].Misc.VirtualSize,
- 0,
- MEM_COMMIT,
- PAGE_READWRITE);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
- }
- return(STATUS_SUCCESS);
-}
-
-static NTSTATUS LdrLoadDll(PDLL* Base, PCHAR Name)
-{
- char fqname[255] = "\\??\\C:\\reactos\\system\\";
- ANSI_STRING AnsiString;
- UNICODE_STRING UnicodeString;
- OBJECT_ATTRIBUTES FileObjectAttributes;
- char BlockBuffer[1024];
- PIMAGE_DOS_HEADER DosHeader;
- NTSTATUS Status;
- PIMAGE_NT_HEADERS NTHeaders;
- PEPFUNC DllStartupAddr;
- ULONG ImageBase, ImageSize, InitialViewSize;
- HANDLE FileHandle, SectionHandle;
- PDLL DllDesc;
-
- DPRINT("LdrLoadDll(Base %x, Name %s)\n",Base,Name);
-
- strcat(fqname, Name);
-
- DPRINT("fqname %s\n",fqname);
-
- RtlInitAnsiString(&AnsiString,fqname);
- RtlAnsiStringToUnicodeString(&UnicodeString,&AnsiString,TRUE);
-
- InitializeObjectAttributes(&FileObjectAttributes,
- &UnicodeString,
- 0,
- NULL,
- NULL);
- DPRINT("Opening dll\n");
- Status = ZwOpenFile(&FileHandle, FILE_ALL_ACCESS, &FileObjectAttributes,
- NULL, 0, 0);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("Dll open failed ");
- return Status;
- }
- Status = ZwReadFile(FileHandle, 0, 0, 0, 0, BlockBuffer, 1024, 0, 0);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("Dll header read failed ");
- ZwClose(FileHandle);
- return Status;
- }
-
- DosHeader = (PIMAGE_DOS_HEADER) BlockBuffer;
- if (DosHeader->e_magic != IMAGE_DOS_MAGIC ||
- DosHeader->e_lfanew == 0L ||
- *(PULONG)((PUCHAR)BlockBuffer + DosHeader->e_lfanew) != IMAGE_PE_MAGIC)
- {
- DPRINT("NTDLL format invalid\n");
- ZwClose(FileHandle);
-
- return STATUS_UNSUCCESSFUL;
- }
- NTHeaders = (PIMAGE_NT_HEADERS)(BlockBuffer + DosHeader->e_lfanew);
- ImageBase = NTHeaders->OptionalHeader.ImageBase;
- ImageSize = NTHeaders->OptionalHeader.SizeOfImage;
-
- DPRINT("ImageBase %x\n",ImageBase);
- DllStartupAddr = ImageBase + NTHeaders->OptionalHeader.AddressOfEntryPoint;
-
- /* Create a section for NTDLL */
- Status = ZwCreateSection(&SectionHandle,
- SECTION_ALL_ACCESS,
- NULL,
- NULL,
- PAGE_READWRITE,
- MEM_COMMIT,
- FileHandle);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("NTDLL create section failed ");
- ZwClose(FileHandle);
- return Status;
- }
-
- /* Map the NTDLL into the process */
- InitialViewSize = DosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS)
- + sizeof(IMAGE_SECTION_HEADER) * NTHeaders->FileHeader.NumberOfSections;
- Status = ZwMapViewOfSection(SectionHandle,
- NtCurrentProcess(),
- (PVOID *)&ImageBase,
- 0,
- InitialViewSize,
- NULL,
- &InitialViewSize,
- 0,
- MEM_COMMIT,
- PAGE_READWRITE);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("NTDLL map view of secion failed ");
- ZwClose(FileHandle);
-
- return Status;
- }
- ZwClose(FileHandle);
-
- DllDesc = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DLL));
- DllDesc->Headers = NTHeaders;
- DllDesc->BaseAddress = ImageBase;
- DllDesc->Next = DllListHead.Next;
- DllDesc->Prev = &DllListHead;
- DllListHead.Next->Prev = DllDesc;
- DllListHead.Next = DllDesc;
-
- LdrPEStartup(ImageBase, SectionHandle);
-
- *Base = DllDesc;
-
- return(STATUS_SUCCESS);
-}
-
-static NTSTATUS LdrFindDll(PDLL* Base, PCHAR Name)
-{
- PIMAGE_EXPORT_DIRECTORY ExportDir;
- DLL* current;
- PIMAGE_OPTIONAL_HEADER OptionalHeader;
-
- DPRINT("LdrFindDll(Name %s)\n",Name);
-
- current = &DllListHead;
- do
- {
- OptionalHeader = ¤t->Headers->OptionalHeader;
- ExportDir = (PIMAGE_EXPORT_DIRECTORY)OptionalHeader->DataDirectory[
- IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
- ExportDir = ((ULONG)ExportDir + (ULONG)current->BaseAddress);
-
- DPRINT("Scanning %s\n",ExportDir->Name + current->BaseAddress);
- if (strcmp(ExportDir->Name + current->BaseAddress, Name) == 0)
- {
- *Base = current;
- return(STATUS_SUCCESS);
- }
-
- current = current->Next;
- } while (current != &DllListHead);
-
- DPRINT("Failed to find dll %s\n",Name);
-
- return(LdrLoadDll(Base, Name));
-}
-
/* LdrStartup
* FUNCTION:
* Handles Process Startup Activities.
DPRINT("LdrStartup(ImageBase %x, SectionHandle %x)\n",ImageBase,
SectionHandle);
- DllListHead.BaseAddress = 0x80000000;
- DllListHead.Prev = &DllListHead;
- DllListHead.Next = &DllListHead;
- PEDosHeader = (PIMAGE_DOS_HEADER)DllListHead.BaseAddress;
- DllListHead.Headers = (PIMAGE_NT_HEADERS)(DllListHead.BaseAddress +
- PEDosHeader->e_lfanew);
+ DPRINT("&_image_base__ %x\n",&_image_base__);
+ LdrDllListHead.BaseAddress = (PVOID)&_image_base__;
+ LdrDllListHead.Prev = &LdrDllListHead;
+ LdrDllListHead.Next = &LdrDllListHead;
+ LdrDllListHead.SectionHandle = SectionHandle;
+ PEDosHeader = (PIMAGE_DOS_HEADER)LdrDllListHead.BaseAddress;
+ LdrDllListHead.Headers = (PIMAGE_NT_HEADERS)(LdrDllListHead.BaseAddress +
+ PEDosHeader->e_lfanew);
/* If MZ header exists */
PEDosHeader = (PIMAGE_DOS_HEADER) ImageBase;
}
NTHeaders = (PIMAGE_NT_HEADERS)(ImageBase + PEDosHeader->e_lfanew);
- __RtlInitHeap(HEAP_BASE,
+ __RtlInitHeap((PVOID)HEAP_BASE,
NTHeaders->OptionalHeader.SizeOfHeapCommit,
NTHeaders->OptionalHeader.SizeOfHeapReserve);
- EntryPoint = LdrPEStartup(ImageBase, SectionHandle);
+ EntryPoint = LdrPEStartup((PVOID)ImageBase, SectionHandle);
if (EntryPoint == NULL)
{
Status = EntryPoint();
ZwTerminateProcess(NtCurrentProcess(),Status);
}
-
-static PVOID LdrGetExportByOrdinal(PDLL Module, ULONG Ordinal)
-{
- PIMAGE_EXPORT_DIRECTORY ExportDir;
- USHORT* ExOrdinals;
-
- ExportDir = (Module->BaseAddress +
- (Module->Headers->OptionalHeader.
- DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress));
-
- ExOrdinals = (USHORT*)RVA(Module->BaseAddress,
- ExportDir->AddressOfNameOrdinals);
- return(ExOrdinals[Ordinal - ExportDir->Base]);
-}
-
-static PVOID LdrGetExportByName(PDLL Module, PUCHAR SymbolName)
-{
- PIMAGE_EXPORT_DIRECTORY ExportDir;
- PDWORD* ExFunctions;
- PDWORD* ExNames;
- USHORT* ExOrdinals;
- ULONG i;
- PVOID ExName;
- ULONG Ordinal;
-
- DPRINT("LdrFindExport(Module %x, SymbolName %s)\n",
- Module, SymbolName);
-
- ExportDir = (Module->BaseAddress +
- (Module->Headers->OptionalHeader.
- DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress));
-
- /* Get header pointers */
- ExNames = (PDWORD*)RVA(Module->BaseAddress, ExportDir->AddressOfNames);
- ExOrdinals = (USHORT*)RVA(Module->BaseAddress,
- ExportDir->AddressOfNameOrdinals);
- ExFunctions = (PDWORD*)RVA(Module->BaseAddress,
- ExportDir->AddressOfFunctions);
- for (i=0; i<ExportDir->NumberOfFunctions; i++)
- {
- ExName = RVA(Module->BaseAddress, ExNames[i]);
- if (strcmp(ExName,SymbolName) == 0)
- {
- Ordinal = ExOrdinals[i];
- return(RVA(Module->BaseAddress, ExFunctions[Ordinal]));
- }
- }
- return(NULL);
-}
-
-static NTSTATUS LdrPerformRelocations(PIMAGE_NT_HEADERS NTHeaders,
- DWORD ImageBase)
-{
- USHORT NumberOfEntries;
- PUSHORT pValue16;
- ULONG RelocationRVA;
- ULONG Delta32, Offset;
- PULONG pValue32;
- PRELOCATION_DIRECTORY RelocationDir;
- PRELOCATION_ENTRY RelocationBlock;
- int i;
-
- RelocationRVA = NTHeaders->OptionalHeader.DataDirectory[
- IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress;
- if (RelocationRVA)
- {
- RelocationDir = (PRELOCATION_DIRECTORY)((PCHAR)ImageBase +
- RelocationRVA);
- while (RelocationDir->SizeOfBlock)
- {
- Delta32 = (unsigned long)(ImageBase -
- NTHeaders->OptionalHeader.ImageBase);
- RelocationBlock = (PRELOCATION_ENTRY)
- (RelocationRVA + ImageBase + sizeof(RELOCATION_DIRECTORY));
- NumberOfEntries =
- (RelocationDir->SizeOfBlock - sizeof(RELOCATION_DIRECTORY)) /
- sizeof(RELOCATION_ENTRY);
- for (i = 0; i < NumberOfEntries; i++)
- {
- Offset = (RelocationBlock[i].TypeOffset & 0xfff) +
- RelocationDir->VirtualAddress;
- switch (RelocationBlock[i].TypeOffset >> 12)
- {
- case TYPE_RELOC_ABSOLUTE:
- break;
-
- case TYPE_RELOC_HIGH:
- pValue16 = (PUSHORT) (ImageBase + Offset);
- *pValue16 += Delta32 >> 16;
- break;
-
- case TYPE_RELOC_LOW:
- pValue16 = (PUSHORT)(ImageBase + Offset);
- *pValue16 += Delta32 & 0xffff;
- break;
-
- case TYPE_RELOC_HIGHLOW:
- pValue32 = (PULONG) (ImageBase + Offset);
- *pValue32 += Delta32;
- break;
-
- case TYPE_RELOC_HIGHADJ:
- /* FIXME: do the highadjust fixup */
- DPRINT("TYPE_RELOC_HIGHADJ fixup not implemented"
- ", sorry\n");
- return(STATUS_UNSUCCESSFUL);
-
- default:
- DPRINT("unexpected fixup type\n");
- return(STATUS_UNSUCCESSFUL);
- }
- }
- RelocationRVA += RelocationDir->SizeOfBlock;
- RelocationDir = (PRELOCATION_DIRECTORY)(ImageBase +
- RelocationRVA);
- }
- }
- return(STATUS_SUCCESS);
-}
-
-static NTSTATUS LdrFixupImports(PIMAGE_NT_HEADERS NTHeaders,
- DWORD ImageBase)
-{
- PIMAGE_IMPORT_MODULE_DIRECTORY ImportModuleDirectory;
- ULONG Ordinal;
- PDLL Module;
- NTSTATUS Status;
-
- /* Process each import module */
- ImportModuleDirectory = (PIMAGE_IMPORT_MODULE_DIRECTORY)
- (ImageBase + NTHeaders->OptionalHeader.
- DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
- while (ImportModuleDirectory->dwRVAModuleName)
- {
- PVOID *ImportAddressList;
- PULONG FunctionNameList;
- DWORD pName;
- PWORD pHint;
-
- Status = LdrFindDll(&Module,
- (PCHAR)(ImageBase +
- ImportModuleDirectory->dwRVAModuleName));
- if (!NT_SUCCESS(Status))
- {
- return 0;
- }
-
- /* Get the import address list */
- ImportAddressList = (PVOID *)
- (NTHeaders->OptionalHeader.ImageBase +
- ImportModuleDirectory->dwRVAFunctionAddressList);
-
- /* Get the list of functions to import */
- if (ImportModuleDirectory->dwRVAFunctionNameList != 0)
- {
- FunctionNameList = (PULONG) (ImageBase +
- ImportModuleDirectory->dwRVAFunctionNameList);
- }
- else
- {
- FunctionNameList = (PULONG) (ImageBase +
- ImportModuleDirectory->dwRVAFunctionAddressList);
- }
-
- /* Walk through function list and fixup addresses */
- while(*FunctionNameList != 0L)
- {
- if ((*FunctionNameList) & 0x80000000)
- {
- Ordinal = (*FunctionNameList) & 0x7fffffff;
- *ImportAddressList = LdrGetExportByOrdinal(Module, Ordinal);
- }
- else
- {
- pName = (DWORD)(ImageBase + *FunctionNameList + 2);
- pHint = (PWORD)(ImageBase + *FunctionNameList);
-
- *ImportAddressList = LdrGetExportByName(Module,pName);
- if ((*ImportAddressList) == NULL)
- {
- return(STATUS_UNSUCCESSFUL);
- }
- }
-
- ImportAddressList++;
- FunctionNameList++;
- }
- ImportModuleDirectory++;
- }
- return(STATUS_SUCCESS);
-}
-
-static PEPFUNC LdrPEStartup(DWORD ImageBase, HANDLE SectionHandle)
-{
- NTSTATUS Status;
- PEPFUNC EntryPoint;
- PIMAGE_DOS_HEADER DosHeader;
- PIMAGE_NT_HEADERS NTHeaders;
-
- DosHeader = (PIMAGE_DOS_HEADER) ImageBase;
- NTHeaders = (PIMAGE_NT_HEADERS)(ImageBase + DosHeader->e_lfanew);
-
- /* Initialize Image sections */
- LdrMapSections(ImageBase, SectionHandle, NTHeaders);
-
- if (ImageBase != (DWORD) NTHeaders->OptionalHeader.ImageBase)
- {
- Status = LdrPerformRelocations(NTHeaders, ImageBase);
- if (!NT_SUCCESS(Status))
- {
- return(NULL);
- }
- }
-
- if (NTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].
- VirtualAddress != 0)
- {
- Status = LdrFixupImports(NTHeaders, ImageBase);
- if (!NT_SUCCESS(Status))
- {
- return(NULL);
- }
- }
-
- EntryPoint = ImageBase + NTHeaders->OptionalHeader.AddressOfEntryPoint;
-
- return(EntryPoint);
-}
-
-
-
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: lib/ntdll/ldr/startup.c
+ * PURPOSE: Process startup for PE executables
+ * PROGRAMMERS: Jean Michault
+ * Rex Jolliff (rex@lvcablemodem.com)
+ */
+
+/* INCLUDES *****************************************************************/
+
+#define WIN32_NO_PEHDR
+#include <windows.h>
+#include <ddk/ntddk.h>
+#include <pe.h>
+#include <string.h>
+#include <internal/string.h>
+#include <wchar.h>
+#include <ntdll/ldr.h>
+
+//#define NDEBUG
+#include <ntdll/ntdll.h>
+
+/* FUNCTIONS *****************************************************************/
+
+static NTSTATUS LdrLoadDll(PDLL* Dll, PCHAR Name)
+{
+ char fqname[255] = "\\??\\C:\\reactos\\system\\";
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+ OBJECT_ATTRIBUTES FileObjectAttributes;
+ char BlockBuffer[1024];
+ PIMAGE_DOS_HEADER DosHeader;
+ NTSTATUS Status;
+ PIMAGE_NT_HEADERS NTHeaders;
+ PEPFUNC DllStartupAddr;
+ ULONG ImageSize, InitialViewSize;
+ PVOID ImageBase;
+ HANDLE FileHandle, SectionHandle;
+
+ DPRINT("LdrLoadDll(Base %x, Name %s)\n",Dll,Name);
+
+ strcat(fqname, Name);
+
+ DPRINT("fqname %s\n",fqname);
+
+ RtlInitAnsiString(&AnsiString,fqname);
+ RtlAnsiStringToUnicodeString(&UnicodeString,&AnsiString,TRUE);
+
+ InitializeObjectAttributes(&FileObjectAttributes,
+ &UnicodeString,
+ 0,
+ NULL,
+ NULL);
+ DPRINT("Opening dll\n");
+ Status = ZwOpenFile(&FileHandle, FILE_ALL_ACCESS, &FileObjectAttributes,
+ NULL, 0, 0);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("Dll open failed ");
+ return Status;
+ }
+ Status = ZwReadFile(FileHandle, 0, 0, 0, 0, BlockBuffer, 1024, 0, 0);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("Dll header read failed ");
+ ZwClose(FileHandle);
+ return Status;
+ }
+
+ DosHeader = (PIMAGE_DOS_HEADER) BlockBuffer;
+ if (DosHeader->e_magic != IMAGE_DOS_MAGIC ||
+ DosHeader->e_lfanew == 0L ||
+ *(PULONG)((PUCHAR)BlockBuffer + DosHeader->e_lfanew) != IMAGE_PE_MAGIC)
+ {
+ DPRINT("NTDLL format invalid\n");
+ ZwClose(FileHandle);
+
+ return STATUS_UNSUCCESSFUL;
+ }
+ NTHeaders = (PIMAGE_NT_HEADERS)(BlockBuffer + DosHeader->e_lfanew);
+ ImageBase = (PVOID)NTHeaders->OptionalHeader.ImageBase;
+ ImageSize = NTHeaders->OptionalHeader.SizeOfImage;
+
+ DPRINT("ImageBase %x\n",ImageBase);
+ DllStartupAddr = (PEPFUNC)(ImageBase +
+ NTHeaders->OptionalHeader.AddressOfEntryPoint);
+
+ /* Create a section for NTDLL */
+ Status = ZwCreateSection(&SectionHandle,
+ SECTION_ALL_ACCESS,
+ NULL,
+ NULL,
+ PAGE_READWRITE,
+ MEM_COMMIT,
+ FileHandle);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("NTDLL create section failed ");
+ ZwClose(FileHandle);
+ return Status;
+ }
+
+ /* Map the NTDLL into the process */
+ InitialViewSize = DosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS)
+ + sizeof(IMAGE_SECTION_HEADER) * NTHeaders->FileHeader.NumberOfSections;
+ Status = ZwMapViewOfSection(SectionHandle,
+ NtCurrentProcess(),
+ (PVOID *)&ImageBase,
+ 0,
+ InitialViewSize,
+ NULL,
+ &InitialViewSize,
+ 0,
+ MEM_COMMIT,
+ PAGE_READWRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("NTDLL map view of secion failed ");
+ ZwClose(FileHandle);
+
+ return Status;
+ }
+ ZwClose(FileHandle);
+
+ (*Dll) = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DLL));
+ (*Dll)->Headers = NTHeaders;
+ (*Dll)->BaseAddress = (PVOID)ImageBase;
+ (*Dll)->Next = LdrDllListHead.Next;
+ (*Dll)->Prev = &LdrDllListHead;
+ LdrDllListHead.Next->Prev = (*Dll);
+ LdrDllListHead.Next = (*Dll);
+
+ LdrPEStartup(ImageBase, SectionHandle);
+
+ return(STATUS_SUCCESS);
+}
+
+static NTSTATUS LdrFindDll(PDLL* Dll, PCHAR Name)
+{
+ PIMAGE_EXPORT_DIRECTORY ExportDir;
+ DLL* current;
+ PIMAGE_OPTIONAL_HEADER OptionalHeader;
+
+ DPRINT("LdrFindDll(Name %s)\n",Name);
+
+ current = &LdrDllListHead;
+ do
+ {
+ OptionalHeader = ¤t->Headers->OptionalHeader;
+ ExportDir = (PIMAGE_EXPORT_DIRECTORY)OptionalHeader->DataDirectory[
+ IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
+ ExportDir = (PIMAGE_EXPORT_DIRECTORY)
+ ((ULONG)ExportDir + (ULONG)current->BaseAddress);
+
+ DPRINT("Scanning %x %x %x\n", ExportDir->Name,
+ current->BaseAddress, ExportDir->Name + current->BaseAddress);
+ DPRINT("Scanning %s\n", ExportDir->Name + current->BaseAddress);
+ if (strcmp(ExportDir->Name + current->BaseAddress, Name) == 0)
+ {
+ *Dll = current;
+ return(STATUS_SUCCESS);
+ }
+
+ current = current->Next;
+ } while (current != &LdrDllListHead);
+
+ DPRINT("Failed to find dll %s\n",Name);
+
+ return(LdrLoadDll(Dll, Name));
+}
+
+static NTSTATUS LdrMapSections(PVOID ImageBase,
+ HANDLE SectionHandle,
+ PIMAGE_NT_HEADERS NTHeaders)
+{
+ ULONG i;
+ NTSTATUS Status;
+
+ for (i=0; i<NTHeaders->FileHeader.NumberOfSections; i++)
+ {
+ PIMAGE_SECTION_HEADER Sections;
+ LARGE_INTEGER Offset;
+ ULONG Base;
+
+ Sections = (PIMAGE_SECTION_HEADER)SECHDROFFSET(ImageBase);
+ Base = (ULONG)(Sections[i].VirtualAddress + ImageBase);
+ SET_LARGE_INTEGER_HIGH_PART(Offset,0);
+ SET_LARGE_INTEGER_LOW_PART(Offset,Sections[i].PointerToRawData);
+ Status = ZwMapViewOfSection(SectionHandle,
+ NtCurrentProcess(),
+ (PVOID *)&Base,
+ 0,
+ Sections[i].Misc.VirtualSize,
+ &Offset,
+ (PULONG)&Sections[i].Misc.VirtualSize,
+ 0,
+ MEM_COMMIT,
+ PAGE_READWRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+ }
+ return(STATUS_SUCCESS);
+}
+
+static PVOID LdrGetExportByOrdinal(PDLL Module, ULONG Ordinal)
+{
+ PIMAGE_EXPORT_DIRECTORY ExportDir;
+ PDWORD* ExFunctions;
+ USHORT* ExOrdinals;
+
+ ExportDir = (Module->BaseAddress +
+ (Module->Headers->OptionalHeader.
+ DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress));
+
+ ExOrdinals = (USHORT*)RVA(Module->BaseAddress,
+ ExportDir->AddressOfNameOrdinals);
+ ExFunctions = (PDWORD*)RVA(Module->BaseAddress,
+ ExportDir->AddressOfFunctions);
+ return(ExFunctions[ExOrdinals[Ordinal - ExportDir->Base]]);
+}
+
+static PVOID LdrGetExportByName(PDLL Module, PUCHAR SymbolName)
+{
+ PIMAGE_EXPORT_DIRECTORY ExportDir;
+ PDWORD* ExFunctions;
+ PDWORD* ExNames;
+ USHORT* ExOrdinals;
+ ULONG i;
+ PVOID ExName;
+ ULONG Ordinal;
+
+ DPRINT("LdrFindExport(Module %x, SymbolName %s)\n",
+ Module, SymbolName);
+
+ ExportDir = (Module->BaseAddress +
+ (Module->Headers->OptionalHeader.
+ DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress));
+
+ /* Get header pointers */
+ ExNames = (PDWORD*)RVA(Module->BaseAddress, ExportDir->AddressOfNames);
+ ExOrdinals = (USHORT*)RVA(Module->BaseAddress,
+ ExportDir->AddressOfNameOrdinals);
+ ExFunctions = (PDWORD*)RVA(Module->BaseAddress,
+ ExportDir->AddressOfFunctions);
+ for (i=0; i<ExportDir->NumberOfFunctions; i++)
+ {
+ ExName = RVA(Module->BaseAddress, ExNames[i]);
+ if (strcmp(ExName,SymbolName) == 0)
+ {
+ Ordinal = ExOrdinals[i];
+ return(RVA(Module->BaseAddress, ExFunctions[Ordinal]));
+ }
+ }
+ return(NULL);
+}
+
+static NTSTATUS LdrPerformRelocations(PIMAGE_NT_HEADERS NTHeaders,
+ PVOID ImageBase)
+{
+ USHORT NumberOfEntries;
+ PUSHORT pValue16;
+ ULONG RelocationRVA;
+ ULONG Delta32, Offset;
+ PULONG pValue32;
+ PRELOCATION_DIRECTORY RelocationDir;
+ PRELOCATION_ENTRY RelocationBlock;
+ int i;
+
+ RelocationRVA = NTHeaders->OptionalHeader.DataDirectory[
+ IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress;
+ if (RelocationRVA)
+ {
+ RelocationDir = (PRELOCATION_DIRECTORY)((PCHAR)ImageBase +
+ RelocationRVA);
+ while (RelocationDir->SizeOfBlock)
+ {
+ Delta32 = (unsigned long)(ImageBase -
+ NTHeaders->OptionalHeader.ImageBase);
+ RelocationBlock = (PRELOCATION_ENTRY)
+ (RelocationRVA + ImageBase + sizeof(RELOCATION_DIRECTORY));
+ NumberOfEntries =
+ (RelocationDir->SizeOfBlock - sizeof(RELOCATION_DIRECTORY)) /
+ sizeof(RELOCATION_ENTRY);
+ for (i = 0; i < NumberOfEntries; i++)
+ {
+ Offset = (RelocationBlock[i].TypeOffset & 0xfff) +
+ RelocationDir->VirtualAddress;
+ switch (RelocationBlock[i].TypeOffset >> 12)
+ {
+ case TYPE_RELOC_ABSOLUTE:
+ break;
+
+ case TYPE_RELOC_HIGH:
+ pValue16 = (PUSHORT) (ImageBase + Offset);
+ *pValue16 += Delta32 >> 16;
+ break;
+
+ case TYPE_RELOC_LOW:
+ pValue16 = (PUSHORT)(ImageBase + Offset);
+ *pValue16 += Delta32 & 0xffff;
+ break;
+
+ case TYPE_RELOC_HIGHLOW:
+ pValue32 = (PULONG) (ImageBase + Offset);
+ *pValue32 += Delta32;
+ break;
+
+ case TYPE_RELOC_HIGHADJ:
+ /* FIXME: do the highadjust fixup */
+ DPRINT("TYPE_RELOC_HIGHADJ fixup not implemented"
+ ", sorry\n");
+ return(STATUS_UNSUCCESSFUL);
+
+ default:
+ DPRINT("unexpected fixup type\n");
+ return(STATUS_UNSUCCESSFUL);
+ }
+ }
+ RelocationRVA += RelocationDir->SizeOfBlock;
+ RelocationDir = (PRELOCATION_DIRECTORY)(ImageBase +
+ RelocationRVA);
+ }
+ }
+ return(STATUS_SUCCESS);
+}
+
+static NTSTATUS LdrFixupImports(PIMAGE_NT_HEADERS NTHeaders,
+ PVOID ImageBase)
+{
+ PIMAGE_IMPORT_MODULE_DIRECTORY ImportModuleDirectory;
+ ULONG Ordinal;
+ PDLL Module;
+ NTSTATUS Status;
+
+ /* Process each import module */
+ ImportModuleDirectory = (PIMAGE_IMPORT_MODULE_DIRECTORY)
+ (ImageBase + NTHeaders->OptionalHeader.
+ DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
+ while (ImportModuleDirectory->dwRVAModuleName)
+ {
+ PVOID *ImportAddressList;
+ PULONG FunctionNameList;
+ DWORD pName;
+ PWORD pHint;
+
+ Status = LdrFindDll(&Module,
+ (PCHAR)(ImageBase +
+ ImportModuleDirectory->dwRVAModuleName));
+ if (!NT_SUCCESS(Status))
+ {
+ return 0;
+ }
+
+ /* Get the import address list */
+ ImportAddressList = (PVOID *)
+ (NTHeaders->OptionalHeader.ImageBase +
+ ImportModuleDirectory->dwRVAFunctionAddressList);
+
+ /* Get the list of functions to import */
+ if (ImportModuleDirectory->dwRVAFunctionNameList != 0)
+ {
+ FunctionNameList = (PULONG) (ImageBase +
+ ImportModuleDirectory->dwRVAFunctionNameList);
+ }
+ else
+ {
+ FunctionNameList = (PULONG) (ImageBase +
+ ImportModuleDirectory->dwRVAFunctionAddressList);
+ }
+
+ /* Walk through function list and fixup addresses */
+ while(*FunctionNameList != 0L)
+ {
+ if ((*FunctionNameList) & 0x80000000)
+ {
+ Ordinal = (*FunctionNameList) & 0x7fffffff;
+ *ImportAddressList = LdrGetExportByOrdinal(Module, Ordinal);
+ }
+ else
+ {
+ pName = (DWORD)(ImageBase + *FunctionNameList + 2);
+ pHint = (PWORD)(ImageBase + *FunctionNameList);
+
+ *ImportAddressList = LdrGetExportByName(Module,
+ (PUCHAR)pName);
+ if ((*ImportAddressList) == NULL)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+ }
+
+ ImportAddressList++;
+ FunctionNameList++;
+ }
+ ImportModuleDirectory++;
+ }
+ return(STATUS_SUCCESS);
+}
+
+PEPFUNC LdrPEStartup(PVOID ImageBase, HANDLE SectionHandle)
+{
+ NTSTATUS Status;
+ PEPFUNC EntryPoint;
+ PIMAGE_DOS_HEADER DosHeader;
+ PIMAGE_NT_HEADERS NTHeaders;
+
+ DosHeader = (PIMAGE_DOS_HEADER) ImageBase;
+ NTHeaders = (PIMAGE_NT_HEADERS)(ImageBase + DosHeader->e_lfanew);
+
+ /* Initialize Image sections */
+ LdrMapSections(ImageBase, SectionHandle, NTHeaders);
+
+ if (ImageBase != (PVOID)NTHeaders->OptionalHeader.ImageBase)
+ {
+ Status = LdrPerformRelocations(NTHeaders, ImageBase);
+ if (!NT_SUCCESS(Status))
+ {
+ return(NULL);
+ }
+ }
+
+ if (NTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].
+ VirtualAddress != 0)
+ {
+ Status = LdrFixupImports(NTHeaders, ImageBase);
+ if (!NT_SUCCESS(Status))
+ {
+ return(NULL);
+ }
+ }
+
+ EntryPoint = (PEPFUNC)(ImageBase +
+ NTHeaders->OptionalHeader.AddressOfEntryPoint);
+
+ return(EntryPoint);
+}
+
+
+
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS system libraries
+ * FILE: lib/ntdll/main/dllmain.c
+ * PURPOSE:
+ * PROGRAMMER:
+ */
#include <windows.h>
#include <stdarg.h>
+#include <stdio.h>
#include <ddk/ntddk.h>
#include <ntdll/ntdll.h>
string/strcat.o string/strcmp.o string/strcpy.o string/stricmp.o \
string/strlen.o string/strncmp.o string/strncpy.o string/strnlen.o \
string/strrchr.o string/wstring.o stubs/stubs.o rtl/heap.o \
- rtl/critical.o rtl/mem.o
+ rtl/critical.o rtl/mem.o ldr/utils.o
ntdll.a: $(OBJECTS)
$(AR) csr ntdll.a $(OBJECTS)
- $(RM) temp.exp
$(NM) --numeric-sort ntdll.dll > ntdll.sym
+#WARNINGS_ARE_ERRORS = yes
include ../../rules.mak
/* INCLUDES ******************************************************************/
#include <windows.h>
+#include <ntdll/rtl.h>
+
+#include <ntdll/ntdll.h>
/* FUNCTIONS *****************************************************************/
WINBOOL RtlTryEntryCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{
+ UNIMPLEMENTED;
+ for(;;);
}
#include <string.h>
#include <ddk/ntddk.h>
+#include <ntdll/rtl.h>
#define NDEBUG
#include <ntdll/ntdll.h>
* Called by __VirtualInit to initialize the default process heap *
*********************************************************************/
-VOID WINAPI __RtlInitHeap(LPVOID base, ULONG minsize, ULONG maxsize)
+VOID WINAPI __RtlInitHeap(PVOID base, ULONG minsize, ULONG maxsize)
{
NTSTATUS Result;
PHEAP NewHeap;
/*********************************************************************
* HeapSize -- KERNEL32 *
*********************************************************************/
-DWORD WINAPI RtlSizeHeap(HANDLE hheap, DWORD flags, LPCVOID pmem)
+DWORD WINAPI RtlSizeHeap(HANDLE hheap, DWORD flags, PVOID pmem)
{
PHEAP pheap=(PHEAP) hheap;
PHEAP_BLOCK palloc=((PHEAP_BLOCK)pmem-1);
* *
* NOTE: only implemented in NT *
*********************************************************************/
-BOOL WINAPI RtlValidateHeap(HANDLE hheap, DWORD flags, LPCVOID pmem)
+BOOL WINAPI RtlValidateHeap(HANDLE hheap, DWORD flags, PVOID pmem)
{
PHEAP pheap=(PHEAP)hheap;
PHEAP_BLOCK pcheck;
RtlCopyMemory(Destination,Source,Length);
}
-VOID RtlCopyMemory(VOID* Destination, VOID* Source, ULONG Length)
+VOID RtlCopyMemory(VOID* Destination, CONST VOID* Source, ULONG Length)
{
DPRINT("RtlCopyMemory(Destination %x Source %x Length %d\n",
Destination,Source,Length);
*/
#include <ddk/ntddk.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
#define NDEBUG
#include <internal/debug.h>
#define Aa_Difference ('A'-'a')
-PUNICODE_STRING RtlDuplicateUnicodeString(PUNICODE_STRING Dest,
- PUNICODE_STRING Src)
-{
- if (Dest==NULL)
- {
-// Dest=ExAllocatePool(NonPagedPool,sizeof(UNICODE_STRING));
- }
-}
+extern unsigned long simple_strtoul(const char *cp,
+ char **endp,
+ unsigned int base);
WCHAR wtoupper(WCHAR c)
{
NTSTATUS RtlCharToInteger(IN PCSZ String, IN ULONG Base, IN OUT PULONG Value)
{
- *Value=simple_strtoul((const char *)String, NULL, Base);
-};
+ *Value = simple_strtoul((const char *)String, NULL, Base);
+ return(STATUS_SUCCESS);
+}
LONG RtlCompareString(PSTRING String1, PSTRING String2, BOOLEAN CaseInsensitive)
{
DestinationString->Length=strlen((char *)SourceString);
DestinationString->MaximumLength=strlen((char *)SourceString)+1;
DestinationString->Buffer=SourceString;
-};
+}
VOID RtlInitUnicodeString(IN OUT PUNICODE_STRING DestinationString,
IN PCWSTR SourceString)
{
- unsigned long i, DestSize;
- UNICODE_STRING Dest=*DestinationString;
-
- if(SourceString==NULL) {
- DestinationString->Length=0;
- DestinationString->MaximumLength=0;
- DestinationString->Buffer=NULL;
- } else {
- DestSize=wcslen((PWSTR)SourceString);
- DestinationString->Length=DestSize;
- DestinationString->MaximumLength=DestSize+1;
-
- DestinationString->Buffer=(PWSTR)SourceString;
- };
-};
+ unsigned long DestSize;
+
+ if (SourceString == NULL)
+ {
+ DestinationString->Length = 0;
+ DestinationString->MaximumLength = 0;
+ DestinationString->Buffer = NULL;
+ }
+ else
+ {
+ DestSize = wcslen((PWSTR)SourceString);
+ DestinationString->Length = DestSize;
+ DestinationString->MaximumLength = DestSize+1;
+ DestinationString->Buffer = (PWSTR)SourceString;
+ }
+}
NTSTATUS RtlIntegerToUnicodeString(IN ULONG Value, IN ULONG Base, /* optional */
IN OUT PUNICODE_STRING String)
char *str;
unsigned long len, i;
-// str=ExAllocatePool(NonPagedPool, 1024);
+ str = RtlAllocateHeap(RtlGetProcessHeap, 0, 1024);
if(Base==16) {
- sprintf(str, "%x", Value);
+ sprintf(str, "%x", (unsigned int)Value);
} else
if(Base==8) {
- sprintf(str, "%o", Value);
+ sprintf(str, "%o", (unsigned int)Value);
} else
if(Base==2) {
- sprintf(str, "%b", Value);
+// sprintf(str, "%b", Value);
} else {
- sprintf(str, "%u", Value);
+ sprintf(str, "%u", (unsigned int)Value);
};
len=strlen(str);
// ExFreePool(str);
return STATUS_SUCCESS;
-};
+}
NTSTATUS RtlUnicodeStringToAnsiString(IN OUT PANSI_STRING DestinationString,
IN PUNICODE_STRING SourceString,
NTSTATUS RtlUnicodeStringToInteger(IN PUNICODE_STRING String, IN ULONG Base,
OUT PULONG Value)
{
- char *str;
- unsigned long i, lenmin=0;
- BOOLEAN addneg=FALSE;
-
-// str=ExAllocatePool(NonPagedPool, String->Length+1);
-
- for(i=0; i<String->Length; i++) {
- *str=*String->Buffer;
-
- if(*str=='b') { Base=2; lenmin++; } else
- if(*str=='o') { Base=8; lenmin++; } else
- if(*str=='d') { Base=10; lenmin++; } else
- if(*str=='x') { Base=16; lenmin++; } else
- if(*str=='+') { lenmin++; } else
- if(*str=='-') { addneg=TRUE; lenmin++; } else
- if((*str>'1') && (Base==2)) {
- String->Buffer-=i;
- *Value=0;
- return STATUS_INVALID_PARAMETER;
- } else
- if(((*str>'7') || (*str<'0')) && (Base==8)) {
- String->Buffer-=i;
- *Value=0;
- return STATUS_INVALID_PARAMETER;
- } else
- if(((*str>'9') || (*str<'0')) && (Base==10)) {
- String->Buffer-=i;
- *Value=0;
- return STATUS_INVALID_PARAMETER;
- } else
- if((((*str>'9') || (*str<'0')) ||
- ((toupper(*str)>'F') || (toupper(*str)<'A'))) && (Base==16))
- {
- String->Buffer-=i;
- *Value=0;
- return STATUS_INVALID_PARAMETER;
- } else
- str++;
-
- String->Buffer++;
+ char *str;
+ unsigned long i, lenmin=0;
+ BOOLEAN addneg=FALSE;
+
+ str=RtlAllocateHeap(RtlGetProcessHeap(), 0, String->Length+1);
+
+ for(i=0; i<String->Length; i++)
+ {
+ *str=*String->Buffer;
+
+ if(*str=='b') { Base=2; lenmin++; } else
+ if(*str=='o') { Base=8; lenmin++; } else
+ if(*str=='d') { Base=10; lenmin++; } else
+ if(*str=='x') { Base=16; lenmin++; } else
+ if(*str=='+') { lenmin++; } else
+ if(*str=='-') { addneg=TRUE; lenmin++; } else
+ if((*str>'1') && (Base==2)) {
+ String->Buffer-=i;
+ *Value=0;
+ return STATUS_INVALID_PARAMETER;
+ } else
+ if(((*str>'7') || (*str<'0')) && (Base==8)) {
+ String->Buffer-=i;
+ *Value=0;
+ return STATUS_INVALID_PARAMETER;
+ } else
+ if(((*str>'9') || (*str<'0')) && (Base==10)) {
+ String->Buffer-=i;
+ *Value=0;
+ return STATUS_INVALID_PARAMETER;
+ } else
+ if((((*str>'9') || (*str<'0')) ||
+ ((toupper(*str)>'F') || (toupper(*str)<'A'))) && (Base==16))
+ {
+ String->Buffer-=i;
+ *Value=0;
+ return STATUS_INVALID_PARAMETER;
+ } else
+ str++;
+
+ String->Buffer++;
};
-
- *str=0;
- String->Buffer-=String->Length;
- str-=(String->Length-lenmin);
-
- if(addneg==TRUE) {
- *Value=simple_strtoul(str, NULL, Base)*-1;
+
+ *str=0;
+ String->Buffer-=String->Length;
+ str-=(String->Length-lenmin);
+
+ if(addneg==TRUE) {
+ *Value=simple_strtoul(str, NULL, Base)*-1;
} else
- *Value=simple_strtoul(str, NULL, Base);
-
-// ExFreePool(str);
-};
+ *Value=simple_strtoul(str, NULL, Base);
+
+ // ExFreePool(str);
+ return(STATUS_SUCCESS);
+}
NTSTATUS RtlUpcaseUnicodeString(IN OUT PUNICODE_STRING DestinationString,
IN PUNICODE_STRING SourceString,
#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>
+#include <string.h>
#include <internal/debug.h>
+extern size_t strnlen(const char* string, size_t maxlen);
+
unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
{
unsigned long result = 0,value;
n = ((unsigned long) n) / (unsigned) base; \
__res; })
-static char * number(char * str, long num, int base, int size, int precision
- ,int type)
+static char * number(char * str, long num, int base, int size, int precision,
+ int type)
{
- char c,sign,tmp[66];
- const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
- int i;
-
- if (type & LARGE)
- digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
- if (type & LEFT)
- type &= ~ZEROPAD;
- if (base < 2 || base > 36)
- return 0;
- c = (type & ZEROPAD) ? '0' : ' ';
- sign = 0;
- if (type & SIGN) {
- if (num < 0) {
- sign = '-';
- num = -num;
- size--;
- } else if (type & PLUS) {
- sign = '+';
- size--;
- } else if (type & SPACE) {
- sign = ' ';
- size--;
- }
- }
- if (type & SPECIAL) {
- if (base == 16)
- size -= 2;
- else if (base == 8)
- size--;
- }
- i = 0;
- if (num == 0)
- tmp[i++]='0';
- else while (num != 0)
- tmp[i++] = digits[do_div(num,base)];
- if (i > precision)
- precision = i;
- size -= precision;
- if (!(type&(ZEROPAD+LEFT)))
- while(size-->0)
- *str++ = ' ';
- if (sign)
- *str++ = sign;
- if (type & SPECIAL)
- if (base==8)
- *str++ = '0';
- else if (base==16) {
- *str++ = '0';
- *str++ = digits[33];
- }
- if (!(type & LEFT))
- while (size-- > 0)
- *str++ = c;
- while (i < precision--)
- *str++ = '0';
- while (i-- > 0)
- *str++ = tmp[i];
- while (size-- > 0)
- *str++ = ' ';
- return str;
+ char c,sign,tmp[66];
+ const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
+ int i;
+
+ if (type & LARGE)
+ digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ if (type & LEFT)
+ type &= ~ZEROPAD;
+ if (base < 2 || base > 36)
+ return 0;
+
+ c = (type & ZEROPAD) ? '0' : ' ';
+ sign = 0;
+
+ if (type & SIGN)
+ {
+ if (num < 0)
+ {
+ sign = '-';
+ num = -num;
+ size--;
+ }
+ else if (type & PLUS)
+ {
+ sign = '+';
+ size--;
+ }
+ else if (type & SPACE)
+ {
+ sign = ' ';
+ size--;
+ }
+ }
+
+ if (type & SPECIAL)
+ {
+ if (base == 16)
+ size -= 2;
+ else if (base == 8)
+ size--;
+ }
+
+ i = 0;
+ if (num == 0)
+ tmp[i++]='0';
+ else while (num != 0)
+ tmp[i++] = digits[do_div(num,base)];
+ if (i > precision)
+ precision = i;
+ size -= precision;
+ if (!(type&(ZEROPAD+LEFT)))
+ while(size-->0)
+ *str++ = ' ';
+ if (sign)
+ *str++ = sign;
+ if (type & SPECIAL)
+ {
+ if (base==8)
+ {
+ *str++ = '0';
+ }
+ else if (base==16)
+ {
+ *str++ = '0';
+ *str++ = digits[33];
+ }
+ }
+ if (!(type & LEFT))
+ while (size-- > 0)
+ *str++ = c;
+ while (i < precision--)
+ *str++ = '0';
+ while (i-- > 0)
+ *str++ = tmp[i];
+ while (size-- > 0)
+ *str++ = ' ';
+ return str;
}
int vsprintf(char *buf, const char *fmt, va_list args)
return i;
}
+#if 0
int wsprintfW(unsigned short * buf, const unsigned short *fmt, ...)
{
- va_list args;
- int i;
-
- va_start(args, fmt);
- //i=vsprintf(buf,fmt,args);
- va_end(args);
- return i;
+ va_list args;
+ int i;
+
+ va_start(args, fmt);
+ //i=vsprintf(buf,fmt,args);
+ va_end(args);
+ return i;
}
-
+#endif
unsigned short towupper(unsigned short w)
{
#include <ddk/ntddk.h>
#include <wchar.h>
-static wchar_t * ___wcstok = NULL;
+/* GLOBALS *******************************************************************/
+
+// static wchar_t * ___wcstok = NULL;
/* FUNCTIONS *****************************************************************/
-int wcsicmp(const wchar_t* ws1, const wchar_t* ws2)
+int wcsnicmp(const wchar_t* ws1, const wchar_t* ws2, size_t size)
{
}
-int wcsnicmp(const wchar_t* ws1, const wchar_t* ws2, size_t size)
+int wcsicmp(const wchar_t* ws1, const wchar_t* ws2)
{
}
return dest;
}
-wchar_t *
-wcschr(const wchar_t *str, wchar_t ch)
+wchar_t* wcschr(const wchar_t *str, wchar_t ch)
{
while ((*str) != ((wchar_t) 0))
{
if ((*str) == ch)
{
- return str;
+ return (wchar_t *)str;
}
str++;
}
return NULL;
}
-int
-wcscmp(const wchar_t *cs, const wchar_t *ct)
+int wcscmp(const wchar_t *cs, const wchar_t *ct)
{
while (*cs != '\0' && *ct != '\0' && *cs == *ct)
{
STUB(PfxInsertPrefix)
STUB(PfxRemovePrefix)
STUB(RestoreEm87Context)
-STUB(RtlValidateHeap)
STUB(RtlValidateProcessHeaps)
STUB(RtlWalkHeap)
STUB(RtlZeroHeap)
#
# Required to run the system
#
-COMPONENTS = iface_native ntoskrnl kernel32 ntdll
+COMPONENTS = iface_native ntoskrnl ntdll kernel32
#
# Select the server(s) you want to build
return(BlockNr % Dccb->HashTblSize);
}
+#if 0
static VOID CbDereferenceCcb(PDCCB Dccb, PCCB Ccb)
{
KIRQL oldlvl;
Ccb->References--;
KeReleaseSpinLock(&Dccb->HashTblLock,oldlvl);
}
+#endif
static PCCB CbGetCcbFromHashTable(PDCCB Dccb, ULONG BlockNr)
{
return(Ccb);
}
+#if 0
static BOOLEAN CbRemoveCcbFromHashTable(PDCCB Dccb, PCCB Ccb)
{
KIRQL oldlvl;
KeReleaseSpinLock(&Dccb->HashTblLock,oldlvl);
return(Status);
}
-
+#endif
static BOOLEAN CbLockForWrite(PCCB Ccb)
{
return(TRUE);
}
+#if 0
static VOID CbUnlockForDelete(PDCCB Dccb, PCCB Ccb)
{
Ccb->ActiveWriter = FALSE;
KeSetEvent(&Ccb->FinishedNotify,IO_NO_INCREMENT,FALSE);
}
+#endif
VOID CbAcquireForDelete(PDCCB Dccb, PCCB Ccb)
/*
UNIMPLEMENTED;
}
+#if 0
static VOID CbDeleteAllCcbs(PDCCB Dccb)
/*
* FUNCTION: Delete all the ccbs associated with a dccb
ExFreePool(Ccb);
}
}
+#endif
+#if 0
static VOID CbFreeCcb(PDCCB Dccb, PCCB Ccb)
{
KIRQL oldlvl;
KeReleaseSpinLock(&Dccb->CcbListLock,oldlvl);
ExFreePool(Ccb);
}
+#endif
+#if 0
static VOID CbReclaimMemory(PDCCB Dccb)
{
PCCB RedundantCcbs[25];
CbFreeCcb(Dccb,RedundantCcbs[i]);
}
}
+#endif
+#if 0
static VOID CbDeleteCcb(PDCCB Dccb, PCCB Ccb)
/*
* FUNCTION: Deletes a CCB
CbAcquireForDelete(Dccb,Ccb);
Ccb->State = CCB_DELETE_PENDING;
}
+#endif
VOID CbReinitCcb(PDCCB Dccb, PCCB Ccb, ULONG BlockNr)
{
NTSTATUS NtDeleteKey(HANDLE KeyHandle)
{
+ return(ZwDeleteKey(KeyHandle));
}
NTSTATUS ZwDeleteKey(HANDLE KeyHandle)
UNIMPLEMENTED;
}
-NTSTATUS NtEnumerateKey(HANDLE KeyHandle, ULONG Index,
+NTSTATUS NtEnumerateKey(HANDLE KeyHandle,
+ ULONG Index,
KEY_INFORMATION_CLASS KeyInformationClass,
PVOID KeyInformation,
ULONG Length,
PULONG ResultLength)
{
+ return(ZwEnumerateKey(KeyHandle,
+ Index,
+ KeyInformationClass,
+ KeyInformation,
+ Length,
+ ResultLength));
}
-NTSTATUS ZwEnumerateKey(HANDLE KeyHandle, ULONG Index,
+NTSTATUS ZwEnumerateKey(HANDLE KeyHandle,
+ ULONG Index,
KEY_INFORMATION_CLASS KeyInformationClass,
PVOID KeyInformation,
ULONG Length,
BOOLEAN ExTryToAcquireFastMutex(PFAST_MUTEX FastMutex)
{
- InterlockedCompareExchange(&(FastMutex->Count),0,0);
+ UNIMPLEMENTED;
}
NTSTATUS ExInitializeResource(PERESOURCE Resource)
{
+ UNIMPLEMENTED;
}
NTSTATUS ExInitializeResourceLite(PERESOURCE Resource)
Resource->NumberOfExclusiveWaiters = 0;
KeInitializeSpinLock(&Resource->SpinLock);
Resource->Flag=0;
- KeInitializeEvent(&Resource->ExclusiveWaiters,SynchronizationEvent,
+ Resource->ExclusiveWaiters = ExAllocatePool(NonPagedPool,
+ sizeof(KEVENT));
+ KeInitializeEvent(Resource->ExclusiveWaiters,
+ SynchronizationEvent,
FALSE);
- KeInitializeSemaphore(&Resource->SharedWaiters,5,0);
+ Resource->SharedWaiters = ExAllocatePool(NonPagedPool,
+ sizeof(KSEMAPHORE));
+ KeInitializeSemaphore(Resource->SharedWaiters,5,0);
Resource->ActiveCount = 0;
+
+ return(STATUS_SUCCESS);
}
BOOLEAN ExIsResourceAcquiredExclusiveLite(PERESOURCE Resource)
/*
* PURPOSE: Queue of items waiting to be processed at normal priority
*/
-WORK_QUEUE normal_work_queue = {0,};
+WORK_QUEUE normal_work_queue = {{0,}};
#define WAIT_INTERVAL (0)
ExAllocateFromPagedLookasideList
ExAllocateFromZone
ExAllocatePool
-ExAllocatePoolWithQuota
-ExAllocatePoolWithQuotaTag
+#ExAllocatePoolWithQuota
+#ExAllocatePoolWithQuotaTag
ExAllocatePoolWithTag
ExConvertExclusiveToSharedLite
ExDeleteNPagedLookasideList
InterlockedExchange
InterlockedExchangeAdd
InterlockedIncrement
-HalAllocateCommonBuffer
+#HalAllocateCommonBuffer
HalAssignSlotResources
HalExamineMBR
-HalFreeCommonBuffer
-HalGetAdapter
+#HalFreeCommonBuffer
+#HalGetAdapter
HalGetBusData
HalGetBusDataByOffset
HalGetDmaAlignmentRequirement
RtlInitAnsiString
RtlInitString
RtlInitUnicodeString
-RtlIntegerToUnicodeString
+#RtlIntegerToUnicodeString
RtlLargeIntegerAdd
RtlLargeIntegerAnd
RtlLargeIntegerArithmeticShift
return(1);
}
+#if 0
PVOID HalAllocateCommonBuffer(PADAPTER_OBJECT AdapterObject,
ULONG Length,
PPHYSICAL_ADDRESS LogicalAddress,
RtlCopyMemory(&adapter->desc,DeviceDescription,sizeof(DEVICE_DESCRIPTION));
*/
}
+#endif
ULONG HalReadDmaCounter(PADAPTER_OBJECT AdapterObject)
{
/* FUNCTIONS ****************************************************************/
+#if 0
static unsigned int HiGetCurrentPICMask(void)
{
unsigned int mask;
return mask;
}
+#endif
static unsigned int HiSetCurrentPICMask(unsigned int mask)
{
* FUNCTION: Returns the physical address corresponding to a virtual address
*/
{
- PHYSICAL_ADDRESS p;
+ PHYSICAL_ADDRESS p = INITIALIZE_LARGE_INTEGER;
DPRINT("MmGetPhysicalAddress(vaddr %x)\n", vaddr);
#include <internal/ke.h>
#include <internal/bitops.h>
#include <internal/linkage.h>
+#include <string.h>
#include <internal/string.h>
#include <internal/i386/segment.h>
IoAcquireCancelSpinLock(&oldlvl);
Irp->Cancel = TRUE;
- if (Irp->CancelRoutine==NULL)
+ if (Irp->CancelRoutine == NULL)
{
return(FALSE);
}
- Irp->CancelRoutine(Irp->Stack[0].DeviceObject,Irp);
- IoReleaseCancelSpinLock(&oldlvl);
+ Irp->CancelRoutine(Irp->Stack[0].DeviceObject, Irp);
+ IoReleaseCancelSpinLock(oldlvl);
return(TRUE);
}
PWSTR RemainingPath,
POBJECT_ATTRIBUTES ObjectAttributes)
{
- PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ObjectBody;
DPRINT("IopCreateDevice(ObjectBody %x, Parent %x, RemainingPath %w)\n",
ObjectBody, Parent, RemainingPath);
* MmLockPagableDataSection
*/
{
- MmUnlockMemoryArea((MEMORY_AREA *)ImageSectionHandle);
+// MmUnlockMemoryArea((MEMORY_AREA *)ImageSectionHandle);
+ UNIMPLEMENTED;
}
VOID MmLockPagableSectionByHandle(PVOID ImageSectionHandle)
{
- MmLockMemoryArea((MEMORY_AREA *)ImageSectionHandle);
+// MmLockMemoryArea((MEMORY_AREA *)ImageSectionHandle);
+ UNIMPLEMENTED;
}
PVOID MmLockPagableCodeSection(PVOID AddressWithinSection)
/* FUNCTIONS *****************************************************************/
-NTSTATUS
-STDCALL
-NtCreateIoCompletion(
- OUT PHANDLE CompletionPort,
- IN ACCESS_MASK DesiredAccess,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG NumberOfConcurrentThreads
- )
+NTSTATUS STDCALL NtCreateIoCompletion(OUT PHANDLE CompletionPort,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfConcurrentThreads)
{
+ return(ZwCreateIoCompletion(CompletionPort,
+ DesiredAccess,
+ IoStatusBlock,
+ NumberOfConcurrentThreads));
}
-NTSTATUS
-STDCALL
-ZwCreateIoCompletion(
- OUT PHANDLE CompletionPort,
- IN ACCESS_MASK DesiredAccess,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG NumberOfConcurrentThreads
- )
+NTSTATUS STDCALL ZwCreateIoCompletion(OUT PHANDLE CompletionPort,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfConcurrentThreads)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtOpenIoCompletion(
- OUT PHANDLE CompetionPort,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes
- )
+NTSTATUS STDCALL NtOpenIoCompletion(OUT PHANDLE CompletionPort,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes)
{
+ return(ZwOpenIoCompletion(CompletionPort,
+ DesiredAccess,
+ ObjectAttributes));
}
-NTSTATUS
-STDCALL
-ZwOpenIoCompletion(
- OUT PHANDLE CompetionPort,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes
- )
+NTSTATUS STDCALL ZwOpenIoCompletion(OUT PHANDLE CompetionPort,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes)
{
+ return(STATUS_SUCCESS);
}
-NTSTATUS
-STDCALL
-NtQueryIoCompletion(
- IN HANDLE CompletionPort,
- IN ULONG CompletionKey,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PULONG NumberOfBytesTransferred
- )
+NTSTATUS STDCALL NtQueryIoCompletion(IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG NumberOfBytesTransferred)
{
-
-return ZwQueryIoCompletion(CompletionPort,CompletionKey,IoStatusBlock,NumberOfBytesTransferred);
-
+ return(ZwQueryIoCompletion(CompletionPort,
+ CompletionKey,
+ IoStatusBlock,
+ NumberOfBytesTransferred));
}
-NTSTATUS
-STDCALL
-ZwQueryIoCompletion(
- IN HANDLE CompletionPort,
- IN ULONG CompletionKey,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PULONG NumberOfBytesTransferred
- )
+NTSTATUS STDCALL ZwQueryIoCompletion(IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG NumberOfBytesTransferred)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtRemoveIoCompletion(
- IN HANDLE CompletionPort,
- OUT PULONG CompletionKey,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PULONG CompletionStatus,
- PLARGE_INTEGER WaitTime
- )
+
+NTSTATUS STDCALL NtRemoveIoCompletion(IN HANDLE CompletionPort,
+ OUT PULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG CompletionStatus,
+ PLARGE_INTEGER WaitTime)
{
+ return(ZwRemoveIoCompletion(CompletionPort,
+ CompletionKey,
+ IoStatusBlock,
+ CompletionStatus,
+ WaitTime));
}
-NTSTATUS
-STDCALL
-ZwRemoveIoCompletion(
- IN HANDLE CompletionPort,
- OUT PULONG CompletionKey,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PULONG CompletionStatus,
- PLARGE_INTEGER WaitTime
- )
+NTSTATUS STDCALL ZwRemoveIoCompletion(IN HANDLE CompletionPort,
+ OUT PULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PULONG CompletionStatus,
+ PLARGE_INTEGER WaitTime)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtSetIoCompletion(
- IN HANDLE CompletionPort,
- IN ULONG CompletionKey,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG NumberOfBytesToTransfer,
- OUT PULONG NumberOfBytesTransferred
- )
+NTSTATUS STDCALL NtSetIoCompletion(IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfBytesToTransfer,
+ OUT PULONG NumberOfBytesTransferred)
{
+ return(ZwSetIoCompletion(CompletionPort,
+ CompletionKey,
+ IoStatusBlock,
+ NumberOfBytesToTransfer,
+ NumberOfBytesTransferred));
}
-NTSTATUS
-STDCALL
-ZwSetIoCompletion(
- IN HANDLE CompletionPort,
- IN ULONG CompletionKey,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG NumberOfBytesToTransfer,
- OUT PULONG NumberOfBytesTransferred
- )
+NTSTATUS STDCALL ZwSetIoCompletion(IN HANDLE CompletionPort,
+ IN ULONG CompletionKey,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG NumberOfBytesToTransfer,
+ OUT PULONG NumberOfBytesTransferred)
{
+ UNIMPLEMENTED;
}
DPRINT("IoGetCurrentIrpStackLocation(Irp) %x\n",
IoGetCurrentIrpStackLocation(Irp));
IoGetCurrentIrpStackLocation(Irp)->Control |= SL_PENDING_RETURNED;
- Irp->Tail.Overlay.Thread = KeGetCurrentThread();
+ Irp->Tail.Overlay.Thread = PsGetCurrentThread();
DPRINT("IoGetCurrentIrpStackLocation(Irp)->Control %x\n",
IoGetCurrentIrpStackLocation(Irp)->Control);
DPRINT("SL_PENDING_RETURNED %x\n",SL_PENDING_RETURNED);
Irp->CurrentLocation,
Irp->StackCount);
- return &Irp->Stack[Irp->CurrentLocation];
+ return &Irp->Stack[(ULONG)Irp->CurrentLocation];
}
if (ChargeQuota)
{
- Irp = ExAllocatePoolWithQuota(NonPagedPool,IoSizeOfIrp(StackSize));
+// Irp = ExAllocatePoolWithQuota(NonPagedPool,IoSizeOfIrp(StackSize));
+ Irp = ExAllocatePool(NonPagedPool,IoSizeOfIrp(StackSize));
}
else
{
/* FUNCTIONS *****************************************************************/
-NTSTATUS
-STDCALL
-NtCreateMailslotFile(
- OUT PHANDLE MailSlotFileHandle,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG FileAttributes,
- IN ULONG ShareAccess,
- IN ULONG MaxMessageSize,
- IN PLARGE_INTEGER TimeOut
- )
+NTSTATUS STDCALL NtCreateMailslotFile(OUT PHANDLE MailSlotFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG MaxMessageSize,
+ IN PLARGE_INTEGER TimeOut)
{
+ return(ZwCreateMailslotFile(MailSlotFileHandle,
+ DesiredAccess,
+ ObjectAttributes,
+ IoStatusBlock,
+ FileAttributes,
+ ShareAccess,
+ MaxMessageSize,
+ TimeOut));
}
-NTSTATUS
-STDCALL
-ZwCreateMailslotFile(
- OUT PHANDLE MailSlotFileHandle,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG FileAttributes,
- IN ULONG ShareAccess,
- IN ULONG MaxMessageSize,
- IN PLARGE_INTEGER TimeOut
- )
+NTSTATUS STDCALL ZwCreateMailslotFile(OUT PHANDLE MailSlotFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG MaxMessageSize,
+ IN PLARGE_INTEGER TimeOut)
{
+ UNIMPLEMENTED;
}
if (ChargeQuota)
{
- Mdl = ExAllocatePoolWithQuota(NonPagedPool,
- MmSizeOfMdl(VirtualAddress,Length));
+// Mdl = ExAllocatePoolWithQuota(NonPagedPool,
+// MmSizeOfMdl(VirtualAddress,Length));
+ Mdl = ExAllocatePool(NonPagedPool,MmSizeOfMdl(VirtualAddress,Length));
}
else
{
/* FUNCTIONS *****************************************************************/
-NTSTATUS
-STDCALL
-NtCreateNamedPipeFile(
- OUT PHANDLE NamedPipeFileHandle,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG FileAttributes,
- IN ULONG ShareAccess,
- IN ULONG OpenMode,
- IN ULONG PipeType,
- IN ULONG PipeRead,
- IN ULONG PipeWait,
- IN ULONG MaxInstances,
- IN ULONG InBufferSize,
- IN ULONG OutBufferSize,
- IN PLARGE_INTEGER TimeOut
- )
+NTSTATUS STDCALL NtCreateNamedPipeFile(OUT PHANDLE NamedPipeFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG OpenMode,
+ IN ULONG PipeType,
+ IN ULONG PipeRead,
+ IN ULONG PipeWait,
+ IN ULONG MaxInstances,
+ IN ULONG InBufferSize,
+ IN ULONG OutBufferSize,
+ IN PLARGE_INTEGER TimeOut)
{
+ return(ZwCreateNamedPipeFile(NamedPipeFileHandle,
+ DesiredAccess,
+ ObjectAttributes,
+ IoStatusBlock,
+ FileAttributes,
+ ShareAccess,
+ OpenMode,
+ PipeType,
+ PipeRead,
+ PipeWait,
+ MaxInstances,
+ InBufferSize,
+ OutBufferSize,
+ TimeOut));
}
-NTSTATUS
-STDCALL
-ZwCreateNamedPipeFile(
- OUT PHANDLE NamedPipeFileHandle,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG FileAttributes,
- IN ULONG ShareAccess,
- IN ULONG OpenMode,
- IN ULONG PipeType,
- IN ULONG PipeRead,
- IN ULONG PipeWait,
- IN ULONG MaxInstances,
- IN ULONG InBufferSize,
- IN ULONG OutBufferSize,
- IN PLARGE_INTEGER TimeOut
- )
+NTSTATUS STDCALL ZwCreateNamedPipeFile(OUT PHANDLE NamedPipeFileHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN ULONG FileAttributes,
+ IN ULONG ShareAccess,
+ IN ULONG OpenMode,
+ IN ULONG PipeType,
+ IN ULONG PipeRead,
+ IN ULONG PipeWait,
+ IN ULONG MaxInstances,
+ IN ULONG InBufferSize,
+ IN ULONG OutBufferSize,
+ IN PLARGE_INTEGER TimeOut)
{
+ UNIMPLEMENTED;
}
{
PKDEVICE_QUEUE_ENTRY entry;
PIRP Irp;
- KIRQL oldirql;
entry = KeRemoveByKeyDeviceQueue(&DeviceObject->DeviceQueue,Key);
{
PKDEVICE_QUEUE_ENTRY entry;
PIRP Irp;
- KIRQL oldirql;
DPRINT("IoStartNextPacket(DeviceObject %x, Cancelable %d)\n",
DeviceObject,Cancelable);
#include <ddk/ntddk.h>
#include <internal/ob.h>
+#include <wchar.h>
#define NDEBUG
#include <internal/debug.h>
RtlZeroMemory(Vpb->VolumeLabel,sizeof(WCHAR)*MAXIMUM_VOLUME_LABEL_LENGTH);
DeviceObject->Vpb = Vpb;
+
+ return(STATUS_SUCCESS);
}
PIRP IoBuildVolumeInformationIrp(ULONG MajorFunction,
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/bug.c
* PURPOSE: Graceful system shutdown if a bug is detected
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
+#include <internal/ke.h>
#include <internal/debug.h>
CallbackRecord->Buffer=Buffer;
CallbackRecord->Component=Component;
CallbackRecord->CallbackRoutine=CallbackRoutine;
+ return(TRUE);
}
VOID KeBugCheckEx(ULONG BugCheckCode,
#include <ddk/ntddk.h>
+#include <internal/debug.h>
+
/* FUNCTIONS ***************************************************************/
NTSTATUS STDCALL NtRaiseHardError(VOID)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtSetDefaultHardErrorPort(
- IN HANDLE PortHandle
- )
+NTSTATUS STDCALL NtSetDefaultHardErrorPort(IN HANDLE PortHandle)
{
+ UNIMPLEMENTED;
}
for (i=1;i<bp.nr_files;i++)
{
DPRINT("process module at %08lx\n", start);
- LdrProcessDriver(start);
+ LdrProcessDriver((PVOID)start);
start=start+PAGE_ROUND_UP(bp.module_length[i]);
}
#include <ddk/ntddk.h>
#include <string.h>
#include <internal/string.h>
+#include <stdio.h>
#define NDEBUG
#include <internal/debug.h>
DPRINT("Finished KeExpireTimers()\n");
}
-extern unsigned int nr_used_blocks;
-extern unsigned int EiFreeNonPagedPool;
-extern unsigned int EiUsedNonPagedPool;
BOOLEAN KiTimerInterrupt(VOID)
/*
char* vidmem=(char *)physical_to_linear(0xb8000 + 160 - 36);
int i;
int x,y;
- extern ULONG PiNrThreads;
extern ULONG EiNrUsedBlocks;
+ extern unsigned int EiFreeNonPagedPool;
+ extern unsigned int EiUsedNonPagedPool;
/*
* Increment the number of timers ticks
}
// sprintf(str,"%.8u %.8u",EiFreeNonPagedPool,ticks);
memset(str, 0, sizeof(str));
- sprintf(str,"%.8u %.8u",EiNrUsedBlocks,EiFreeNonPagedPool);
+ sprintf(str,"%.8u %.8u",(unsigned int)EiNrUsedBlocks,
+ (unsigned int)EiFreeNonPagedPool);
// sprintf(str,"%.8u %.8u",EiFreeNonPagedPool,EiUsedNonPagedPool);
// sprintf(str,"%.8u %.8u",PiNrThreads,KiTimerTicks);
for (i=0;i<17;i++)
/* Copy image sections into virtual section */
memcpy(DriverBase, ModuleLoadBase, PESectionHeaders[0].PointerToRawData);
CurrentBase = (PVOID) ((DWORD)DriverBase + PESectionHeaders[0].PointerToRawData);
+ CurrentSize = 0;
for (Idx = 0; Idx < PEFileHeader->NumberOfSections; Idx++)
{
/* Copy current section into current offset of virtual section */
OBJECT_ATTRIBUTES FileObjectAttributes;
HANDLE FileHandle, SectionHandle, ThreadHandle;
CONTEXT Context;
- ANSI_STRING AnsiString;
UNICODE_STRING DllPathname;
PIMAGE_DOS_HEADER DosHeader;
PIMAGE_NT_HEADERS NTHeaders;
0,
Sections[i].Misc.VirtualSize,
&Offset,
- &Sections[i].Misc.VirtualSize,
+ (PULONG)&Sections[i].Misc.VirtualSize,
0,
MEM_COMMIT,
PAGE_READWRITE);
DUPLICATE_SAME_ACCESS);
ZwWriteVirtualMemory(ProcessHandle,
- STACK_TOP - 4,
+ (PVOID)(STACK_TOP - 4),
&ImageBase,
sizeof(ImageBase),
&BytesWritten);
ZwWriteVirtualMemory(ProcessHandle,
- STACK_TOP - 8,
+ (PVOID)(STACK_TOP - 8),
&DupSectionHandle,
sizeof(DupSectionHandle),
&BytesWritten);
}
NTSTATUS LdrLoadInitialProcess(VOID)
+/*
+ * FIXME: The location of the initial process should be configurable,
+ * from command line or registry
+ */
{
NTSTATUS Status;
HANDLE ProcessHandle;
- ANSI_STRING AnsiString;
UNICODE_STRING ProcessName;
Status = ZwCreateProcess(&ProcessHandle,
NULL);
if (!NT_SUCCESS(Status))
{
- DbgPrint("Could not create process\n");
- return Status;
+ DbgPrint("Could not create process\n");
+ return Status;
}
- RtlInitAnsiString(&AnsiString, "\\??\\C:\\reactos\\system\\shell.exe");
- RtlAnsiStringToUnicodeString(&ProcessName, &AnsiString, TRUE);
-
+ RtlInitUnicodeString(&ProcessName, L"\\??\\C:\\reactos\\system\\shell.exe");
Status = LdrLoadImage(ProcessHandle, &ProcessName);
- RtlFreeUnicodeString(&ProcessName);
-
return Status;
}
#WITH_DEBUGGING = yes
WIN32_LEAN_AND_MEAN = yes
+WARNINGS_ARE_ERRORS = yes
include ../rules.mak
{
PLIST_ENTRY current_entry;
MEMORY_AREA* current;
- ULONG i;
DbgPrint("MmDumpMemoryAreas()\n");
DbgPrint("Finished MmDumpMemoryAreas()\n");
}
-VOID MmLockMemoryAreaList(ULONG Address, PKIRQL oldlvl)
+VOID MmLockMemoryAreaList(PVOID Address, PKIRQL oldlvl)
{
- if (Address >= KERNEL_BASE)
+ if (Address >= (PVOID)KERNEL_BASE)
{
KeAcquireSpinLock(&SystemAreaListLock,oldlvl);
}
}
}
-VOID MmUnlockMemoryAreaList(ULONG Address, PKIRQL oldlvl)
+VOID MmUnlockMemoryAreaList(PVOID Address, PKIRQL oldlvl)
{
- if (Address >= KERNEL_BASE)
+ if (Address >= (PVOID)KERNEL_BASE)
{
KeReleaseSpinLock(&SystemAreaListLock,*oldlvl);
}
}
-static PLIST_ENTRY MmGetRelatedListHead(PEPROCESS Process, ULONG BaseAddress)
+static PLIST_ENTRY MmGetRelatedListHead(PEPROCESS Process, PVOID BaseAddress)
{
- if (BaseAddress >= KERNEL_BASE)
+ if (BaseAddress >= (PVOID)KERNEL_BASE)
{
return(&SystemAreaList);
}
}
static MEMORY_AREA* MmInternalOpenMemoryAreaByAddress(PLIST_ENTRY ListHead,
- ULONG Address)
+ PVOID Address)
{
PLIST_ENTRY current_entry;
MEMORY_AREA* current;
MEMORY_AREA* MmInternalOpenMemoryAreaByRegion(PLIST_ENTRY ListHead,
- ULONG Address,
+ PVOID Address,
ULONG Length)
{
PLIST_ENTRY current_entry;
current);
return(current);
}
- Extent = current->BaseAddress + current->Length;
- if (Extent > Address &&
- Extent < (Address+Length))
+ Extent = (ULONG)current->BaseAddress + current->Length;
+ if (Extent > (ULONG)Address &&
+ Extent < (ULONG)(Address+Length))
{
DPRINT("Finished MmInternalOpenMemoryAreaByRegion() = %x\n",
current);
return(current);
}
if (current->BaseAddress <= Address &&
- Extent >= (Address+Length))
+ Extent >= (ULONG)(Address+Length))
{
DPRINT("Finished MmInternalOpenMemoryAreaByRegion() = %x\n",
current);
return(NULL);
}
-MEMORY_AREA* MmOpenMemoryAreaByRegion(PEPROCESS Process, ULONG Address,
+MEMORY_AREA* MmOpenMemoryAreaByRegion(PEPROCESS Process,
+ PVOID Address,
ULONG Length)
{
KIRQL oldlvl;
MEMORY_AREA* MmOpenMemoryAreaByRegionWithoutLock(PEPROCESS Process,
- ULONG Address, ULONG Length)
+ PVOID Address,
+ ULONG Length)
{
MEMORY_AREA* Result;
PLIST_ENTRY ListHead;
}
MEMORY_AREA* MmOpenMemoryAreaByAddressWithoutLock(PEPROCESS Process,
- ULONG Address)
+ PVOID Address)
{
MEMORY_AREA* Result;
PLIST_ENTRY ListHead;
ListHead = MmGetRelatedListHead(Process, Address);
- Result = MmInternalOpenMemoryAreaByAddress(ListHead,Address);
+ Result = MmInternalOpenMemoryAreaByAddress(ListHead, Address);
return(Result);
}
InsertTailList(ListHead,inserted_entry);
}
-static ULONG MmFindGapWithoutLock(PEPROCESS Process,
+static PVOID MmFindGapWithoutLock(PEPROCESS Process,
KPROCESSOR_MODE Mode, ULONG Length)
{
PLIST_ENTRY ListHead;
if (current_entry == ListHead)
{
assert(Mode==UserMode);
- return(MM_LOWEST_USER_ADDRESS);
+ return((PVOID)MM_LOWEST_USER_ADDRESS);
}
current = CONTAINING_RECORD(current_entry,MEMORY_AREA,Entry);
DPRINT("MmFreeMemoryArea(Process %x, BaseAddress %x, Length %x,"
"FreePages %d)\n",Process,BaseAddress,Length,FreePages);
- MmLockMemoryAreaList((ULONG)BaseAddress,&oldlvl);
+ MmLockMemoryAreaList(BaseAddress, &oldlvl);
MemoryArea = MmOpenMemoryAreaByAddressWithoutLock(Process,
- (ULONG)BaseAddress);
+ BaseAddress);
if (MemoryArea==NULL)
{
- MmUnlockMemoryAreaList((ULONG)BaseAddress,&oldlvl);
+ MmUnlockMemoryAreaList(BaseAddress, &oldlvl);
return(STATUS_UNSUCCESSFUL);
}
if (FreePages)
RemoveEntryList(&(MemoryArea->Entry));
ExFreePool(MemoryArea);
- MmUnlockMemoryAreaList((ULONG)BaseAddress,&oldlvl);
+ MmUnlockMemoryAreaList(BaseAddress, &oldlvl);
return(STATUS_SUCCESS);
}
-NTSTATUS MmLockMemoryArea(MEMORY_AREA* MemoryArea)
-{
- MemoryArea->LockCount++;
-}
-
-NTSTATUS MmUnlockMemoryArea(MEMORY_AREA* MemoryArea)
-{
- MemoryArea->LockCount--;
-}
-
PMEMORY_AREA MmSplitMemoryArea(PEPROCESS Process,
PMEMORY_AREA OriginalMemoryArea,
PVOID BaseAddress,
}
else
{
- (*BaseAddress) = PAGE_ROUND_DOWN((*BaseAddress));
- if (MmOpenMemoryAreaByRegionWithoutLock(Process,*BaseAddress,
+ (*BaseAddress) = (PVOID)PAGE_ROUND_DOWN((*BaseAddress));
+ if (MmOpenMemoryAreaByRegionWithoutLock(Process,
+ *BaseAddress,
Length)!=NULL)
{
MmUnlockMemoryAreaList(*BaseAddress,&oldlvl);
DPRINT("Writing %x with physical address %x\n",
base+(i*PAGESIZE),mdl_pages[i]);
MmSetPage(NULL,
- (DWORD)base+(i*PAGESIZE),
+ (PVOID)((DWORD)base+(i*PAGESIZE)),
PAGE_READWRITE,
mdl_pages[i]);
}
DPRINT("StartVa %x\n",Mdl->StartVa);
marea = MmOpenMemoryAreaByAddress(PsGetCurrentProcess(),
- (ULONG)Mdl->StartVa);
+ Mdl->StartVa);
DPRINT("marea %x\n",marea);
*/
{
memset(MemoryDescriptorList,0,sizeof(MDL));
- MemoryDescriptorList->StartVa = PAGE_ROUND_DOWN(Base);
- MemoryDescriptorList->ByteOffset = Base - PAGE_ROUND_DOWN(Base);
+ MemoryDescriptorList->StartVa = (PVOID)PAGE_ROUND_DOWN(Base);
+ MemoryDescriptorList->ByteOffset = (ULONG)(Base - PAGE_ROUND_DOWN(Base));
MemoryDescriptorList->MdlFlags = 0;
MemoryDescriptorList->ByteCount = Length;
MemoryDescriptorList->Size = sizeof(MDL) +
i<PAGE_ROUND_DOWN(((int)&etext));i=i+PAGESIZE)
{
MmSetPageProtect(NULL,
- i,
+ (PVOID)i,
PAGE_EXECUTE_READ);
}
DPRINT("end %x\n",(int)&end);
i<(KERNEL_BASE+PAGE_TABLE_SIZE);i=i+PAGESIZE)
{
MmSetPage(NULL,
- i,
+ (PVOID)i,
PAGE_NOACCESS,
0);
}
*/
static unsigned int alloc_map[ALLOC_MAP_SIZE/32]={0,};
-static unsigned int pool_free_mem = 0;
-
unsigned int EiFreeNonPagedPool = 0;
unsigned int EiUsedNonPagedPool = 0;
kernel_pool_base=BaseAddress;
}
+#if 0
static void validate_free_list(void)
/*
* FUNCTION: Validate the integrity of the list of free blocks
current=current->next;
}
}
+#endif
static void add_to_free_list(block_hdr* blk)
/*
for (i=0;i<nr_pages;i++)
{
MmSetPage(NULL,
- start + (i*PAGESIZE),
+ (PVOID)(start + (i*PAGESIZE)),
PAGE_READWRITE,
get_free_page());
}
VALIDATE_POOL;
}
-static void defrag_free_list(void)
-/*
- * FUNCTION: defrag the list of free blocks
- */
-{
- block_hdr* current=free_list_head,*current2;
- ULONG addr1,addr2,max=0;
-
- DPRINT("Begin defrag free,tot free=%d,tot used=%d\n"
- ,EiFreeNonPagedPool
- ,EiUsedNonPagedPool);
- while (current)
- {
- addr1=(ULONG)current;
- current2=current->next;
- while(current2)
- {
- addr2=(ULONG)current2;
- if(addr2==addr1+current->size+sizeof(block_hdr))
- {
- remove_from_free_list(current2);
- current->size+=current2->size+sizeof(block_hdr);
- if(current->size>max)max=current->size;
- }
- else if(addr1==addr2+current2->size+sizeof(block_hdr))
- {
- remove_from_free_list(current);
- current2->size+=current->size+sizeof(block_hdr);
- if(current2->size>max)max=current2->size;
- break;
- }
- current2=current2->next;
- }
- current=current->next;
- }
- DPRINT("Finish To defrag free blocks,max=%d\n",max);
-}
-
PVOID ExAllocateNonPagedPoolWithTag(ULONG type,
ULONG size,
ULONG Tag,
Block = ExAllocateNonPagedPoolWithTag(PoolType,
NumberOfBytes,
TAG_NONE,
- (&PoolType)[-1]);
+ (PVOID)(&PoolType)[-1]);
return(Block);
}
Block = ExAllocateNonPagedPoolWithTag(PoolType,
NumberOfBytes,
Tag,
- (&PoolType)[-1]);
+ (PVOID)(&PoolType)[-1]);
break;
case PagedPool:
}
return(Block);
}
-
-PVOID ExAllocatePoolWithQuotaTag(POOL_TYPE PoolType, ULONG NumberOfBytes,
- ULONG Tag)
-{
- PVOID Block;
- PKTHREAD current = KeGetCurrentThread();
-
- Block = ExAllocatePoolWithTag(PoolType,NumberOfBytes,Tag);
- switch(PoolType)
- {
- case NonPagedPool:
- case NonPagedPoolMustSucceed:
- case NonPagedPoolCacheAligned:
- case NonPagedPoolCacheAlignedMustS:
-// current->NPagedPoolQuota = current->NPagedPoolQuota - NumberOfBytes;
- break;
-
- case PagedPool:
- case PagedPoolCacheAligned:
-// current->PagedPoolQuota = current->PagedPoolQuota - NumberOfBytes;
- break;
- };
- return(Block);
-}
PVOID ExAllocatePoolWithQuota(POOL_TYPE PoolType, ULONG NumberOfBytes)
{
- return(ExAllocatePoolWithQuotaTag(PoolType,NumberOfBytes,TAG_NONE));
+// return(ExAllocatePoolWithQuotaTag(PoolType,NumberOfBytes,TAG_NONE));
+ UNIMPLEMENTED;
}
#include <internal/ob.h>
#include <internal/io.h>
#include <internal/ps.h>
+#include <wchar.h>
#define NDEBUG
#include <internal/debug.h>
NTSTATUS MmpCreateSection(PVOID ObjectBody,
PVOID Parent,
- PWSTR RemainingPath)
+ PWSTR RemainingPath,
+ POBJECT_ATTRIBUTES ObjectAttributes)
{
- PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ObjectBody;
NTSTATUS Status;
DPRINT("MmpCreateDevice(ObjectBody %x, Parent %x, RemainingPath %w)\n",
PVOID MmAllocateSection(ULONG Length)
{
- ULONG Result;
+ PVOID Result;
MEMORY_AREA* marea;
NTSTATUS Status;
ULONG i;
{
return(NULL);
}
- DPRINT("Result %x\n",Result);
+ DPRINT("Result %p\n",Result);
for (i=0;i<=(Length/PAGESIZE);i++)
{
MmSetPage(NULL,
ULONG NumberOfBytes,
BOOLEAN CacheEnable)
{
- ULONG Result;
+ PVOID Result;
MEMORY_AREA* marea;
NTSTATUS Status;
ULONG i;
ULONG Attributes;
- Result=0;
+ Result = 0;
Status = MmCreateMemoryArea(KernelMode,
PsGetCurrentProcess(),
MEMORY_AREA_IO_MAPPING,
PVOID MmAllocateNonCachedMemory(ULONG NumberOfBytes)
{
- ULONG Result;
+ PVOID Result;
MEMORY_AREA* marea;
NTSTATUS Status;
ULONG i;
- Result=0;
+ Result = 0;
Status = MmCreateMemoryArea(KernelMode,
PsGetCurrentProcess(),
MEMORY_AREA_NO_CACHE,
MmInitSectionImplementation();
}
-ULONG MmCommitedSectionHandleFault(MEMORY_AREA* MemoryArea, ULONG Address)
+ULONG MmCommitedSectionHandleFault(MEMORY_AREA* MemoryArea, PVOID Address)
{
MmSetPage(PsGetCurrentProcess(),
Address,
break;
case MEMORY_AREA_COMMIT:
- stat = MmCommitedSectionHandleFault(MemoryArea,cr2);
+ stat = MmCommitedSectionHandleFault(MemoryArea,(PVOID)cr2);
break;
default:
for (i=0; i<(NumberOfBytesToRead/PAGESIZE); i++)
{
- CurrentEntry = MmGetPageEntry(Process, (DWORD)BaseAddress + (i*PAGESIZE));
+ CurrentEntry = MmGetPageEntry(Process,
+ (PVOID)((DWORD)BaseAddress + (i*PAGESIZE)));
RtlCopyMemory(Buffer + (i*PAGESIZE),
(PVOID)physical_to_linear(PAGE_MASK(*CurrentEntry)),
PAGESIZE);
OUT PULONG NumberOfBytesWritten)
{
PEPROCESS Process;
- PMEMORY_AREA InMemoryArea;
PMEMORY_AREA OutMemoryArea;
ULONG i;
NTSTATUS Status;
OutMemoryArea->Attributes,
get_free_page());
}
- CurrentEntry = MmGetPageEntry(Process, (DWORD)BaseAddress +
- (i*PAGESIZE));
+ CurrentEntry = MmGetPageEntry(Process,
+ (PVOID)((DWORD)BaseAddress +
+ (i*PAGESIZE)));
RtlCopyMemory((PVOID)physical_to_linear(PAGE_MASK(*CurrentEntry)) +
(((DWORD)BaseAddress)%PAGESIZE),
Buffer + (i*PAGESIZE),
PushEntryList(&Zone->FreeList,&entry->Entry);
entry = (PZONE_ENTRY)(((PVOID)entry) + sizeof(ZONE_ENTRY) + BlockSize);
}
+
+ return(STATUS_SUCCESS);
}
PVOID ExInterlockedFreeToZone(PZONE_HEADER Zone, PVOID Block,
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/nt/nt.c
* PURPOSE: Initialization of system call interfaces
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
+#include <internal/nt.h>
#include <internal/debug.h>
NTSTATUS STDCALL NtCancelTimer(IN HANDLE TimerHandle,
OUT PBOOLEAN CurrentState OPTIONAL)
{
- return(ZwCancelTimer(TimerHandle,
- CurrentState));
+ UNIMPLEMENTED;
}
NTSTATUS STDCALL ZwCancelTimer(IN HANDLE TimerHandle,
/* FUNCTIONS ***************************************************************/
+static PHANDLE_REP ObpGetObjectByHandle(PEPROCESS Process,
+ HANDLE h)
+/*
+ * FUNCTION: Get the data structure for a handle
+ * ARGUMENTS:
+ * Process = Process to get the handle for
+ * h = Handle
+ * ARGUMENTS: A pointer to the information about the handle on success,
+ * NULL on failure
+ */
+{
+ PLIST_ENTRY current;
+ unsigned int handle = ((unsigned int)h) - 1;
+ unsigned int count=handle/HANDLE_BLOCK_ENTRIES;
+ HANDLE_BLOCK* blk = NULL;
+ unsigned int i;
+
+ DPRINT("ObpGetObjectByHandle(Process %x, h %x)\n",Process,h);
+
+ current = Process->Pcb.HandleTable.ListHead.Flink;
+ DPRINT("current %x\n",current);
+
+ for (i=0;i<count;i++)
+ {
+ current = current->Flink;
+ if (current==(&(Process->Pcb.HandleTable.ListHead)))
+ {
+ return(NULL);
+ }
+ }
+
+ blk = CONTAINING_RECORD(current,HANDLE_BLOCK,entry);
+ return(&(blk->handles[handle%HANDLE_BLOCK_ENTRIES]));
+}
NTSTATUS STDCALL NtDuplicateObject(IN HANDLE SourceProcessHandle,
IN PHANDLE SourceHandle,
}
}
-static PHANDLE_REP ObpGetObjectByHandle(PEPROCESS Process,
- HANDLE h)
-/*
- * FUNCTION: Get the data structure for a handle
- * ARGUMENTS:
- * Process = Process to get the handle for
- * h = Handle
- * ARGUMENTS: A pointer to the information about the handle on success,
- * NULL on failure
- */
-{
- PLIST_ENTRY current;
- unsigned int handle = ((unsigned int)h) - 1;
- unsigned int count=handle/HANDLE_BLOCK_ENTRIES;
- HANDLE_BLOCK* blk = NULL;
- unsigned int i;
-
- DPRINT("ObpGetObjectByHandle(Process %x, h %x)\n",Process,h);
-
- current = Process->Pcb.HandleTable.ListHead.Flink;
- DPRINT("current %x\n",current);
-
- for (i=0;i<count;i++)
- {
- current = current->Flink;
- if (current==(&(Process->Pcb.HandleTable.ListHead)))
- {
- return(NULL);
- }
- }
-
- blk = CONTAINING_RECORD(current,HANDLE_BLOCK,entry);
- return(&(blk->handles[handle%HANDLE_BLOCK_ENTRIES]));
-}
-
VOID ObDeleteHandle(HANDLE Handle)
{
PHANDLE_REP Rep;
{
PWSTR end;
PVOID FoundObject;
- NTSTATUS Status;
DPRINT("ObpParseDirectory(Object %x, Path %x, *Path %w)\n",
Object,Path,*Path);
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
+#include <internal/ke.h>
#define NDEBUG
#include <internal/debug.h>
/* GLOBALS *******************************************************************/
-HANDLE IdleThreadHandle = NULL;
+HANDLE PsIdleThreadHandle = NULL;
extern ULONG DpcQueueSize;
/* FUNCTIONS *****************************************************************/
-static VOID PsIdleThreadMain(PVOID Context)
+static NTSTATUS PsIdleThreadMain(PVOID Context)
{
KIRQL oldlvl;
{
KPRIORITY Priority;
- PsCreateSystemThread(&IdleThreadHandle,
+ PsCreateSystemThread(&PsIdleThreadHandle,
THREAD_ALL_ACCESS,
NULL,
NULL,
NULL);
Priority = THREAD_PRIORITY_IDLE;
- ZwSetInformationThread(IdleThreadHandle,
+ ZwSetInformationThread(PsIdleThreadHandle,
ThreadPriority,
&Priority,
sizeof(Priority));
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ps/kill.c
* PURPOSE: Terminating a thread
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
#include <ddk/ntddk.h>
#include <internal/ps.h>
+#include <internal/ke.h>
#define NDEBUG
#include <internal/debug.h>
NTSTATUS STDCALL ZwTerminateProcess(IN HANDLE ProcessHandle,
IN NTSTATUS ExitStatus)
{
- PETHREAD Thread;
NTSTATUS Status;
PEPROCESS Process;
KIRQL oldlvl;
#include <ddk/ntddk.h>
#include <internal/ob.h>
#include <internal/mm.h>
+#include <internal/ke.h>
#include <string.h>
#include <internal/string.h>
PULONG CurrentPageDirectory;
ULONG i;
PKPROCESS KProcess;
- ULONG Base;
- ULONG Length;
- LARGE_INTEGER Offset;
NTSTATUS Status;
DPRINT("ZwCreateProcess(ObjectAttributes %x)\n",ObjectAttributes);
InheritObjectTable,
Process);
- PageDirectory = physical_to_linear((ULONG)get_free_page());
+ PageDirectory = (PULONG)physical_to_linear((ULONG)get_free_page());
KProcess->PageTableDirectory = PageDirectory;
- CurrentPageDirectory = get_page_directory();
+ CurrentPageDirectory = (PULONG)get_page_directory();
memset(PageDirectory,0,PAGESIZE);
for (i=768;i<1024;i++)
IN ULONG ProcessInformationLength,
OUT PULONG ReturnLength)
{
- PEPROCESS Process;
+// PEPROCESS Process;
NTSTATUS Status;
- Status = ObReferenceObjectByHandle(ProcessHandle,
+/* Status = ObReferenceObjectByHandle(ProcessHandle,
PROCESS_QUERY_INFORMATION,
PsProcessType,
UserMode,
if (Status != STATUS_SUCCESS)
{
return(Status);
- }
+ }*/
switch (ProcessInformationClass)
{
IN PVOID ProcessInformation,
IN ULONG ProcessInformationLength)
{
- PEPROCESS Process;
+// PEPROCESS Process;
NTSTATUS Status;
- Status = ObReferenceObjectByHandle(ProcessHandle,
+/* Status = ObReferenceObjectByHandle(ProcessHandle,
PROCESS_SET_INFORMATION,
PsProcessType,
UserMode,
if (Status != STATUS_SUCCESS)
{
return(Status);
- }
+ }*/
switch (ProcessInformationClass)
{
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ThreadAttributes)
{
- ULONG ThreadId;
- ULONG ProcessId;
PETHREAD Thread;
NTSTATUS Status;
UserMode);
InitializeListHead(Thread->Tcb.ApcList);
InitializeListHead(&(Thread->IrpList));
- Thread->Cid.UniqueThread=InterlockedIncrement(&NextThreadUniqueId);
+ Thread->Cid.UniqueThread = (HANDLE)InterlockedIncrement(
+ &NextThreadUniqueId);
ObReferenceObjectByPointer(Thread,
THREAD_ALL_ACCESS,
PsThreadType,
ThreadBasicInformationP->TebBaseAddress = Thread->Tcb.Teb;
ThreadBasicInformationP->AffinityMask = Thread->Tcb.Affinity;
ThreadBasicInformationP->BasePriority = Thread->Tcb.BasePriority;
- ThreadBasicInformationP->UniqueThreadId = Thread->Cid.UniqueThread;
+ ThreadBasicInformationP->UniqueThreadId = (ULONG)
+ Thread->Cid.UniqueThread;
Status = STATUS_SUCCESS;
break;
RtlCopyMemory(Destination,Source,Length);
}
-VOID RtlCopyMemory(VOID* Destination, VOID* Source, ULONG Length)
+VOID RtlCopyMemory(VOID* Destination, CONST VOID* Source, ULONG Length)
{
DPRINT("RtlCopyMemory(Destination %x Source %x Length %d\n",
Destination,Source,Length);
/* FUNCTIONS *****************************************************************/
-#undef memcpy
void *memcpy (void *to, const void *from, size_t count)
{
- register char *f = from;
- register char *t = to;
- register int i = count;
+ const char *f = from;
+ char *t = to;
+ int i = count;
while (i-- > 0)
*t++ = *f++;
/* FUNCTIONS *****************************************************************/
-VOID RtlGetCallersAddress(PVOID* CallersAddress)
-{
- PULONG stk = (PULONG)(&CallersAddress);
- *CallersAddress = stk[-1];
-}
#define Aa_Difference ('A'-'a')
-PUNICODE_STRING RtlDuplicateUnicodeString(PUNICODE_STRING Dest,
- PUNICODE_STRING Src)
-{
- if (Dest==NULL)
- {
- Dest=ExAllocatePool(NonPagedPool,sizeof(UNICODE_STRING));
- }
-}
+extern unsigned long simple_strtoul(const char *cp, char **endp,
+ unsigned int base);
VOID RtlUpperString(PSTRING DestinationString, PSTRING SourceString)
{
NTSTATUS RtlCharToInteger(IN PCSZ String, IN ULONG Base, IN OUT PULONG Value)
{
- *Value=simple_strtoul((const char *)String, NULL, Base);
-};
+ *Value=simple_strtoul((const char *)String, NULL, Base);
+ return(STATUS_SUCCESS);
+}
LONG RtlCompareString(PSTRING String1, PSTRING String2, BOOLEAN CaseInsensitive)
{
VOID RtlInitUnicodeString(IN OUT PUNICODE_STRING DestinationString,
IN PCWSTR SourceString)
{
- unsigned long i, DestSize;
+ unsigned long DestSize;
DPRINT("RtlInitUnicodeString(DestinationString %x, "
"SourceString %x)\n",DestinationString,SourceString);
}
}
+#if 0
NTSTATUS RtlIntegerToUnicodeString(IN ULONG Value, IN ULONG Base, /* optional */
IN OUT PUNICODE_STRING String)
{
if(Base==2) {
sprintf(str, "%b", Value);
} else {
- sprintf(str, "%u", Value);
+ sprintf(str, "%u", (unsigned int)Value);
};
len=strlen(str);
ExFreePool(str);
return STATUS_SUCCESS;
-};
+}
+#endif
NTSTATUS RtlUnicodeStringToAnsiString(IN OUT PANSI_STRING DestinationString,
IN PUNICODE_STRING SourceString,
*Value=simple_strtoul(str, NULL, Base);
ExFreePool(str);
-};
+ return(STATUS_SUCCESS);
+}
NTSTATUS RtlUpcaseUnicodeString(IN OUT PUNICODE_STRING DestinationString,
IN PUNICODE_STRING SourceString,
#include <internal/debug.h>
#include <string.h>
#include <internal/string.h>
+#include <ctype.h>
#include <ddk/ntddk.h>
#include <ddk/ntddk.h>
#include <wchar.h>
+#include <ctype.h>
#define NDEBUG
#include <internal/debug.h>
return NULL;
}
-#if 0
wchar_t towupper(wchar_t w)
{
if (w < L'A')
return(w);
}
}
-#endif
int wcsicmp(const wchar_t* cs, const wchar_t* ct)
{
- while (*cs != '\0' && *ct != '\0' && wtoupper(*cs) == wtoupper(*ct))
+ while (*cs != '\0' && *ct != '\0' && towupper(*cs) == towupper(*ct))
{
cs++;
ct++;
IN PSECURITY_DESCRIPTOR SecurityDescriptor
)
{
+ UNIMPLEMENTED;
}
NTSTATUS
IN ULONG TokenInformationLength
)
{
+ UNIMPLEMENTED;
}
NTSTATUS
IN PBOOLEAN Result
)
{
+ UNIMPLEMENTED;
}
NTSTATUS
IN BOOLEAN AccessGranted
)
{
+ UNIMPLEMENTED;
}
NTSTATUS
IN ULONG DesiredAccess,
IN PPRIVILEGE_SET Privileges,
IN BOOLEAN AccessGranted
- )
+
+ )
{
+ UNIMPLEMENTED;
}
NTSTATUS
OUT PBOOLEAN GenerateOnClose
)
{
+ UNIMPLEMENTED;
}
NTSTATUS
OUT PHANDLE TokenHandle
)
{
+ UNIMPLEMENTED;
}
NTSTATUS
OUT PHANDLE TokenHandle
)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtDuplicateToken(
- IN HANDLE ExistingToken,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes,
- IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
- IN TOKEN_TYPE TokenType,
- OUT PHANDLE NewToken
- )
+NTSTATUS STDCALL NtDuplicateToken(IN HANDLE ExistingToken,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN SECURITY_IMPERSONATION_LEVEL
+ ImpersonationLevel,
+ IN TOKEN_TYPE TokenType,
+ OUT PHANDLE NewToken)
{
+ UNIMPLEMENTED;
}
NTSTATUS STDCALL NtImpersonateClientOfPort(VOID)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtImpersonateThread(
- IN HANDLE ThreadHandle,
- IN HANDLE ThreadToImpersonate,
- IN PSECURITY_QUALITY_OF_SERVICE SecurityQualityOfService
- )
+NTSTATUS STDCALL NtImpersonateThread(IN HANDLE ThreadHandle,
+ IN HANDLE ThreadToImpersonate,
+ IN PSECURITY_QUALITY_OF_SERVICE
+ SecurityQualityOfService)
{
+ UNIMPLEMENTED;
}
NTSTATUS STDCALL NtCreateToken(VOID)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtDeleteObjectAuditAlarm (
- IN PUNICODE_STRING SubsystemName,
- IN PVOID HandleId,
- IN BOOLEAN GenerateOnClose
- )
+NTSTATUS STDCALL NtDeleteObjectAuditAlarm(IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN BOOLEAN GenerateOnClose)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtAllocateLocallyUniqueId(
- OUT LUID *LocallyUniqueId
- )
+NTSTATUS STDCALL NtAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId)
{
+ return(ZwAllocateLocallyUniqueId(LocallyUniqueId));
}
-NTSTATUS
-STDCALL
-ZwAllocateLocallyUniqueId(
- OUT LUID *LocallyUniqueId
- )
+NTSTATUS STDCALL ZwAllocateLocallyUniqueId(OUT LUID *LocallyUniqueId)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtAccessCheckAndAuditAlarm(
- IN PUNICODE_STRING SubsystemName,
- IN PHANDLE ObjectHandle,
- IN POBJECT_ATTRIBUTES ObjectAttributes,
- IN ACCESS_MASK DesiredAccess,
- IN PGENERIC_MAPPING GenericMapping,
- IN BOOLEAN ObjectCreation,
- OUT PULONG GrantedAccess,
- OUT PBOOLEAN AccessStatus,
- OUT PBOOLEAN GenerateOnClose
- )
+NTSTATUS STDCALL NtAccessCheckAndAuditAlarm(IN PUNICODE_STRING SubsystemName,
+ IN PHANDLE ObjectHandle,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN ACCESS_MASK DesiredAccess,
+ IN PGENERIC_MAPPING GenericMapping,
+ IN BOOLEAN ObjectCreation,
+ OUT PULONG GrantedAccess,
+ OUT PBOOLEAN AccessStatus,
+ OUT PBOOLEAN GenerateOnClose)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtAdjustGroupsToken(
- IN HANDLE TokenHandle,
- IN BOOLEAN ResetToDefault,
- IN PTOKEN_GROUPS NewState,
- IN ULONG BufferLength,
- OUT PTOKEN_GROUPS PreviousState OPTIONAL,
- OUT PULONG ReturnLength
- )
+NTSTATUS STDCALL NtAdjustGroupsToken(IN HANDLE TokenHandle,
+ IN BOOLEAN ResetToDefault,
+ IN PTOKEN_GROUPS NewState,
+ IN ULONG BufferLength,
+ OUT PTOKEN_GROUPS PreviousState OPTIONAL,
+ OUT PULONG ReturnLength)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtAdjustPrivilegesToken(
- IN HANDLE TokenHandle,
- IN BOOLEAN DisableAllPrivileges,
- IN PTOKEN_PRIVILEGES NewState,
- IN ULONG BufferLength,
- OUT PTOKEN_PRIVILEGES PreviousState,
- OUT PULONG ReturnLength
- )
-{
-}
-NTSTATUS
-STDCALL
-ZwAdjustPrivilegesToken(
- IN HANDLE TokenHandle,
- IN BOOLEAN DisableAllPrivileges,
- IN PTOKEN_PRIVILEGES NewState,
- IN ULONG BufferLength,
- OUT PTOKEN_PRIVILEGES PreviousState,
- OUT PULONG ReturnLength
- )
+NTSTATUS STDCALL NtAdjustPrivilegesToken(IN HANDLE TokenHandle,
+ IN BOOLEAN DisableAllPrivileges,
+ IN PTOKEN_PRIVILEGES NewState,
+ IN ULONG BufferLength,
+ OUT PTOKEN_PRIVILEGES PreviousState,
+ OUT PULONG ReturnLength)
{
+ return(ZwAdjustPrivilegesToken(TokenHandle,
+ DisableAllPrivileges,
+ NewState,
+ BufferLength,
+ PreviousState,
+ ReturnLength));
}
-NTSTATUS
-STDCALL
-NtAllocateUuids(
- PLARGE_INTEGER Time,
- PULONG Version, // ???
- PULONG ClockCycle
- )
+NTSTATUS STDCALL ZwAdjustPrivilegesToken(IN HANDLE TokenHandle,
+ IN BOOLEAN DisableAllPrivileges,
+ IN PTOKEN_PRIVILEGES NewState,
+ IN ULONG BufferLength,
+ OUT PTOKEN_PRIVILEGES PreviousState,
+ OUT PULONG ReturnLength)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-ZwAllocateUuids(
- PLARGE_INTEGER Time,
- PULONG Version, // ???
- PULONG ClockCycle
- )
+NTSTATUS STDCALL NtAllocateUuids(PLARGE_INTEGER Time,
+ PULONG Version, // ???
+ PULONG ClockCycle)
{
+ return(ZwAllocateUuids(Time,
+ Version,
+ ClockCycle));
}
-NTSTATUS
-STDCALL
-NtCloseObjectAuditAlarm(
- IN PUNICODE_STRING SubsystemName,
- IN PVOID HandleId,
- IN BOOLEAN GenerateOnClose
- )
+NTSTATUS STDCALL ZwAllocateUuids(PLARGE_INTEGER Time,
+ PULONG Version, // ???
+ PULONG ClockCycle)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtAccessCheck(
- IN PSECURITY_DESCRIPTOR SecurityDescriptor,
- IN HANDLE ClientToken,
- IN ACCESS_MASK DesiredAcces,
- IN PGENERIC_MAPPING GenericMapping,
- OUT PRIVILEGE_SET PrivilegeSet,
- OUT PULONG ReturnLength,
- OUT PULONG GrantedAccess,
- OUT PBOOLEAN AccessStatus
- )
+NTSTATUS STDCALL NtCloseObjectAuditAlarm(IN PUNICODE_STRING SubsystemName,
+ IN PVOID HandleId,
+ IN BOOLEAN GenerateOnClose)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-ZwAccessCheck(
- IN PSECURITY_DESCRIPTOR SecurityDescriptor,
- IN HANDLE ClientToken,
- IN ACCESS_MASK DesiredAcces,
- IN PGENERIC_MAPPING GenericMapping,
- OUT PRIVILEGE_SET PrivilegeSet,
- OUT PULONG ReturnLength,
- OUT PULONG GrantedAccess,
- OUT PBOOLEAN AccessStatus
- )
+NTSTATUS STDCALL NtAccessCheck(IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN HANDLE ClientToken,
+ IN ACCESS_MASK DesiredAccess,
+ IN PGENERIC_MAPPING GenericMapping,
+ OUT PRIVILEGE_SET PrivilegeSet,
+ OUT PULONG ReturnLength,
+ OUT PULONG GrantedAccess,
+ OUT PBOOLEAN AccessStatus)
+{
+ return(ZwAccessCheck(SecurityDescriptor,
+ ClientToken,
+ DesiredAccess,
+ GenericMapping,
+ PrivilegeSet,
+ ReturnLength,
+ GrantedAccess,
+ AccessStatus));
+}
+
+NTSTATUS STDCALL ZwAccessCheck(IN PSECURITY_DESCRIPTOR SecurityDescriptor,
+ IN HANDLE ClientToken,
+ IN ACCESS_MASK DesiredAcces,
+ IN PGENERIC_MAPPING GenericMapping,
+ OUT PRIVILEGE_SET PrivilegeSet,
+ OUT PULONG ReturnLength,
+ OUT PULONG GrantedAccess,
+ OUT PBOOLEAN AccessStatus)
{
+ UNIMPLEMENTED;
}
NTSTATUS RtlCreateSecurityDescriptor(PSECURITY_DESCRIPTOR SecurityDescriptor,
fprintf(stdout,"{\"_%s\",(unsigned int)%s},\n",sym[j],sym[j]);
}
- fprintf(stdout,"{NULL,NULL},\n");
+ fprintf(stdout,"{(char *)NULL,0},\n");
fprintf(stdout,"};\n");
return(0);
DEBUGGING_CFLAGS =
endif
+ifeq ($(WARNINGS_ARE_ERRORS),yes)
+EXTRA_CFLAGS = -Werror
+endif
+
DEFINES = -DDBG -DCOMPILER_LARGE_INTEGERS
ifeq ($(WIN32_LEAN_AND_MEAN),yes)
NATIVE_CC = gcc
CFLAGS = -O2 -I../../../include -I../../include \
-I../include -fno-builtin $(LEAN_AND_MEAN_DEFINE) \
- $(DEFINES) -Wall -Wstrict-prototypes $(DEBUGGING_CFLAGS)
+ $(DEFINES) -Wall -Wstrict-prototypes $(DEBUGGING_CFLAGS) \
+ $(EXTRA_CFLAGS)
CXXFLAGS = $(CFLAGS)
NFLAGS = -i../../include/ -i../include/ -pinternal/asm.inc -f$(NASM_FORMAT) -d$(NASM_FORMAT)
LD = $(PREFIX)ld