Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-03 13:25:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/drivers/filesystems/npfs/main.c

387 lines
12 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS Named Pipe FileSystem
* LICENSE: BSD - See COPYING.ARM in the top level directory
* FILE: drivers/filesystems/npfs/main.c
* PURPOSE: Named Pipe FileSystem Driver Initialization
* PROGRAMMERS: ReactOS Portable Systems Group
*/
/* INCLUDES *******************************************************************/
#include "npfs.h"
// File ID number for NPFS bugchecking support
#define NPFS_BUGCHECK_FILE_ID (NPFS_BUGCHECK_MAIN)
/* GLOBALS ********************************************************************/
PDEVICE_OBJECT NpfsDeviceObject;
PVOID NpAliases;
PNPFS_ALIAS NpAliasList;
PNPFS_ALIAS NpAliasListByLength[MAX_INDEXED_LENGTH + 1 - MIN_INDEXED_LENGTH];
FAST_IO_DISPATCH NpFastIoDispatch =
{
sizeof(FAST_IO_DISPATCH),
NULL,
NpFastRead,
NpFastWrite,
};
/* FUNCTIONS ******************************************************************/
NTSTATUS
NTAPI
NpReadAlias(
PWSTR ValueName,
ULONG ValueType,
PVOID ValueData,
ULONG ValueLength,
PVOID Context,
PVOID EntryContext)
{
PNPFS_QUERY_VALUE_CONTEXT QueryContext = Context;
PWSTR CurrentString;
USHORT Length;
PNPFS_ALIAS CurrentAlias;
UNICODE_STRING TempString;
PUNICODE_STRING CurrentTargetName;
/* Check if we have the expected type */
if (ValueType != REG_MULTI_SZ)
{
return STATUS_INVALID_PARAMETER;
}
/* Check if only the size is requested */
if (QueryContext->SizeOnly)
{
/* Count this entry */
QueryContext->NumberOfEntries++;
/* Get the length of the value name (i.e. the target name). */
Length = wcslen(ValueName) * sizeof(WCHAR);
/* Add the size of the name plus a '\' and a UNICODE_STRING structure */
QueryContext->FullSize += Length + sizeof(UNICODE_NULL) +
sizeof(OBJ_NAME_PATH_SEPARATOR) +
sizeof(UNICODE_STRING);
/* Loop while we have alias names */
CurrentString = ValueData;
while (*CurrentString != UNICODE_NULL)
{
/* Count this alias */
QueryContext->NumberOfAliases++;
/* Get the length of the current string (i.e. the alias name) */
Length = wcslen(CurrentString) * sizeof(WCHAR);
/* Count the length plus the size of an NPFS_ALIAS structure */
QueryContext->FullSize += Length + sizeof(UNICODE_NULL) + sizeof(NPFS_ALIAS);
/* Go to the next string */
CurrentString += (Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR);
}
}
else
{
/* Get the next name string pointer */
CurrentTargetName = QueryContext->CurrentTargetName++;
/* Get the length of the value name (i.e. the target name). */
Length = wcslen(ValueName) * sizeof(WCHAR);
/* Initialize the current name string (one char more than the name) */
CurrentTargetName->Buffer = QueryContext->CurrentStringPointer;
CurrentTargetName->Length = Length + sizeof(OBJ_NAME_PATH_SEPARATOR);
CurrentTargetName->MaximumLength = CurrentTargetName->Length + sizeof(UNICODE_NULL);
/* Update the current string pointer */
QueryContext->CurrentStringPointer +=
CurrentTargetName->MaximumLength / sizeof(WCHAR);
/* Prepend a '\' before the name */
CurrentTargetName->Buffer[0] = OBJ_NAME_PATH_SEPARATOR;
/* Append the value name (including the NULL termination) */
RtlCopyMemory(&CurrentTargetName->Buffer[1],
ValueName,
Length + sizeof(UNICODE_NULL));
/* Upcase the target name */
RtlUpcaseUnicodeString(CurrentTargetName, CurrentTargetName, 0);
/* Loop while we have alias names */
CurrentString = ValueData;
while (*CurrentString != UNICODE_NULL)
{
/* Get the next alias pointer */
CurrentAlias = QueryContext->CurrentAlias++;
/* Get the length of the current string (i.e. the alias name) */
Length = wcslen(CurrentString) * sizeof(WCHAR);
/* Setup the alias structure */
CurrentAlias->TargetName = CurrentTargetName;
CurrentAlias->Name.Buffer = QueryContext->CurrentStringPointer;
CurrentAlias->Name.Length = Length;
CurrentAlias->Name.MaximumLength = Length + sizeof(UNICODE_NULL);
/* Upcase the alias name */
TempString.Buffer = CurrentString;
TempString.Length = Length;
RtlUpcaseUnicodeString(&CurrentAlias->Name,
&TempString,
FALSE);
/* Update the current string pointer */
QueryContext->CurrentStringPointer +=
CurrentAlias->Name.MaximumLength / sizeof(WCHAR);
/* Go to the next string */
CurrentString += (Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR);
}
}
return STATUS_SUCCESS;
}
LONG
NTAPI
NpCompareAliasNames(
_In_ PCUNICODE_STRING String1,
_In_ PCUNICODE_STRING String2)
{
ULONG Count;
PWCHAR P1, P2;
/* First check if the string sizes match */
if (String1->Length != String2->Length)
{
/* They don't, return positive if the first is longer, negative otherwise */
return String1->Length - String2->Length;
}
/* Now loop all characters */
Count = String1->Length / sizeof(WCHAR);
P1 = String1->Buffer;
P2 = String2->Buffer;
while (Count)
{
/* Check if they don't match */
if (*P1 != *P2)
{
/* Return positive if the first char is greater, negative otherwise */
return *P1 - *P2;
}
/* Go to the next buffer position */
P1++;
P2++;
Count--;
}
/* All characters matched, return 0 */
return 0;
}
NTSTATUS
NTAPI
NpInitializeAliases(VOID)
{
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
NPFS_QUERY_VALUE_CONTEXT Context;
NTSTATUS Status;
USHORT Length;
ULONG i;
PNPFS_ALIAS CurrentAlias, *AliasPointer;
/* Initialize the query table */
QueryTable[0].QueryRoutine = NpReadAlias;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_NOEXPAND;
QueryTable[0].Name = NULL;
QueryTable[0].EntryContext = NULL;
QueryTable[0].DefaultType = REG_NONE;
QueryTable[0].DefaultData = NULL;
QueryTable[0].DefaultLength = 0;
QueryTable[1].QueryRoutine = NULL;
QueryTable[1].Flags = 0;
QueryTable[1].Name = NULL;
/* Setup the query context */
Context.SizeOnly = 1;
Context.FullSize = 0;
Context.NumberOfAliases = 0;
Context.NumberOfEntries = 0;
/* Query the registry values (calculate length only) */
Status = RtlQueryRegistryValues(RTL_REGISTRY_SERVICES | RTL_REGISTRY_OPTIONAL,
L"Npfs\\Aliases",
QueryTable,
&Context,
NULL);
if (!NT_SUCCESS(Status))
{
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
return STATUS_SUCCESS;
return Status;
}
/* Check if there is anything */
if (Context.FullSize == 0)
{
/* Nothing to do, return success */
return STATUS_SUCCESS;
}
/* Allocate a structure large enough to hold all the data */
NpAliases = ExAllocatePoolWithTag(NonPagedPool, Context.FullSize, 'sfpN');
if (NpAliases == NULL)
return STATUS_INSUFFICIENT_RESOURCES;
/* Now setup the actual pointers in the context */
Context.CurrentTargetName = NpAliases;
CurrentAlias = (PNPFS_ALIAS)&Context.CurrentTargetName[Context.NumberOfEntries];
Context.CurrentAlias = CurrentAlias;
Context.CurrentStringPointer = (PWCHAR)&CurrentAlias[Context.NumberOfAliases];
/* This time query the real data */
Context.SizeOnly = FALSE;
Status = RtlQueryRegistryValues(RTL_REGISTRY_SERVICES | RTL_REGISTRY_OPTIONAL,
L"Npfs\\Aliases",
QueryTable,
&Context,
NULL);
if (!NT_SUCCESS(Status))
{
ExFreePoolWithTag(NpAliases, 0);
NpAliases = NULL;
return Status;
}
/* Make sure we didn't go past the end of the allocation! */
NT_ASSERT((PUCHAR)Context.CurrentStringPointer <=
((PUCHAR)NpAliases + Context.FullSize));
/* Loop all aliases we got */
for (i = 0; i < Context.NumberOfAliases; i++)
{
/* Get the length and check what list to use */
Length = CurrentAlias->Name.Length;
if ((Length >= MIN_INDEXED_LENGTH * sizeof(WCHAR)) &&
(Length <= MAX_INDEXED_LENGTH * sizeof(WCHAR)))
{
/* For this length range, we use an indexed list */
AliasPointer = &NpAliasListByLength[(Length / sizeof(WCHAR)) - 5];
}
else
{
/* Length is outside of the range, use the default list */
AliasPointer = &NpAliasList;
}
/* Loop through all aliases already in the list until we find one that
is greater than our current alias */
while ((*AliasPointer != NULL) &&
(NpCompareAliasNames(&CurrentAlias->Name,
&(*AliasPointer)->Name) > 0))
{
/* Go to the next alias */
AliasPointer = &(*AliasPointer)->Next;
}
/* Insert the alias in the list */
CurrentAlias->Next = *AliasPointer;
*AliasPointer = CurrentAlias;
/* Go to the next alias in the array */
CurrentAlias++;
}
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
NpFsdDirectoryControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
TRACE("Entered\n");
UNIMPLEMENTED;
Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName;
NTSTATUS Status;
UNREFERENCED_PARAMETER(RegistryPath);
DPRINT("Next-Generation NPFS-Advanced\n");
Status = NpInitializeAliases();
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to initialize aliases!\n");
return Status;
}
DriverObject->MajorFunction[IRP_MJ_CREATE] = NpFsdCreate;
DriverObject->MajorFunction[IRP_MJ_CREATE_NAMED_PIPE] = NpFsdCreateNamedPipe;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = NpFsdClose;
DriverObject->MajorFunction[IRP_MJ_READ] = NpFsdRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = NpFsdWrite;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = NpFsdQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = NpFsdSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = NpFsdQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = NpFsdCleanup;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = NpFsdFlushBuffers;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = NpFsdDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = NpFsdFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = NpFsdQuerySecurityInfo;
DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] = NpFsdSetSecurityInfo;
DriverObject->DriverUnload = NULL;
DriverObject->FastIoDispatch = &NpFastIoDispatch;
RtlInitUnicodeString(&DeviceName, L"\\Device\\NamedPipe");
Status = IoCreateDevice(DriverObject,
sizeof(NP_VCB),
&DeviceName,
FILE_DEVICE_NAMED_PIPE,
0,
FALSE,
&DeviceObject);
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to create named pipe device! (Status %lx)\n", Status);
return Status;
}
/* Initialize the device object */
NpfsDeviceObject = DeviceObject;
DeviceObject->Flags |= DO_LONG_TERM_REQUESTS;
/* Initialize the Volume Control Block (VCB) */
NpVcb = DeviceObject->DeviceExtension;
NpInitializeVcb();
Status = NpCreateRootDcb();
ASSERT(Status == STATUS_SUCCESS);
return STATUS_SUCCESS;
}
/* EOF */
Reference in a new issue View git blame Copy permalink