for(;;);
}
+VOID KeDumpStackFrames(ULONG DummyArg)
+{
+ PULONG Stack = ((PULONG)&DummyArg)[-1];
+ ULONG i;
+
+ DbgPrint("Frames:\n");
+ for (i=0; i<32; i++)
+ {
+ if (Stack[i] > KERNEL_BASE)
+ {
+ DbgPrint("%.8x ",Stack[i]);
+ }
+ }
+ DbgPrint("\n");
+}
+
static void set_system_call_gate(unsigned int sel, unsigned int func)
{
DPRINT("sel %x %d\n",sel,sel);
#include <internal/mmhal.h>
#include <internal/halio.h>
-//#define BOCHS_DEBUGGING 1
+#define BOCHS_DEBUGGING 1
//#define SERIAL_DEBUGGING
#define SERIAL_PORT 0x03f8
#define SERIAL_BAUD_RATE 19200
PDEVICE_OBJECT DeviceObject,
PVOID Buffer,
PVOID Length)
+/*
+ * FUNCTION: Prepares the buffer to be used for an IRP
+ */
{
+ Irp->UserBuffer = (LPVOID)Buffer;
+ if (DeviceObject->Flags&DO_BUFFERED_IO)
+ {
+ DPRINT("Doing buffer i/o\n",0);
+ Irp->AssociatedIrp.SystemBuffer = (PVOID)
+ ExAllocatePool(NonPagedPool,Length);
+ if (Irp->AssociatedIrp.SystemBuffer==NULL)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+ }
+ if (DeviceObject->Flags&DO_DIRECT_IO)
+ {
+ DPRINT("Doing direct i/o\n",0);
+
+ Irp->MdlAddress = MmCreateMdl(NULL,Buffer,Length);
+ MmProbeAndLockPages(Irp->MdlAddress,UserMode,IoWriteAccess);
+ Irp->UserBuffer = NULL;
+ Irp->AssociatedIrp.SystemBuffer = NULL;
+ }
+ return(STATUS_SUCCESS);
}
PIRP IoBuildFilesystemControlRequest(ULONG MinorFunction,
Irp->UserIosb = IoStatusBlock;
if (DeviceObject->Flags&DO_BUFFERED_IO)
{
- DPRINT("Doing buffer i/o\n",0);
+ DPRINT("Doing buffer i/o\n");
Irp->AssociatedIrp.SystemBuffer = (PVOID)
ExAllocatePool(NonPagedPool,Length);
if (Irp->AssociatedIrp.SystemBuffer==NULL)
{
+ IoFreeIrp(Irp);
return(NULL);
}
if (MajorFunction == IRP_MJ_WRITE)
}
if (DeviceObject->Flags&DO_DIRECT_IO)
{
- DPRINT("Doing direct i/o\n",0);
+ DPRINT("Doing direct i/o\n");
Irp->MdlAddress = MmCreateMdl(NULL,Buffer,Length);
if (MajorFunction == IRP_MJ_READ)
}
if (DeviceObject->Flags & DO_DIRECT_IO)
{
+ DPRINT("Tearing down MDL\n");
if (Irp->MdlAddress->MappedSystemVa!=NULL)
{
MmUnmapLockedPages(Irp->MdlAddress->MappedSystemVa,
if (Result == DeallocateObject)
{
IoFreeController(ControllerObject);
- ExFreePool(entry);
}
+ ExFreePool(entry);
}
PCONTROLLER_OBJECT IoCreateController(ULONG Size)
* ControllerObject = Controller object to be released
*/
{
- PKDEVICE_QUEUE_ENTRY QEntry = KeRemoveDeviceQueue(&ControllerObject->
- DeviceWaitQueue);
- CONTROLLER_QUEUE_ENTRY* Entry = CONTAINING_RECORD(QEntry,
- CONTROLLER_QUEUE_ENTRY,
- Entry);
+ PKDEVICE_QUEUE_ENTRY QEntry;
+ CONTROLLER_QUEUE_ENTRY* Entry;
IO_ALLOCATION_ACTION Result;
- if (QEntry==NULL)
- {
- return;
- }
- Result = Entry->ExecutionRoutine(Entry->DeviceObject,
- Entry->DeviceObject->CurrentIrp,NULL,
- Entry->Context);
- if (Result == DeallocateObject)
+ do
{
+ QEntry = KeRemoveDeviceQueue(&ControllerObject->DeviceWaitQueue);
+ Entry = CONTAINING_RECORD(QEntry,CONTROLLER_QUEUE_ENTRY,Entry);
+ if (QEntry==NULL)
+ {
+ return;
+ }
+ Result = Entry->ExecutionRoutine(Entry->DeviceObject,
+ Entry->DeviceObject->CurrentIrp,
+ NULL,
+ Entry->Context);
ExFreePool(Entry);
- }
+ } while (Result == DeallocateObject);
}
DeviceObject = (PDEVICE_OBJECT)Object;
+ DPRINT("DeviceObject %x\n",DeviceObject);
DeviceObject = IoGetAttachedDevice(DeviceObject);
DPRINT("DeviceObject %x\n",DeviceObject);
else
{
CHECKPOINT;
+ DPRINT("DeviceObject %x\n",DeviceObject);
+ DPRINT("FileHandle %x\n",FileHandle);
if (DeviceObject->DeviceType != FILE_DEVICE_FILE_SYSTEM &&
DeviceObject->DeviceType != FILE_DEVICE_DISK)
{
+ CHECKPOINT;
ZwClose(*FileHandle);
*FileHandle=0;
return(STATUS_UNSUCCESSFUL);
}
+ DPRINT("DeviceObject->Vpb %x\n",DeviceObject->Vpb);
if (!(DeviceObject->Vpb->Flags & VPB_MOUNTED))
{
+ CHECKPOINT;
Status = IoTryToMountStorageDevice(DeviceObject);
if (Status!=STATUS_SUCCESS)
{
+ CHECKPOINT;
ZwClose(*FileHandle);
*FileHandle=0;
return(Status);
}
DeviceObject = IoGetAttachedDevice(DeviceObject);
}
- DPRINT("Remainder %w\n",Remainder);
+// DPRINT("Remainder %x\n",Remainder);
+// DPRINT("Remainder %w\n",Remainder);
FileObject->FileName.Buffer = ExAllocatePool(NonPagedPool,
wstrlen(Remainder));
RtlInitUnicodeString(&(FileObject->FileName),Remainder);
- DPRINT("FileObject->FileName.Buffer %x %w\n",
- FileObject->FileName.Buffer,FileObject->FileName.Buffer);
+// DPRINT("FileObject->FileName.Buffer %x %w\n",
+// FileObject->FileName.Buffer,FileObject->FileName.Buffer);
}
CHECKPOINT;
/* FUNCTIONS ***************************************************************/
-NTSTATUS
-STDCALL
-NtUnloadDriver(
- IN PUNICODE_STRING DriverServiceName
- )
+NTSTATUS STDCALL NtUnloadDriver(IN PUNICODE_STRING DriverServiceName)
{
+ return(ZwUnloadDriver(DriverServiceName));
}
-NTSTATUS
-STDCALL
-ZwUnloadDriver(
- IN PUNICODE_STRING DriverServiceName
- )
+NTSTATUS STDCALL ZwUnloadDriver(IN PUNICODE_STRING DriverServiceName)
{
+ UNIMPLEMENTED;
}
NTSTATUS NtLoadDriver(PUNICODE_STRING DriverServiceName)
{
+ return(ZwLoadDriver(DriverServiceName));
}
NTSTATUS ZwLoadDriver(PUNICODE_STRING DriverServiceName)
* RETURNS: Status
*/
{
+ UNIMPLEMENTED;
}
NTSTATUS IoAttachDeviceByPointer(PDEVICE_OBJECT SourceDevice,
AttachedDevice->AttachedDevice = SourceDevice;
SourceDevice->StackSize = AttachedDevice->StackSize + 1;
+ SourceDevice->Vpb = AttachedDevice->Vpb;
return(AttachedDevice);
}
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/dir.c
* PURPOSE: Directory functions
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/* FUNCTIONS *****************************************************************/
-NTSTATUS STDCALL
-NtQueryDirectoryFile(
- IN HANDLE FileHandle,
- IN HANDLE Event OPTIONAL,
- IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
- IN PVOID ApcContext OPTIONAL,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PVOID FileInformation,
- IN ULONG Length,
- IN FILE_INFORMATION_CLASS FileInformationClass,
- IN BOOLEAN ReturnSingleEntry,
- IN PUNICODE_STRING FileName OPTIONAL,
- IN BOOLEAN RestartScan
- )
+NTSTATUS STDCALL NtQueryDirectoryFile(IN HANDLE FileHandle,
+ IN HANDLE Event OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS
+ FileInformationClass,
+ IN BOOLEAN ReturnSingleEntry,
+ IN PUNICODE_STRING FileName OPTIONAL,
+ IN BOOLEAN RestartScan)
{
return(ZwQueryDirectoryFile(FileHandle,
Event,
NTSTATUS Status;
KEVENT Event;
PIO_STACK_LOCATION IoStack;
+ BOOLEAN IndexSpecified;
+ ULONG Idx;
Status = ObReferenceObjectByHandle(FileHandle,
FILE_LIST_DIRECTORY,
Irp->UserEvent = &Event;
IoStack = IoGetNextIrpStackLocation(Irp);
+
+ IoStack->Flags = 0;
+ if (RestartScan)
+ {
+ IoStack->Flags = IoStack->Flags | SL_RESTART_SCAN;
+ }
+ if (ReturnSingleEntry)
+ {
+ IoStack->Flags = IoStack->Flags | SL_RETURN_SINGLE_ENTRY;
+ }
+
+ switch (FileInformationClass)
+ {
+ case FileNameInformation:
+ Idx = ((PFILE_NAMES_INFORMATION)FileInformation)->FileIndex;
+ if (Idx != 0)
+ {
+ IoStack->Parameters.QueryDirectory.FileIndex = Idx;
+ IoStack->Flags = IoStack->Flags | SL_INDEX_SPECIFIED;
+ }
+ break;
+
+ case FileDirectoryInformation:
+ Idx = ((PFILE_DIRECTORY_INFORMATION)FileInformation)->FileIndex;
+ if (Idx != 0)
+ {
+ IoStack->Parameters.QueryDirectory.FileIndex = Idx;
+ IoStack->Flags = IoStack->Flags | SL_INDEX_SPECIFIED;
+ }
+ break;
+
+ case FileFullDirectoryInformation:
+ Idx = ((PFILE_FULL_DIR_INFORMATION)FileInformation)->FileIndex;
+ if (Idx != 0)
+ {
+ IoStack->Parameters.QueryDirectory.FileIndex = Idx;
+ IoStack->Flags = IoStack->Flags | SL_INDEX_SPECIFIED;
+ }
+ break;
+
+ case FileBothDirectoryInformation:
+ Idx = ((PFILE_BOTH_DIR_INFORMATION)FileInformation)->FileIndex;
+ if (Idx != 0)
+ {
+ IoStack->Parameters.QueryDirectory.FileIndex = Idx;
+ IoStack->Flags = IoStack->Flags | SL_INDEX_SPECIFIED;
+ }
+ break;
+
+ default:
+ return(STATUS_UNSUCCESSFUL);
+ }
+
IoStack->MajorFunction = IRP_MJ_DIRECTORY_CONTROL;
IoStack->MinorFunction = IRP_MN_QUERY_DIRECTORY;
- IoStack->Flags = 0;
+
IoStack->Control = 0;
IoStack->DeviceObject = DeviceObject;
IoStack->FileObject = FileObject;
IoStack->Parameters.QueryDirectory.FileInformationClass =
FileInformationClass;
- IoStack->Parameters.QueryDirectory.ReturnSingleEntry =
- ReturnSingleEntry;
IoStack->Parameters.QueryDirectory.FileName = FileName;
- IoStack->Parameters.QueryDirectory.RestartScan = RestartScan;
+ IoStack->Parameters.QueryDirectory.Length = Length;
Status = IoCallDriver(FileObject->DeviceObject,Irp);
if (Status==STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
break;
case STATUS_SUCCESS:
+ DeviceObject->Vpb->Flags = DeviceObject->Vpb->Flags |
+ VPB_MOUNTED;
KeReleaseSpinLock(&FileSystemListLock,oldlvl);
return(STATUS_SUCCESS);
DbgPrint("Bug detected (code %x param %x %x %x %x)\n",BugCheckCode,
BugCheckParameter1,BugCheckParameter2,BugCheckParameter3,
BugCheckParameter4);
- *((unsigned int *)0)=0;
+ KeDumpStackFrames();
for(;;);
}
#include <windows.h>
#include <ddk/ntddk.h>
+#include <internal/debug.h>
+
/* FUNCTIONS ****************************************************************/
VOID ExRaiseStatus(NTSTATUS Status)
}
-NTSTATUS
-STDCALL
-NtRaiseException(
- IN PEXCEPTION_RECORD ExceptionRecord,
- IN PCONTEXT Context,
- IN BOOL IsDebugger OPTIONAL
- )
+NTSTATUS STDCALL NtRaiseException(IN PEXCEPTION_RECORD ExceptionRecord,
+ IN PCONTEXT Context,
+ IN BOOL IsDebugger OPTIONAL)
{
+ return(ZwRaiseException(ExceptionRecord,
+ Context,
+ IsDebugger));
}
-NTSTATUS
-STDCALL
-ZwRaiseException(
- IN PEXCEPTION_RECORD ExceptionRecord,
- IN PCONTEXT Context,
- IN BOOL IsDebugger OPTIONAL
- )
+NTSTATUS STDCALL ZwRaiseException(IN PEXCEPTION_RECORD ExceptionRecord,
+ IN PCONTEXT Context,
+ IN BOOL IsDebugger OPTIONAL)
{
+ UNIMPLEMENTED;
}
#include <internal/mmhal.h>
#include <internal/i386/segment.h>
-//#define NDEBUG
+#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS ****************************************************************/
}
extern unsigned int nr_used_blocks;
+extern unsigned int EiFreeNonPagedPool;
+extern unsigned int EiUsedNonPagedPool;
VOID KiTimerInterrupt(VOID)
/*
char str[36];
char* vidmem=(char *)physical_to_linear(0xb8000 + 160 - 36);
int i;
+ int x,y;
/*
* Increment the number of timers ticks
* Display the tick count in the top left of the screen as a debugging
* aid
*/
- sprintf(str,"%.8u %.8u",nr_used_blocks,ticks);
+// sprintf(str,"%.8u %.8u",nr_used_blocks,ticks);
+ if ((EiFreeNonPagedPool + EiUsedNonPagedPool) == 0)
+ {
+ x = y = 0;
+ }
+ else
+ {
+ x = (EiFreeNonPagedPool * 100) /
+ (EiFreeNonPagedPool + EiUsedNonPagedPool);
+ y = (EiUsedNonPagedPool * 100) /
+ (EiFreeNonPagedPool + EiUsedNonPagedPool);
+ }
+// sprintf(str,"%.8u %.8u",EiFreeNonPagedPool,ticks);
+ sprintf(str,"%.4u %.4u %.7u",x,y,ticks);
+// sprintf(str,"%.8u %.8u",EiFreeNonPagedPool,EiUsedNonPagedPool);
for (i=0;i<17;i++)
{
*vidmem=str[i];
#include <ddk/ntddk.h>
+#if 0
+#define VALIDATE_POOL validate_kernel_pool()
+#else
+#define VALIDATE_POOL
+#endif
/* TYPES *******************************************************************/
static unsigned int pool_free_mem = 0;
+unsigned int EiFreeNonPagedPool = 0;
+unsigned int EiUsedNonPagedPool = 0;
+
/* FUNCTIONS ***************************************************************/
VOID ExInitNonPagedPool(ULONG BaseAddress)
free_blk->magic = BLOCK_HDR_MAGIC;
free_blk->size = (nr_pages * PAGESIZE) -((sizeof(block_hdr)*2) + size);
add_to_free_list(free_blk);
+
+ EiFreeNonPagedPool = EiFreeNonPagedPool + free_blk->size;
+ EiUsedNonPagedPool = EiUsedNonPagedPool + used_blk->size;
}
else
{
used_blk->magic = BLOCK_HDR_MAGIC;
used_blk->size = nr_pages * PAGESIZE;
add_to_used_list(used_blk);
+
+ EiUsedNonPagedPool = EiUsedNonPagedPool + used_blk->size;
}
- validate_kernel_pool();
+ VALIDATE_POOL;
return(used_blk);
}
*/
if (current->size > (1 + size + sizeof(block_hdr)))
{
+ block_hdr* free_blk;
+
+ EiFreeNonPagedPool = EiFreeNonPagedPool - current->size;
+
/*
* Replace the bigger block with a smaller block in the
* same position in the list
*/
- block_hdr* free_blk = (block_hdr *)(((int)current)
- + sizeof(block_hdr) + size);
+ free_blk = (block_hdr *)(((int)current)
+ + sizeof(block_hdr) + size);
free_blk->magic = BLOCK_HDR_MAGIC;
free_blk->next = current->next;
free_blk->previous = current->previous;
current->size=size;
add_to_used_list(current);
- validate_kernel_pool();
+ EiUsedNonPagedPool = EiUsedNonPagedPool + current->size;
+ EiFreeNonPagedPool = EiFreeNonPagedPool + free_blk->size;
+
+ VALIDATE_POOL;
return(block_to_address(current));
}
remove_from_free_list(current);
add_to_used_list(current);
- validate_kernel_pool();
+ EiFreeNonPagedPool = EiFreeNonPagedPool - current->size;
+ EiUsedNonPagedPool = EiUsedNonPagedPool + current->size;
+
+ VALIDATE_POOL;
return(block_to_address(current));
}
block_hdr* blk=address_to_block(block);
OLD_DPRINT("(%s:%d) freeing block %x\n",__FILE__,__LINE__,blk);
- validate_kernel_pool();
+// DbgPrint("ExFreePool(block %x), size %d, caller %x\n",block,blk->size,
+// ((PULONG)&block)[-1]);
+
+ VALIDATE_POOL;
+
+ if (blk->magic != BLOCK_HDR_MAGIC)
+ {
+ DbgPrint("ExFreePool of non-allocated address\n");
+ for(;;);
+ return;
+ }
+
/*
* Please don't change the order
*/
remove_from_used_list(blk);
add_to_free_list(blk);
- validate_kernel_pool();
+ EiUsedNonPagedPool = EiUsedNonPagedPool - blk->size;
+ EiFreeNonPagedPool = EiFreeNonPagedPool + blk->size;
+
+ VALIDATE_POOL;
}
PVOID ExAllocateNonPagedPoolWithTag(ULONG type, ULONG size, ULONG Tag)
// DbgPrint("Blocks on free list %d\n",nr_free_blocks);
// DbgPrint("Blocks on used list %d\n",nr_used_blocks);
- OLD_DPRINT("ExAllocateNonPagedPool(type %d, size %d)\n",type,size);
- validate_kernel_pool();
+// OLD_DPRINT("ExAllocateNonPagedPool(type %d, size %d)\n",type,size);
+ VALIDATE_POOL;
/*
* accomodate this useful idiom
* NULL on failure
*/
{
- return(ExAllocatePoolWithTag(PoolType,NumberOfBytes,TAG_NONE));
+ PVOID Block;
+// DbgPrint("ExAllocatePool(NumberOfBytes %d) caller %x\n",
+// NumberOfBytes,((PULONG)&PoolType)[-1]);
+ Block = ExAllocatePoolWithTag(PoolType,NumberOfBytes,TAG_NONE);
+// DbgPrint("ExAllocatePool() = %x\n",Block);
+ return(Block);
}
PVOID ExAllocatePoolWithTag(ULONG type, ULONG size, ULONG Tag)
Status = ObLookupObject(ObjectAttributes->RootDirectory,
ObjectAttributes->ObjectName->Buffer,
Object,
- UnparsedSection);
+ UnparsedSection,
+ ObjectAttributes->Attributes);
DPRINT("*Object %x\n",*Object);
DPRINT("ObjectAttributes->ObjectName->Length %d\n",
ObjectAttributes->ObjectName->Length);
InitializedAttributes->SecurityQualityOfService=NULL;
}
-static PVOID ObDirLookup(PDIRECTORY_OBJECT dir, PWSTR name)
+static PVOID ObDirLookup(PDIRECTORY_OBJECT dir, PWSTR name,
+ ULONG Attributes)
/*
* FUNCTION: Looks up an entry within a namespace directory
* ARGUMENTS:
{
current_obj = CONTAINING_RECORD(current,OBJECT_HEADER,Entry);
DPRINT("Scanning %w\n",current_obj->Name.Buffer);
- if ( wcscmp(current_obj->Name.Buffer, name)==0)
+ if (Attributes & OBJ_CASE_INSENSITIVE)
{
- return(HEADER_TO_BODY(current_obj));
+ if (wcsicmp(current_obj->Name.Buffer, name)==0)
+ {
+ DPRINT("Found it %x\n",HEADER_TO_BODY(current_obj));
+ return(HEADER_TO_BODY(current_obj));
+ }
+ }
+ else
+ {
+ if ( wcscmp(current_obj->Name.Buffer, name)==0)
+ {
+ DPRINT("Found it %x\n",HEADER_TO_BODY(current_obj));
+ return(HEADER_TO_BODY(current_obj));
+ }
}
current = current->Flink;
}
}
NTSTATUS ObLookupObject(HANDLE rootdir, PWSTR string, PVOID* Object,
- PWSTR* UnparsedSection)
+ PWSTR* UnparsedSection, ULONG Attributes)
/*
* FUNCTION: Lookup an object within the system namespc
* ARGUMENTS:
}
DPRINT("\n",0);
- current_dir=(PDIRECTORY_OBJECT)ObDirLookup(current_dir,current);
+ current_dir=(PDIRECTORY_OBJECT)ObDirLookup(current_dir,current,
+ Attributes);
if (current_dir==NULL)
{
- DbgPrint("(%s:%d) Path component not found\n",__FILE__,
- __LINE__);
+ DbgPrint("(%s:%d) Path component %w not found\n",__FILE__,
+ __LINE__,current);
return(STATUS_UNSUCCESSFUL);
}
#include <ddk/ntddk.h>
#include <internal/ps.h>
+#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS *****************************************************************/
DestinationString->Buffer-=len;
SourceString->Buffer-=len;
-};
+}
return NULL;
}
-int
-wcscmp(const wchar_t *cs, const wchar_t *ct)
+wchar_t towupper(wchar_t w)
+{
+ if (w < L'A')
+ {
+ return(w+'A');
+ }
+ else
+ {
+ return(w);
+ }
+}
+
+int wcsicmp(const wchar_t* cs, const wchar_t* ct)
+{
+ while (*cs != '\0' && *ct != '\0' && towupper(*cs) == towupper(*ct))
+ {
+ cs++;
+ ct++;
+ }
+ return *cs - *ct;
+}
+
+int wcscmp(const wchar_t *cs, const wchar_t *ct)
{
while (*cs != '\0' && *ct != '\0' && *cs == *ct)
{
return *cs - *ct;
}
-wchar_t *
-wcscpy(wchar_t *str1, const wchar_t *str2)
+wchar_t* wcscpy(wchar_t* str1, const wchar_t* str2)
{
- while ( (*str1)==(*str2) )
+ wchar_t* s = str1;
+ DbgPrint("wcscpy(str1 %w, str2 %w)\n",str1,str2);
+ while ((*str2)!=0)
{
- str1++;
+ *s = *str2;
+ s++;
str2++;
- if ( (*str1)==((wchar_t)0) && (*str1)==((wchar_t)0) )
- {
- return(0);
- }
}
- return(wchar_t *)( (*str1) - (*str2) );
+ return(str1);
}
#ifdef i386
#endif
-#ifdef i386
+#if 0
int
wcsicmp(const wchar_t *cs,const wchar_t *ct)
return __res;
}
-#else
+
int
wcsicmp(const wchar_t *cs,const wchar_t *ct)
/* FUNCTIONS ***************************************************************/
-NTSTATUS
-STDCALL
-NtQueryInformationToken(
- IN HANDLE TokenHandle,
+NTSTATUS STDCALL ZwQueryInformationToken(IN HANDLE TokenHandle,
IN TOKEN_INFORMATION_CLASS TokenInformationClass,
OUT PVOID TokenInformation,
IN ULONG TokenInformationLength,
- OUT PULONG ReturnLength
- )
+ OUT PULONG ReturnLength)
{
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtQuerySecurityObject(
- IN HANDLE Object,
- IN CINT SecurityObjectInformationClass,
- OUT PVOID SecurityObjectInformation,
- IN ULONG Length,
- OUT PULONG ReturnLength
- )
+NTSTATUS STDCALL NtQueryInformationToken(IN HANDLE TokenHandle,
+ IN TOKEN_INFORMATION_CLASS TokenInformationClass,
+ OUT PVOID TokenInformation,
+ IN ULONG TokenInformationLength,
+ OUT PULONG ReturnLength)
+{
+ return(ZwQueryInformationToken(TokenHandle,
+ TokenInformationClass,
+ TokenInformation,
+ TokenInformationLength,
+ ReturnLength));
+}
+
+NTSTATUS STDCALL ZwQuerySecurityObject(IN HANDLE Object,
+ IN CINT SecurityObjectInformationClass,
+ OUT PVOID SecurityObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ReturnLength)
+{
+ UNIMPLEMENTED;
+}
+
+NTSTATUS STDCALL NtQuerySecurityObject(IN HANDLE Object,
+ IN CINT SecurityObjectInformationClass,
+ OUT PVOID SecurityObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ReturnLength)
{
+ return(ZwQuerySecurityObject(Object,
+ SecurityObjectInformationClass,
+ SecurityObjectInformation,
+ Length,
+ ReturnLength));
}
NTSTATUS
BaseAddress = (PVOID)0x10000;
SectionOffset.HighPart = 0;
SectionOffset.LowPart = 0;
- Size = 0x8000;
+ Size = 0x10000;
ZwMapViewOfSection(SectionHandle,
ShellHandle,
&BaseAddress,
0,
- 0x8000,
+ Size,
&SectionOffset,
&Size,
0,