Fixed buffer size issues in volume functions.
Fixed several minor bugs.
svn path=/trunk/; revision=1959
Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
+
return(STATUS_UNSUCCESSFUL);
}
FileObject = Param->FileObject;
DeviceExt = DeviceObject->DeviceExtension;
Length = Param->Parameters.QueryFile.Length;
- Buffer = MmGetSystemAddressForMdl(Irp->MdlAddress);
+ Buffer = Param->AssociatedIrp.SystemBuffer;
switch (Param->Parameters.QueryFile.FileInformationClass)
{
break;
default:
- Status = STATUS_NOT_IMPLEMENTED;
+ Status = STATUS_NOT_SUPPORTED;
}
Irp->IoStatus.Status = Status;
- Irp->IoStatus.Information = 0;
- return(STATUS_UNSUCCESSFUL);
+ if (NT_SUCCESS(Status)
+ Irp->IoStatus.Information =
+ Param->Parameters.QueryFile.Length - Length;
+ else
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
+
+ return(Status);
}
-
-# $Id: makefile,v 1.8 2000/04/01 14:19:07 ea Exp $
+# $Id: makefile,v 1.9 2001/06/12 12:32:46 ekohl Exp $
#
# Linux Ext2 IFS Driver
#
.phony: all
clean:
- - $(RM) super.o
- - $(RM) blockdev.o
- - $(RM) inode.o
- - $(RM) file.o
- - $(RM) dir.o
- - $(RM) rw.o
+ - $(RM) *.o
- $(RM) ext2.coff
- $(RM) junk.tmp
- $(RM) base.tmp
-# $Id: Makefile,v 1.2 2000/12/23 02:37:41 dwelch Exp $
+# $Id: Makefile,v 1.3 2001/06/12 12:33:10 ekohl Exp $
#
#
PATH_TO_TOP = ../../..
.phony: all
clean:
- - $(RM) $(TARGET).o
+ - $(RM) *.o
- $(RM) $(TARGET).coff
- $(RM) junk.tmp
- $(RM) base.tmp
-/* $Id: create.c,v 1.1 2001/05/05 15:11:57 ekohl Exp $
+/* $Id: create.c,v 1.2 2001/06/12 12:33:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <ddk/ntddk.h>
#include "msfs.h"
-//#define NDEBUG
+#define NDEBUG
#include <debug.h>
PLIST_ENTRY current_entry;
KIRQL oldIrql;
- DPRINT1("MsfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+ DPRINT("MsfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
IoStack = IoGetCurrentIrpStackLocation(Irp);
DeviceExtension = DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject;
- DPRINT1("Mailslot name: %wZ\n", &FileObject->FileName);
+ DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);
Fcb = ExAllocatePool(NonPagedPool, sizeof(MSFS_FCB));
if (Fcb == NULL)
PMSFS_MAILSLOT current;
PIO_MAILSLOT_CREATE_BUFFER Buffer;
- DPRINT1("MsfsCreateMailslot(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+ DPRINT("MsfsCreateMailslot(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
IoStack = IoGetCurrentIrpStackLocation(Irp);
DeviceExtension = DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject;
Buffer = (PIO_MAILSLOT_CREATE_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
- DPRINT1("Mailslot name: %wZ\n", &FileObject->FileName);
+ DPRINT("Mailslot name: %wZ\n", &FileObject->FileName);
Mailslot = ExAllocatePool(NonPagedPool, sizeof(MSFS_MAILSLOT));
if (Mailslot == NULL)
PMSFS_FCB Fcb;
PMSFS_MESSAGE Message;
KIRQL oldIrql;
-
- DPRINT1("MsfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
-
+
+ DPRINT("MsfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+
IoStack = IoGetCurrentIrpStackLocation(Irp);
DeviceExtension = DeviceObject->DeviceExtension;
FileObject = IoStack->FileObject;
-
+
KeLockMutex(&DeviceExtension->MailslotListLock);
-
+
if (DeviceExtension->MailslotListHead.Flink == &DeviceExtension->MailslotListHead)
{
KeUnlockMutex(&DeviceExtension->MailslotListLock);
-CHECKPOINT1;
-
+
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
-
+
IoCompleteRequest(Irp, IO_NO_INCREMENT);
-CHECKPOINT1;
-
+
return(STATUS_SUCCESS);
}
-
+
Fcb = FileObject->FsContext;
Mailslot = Fcb->Mailslot;
-
- DPRINT1("Mailslot name: %wZ\n", &Mailslot->Name);
-
+
+ DPRINT("Mailslot name: %wZ\n", &Mailslot->Name);
+
Mailslot->ReferenceCount--;
-CHECKPOINT1;
if (Mailslot->ServerFcb == Fcb)
{
-CHECKPOINT1;
/* delete all messages from message-list */
KeAcquireSpinLock(&Mailslot->MessageListLock, &oldIrql);
-
+
while (Mailslot->MessageListHead.Flink != &Mailslot->MessageListHead)
{
Message = CONTAINING_RECORD(Mailslot->MessageListHead.Flink,
ExFreePool(Message);
}
Mailslot->MessageCount = 0;
-
+
KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
Mailslot->ServerFcb = NULL;
}
-CHECKPOINT1;
-
+
KeAcquireSpinLock(&Mailslot->FcbListLock, &oldIrql);
RemoveEntryList(&Fcb->FcbListEntry);
KeReleaseSpinLock(&Mailslot->FcbListLock, oldIrql);
ExFreePool(Fcb);
FileObject->FsContext = NULL;
-CHECKPOINT1;
-
+
if (Mailslot->ReferenceCount == 0)
{
DPRINT1("ReferenceCount == 0: Deleting mailslot data\n");
RemoveEntryList(&Mailslot->MailslotListEntry);
ExFreePool(Mailslot);
}
-CHECKPOINT1;
-
+
KeUnlockMutex(&DeviceExtension->MailslotListLock);
-CHECKPOINT1;
-
+
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
-
+
IoCompleteRequest(Irp, IO_NO_INCREMENT);
-CHECKPOINT1;
-
+
return(STATUS_SUCCESS);
}
-/* $Id: finfo.c,v 1.1 2001/05/05 15:11:57 ekohl Exp $
+/* $Id: finfo.c,v 1.2 2001/06/12 12:33:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <ddk/ntddk.h>
#include "msfs.h"
-//#define NDEBUG
+#define NDEBUG
#include <debug.h>
+/* FUNCTIONS *****************************************************************/
static NTSTATUS
MsfsQueryMailslotInformation(PMSFS_FCB Fcb,
- PFILE_MAILSLOT_QUERY_INFORMATION Buffer);
+ PFILE_MAILSLOT_QUERY_INFORMATION Buffer,
+ PULONG BufferLength)
+{
+ PMSFS_MAILSLOT Mailslot;
+ KIRQL oldIrql;
+
+ if (*BufferLength < sizeof(FILE_MAILSLOT_QUERY_INFORMATION))
+ return(STATUS_BUFFER_OVERFLOW);
+
+ Mailslot = Fcb->Mailslot;
+
+ Buffer->MaxMessageSize = Mailslot->MaxMessageSize;
+ Buffer->Timeout = Mailslot->TimeOut;
+
+ KeAcquireSpinLock(&Mailslot->MessageListLock, &oldIrql);
+ Buffer->MessageCount = Mailslot->MessageCount;
+ if (Mailslot->MessageCount == 0)
+ {
+ Buffer->NextSize = 0;
+ }
+ else
+ {
+ /* FIXME: read size of first message (head) */
+ Buffer->NextSize = 0;
+ }
+ KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
+
+ *BufferLength -= sizeof(FILE_MAILSLOT_QUERY_INFORMATION);
+
+ return(STATUS_SUCCESS);
+}
+
static NTSTATUS
MsfsSetMailslotInformation(PMSFS_FCB Fcb,
- PFILE_MAILSLOT_SET_INFORMATION Buffer);
+ PFILE_MAILSLOT_SET_INFORMATION Buffer,
+ PULONG BufferLength)
+{
+ if (*BufferLength < sizeof(FILE_MAILSLOT_SET_INFORMATION))
+ return(STATUS_BUFFER_OVERFLOW);
+
+ Fcb->Mailslot->TimeOut = Buffer->Timeout;
+
+ return(STATUS_SUCCESS);
+}
-/* FUNCTIONS *****************************************************************/
NTSTATUS STDCALL
MsfsQueryInformation(PDEVICE_OBJECT DeviceObject,
PMSFS_DEVICE_EXTENSION DeviceExtension;
PMSFS_FCB Fcb;
PMSFS_MAILSLOT Mailslot;
+ PVOID SystemBuffer;
+ ULONG BufferLength;
NTSTATUS Status;
- PVOID Buffer;
- DPRINT1("MsfsQueryInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+ DPRINT("MsfsQueryInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
IoStack = IoGetCurrentIrpStackLocation (Irp);
FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
Fcb = (PMSFS_FCB)FileObject->FsContext;
Mailslot = Fcb->Mailslot;
- DPRINT1("Mailslot name: %wZ\n", &Mailslot->Name);
+ DPRINT("Mailslot name: %wZ\n", &Mailslot->Name);
/* querying information is not permitted on client side */
if (Fcb->Mailslot->ServerFcb != Fcb)
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
return(Status);
}
- // FIXME : determine Buffer for result :
- if (Irp->MdlAddress)
- Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
- else
- Buffer = Irp->UserBuffer;
+ SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
+ BufferLength = IoStack->Parameters.QueryFile.Length;
switch (FileInformationClass)
{
case FileMailslotQueryInformation:
Status = MsfsQueryMailslotInformation(Fcb,
- (PFILE_MAILSLOT_QUERY_INFORMATION)Buffer);
+ SystemBuffer,
+ &BufferLength);
break;
default:
Status = STATUS_NOT_IMPLEMENTED;
}
Irp->IoStatus.Status = Status;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest (Irp, IO_NO_INCREMENT);
-
- return(Status);
-}
-
-
-static NTSTATUS
-MsfsQueryMailslotInformation(PMSFS_FCB Fcb,
- PFILE_MAILSLOT_QUERY_INFORMATION Buffer)
-{
- PMSFS_MAILSLOT Mailslot;
- KIRQL oldIrql;
-
- Mailslot = Fcb->Mailslot;
-
- Buffer->MaxMessageSize = Mailslot->MaxMessageSize;
- Buffer->Timeout = Mailslot->TimeOut;
-
- KeAcquireSpinLock(&Mailslot->MessageListLock, &oldIrql);
- Buffer->MessageCount = Mailslot->MessageCount;
- if (Mailslot->MessageCount == 0)
- {
- Buffer->NextSize = 0;
- }
+ if (NT_SUCCESS(Status))
+ Irp->IoStatus.Information =
+ IoStack->Parameters.QueryFile.Length - BufferLength;
else
- {
- /* FIXME: read size of first message (head) */
- Buffer->NextSize = 0;
- }
- KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
- return(STATUS_SUCCESS);
+ return(Status);
}
-
NTSTATUS STDCALL
MsfsSetInformation(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
PFILE_OBJECT FileObject;
PMSFS_FCB Fcb;
PMSFS_MAILSLOT Mailslot;
- PVOID Buffer;
+ PVOID SystemBuffer;
+ PULONG BufferLength;
NTSTATUS Status;
- DPRINT1("MsfsSetInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+ DPRINT("MsfsSetInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
IoStack = IoGetCurrentIrpStackLocation (Irp);
FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
Fcb = (PMSFS_FCB)FileObject->FsContext;
Mailslot = Fcb->Mailslot;
- DPRINT1("Mailslot name: %wZ\n", &Mailslot->Name);
+ DPRINT("Mailslot name: %wZ\n", &Mailslot->Name);
/* setting information is not permitted on client side */
if (Fcb->Mailslot->ServerFcb != Fcb)
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
return(Status);
}
- // FIXME : determine Buffer for result :
- if (Irp->MdlAddress)
- Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
- else
- Buffer = Irp->UserBuffer;
+ SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
+ BufferLength = IoStack->Parameters.QueryFile.Length;
- DPRINT("FileInformationClass %d\n", FileInformationClass);
- DPRINT("Buffer %x\n", Buffer);
+ DPRINT("FileInformationClass %d\n", FileInformationClass);
+ DPRINT("SystemBuffer %x\n", SystemBuffer);
switch (FileInformationClass)
{
case FileMailslotSetInformation:
Status = MsfsSetMailslotInformation(Fcb,
- (PFILE_MAILSLOT_SET_INFORMATION)Buffer);
+ SystemBuffer,
+ &BufferLength);
break;
default:
Status = STATUS_NOT_IMPLEMENTED;
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
return(Status);
}
-
-static NTSTATUS
-MsfsSetMailslotInformation(PMSFS_FCB Fcb,
- PFILE_MAILSLOT_SET_INFORMATION Buffer)
-{
- Fcb->Mailslot->TimeOut = Buffer->Timeout;
-
- return(STATUS_SUCCESS);
-}
-
-
/* EOF */
-/* $Id: msfs.c,v 1.1 2001/05/05 15:11:57 ekohl Exp $
+/* $Id: msfs.c,v 1.2 2001/06/12 12:33:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PMSFS_DEVICE_EXTENSION DeviceExtension;
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName;
- UNICODE_STRING LinkName;
NTSTATUS Status;
DbgPrint("Mailslot FSD 0.0.1\n");
- RtlInitUnicodeString(&DeviceName,
- L"\\Device\\MailSlot");
- Status = IoCreateDevice(DriverObject,
- sizeof(MSFS_DEVICE_EXTENSION),
- &DeviceName,
- FILE_DEVICE_MAILSLOT,
- 0,
- FALSE,
- &DeviceObject);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
-
DeviceObject->Flags = 0;
DriverObject->MajorFunction[IRP_MJ_CREATE] = MsfsCreate;
DriverObject->MajorFunction[IRP_MJ_CREATE_MAILSLOT] =
DriverObject->DriverUnload = NULL;
-//#if 0
- RtlInitUnicodeString(&LinkName,
- L"\\??\\MAILSLOT");
- Status = IoCreateSymbolicLink(&LinkName,
- &DeviceName);
+ RtlInitUnicodeString(&DeviceName,
+ L"\\Device\\MailSlot");
+ Status = IoCreateDevice(DriverObject,
+ sizeof(MSFS_DEVICE_EXTENSION),
+ &DeviceName,
+ FILE_DEVICE_MAILSLOT,
+ 0,
+ FALSE,
+ &DeviceObject);
if (!NT_SUCCESS(Status))
{
-// IoDeleteDevice();
return(Status);
}
-//#endif
/* initialize device extension */
DeviceExtension = DeviceObject->DeviceExtension;
-/* $Id: rw.c,v 1.1 2001/05/05 15:11:57 ekohl Exp $
+/* $Id: rw.c,v 1.2 2001/06/12 12:33:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <ntos/minmax.h>
#include "msfs.h"
-//#define NDEBUG
+#define NDEBUG
#include <debug.h>
KernelMode,
FALSE,
NULL); /* FIXME: handle timeout */
-CHECKPOINT1;
if ((NT_SUCCESS(Status)) && (Mailslot->MessageCount > 0))
{
/* copy current message into buffer */
MessageListEntry);
memcpy(Buffer, &Message->Buffer, min(Message->Size,Length));
LengthRead = Message->Size;
-CHECKPOINT1;
+
KeAcquireSpinLock(&Mailslot->MessageListLock, &oldIrql);
-CHECKPOINT1;
RemoveHeadList(&Mailslot->MessageListHead);
-CHECKPOINT1;
KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
-CHECKPOINT1;
+
ExFreePool(Message);
-CHECKPOINT1;
Mailslot->MessageCount--;
-CHECKPOINT1;
if (Mailslot->MessageCount == 0)
{
-CHECKPOINT1;
KeClearEvent(&Mailslot->MessageEvent);
}
}
-CHECKPOINT1;
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = LengthRead;
KIRQL oldIrql;
ULONG Length;
PVOID Buffer;
-
- DPRINT1("MsfsWrite(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
-
+
+ DPRINT("MsfsWrite(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+
IoStack = IoGetCurrentIrpStackLocation (Irp);
FileObject = IoStack->FileObject;
Fcb = (PMSFS_FCB)FileObject->FsContext;
Mailslot = Fcb->Mailslot;
-
- DPRINT1("MailslotName: %wZ\n", &Mailslot->Name);
-
+
+ DPRINT("MailslotName: %wZ\n", &Mailslot->Name);
+
/* writing is not permitted on server side */
if (Fcb->Mailslot->ServerFcb == Fcb)
{
Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
Irp->IoStatus.Information = 0;
-
+
IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
+
return(STATUS_ACCESS_DENIED);
}
Buffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
else
Buffer = Irp->UserBuffer;
-
+
DPRINT("Length: %lu Message: %s\n", Length, (PUCHAR)Buffer);
-
+
/* Allocate new message */
Message = ExAllocatePool(NonPagedPool,
sizeof(MSFS_MESSAGE) + Length);
{
Irp->IoStatus.Status = STATUS_NO_MEMORY;
Irp->IoStatus.Information = 0;
-
+
IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
+
return(STATUS_NO_MEMORY);
}
-
+
Message->Size = Length;
memcpy(&Message->Buffer, Buffer, Length);
-
+
KeAcquireSpinLock(&Mailslot->MessageListLock, &oldIrql);
InsertTailList(&Mailslot->MessageListHead, &Message->MessageListEntry);
KeReleaseSpinLock(&Mailslot->MessageListLock, oldIrql);
-
+
Mailslot->MessageCount++;
if (Mailslot->MessageCount == 1)
{
0,
FALSE);
}
-
+
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = Length;
-
+
IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
+
return(STATUS_SUCCESS);
}
-# $Id: Makefile,v 1.6 2001/05/10 23:38:31 ekohl Exp $
+# $Id: Makefile,v 1.7 2001/06/12 12:35:04 ekohl Exp $
#
# Named Pipes File System
#
#BASE_CFLAGS = -I../../../include
-OBJECTS = create.o fsctrl.o mount.o rw.o npfs.coff
+OBJECTS = create.o finfo.o fsctrl.o mount.o rw.o volume.o npfs.coff
LIBS = ../../../ntoskrnl/ntoskrnl.a
-/* $Id: create.c,v 1.6 2001/05/10 23:38:31 ekohl Exp $
+/* $Id: create.c,v 1.7 2001/06/12 12:35:04 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
NTSTATUS Status;
PNPFS_PIPE Pipe;
PNPFS_FCB Fcb;
+ PNPFS_FCB ServerFcb;
PNPFS_PIPE current;
PLIST_ENTRY current_entry;
PNPFS_DEVICE_EXTENSION DeviceExt;
DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
IoStack = IoGetCurrentIrpStackLocation(Irp);
FileObject = IoStack->FileObject;
+ DPRINT("FileObject %p\n", FileObject);
Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB));
if (Fcb == NULL)
Pipe = current;
- KeAcquireSpinLock(&Pipe->FcbListLock, &oldIrql);
- InsertTailList(&Pipe->FcbListHead, &Fcb->FcbListEntry);
- KeReleaseSpinLock(&Pipe->FcbListLock, oldIrql);
Fcb->WriteModeMessage = FALSE;
Fcb->ReadModeMessage = FALSE;
Fcb->NonBlocking = FALSE;
Fcb->Pipe = Pipe;
Fcb->IsServer = FALSE;
Fcb->OtherSide = NULL;
+
+ /* search for disconnected server fcb */
+
+ current_entry = Pipe->FcbListHead.Flink;
+ while (current_entry != &Pipe->FcbListHead)
+ {
+ ServerFcb = CONTAINING_RECORD(current_entry,
+ NPFS_FCB,
+ FcbListEntry);
+
+ DPRINT("ServerFcb->IsServer: %x\n", ServerFcb->IsServer);
+ DPRINT("ServerFcb->OtherSide: %p\n", ServerFcb->OtherSide);
+ if ((ServerFcb->IsServer == TRUE) && (ServerFcb->OtherSide == NULL))
+ {
+ DPRINT("Server found! Fcb %p\n", ServerFcb);
+ break;
+ }
+
+ current_entry = current_entry->Flink;
+ }
+
+ if (current_entry == &Pipe->FcbListHead)
+ {
+ DPRINT("No server fcb found!\n");
+
+ ExFreePool(Fcb);
+ KeUnlockMutex(&DeviceExt->PipeListLock);
+
+ Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
+ Irp->IoStatus.Information = 0;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ KeAcquireSpinLock(&Pipe->FcbListLock, &oldIrql);
+ InsertTailList(&Pipe->FcbListHead, &Fcb->FcbListEntry);
+ KeReleaseSpinLock(&Pipe->FcbListLock, oldIrql);
Pipe->ReferenceCount++;
- /* search for unconnected server fcb */
+ Fcb->OtherSide = ServerFcb;
+ ServerFcb->OtherSide = Fcb;
+
+ KeSetEvent(&ServerFcb->ConnectEvent, 0, FALSE);
KeUnlockMutex(&DeviceExt->PipeListLock);
DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
IoStack = IoGetCurrentIrpStackLocation(Irp);
FileObject = IoStack->FileObject;
+ DPRINT("FileObject %p\n", FileObject);
+ DPRINT("Pipe name %wZ\n", &FileObject->FileName);
Buffer = (PIO_PIPE_CREATE_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
--- /dev/null
+/* $Id: finfo.c,v 1.1 2001/06/12 12:35:04 ekohl Exp $
+ *
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: services/fs/np/finfo.c
+ * PURPOSE: Named pipe filesystem
+ * PROGRAMMER: Eric Kohl <ekohl@rz-online.de>
+ */
+
+/* INCLUDES ******************************************************************/
+
+#include <ddk/ntddk.h>
+#include "npfs.h"
+
+//#define NDEBUG
+#include <debug.h>
+
+
+
+
+/* FUNCTIONS *****************************************************************/
+
+
+NTSTATUS STDCALL
+NpfsQueryInformation(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
+{
+ PIO_STACK_LOCATION IoStack;
+ FILE_INFORMATION_CLASS FileInformationClass;
+ PFILE_OBJECT FileObject;
+ PNPFS_DEVICE_EXTENSION DeviceExtension;
+ PNPFS_FCB Fcb;
+ PNPFS_PIPE Pipe;
+ PVOID SystemBuffer;
+ ULONG BufferLength;
+ NTSTATUS Status;
+
+ DPRINT("NpfsQueryInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+
+ IoStack = IoGetCurrentIrpStackLocation (Irp);
+ FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
+ DeviceExtension = DeviceObject->DeviceExtension;
+ FileObject = IoStack->FileObject;
+ Fcb = (PNPFS_FCB)FileObject->FsContext;
+ Pipe = Fcb->Pipe;
+
+ SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
+ BufferLength = IoStack->Parameters.QueryFile.Length;
+
+ DPRINT("Pipe name: %wZ\n", &Pipe->PipeName);
+ DPRINT("FileInformationClass %d\n", FileInformationClass);
+ DPRINT("SystemBuffer %x\n", SystemBuffer);
+ DPRINT("BufferLength %lu\n", BufferLength);
+
+ switch (FileInformationClass)
+ {
+ case FilePipeInformation:
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ case FilePipeLocalInformation:
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ case FilePipeRemoteInformation:
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ default:
+ Status = STATUS_NOT_SUPPORTED;
+ }
+
+ Irp->IoStatus.Status = Status;
+ if (NT_SUCCESS(Status))
+ Irp->IoStatus.Information =
+ IoStack->Parameters.QueryFile.Length - BufferLength;
+ else
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest (Irp, IO_NO_INCREMENT);
+
+ return(Status);
+}
+
+
+NTSTATUS STDCALL
+NpfsSetInformation(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
+{
+ PIO_STACK_LOCATION IoStack;
+ FILE_INFORMATION_CLASS FileInformationClass;
+ PFILE_OBJECT FileObject;
+ PNPFS_FCB Fcb;
+ PNPFS_PIPE Pipe;
+ PVOID SystemBuffer;
+ ULONG BufferLength;
+ NTSTATUS Status;
+
+ DPRINT("NpfsSetInformation(DeviceObject %p Irp %p)\n", DeviceObject, Irp);
+
+ IoStack = IoGetCurrentIrpStackLocation (Irp);
+ FileInformationClass = IoStack->Parameters.QueryFile.FileInformationClass;
+ FileObject = IoStack->FileObject;
+ Fcb = (PNPFS_FCB)FileObject->FsContext;
+ Pipe = Fcb->Pipe;
+
+ SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
+ BufferLength = IoStack->Parameters.QueryFile.Length;
+
+ DPRINT("Pipe name: %wZ\n", &Pipe->PipeName);
+ DPRINT("FileInformationClass %d\n", FileInformationClass);
+ DPRINT("SystemBuffer %x\n", SystemBuffer);
+ DPRINT("BufferLength %lu\n", BufferLength);
+
+ switch (FileInformationClass)
+ {
+ case FilePipeInformation:
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ case FilePipeLocalInformation:
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ case FilePipeRemoteInformation:
+ Status = STATUS_NOT_IMPLEMENTED;
+ break;
+ default:
+ Status = STATUS_NOT_SUPPORTED;
+ }
+
+ Irp->IoStatus.Status = Status;
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
+
+ return(Status);
+}
+
+/* EOF */
-/* $Id: fsctrl.c,v 1.3 2001/05/10 23:38:31 ekohl Exp $
+/* $Id: fsctrl.c,v 1.4 2001/06/12 12:35:04 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
{
NTSTATUS Status;
+ DPRINT("Waiting for connection...\n");
+
Status = KeWaitForSingleObject(&Fcb->ConnectEvent,
UserRequest,
KernelMode,
DPRINT("Finished waiting! Status: %x\n", Status);
+ DPRINT("Client Fcb: %p\n", Fcb->OtherSide);
+
return STATUS_SUCCESS;
}
return STATUS_SUCCESS;
}
+
+static NTSTATUS
+NpfsWaitPipe(PNPFS_FCB Fcb)
+{
+
+ return STATUS_SUCCESS;
+}
+
+
NTSTATUS STDCALL
NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
IoStack = IoGetCurrentIrpStackLocation(Irp);
FileObject = IoStack->FileObject;
+ DPRINT("FileObject: %p\n", FileObject);
Fcb = FileObject->FsContext;
Pipe = Fcb->Pipe;
Status = NpfsDisconnectPipe(Fcb);
break;
-#if 0
- case FSCTL_WAIT_PIPE:
- break;
-
- case FSCTL_SET_STATE:
+ case FSCTL_PIPE_WAIT:
+ DPRINT("Waiting for pipe %wZ\n", &Pipe->PipeName);
+ Status = NpfsWaitPipe(Fcb);
break;
-
- case FSCTL_GET_STATE:
- {
-
-
- break;
- }
-
-#endif
+
default:
DPRINT("IoControlCode: %x\n", IoStack->Parameters.FileSystemControl.IoControlCode)
Status = STATUS_UNSUCCESSFUL;
-/* $Id: mount.c,v 1.7 2001/05/10 23:38:31 ekohl Exp $
+/* $Id: mount.c,v 1.8 2001/06/12 12:35:04 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PNPFS_DEVICE_EXTENSION DeviceExtension;
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName;
- UNICODE_STRING LinkName;
NTSTATUS Status;
DbgPrint("Named Pipe FSD 0.0.2\n");
DriverObject->MajorFunction[IRP_MJ_CLOSE] = NpfsClose;
DriverObject->MajorFunction[IRP_MJ_READ] = NpfsRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = NpfsWrite;
+ DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
+ NpfsQueryInformation;
+ DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
+ NpfsSetInformation;
+ DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
+ NpfsQueryVolumeInformation;
+// DriverObject->MajorFunction[IRP_MJ_CLEANUP] = NpfsCleanup;
+// DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = NpfsFlushBuffers;
// DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
// NpfsDirectoryControl;
-// DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
-// NpfsQueryInformation;
-// DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
-// NpfsSetInformation;
-// DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = NpfsFlushBuffers;
-// DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = NpfsShutdown;
+ DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
+ NpfsFileSystemControl;
// DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] =
// NpfsQuerySecurity;
// DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] =
// NpfsSetSecurity;
- DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
- NpfsFileSystemControl;
DriverObject->DriverUnload = NULL;
return(Status);
}
-#if 0
- /* FIXME: this should really be done by SMSS!! */
- RtlInitUnicodeString(&LinkName, L"\\??\\PIPE");
- Status = IoCreateSymbolicLink(&LinkName,
- &DeviceName);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("Failed to create named pipe symbolic link! (Status %x)\n", Status);
-// IoDeleteDevice();
- return(Status);
- }
-#endif
-
/* initialize the device extension */
DeviceExtension = DeviceObject->DeviceExtension;
InitializeListHead(&DeviceExtension->PipeListHead);
NTSTATUS STDCALL NpfsFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+NTSTATUS STDCALL NpfsQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+NTSTATUS STDCALL NpfsSetInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp);
+
+NTSTATUS STDCALL NpfsQueryVolumeInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp);
+
#endif /* __SERVICES_FS_NP_NPFS_H */
--- /dev/null
+/* $Id: volume.c,v 1.1 2001/06/12 12:35:05 ekohl Exp $
+ *
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: services/fs/npfs/volume.c
+ * PURPOSE: Named pipe filesystem
+ * PROGRAMMER: Eric Kohl <ekohl@rz-online.de>
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ddk/ntddk.h>
+#include <wchar.h>
+
+#define NDEBUG
+#include <debug.h>
+
+#include "npfs.h"
+
+/* FUNCTIONS ****************************************************************/
+
+static NTSTATUS
+NpfsQueryFsDeviceInformation(PFILE_FS_DEVICE_INFORMATION FsDeviceInfo,
+ PULONG *BufferLength)
+{
+ DPRINT("NpfsQueryFsDeviceInformation()\n");
+ DPRINT("FsDeviceInfo = %p\n", FsDeviceInfo);
+
+ if (*BufferLength < sizeof(FILE_FS_DEVICE_INFORMATION))
+ return(STATUS_BUFFER_OVERFLOW);
+
+ FsDeviceInfo->DeviceType = FILE_DEVICE_NAMED_PIPE;
+ FsDeviceInfo->Characteristics = 0;
+
+ *BufferLength -= sizeof(FILE_FS_DEVICE_INFORMATION);
+
+ DPRINT("NpfsQueryFsDeviceInformation() finished.\n");
+
+ return(STATUS_SUCCESS);
+}
+
+
+static NTSTATUS
+NpfsQueryFsAttributeInformation(PFILE_FS_ATTRIBUTE_INFORMATION FsAttributeInfo,
+ PULONG BufferLength)
+{
+ DPRINT("NpfsQueryFsAttributeInformation() called.\n");
+ DPRINT("FsAttributeInfo = %p\n", FsAttributeInfo);
+
+ if (*BufferLength < sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8)
+ return(STATUS_BUFFER_OVERFLOW);
+
+ FsAttributeInfo->FileSystemAttributes = FILE_CASE_PRESERVED_NAMES;
+ FsAttributeInfo->MaximumComponentNameLength = 255;
+ FsAttributeInfo->FileSystemNameLength = 8;
+ wcscpy(FsAttributeInfo->FileSystemName,
+ L"NPFS");
+
+ DPRINT("NpfsQueryFsAttributeInformation() finished.\n");
+ *BufferLength -= (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 8);
+
+ return(STATUS_SUCCESS);
+}
+
+
+NTSTATUS STDCALL
+NpfsQueryVolumeInformation(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
+{
+ PIO_STACK_LOCATION Stack;
+ FS_INFORMATION_CLASS FsInformationClass;
+ NTSTATUS Status = STATUS_SUCCESS;
+ PVOID SystemBuffer;
+ ULONG BufferLength;
+
+ /* PRECONDITION */
+ assert(DeviceObject != NULL);
+ assert(Irp != NULL);
+
+ DPRINT("NpfsQueryVolumeInformation(DeviceObject %x, Irp %x)\n",
+ DeviceObject,
+ Irp);
+
+ Stack = IoGetCurrentIrpStackLocation (Irp);
+ FsInformationClass = Stack->Parameters.QueryVolume.FsInformationClass;
+ BufferLength = Stack->Parameters.QueryVolume.Length;
+ SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
+
+ DPRINT("FsInformationClass %d\n", FsInformationClass);
+ DPRINT("SystemBuffer %x\n", SystemBuffer);
+
+ switch (FsInformationClass)
+ {
+ case FileFsDeviceInformation:
+ Status = NpfsQueryFsDeviceInformation(SystemBuffer,
+ &BufferLength);
+ break;
+
+ case FileFsAttributeInformation:
+ Status = NpfsQueryFsAttributeInformation(SystemBuffer,
+ &BufferLength);
+ break;
+
+ default:
+ Status = STATUS_NOT_SUPPORTED;
+ }
+
+ Irp->IoStatus.Status = Status;
+ if (NT_SUCCESS(Status))
+ Irp->IoStatus.Information =
+ Stack->Parameters.QueryVolume.Length - BufferLength;
+ else
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
+
+ return(Status);
+}
+
+/* EOF */
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
-#include <internal/string.h>
-#include <wstring.h>
#define NDEBUG
-#include <internal/debug.h>
+#include <debug.h>
typedef struct
{
/* FUNCTIONS ****************************************************************/
-NTSTATUS FsdCloseFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
+NTSTATUS
+FsdCloseFile(PDEVICE_EXTENSION DeviceExt,
+ PFILE_OBJECT FileObject)
/*
* FUNCTION: Closes a file
*/
{
+ return(STATUS_SUCCESS);
}
-NTSTATUS FsdOpenFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
- PWSTR FileName)
+NTSTATUS
+FsdOpenFile(PDEVICE_EXTENSION DeviceExt,
+ PFILE_OBJECT FileObject,
+ PWSTR FileName)
/*
* FUNCTION: Opens a file
*/
{
+ return(STATUS_SUCCESS);
}
-BOOLEAN FsdHasFileSystem(PDEVICE_OBJECT DeviceToMount)
+BOOLEAN
+FsdHasFileSystem(PDEVICE_OBJECT DeviceToMount)
/*
* FUNCTION: Tests if the device contains a filesystem that can be mounted
* by this fsd
*/
{
+ return(TRUE);
}
-NTSTATUS FsdMountDevice(PDEVICE_EXTENSION DeviceExt,
- PDEVICE_OBJECT DeviceToMount)
+NTSTATUS
+FsdMountDevice(PDEVICE_EXTENSION DeviceExt,
+ PDEVICE_OBJECT DeviceToMount)
/*
* FUNCTION: Mounts the device
*/
{
+ return(STATUS_SUCCESS);
}
-NTSTATUS FsdReadFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
- PVOID Buffer, ULONG Length, ULONG Offset)
+NTSTATUS
+FsdReadFile(PDEVICE_EXTENSION DeviceExt,
+ PFILE_OBJECT FileObject,
+ PVOID Buffer,
+ ULONG Length,
+ ULONG Offset)
/*
* FUNCTION: Reads data from a file
*/
{
+ return(STATUS_SUCCESS);
}
-NTSTATUS FsdClose(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+NTSTATUS STDCALL
+FsdClose(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = Stack->FileObject;
return(Status);
}
-NTSTATUS FsdCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+NTSTATUS STDCALL
+FsdCreate(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = Stack->FileObject;
}
-NTSTATUS FsdWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+NTSTATUS STDCALL
+FsdWrite(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
{
DPRINT("FsdWrite(DeviceObject %x Irp %x)\n",DeviceObject,Irp);
return(STATUS_UNSUCCESSFUL);
}
-NTSTATUS FsdRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+NTSTATUS STDCALL
+FsdRead(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
{
ULONG Length;
PVOID Buffer;
}
-NTSTATUS FsdMount(PDEVICE_OBJECT DeviceToMount)
+NTSTATUS
+FsdMount(PDEVICE_OBJECT DeviceToMount)
{
PDEVICE_OBJECT DeviceObject;
PDEVICE_EXTENSION DeviceExt;
-
+
IoCreateDevice(DriverObject,
sizeof(DEVICE_EXTENSION),
NULL,
DeviceObject->Flags = DeviceObject->Flags | DO_DIRECT_IO;
DeviceExt = (PVOID)DeviceObject->DeviceExtension;
- FsdMountDevice(DeviceExt,DeviceToMount);
+ FsdMountDevice(DeviceExt,
+ DeviceToMount);
DeviceExt->StorageDevice = IoAttachDeviceToDeviceStack(DeviceObject,
DeviceToMount);
return(STATUS_SUCCESS);
}
-NTSTATUS FsdFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+NTSTATUS STDCALL
+FsdFileSystemControl(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
{
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
PVPB vpb = Stack->Parameters.Mount.Vpb;
return(Status);
}
-NTSTATUS DriverEntry(PDRIVER_OBJECT _DriverObject,
- PUNICODE_STRING RegistryPath)
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT _DriverObject,
+ PUNICODE_STRING RegistryPath)
/*
* FUNCTION: Called by the system to initalize the driver
* ARGUMENTS:
*/
{
PDEVICE_OBJECT DeviceObject;
- NTSTATUS ret;
- UNICODE_STRING ustr;
- ANSI_STRING astr;
+ NTSTATUS Status;
+ UNICODE_STRING DeviceName;
DbgPrint("Bare FSD Template 0.0.1\n");
-
+
DriverObject = _DriverObject;
- RtlInitAnsiString(&astr,"\\Device\\BareFsd");
- RtlAnsiStringToUnicodeString(&ustr,&astr,TRUE);
- ret = IoCreateDevice(DriverObject,0,&ustr,
- FILE_DEVICE_FILE_SYSTEM,0,FALSE,&DeviceObject);
- if (ret!=STATUS_SUCCESS)
+ RtlInitUnicodeString(&DeviceName,
+ L"\\Device\\BareFsd");
+ Status = IoCreateDevice(DriverObject,
+ 0,
+ &DeviceName,
+ FILE_DEVICE_FILE_SYSTEM,
+ 0,
+ FALSE,
+ &DeviceObject);
+ if (!NT_SUCCESS(Status))
{
return(ret);
}
-
+
DeviceObject->Flags=0;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = FsdClose;
DriverObject->MajorFunction[IRP_MJ_CREATE] = FsdCreate;
-/* $Id: finfo.c,v 1.7 2001/03/07 13:44:40 ekohl Exp $
+/* $Id: finfo.c,v 1.8 2001/06/12 12:35:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
static NTSTATUS
VfatGetStandardInformation(PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
- PFILE_STANDARD_INFORMATION StandardInfo)
+ PFILE_STANDARD_INFORMATION StandardInfo,
+ PULONG BufferLength)
/*
* FUNCTION: Retrieve the standard file information
*/
PDEVICE_EXTENSION DeviceExtension;
unsigned long AllocSize;
+ if (*BufferLength < sizeof(FILE_STANDARD_INFORMATION))
+ return STATUS_BUFFER_OVERFLOW;
+
DeviceExtension = DeviceObject->DeviceExtension;
/* PRECONDITION */
assert (DeviceExtension != NULL);
assert (StandardInfo != NULL);
assert (FCB != NULL);
- RtlZeroMemory (StandardInfo, sizeof (FILE_STANDARD_INFORMATION));
+ RtlZeroMemory(StandardInfo,
+ sizeof(FILE_STANDARD_INFORMATION));
/* Make allocsize a rounded up multiple of BytesPerCluster */
AllocSize = ((FCB->entry.FileSize + DeviceExtension->BytesPerCluster - 1) /
{
StandardInfo->Directory = FALSE;
}
-
- return STATUS_SUCCESS;
+
+ *BufferLength -= sizeof(FILE_STANDARD_INFORMATION);
+ return(STATUS_SUCCESS);
}
static NTSTATUS
VfatGetPositionInformation(PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
- PFILE_POSITION_INFORMATION PositionInfo)
+ PFILE_POSITION_INFORMATION PositionInfo,
+ PULONG BufferLength)
{
DPRINT ("VfatGetPositionInformation()\n");
- memcpy (&PositionInfo->CurrentByteOffset, &FileObject->CurrentByteOffset,
- sizeof (LARGE_INTEGER));
- DPRINT ("Getting position %x\n", PositionInfo->CurrentByteOffset.u.LowPart);
- return (STATUS_SUCCESS);
+ if (*BufferLength < sizeof(FILE_POSITION_INFORMATION))
+ return STATUS_BUFFER_OVERFLOW;
+
+ PositionInfo->CurrentByteOffset.QuadPart =
+ FileObject->CurrentByteOffset.QuadPart;
+
+ DPRINT("Getting position %I64x\n",
+ PositionInfo->CurrentByteOffset.QuadPart);
+
+ *BufferLength -= sizeof(FILE_POSITION_INFORMATION);
+ return(STATUS_SUCCESS);
}
static NTSTATUS
VfatGetBasicInformation(PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
- PFILE_BASIC_INFORMATION BasicInfo)
+ PFILE_BASIC_INFORMATION BasicInfo,
+ PULONG BufferLength)
{
- DPRINT ("VfatGetBasicInformation()\n");
-
- FsdDosDateTimeToFileTime (FCB->entry.CreationDate, FCB->entry.CreationTime,
- &BasicInfo->CreationTime);
- FsdDosDateTimeToFileTime (FCB->entry.AccessDate, 0,
- &BasicInfo->LastAccessTime);
- FsdDosDateTimeToFileTime (FCB->entry.UpdateDate, FCB->entry.UpdateTime,
- &BasicInfo->LastWriteTime);
- FsdDosDateTimeToFileTime (FCB->entry.UpdateDate, FCB->entry.UpdateTime,
- &BasicInfo->ChangeTime);
+ DPRINT("VfatGetBasicInformation()\n");
+
+ if (*BufferLength < sizeof(FILE_BASIC_INFORMATION))
+ return STATUS_BUFFER_OVERFLOW;
+
+ FsdDosDateTimeToFileTime(FCB->entry.CreationDate,
+ FCB->entry.CreationTime,
+ &BasicInfo->CreationTime);
+ FsdDosDateTimeToFileTime(FCB->entry.AccessDate,
+ 0,
+ &BasicInfo->LastAccessTime);
+ FsdDosDateTimeToFileTime(FCB->entry.UpdateDate,
+ FCB->entry.UpdateTime,
+ &BasicInfo->LastWriteTime);
+ FsdDosDateTimeToFileTime(FCB->entry.UpdateDate,
+ FCB->entry.UpdateTime,
+ &BasicInfo->ChangeTime);
BasicInfo->FileAttributes = FCB->entry.Attrib;
+ DPRINT("Getting attributes %x\n", BasicInfo->FileAttributes);
- DPRINT ("Getting attributes %x\n", BasicInfo->FileAttributes);
-
- return (STATUS_SUCCESS);
+ *BufferLength -= sizeof(FILE_BASIC_INFORMATION);
+ return(STATUS_SUCCESS);
}
return (STATUS_SUCCESS);
}
-NTSTATUS
-VfatGetNameInformation (PFILE_OBJECT FileObject, PVFATFCB FCB, PDEVICE_OBJECT DeviceObject,
- PFILE_NAME_INFORMATION NameInfo)
+static NTSTATUS
+VfatGetNameInformation(PFILE_OBJECT FileObject,
+ PVFATFCB FCB,
+ PDEVICE_OBJECT DeviceObject,
+ PFILE_NAME_INFORMATION NameInfo,
+ PULONG BufferLength)
/*
* FUNCTION: Retrieve the file name information
- * FIXME: We would need the IRP to check the length of the passed buffer. Now, it can cause overflows.
*/
{
+ ULONG NameLength;
+
assert (NameInfo != NULL);
assert (FCB != NULL);
- NameInfo->FileNameLength = wcslen(FCB->PathName);
- memcpy(NameInfo->FileName, FCB->PathName, sizeof(WCHAR)*(NameInfo->FileNameLength+1));
+ NameLength = wcslen(FCB->PathName) * sizeof(WCHAR);
+ if (*BufferLength < sizeof(FILE_NAME_INFORMATION) + NameLength)
+ return STATUS_BUFFER_OVERFLOW;
+
+ NameInfo->FileNameLength = NameLength;
+ memcpy(NameInfo->FileName,
+ FCB->PathName,
+ NameLength + sizeof(WCHAR));
+
+ *BufferLength -=
+ (sizeof(FILE_NAME_INFORMATION) + NameLength + sizeof(WCHAR));
return STATUS_SUCCESS;
}
NTSTATUS STDCALL
-VfatQueryInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+VfatQueryInformation(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
/*
* FUNCTION: Retrieve the specified file information
*/
{
- PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation (Irp);
- FILE_INFORMATION_CLASS FileInformationClass =
- Stack->Parameters.QueryFile.FileInformationClass;
+ PIO_STACK_LOCATION Stack;
+ FILE_INFORMATION_CLASS FileInformationClass;
PFILE_OBJECT FileObject = NULL;
PVFATFCB FCB = NULL;
// PVFATCCB CCB = NULL;
NTSTATUS RC = STATUS_SUCCESS;
- void *SystemBuffer;
+ PVOID SystemBuffer;
+ ULONG BufferLength;
/* PRECONDITION */
assert (DeviceObject != NULL);
// FCB = CCB->Buffer; // Should be CCB->FCB???
FCB = ((PVFATCCB) (FileObject->FsContext2))->pFcb;
- // FIXME : determine Buffer for result :
- if (Irp->MdlAddress)
- SystemBuffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
- else
- SystemBuffer = Irp->UserBuffer;
-// SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
-
+ SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
+ BufferLength = Stack->Parameters.QueryFile.Length;
+
switch (FileInformationClass)
{
case FileStandardInformation:
- RC = VfatGetStandardInformation (FCB, DeviceObject, SystemBuffer);
+ RC = VfatGetStandardInformation(FCB,
+ DeviceObject,
+ SystemBuffer,
+ &BufferLength);
break;
case FilePositionInformation:
- RC = VfatGetPositionInformation (FileObject,
- FCB, DeviceObject, SystemBuffer);
+ RC = VfatGetPositionInformation(FileObject,
+ FCB,
+ DeviceObject,
+ SystemBuffer,
+ &BufferLength);
break;
case FileBasicInformation:
- RC = VfatGetBasicInformation (FileObject,
- FCB, DeviceObject, SystemBuffer);
+ RC = VfatGetBasicInformation(FileObject,
+ FCB,
+ DeviceObject,
+ SystemBuffer,
+ &BufferLength);
break;
case FileNameInformation:
- RC = VfatGetNameInformation (FileObject,
- FCB, DeviceObject, SystemBuffer);
+ RC = VfatGetNameInformation(FileObject,
+ FCB,
+ DeviceObject,
+ SystemBuffer,
+ &BufferLength);
break;
- default:
+ case FileInternalInformation:
+ case FileAlternateNameInformation:
+ case FileAllInformation:
RC = STATUS_NOT_IMPLEMENTED;
+ break;
+ default:
+ RC = STATUS_NOT_SUPPORTED;
}
Irp->IoStatus.Status = RC;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest (Irp, IO_NO_INCREMENT);
+ if (NT_SUCCESS(RC))
+ Irp->IoStatus.Information =
+ Stack->Parameters.QueryFile.Length - BufferLength;
+ else
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
return RC;
}
NTSTATUS STDCALL
-VfatSetInformation (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+VfatSetInformation(PDEVICE_OBJECT DeviceObject,
+ PIRP Irp)
/*
* FUNCTION: Retrieve the specified file information
*/
{
- PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation (Irp);
+ PIO_STACK_LOCATION Stack;
FILE_INFORMATION_CLASS FileInformationClass;
PFILE_OBJECT FileObject = NULL;
PVFATFCB FCB = NULL;
-// PVFATCCB CCB = NULL;
+// PVFATCCB CCB = NULL;
NTSTATUS RC = STATUS_SUCCESS;
PVOID SystemBuffer;
/* PRECONDITION */
- assert (DeviceObject != NULL);
- assert (Irp != NULL);
+ assert(DeviceObject != NULL);
+ assert(Irp != NULL);
- DPRINT ("VfatSetInformation(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
+ DPRINT("VfatSetInformation(DeviceObject %x, Irp %x)\n", DeviceObject, Irp);
/* INITIALIZATION */
Stack = IoGetCurrentIrpStackLocation (Irp);
FileInformationClass = Stack->Parameters.SetFile.FileInformationClass;
FileObject = Stack->FileObject;
FCB = ((PVFATCCB) (FileObject->FsContext2))->pFcb;
+ SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
- // FIXME : determine Buffer for result :
- if (Irp->MdlAddress)
- SystemBuffer = MmGetSystemAddressForMdl (Irp->MdlAddress);
- else
- SystemBuffer = Irp->UserBuffer;
- // SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
-
- DPRINT ("FileInformationClass %d\n", FileInformationClass);
- DPRINT ("SystemBuffer %x\n", SystemBuffer);
+ DPRINT("FileInformationClass %d\n", FileInformationClass);
+ DPRINT("SystemBuffer %x\n", SystemBuffer);
switch (FileInformationClass)
{
case FilePositionInformation:
- RC = VfatSetPositionInformation (FileObject,
- FCB, DeviceObject, SystemBuffer);
+ RC = VfatSetPositionInformation(FileObject,
+ FCB,
+ DeviceObject,
+ SystemBuffer);
break;
case FileDispositionInformation:
- RC = VfatSetDispositionInformation (FileObject,
- FCB, DeviceObject, SystemBuffer);
+ RC = VfatSetDispositionInformation(FileObject,
+ FCB,
+ DeviceObject,
+ SystemBuffer);
break;
-// case FileBasicInformation:
-// case FileAllocationInformation:
-// case FileEndOfFileInformation:
-// case FileRenameInformation:
-// case FileLinkInformation:
- default:
+ case FileBasicInformation:
+ case FileAllocationInformation:
+ case FileEndOfFileInformation:
+ case FileRenameInformation:
RC = STATUS_NOT_IMPLEMENTED;
+ break;
+ default:
+ RC = STATUS_NOT_SUPPORTED;
}
Irp->IoStatus.Status = RC;
Irp->IoStatus.Information = 0;
- IoCompleteRequest (Irp, IO_NO_INCREMENT);
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
return RC;
}
+
+/* EOF */
-/* $Id: volume.c,v 1.8 2001/06/11 19:52:22 ekohl Exp $
+/* $Id: volume.c,v 1.9 2001/06/12 12:35:42 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
FsdGetFsVolumeInformation(PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
- PFILE_FS_VOLUME_INFORMATION FsVolumeInfo)
+ PFILE_FS_VOLUME_INFORMATION FsVolumeInfo,
+ PULONG BufferLength)
{
+ ULONG LabelLength;
+
DPRINT("FsdGetFsVolumeInformation()\n");
DPRINT("FsVolumeInfo = %p\n", FsVolumeInfo);
-
- if (!FsVolumeInfo)
- return (STATUS_SUCCESS);
-
+ DPRINT("BufferLength %lu\n", *BufferLength);
+ DPRINT("Required length %lu\n", (sizeof(FILE_FS_VOLUME_INFORMATION) + LabelLength));
+
+ LabelLength = DeviceObject->Vpb->VolumeLabelLength;
+ DPRINT("LabelLength %lu\n", LabelLength);
+
+ /* FIXME: This does not work correctly! Why?? */
+// if (*BufferLength < (sizeof(FILE_FS_VOLUME_INFORMATION) + LabelLength));
+// return(STATUS_BUFFER_OVERFLOW);
/* valid entries */
FsVolumeInfo->VolumeSerialNumber = DeviceObject->Vpb->SerialNumber;
- FsVolumeInfo->VolumeLabelLength = DeviceObject->Vpb->VolumeLabelLength;
+ FsVolumeInfo->VolumeLabelLength = LabelLength;
wcscpy(FsVolumeInfo->VolumeLabel, DeviceObject->Vpb->VolumeLabel);
-
+
/* dummy entries */
FsVolumeInfo->VolumeCreationTime.QuadPart = 0;
FsVolumeInfo->SupportsObjects = FALSE;
-
+
DPRINT("Finished FsdGetFsVolumeInformation()\n");
-
+
+ *BufferLength -= (sizeof(FILE_FS_VOLUME_INFORMATION) + LabelLength);
+
+ DPRINT("BufferLength %lu\n", *BufferLength);
+
return(STATUS_SUCCESS);
}
static NTSTATUS
-FsdGetFsAttributeInformation(PFILE_FS_ATTRIBUTE_INFORMATION FsAttributeInfo)
+FsdGetFsAttributeInformation(PFILE_FS_ATTRIBUTE_INFORMATION FsAttributeInfo,
+ PULONG BufferLength)
{
DPRINT("FsdGetFsAttributeInformation()\n");
DPRINT("FsAttributeInfo = %p\n", FsAttributeInfo);
-
- if (!FsAttributeInfo)
- return (STATUS_SUCCESS);
-
+ DPRINT("BufferLength %lu\n", *BufferLength);
+ DPRINT("Required length %lu\n", (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 6));
+
+ /* FIXME: This does not work correctly! Why?? */
+// if (*BufferLength < (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 6));
+// return(STATUS_BUFFER_OVERFLOW);
+
FsAttributeInfo->FileSystemAttributes =
- FILE_CASE_PRESERVED_NAMES || FILE_UNICODE_ON_DISK;
+ FILE_CASE_PRESERVED_NAMES | FILE_UNICODE_ON_DISK;
FsAttributeInfo->MaximumComponentNameLength = 255;
FsAttributeInfo->FileSystemNameLength = 6;
wcscpy(FsAttributeInfo->FileSystemName, L"FAT");
-
+
DPRINT("Finished FsdGetFsAttributeInformation()\n");
-
+
+ *BufferLength -= (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + 6);
+ DPRINT("BufferLength %lu\n", *BufferLength);
+
return(STATUS_SUCCESS);
}
+
static NTSTATUS
FsdGetFsSizeInformation(PDEVICE_OBJECT DeviceObject,
- PFILE_FS_SIZE_INFORMATION FsSizeInfo)
+ PFILE_FS_SIZE_INFORMATION FsSizeInfo,
+ PULONG BufferLength)
{
- PDEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
-
+ PDEVICE_EXTENSION DeviceExt;
+
DPRINT("FsdGetFsSizeInformation()\n");
DPRINT("FsSizeInfo = %p\n", FsSizeInfo);
-
- if (!FsSizeInfo)
- return(STATUS_SUCCESS);
-
+
+ /* FIXME: This does not work correctly! Why?? */
+// if (*BufferLength < sizeof(FILE_FS_SIZE_INFORMATION));
+// return(STATUS_BUFFER_OVERFLOW);
+
+ DeviceExt = DeviceObject->DeviceExtension;
+
if (DeviceExt->FatType == FAT32)
{
struct _BootSector32 *BootSect =
FsSizeInfo->SectorsPerAllocationUnit = BootSect->SectorsPerCluster;
FsSizeInfo->BytesPerSector = BootSect->BytesPerSector;
}
-
+
DPRINT("Finished FsdGetFsSizeInformation()\n");
+
+ *BufferLength -= sizeof(FILE_FS_SIZE_INFORMATION);
+
+ return(STATUS_SUCCESS);
+}
+
+static NTSTATUS
+FsdGetFsDeviceInformation(PFILE_FS_DEVICE_INFORMATION FsDeviceInfo,
+ PULONG BufferLength)
+{
+ DPRINT("FsdGetFsDeviceInformation()\n");
+ DPRINT("FsDeviceInfo = %p\n", FsDeviceInfo);
+ DPRINT("BufferLength %lu\n", *BufferLength);
+ DPRINT("Required length %lu\n", sizeof(FILE_FS_DEVICE_INFORMATION));
+
+ /* FIXME: This does not work correctly! Why?? */
+// if (*BufferLength < sizeof(FILE_FS_DEVICE_INFORMATION));
+// return(STATUS_BUFFER_OVERFLOW);
+
+ FsDeviceInfo->DeviceType = FILE_DEVICE_DISK;
+ FsDeviceInfo->Characteristics = 0; /* FIXME: fix this !! */
+
+ DPRINT("FsdGetFsDeviceInformation() finished.\n");
+
+ *BufferLength -= sizeof(FILE_FS_DEVICE_INFORMATION);
+ DPRINT("BufferLength %lu\n", *BufferLength);
+
return(STATUS_SUCCESS);
}
FsdSetFsLabelInformation(PDEVICE_OBJECT DeviceObject,
PFILE_FS_LABEL_INFORMATION FsLabelInfo)
{
- DPRINT1("FsdSetFsLabelInformation()\n");
+ DPRINT("FsdSetFsLabelInformation()\n");
return STATUS_NOT_IMPLEMENTED;
}
FS_INFORMATION_CLASS FsInformationClass;
PFILE_OBJECT FileObject = NULL;
PVFATFCB FCB = NULL;
-
NTSTATUS RC = STATUS_SUCCESS;
PVOID SystemBuffer;
ULONG BufferLength;
// FCB = CCB->Buffer; // Should be CCB->FCB???
FCB = ((PVFATCCB) (FileObject->FsContext2))->pFcb;
-
DPRINT ("FsInformationClass %d\n", FsInformationClass);
DPRINT ("SystemBuffer %x\n", SystemBuffer);
RC = FsdGetFsVolumeInformation(FileObject,
FCB,
DeviceObject,
- SystemBuffer);
+ SystemBuffer,
+ &BufferLength);
break;
case FileFsAttributeInformation:
- RC = FsdGetFsAttributeInformation(SystemBuffer);
+ RC = FsdGetFsAttributeInformation(SystemBuffer,
+ &BufferLength);
break;
case FileFsSizeInformation:
- RC = FsdGetFsSizeInformation (DeviceObject, SystemBuffer);
+ RC = FsdGetFsSizeInformation(DeviceObject,
+ SystemBuffer,
+ &BufferLength);
+ break;
+
+ case FileFsDeviceInformation:
+ RC = FsdGetFsDeviceInformation(SystemBuffer,
+ &BufferLength);
break;
default:
- RC = STATUS_NOT_IMPLEMENTED;
+ RC = STATUS_NOT_SUPPORTED;
}
Irp->IoStatus.Status = RC;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest (Irp, IO_NO_INCREMENT);
+ if (NT_SUCCESS(RC))
+ Irp->IoStatus.Information =
+ Stack->Parameters.QueryVolume.Length - BufferLength;
+ else
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp,
+ IO_NO_INCREMENT);
return RC;
}
FS_INFORMATION_CLASS FsInformationClass;
// PFILE_OBJECT FileObject = NULL;
// PVFATFCB FCB = NULL;
-
NTSTATUS Status = STATUS_SUCCESS;
PVOID SystemBuffer;
ULONG BufferLength;
-/* $Id: path.c,v 1.10 2001/05/06 16:09:03 cnettel Exp $
+/* $Id: path.c,v 1.11 2001/06/12 12:29:40 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
}
-ULONG
-STDCALL
-RtlDetermineDosPathNameType_U (
- PWSTR Path
- )
+ULONG STDCALL
+RtlDetermineDosPathNameType_U(PWSTR Path)
{
- DPRINT ("RtlDetermineDosPathNameType_U %S\n", Path);
+ DPRINT("RtlDetermineDosPathNameType_U %S\n", Path);
- if (Path == NULL)
- return 0;
+ if (Path == NULL)
+ {
+ return 0;
+ }
- if (IS_PATH_SEPARATOR(Path[0]))
- {
- if (!IS_PATH_SEPARATOR(Path[1]))
- return 4; /* \xxx */
+ if (IS_PATH_SEPARATOR(Path[0]))
+ {
+ if (!IS_PATH_SEPARATOR(Path[1]))
+ {
+ return 4; /* \xxx */
+ }
- if (Path[2] != L'.')
- return 1; /* \\xxx */
+ if (Path[2] != L'.')
+ return 1; /* \\xxx */
- if (IS_PATH_SEPARATOR(Path[3]))
- return 6; /* \\.\xxx */
+ if (IS_PATH_SEPARATOR(Path[3]))
+ return 6; /* \\.\xxx */
- if (Path[3])
- return 1; /* \\.xxxx */
+ if (Path[3])
+ return 1; /* \\.xxxx */
- return 7; /* \\. */
- }
- else
- {
- if (Path[1] != L':')
- return 5; /* xxx */
+ return 7; /* \\. */
+ }
+ else
+ {
+ if (Path[1] != L':')
+ return 5; /* xxx */
- if (IS_PATH_SEPARATOR(Path[2]))
- return 2; /* x:\xxx */
+ if (IS_PATH_SEPARATOR(Path[2]))
+ return 2; /* x:\xxx */
- return 3; /* x:xxx */
- }
+ return 3; /* x:xxx */
+ }
}
/* returns 0 if name is not valid DOS device name, or DWORD with
* offset in bytes to DOS device name from beginning of buffer in high word
* and size in bytes of DOS device name in low word */
-ULONG
-STDCALL
-RtlIsDosDeviceName_U (
- PWSTR DeviceName
- )
-{
- ULONG Type;
- ULONG Length = 0;
- ULONG Offset;
- PWCHAR wc;
-
- if (DeviceName == NULL)
- return 0;
- while (DeviceName[Length])
- Length++;
+ULONG STDCALL
+RtlIsDosDeviceName_U(PWSTR DeviceName)
+{
+ ULONG Type;
+ ULONG Length = 0;
+ ULONG Offset;
+ PWCHAR wc;
- Type = RtlDetermineDosPathNameType_U (DeviceName);
- if (Type <= 1)
- return 0;
- if (Type == 6)
- {
- if (Length == 7 &&
- !_wcsnicmp (DeviceName, L"\\\\.\\CON", 7))
- return 0x00080006;
- return 0;
- }
+ if (DeviceName == NULL)
+ {
+ return 0;
+ }
- /* name can end with ':' */
- if (Length && DeviceName[Length - 1 ] == L':')
- Length--;
+ while (DeviceName[Length])
+ {
+ Length++;
+ }
- /* there can be spaces or points at the end of name */
- wc = DeviceName + Length - 1;
- while (Length && (*wc == L'.' || *wc == L' '))
- {
- Length--;
- wc--;
- }
+ Type = RtlDetermineDosPathNameType_U(DeviceName);
+ if (Type <= 1)
+ {
+ return 0;
+ }
- /* let's find a beginning of name */
- wc = DeviceName + Length - 1;
- while (wc > DeviceName && !IS_PATH_SEPARATOR(*(wc - 1)))
- wc--;
- Offset = wc - DeviceName;
- Length -= Offset;
+ if (Type == 6)
+ {
+ if (Length == 7 &&
+ !_wcsnicmp (DeviceName, L"\\\\.\\CON", 7))
+ return 0x00080006;
+ return 0;
+ }
- /* check for LPTx or COMx */
- if (Length == 4 && wc[3] >= L'0' && wc[3] <= L'9')
- {
- if (wc[3] == L'0')
- return 0;
- if (!_wcsnicmp (wc, L"LPT", 3) ||
- !_wcsnicmp (wc, L"COM", 3))
- {
- return ((Offset * 2) << 16 ) | 8;
- }
- return 0;
- }
+ /* name can end with ':' */
+ if (Length && DeviceName[Length - 1 ] == L':')
+ {
+ Length--;
+ }
- /* check for PRN,AUX,NUL or CON */
- if (Length == 3 &&
- (!_wcsnicmp (wc, L"PRN", 3) ||
- !_wcsnicmp (wc, L"AUX", 3) ||
- !_wcsnicmp (wc, L"NUL", 3) ||
- !_wcsnicmp (wc, L"CON", 3)))
- {
- return ((Offset * 2) << 16) | 6;
- }
+ /* there can be spaces or points at the end of name */
+ wc = DeviceName + Length - 1;
+ while (Length && (*wc == L'.' || *wc == L' '))
+ {
+ Length--;
+ wc--;
+ }
+ /* let's find a beginning of name */
+ wc = DeviceName + Length - 1;
+ while (wc > DeviceName && !IS_PATH_SEPARATOR(*(wc - 1)))
+ {
+ wc--;
+ }
+ Offset = wc - DeviceName;
+ Length -= Offset;
+
+ /* check for LPTx or COMx */
+ if (Length == 4 && wc[3] >= L'0' && wc[3] <= L'9')
+ {
+ if (wc[3] == L'0')
+ {
+ return 0;
+ }
+
+ if (!_wcsnicmp (wc, L"LPT", 3) ||
+ !_wcsnicmp (wc, L"COM", 3))
+ {
+ return ((Offset * 2) << 16 ) | 8;
+ }
return 0;
+ }
+
+ /* check for PRN,AUX,NUL or CON */
+ if (Length == 3 &&
+ (!_wcsnicmp (wc, L"PRN", 3) ||
+ !_wcsnicmp (wc, L"AUX", 3) ||
+ !_wcsnicmp (wc, L"NUL", 3) ||
+ !_wcsnicmp (wc, L"CON", 3)))
+ {
+ return ((Offset * 2) << 16) | 6;
+ }
+
+ return 0;
}
-ULONG
-STDCALL
-RtlGetCurrentDirectory_U (
- ULONG MaximumLength,
- PWSTR Buffer
- )
+ULONG STDCALL
+RtlGetCurrentDirectory_U(ULONG MaximumLength,
+ PWSTR Buffer)
{
ULONG Length;
PCURDIR cd;
}
-NTSTATUS STDCALL RtlSetCurrentDirectory_U (PUNICODE_STRING name)
+NTSTATUS STDCALL
+RtlSetCurrentDirectory_U(PUNICODE_STRING name)
{
UNICODE_STRING full;
UNICODE_STRING envvar;
ULONG backslashcount = 0;
PWSTR cntr;
WCHAR var[4];
-
+
DPRINT ("RtlSetCurrentDirectory %wZ\n", name);
-
+
RtlAcquirePebLock ();
cd = &NtCurrentPeb ()->ProcessParameters->CurrentDirectory;
size = cd->DosPath.MaximumLength;
RtlReleasePebLock ();
return Status;
}
-
- filenameinfo = RtlAllocateHeap (RtlGetProcessHeap(),
- 0,
- MAX_PATH*sizeof(WCHAR)+sizeof(ULONG));
-
- NtQueryInformationFile(handle,NULL, filenameinfo,MAX_PATH*sizeof(WCHAR)+sizeof(ULONG),FileNameInformation);
-
+
+ filenameinfo = RtlAllocateHeap(RtlGetProcessHeap(),
+ 0,
+ MAX_PATH*sizeof(WCHAR)+sizeof(ULONG));
+
+ Status = NtQueryInformationFile(handle,
+ &iosb,
+ filenameinfo,
+ MAX_PATH*sizeof(WCHAR)+sizeof(ULONG),
+ FileNameInformation);
+ if (!NT_SUCCESS(Status))
+ {
+ RtlFreeHeap(RtlGetProcessHeap(),
+ 0,
+ filenameinfo);
+ RtlFreeHeap(RtlGetProcessHeap(),
+ 0,
+ buf);
+ RtlFreeHeap(RtlGetProcessHeap(),
+ 0,
+ full.Buffer);
+ RtlReleasePebLock();
+ return(Status);
+ }
+
if (filenameinfo->FileName[1]) // If it's just "\", we need special handling
- {
+ {
wcs = buf + size / sizeof(WCHAR) - 1;
if (*wcs == L'\\')
{
*(wcs) = 0;
wcs--;
size -= sizeof(WCHAR);
- }
-
- for (cntr=filenameinfo->FileName;*cntr!=0;cntr++)
- {
- if (*cntr=='\\') backslashcount++;
- }
-
-
- DPRINT("%d \n",backslashcount);
- for (;backslashcount;wcs--)
- {
- if (*wcs=='\\') backslashcount--;
- }
- wcs++;
+ }
+ for (cntr=filenameinfo->FileName;*cntr!=0;cntr++)
+ {
+ if (*cntr=='\\') backslashcount++;
+ }
- wcscpy(wcs,filenameinfo->FileName);
+ DPRINT("%d \n",backslashcount);
+ for (;backslashcount;wcs--)
+ {
+ if (*wcs=='\\') backslashcount--;
+ }
+ wcs++;
- size=((wcs-buf)+wcslen(filenameinfo->FileName))*sizeof(WCHAR);
- }
+ wcscpy(wcs,filenameinfo->FileName);
+ size=((wcs-buf)+wcslen(filenameinfo->FileName))*sizeof(WCHAR);
+ }
+
RtlFreeHeap (RtlGetProcessHeap (),
0,
filenameinfo);
-
-
/* append backslash if missing */
wcs = buf + size / sizeof(WCHAR) - 1;
if (*wcs != L'\\')
*(++wcs) = 0;
size += sizeof(WCHAR);
}
-
- memmove (cd->DosPath.Buffer,
- buf,
- size + sizeof(WCHAR));
+
+ memmove(cd->DosPath.Buffer,
+ buf,
+ size + sizeof(WCHAR));
cd->DosPath.Length = size;
if (cd->Handle)
- NtClose (cd->Handle);
+ NtClose(cd->Handle);
cd->Handle = handle;
if (cd->DosPath.Buffer[1]==':')
- {
- envvar.Length = 2 * swprintf (var, L"=%c:", cd->DosPath.Buffer[0]);
- envvar.MaximumLength = 8;
- envvar.Buffer = var;
-
- RtlSetEnvironmentVariable(NULL,&envvar,&cd->DosPath);
+ {
+ envvar.Length = 2 * swprintf (var, L"=%c:", cd->DosPath.Buffer[0]);
+ envvar.MaximumLength = 8;
+ envvar.Buffer = var;
+
+ RtlSetEnvironmentVariable(NULL,
+ &envvar,
+ &cd->DosPath);
}
RtlFreeHeap (RtlGetProcessHeap (),
}
-ULONG
-STDCALL
-RtlGetFullPathName_U (
- PWSTR DosName,
- ULONG size,
- PWSTR buf,
- PWSTR *FilePart
- )
+ULONG STDCALL
+RtlGetFullPathName_U(PWSTR DosName,
+ ULONG size,
+ PWSTR buf,
+ PWSTR *FilePart)
{
WCHAR *wcs, var[4], drive;
int len;
}
-BOOLEAN
-STDCALL
-RtlDosPathNameToNtPathName_U (
- PWSTR dosname,
- PUNICODE_STRING ntname,
- PWSTR *FilePart,
- PCURDIR nah
- )
+BOOLEAN STDCALL
+RtlDosPathNameToNtPathName_U(PWSTR dosname,
+ PUNICODE_STRING ntname,
+ PWSTR *FilePart,
+ PCURDIR nah)
{
UNICODE_STRING us;
PCURDIR cd;
-/* $Id: file.c,v 1.13 2001/03/06 23:34:39 cnettel Exp $
+/* $Id: file.c,v 1.14 2001/06/12 12:30:36 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <ddk/ntddk.h>
#include <internal/io.h>
+#include <internal/mm.h>
#define NDEBUG
#include <internal/debug.h>
+
+/* GLOBALS *******************************************************************/
+
+#define TAG_SYSB TAG('S', 'Y', 'S', 'B')
+
+
/* FUNCTIONS *****************************************************************/
-NTSTATUS STDCALL internalQueryFileInfo (
- IN PFILE_OBJECT FileObject,
- IN FILE_INFORMATION_CLASS FileInformationClass,
- PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG Length,
- OUT PVOID FileInformation,
- OUT PULONG ReturnedLength // FIXME: ReturnedLength not implemented
- )
+NTSTATUS STDCALL
+NtQueryInformationFile(HANDLE FileHandle,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass)
{
- //This code is taken from old NtQueryInformationFile, now shared with IoQueryFileInformation
+ PFILE_OBJECT FileObject;
+ NTSTATUS Status;
PIRP Irp;
PDEVICE_OBJECT DeviceObject;
- NTSTATUS Status;
- KEVENT Event;
PIO_STACK_LOCATION StackPtr;
-
-
- KeInitializeEvent(&Event,NotificationEvent,FALSE);
+ KEVENT Event;
+ PVOID SystemBuffer;
+
+ assert(IoStatusBlock != NULL);
+ assert(FileInformation != NULL);
+
+ DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
+ FileHandle,
+ IoStatusBlock,
+ FileInformation,
+ Length,
+ FileInformationClass);
+
+ Status = ObReferenceObjectByHandle(FileHandle,
+ FILE_READ_ATTRIBUTES,
+ IoFileObjectType,
+ UserMode,
+ (PVOID *)&FileObject,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+ DPRINT("FileObject %x\n", FileObject);
+
+ KeInitializeEvent(&Event,
+ NotificationEvent,
+ FALSE);
DeviceObject = FileObject->DeviceObject;
- Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
- if (Irp==NULL)
+ Irp = IoAllocateIrp(DeviceObject->StackSize,
+ TRUE);
+ if (Irp == NULL)
{
ObDereferenceObject(FileObject);
- return STATUS_UNSUCCESSFUL;
+ return STATUS_INSUFFICIENT_RESOURCES;
}
-
+
+ SystemBuffer = ExAllocatePoolWithTag(NonPagedPool,
+ Length,
+ TAG_SYSB);
+ if (SystemBuffer == NULL)
+ {
+ IoFreeIrp(Irp);
+ ObDereferenceObject(FileObject);
+ return(STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ Irp->AssociatedIrp.SystemBuffer = SystemBuffer;
Irp->UserIosb = IoStatusBlock;
Irp->UserEvent = &Event;
- Irp->UserBuffer=FileInformation;
StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->MajorFunction = IRP_MJ_QUERY_INFORMATION;
StackPtr->DeviceObject = DeviceObject;
StackPtr->FileObject = FileObject;
- StackPtr->Parameters.QueryFile.FileInformationClass =
+ StackPtr->Parameters.QueryFile.FileInformationClass =
FileInformationClass;
StackPtr->Parameters.QueryFile.Length = Length;
- Status = IoCallDriver(FileObject->DeviceObject,Irp);
+ Status = IoCallDriver(FileObject->DeviceObject,
+ Irp);
if (Status==STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
{
- KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL);
- Status = Irp->IoStatus.Status;
+ KeWaitForSingleObject(&Event,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ Status = Irp->IoStatus.Status;
}
- return Status;
+ if (NT_SUCCESS(Status))
+ {
+ DPRINT("Information %lu\n", IoStatusBlock->Information);
+ MmSafeCopyToUser(FileInformation,
+ SystemBuffer,
+ IoStatusBlock->Information);
+ }
+
+ ExFreePool(SystemBuffer);
+ ObDereferenceObject(FileObject);
+
+ return(Status);
}
-NTSTATUS
-STDCALL
-NtQueryInformationFile (
- HANDLE FileHandle,
- PIO_STATUS_BLOCK IoStatusBlock,
- PVOID FileInformation,
- ULONG Length,
- FILE_INFORMATION_CLASS FileInformationClass
- )
+
+NTSTATUS STDCALL
+IoQueryFileInformation(IN PFILE_OBJECT FileObject,
+ IN FILE_INFORMATION_CLASS FileInformationClass,
+ IN ULONG Length,
+ OUT PVOID FileInformation,
+ OUT PULONG ReturnedLength)
{
- PFILE_OBJECT FileObject;
+ IO_STATUS_BLOCK IoStatusBlock;
+ PIRP Irp;
+ PDEVICE_OBJECT DeviceObject;
+ PIO_STACK_LOCATION StackPtr;
+ KEVENT Event;
NTSTATUS Status;
- DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
- FileHandle,
- IoStatusBlock,
- FileInformation,
- Length,
- FileInformationClass);
+ assert(FileInformation != NULL)
- Status = ObReferenceObjectByHandle(FileHandle,
- FILE_READ_ATTRIBUTES,
- IoFileObjectType,
- UserMode,
- (PVOID *)&FileObject,
- NULL);
+ Status = ObReferenceObjectByPointer(FileObject,
+ FILE_READ_ATTRIBUTES,
+ IoFileObjectType,
+ KernelMode);
if (!NT_SUCCESS(Status))
{
return(Status);
}
+
DPRINT("FileObject %x\n", FileObject);
- Status = internalQueryFileInfo(FileObject, FileInformationClass, IoStatusBlock, Length, FileInformation, NULL);
-
-// ObDereferenceObject(FileObject); FIXME: Why will a Dereference here make the OS impossible to boot. Incorrect deferring somewhere else?
- return(Status);
+
+ KeInitializeEvent(&Event,
+ NotificationEvent,
+ FALSE);
+ DeviceObject = FileObject->DeviceObject;
+
+ Irp = IoAllocateIrp(DeviceObject->StackSize,
+ TRUE);
+ if (Irp == NULL)
+ {
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ Irp->AssociatedIrp.SystemBuffer = FileInformation;
+ Irp->UserIosb = &IoStatusBlock;
+ Irp->UserEvent = &Event;
+
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->MajorFunction = IRP_MJ_QUERY_INFORMATION;
+ StackPtr->MinorFunction = 0;
+ StackPtr->Flags = 0;
+ StackPtr->Control = 0;
+ StackPtr->DeviceObject = DeviceObject;
+ StackPtr->FileObject = FileObject;
+
+ StackPtr->Parameters.QueryFile.FileInformationClass =
+ FileInformationClass;
+ StackPtr->Parameters.QueryFile.Length = Length;
+
+ Status = IoCallDriver(FileObject->DeviceObject,
+ Irp);
+ if (Status==STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
+ {
+ KeWaitForSingleObject(&Event,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ Status = Irp->IoStatus.Status;
+ }
+
+ if (ReturnedLength != NULL)
+ {
+ *ReturnedLength = IoStatusBlock.Information;
+ }
+
+ ObDereferenceObject(FileObject);
+
+ return Status;
}
-
-NTSTATUS
-STDCALL
-IoQueryFileInformation (
- IN PFILE_OBJECT FileObject,
- IN FILE_INFORMATION_CLASS FileInformationClass,
- IN ULONG Length,
- OUT PVOID FileInformation,
- OUT PULONG ReturnedLength // FIXME: ReturnedLength not implemented
- )
+NTSTATUS STDCALL
+NtSetInformationFile(HANDLE FileHandle,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ FILE_INFORMATION_CLASS FileInformationClass)
{
+ PIO_STACK_LOCATION StackPtr;
+ PFILE_OBJECT FileObject;
+ PDEVICE_OBJECT DeviceObject;
+ PIRP Irp;
+ KEVENT Event;
NTSTATUS Status;
-
- Status = ObReferenceObjectByPointer(FileObject,
- FILE_READ_ATTRIBUTES,
- IoFileObjectType,
- KernelMode); // FIXME: Is KernelMode the correct choice here?
+ PVOID SystemBuffer;
+
+ assert(IoStatusBlock != NULL)
+ assert(FileInformation != NULL)
+
+ DPRINT("NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
+ FileHandle,
+ IoStatusBlock,
+ FileInformation,
+ Length,
+ FileInformationClass);
+
+ /* Get the file object from the file handle */
+ Status = ObReferenceObjectByHandle(FileHandle,
+ FILE_WRITE_ATTRIBUTES,
+ IoFileObjectType,
+ UserMode,
+ (PVOID *)&FileObject,
+ NULL);
if (!NT_SUCCESS(Status))
{
- return(Status);
- }
-
-// ObDereferenceObject(FileObject); For some reason, ObDereference is NOT a good thing here... wish I knew why
- return internalQueryFileInfo(FileObject,FileInformationClass,NULL,Length,FileInformation,ReturnedLength);
-}
-
-
-NTSTATUS
-STDCALL
-NtSetInformationFile (
- HANDLE FileHandle,
- PIO_STATUS_BLOCK IoStatusBlock,
- PVOID FileInformation,
- ULONG Length,
- FILE_INFORMATION_CLASS FileInformationClass
- )
-{
- NTSTATUS Status;
- PFILE_OBJECT FileObject;
- PIRP Irp;
- PIO_STACK_LOCATION StackPtr;
- KEVENT Event;
-
- DPRINT(
- "NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
- FileHandle,
- IoStatusBlock,
- FileInformation,
- Length,
- FileInformationClass
- );
-
- /* Get the file object from the file handle */
- Status = ObReferenceObjectByHandle(
- FileHandle,
- FILE_WRITE_ATTRIBUTES,
- IoFileObjectType,
- UserMode,
- (PVOID *) & FileObject,
- NULL
- );
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
- DPRINT("FileObject %x\n", FileObject);
-
- /*
- * Initialize an event object to wait
- * on for the request.
- */
- KeInitializeEvent(
- & Event,
- NotificationEvent,
- FALSE
- );
- /*
- * Build the IRP to be sent to the driver
- * for the request.
- */
- Irp = IoBuildSynchronousFsdRequest(
- IRP_MJ_SET_INFORMATION,
- FileObject->DeviceObject,
- FileInformation,
- Length,
- 0,
- & Event,
- IoStatusBlock
- );
-
- StackPtr = IoGetNextIrpStackLocation(Irp);
- StackPtr->FileObject = FileObject;
- StackPtr->Parameters.SetFile.Length = Length;
- StackPtr->Parameters.SetFile.FileInformationClass =
- FileInformationClass;
-
- /*
- * Pass the IRP to the FSD (and wait for
- * it if required)
- */
- DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject);
- Status = IoCallDriver(
- FileObject->DeviceObject,
- Irp
- );
- if ( (Status == STATUS_PENDING)
- && (FileObject->Flags & FO_SYNCHRONOUS_IO)
- )
- {
- KeWaitForSingleObject(
- & Event,
- Executive,
- KernelMode,
- FALSE,
- NULL
- );
- Status = Irp->IoStatus.Status;
- }
-
return Status;
+ }
+
+ DPRINT("FileObject %x\n", FileObject);
+
+ /*
+ * Initialize an event object to wait
+ * on for the request.
+ */
+ KeInitializeEvent(&Event,
+ NotificationEvent,
+ FALSE);
+
+ DeviceObject = FileObject->DeviceObject;
+
+ Irp = IoAllocateIrp(DeviceObject->StackSize,
+ TRUE);
+ if (Irp == NULL)
+ {
+ ObDereferenceObject(FileObject);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ SystemBuffer = ExAllocatePoolWithTag(NonPagedPool,
+ Length,
+ TAG_SYSB);
+ if (SystemBuffer == NULL)
+ {
+ IoFreeIrp(Irp);
+ ObDereferenceObject(FileObject);
+ return(STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ MmSafeCopyFromUser(SystemBuffer,
+ FileInformation,
+ Length);
+
+ Irp->AssociatedIrp.SystemBuffer = SystemBuffer;
+ Irp->UserIosb = IoStatusBlock;
+ Irp->UserEvent = &Event;
+
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->MajorFunction = IRP_MJ_SET_INFORMATION;
+ StackPtr->MinorFunction = 0;
+ StackPtr->Flags = 0;
+ StackPtr->Control = 0;
+ StackPtr->DeviceObject = DeviceObject;
+ StackPtr->FileObject = FileObject;
+
+ StackPtr->Parameters.SetFile.FileInformationClass =
+ FileInformationClass;
+ StackPtr->Parameters.SetFile.Length = Length;
+
+ /*
+ * Pass the IRP to the FSD (and wait for
+ * it if required)
+ */
+ DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject);
+ Status = IoCallDriver(FileObject->DeviceObject,
+ Irp);
+ if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO))
+ {
+ KeWaitForSingleObject(&Event,
+ Executive,
+ KernelMode,
+ FALSE,
+ NULL);
+ Status = Irp->IoStatus.Status;
+ }
+
+ ExFreePool(SystemBuffer);
+ ObDereferenceObject(FileObject);
+
+ return Status;
}
-NTSTATUS
-STDCALL
-NtQueryAttributesFile (
- IN POBJECT_ATTRIBUTES ObjectAttributes,
- IN PVOID Buffer
- )
+NTSTATUS STDCALL
+NtQueryAttributesFile(IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN PVOID Buffer)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS
-STDCALL
-NtQueryFullAttributesFile (
- IN HANDLE FileHandle,
- IN PVOID Attributes
- )
+NTSTATUS STDCALL
+NtQueryFullAttributesFile(IN HANDLE FileHandle,
+ IN PVOID Attributes)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
}
-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)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
}
-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,
+ IN PVOID EaBuffer,
+ IN ULONG EaBufferSize)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
}
-
/* EOF */
-/* $Id: vpb.c,v 1.12 2001/06/11 19:48:58 ekohl Exp $
+/* $Id: vpb.c,v 1.13 2001/06/12 12:30:36 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
NTSTATUS STDCALL
NtQueryVolumeInformationFile(IN HANDLE FileHandle,
OUT PIO_STATUS_BLOCK IoStatusBlock,
- OUT PVOID FSInformation,
+ OUT PVOID FsInformation,
IN ULONG Length,
- IN FS_INFORMATION_CLASS FSInformationClass)
+ IN FS_INFORMATION_CLASS FsInformationClass)
/*
* FUNCTION: Queries the volume information
* ARGUMENTS:
* FileHandle = Handle to a file object on the target volume
* ReturnLength = DataWritten
- * FSInformation = Caller should supply storage for the information
+ * FsInformation = Caller should supply storage for the information
* structure.
* Length = Size of the information structure
- * FSInformationClass = Index to a information structure
+ * FsInformationClass = Index to a information structure
*
* FileFsVolumeInformation FILE_FS_VOLUME_INFORMATION
* FileFsLabelInformation FILE_FS_LABEL_INFORMATION
NTSTATUS Status;
PIO_STACK_LOCATION StackPtr;
PVOID SystemBuffer;
-
- DPRINT("FSInformation %p\n", FSInformation);
-
+
+ assert(IoStatusBlock != NULL);
+ assert(FsInformation != NULL);
+
+ DPRINT("FsInformation %p\n", FsInformation);
+
Status = ObReferenceObjectByHandle(FileHandle,
FILE_READ_ATTRIBUTES,
NULL,
StackPtr->FileObject = FileObject;
StackPtr->Parameters.QueryVolume.Length = Length;
StackPtr->Parameters.QueryVolume.FsInformationClass =
- FSInformationClass;
+ FsInformationClass;
Status = IoCallDriver(DeviceObject,
Irp);
NULL);
Status = IoStatusBlock->Status;
}
+ DPRINT("Status %x\n", Status);
- MmSafeCopyToUser(FSInformation,
- SystemBuffer,
- Length);
+ if (NT_SUCCESS(Status))
+ {
+ DPRINT("Information %lu\n", IoStatusBlock->Information);
+ MmSafeCopyToUser(FsInformation,
+ SystemBuffer,
+ IoStatusBlock->Information);
+ }
ExFreePool(SystemBuffer);
+ ObDereferenceObject(FileObject);
return(Status);
}
OUT PVOID FsInformation,
OUT PULONG ReturnedLength)
{
- UNIMPLEMENTED;
- return(STATUS_NOT_IMPLEMENTED);
+ IO_STATUS_BLOCK IoStatusBlock;
+ PIO_STACK_LOCATION StackPtr;
+ PDEVICE_OBJECT DeviceObject;
+ PIRP Irp;
+ KEVENT Event;
+ NTSTATUS Status;
+
+ assert(FsInformation != NULL);
+
+ DPRINT("FsInformation %p\n", FsInformation);
+
+ Status = ObReferenceObjectByPointer(FileObject,
+ FILE_READ_ATTRIBUTES,
+ IoFileObjectType,
+ KernelMode);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ DeviceObject = FileObject->DeviceObject;
+
+ KeInitializeEvent(&Event,
+ NotificationEvent,
+ FALSE);
+
+ Irp = IoAllocateIrp(DeviceObject->StackSize,
+ TRUE);
+ if (Irp == NULL)
+ {
+ ObDereferenceObject(FileObject);
+ return(STATUS_INSUFFICIENT_RESOURCES);
+ }
+
+ Irp->AssociatedIrp.SystemBuffer = FsInformation;
+ Irp->UserEvent = &Event;
+ Irp->UserIosb = &IoStatusBlock;
+
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->MajorFunction = IRP_MJ_QUERY_VOLUME_INFORMATION;
+ StackPtr->MinorFunction = 0;
+ StackPtr->Flags = 0;
+ StackPtr->Control = 0;
+ StackPtr->DeviceObject = DeviceObject;
+ StackPtr->FileObject = FileObject;
+ StackPtr->Parameters.QueryVolume.Length = Length;
+ StackPtr->Parameters.QueryVolume.FsInformationClass =
+ FsInformationClass;
+
+ Status = IoCallDriver(DeviceObject,
+ Irp);
+ if (Status == STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event,
+ UserRequest,
+ KernelMode,
+ FALSE,
+ NULL);
+ Status = IoStatusBlock.Status;
+ }
+ DPRINT("Status %x\n", Status);
+
+ if (ReturnedLength != NULL)
+ {
+ *ReturnedLength = IoStatusBlock.Information;
+ }
+ ObDereferenceObject(FileObject);
+
+ return(Status);
}
-/* $Id: loader.c,v 1.81 2001/06/04 11:26:12 chorns Exp $
+/* $Id: loader.c,v 1.82 2001/06/12 12:31:28 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
}
}
-VOID LdrpLoadModuleSymbols(
- PMODULE_OBJECT ModuleObject)
+VOID
+LdrpLoadModuleSymbols(PMODULE_OBJECT ModuleObject)
{
FILE_STANDARD_INFORMATION FileStdInfo;
OBJECT_ATTRIBUTES ObjectAttributes;
PVOID FileBuffer;
NTSTATUS Status;
ULONG Length;
+ IO_STATUS_BLOCK IoStatusBlock;
/* Get the path to the symbol store */
wcscpy(TmpFileName, L"\\SystemRoot\\symbols\\");
Status = ZwOpenFile(&FileHandle,
FILE_ALL_ACCESS,
&ObjectAttributes,
- NULL, 0, 0);
+ &IoStatusBlock,
+ 0,
+ 0);
if (!NT_SUCCESS(Status))
{
DPRINT("Could not open symbol file: %wZ\n", &Filename);
/* Get the size of the file */
Status = ZwQueryInformationFile(FileHandle,
- NULL,
+ &IoStatusBlock,
&FileStdInfo,
sizeof(FileStdInfo),
FileStandardInformation);
}
/* Load file into memory chunk */
- Status = ZwReadFile(FileHandle,
- 0, 0, 0, 0,
- FileBuffer,
- FileStdInfo.EndOfFile.u.LowPart,
+ Status = ZwReadFile(FileHandle,
+ 0, 0, 0,
+ &IoStatusBlock,
+ FileBuffer,
+ FileStdInfo.EndOfFile.u.LowPart,
0, 0);
if (!NT_SUCCESS(Status))
{
PVOID FileBuffer;
NTSTATUS Status;
ULONG Length;
+ IO_STATUS_BLOCK IoStatusBlock;
/* Get the path to the symbol store */
wcscpy(TmpFileName, L"\\SystemRoot\\symbols\\");
Status = ZwOpenFile(&FileHandle,
FILE_ALL_ACCESS,
&ObjectAttributes,
- NULL, 0, 0);
+ &IoStatusBlock,
+ 0,
+ 0);
if (!NT_SUCCESS(Status))
{
DPRINT("Could not open symbol file: %wZ\n", &Filename);
/* Get the size of the file */
Status = ZwQueryInformationFile(FileHandle,
- NULL,
+ &IoStatusBlock,
&FileStdInfo,
sizeof(FileStdInfo),
FileStandardInformation);
}
/* Load file into memory chunk */
- Status = ZwReadFile(FileHandle,
- 0, 0, 0, 0,
- FileBuffer,
- FileStdInfo.EndOfFile.u.LowPart,
+ Status = ZwReadFile(FileHandle,
+ 0, 0, 0,
+ &IoStatusBlock,
+ FileBuffer,
+ FileStdInfo.EndOfFile.u.LowPart,
0, 0);
if (!NT_SUCCESS(Status))
{
OBJECT_ATTRIBUTES ObjectAttributes;
PMODULE_OBJECT ModuleObject;
FILE_STANDARD_INFORMATION FileStdInfo;
+ IO_STATUS_BLOCK IoStatusBlock;
/* Check for module already loaded */
if ((ModuleObject = LdrOpenModule(Filename)) != NULL)
Status = NtOpenFile(&FileHandle,
FILE_ALL_ACCESS,
&ObjectAttributes,
- NULL, 0, 0);
+ &IoStatusBlock,
+ 0,
+ 0);
CHECKPOINT;
if (!NT_SUCCESS(Status))
{
/* Get the size of the file */
Status = NtQueryInformationFile(FileHandle,
- NULL,
+ &IoStatusBlock,
&FileStdInfo,
sizeof(FileStdInfo),
FileStandardInformation);
CHECKPOINT;
/* Load driver into memory chunk */
- Status = NtReadFile(FileHandle,
- 0, 0, 0, 0,
- ModuleLoadBase,
- FileStdInfo.EndOfFile.u.LowPart,
+ Status = NtReadFile(FileHandle,
+ 0, 0, 0,
+ &IoStatusBlock,
+ ModuleLoadBase,
+ FileStdInfo.EndOfFile.u.LowPart,
0, 0);
if (!NT_SUCCESS(Status))
{
-/* $Id: namespc.c,v 1.23 2001/05/05 09:33:16 ekohl Exp $
+/* $Id: namespc.c,v 1.24 2001/06/12 12:32:11 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FUNCTION: Initialize the object manager namespace
*/
{
- ANSI_STRING AnsiString;
-
ObDirectoryType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
ObDirectoryType->Tag = TAG('D', 'I', 'R', 'T');
ObDirectoryType->OkayToClose = NULL;
ObDirectoryType->Create = ObpCreateDirectory;
- RtlInitAnsiString(&AnsiString,"Directory");
- RtlAnsiStringToUnicodeString(&ObDirectoryType->TypeName,
- &AnsiString,TRUE);
+ RtlInitUnicodeString(&ObDirectoryType->TypeName,
+ L"Directory");
NameSpaceRoot = ObCreateObject(NULL,
STANDARD_RIGHTS_REQUIRED,