}
void ExecuteCd(char* cmdline)
-{
- UCHAR Buffer[255];
-
- debug_printf("ExecuteCd(cmdline %s)\n",cmdline);
-
- if (cmdline[0] != '\\' &&
- cmdline[1] != ':')
- {
- GetCurrentDirectoryA(255,Buffer);
- }
- else
- {
- Buffer[0] = 0;
- }
- debug_printf("Buffer %s\n",Buffer);
-
- lstrcatA(Buffer,cmdline);
-
- debug_printf("Buffer %s\n",Buffer);
-
- if (Buffer[lstrlenA(Buffer)-1] != '\\')
+{
+ if (!SetCurrentDirectoryA(cmdline))
{
- lstrcatA(Buffer,"\\");
+ debug_printf("Invalid directory\n");
}
- debug_printf("Buffer %s\n",Buffer);
-
- SetCurrentDirectoryA(Buffer);
}
void ExecuteDir(char* cmdline)
char* cmd;
char* tail;
- if (line[1] == ':' && line[2] == 0)
+ if (isalpha(line[0]) && line[1] == ':' && line[2] == 0)
{
line[2] = '\\';
line[3] = 0;
tail++;
}
cmd = line;
-
-// debug_printf("cmd '%s' tail '%s'\n",cmd,tail);
+
if (cmd==NULL)
{
do
{
- ReadConsoleA(InputHandle,
+ if (!ReadConsoleA(InputHandle,
&KeyEvent,
sizeof(KEY_EVENT_RECORD),
&Result,
- NULL);
+ NULL))
+ {
+ debug_printf("Failed to read from console\n");
+ for(;;);
+ }
if (KeyEvent.bKeyDown && KeyEvent.AsciiChar != 0)
{
debug_printf("%c", KeyEvent.AsciiChar);
// -------------------------------------------------------------------------
-#include <internal/kernel.h>
#include <internal/i386/io.h>
#include <internal/string.h>
#include <internal/string.h>
#include <wstring.h>
-//#define NDEBUG
+#define NDEBUG
#include <internal/debug.h>
#include "ext2fs.h"
* FUNCTION: Closes a file
*/
{
+ DPRINT("Ext2CloseFile(DeviceExt %x, FileObject %x)\n",
+ DeviceExt,FileObject);
+ return(STATUS_SUCCESS);
}
NTSTATUS Ext2Close(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
- PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
- PFILE_OBJECT FileObject = Stack->FileObject;
- PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
+ PIO_STACK_LOCATION Stack;
+ PFILE_OBJECT FileObject;
+ PDEVICE_EXTENSION DeviceExtension;
NTSTATUS Status;
+ DPRINT("Ext2Close(DeviceObject %x, Irp %x)\n",DeviceObject,Irp);
+
+ Stack = IoGetCurrentIrpStackLocation(Irp);
+ FileObject = Stack->FileObject;
+ DeviceExtension = DeviceObject->DeviceExtension;
+
Status = Ext2CloseFile(DeviceExtension,FileObject);
Irp->IoStatus.Status = Status;
{
PVfatFCB pFcb;
PVfatCCB pCcb;
+
+ DPRINT("FsdCloseFile(DeviceExt %x, FileObject %x)\n",
+ DeviceExt,FileObject);
+
//FIXME : update entry in directory ?
pCcb = (PVfatCCB)(FileObject->FsContext2);
+
+ DPRINT("pCcb %x\n",pCcb);
+ if (pCcb == NULL)
+ {
+ return(STATUS_SUCCESS);
+ }
+
pFcb = pCcb->pFcb;
+
pFcb->RefCount--;
if(pFcb->RefCount<=0)
{
PDEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
NTSTATUS Status;
+ DPRINT("FsdClose(DeviceObject %x, Irp %x)\n",DeviceObject, Irp);
+
Status = FsdCloseFile(DeviceExtension,FileObject);
Irp->IoStatus.Status = Status;
POBJECT_TYPE ObjectType,
KPROCESSOR_MODE AccessMode);
-NTSTATUS ObOpenObjectByName(POBJECT_ATTRIBUTES ObjectAttributes,
- PVOID* Object, PWSTR* UnparsedSection);
+NTSTATUS ObReferenceObjectByName(PUNICODE_STRING ObjectPath,
+ ULONG Attributes,
+ PACCESS_STATE PassedAccessState,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_TYPE ObjectType,
+ KPROCESSOR_MODE AccessMode,
+ PVOID ParseContext,
+ PVOID* ObjectPtr);
+
+PVOID ObCreateObject(PHANDLE Handle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ POBJECT_TYPE Type);
struct _DIRECTORY_OBJECT;
+struct _OBJECT_ATTRIBUTES;
typedef ULONG ACCESS_STATE, *PACCESS_STATE;
ACCESS_MASK GrantedAccess;
} OBJECT_HANDLE_INFORMATION, *POBJECT_HANDLE_INFORMATION;
-struct _OBJECT;
-
-
typedef struct _OBJECT_TYPE
{
/*
/*
* PURPOSE: Called to close an object if OkayToClose returns true
*/
- VOID (*Close)(PVOID ObjectBody);
+ VOID (*Close)(PVOID ObjectBody, ULONG HandleCount);
/*
- * PURPOSE: Called to close an object if OkayToClose returns true
+ * PURPOSE: Called to delete an object when the last reference is removed
*/
- VOID (*Delete)(VOID);
+ VOID (*Delete)(PVOID ObjectBody);
/*
* PURPOSE: Called when an open attempts to open a file apparently
* residing within the object
*/
- PVOID (*Parse)(struct _OBJECT *ParsedObject, PWSTR UnparsedSection);
+ PVOID (*Parse)(PVOID ParsedObject, PWSTR* Path);
/*
*/
* PURPOSE: Called when a process asks to close the object
*/
VOID (*OkayToClose)(VOID);
-
+
+ NTSTATUS (*Create)(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ struct _OBJECT_ATTRIBUTES* ObjectAttributes);
+
} OBJECT_TYPE, *POBJECT_TYPE;
LIST_ENTRY ListHead;
KSPIN_LOCK ListLock;
} HANDLE_TABLE, *PHANDLE_TABLE;
+
+extern POBJECT_TYPE ObDirectoryType;
IN ULONG NumberOfBytesToFlush,
OUT PULONG NumberOfBytesFlushed OPTIONAL
);
+
/*
* FUNCTION: Flushes the dirty pages to file
- * RETURNS: Status
+ * RETURNS: Status
+ * FIXME: Not sure this does (how is the file specified)
*/
-NTSTATUS
-STDCALL
-NtFlushWriteBuffer (
- VOID
- );
-NTSTATUS
-STDCALL
-ZwFlushWriteBuffer (
- VOID
- );
-/*
+NTSTATUS STDCALL NtFlushWriteBuffer(VOID);
+NTSTATUS STDCALL ZwFlushWriteBuffer(VOID);
+
+ /*
* FUNCTION: Frees a range of virtual memory
* ARGUMENTS:
- * ProcessHandle = Points to the process that allocated the virtual memory
- * BaseAddress = Points to the memory address, rounded down to a multiple of the pagesize
- * RegionSize = Limits the range to free, rounded up to a multiple of the paging size
+ * ProcessHandle = Points to the process that allocated the virtual
+ * memory
+ * BaseAddress = Points to the memory address, rounded down to a
+ * multiple of the pagesize
+ * RegionSize = Limits the range to free, rounded up to a multiple of
+ * the paging size
* FreeType = Can be one of the values: MEM_DECOMMIT, or MEM_RELEASE
* RETURNS: Status
*/
-
-NTSTATUS
-STDCALL
-NtFreeVirtualMemory(
- IN HANDLE ProcessHandle,
- IN PVOID *BaseAddress,
- IN PULONG RegionSize,
- IN ULONG FreeType
- );
-
-NTSTATUS
-STDCALL
-ZwFreeVirtualMemory(
- IN HANDLE ProcessHandle,
- IN PVOID *BaseAddress,
- IN PULONG RegionSize,
- IN ULONG FreeType
- );
+NTSTATUS STDCALL NtFreeVirtualMemory(IN HANDLE ProcessHandle,
+ IN PVOID *BaseAddress,
+ IN PULONG RegionSize,
+ IN ULONG FreeType);
+NTSTATUS STDCALL ZwFreeVirtualMemory(IN HANDLE ProcessHandle,
+ IN PVOID *BaseAddress,
+ IN PULONG RegionSize,
+ IN ULONG FreeType);
/*
* FUNCTION: Sends FSCTL to the filesystem
PLARGE_INTEGER Offset,
PIO_STATUS_BLOCK StatusBlock);
VOID IoSecondStageCompletion(PIRP Irp, CCHAR PriorityBoost);
+
+NTSTATUS IopCreateFile(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ POBJECT_ATTRIBUTES ObjectAttributes);
+NTSTATUS IopCreateDevice(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ POBJECT_ATTRIBUTES ObjectAttributes);
+
#endif
unsigned int module_length[64];
} boot_param;
+VOID NtInitializeEventImplementation(VOID);
+VOID NtInit(VOID);
/*
* Initalization functions (called once by main())
*/
-void MmInitialize(boot_param* bp);
-void HalInit(boot_param* bp);
-void IoInit(void);
-void ObInit(void);
-void PsInit(void);
-void TstBegin(void);
+VOID MmInitialize(boot_param* bp);
+VOID HalInit(boot_param* bp);
+VOID IoInit(VOID);
+VOID ObInit(VOID);
+VOID PsInit(VOID);
+VOID TstBegin(VOID);
VOID KeInit(VOID);
VOID HalInitConsole(boot_param* bp);
NTSTATUS ObLookupObject(HANDLE rootdir, PWSTR string, PVOID* Object,
PWSTR* UnparsedSection, ULONG Attributes);
-PVOID ObGenericCreateObject(PHANDLE Handle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes,
- POBJECT_TYPE Type);
+PVOID ObCreateObject(PHANDLE Handle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ POBJECT_TYPE Type);
VOID ObInitializeHandleTable(PKPROCESS Parent, BOOLEAN Inherit,
PKPROCESS Process);
VOID ObRemoveEntry(POBJECT_HEADER Header);
} HANDLE_REP, *PHANDLE_REP;
PHANDLE_REP ObTranslateHandle(PKPROCESS Process, HANDLE h);
+extern PDIRECTORY_OBJECT NameSpaceRoot;
#endif /* __INCLUDE_INTERNAL_OBJMGR_H */
WCHAR *FilePart;
UINT Len = 0;
+ switch (dwCreationDisposition)
+ {
+ case CREATE_NEW:
+ dwCreationDisposition = FILE_CREATE;
+ break;
+
+ case CREATE_ALWAYS:
+ dwCreationDisposition = FILE_OVERWRITE_IF;
+ break;
+
+ case OPEN_EXISTING:
+ dwCreationDisposition = FILE_OPEN;
+ break;
+
+ case OPEN_ALWAYS:
+ dwCreationDisposition = OPEN_ALWAYS;
+ break;
+
+ case TRUNCATE_EXISTING:
+ dwCreationDisposition = FILE_OVERWRITE;
+ }
+
DPRINT("CreateFileW(lpFileName %w)\n",lpFileName);
if (!(dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
BOOL STDCALL SetCurrentDirectoryA(LPCSTR lpPathName)
{
UINT i;
-
+ WCHAR TempStr[MAX_PATH];
+
DPRINT("SetCurrentDirectoryA(lpPathName %s)\n",lpPathName);
if ( lpPathName == NULL )
i = 0;
while ((lpPathName[i])!=0 && i < MAX_PATH)
{
- CurrentDirectoryW[i] = (unsigned short)lpPathName[i];
+ TempStr[i] = (unsigned short)lpPathName[i];
i++;
}
- CurrentDirectoryW[i] = 0;
+ TempStr[i] = 0;
- DPRINT("CurrentDirectoryW = '%w'\n",CurrentDirectoryW);
-
- return(TRUE);
+ return(SetCurrentDirectoryW(TempStr));
}
WINBOOL STDCALL SetCurrentDirectoryW(LPCWSTR lpPathName)
{
+ WCHAR TempDir[MAX_PATH];
+ HANDLE TempHandle;
+ ULONG Len;
+
+ DPRINT("SetCurrentDirectoryW(lpPathName %w)\n",lpPathName);
+
if ( lpPathName == NULL )
return FALSE;
if ( lstrlenW(lpPathName) > MAX_PATH )
return FALSE;
- lstrcpyW(CurrentDirectoryW,lpPathName);
+
+ lstrcpyW(TempDir, CurrentDirectoryW);
+ GetFullPathNameW(lpPathName,
+ MAX_PATH,
+ TempDir,
+ NULL);
+
+ Len = lstrlenW(TempDir);
+ if (TempDir[Len-1] != '\\')
+ {
+ TempDir[Len] = '\\';
+ TempDir[Len+1] = 0;
+ }
+
+ DPRINT("TempDir %w\n",TempDir);
+
+ TempHandle = CreateFileW(TempDir,
+ FILE_TRAVERSE,
+ 0,
+ NULL,
+ OPEN_EXISTING,
+ FILE_ATTRIBUTE_DIRECTORY,
+ NULL);
+ if (TempHandle == NULL)
+ {
+ return(FALSE);
+ }
+ CloseHandle(TempHandle);
+ lstrcpyW(CurrentDirectoryW, TempDir);
+
+ DPRINT("CurrentDirectoryW %w\n",CurrentDirectoryW);
+
return(TRUE);
}
}
-#define IS_END_OF_NAME(ch) (!(ch) || ((ch) == L'/') || ((ch) == L'\\'))
-
-
-DWORD
-STDCALL
-GetFullPathNameW(
- LPCWSTR lpFileName,
- DWORD nBufferLength,
- LPWSTR lpBuffer,
- LPWSTR *lpFilePart
- )
+DWORD STDCALL GetFullPathNameW(LPCWSTR lpFileName,
+ DWORD nBufferLength,
+ LPWSTR lpBuffer,
+ LPWSTR *lpFilePart)
{
-
- WCHAR buffer[MAX_PATH];
- WCHAR *p;
-
- if (!lpFileName || !lpBuffer) return 0;
-
- p = buffer;
-
- if (IS_END_OF_NAME(*lpFileName) && (*lpFileName)) /* Absolute path */
- {
- while (*lpFileName == L'\\')
- lpFileName++;
- }
- else /* Relative path or empty path */
- {
- if ( GetCurrentDirectoryW(MAX_PATH,p) == 0 )
- wcscpy( p, L"C:");
- if (*p)
- p += wcslen(p);
- }
- if (!*lpFileName) /* empty path */
- *p++ = '\\';
- *p = '\0';
-
- while (*lpFileName)
- {
- if (*lpFileName == '.')
- {
- if (IS_END_OF_NAME(lpFileName[1]))
- {
- lpFileName++;
- while (*lpFileName == L'\\' ) lpFileName++;
- continue;
- }
- else if ((lpFileName[1] == L'.') && IS_END_OF_NAME(lpFileName[2]))
- {
- lpFileName += 2;
- while ((*lpFileName == '\\') ) lpFileName++;
- while ((p > buffer + 2) && (*p != '\\')) p--;
- *p = '\0'; /* Remove trailing separator */
- continue;
- }
- }
- if (p >= buffer + sizeof(buffer) - 1)
- {
- //DOS_ERROR( ER_PathNotFound, EC_NotFound, SA_Abort, EL_Disk);
- return 0;
- }
- *p++ = '\\';
- while (!IS_END_OF_NAME(*lpFileName) && (p < buffer + sizeof(buffer) -1))
- *p++ = *lpFileName++;
- *p = '\0';
- while ((*lpFileName == '\\') ) lpFileName++;
- }
-
- if (!buffer[2])
- {
- buffer[2] = '\\';
- buffer[3] = '\0';
- }
-
-
- wcsncpy( lpBuffer, buffer, nBufferLength);
-
- //TRACE(dosfs, "returning %s\n", buffer );
- return wcslen(buffer);
+ PWSTR p;
+ PWSTR prev = NULL;
+
+ DPRINT("GetFullPathNameW(lpFileName %w, nBufferLength %d, lpBuffer %w, "
+ "lpFilePart %x)\n",lpFileName,nBufferLength,lpBuffer,lpFilePart);
+
+ if (!lpFileName || !lpBuffer) return 0;
+
+ if (isalpha(lpFileName[0]) && lpFileName[1] == ':')
+ {
+ lstrcpyW(lpBuffer, lpFileName);
+ }
+ else if (lpFileName[0] == '\\')
+ {
+ lstrcpyW(&lpBuffer[2], lpFileName);
+ }
+ else
+ {
+ lstrcatW(lpBuffer, lpFileName);
+ }
+
+ DPRINT("lpBuffer %w\n",lpBuffer);
+
+ p = lpBuffer + 2;
+
+ while ((*p) != 0)
+ {
+ DPRINT("prev %w p %w\n",prev,p);
+ if (p[1] == '.' && (p[2] == '\\' || p[2] == 0))
+ {
+ lstrcpyW(p, p+2);
+ }
+ else if (p[1] == '.' && p[2] == '.' && (p[3] == '\\' || p[3] == 0) &&
+ prev != NULL)
+ {
+ lstrcpyW(prev, p+3);
+ p = prev;
+ if (prev == (lpBuffer+2))
+ {
+ prev = NULL;
+ }
+ else
+ {
+ prev--;
+ while ((*prev) != '\\')
+ {
+ prev--;
+ }
+ }
+ }
+ else
+ {
+ prev = p;
+ do
+ {
+ p++;
+ }
+ while ((*p) != 0 && (*p) != '\\');
+ }
+ }
+
+ if (lpFilePart != NULL)
+ {
+ (*lpFilePart) = prev;
+ }
+
+ DPRINT("lpBuffer %w\n",lpBuffer);
+
+ return wcslen(lpBuffer);
}
all: ntdll.a
OBJECTS = napi.o stubs/stubs.o string/wstring.o stdio/vsprintf.o \
- rtl/unicode.o rtl/namespc.o
+ rtl/unicode.o rtl/namespc.o string/ctype.o
ntdll.a: $(OBJECTS)
$(AR) vcsr ntdll.a $(OBJECTS)
--- /dev/null
+
+#define upalpha ('A' - 'a')
+
+int isalpha(char c)
+{
+ return(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')));
+}
+
+int isspace(char c)
+{
+ return(c==' '||c=='\t');
+}
+
+char toupper(char c)
+{
+ if ((c>='a') && (c<='z')) return (c+upalpha);
+ return(c);
+}
+
+int islower(char c)
+{
+ if ((c>='a') && (c<='z')) return 1;
+ return 0;
+}
+
+int isdigit(char c)
+{
+ if ((c>='0') && (c<='9')) return 1;
+ return 0;
+}
+
+int isxdigit(char c)
+{
+ if (((c>='0') && (c<='9')) || ((toupper(c)>='A') && (toupper(c)<='Z')))
+ {
+ return 1;
+ }
+ return 0;
+}
+
+
+
STUB(fabs)
STUB(floor)
STUB(isalnum)
-STUB(isalpha)
STUB(iscntrl)
-STUB(isdigit)
STUB(isgraph)
-STUB(islower)
STUB(isprint)
STUB(ispunct)
-STUB(isspace)
STUB(isupper)
STUB(iswalpha)
STUB(iswctype)
-STUB(isxdigit)
STUB(labs)
STUB(log)
STUB(mbstowcs)
STUB(strtoul)
STUB(swprintf)
STUB(tan)
-STUB(tolower)
-STUB(toupper)
STUB(towlower)
#include <ddk/ntddk.h>
#include <ddk/ntifs.h>
+#include <internal/bitops.h>
#define NDEBUG
#include <internal/debug.h>
/* TYPES *********************************************************************/
-#define CACHE_SEGMENT_SIZE (0x10000)
-
-#define CACHE_SEGMENT_INVALID (0) // Isn't valid
-#define CACHE_SEGMENT_WRITTEN (1) // Written
-#define CACHE_SEGMENT_READ (2)
+#define CACHE_SEGMENT_SIZE (0x10000)
typedef struct _CACHE_SEGMENT
{
- ULONG Type; // Debugging
- ULONG Size;
- LIST_ENTRY ListEntry; // Entry in the per-open list of segments
- PVOID BaseAddress; // Base address of the mapping
- ULONG ValidLength; // Length of the mapping
- ULONG State; // Information
- MEMORY_AREA* MemoryArea; // Memory area for the mapping
- ULONG FileOffset; // Offset within the file of the mapping
- KEVENT Event;
- BOOLEAN Dirty; // Contains dirty data
+ PVOID BaseAddress;
+ PMEMORY_AREA MemoryArea;
+ ULONG ValidPages;
+ ULONG AllocatedPages;
+ LIST_ENTRY ListEntry;
+ ULONG FileOffset;
} CACHE_SEGMENT, *PCACHE_SEGMENT;
-typedef struct _CC1_CCB
+typedef struct _BCB
{
- ULONG Type;
- ULONG Size;
LIST_ENTRY CacheSegmentListHead;
- KSPIN_LOCK CacheSegmentListLock;
- LIST_ENTRY ListEntry;
-} CC1_CCB, PCC1_CCB;
+ PFILE_OBJECT FileObject;
+ KSPIN_LOCK BcbLock;
+} BCB, *PBCB;
/* FUNCTIONS *****************************************************************/
-PVOID Cc1FlushView(PCC1_CCB CacheDesc,
- ULONG FileOffset,
- ULONG Length)
-{
-}
-
-PVOID Cc1PurgeView(PCC1_CCB CacheDesc,
- ULONG FileOffset,
- ULONG Length)
-{
-}
-
-
-
-NTSTATUS Cc1RequestView(PCC1_CCB CacheDesc,
- ULONG FileOffset,
- ULONG Length,
- PCACHE_SEGMENT ReturnedSegments[],
- PULONG NrSegments)
-/*
- * FUNCTION: Request a view for caching data
- */
+NTSTATUS CcRequestCachePage(PBCB Bcb,
+ ULONG FileOffset,
+ PVOID* BaseAddress,
+ PBOOLEAN UptoDate)
{
+ KIRQL oldirql;
PLIST_ENTRY current_entry;
PCACHE_SEGMENT current;
- PCACHE_SEGMENT new_segment;
- ULONG MaxSegments;
- ULONG LengthDelta;
-
- MaxSegments = *NrSegments;
- (*NrSegments) = 0;
+ ULONG InternalOffset;
- KeAcquireSpinLock(&CacheDesc->CacheSegmentListLock);
+ KeAcquireSpinLock(&Bcb->BcbLock, &oldirql);
- current_entry = CacheDesc->CacheSegmentListHead.Flink;
- while (current_entry != &(CacheDesc->CacheSegmentListHead))
+ current_entry = Bcb->CacheSegmentListHead.Flink;
+ while (current_entry != &Bcb->CacheSegmentListHead)
{
- current = CONTAING_RECORD(current_entry, CACHE_SEGMENT, ListEntry);
-
+ current = CONTAING_RECORD(current, CACHE_SEGMENT, ListEntry);
if (current->FileOffset <= FileOffset &&
- (current->FileOffset + current->ValidLength) > FileOffset)
+ (current->FileOffset + CACHE_SEGMENT_SIZE) > FileOffset)
{
- ReturnedSegments[(*NrSegments)] = current;
- (*NrSegments)++;
- FileOffset = current->FileOffset + current->ValidLength;
- LengthDelta = (FileOffset - current->FileOffset);
- if (Length <= LengthDelta)
+ InternalOffset = (FileOffset - current->FileOffset);
+
+ if (!test_bit(InternalOffset / PAGESIZE,
+ current->AllocatedPages))
{
- KeReleaseSpinLock(&CacheDesc->CacheSegmentListLock);
- return(STATUS_SUCCESS);
+ MmSetPageEntry(PsGetCurrentProcess(),
+ current->BaseAddress + InternalOffset,
+ PAGE_READWRITE,
+ get_free_page());
}
- Length = Length - LengthDelta;
- }
- else if (current->FileOffset <= (FileOffset + Length) &&
- (current->FileOffset + current->ValidLength) >
- (FileOffset + Length))
- {
- ReturnedSegments[(*NrSegments)] = current;
- (*NrSegments)++;
- Length = Length - ((FileOffset + Length) - current->FileOffset);
+ if (!test_bit(InternalOffset / PAGESIZE,
+ current->ValidPages))
+ {
+ UptoDate = False;
+ }
+ else
+ {
+ UptoDate = True;
+ }
+ (*BaseAddress) = current->BaseAddress + InternalOffset;
+ KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
+ return(STATUS_SUCCESS);
}
-
current_entry = current_entry->Flink;
}
- KeReleaseSpinLock(&CacheDesc->CacheSegmentListLock);
+ KeReleaseSpinLock(&Bcb->BcbLock, oldirql);
}
-PCC1_CCB Cc1InitializeFileCache(PFILE_OBJECT FileObject)
-/*
- * FUNCTION: Initialize caching for a file
- */
+NTSTATUS CcInitializeFileCache(PFILE_OBJECT FileObject,
+ PBCB* Bcb)
{
- PCC1_CCB CacheDesc;
-
- CacheDesc = ExAllocatePool(NonPagedPool, sizeof(CC1_CCB));
- if (CacheDesc == NULL)
+ (*Bcb) = ExAllocatePool(NonPagedPool, sizeof(BCB));
+ if ((*Bcb) == NULL)
{
- return(NULL);
+ return(STATUS_OUT_OF_MEMORY);
}
- CacheDesc->Type = CC1_CCB_ID;
- InitializeListHead(&CacheDesc->CacheSegmentListHead);
- KeInitializeSpinLock(&CacheDesc->CacheSegmentListLock);
+ (*Bcb)->FileObject = FileObject;
+ InitializeListHead(&(*Bcb)->CacheSegmentListHead);
+ KeInitializeSpinLock(&(*Bcb)->BcbLock);
- return(CacheDesc);
+ return(STATUS_SUCCESS);
}
+
+
+
KeyInformationLength);
}
-NTSTATUS
-STDCALL
-ZwSetInformationKey(
- IN HANDLE KeyHandle,
- IN CINT KeyInformationClass,
- IN PVOID KeyInformation,
- IN ULONG KeyInformationLength
- )
+NTSTATUS STDCALL ZwSetInformationKey(IN HANDLE KeyHandle,
+ IN CINT KeyInformationClass,
+ IN PVOID KeyInformation,
+ IN ULONG KeyInformationLength)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtUnloadKey(
- HANDLE KeyHandle
- )
+NTSTATUS STDCALL NtUnloadKey(HANDLE KeyHandle)
{
return ZwUnloadKey(KeyHandle);
}
-NTSTATUS
-STDCALL
-ZwUnloadKey(
- HANDLE KeyHandle
- )
+NTSTATUS STDCALL ZwUnloadKey(HANDLE KeyHandle)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
}
-NTSTATUS STDCALL
-NtInitializeRegistry(BOOLEAN SetUpBoot)
+NTSTATUS STDCALL NtInitializeRegistry(BOOLEAN SetUpBoot)
{
return ZwInitializeRegistry(SetUpBoot);
}
-NTSTATUS STDCALL
-ZwInitializeRegistry(BOOLEAN SetUpBoot)
+NTSTATUS STDCALL ZwInitializeRegistry(BOOLEAN SetUpBoot)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
}
NTSTATUS RtlCheckRegistryKey(ULONG RelativeTo, PWSTR Path)
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: ntoskrnl/ke/bug.c
- * PURPOSE: Graceful system shutdown if a bug is detected
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * FILE: ntoskrnl/ex/power.c
+ * PURPOSE: Power managment
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
+ * Added reboot support 30/01/99
*/
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
+#include <internal/hal/io.h>
#include <internal/debug.h>
return(ZwShutdownSystem(Action));
}
+static void kb_wait(void)
+{
+ int i;
+
+ for (i=0; i<10000; i++)
+ {
+ if ((inb_p(0x64) & 0x02) == 0)
+ {
+ return;
+ }
+ }
+}
+
NTSTATUS STDCALL ZwShutdownSystem(IN SHUTDOWN_ACTION Action)
+/*
+ * FIXME: Does a reboot only
+ */
{
- UNIMPLEMENTED;
+ int i, j;
+
+ for (;;)
+ {
+ for (i=0; i<100; i++)
+ {
+ kb_wait();
+ for (j=0; j<500; j++);
+ outb(0xfe, 0x64);
+ for (j=0; j<500; j++);
+ }
+ }
}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: mkernel/hal/eisa.c
- * PURPOSE: Interfaces to the PCI bus
+ * FILE: ntoskrnl/hal/pci
+ * PURPOSE: Interfaces to BIOS32 interface
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
* 05/06/98: Created
/* INCLUDES ***************************************************************/
-#include <windows.h>
#include <ddk/ntddk.h>
#include <internal/mm.h>
#include <internal/string.h>
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: mkernel/hal/x86/halinit.c
+ * FILE: ntoskrnl/hal/x86/halinit.c
* PURPOSE: Initalize the uniprocessor, x86 hal
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: mkernel/hal/eisa.c
+ * FILE: ntoskrnl/hal/isa.c
* PURPOSE: Interfaces to the ISA bus
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: kernel/hal/x86/mbr.c
+ * FILE: ntoskrnl/hal/x86/mbr.c
* PURPOSE: Functions for reading the master boot record (MBR)
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: kernel/hal/x86/mp.c
+ * FILE: ntoskrnl/hal/x86/mp.c
* PURPOSE: Multiprocessor stubs
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: kernel/hal/x86/spinlock.c
+ * FILE: ntoskrnl/hal/x86/spinlock.c
* PURPOSE: Implements spinlocks
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* 3/6/98: Created
*/
/* INCLUDES ****************************************************************/
-#include <windows.h>
#include <ddk/ntddk.h>
#include <internal/debug.h>
if (Irp->AssociatedIrp.SystemBuffer==NULL)
{
IoFreeIrp(Irp);
- return(NULL);
+ return(STATUS_NOT_IMPLEMENTED);
}
/* FIXME: should copy buffer in on other ops */
if (MajorFunction == IRP_MJ_WRITE)
StackPtr->FileObject = NULL;
StackPtr->CompletionRoutine = NULL;
- IoPrepareIrpBuffer(Irp,
- DeviceObject,
- Buffer,
- Length,
- MajorFunction);
+ if (Buffer != NULL)
+ {
+ IoPrepareIrpBuffer(Irp,
+ DeviceObject,
+ Buffer,
+ Length,
+ MajorFunction);
+ }
if (MajorFunction == IRP_MJ_READ)
{
VOID IoReadWriteCompletion(PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PIO_STACK_LOCATION IoStack)
-{
+{
PFILE_OBJECT FileObject;
FileObject = IoStack->FileObject;
- DPRINT("FileObject %x\n",FileObject);
-
if (DeviceObject->Flags & DO_BUFFERED_IO)
{
if (IoStack->MajorFunction == IRP_MJ_READ)
{
PIO_STACK_LOCATION IoStack;
PDEVICE_OBJECT DeviceObject;
+ PFILE_OBJECT FileObject;
IoStack = IoGetCurrentIrpStackLocation(Irp);
{
KeSetEvent(Irp->UserEvent,PriorityBoost,FALSE);
}
+
+ FileObject = IoStack->FileObject;
+
+ if (FileObject != NULL && IoStack->MajorFunction != IRP_MJ_CLOSE)
+ {
+ ObDereferenceObject(FileObject);
+ }
IoFreeIrp(Irp);
}
EaLength));
}
+NTSTATUS IopCreateFile(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ POBJECT_ATTRIBUTES ObjectAttributes)
+{
+ PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)Parent;
+ PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
+ NTSTATUS Status;
+
+ DPRINT("IopCreateFile(ObjectBody %x, Parent %x, RemainingPath %w)\n",
+ ObjectBody,Parent,RemainingPath);
+
+ Status = ObReferenceObjectByPointer(DeviceObject,
+ STANDARD_RIGHTS_REQUIRED,
+ IoDeviceType,
+ UserMode);
+ if (Status != STATUS_SUCCESS)
+ {
+ CHECKPOINT;
+ return(Status);
+ }
+
+ DeviceObject = IoGetAttachedDevice(DeviceObject);
+
+ DPRINT("DeviceObject %x\n",DeviceObject);
+
+ if (RemainingPath == NULL)
+ {
+ FileObject->Flags = FileObject->Flags | FO_DIRECT_DEVICE_OPEN;
+ FileObject->FileName.Buffer = ExAllocatePool(NonPagedPool,
+ (ObjectAttributes->ObjectName->Length+1)*2);
+ FileObject->FileName.Length = ObjectAttributes->ObjectName->Length;
+ FileObject->FileName.MaximumLength =
+ ObjectAttributes->ObjectName->MaximumLength;
+ RtlCopyUnicodeString(&(FileObject->FileName),
+ ObjectAttributes->ObjectName);
+ }
+ else
+ {
+ if (DeviceObject->DeviceType != FILE_DEVICE_FILE_SYSTEM &&
+ DeviceObject->DeviceType != FILE_DEVICE_DISK)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+ if (!(DeviceObject->Vpb->Flags & VPB_MOUNTED))
+ {
+ Status = IoTryToMountStorageDevice(DeviceObject);
+ if (Status!=STATUS_SUCCESS)
+ {
+ return(Status);
+ }
+ DeviceObject = IoGetAttachedDevice(DeviceObject);
+ }
+ RtlInitUnicodeString(&(FileObject->FileName),wstrdup(RemainingPath));
+ }
+ DPRINT("FileObject->FileName.Buffer %w\n",FileObject->FileName.Buffer);
+ FileObject->DeviceObject=DeviceObject;
+ FileObject->Vpb=DeviceObject->Vpb;
+
+ return(STATUS_SUCCESS);
+}
+
NTSTATUS ZwCreateFile(PHANDLE FileHandle,
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes,
* RETURNS: Status
*/
{
- PVOID Object;
+ PFILE_OBJECT FileObject;
NTSTATUS Status;
PIRP Irp;
KEVENT Event;
- PDEVICE_OBJECT DeviceObject;
- PFILE_OBJECT FileObject;
PIO_STACK_LOCATION StackLoc;
- PWSTR Remainder;
DPRINT("ZwCreateFile(FileHandle %x, DesiredAccess %x, "
"ObjectAttributes %x ObjectAttributes->ObjectName->Buffer %w)\n",
*FileHandle=0;
- FileObject = ObGenericCreateObject(FileHandle,
- DesiredAccess,
- NULL,
- IoFileType);
- memset(FileObject,0,sizeof(FILE_OBJECT));
-
- Status = ObOpenObjectByName(ObjectAttributes,&Object,&Remainder);
-
- if (Status != STATUS_SUCCESS && Status != STATUS_FS_QUERY_REQUIRED)
+ FileObject = ObCreateObject(FileHandle,
+ DesiredAccess,
+ ObjectAttributes,
+ IoFileType);
+ if (FileObject == NULL)
{
- DPRINT("%s() = Failed to find object\n",__FUNCTION__);
- ObDereferenceObject(FileObject);
- ZwClose(*FileHandle);
- *FileHandle=0;
return(STATUS_UNSUCCESSFUL);
}
-
- DeviceObject = (PDEVICE_OBJECT)Object;
- DeviceObject = IoGetAttachedDevice(DeviceObject);
-
- if (Status == STATUS_SUCCESS)
- {
- CHECKPOINT;
- FileObject->Flags = FileObject->Flags | FO_DIRECT_DEVICE_OPEN;
- FileObject->FileName.Buffer = ExAllocatePool(NonPagedPool,
- (ObjectAttributes->ObjectName->Length+1)*2);
- FileObject->FileName.Length = ObjectAttributes->ObjectName->Length;
- FileObject->FileName.MaximumLength =
- ObjectAttributes->ObjectName->MaximumLength;
- RtlCopyUnicodeString(&(FileObject->FileName),
- ObjectAttributes->ObjectName);
- }
- else
- {
- CHECKPOINT;
- DPRINT("DeviceObject %x\n",DeviceObject);
- DPRINT("FileHandle %x\n",FileHandle);
- if (DeviceObject->DeviceType != FILE_DEVICE_FILE_SYSTEM &&
- DeviceObject->DeviceType != FILE_DEVICE_DISK)
- {
- ObDereferenceObject(FileObject);
- 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)
- {
- ObDereferenceObject(FileObject);
- ZwClose(*FileHandle);
- *FileHandle=0;
- return(Status);
- }
- DeviceObject = IoGetAttachedDevice(DeviceObject);
- }
- DPRINT("Remainder %x\n",Remainder);
- DPRINT("Remainder %w\n",Remainder);
- DPRINT("FileObject->FileName.Buffer %w\n",FileObject->FileName.Buffer);
- RtlInitUnicodeString(&(FileObject->FileName),wstrdup(Remainder));
- DPRINT("FileObject->FileName.Buffer %x %w\n",
- FileObject->FileName.Buffer,FileObject->FileName.Buffer);
- }
- CHECKPOINT;
- DPRINT("FileObject->FileName.Buffer %x\n",FileObject->FileName.Buffer);
-
if (CreateOptions & FILE_SYNCHRONOUS_IO_ALERT)
{
FileObject->Flags = FileObject->Flags | FO_ALERTABLE_IO;
{
FileObject->Flags = FileObject->Flags | FO_SYNCHRONOUS_IO;
}
-
- FileObject->DeviceObject=DeviceObject;
- FileObject->Vpb=DeviceObject->Vpb;
-
+
KeInitializeEvent(&Event,NotificationEvent,FALSE);
- DPRINT("DevObj StackSize %d\n", DeviceObject->StackSize);
- Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
+ Irp = IoAllocateIrp(FileObject->DeviceObject->StackSize, FALSE);
if (Irp==NULL)
{
- ObDereferenceObject(FileObject);
- ZwClose(*FileHandle);
- *FileHandle=0;
return(STATUS_UNSUCCESSFUL);
}
StackLoc->MinorFunction = 0;
StackLoc->Flags = 0;
StackLoc->Control = 0;
- StackLoc->DeviceObject = DeviceObject;
- StackLoc->FileObject=FileObject;
- StackLoc->Parameters.Create.Options=CreateOptions&FILE_VALID_OPTION_FLAGS;
- StackLoc->Parameters.Create.Options|=CreateDisposition<<24;
- Status = IoCallDriver(DeviceObject,Irp);
- if (Status==STATUS_PENDING)
+ StackLoc->DeviceObject = FileObject->DeviceObject;
+ StackLoc->FileObject = FileObject;
+ StackLoc->Parameters.Create.Options = CreateOptions&FILE_VALID_OPTION_FLAGS;
+ StackLoc->Parameters.Create.Options |= CreateDisposition<<24;
+
+ Status = IoCallDriver(FileObject->DeviceObject,Irp);
+ if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL);
Status = IoStatusBlock->Status;
}
- if (Status!=STATUS_SUCCESS)
+ if (!NT_SUCCESS(Status))
{
- DPRINT("FileObject->FileName.Buffer %x\n",FileObject->FileName.Buffer);
- ObDereferenceObject(FileObject);
ZwClose(*FileHandle);
- *FileHandle=0;
- return(Status);
+ (*FileHandle) = 0;
}
- DPRINT("*FileHandle %x\n",*FileHandle);
- ObDereferenceObject(FileObject);
-
+ DPRINT("Finished ZwCreateFile()\n");
return(Status);
-
}
NTSTATUS NtOpenFile(PHANDLE FileHandle,
UNIMPLEMENTED;
}
+NTSTATUS IopDefaultDispatchFunction(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
+{
+ Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
+ Irp->IoStatus.Information = 0;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return(STATUS_NOT_IMPLEMENTED);
+}
NTSTATUS InitializeLoadedDriver(PDRIVER_INITIALIZE entry)
/*
{
NTSTATUS ret;
PDRIVER_OBJECT DriverObject;
+ ULONG i;
/*
* Allocate memory for a driver object
DbgPrint("%s:%d\n",__FILE__,__LINE__);
return STATUS_INSUFFICIENT_RESOURCES;
}
- memset(DriverObject, '\0', sizeof(DRIVER_OBJECT));
- CHECKPOINT;
+ memset(DriverObject, 0, sizeof(DRIVER_OBJECT));
+
+ for (i=0; i<=IRP_MJ_MAXIMUM_FUNCTION; i++)
+ {
+ DriverObject->MajorFunction[i] = IopDefaultDispatchFunction;
+ }
/*
* Initalize the driver
UNIMPLEMENTED;
}
+NTSTATUS IopCreateDevice(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ POBJECT_ATTRIBUTES ObjectAttributes)
+{
+ PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ObjectBody;
+
+ DPRINT("IopCreateDevice(ObjectBody %x, Parent %x, RemainingPath %w)\n",
+ ObjectBody, Parent, RemainingPath);
+
+ if (RemainingPath != NULL && wcschr(RemainingPath+1, '\\') != NULL)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ if (Parent != NULL && RemainingPath != NULL)
+ {
+ ObAddEntryDirectory(Parent, ObjectBody, RemainingPath+1);
+ }
+ return(STATUS_SUCCESS);
+}
+
+
NTSTATUS IoCreateDevice(PDRIVER_OBJECT DriverObject,
ULONG DeviceExtensionSize,
PUNICODE_STRING DeviceName,
if (DeviceName!=NULL)
{
InitializeObjectAttributes(&dev_attr,DeviceName,0,NULL,NULL);
- dev = ObGenericCreateObject(&devh,0,&dev_attr,IoDeviceType);
+ dev = ObCreateObject(&devh,0,&dev_attr,IoDeviceType);
}
else
{
- dev = ObGenericCreateObject(&devh,0,NULL,IoDeviceType);
+ dev = ObCreateObject(&devh,0,NULL,IoDeviceType);
}
*DeviceObject=NULL;
}
Status = IoStatusBlock->Status;
}
- ObDereferenceObject(FileObject);
return(Status);
}
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/errlog.c
* PURPOSE: Error logging
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/* FUNCTIONS *****************************************************************/
-NTSTATUS
-NtQueryInformationFile(HANDLE FileHandle,
- PIO_STATUS_BLOCK IoStatusBlock,
- PVOID FileInformation,
- ULONG Length,
- FILE_INFORMATION_CLASS FileInformationClass)
+NTSTATUS NtQueryInformationFile(HANDLE FileHandle,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass)
{
return ZwQueryInformationFile(FileHandle,
IoStatusBlock,
FileInformationClass);
}
-NTSTATUS
-ZwQueryInformationFile(HANDLE FileHandle,
- PIO_STATUS_BLOCK IoStatusBlock,
- PVOID FileInformation,
- ULONG Length,
- FILE_INFORMATION_CLASS FileInformationClass)
+NTSTATUS ZwQueryInformationFile(HANDLE FileHandle,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass)
{
NTSTATUS Status;
PFILE_OBJECT FileObject;
return Status;
}
-NTSTATUS
-NtSetInformationFile(HANDLE FileHandle,
- PIO_STATUS_BLOCK IoStatusBlock,
- PVOID FileInformation,
- ULONG Length,
- FILE_INFORMATION_CLASS FileInformationClass)
+NTSTATUS NtSetInformationFile(HANDLE FileHandle,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass)
{
return ZwSetInformationFile(FileHandle,
IoStatusBlock,
FileInformationClass);
}
-NTSTATUS
-ZwSetInformationFile(HANDLE FileHandle,
- PIO_STATUS_BLOCK IoStatusBlock,
- PVOID FileInformation,
- ULONG Length,
- FILE_INFORMATION_CLASS FileInformationClass)
+NTSTATUS ZwSetInformationFile(HANDLE FileHandle,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass)
{
UNIMPLEMENTED;
}
-PGENERIC_MAPPING
-IoGetFileObjectGenericMapping(VOID)
+PGENERIC_MAPPING IoGetFileObjectGenericMapping(VOID)
{
UNIMPLEMENTED;
}
-NTSTATUS STDCALL
-NtQueryAttributesFile(IN HANDLE FileHandle,
- IN PVOID Buffer)
+NTSTATUS STDCALL NtQueryAttributesFile(IN HANDLE FileHandle,
+ IN PVOID Buffer)
{
return ZwQueryAttributesFile(FileHandle, Buffer);
}
-NTSTATUS STDCALL
-ZwQueryAttributesFile(IN HANDLE FileHandle, IN PVOID Buffer)
+NTSTATUS STDCALL ZwQueryAttributesFile(IN HANDLE FileHandle, IN PVOID Buffer)
{
UNIMPLEMENTED;
}
-NTSTATUS STDCALL
-NtQueryFullAttributesFile(IN HANDLE FileHandle, IN PVOID Attributes)
+NTSTATUS STDCALL NtQueryFullAttributesFile(IN HANDLE FileHandle,
+ IN PVOID Attributes)
{
return ZwQueryFullAttributesFile(FileHandle, Attributes);
}
-NTSTATUS STDCALL
-ZwQueryFullAttributesFile(IN HANDLE FileHandle, IN PVOID Attributes)
+NTSTATUS STDCALL ZwQueryFullAttributesFile(IN HANDLE FileHandle,
+ IN PVOID Attributes)
{
UNIMPLEMENTED;
}
-NTSTATUS STDCALL
-NtQueryEaFile(IN HANDLE FileHandle,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PVOID Buffer,
- IN ULONG Length,
- IN BOOLEAN ReturnSingleEntry,
- IN PVOID EaList OPTIONAL,
- IN ULONG EaListLength,
- IN PULONG EaIndex OPTIONAL,
- IN BOOLEAN RestartScan)
+NTSTATUS STDCALL NtQueryEaFile(IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG Length,
+ IN BOOLEAN ReturnSingleEntry,
+ IN PVOID EaList OPTIONAL,
+ IN ULONG EaListLength,
+ IN PULONG EaIndex OPTIONAL,
+ IN BOOLEAN RestartScan)
{
return NtQueryEaFile(FileHandle,
IoStatusBlock,
RestartScan);
}
-NTSTATUS STDCALL
-ZwQueryEaFile(IN HANDLE FileHandle,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PVOID Buffer,
- IN ULONG Length,
- IN BOOLEAN ReturnSingleEntry,
- IN PVOID EaList OPTIONAL,
- IN ULONG EaListLength,
- IN PULONG EaIndex OPTIONAL,
- IN BOOLEAN RestartScan)
+NTSTATUS STDCALL ZwQueryEaFile(IN HANDLE FileHandle,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG Length,
+ IN BOOLEAN ReturnSingleEntry,
+ IN PVOID EaList OPTIONAL,
+ IN ULONG EaListLength,
+ IN PULONG EaIndex OPTIONAL,
+ IN BOOLEAN RestartScan)
{
UNIMPLEMENTED;
}
-NTSTATUS STDCALL
-NtSetEaFile(IN HANDLE FileHandle,
- IN PIO_STATUS_BLOCK IoStatusBlock,
- PVOID EaBuffer,
- ULONG EaBufferSize)
+NTSTATUS STDCALL NtSetEaFile(IN HANDLE FileHandle,
+ IN PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID EaBuffer,
+ ULONG EaBufferSize)
{
return ZwSetEaFile(FileHandle,
IoStatusBlock,
EaBufferSize);
}
-NTSTATUS STDCALL
-ZwSetEaFile(IN HANDLE FileHandle,
- IN PIO_STATUS_BLOCK IoStatusBlock,
- PVOID EaBuffer,
- ULONG EaBufferSize)
+NTSTATUS STDCALL ZwSetEaFile(IN HANDLE FileHandle,
+ IN PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID EaBuffer,
+ ULONG EaBufferSize)
{
UNIMPLEMENTED;
}
* the flush buffers operation. The information field is
* set to number of bytes flushed to disk.
* RETURNS: Status
- * REMARKS: This funciton maps to the win32 FlushFileBuffers
+ * REMARKS: This function maps to the win32 FlushFileBuffers
*/
{
PFILE_OBJECT FileObject = NULL;
POBJECT_TYPE IoDeviceType = NULL;
POBJECT_TYPE IoFileType = NULL;
-
/* FUNCTIONS ****************************************************************/
-VOID IopCloseFile(PVOID ObjectBody)
+VOID IopCloseFile(PVOID ObjectBody, ULONG HandleCount)
{
PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
-
+ PIRP Irp;
+ PIO_STACK_LOCATION StackPtr;
+ NTSTATUS Status;
+
+ if (HandleCount > 0)
+ {
+ return;
+ }
+
+ ObReferenceObjectByPointer(FileObject,
+ STANDARD_RIGHTS_REQUIRED,
+ IoFileType,
+ UserMode);
+
+ Irp = IoBuildSynchronousFsdRequest(IRP_MJ_CLEANUP,
+ FileObject->DeviceObject,
+ NULL,
+ 0,
+ NULL,
+ NULL,
+ NULL);
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->FileObject = FileObject;
+
+ Status = IoCallDriver(FileObject->DeviceObject, Irp);
+}
+
+VOID IopDeleteFile(PVOID ObjectBody)
+{
+ PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
+ PIRP Irp;
+ PIO_STACK_LOCATION StackPtr;
+ NTSTATUS Status;
+
+ ObReferenceObjectByPointer(ObjectBody,
+ STANDARD_RIGHTS_REQUIRED,
+ IoFileType,
+ UserMode);
+
+ Irp = IoBuildSynchronousFsdRequest(IRP_MJ_CLOSE,
+ FileObject->DeviceObject,
+ NULL,
+ 0,
+ NULL,
+ NULL,
+ NULL);
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->FileObject = FileObject;
+
+ Status = IoCallDriver(FileObject->DeviceObject, Irp);
+
if (FileObject->FileName.Buffer != NULL)
{
ExFreePool(FileObject->FileName.Buffer);
IoDeviceType->Security = NULL;
IoDeviceType->QueryName = NULL;
IoDeviceType->OkayToClose = NULL;
+ IoDeviceType->Create = IopCreateDevice;
RtlInitAnsiString(&AnsiString,"Device");
RtlAnsiStringToUnicodeString(&IoDeviceType->TypeName,&AnsiString,TRUE);
IoFileType->Dump = NULL;
IoFileType->Open = NULL;
IoFileType->Close = IopCloseFile;
- IoFileType->Delete = NULL;
+ IoFileType->Delete = IopDeleteFile;
IoFileType->Parse = NULL;
IoFileType->Security = NULL;
IoFileType->QueryName = NULL;
IoFileType->OkayToClose = NULL;
+ IoFileType->Create = IopCreateFile;
RtlInitAnsiString(&AnsiString,"File");
RtlAnsiStringToUnicodeString(&IoFileType->TypeName,&AnsiString,TRUE);
* RETURNS: A pointer to the stack location
*/
{
- DPRINT("IoGetNextIrpStackLocation: Irp %08lx CurLoc %d StkCnt %d\n",
- Irp,
- Irp->CurrentLocation,
- Irp->StackCount);
+ DPRINT("IoGetNextIrpStackLocation(Irp %x)\n",Irp);
assert(Irp!=NULL);
DPRINT("Irp %x Irp->StackPtr %x\n",Irp,Irp->CurrentLocation);
*/
{
NTSTATUS Status;
- PDRIVER_OBJECT DriverObject = DeviceObject->DriverObject;
- PIO_STACK_LOCATION param = IoGetNextIrpStackLocation(Irp);
-
+ PDRIVER_OBJECT DriverObject;
+ PIO_STACK_LOCATION param;
+
+ DPRINT("IoCallDriver(DeviceObject %x, Irp %x)\n",DeviceObject,Irp);
+
+ DriverObject = DeviceObject->DriverObject;
+ param = IoGetNextIrpStackLocation(Irp);
+
Irp->Tail.Overlay.CurrentStackLocation--;
Irp->CurrentLocation--;
-
+
+ DPRINT("DriverObject->MajorFunction[param->MajorFunction] %x\n",
+ DriverObject->MajorFunction[param->MajorFunction]);
Status = DriverObject->MajorFunction[param->MajorFunction](DeviceObject,
Irp);
return Status;
DPRINT("IoPageRead(FileObject %x, Address %x)\n",
FileObject,Address);
-
+
+ ObReferenceObjectByPointer(FileObject,
+ STANDARD_RIGHTS_REQUIRED,
+ IoFileType,
+ UserMode);
+
KeInitializeEvent(&Event,NotificationEvent,FALSE);
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
FileObject->DeviceObject,
KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL);
return(IoStatusBlock->Status);
}
- ObDereferenceObject(FileObject);
return(Status);
}
KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL);
Status = Irp->IoStatus.Status;
}
- ObDereferenceObject(FileObject);
-
return(Status);
}
/* FUNCTIONS *****************************************************************/
+NTSTATUS IopCreateSymbolicLink(PVOID Object,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ POBJECT_ATTRIBUTES ObjectAttributes)
+{
+ if (Parent != NULL && RemainingPath != NULL)
+ {
+ ObAddEntryDirectory(Parent, Object, RemainingPath+1);
+ }
+ return(STATUS_SUCCESS);
+}
+
+PVOID IopParseSymbolicLink(PVOID Object,
+ PWSTR* RemainingPath)
+{
+ NTSTATUS Status;
+ PSYMLNK_OBJECT SymlinkObject = (PSYMLNK_OBJECT)Object;
+ PVOID ReturnedObject;
+
+ Status = ObReferenceObjectByName(SymlinkObject->Target.ObjectName,
+ 0,
+ NULL,
+ STANDARD_RIGHTS_REQUIRED,
+ NULL,
+ UserMode,
+ NULL,
+ &ReturnedObject);
+ if (NT_SUCCESS(Status))
+ {
+ return(ReturnedObject);
+ }
+ return(NULL);
+}
+
VOID IoInitSymbolicLinkImplementation(VOID)
{
ANSI_STRING AnsiString;
IoSymbolicLinkType->Open = NULL;
IoSymbolicLinkType->Close = NULL;
IoSymbolicLinkType->Delete = NULL;
- IoSymbolicLinkType->Parse = NULL;
+ IoSymbolicLinkType->Parse = IopParseSymbolicLink;
IoSymbolicLinkType->Security = NULL;
IoSymbolicLinkType->QueryName = NULL;
IoSymbolicLinkType->OkayToClose = NULL;
+ IoSymbolicLinkType->Create = IopCreateSymbolicLink;
RtlInitAnsiString(&AnsiString,"Symbolic Link");
RtlAnsiStringToUnicodeString(&IoSymbolicLinkType->TypeName,
{
NTSTATUS Status;
PVOID Object;
- PWSTR Ignored;
- Status = ObOpenObjectByName(ObjectAttributes,&Object,&Ignored);
+ Status = ObReferenceObjectByName(ObjectAttributes->ObjectName,
+ ObjectAttributes->Attributes,
+ NULL,
+ DesiredAccess,
+ NULL,
+ UserMode,
+ NULL,
+ &Object);
if (!NT_SUCCESS(Status))
{
return(Status);
return(STATUS_SUCCESS);
}
-
-POBJECT IoOpenSymlink(POBJECT _Symlink)
-{
- PVOID Result;
- PSYMLNK_OBJECT Symlink = (PSYMLNK_OBJECT)_Symlink;
- PWSTR Ignored;
-
- DPRINT("IoOpenSymlink(_Symlink %x)\n",Symlink);
-
- DPRINT("Target %w\n",Symlink->Target.ObjectName->Buffer);
-
- ObOpenObjectByName(&(Symlink->Target),&Result,&Ignored);
- return(Result);
-}
-
NTSTATUS IoCreateUnprotectedSymbolicLink(PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName)
{
SymbolicLinkName->Buffer,DeviceName->Buffer);
InitializeObjectAttributes(&ObjectAttributes,SymbolicLinkName,0,NULL,NULL);
- SymbolicLink = ObGenericCreateObject(&SymbolicLinkHandle,
- SYMBOLIC_LINK_ALL_ACCESS,
- &ObjectAttributes,
- IoSymbolicLinkType);
+ SymbolicLink = ObCreateObject(&SymbolicLinkHandle,
+ SYMBOLIC_LINK_ALL_ACCESS,
+ &ObjectAttributes,
+ IoSymbolicLinkType);
if (SymbolicLink == NULL)
{
return(STATUS_UNSUCCESSFUL);
SymbolicLink->TargetName.MaximumLength =
((wstrlen(DeviceName->Buffer) + 1) * sizeof(WCHAR));
SymbolicLink->TargetName.Buffer = ExAllocatePool(NonPagedPool,
- SymbolicLink->TargetName.MaximumLength);
+ SymbolicLink->TargetName.MaximumLength);
RtlCopyUnicodeString(&(SymbolicLink->TargetName), DeviceName);
DPRINT("DeviceName %w\n", SymbolicLink->TargetName.Buffer);
InitializeObjectAttributes(&(SymbolicLink->Target),
VOID ExRaiseStatus(NTSTATUS Status)
{
- DbgPrint("ExRaiseStatus(%d)\n",Status);
+ DbgPrint("ExRaiseStatus(%x)\n",Status);
for(;;);
}
KeInit();
ObInit();
PsInit();
- IoInit();
+ IoInit();
LdrInitModuleManagement();
/*
LdrProcessDriver(start);
start=start+PAGE_ROUND_UP(bp.module_length[i]);
}
-
+
/*
* Load Auto configured drivers
*/
/* INCLUDES *****************************************************************/
#include <internal/i386/segment.h>
-#include <internal/kernel.h>
+#include <internal/ntoskrnl.h>
#include <internal/linkage.h>
#include <internal/module.h>
#include <internal/ob.h>
}
/* Build a module structure for the image */
- Module = ObGenericCreateObject(ModuleHandle,
- PROCESS_ALL_ACCESS,
- NULL,
- ObModuleType);
+ Module = ObCreateObject(ModuleHandle,
+ PROCESS_ALL_ACCESS,
+ NULL,
+ ObModuleType);
if (Module == NULL)
{
ZwClose(FileHandle);
NT_OBJECTS = nt/port.o nt/channel.o nt/ntevent.o nt/nttimer.o nt/atom.o \
nt/evtpair.o nt/ntsem.o nt/mutant.o nt/misc.o nt/plugplay.o \
- nt/profile.o
+ nt/profile.o nt/nt.o
RTL_OBJECTS = rtl/vsprintf.o rtl/lookas.o rtl/unicode.o rtl/strtok.o \
rtl/time.o rtl/unalign.o rtl/mem.o rtl/largeint.o rtl/ctype.o \
io/fs.o io/vpb.o io/buildirp.o io/flush.o io/dir.o io/iocomp.o \
io/mailslot.o io/npipe.o io/lock.o io/page.o io/cleanup.o
-OB_OBJECTS = ob/object.o ob/handle.o ob/namespc.o
+OB_OBJECTS = ob/object.o ob/handle.o ob/namespc.o ob/ntobj.o ob/dirobj.o
PS_OBJECTS = ps/psmgr.o ps/thread.o ps/process.o ps/idle.o ps/kill.o \
ps/tinfo.o
CM_OBJECTS = cm/registry.o
-TST_OBJECTS = tst/test.o tst/sshell.o tst/readline.o
+TST_OBJECTS = tst/test.o
DBG_OBJECTS = dbg/brkpoint.o dbg/errinfo.o
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: kernel/mm/cont.c
+ * FILE: ntoskrnl/mm/cont.c
* PURPOSE: Manages continuous memory
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/* INCLUDES *****************************************************************/
-#include <internal/kernel.h>
-#include <internal/linkage.h>
#include <ddk/ntddk.h>
#include <internal/debug.h>
*/
if (marea==NULL )
{
- printk("Area is invalid\n");
+ DbgPrint("(%s:%d) Area is invalid\n",__FILE__,__LINE__);
ExRaiseStatus(STATUS_INVALID_PARAMETER);
}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: kernel/mm/cont.c
+ * FILE: ntoskrnl/mm/cont.c
* PURPOSE: Manages non-cached memory
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
/* INCLUDES *****************************************************************/
-#include <internal/kernel.h>
-#include <internal/linkage.h>
#include <ddk/ntddk.h>
#include <internal/debug.h>
/* FUNCTIONS *****************************************************************/
+VOID MmpDeleteSection(PVOID ObjectBody)
+{
+}
+
+NTSTATUS MmpCreateSection(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath)
+{
+ PDEVICE_OBJECT DeviceObject = (PDEVICE_OBJECT)ObjectBody;
+ NTSTATUS Status;
+
+ DPRINT("MmpCreateDevice(ObjectBody %x, Parent %x, RemainingPath %w)\n",
+ ObjectBody, Parent, RemainingPath);
+
+ if (RemainingPath == NULL)
+ {
+ return(STATUS_SUCCESS);
+ }
+
+ if (wcschr(RemainingPath+1, '\\') != NULL)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ Status = ObReferenceObjectByPointer(Parent,
+ STANDARD_RIGHTS_REQUIRED,
+ ObDirectoryType,
+ UserMode);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ ObAddEntryDirectory(Parent, ObjectBody, RemainingPath+1);
+
+ return(STATUS_SUCCESS);
+}
+
NTSTATUS MmInitSectionImplementation(VOID)
{
ANSI_STRING AnsiString;
MmSectionType->Dump = NULL;
MmSectionType->Open = NULL;
MmSectionType->Close = NULL;
- MmSectionType->Delete = NULL;
+ MmSectionType->Delete = MmpDeleteSection;
MmSectionType->Parse = NULL;
MmSectionType->Security = NULL;
MmSectionType->QueryName = NULL;
MmSectionType->OkayToClose = NULL;
+ MmSectionType->Create = MmpCreateSection;
RtlInitAnsiString(&AnsiString,"Section");
RtlAnsiStringToUnicodeString(&MmSectionType->TypeName,
DbgPrint("ZwCreateSection()\n");
- Section = ObGenericCreateObject(SectionHandle,
- DesiredAccess,
- ObjectAttributes,
- MmSectionType);
+ Section = ObCreateObject(SectionHandle,
+ DesiredAccess,
+ ObjectAttributes,
+ MmSectionType);
if (MaximumSize != NULL)
{
LARGE_INTEGER_QUAD_PART(Section->MaximumSize) = 0xffffffff;
}
Section->SectionPageProtection = SectionPageProtection;
- Status = ObReferenceObjectByHandle(FileHandle,
- FILE_READ_DATA,
- IoFileType,
- UserMode,
- (PVOID*)&Section->FileObject,
- NULL);
- if (Status != STATUS_SUCCESS)
+ Section->AllocateAttributes = AllocationAttributes;
+
+ if (FileHandle != NULL)
{
- DPRINT("ZwCreateSection() = %x\n",Status);
- return(Status);
+ Status = ObReferenceObjectByHandle(FileHandle,
+ FILE_READ_DATA,
+ IoFileType,
+ UserMode,
+ (PVOID*)&Section->FileObject,
+ NULL);
+ if (Status != STATUS_SUCCESS)
+ {
+ DPRINT("ZwCreateSection() = %x\n",Status);
+ return(Status);
+ }
+ }
+ else
+ {
+ Section->FileObject = NULL;
}
-
- Section->AllocateAttributes = AllocationAttributes;
DPRINT("ZwCreateSection() = STATUS_SUCCESS\n");
return(STATUS_SUCCESS);
{
PVOID Object;
NTSTATUS Status;
- PWSTR Ignored;
*SectionHandle = 0;
-
- Status = ObOpenObjectByName(ObjectAttributes,&Object,&Ignored);
+
+ Status = ObReferenceObjectByName(ObjectAttributes->ObjectName,
+ ObjectAttributes->Attributes,
+ NULL,
+ DesiredAccess,
+ MmSectionType,
+ UserMode,
+ NULL,
+ &Object);
if (!NT_SUCCESS(Status))
{
return(Status);
}
- if (BODY_TO_HEADER(Object)->ObjectType!=MmSectionType)
- {
- return(STATUS_UNSUCCESSFUL);
- }
-
- *SectionHandle = ObInsertHandle(KeGetCurrentProcess(),Object,
- DesiredAccess,FALSE);
+ *SectionHandle = ObInsertHandle(KeGetCurrentProcess(),
+ Object,
+ DesiredAccess,
+ FALSE);
return(STATUS_SUCCESS);
}
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: ntoskrnl/nt/nt.c
+ * PURPOSE: Initialization of system call interfaces
+ * PROGRAMMER: David Welch (welch@mcmail.com)
+ * UPDATE HISTORY:
+ * Created 22/05/98
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ddk/ntddk.h>
+
+#include <internal/debug.h>
+
+/* FUNCTIONS *****************************************************************/
+
+VOID NtInit(VOID)
+{
+ NtInitializeEventImplementation();
+}
{
PKEVENT Event;
- Event = ObGenericCreateObject(EventHandle,
- DesiredAccess,
- ObjectAttributes,
- ExEventType);
+ Event = ObCreateObject(EventHandle,
+ DesiredAccess,
+ ObjectAttributes,
+ ExEventType);
if (ManualReset == TRUE)
{
KeInitializeEvent(Event,NotificationEvent,InitialState);
{
NTSTATUS Status;
PKEVENT Event;
- PWSTR Ignored;
+
- Status = ObOpenObjectByName(ObjectAttributes,(PVOID*)Event,&Ignored);
+ Status = ObReferenceObjectByName(ObjectAttributes->ObjectName,
+ ObjectAttributes->Attributes,
+ NULL,
+ DesiredAccess,
+ ExEventType,
+ UserMode,
+ NULL,
+ (PVOID*)&Event);
if (Status != STATUS_SUCCESS)
{
return(Status);
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/nt/port.c
* PURPOSE: Communication mechanism (like Mach?)
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* Created 22/05/98
*/
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: ntoskrnl/ob/dirobj.c
+ * PURPOSE: Interface functions to directory object
+ * PROGRAMMER: David Welch (welch@mcmail.com)
+ * UPDATE HISTORY:
+ * 22/05/98: Created
+ */
+
+/* INCLUDES ***************************************************************/
+
+#include <windows.h>
+#include <wstring.h>
+#include <ddk/ntddk.h>
+#include <internal/ob.h>
+#include <internal/io.h>
+#include <internal/string.h>
+
+#define NDEBUG
+#include <internal/debug.h>
+
+
+/* FUNCTIONS **************************************************************/
+
+NTSTATUS NtOpenDirectoryObject(PHANDLE DirectoryHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes)
+{
+ return(ZwOpenDirectoryObject(DirectoryHandle,
+ DesiredAccess,
+ ObjectAttributes));
+}
+
+NTSTATUS ZwOpenDirectoryObject(PHANDLE DirectoryHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes)
+/*
+ * FUNCTION: Opens a namespace directory object
+ * ARGUMENTS:
+ * DirectoryHandle (OUT) = Variable which receives the directory handle
+ * DesiredAccess = Desired access to the directory
+ * ObjectAttributes = Structure describing the directory
+ * RETURNS: Status
+ * NOTES: Undocumented
+ */
+{
+ PVOID Object;
+ NTSTATUS Status;
+
+ *DirectoryHandle = 0;
+
+ Status = ObReferenceObjectByName(ObjectAttributes->ObjectName,
+ ObjectAttributes->Attributes,
+ NULL,
+ DesiredAccess,
+ ObDirectoryType,
+ UserMode,
+ NULL,
+ &Object);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ *DirectoryHandle = ObInsertHandle(KeGetCurrentProcess(),Object,
+ DesiredAccess,FALSE);
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS NtQueryDirectoryObject(IN HANDLE DirObjHandle,
+ OUT POBJDIR_INFORMATION DirObjInformation,
+ IN ULONG BufferLength,
+ IN BOOLEAN GetNextIndex,
+ IN BOOLEAN IgnoreInputIndex,
+ IN OUT PULONG ObjectIndex,
+ OUT PULONG DataWritten OPTIONAL)
+{
+ return(ZwQueryDirectoryObject(DirObjHandle,
+ DirObjInformation,
+ BufferLength,
+ GetNextIndex,
+ IgnoreInputIndex,
+ ObjectIndex,
+ DataWritten));
+}
+
+NTSTATUS ZwQueryDirectoryObject(IN HANDLE DirObjHandle,
+ OUT POBJDIR_INFORMATION DirObjInformation,
+ IN ULONG BufferLength,
+ IN BOOLEAN GetNextIndex,
+ IN BOOLEAN IgnoreInputIndex,
+ IN OUT PULONG ObjectIndex,
+ OUT PULONG DataWritten OPTIONAL)
+/*
+ * FUNCTION: Reads information from a namespace directory
+ * ARGUMENTS:
+ * DirObjInformation (OUT) = Buffer to hold the data read
+ * BufferLength = Size of the buffer in bytes
+ * GetNextIndex = If TRUE then set ObjectIndex to the index of the
+ * next object
+ * If FALSE then set ObjectIndex to the number of
+ * objects in the directory
+ * IgnoreInputIndex = If TRUE start reading at index 0
+ * If FALSE start reading at the index specified
+ * by object index
+ * ObjectIndex = Zero based index into the directory, interpretation
+ * depends on IgnoreInputIndex and GetNextIndex
+ * DataWritten (OUT) = Caller supplied storage for the number of bytes
+ * written (or NULL)
+ * RETURNS: Status
+ */
+{
+ PDIRECTORY_OBJECT dir = NULL;
+ ULONG EntriesToRead;
+ PLIST_ENTRY current_entry;
+ POBJECT_HEADER current;
+ ULONG i=0;
+ ULONG EntriesToSkip;
+ NTSTATUS Status;
+
+ DPRINT("ZwQueryDirectoryObject(DirObjHandle %x)\n",DirObjHandle);
+ DPRINT("dir %x namespc_root %x\n",dir,HEADER_TO_BODY(&(namespc_root.hdr)));
+
+// assert_irql(PASSIVE_LEVEL);
+
+ Status = ObReferenceObjectByHandle(DirObjHandle,
+ DIRECTORY_QUERY,
+ ObDirectoryType,
+ UserMode,
+ (PVOID*)&dir,
+ NULL);
+ if (Status != STATUS_SUCCESS)
+ {
+ return(Status);
+ }
+
+ EntriesToRead = BufferLength / sizeof(OBJDIR_INFORMATION);
+ *DataWritten = 0;
+
+ DPRINT("EntriesToRead %d\n",EntriesToRead);
+
+ current_entry = dir->head.Flink;
+
+ /*
+ * Optionally, skip over some entries at the start of the directory
+ */
+ if (!IgnoreInputIndex)
+ {
+ CHECKPOINT;
+
+ EntriesToSkip = *ObjectIndex;
+ while ( i<EntriesToSkip && current_entry!=NULL)
+ {
+ current_entry = current_entry->Flink;
+ }
+ }
+
+ DPRINT("DirObjInformation %x\n",DirObjInformation);
+
+ /*
+ * Read the maximum entries possible into the buffer
+ */
+ while ( i<EntriesToRead && current_entry!=(&(dir->head)))
+ {
+ current = CONTAINING_RECORD(current_entry,OBJECT_HEADER,Entry);
+ DPRINT("Scanning %w\n",current->Name.Buffer);
+ DirObjInformation[i].ObjectName.Buffer =
+ ExAllocatePool(NonPagedPool,(current->Name.Length+1)*2);
+ DirObjInformation[i].ObjectName.Length = current->Name.Length;
+ DirObjInformation[i].ObjectName.MaximumLength = current->Name.Length;
+ DPRINT("DirObjInformation[i].ObjectName.Buffer %x\n",
+ DirObjInformation[i].ObjectName.Buffer);
+ RtlCopyUnicodeString(&DirObjInformation[i].ObjectName,
+ &(current->Name));
+ i++;
+ current_entry = current_entry->Flink;
+ (*DataWritten) = (*DataWritten) + sizeof(OBJDIR_INFORMATION);
+ CHECKPOINT;
+ }
+ CHECKPOINT;
+
+ /*
+ * Optionally, count the number of entries in the directory
+ */
+ if (GetNextIndex)
+ {
+ *ObjectIndex=i;
+ }
+ else
+ {
+ while ( current_entry!=(&(dir->head)) )
+ {
+ current_entry=current_entry->Flink;
+ i++;
+ }
+ *ObjectIndex=i;
+ }
+ return(STATUS_SUCCESS);
+}
+
+
+NTSTATUS NtCreateDirectoryObject(PHANDLE DirectoryHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes)
+{
+ return(ZwCreateDirectoryObject(DirectoryHandle,
+ DesiredAccess,
+ ObjectAttributes));
+}
+
+NTSTATUS ZwCreateDirectoryObject(PHANDLE DirectoryHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes)
+/*
+ * FUNCTION: Creates or opens a directory object (a container for other
+ * objects)
+ * ARGUMENTS:
+ * DirectoryHandle (OUT) = Caller supplied storage for the handle
+ * of the directory
+ * DesiredAccess = Access desired to the directory
+ * ObjectAttributes = Object attributes initialized with
+ * InitializeObjectAttributes
+ * RETURNS: Status
+ */
+{
+ PDIRECTORY_OBJECT dir;
+
+ dir = ObCreateObject(DirectoryHandle,
+ DesiredAccess,
+ ObjectAttributes,
+ ObDirectoryType);
+ return(STATUS_SUCCESS);
+}
+
+VOID InitializeObjectAttributes(POBJECT_ATTRIBUTES InitializedAttributes,
+ PUNICODE_STRING ObjectName,
+ ULONG Attributes,
+ HANDLE RootDirectory,
+ PSECURITY_DESCRIPTOR SecurityDescriptor)
+/*
+ * FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a
+ * subsequent call to ZwCreateXXX or ZwOpenXXX
+ * ARGUMENTS:
+ * InitializedAttributes (OUT) = Caller supplied storage for the
+ * object attributes
+ * ObjectName = Full path name for object
+ * Attributes = Attributes for the object
+ * RootDirectory = Where the object should be placed or NULL
+ * SecurityDescriptor = Ignored
+ *
+ * NOTE:
+ * Either ObjectName is a fully qualified pathname or a path relative
+ * to RootDirectory
+ */
+{
+ DPRINT("InitializeObjectAttributes(InitializedAttributes %x "
+ "ObjectName %x Attributes %x RootDirectory %x)\n",
+ InitializedAttributes,ObjectName,Attributes,RootDirectory);
+ InitializedAttributes->Length=sizeof(OBJECT_ATTRIBUTES);
+ InitializedAttributes->RootDirectory=RootDirectory;
+ InitializedAttributes->ObjectName=ObjectName;
+ InitializedAttributes->Attributes=Attributes;
+ InitializedAttributes->SecurityDescriptor=SecurityDescriptor;
+ InitializedAttributes->SecurityQualityOfService=NULL;
+}
+
DPRINT("Finished ObDeleteHandle()\n");
}
-HANDLE ObInsertHandle(PKPROCESS Process, PVOID ObjectBody,
- ACCESS_MASK GrantedAccess, BOOLEAN Inherit)
+HANDLE ObInsertHandle(PKPROCESS Process,
+ PVOID ObjectBody,
+ ACCESS_MASK GrantedAccess,
+ BOOLEAN Inherit)
/*
* FUNCTION: Add a handle referencing an object
* ARGUMENTS:
POBJECT_TYPE ObDirectoryType = NULL;
-static struct
-{
- OBJECT_HEADER hdr;
-// DIRECTORY_OBJECT directory;
- LIST_ENTRY head;
- KSPIN_LOCK Lock;
-} namespc_root = {{0,},};
+PDIRECTORY_OBJECT NameSpaceRoot = NULL;
/* FUNCTIONS **************************************************************/
-NTSTATUS NtOpenDirectoryObject(PHANDLE DirectoryHandle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes)
+NTSTATUS ObReferenceObjectByName(PUNICODE_STRING ObjectPath,
+ ULONG Attributes,
+ PACCESS_STATE PassedAccessState,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_TYPE ObjectType,
+ KPROCESSOR_MODE AccessMode,
+ PVOID ParseContext,
+ PVOID* ObjectPtr)
{
- return(ZwOpenDirectoryObject(DirectoryHandle,
- DesiredAccess,
- ObjectAttributes));
+ PVOID Object;
+ PWSTR RemainingPath;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+
+ InitializeObjectAttributes(&ObjectAttributes,
+ ObjectPath,
+ 0,
+ NULL,
+ NULL);
+ ObFindObject(&ObjectAttributes,
+ &Object,
+ &RemainingPath);
+
+ if (RemainingPath != NULL ||
+ Object == NULL)
+ {
+ *ObjectPtr = NULL;
+ return(STATUS_UNSUCCESSFUL);
+ }
+ *ObjectPtr = Object;
+ return(STATUS_SUCCESS);
}
-NTSTATUS ZwOpenDirectoryObject(PHANDLE DirectoryHandle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes)
+VOID ObAddEntryDirectory(PDIRECTORY_OBJECT Parent,
+ POBJECT Object,
+ PWSTR Name)
/*
- * FUNCTION: Opens a namespace directory object
+ * FUNCTION: Add an entry to a namespace directory
* ARGUMENTS:
- * DirectoryHandle (OUT) = Variable which receives the directory handle
- * DesiredAccess = Desired access to the directory
- * ObjectAttributes = Structure describing the directory
- * RETURNS: Status
- * NOTES: Undocumented
+ * parent = directory to add in
+ * name = Name to give the entry
+ * Object = Header of the object to add the entry for
*/
{
- PVOID Object;
- NTSTATUS Status;
- PWSTR Ignored;
+ KIRQL oldlvl;
+ POBJECT_HEADER Header = BODY_TO_HEADER(Object);
- *DirectoryHandle = 0;
+ RtlInitUnicodeString(&Header->Name, wstrdup(Name));
+ Header->Parent = Parent;
- Status = ObOpenObjectByName(ObjectAttributes,&Object,&Ignored);
- if (!NT_SUCCESS(Status))
+ KeAcquireSpinLock(&Parent->Lock, &oldlvl);
+ InsertTailList(&Parent->head, &Header->Entry);
+ KeReleaseSpinLock(&Parent->Lock, oldlvl);
+}
+
+PVOID ObpFindEntryDirectory(PDIRECTORY_OBJECT DirectoryObject,
+ PWSTR Name,
+ ULONG Attributes)
+{
+ PLIST_ENTRY current = DirectoryObject->head.Flink;
+ POBJECT_HEADER current_obj;
+
+ DPRINT("ObDirLookup(dir %x, name %w)\n",DirectoryObject, Name);
+
+ if (Name[0]==0)
{
- return(Status);
+ return(DirectoryObject);
}
-
- if (BODY_TO_HEADER(Object)->Type!=OBJTYP_DIRECTORY)
- {
- return(STATUS_UNSUCCESSFUL);
+ if (Name[0]=='.' && Name[1]==0)
+ {
+ return(DirectoryObject);
}
-
- *DirectoryHandle = ObInsertHandle(KeGetCurrentProcess(),Object,
- DesiredAccess,FALSE);
- CHECKPOINT;
- return(STATUS_SUCCESS);
-}
+ if (Name[0]=='.' && Name[1]=='.' && Name[2]==0)
+ {
+ return(BODY_TO_HEADER(DirectoryObject)->Parent);
+ }
+ while (current!=(&(DirectoryObject->head)))
+ {
+ current_obj = CONTAINING_RECORD(current,OBJECT_HEADER,Entry);
+ DPRINT("Scanning %w %w\n",current_obj->Name.Buffer, Name);
+ if (Attributes & OBJ_CASE_INSENSITIVE)
+ {
+ 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;
+ }
+ DPRINT("%s() = NULL\n",__FUNCTION__);
+ return(NULL);
-NTSTATUS NtQueryDirectoryObject(IN HANDLE DirObjHandle,
- OUT POBJDIR_INFORMATION DirObjInformation,
- IN ULONG BufferLength,
- IN BOOLEAN GetNextIndex,
- IN BOOLEAN IgnoreInputIndex,
- IN OUT PULONG ObjectIndex,
- OUT PULONG DataWritten OPTIONAL)
-{
- return(ZwQueryDirectoryObject(DirObjHandle,
- DirObjInformation,
- BufferLength,
- GetNextIndex,
- IgnoreInputIndex,
- ObjectIndex,
- DataWritten));
}
-NTSTATUS ZwQueryDirectoryObject(IN HANDLE DirObjHandle,
- OUT POBJDIR_INFORMATION DirObjInformation,
- IN ULONG BufferLength,
- IN BOOLEAN GetNextIndex,
- IN BOOLEAN IgnoreInputIndex,
- IN OUT PULONG ObjectIndex,
- OUT PULONG DataWritten OPTIONAL)
-/*
- * FUNCTION: Reads information from a namespace directory
- * ARGUMENTS:
- * DirObjInformation (OUT) = Buffer to hold the data read
- * BufferLength = Size of the buffer in bytes
- * GetNextIndex = If TRUE then set ObjectIndex to the index of the
- * next object
- * If FALSE then set ObjectIndex to the number of
- * objects in the directory
- * IgnoreInputIndex = If TRUE start reading at index 0
- * If FALSE start reading at the index specified
- * by object index
- * ObjectIndex = Zero based index into the directory, interpretation
- * depends on IgnoreInputIndex and GetNextIndex
- * DataWritten (OUT) = Caller supplied storage for the number of bytes
- * written (or NULL)
- * RETURNS: Status
- */
+PVOID ObpParseDirectory(PVOID Object, PWSTR* Path)
{
- PDIRECTORY_OBJECT dir = NULL;
- ULONG EntriesToRead;
- PLIST_ENTRY current_entry;
- POBJECT_HEADER current;
- ULONG i=0;
- ULONG EntriesToSkip;
+ PWSTR end;
+ PVOID FoundObject;
NTSTATUS Status;
- DPRINT("ZwQueryDirectoryObject(DirObjHandle %x)\n",DirObjHandle);
- DPRINT("dir %x namespc_root %x\n",dir,HEADER_TO_BODY(&(namespc_root.hdr)));
-
-// assert_irql(PASSIVE_LEVEL);
+ DPRINT("ObpParseDirectory(Object %x, Path %x, *Path %w)\n",
+ Object,Path,*Path);
- Status = ObReferenceObjectByHandle(DirObjHandle,
- DIRECTORY_QUERY,
- ObDirectoryType,
- UserMode,
- (PVOID*)&dir,
- NULL);
- if (Status != STATUS_SUCCESS)
+ if ((*Path) == NULL)
{
- return(Status);
+ return(NULL);
}
- EntriesToRead = BufferLength / sizeof(OBJDIR_INFORMATION);
- *DataWritten = 0;
-
- DPRINT("EntriesToRead %d\n",EntriesToRead);
-
- current_entry = dir->head.Flink;
+ end = wcschr((*Path)+1, '\\');
+ if (end != NULL)
+ {
+ *end = 0;
+ }
+
+ FoundObject = ObpFindEntryDirectory(Object, (*Path)+1, 0);
- /*
- * Optionally, skip over some entries at the start of the directory
- */
- if (!IgnoreInputIndex)
+ if (FoundObject == NULL)
{
- CHECKPOINT;
-
- EntriesToSkip = *ObjectIndex;
- while ( i<EntriesToSkip && current_entry!=NULL)
+ if (end != NULL)
{
- current_entry = current_entry->Flink;
+ *end = '\\';
}
+ return(NULL);
}
- DPRINT("DirObjInformation %x\n",DirObjInformation);
+ ObReferenceObjectByPointer(FoundObject,
+ STANDARD_RIGHTS_REQUIRED,
+ NULL,
+ UserMode);
- /*
- * Read the maximum entries possible into the buffer
- */
- while ( i<EntriesToRead && current_entry!=(&(dir->head)))
+ if (end != NULL)
{
- current = CONTAINING_RECORD(current_entry,OBJECT_HEADER,Entry);
- DPRINT("Scanning %w\n",current->Name.Buffer);
- DirObjInformation[i].ObjectName.Buffer =
- ExAllocatePool(NonPagedPool,(current->Name.Length+1)*2);
- DirObjInformation[i].ObjectName.Length = current->Name.Length;
- DirObjInformation[i].ObjectName.MaximumLength = current->Name.Length;
- DPRINT("DirObjInformation[i].ObjectName.Buffer %x\n",
- DirObjInformation[i].ObjectName.Buffer);
- RtlCopyUnicodeString(&DirObjInformation[i].ObjectName,
- &(current->Name));
- i++;
- current_entry = current_entry->Flink;
- (*DataWritten) = (*DataWritten) + sizeof(OBJDIR_INFORMATION);
- CHECKPOINT;
- }
- CHECKPOINT;
-
- /*
- * Optionally, count the number of entries in the directory
- */
- if (GetNextIndex)
- {
- *ObjectIndex=i;
+ *end = '\\';
+ *Path = end;
}
else
{
- while ( current_entry!=(&(dir->head)) )
- {
- current_entry=current_entry->Flink;
- i++;
- }
- *ObjectIndex=i;
+ *Path = NULL;
}
- return(STATUS_SUCCESS);
-}
-
-
-NTSTATUS ObReferenceObjectByName(PUNICODE_STRING ObjectPath,
- ULONG Attributes,
- PACCESS_STATE PassedAccessState,
- ACCESS_MASK DesiredAccess,
- POBJECT_TYPE ObjectType,
- KPROCESSOR_MODE AccessMode,
- PVOID ParseContext,
- PVOID* ObjectPtr)
-{
- UNIMPLEMENTED;
+
+ return(FoundObject);
}
-NTSTATUS ObOpenObjectByName(POBJECT_ATTRIBUTES ObjectAttributes,
- PVOID* Object, PWSTR* UnparsedSection)
+NTSTATUS ObpCreateDirectory(PVOID ObjectBody,
+ PVOID Parent,
+ PWSTR RemainingPath,
+ POBJECT_ATTRIBUTES ObjectAttributes)
{
- NTSTATUS Status;
+ PDIRECTORY_OBJECT DirectoryObject = (PDIRECTORY_OBJECT)ObjectBody;
- DPRINT("ObOpenObjectByName(ObjectAttributes %x, Object %x)\n",
- ObjectAttributes,Object);
- DPRINT("ObjectAttributes = {ObjectName %x ObjectName->Buffer %w}\n",
- ObjectAttributes->ObjectName,ObjectAttributes->ObjectName->Buffer);
- DPRINT("ObjectAttributes->ObjectName->Length %d\n",
- ObjectAttributes->ObjectName->Length);
+ DPRINT("ObpCreateDirectory(ObjectBody %x, Parent %x, RemainingPath %w)\n",
+ ObjectBody, Parent, RemainingPath);
- *Object = NULL;
- Status = ObLookupObject(ObjectAttributes->RootDirectory,
- ObjectAttributes->ObjectName->Buffer,
- Object,
- UnparsedSection,
- ObjectAttributes->Attributes);
- DPRINT("*Object %x\n",*Object);
- DPRINT("ObjectAttributes->ObjectName->Length %d\n",
- ObjectAttributes->ObjectName->Length);
- return(Status);
+ if (RemainingPath != NULL && wcschr(RemainingPath+1, '\\') != NULL)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ if (Parent != NULL && RemainingPath != NULL)
+ {
+ ObAddEntryDirectory(Parent, ObjectBody, RemainingPath+1);
+ }
+ InitializeListHead(&DirectoryObject->head);
+ KeInitializeSpinLock(&DirectoryObject->Lock);
+ return(STATUS_SUCCESS);
}
-void ObInit(void)
+VOID ObInit(VOID)
/*
* FUNCTION: Initialize the object manager namespace
*/
ObDirectoryType->Open = NULL;
ObDirectoryType->Close = NULL;
ObDirectoryType->Delete = NULL;
- ObDirectoryType->Parse = NULL;
+ ObDirectoryType->Parse = ObpParseDirectory;
ObDirectoryType->Security = NULL;
ObDirectoryType->QueryName = NULL;
ObDirectoryType->OkayToClose = NULL;
+ ObDirectoryType->Create = ObpCreateDirectory;
RtlInitAnsiString(&AnsiString,"Directory");
RtlAnsiStringToUnicodeString(&ObDirectoryType->TypeName,
&AnsiString,TRUE);
- ObInitializeObjectHeader(ObDirectoryType,NULL,&namespc_root.hdr);
- InitializeListHead(&namespc_root.head);
-}
-
-NTSTATUS NtCreateDirectoryObject(PHANDLE DirectoryHandle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes)
-{
- return(ZwCreateDirectoryObject(DirectoryHandle,
- DesiredAccess,
- ObjectAttributes));
-}
-
-NTSTATUS ZwCreateDirectoryObject(PHANDLE DirectoryHandle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes)
-/*
- * FUNCTION: Creates or opens a directory object (a container for other
- * objects)
- * ARGUMENTS:
- * DirectoryHandle (OUT) = Caller supplied storage for the handle
- * of the directory
- * DesiredAccess = Access desired to the directory
- * ObjectAttributes = Object attributes initialized with
- * InitializeObjectAttributes
- * RETURNS: Status
- */
-{
- PDIRECTORY_OBJECT dir;
-
- dir = ObGenericCreateObject(DirectoryHandle,DesiredAccess,ObjectAttributes,
- ObDirectoryType);
-
- /*
- * Initialize the object body
- */
- InitializeListHead(&dir->head);
- KeInitializeSpinLock(&(dir->Lock));
-
- return(STATUS_SUCCESS);
-}
-
-VOID InitializeObjectAttributes(POBJECT_ATTRIBUTES InitializedAttributes,
- PUNICODE_STRING ObjectName,
- ULONG Attributes,
- HANDLE RootDirectory,
- PSECURITY_DESCRIPTOR SecurityDescriptor)
-/*
- * FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a
- * subsequent call to ZwCreateXXX or ZwOpenXXX
- * ARGUMENTS:
- * InitializedAttributes (OUT) = Caller supplied storage for the
- * object attributes
- * ObjectName = Full path name for object
- * Attributes = Attributes for the object
- * RootDirectory = Where the object should be placed or NULL
- * SecurityDescriptor = Ignored
- *
- * NOTE:
- * Either ObjectName is a fully qualified pathname or a path relative
- * to RootDirectory
- */
-{
- DPRINT("InitializeObjectAttributes(InitializedAttributes %x "
- "ObjectName %x Attributes %x RootDirectory %x)\n",
- InitializedAttributes,ObjectName,Attributes,RootDirectory);
- InitializedAttributes->Length=sizeof(OBJECT_ATTRIBUTES);
- InitializedAttributes->RootDirectory=RootDirectory;
- InitializedAttributes->ObjectName=ObjectName;
- InitializedAttributes->Attributes=Attributes;
- InitializedAttributes->SecurityDescriptor=SecurityDescriptor;
- InitializedAttributes->SecurityQualityOfService=NULL;
-}
-
-static PVOID ObDirLookup(PDIRECTORY_OBJECT dir, PWSTR name,
- ULONG Attributes)
-/*
- * FUNCTION: Looks up an entry within a namespace directory
- * ARGUMENTS:
- * dir = Directory to lookup in
- * name = Entry name to find
- * RETURNS: A pointer to the object body if found
- * NULL otherwise
- */
-{
- LIST_ENTRY* current = dir->head.Flink;
- POBJECT_HEADER current_obj;
-
- DPRINT("ObDirLookup(dir %x, name %w)\n",dir,name);
-
- if (name[0]==0)
- {
- return(dir);
- }
- if (name[0]=='.'&&name[1]==0)
- {
- return(dir);
- }
- if (name[0]=='.'&&name[1]=='.'&&name[2]==0)
- {
- return(BODY_TO_HEADER(dir)->Parent);
- }
- while (current!=(&(dir->head)))
- {
- current_obj = CONTAINING_RECORD(current,OBJECT_HEADER,Entry);
- DPRINT("Scanning %w\n",current_obj->Name.Buffer);
- if (Attributes & OBJ_CASE_INSENSITIVE)
- {
- 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;
- }
- DPRINT("%s() = NULL\n",__FUNCTION__);
- return(NULL);
+ NameSpaceRoot = ObCreateObject(NULL,
+ STANDARD_RIGHTS_REQUIRED,
+ NULL,
+ ObDirectoryType);
}
VOID ObRemoveEntry(POBJECT_HEADER Header)
KeReleaseSpinLock(&(Header->Parent->Lock),oldlvl);
}
-VOID ObCreateEntry(PDIRECTORY_OBJECT parent,POBJECT_HEADER Object)
-/*
- * FUNCTION: Add an entry to a namespace directory
- * ARGUMENTS:
- * parent = directory to add in
- * name = Name to give the entry
- * Object = Header of the object to add the entry for
- */
-{
- DPRINT("ObjCreateEntry(%x,%x,%x,%w)\n",parent,Object,Object->Name.Buffer,
- Object->Name.Buffer);
-
- /*
- * Insert ourselves in our parents list
- */
- InsertTailList(&parent->head,&Object->Entry);
-}
-
-NTSTATUS ObLookupObject(HANDLE rootdir,
- PWSTR string,
- PVOID* Object,
- PWSTR* UnparsedSection,
- ULONG Attributes)
-/*
- * FUNCTION: Lookup an object within the system namespc
- * ARGUMENTS:
- * root = Directory to start lookup from
- * _string = Pathname to lookup
- * RETURNS: On success a pointer to the object body
- * On failure NULL
- */
-{
- PWSTR current;
- PWSTR next;
- PDIRECTORY_OBJECT current_dir = NULL;
- NTSTATUS Status;
-
- DPRINT("ObLookupObject(rootdir %x, string %x, string %w, Object %x, "
- "UnparsedSection %x)\n",rootdir,string,string,Object,
- UnparsedSection);
- *UnparsedSection = NULL;
- *Object = NULL;
-
- if (rootdir == NULL)
- {
- current_dir = HEADER_TO_BODY(&(namespc_root.hdr));
- }
- else
- {
- ObReferenceObjectByHandle(rootdir,
- DIRECTORY_TRAVERSE,
- NULL,
- UserMode,
- (PVOID*)¤t_dir,
- NULL);
- }
-
- /*
- * Bit of a hack this
- */
- if (string[0] == 0)
- {
- *Object = current_dir;
- return STATUS_SUCCESS;
- }
-
- if (string[0] != '\\')
- {
- DbgPrint("Non absolute pathname passed\n");
- return STATUS_UNSUCCESSFUL;
- }
-
- next = string;
- current = next + 1;
-
- while (next != NULL &&
- BODY_TO_HEADER(current_dir)->ObjectType == ObDirectoryType)
- {
- *next = '\\';
- current = next + 1;
- next = wcschr(next + 1,'\\');
- if (next != NULL)
- {
- *next = 0;
- }
-
- DPRINT("current %w current[5] %x next %x ", current, current[5], next);
- if (next != NULL)
- {
- DPRINT("(next+1) %w", next + 1);
- }
- DPRINT("\n",0);
-
- current_dir = (PDIRECTORY_OBJECT)ObDirLookup(current_dir,
- current,
- Attributes);
- if (current_dir == NULL)
- {
- DbgPrint("Path component %w not found\n", current);
- return STATUS_UNSUCCESSFUL;
- }
-
- if (BODY_TO_HEADER(current_dir)->ObjectType == IoSymbolicLinkType)
- {
- current_dir = IoOpenSymlink(current_dir);
- }
-
- }
- DPRINT("next %x\n",next);
- DPRINT("current %x current %w\n",current,current);
- if (next == NULL)
- {
- if (current_dir == NULL)
- {
- Status = STATUS_UNSUCCESSFUL;
- }
- else
- {
- Status = STATUS_SUCCESS;
- }
- }
- else
- {
- CHECKPOINT;
- *next = '\\';
- *UnparsedSection = next;
- if (BODY_TO_HEADER(current_dir)->ObjectType == IoDeviceType)
- {
- Status = STATUS_FS_QUERY_REQUIRED;
- }
- else if (BODY_TO_HEADER(current_dir)->ObjectType->Parse != NULL)
- {
- current_dir = BODY_TO_HEADER(current_dir)->ObjectType->
- Parse(current_dir,
- UnparsedSection);
- Status = (current_dir != NULL) ? STATUS_SUCCESS :
- STATUS_UNSUCCESSFUL;
- }
- else
- {
- Status = STATUS_UNSUCCESSFUL;
- }
- }
- CHECKPOINT;
- *Object = current_dir;
- DPRINT("current_dir %x\n", current_dir);
-
- return Status;
-}
-
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: ntoskrnl/ob/ntobj.c
+ * PURPOSE: User mode interface to object manager
+ * PROGRAMMER: David Welch (welch@cwcom.net)
+ * UPDATE HISTORY:
+ * 10/06/98: Created
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ddk/ntddk.h>
+#include <internal/ob.h>
+#include <wstring.h>
+#include <string.h>
+
+#define NDEBUG
+#include <internal/debug.h>
+
+/* FUNCTIONS ************************************************************/
+
+NTSTATUS STDCALL NtSetInformationObject(IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ IN PVOID ObjectInformation,
+ IN ULONG Length)
+{
+ return(ZwSetInformationObject(ObjectHandle,
+ ObjectInformationClass,
+ ObjectInformation,
+ Length));
+}
+
+NTSTATUS STDCALL ZwSetInformationObject(IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ IN PVOID ObjectInformation,
+ IN ULONG Length)
+{
+ UNIMPLEMENTED;
+}
+
+NTSTATUS STDCALL NtQueryObject(IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ OUT PVOID ObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength)
+{
+ return(ZwQueryObject(ObjectHandle,
+ ObjectInformationClass,
+ ObjectInformation,
+ Length,
+ ResultLength));
+}
+
+NTSTATUS STDCALL ZwQueryObject(IN HANDLE ObjectHandle,
+ IN CINT ObjectInformationClass,
+ OUT PVOID ObjectInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength)
+{
+ UNIMPLEMENTED
+}
+
+VOID ObMakeTemporaryObject(PVOID ObjectBody)
+{
+ POBJECT_HEADER ObjectHeader;
+
+ ObjectHeader = BODY_TO_HEADER(ObjectBody);
+ ObjectHeader->Permanent = FALSE;
+}
+
+NTSTATUS NtMakeTemporaryObject(HANDLE Handle)
+{
+ return(ZwMakeTemporaryObject(Handle));
+}
+
+NTSTATUS ZwMakeTemporaryObject(HANDLE Handle)
+{
+ PVOID Object;
+ NTSTATUS Status;
+ POBJECT_HEADER ObjectHeader;
+
+ Status = ObReferenceObjectByHandle(Handle,
+ 0,
+ NULL,
+ KernelMode,
+ &Object,
+ NULL);
+ if (Status != STATUS_SUCCESS)
+ {
+ return(Status);
+ }
+
+ ObjectHeader = BODY_TO_HEADER(Object);
+ ObjectHeader->Permanent = FALSE;
+
+ ObDereferenceObject(Object);
+
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS NtClose(HANDLE Handle)
+{
+ return(ZwClose(Handle));
+}
+
+NTSTATUS ZwClose(HANDLE Handle)
+/*
+ * FUNCTION: Closes a handle reference to an object
+ * ARGUMENTS:
+ * Handle = handle to close
+ * RETURNS: Status
+ */
+{
+ PVOID ObjectBody;
+ POBJECT_HEADER Header;
+ PHANDLE_REP HandleRep;
+
+ assert_irql(PASSIVE_LEVEL);
+
+ DPRINT("ZwClose(Handle %x)\n",Handle);
+
+ HandleRep = ObTranslateHandle(KeGetCurrentProcess(),Handle);
+ if (HandleRep == NULL)
+ {
+ return(STATUS_INVALID_HANDLE);
+ }
+ ObjectBody = HandleRep->ObjectBody;
+
+ HandleRep->ObjectBody = NULL;
+
+ Header = BODY_TO_HEADER(ObjectBody);
+
+ Header->RefCount++;
+ Header->HandleCount--;
+
+ if (Header->ObjectType != NULL &&
+ Header->ObjectType->Close != NULL)
+ {
+ Header->ObjectType->Close(ObjectBody, Header->HandleCount);
+ }
+
+ Header->RefCount--;
+
+ ObPerformRetentionChecks(Header);
+
+ return(STATUS_SUCCESS);
+}
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ob/object.c
* PURPOSE: Implements generic object managment functions
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* 10/06/98: Created
*/
/* FUNCTIONS ************************************************************/
-NTSTATUS STDCALL NtSetInformationObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- IN PVOID ObjectInformation,
- IN ULONG Length)
+VOID ObInitializeObject(POBJECT_HEADER ObjectHeader,
+ PHANDLE Handle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_TYPE Type,
+ POBJECT_ATTRIBUTES ObjectAttributes)
{
- return(ZwSetInformationObject(ObjectHandle,
- ObjectInformationClass,
- ObjectInformation,
- Length));
-}
-
-NTSTATUS STDCALL ZwSetInformationObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- IN PVOID ObjectInformation,
- IN ULONG Length)
-{
- UNIMPLEMENTED;
-}
-
-NTSTATUS STDCALL NtQueryObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- OUT PVOID ObjectInformation,
- IN ULONG Length,
- OUT PULONG ResultLength)
-{
- return(ZwQueryObject(ObjectHandle,
- ObjectInformationClass,
- ObjectInformation,
- Length,
- ResultLength));
-}
-
-NTSTATUS STDCALL ZwQueryObject(IN HANDLE ObjectHandle,
- IN CINT ObjectInformationClass,
- OUT PVOID ObjectInformation,
- IN ULONG Length,
- OUT PULONG ResultLength)
-{
- UNIMPLEMENTED
-}
-
-VOID ObMakeTemporaryObject(PVOID ObjectBody)
-{
- POBJECT_HEADER ObjectHeader;
-
- ObjectHeader = BODY_TO_HEADER(ObjectBody);
+ ObjectHeader->HandleCount = 1;
+ ObjectHeader->RefCount = 1;
+ ObjectHeader->ObjectType = Type;
ObjectHeader->Permanent = FALSE;
-}
-
-NTSTATUS NtMakeTemporaryObject(HANDLE Handle)
-{
- return(ZwMakeTemporaryObject(Handle));
-}
-
-NTSTATUS ZwMakeTemporaryObject(HANDLE Handle)
-{
- PVOID Object;
- NTSTATUS Status;
- POBJECT_HEADER ObjectHeader;
-
- Status = ObReferenceObjectByHandle(Handle,
- 0,
- NULL,
- KernelMode,
- &Object,
- NULL);
- if (Status != STATUS_SUCCESS)
+ RtlInitUnicodeString(&(ObjectHeader->Name),NULL);
+ if (Handle != NULL)
{
- return(Status);
+ *Handle = ObInsertHandle(KeGetCurrentProcess(),
+ HEADER_TO_BODY(ObjectHeader),
+ DesiredAccess,
+ FALSE);
}
-
- ObjectHeader = BODY_TO_HEADER(Object);
- ObjectHeader->Permanent = FALSE;
-
- ObDereferenceObject(Object);
-
- return(STATUS_SUCCESS);
}
-PVOID ObGenericCreateObject(PHANDLE Handle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes,
- POBJECT_TYPE Type)
-/*
- * FUNCTION: Creates a new object
- */
+NTSTATUS ObFindObject(POBJECT_ATTRIBUTES ObjectAttributes,
+ PVOID* ReturnedObject,
+ PWSTR* RemainingPath)
{
- POBJECT_HEADER hdr = NULL;
- PWSTR path;
- PWSTR name;
- PWSTR Ignored;
- PULONG addr;
- PWSTR Buffer;
-
- DPRINT("ObGenericCreateObject(Handle %x, DesiredAccess %x,"
- "ObjectAttributes %x, Type %x)\n",Handle,DesiredAccess,
- ObjectAttributes,Type);
-
- /*
- * Allocate the object body and header
- */
- hdr=(POBJECT_HEADER)ExAllocatePool(NonPagedPool,OBJECT_ALLOC_SIZE(Type));
- DPRINT("OBJECT_ALLOC_SIZE(Type) %d\n",OBJECT_ALLOC_SIZE(Type));
- if (hdr==NULL)
+ PVOID NextObject;
+ PVOID CurrentObject;
+ POBJECT_HEADER CurrentHeader;
+ NTSTATUS Status;
+ PWSTR Path;
+ PWSTR current;
+
+ DPRINT("ObFindObject(ObjectAttributes %x, ReturnedObject %x, "
+ "RemainingPath %x)\n",ObjectAttributes,ReturnedObject,RemainingPath);
+ DPRINT("ObjectAttributes->ObjectName->Buffer %x\n",
+ ObjectAttributes->ObjectName->Buffer);
+
+ if (ObjectAttributes->RootDirectory == NULL)
{
- return(NULL);
+ ObReferenceObjectByPointer(NameSpaceRoot,
+ DIRECTORY_TRAVERSE,
+ NULL,
+ UserMode);
+ CurrentObject = NameSpaceRoot;
}
- DPRINT("hdr %x\n",hdr);
-
-
- /*
- * If unnamed then initalize
- */
- if (ObjectAttributes==NULL || ObjectAttributes->ObjectName==NULL)
+ else
{
- ObInitializeObjectHeader(Type,NULL,hdr);
- if (Handle != NULL)
+ Status = ObReferenceObjectByHandle(ObjectAttributes->RootDirectory,
+ DIRECTORY_TRAVERSE,
+ NULL,
+ UserMode,
+ &CurrentObject,
+ NULL);
+ if (!NT_SUCCESS(Status))
{
- *Handle = ObInsertHandle(KeGetCurrentProcess(),
- HEADER_TO_BODY(hdr),
- DesiredAccess,
- FALSE);
+ return(Status);
}
- return(HEADER_TO_BODY(hdr));
}
-
- /*
- * Copy the object name into a buffer
- */
-// DbgPrint("ObjectAttributes->ObjectName %x\n",ObjectAttributes->ObjectName);
-// DbgPrint("ObjectAttributes->ObjectName->Length %d\n",
-// ObjectAttributes->ObjectName->Length);
-// DbgPrint("ObjectAttributes->ObjectName->MaximumLength %d\n",
-// ObjectAttributes->ObjectName->MaximumLength);
- Buffer = ExAllocatePool(NonPagedPool,
- ((ObjectAttributes->ObjectName->Length+1)*2));
- if (Buffer==NULL)
- {
- return(NULL);
- }
- memcpy(Buffer, ObjectAttributes->ObjectName->Buffer,
- (ObjectAttributes->ObjectName->Length+1)*2);
+ Path = ObjectAttributes->ObjectName->Buffer;
- /*
- * Seperate the name into a path and name
- */
- name = wcsrchr(Buffer,'\\');
- if (name==NULL)
+ if (Path[0] == 0)
{
- name=Buffer;
- path=NULL;
+ *ReturnedObject = CurrentObject;
+ return(STATUS_SUCCESS);
}
- else
+
+ if (Path[0] != '\\')
{
- path=Buffer;
- *name=0;
- name=name+1;
+ return(STATUS_UNSUCCESSFUL);
}
- DPRINT("name %w path %w\n",name,path);
- ObLookupObject(ObjectAttributes->RootDirectory,
- path,
- &hdr->Parent,
- &Ignored,
- 0L);
+ current = Path;
- /*
- * Initialize the object header
- */
- ObInitializeObjectHeader(Type,name,hdr);
-
-
- ObCreateEntry(hdr->Parent,hdr);
-
- DPRINT("Handle %x\n",Handle);
- if (Handle != NULL)
+ while (TRUE)
{
- *Handle = ObInsertHandle(KeGetCurrentProcess(),
- HEADER_TO_BODY(hdr),
- DesiredAccess,
- FALSE);
+ DPRINT("current %w\n",current);
+ CurrentHeader = BODY_TO_HEADER(CurrentObject);
+ if (CurrentHeader->ObjectType->Parse == NULL)
+ {
+ break;
+ }
+ NextObject = CurrentHeader->ObjectType->Parse(CurrentObject,
+ ¤t);
+ if (NextObject == NULL)
+ {
+ break;
+ }
+ ObDereferenceObject(CurrentObject);
+ CurrentObject = NextObject;
}
- return(HEADER_TO_BODY(hdr));
+ *RemainingPath = current;
+ *ReturnedObject = CurrentObject;
+
+ return(STATUS_SUCCESS);
}
-VOID ObInitializeObjectHeader(POBJECT_TYPE Type, PWSTR name,
- POBJECT_HEADER ObjectHeader)
-/*
- * FUNCTION: Creates a new object
- * ARGUMENT:
- * id = Identifier for the type of object
- * obj = Pointer to the header of the object
- */
+PVOID ObCreateObject(PHANDLE Handle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes,
+ POBJECT_TYPE Type)
{
- PWSTR temp_name;
+ PVOID Parent = NULL;
+ PWSTR RemainingPath = NULL;
+ POBJECT_HEADER Header;
+ NTSTATUS Status;
- DPRINT("ObInitializeObjectHeader(id %x name %w obj %x)\n",Type,
- name,ObjectHeader);
-
- ObjectHeader->HandleCount = 1;
- ObjectHeader->RefCount = 1;
- ObjectHeader->ObjectType = Type;
- ObjectHeader->Permanent = FALSE;
- if (name==NULL)
+ DPRINT("ObCreateObject(Handle %x, ObjectAttributes %x, Type %x)\n");
+ if (ObjectAttributes != NULL &&
+ ObjectAttributes->ObjectName != NULL)
{
- ObjectHeader->Name.Length=0;
- ObjectHeader->Name.Buffer=NULL;
+ DPRINT("ObjectAttributes->ObjectName->Buffer %w\n",
+ ObjectAttributes->ObjectName->Buffer);
}
- else
+
+ if (ObjectAttributes != NULL &&
+ ObjectAttributes->ObjectName != NULL)
{
- RtlInitUnicodeString(&(ObjectHeader->Name),name);
+ ObFindObject(ObjectAttributes,
+ &Parent,
+ &RemainingPath);
+ }
+
+ Header = (POBJECT_HEADER)ExAllocatePool(NonPagedPool,
+ OBJECT_ALLOC_SIZE(Type));
+ ObInitializeObject(Header,
+ Handle,
+ DesiredAccess,
+ Type,
+ ObjectAttributes);
+ if (Header->ObjectType != NULL &&
+ Header->ObjectType->Create != NULL)
+ {
+ Status = Header->ObjectType->Create(HEADER_TO_BODY(Header),
+ Parent,
+ RemainingPath,
+ ObjectAttributes);
+ if (!NT_SUCCESS(Status))
+ {
+ return(NULL);
+ }
}
+ return(HEADER_TO_BODY(Header));
}
-
NTSTATUS ObReferenceObjectByPointer(PVOID ObjectBody,
ACCESS_MASK DesiredAccess,
POBJECT_TYPE ObjectType,
* RETURNS: Status
*/
{
- POBJECT_HEADER Object;
+ POBJECT_HEADER ObjectHeader;
- DPRINT("ObReferenceObjectByPointer(%x)\n",ObjectBody);
+ DPRINT("ObReferenceObjectByPointer(ObjectBody %x, ObjectType %x)\n",
+ ObjectBody,ObjectType);
+
+ ObjectHeader = BODY_TO_HEADER(ObjectBody);
+
+ if (ObjectType != NULL && ObjectHeader->ObjectType != ObjectType)
+ {
+ DPRINT("Failed (type was %x %w)\n",ObjectHeader->ObjectType,
+ ObjectHeader->ObjectType->TypeName.Buffer);
+ return(STATUS_UNSUCCESSFUL);
+ }
- Object = BODY_TO_HEADER(ObjectBody);
- Object->RefCount++;
+ ObjectHeader->RefCount++;
return(STATUS_SUCCESS);
}
!Header->Permanent)
{
if (Header->ObjectType != NULL &&
- Header->ObjectType->Close != NULL)
+ Header->ObjectType->Delete != NULL)
{
- Header->ObjectType->Close(HEADER_TO_BODY(Header));
+ Header->ObjectType->Delete(HEADER_TO_BODY(Header));
}
if (Header->Name.Buffer != NULL)
{
ObPerformRetentionChecks(Header);
}
-
-NTSTATUS NtClose(HANDLE Handle)
-{
- return(ZwClose(Handle));
-}
-
-NTSTATUS ZwClose(HANDLE Handle)
-/*
- * FUNCTION: Closes a handle reference to an object
- * ARGUMENTS:
- * Handle = handle to close
- * RETURNS: Status
- */
-{
- PVOID ObjectBody;
- POBJECT_HEADER Header;
- PHANDLE_REP HandleRep;
-
- assert_irql(PASSIVE_LEVEL);
-
- DPRINT("ZwClose(Handle %x)\n",Handle);
-
- HandleRep = ObTranslateHandle(KeGetCurrentProcess(),Handle);
- if (HandleRep == NULL)
- {
- return(STATUS_INVALID_HANDLE);
- }
- ObjectBody = HandleRep->ObjectBody;
-
- HandleRep->ObjectBody = NULL;
-
- Header = BODY_TO_HEADER(ObjectBody);
-
- Header->HandleCount--;
- ObPerformRetentionChecks(Header);
-
- return(STATUS_SUCCESS);
-}
-
NTSTATUS ObReferenceObjectByHandle(HANDLE Handle,
ACCESS_MASK DesiredAccess,
POBJECT_TYPE ObjectType,
/*
* Initialize the system process
*/
- SystemProcess = ObGenericCreateObject(NULL,PROCESS_ALL_ACCESS,NULL,
+ SystemProcess = ObCreateObject(NULL,PROCESS_ALL_ACCESS,NULL,
PsProcessType);
KProcess = &SystemProcess->Pcb;
return(Status);
}
- Process = ObGenericCreateObject(ProcessHandle,
- DesiredAccess,
- ObjectAttributes,
- PsProcessType);
+ Process = ObCreateObject(ProcessHandle,
+ DesiredAccess,
+ ObjectAttributes,
+ PsProcessType);
KeInitializeDispatcherHeader(&Process->Pcb.DispatcherHeader,
0,
sizeof(EPROCESS),
PiNrThreads++;
- Thread = ObGenericCreateObject(ThreadHandle,
- DesiredAccess,
- ThreadAttributes,
- PsThreadType);
+ Thread = ObCreateObject(ThreadHandle,
+ DesiredAccess,
+ ThreadAttributes,
+ PsThreadType);
DPRINT("Thread = %x\n",Thread);
Thread->Tcb.LastTick = 0;
Thread->Tcb.ThreadState=THREAD_STATE_SUSPENDED;
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: mkernel/rtl/seqlist.c
+ * FILE: ntoskrnl/rtl/seqlist.c
* PURPOSE: Implementing sequenced lists
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* REVISION HISTORY:
* 28/06/98: Created
*/
/* INCLUDES ***************************************************************/
-#include <windows.h>
#include <ddk/ntddk.h>
-#include <internal/kernel.h>
/* TYPES ********************************************************************/
/* INCLUDES *****************************************************************/
-#include <internal/kernel.h>
-#include <internal/linkage.h>
#include <ddk/ntddk.h>
#include <internal/debug.h>
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/tst/test.c
* PURPOSE: Kernel regression tests
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* 28/05/98: Created
*/
#define IDE_SECTOR_SZ 512
-/* GLOBALS ******************************************************************/
-
-static KEVENT event = {};
-//static KEVENT event2;
-NTSTATUS TstShell(VOID);
-
/* FUNCTIONS ****************************************************************/
-NTSTATUS TstPlaySound(VOID)
-{
- HANDLE hfile;
-
-// * Open the parallel port
- printk("Opening Waveout\n");
-// hfile = CreateFile("\\Device\\WaveOut",0,0,0,0,0,0);
- if (hfile == NULL)
- {
- printk("File open failed\n");
- }
- else
- {
-// WriteFile(hfile,wave,wavelength,NULL,NULL);
- }
-}
-NTSTATUS TstFirstThread(PVOID start)
-{
- int i;
-
- printk("Beginning Thread A\n");
- for (;;)
- {
- KeWaitForSingleObject(&event,Executive,KernelMode,FALSE,NULL);
- printk("AAA ");
- KeSetEvent(&event,IO_NO_INCREMENT,FALSE);
- }
-}
-
-NTSTATUS TstSecondThread(PVOID start)
-{
- int i;
-
- printk("Beginning Thread B\n");
- for(;;)
- {
- KeWaitForSingleObject(&event,Executive,KernelMode,FALSE,NULL);
- printk("BBB ");
- KeSetEvent(&event,IO_NO_INCREMENT,FALSE);
- }
-}
-
-NTSTATUS TstThreadSupport()
-{
- HANDLE th1, th2;
-
- KeInitializeEvent(&event,SynchronizationEvent,TRUE);
- PsCreateSystemThread(&th1,0,NULL,NULL,NULL,TstFirstThread,NULL);
- PsCreateSystemThread(&th2,0,NULL,NULL,NULL,TstSecondThread,NULL);
- printk("Ending main thread\n");
- for(;;);
-}
VOID ExExecuteShell(VOID)
{
LARGE_INTEGER SectionOffset;
ULONG Size, StackSize;
CONTEXT Context;
+ NTSTATUS Status;
ZwCreateProcess(&ShellHandle,
PROCESS_ALL_ACCESS,
RtlInitAnsiString(&afilename,"\\??\\C:\\reactos\\system\\shell.bin");
RtlAnsiStringToUnicodeString(&ufilename,&afilename,TRUE);
InitializeObjectAttributes(&attr,&ufilename,0,NULL,NULL);
- ZwOpenFile(&hfile,FILE_ALL_ACCESS,&attr,NULL,0,0);
- if (hfile==NULL)
+ Status = ZwOpenFile(&hfile,FILE_ALL_ACCESS,&attr,NULL,0,0);
+ if (!NT_SUCCESS(Status))
{
DbgPrint("Failed to open file\n");
return;
}
}
-void
-TstKeyboard(void)
-{
- NTSTATUS Status;
- HANDLE FileHandle;
- ANSI_STRING AnsiDeviceName;
- UNICODE_STRING UnicodeDeviceName;
- OBJECT_ATTRIBUTES ObjectAttributes;
- KEY_EVENT_RECORD KeyEvent[2];
-
- DbgPrint("Testing keyboard driver...\n");
-
- DbgPrint("Opening Keyboard device\n");
- RtlInitAnsiString(&AnsiDeviceName, "\\Device\\Keyboard");
- RtlAnsiStringToUnicodeString(&UnicodeDeviceName, &AnsiDeviceName, TRUE);
- InitializeObjectAttributes(&ObjectAttributes,
- &UnicodeDeviceName,
- 0,
- NULL,
- NULL);
- Status = ZwOpenFile(&FileHandle, FILE_GENERIC_READ, &ObjectAttributes, NULL, 0, 0);
- if (!NT_SUCCESS(Status))
- {
- DbgPrint("Failed to open keyboard\n");
- return;
- }
-
- DbgPrint(">");
- for(;;)
- {
- Status = ZwReadFile(FileHandle,
- NULL,
- NULL,
- NULL,
- NULL,
- &KeyEvent,
- sizeof(KeyEvent),
- 0,
- 0);
- if (!NT_SUCCESS(Status))
- {
- DbgPrint("Failed to read key event, status %08x\n", Status);
- return;
- }
- DbgPrint("%c",KeyEvent[0].AsciiChar);
- }
-}
-
-static int TTcnt = 0;
-
-VOID TstTimerDpc(struct _KDPC* Dpc,
- PVOID DeferredContext,
- PVOID SystemArgument1,
- PVOID SystemArgument2)
-{
- TTcnt++;
-
- DPRINT("Timer DPC cnt:%d\n", TTcnt);
-
-}
-
-void
-TstTimer(void)
-{
- PIO_TIMER Timer = ExAllocatePool(NonPagedPool,sizeof(IO_TIMER));
- long long int lli = -10000000;
- LARGE_INTEGER li = *(LARGE_INTEGER *)&lli;
-
- CHECKPOINT;
- KeInitializeTimer(&Timer->timer);
- CHECKPOINT;
- KeInitializeDpc(&Timer->dpc, TstTimerDpc, NULL);
- CHECKPOINT;
- KeSetTimerEx(&Timer->timer,
- li,
- 1000,
- &Timer->dpc);
- CHECKPOINT;
- while (TTcnt < 100)
- ;
- CHECKPOINT;
- KeCancelTimer(&Timer->timer);
- CHECKPOINT;
-
-}
-
void TstBegin()
{
ExExecuteShell();
-// TstFileRead();
-// TstGeneralWrite();
-// TstThreadSupport();
-// TstKeyboard();
-// TstIDERead();
-// TstKeyboardRead();
-// TstShell();
-// TstTimer();
}