852 lines
26 KiB
C
852 lines
26 KiB
C
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Copyright (C) 1992, Microsoft Corporation.
|
|||
|
//
|
|||
|
// File: logroot.c
|
|||
|
//
|
|||
|
// Contents: This module implements the logical root handling functions.
|
|||
|
//
|
|||
|
// Functions: DfsInitializeLogicalRoot -
|
|||
|
// DfsDeleteLogicalRoot -
|
|||
|
// DfspLogRootNameToPath -
|
|||
|
//
|
|||
|
// History: 14-June-1994 SudK Created (Most stuff moved from Dsinit.c)
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
|
|||
|
#include "dfsprocs.h"
|
|||
|
#include "creds.h"
|
|||
|
#include "dnr.h"
|
|||
|
#include "fcbsup.h"
|
|||
|
|
|||
|
#define Dbg DEBUG_TRACE_LOGROOT
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsDefineDosDevice(
|
|||
|
IN WCHAR Device,
|
|||
|
IN PUNICODE_STRING Target);
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsUndefineDosDevice(
|
|||
|
IN WCHAR Device);
|
|||
|
|
|||
|
#ifdef ALLOC_PRAGMA
|
|||
|
|
|||
|
#pragma alloc_text( PAGE, DfsFindLogicalRoot )
|
|||
|
#pragma alloc_text( PAGE, DfsInitializeLogicalRoot )
|
|||
|
#pragma alloc_text( PAGE, DfsDeleteLogicalRoot )
|
|||
|
#pragma alloc_text( PAGE, DfspLogRootNameToPath )
|
|||
|
#pragma alloc_text( PAGE, DfsGetResourceFromVcb )
|
|||
|
#pragma alloc_text( PAGE, DfsGetResourceFromCredentials )
|
|||
|
#pragma alloc_text( PAGE, DfsLogicalRootExists )
|
|||
|
|
|||
|
#endif
|
|||
|
|
|||
|
|
|||
|
//+-------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsFindLogicalRoot, local
|
|||
|
//
|
|||
|
// Synopsis: DfsFindLogicalRoot takes as input a DS path name in
|
|||
|
// the standard form (root:\file\path\name), looks up
|
|||
|
// the DFS_VCB associated with the logical root, and returns
|
|||
|
// a string pointing to beyond the logical root part
|
|||
|
// of the input string.
|
|||
|
//
|
|||
|
// Arguments: [PrefixPath] -- Input path name
|
|||
|
// [Vcb] -- Returns DFS_VCB which corresponds to logical root
|
|||
|
// in PrefixPath
|
|||
|
// [RemainingPath] -- Returns with portion of PrefixPath
|
|||
|
// after the logical root name and colon
|
|||
|
//
|
|||
|
// Returns: NTSTATUS:
|
|||
|
// STATUS_SUCCESS if Vcb found
|
|||
|
// STATUS_OBJECT_PATH_SYNTAX_BAD - no logical root name
|
|||
|
// STATUS_NO_SUCH_DEVICE - logical root name not found
|
|||
|
//
|
|||
|
//--------------------------------------------------------------------------
|
|||
|
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsFindLogicalRoot(
|
|||
|
IN PUNICODE_STRING PrefixPath,
|
|||
|
OUT PDFS_VCB *Vcb,
|
|||
|
OUT PUNICODE_STRING RemainingPath
|
|||
|
) {
|
|||
|
PLIST_ENTRY Link;
|
|||
|
unsigned int i;
|
|||
|
NTSTATUS Status = STATUS_SUCCESS;
|
|||
|
NETRESOURCE testnt;
|
|||
|
|
|||
|
DfsDbgTrace(+1, Dbg, "DfsFindLogicalRoot...\n", 0);
|
|||
|
|
|||
|
*RemainingPath = *PrefixPath;
|
|||
|
|
|||
|
for (i = 0; i < RemainingPath->Length/sizeof(WCHAR); i++) {
|
|||
|
if ((RemainingPath->Buffer[i] == (WCHAR)':') ||
|
|||
|
(RemainingPath->Buffer[i] == UNICODE_PATH_SEP))
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
if ((i*sizeof(WCHAR) >= RemainingPath->Length) ||
|
|||
|
(RemainingPath->Buffer[i] == UNICODE_PATH_SEP)) {
|
|||
|
Status = STATUS_OBJECT_PATH_SYNTAX_BAD;
|
|||
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", Status);
|
|||
|
return(Status);
|
|||
|
}
|
|||
|
|
|||
|
RemainingPath->Length = i * sizeof (WCHAR);
|
|||
|
|
|||
|
//
|
|||
|
// Search for the logical root in all known DFS_VCBs
|
|||
|
//
|
|||
|
|
|||
|
ExAcquireResourceShared(&DfsData.Resource, TRUE);
|
|||
|
for ( Link = DfsData.VcbQueue.Flink;
|
|||
|
Link != &DfsData.VcbQueue;
|
|||
|
Link = Link->Flink ) {
|
|||
|
*Vcb = CONTAINING_RECORD( Link, DFS_VCB, VcbLinks );
|
|||
|
if (RtlEqualString( (PSTRING)&(*Vcb)->LogicalRoot,
|
|||
|
(PSTRING)RemainingPath, (BOOLEAN)TRUE) ) {
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
if (Link == &DfsData.VcbQueue) {
|
|||
|
Status = STATUS_NO_SUCH_DEVICE;
|
|||
|
ExReleaseResource(&DfsData.Resource);
|
|||
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", Status);
|
|||
|
return(Status);
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Adjust remaining path to point beyond the logical root name
|
|||
|
//
|
|||
|
|
|||
|
RemainingPath->Buffer = (WCHAR*)((char*) (RemainingPath->Buffer) +
|
|||
|
RemainingPath->Length + sizeof (WCHAR) );
|
|||
|
RemainingPath->Length = PrefixPath->Length -
|
|||
|
(RemainingPath->Length + sizeof (WCHAR));
|
|||
|
|
|||
|
if (RemainingPath->Length <= 0 ||
|
|||
|
RemainingPath->Buffer[0] != UNICODE_PATH_SEP) {
|
|||
|
Status = STATUS_OBJECT_PATH_SYNTAX_BAD;
|
|||
|
ExReleaseResource(&DfsData.Resource);
|
|||
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", Status);
|
|||
|
return(Status);
|
|||
|
}
|
|||
|
|
|||
|
ExReleaseResource(&DfsData.Resource);
|
|||
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", Status);
|
|||
|
return(Status);
|
|||
|
}
|
|||
|
|
|||
|
//+-------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsInitializeLogicalRoot, public
|
|||
|
//
|
|||
|
// Synopsis: Allocate and initialize storage for a logical root.
|
|||
|
// This includes creating a device object and DFS_VCB for it.
|
|||
|
//
|
|||
|
// Effects: A logical root device object is created. A corresponding
|
|||
|
// DFS_VCB is also created and linked into the list of known
|
|||
|
// DFS_VCBs.
|
|||
|
//
|
|||
|
// Arguments: [Name] -- name of logical root.
|
|||
|
// [Prefix] -- Prefix to be prepended to file names opened
|
|||
|
// via the logical root being created before
|
|||
|
// they can be resolved in the DFS name space.
|
|||
|
// [Credentials] -- The credentials to use when accessing files
|
|||
|
// via this logical root.
|
|||
|
// [VcbFlags] -- To be OR'd into the VcbState field of the
|
|||
|
// DFS_VCB of the newly created logical root device.
|
|||
|
//
|
|||
|
// Requires: DfsData must first be set up. Also an EXCLUSIVE LOCK on
|
|||
|
// DfsData.Resource must be acquired.
|
|||
|
//
|
|||
|
// Returns: NTSTATUS - STATUS_SUCCESS unless there is some problem.
|
|||
|
//
|
|||
|
// History: 25 Jan 1992 alanw created
|
|||
|
//
|
|||
|
//--------------------------------------------------------------------------
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsInitializeLogicalRoot(
|
|||
|
IN LPCWSTR Name,
|
|||
|
IN PUNICODE_STRING Prefix OPTIONAL,
|
|||
|
IN PDFS_CREDENTIALS Credentials OPTIONAL,
|
|||
|
IN USHORT VcbFlags
|
|||
|
) {
|
|||
|
UNICODE_STRING UnicodeString = DfsData.LogRootDevName;
|
|||
|
UNICODE_STRING LogRootPrefix;
|
|||
|
UNICODE_STRING RootName, RemainingPath;
|
|||
|
PDFS_VCB Vcb;
|
|||
|
WCHAR RootBuffer[MAX_LOGICAL_ROOT_LEN];
|
|||
|
|
|||
|
LPCWSTR pstr = Name;
|
|||
|
PWSTR pdst;
|
|||
|
PLOGICAL_ROOT_DEVICE_OBJECT DeviceObject = NULL;
|
|||
|
NTSTATUS Status;
|
|||
|
|
|||
|
DfsDbgTrace(0, Dbg, "DfsInitializeLogicalRoot -> %ws\n", Name);
|
|||
|
DfsDbgTrace(0, Dbg, "DfsInitializeLogicalRoot -> %wZ\n", Prefix);
|
|||
|
|
|||
|
//
|
|||
|
// First, see if a logical root by the given name already exists
|
|||
|
//
|
|||
|
|
|||
|
ASSERT(ARGUMENT_PRESENT(Name));
|
|||
|
RootName.Buffer = RootBuffer;
|
|||
|
RootName.MaximumLength = sizeof(RootBuffer);
|
|||
|
Status = DfspLogRootNameToPath(Name, &RootName);
|
|||
|
if (!NT_SUCCESS(Status)) {
|
|||
|
return(Status);
|
|||
|
}
|
|||
|
|
|||
|
Status = DfsFindLogicalRoot(&RootName, &Vcb, &RemainingPath);
|
|||
|
ASSERT(Status != STATUS_OBJECT_PATH_SYNTAX_BAD);
|
|||
|
if (Status != STATUS_NO_SUCH_DEVICE) {
|
|||
|
return(STATUS_OBJECT_NAME_COLLISION);
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// DfsData.LogRootDevName is initialized to be L"\Device\WinDfs\"
|
|||
|
// Here, we tack on the name of the Logical root we are creating
|
|||
|
// to the above string, so that the string becomes, for example,
|
|||
|
// L"\Device\WinDfs\Root". Note that at this point, we are scribbling
|
|||
|
// into the buffer belonging to DfsData.LogRootDevName, but this
|
|||
|
// should be ok, since we are not changing the Length field of that
|
|||
|
// Unicode string! BTW, we need a string of this form to create the
|
|||
|
// device object.
|
|||
|
//
|
|||
|
|
|||
|
pdst = &UnicodeString.Buffer[UnicodeString.Length/sizeof (WCHAR)];
|
|||
|
while (*pstr != UNICODE_NULL) {
|
|||
|
*pdst++ = *pstr++;
|
|||
|
UnicodeString.Length += sizeof (WCHAR);
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Next, try to setup the Dos Device link
|
|||
|
//
|
|||
|
if (Prefix) {
|
|||
|
Status = DfsDefineDosDevice( Name[0], &UnicodeString );
|
|||
|
if (!NT_SUCCESS(Status)) {
|
|||
|
return( Status );
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
//
|
|||
|
// Before we initialize the Vcb, we need to allocate space for the
|
|||
|
// Prefix. PagedPool should be fine here. We need to reallocate because
|
|||
|
// we will store this permanently in the DFS_VCB.
|
|||
|
//
|
|||
|
|
|||
|
if (Prefix && Prefix->Length > 0) {
|
|||
|
LogRootPrefix.Length = Prefix->Length;
|
|||
|
LogRootPrefix.MaximumLength = LogRootPrefix.Length + sizeof(WCHAR);
|
|||
|
LogRootPrefix.Buffer =
|
|||
|
ExAllocatePool(PagedPool, LogRootPrefix.MaximumLength);
|
|||
|
|
|||
|
if (LogRootPrefix.Buffer != NULL) {
|
|||
|
RtlMoveMemory(LogRootPrefix.Buffer,
|
|||
|
Prefix->Buffer,
|
|||
|
Prefix->MaximumLength);
|
|||
|
|
|||
|
LogRootPrefix.Buffer[Prefix->Length/sizeof(WCHAR)] = UNICODE_NULL;
|
|||
|
|
|||
|
} else {
|
|||
|
|
|||
|
//
|
|||
|
// Couldn't allocate memory! Ok to return with error code, since
|
|||
|
// we haven't changed the state of the IO subsystem yet.
|
|||
|
//
|
|||
|
|
|||
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|||
|
}
|
|||
|
} else {
|
|||
|
RtlInitUnicodeString(&LogRootPrefix, NULL);
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Create the device object for the logical root.
|
|||
|
//
|
|||
|
|
|||
|
Status = IoCreateDevice( DfsData.DriverObject,
|
|||
|
sizeof( LOGICAL_ROOT_DEVICE_OBJECT ) -
|
|||
|
sizeof( DEVICE_OBJECT ),
|
|||
|
&UnicodeString,
|
|||
|
FILE_DEVICE_DFS,
|
|||
|
FILE_REMOTE_DEVICE,
|
|||
|
FALSE,
|
|||
|
(PDEVICE_OBJECT *) &DeviceObject );
|
|||
|
|
|||
|
if ( !NT_SUCCESS( Status ) ) {
|
|||
|
if (LogRootPrefix.Buffer) {
|
|||
|
ExFreePool(LogRootPrefix.Buffer);
|
|||
|
}
|
|||
|
if (Prefix) {
|
|||
|
NTSTATUS DeleteStatus;
|
|||
|
|
|||
|
DeleteStatus = DfsUndefineDosDevice( Name[0] );
|
|||
|
|
|||
|
ASSERT(NT_SUCCESS(DeleteStatus));
|
|||
|
}
|
|||
|
return Status;
|
|||
|
}
|
|||
|
|
|||
|
DeviceObject->DeviceObject.StackSize = 5;
|
|||
|
|
|||
|
DfsInitializeVcb ( NULL,
|
|||
|
&DeviceObject->Vcb,
|
|||
|
&LogRootPrefix,
|
|||
|
Credentials,
|
|||
|
(PDEVICE_OBJECT)DeviceObject );
|
|||
|
|
|||
|
DeviceObject->Vcb.VcbState |= VcbFlags;
|
|||
|
|
|||
|
//
|
|||
|
// Save the logical root name in the DFS_VCB structure. Remember, above
|
|||
|
// we had UnicodeString to be of the form L"\Device\WinDfs\org". Now,
|
|||
|
// we adjust the buffer and length fields of UnicodeString so that
|
|||
|
// the Buffer points to the beginning of the L"org"; Then, we allocate
|
|||
|
// space for Vcb.LogicalRoot, and copy the name to it!
|
|||
|
//
|
|||
|
|
|||
|
UnicodeString.Buffer =
|
|||
|
&UnicodeString.Buffer[ DfsData.LogRootDevName.Length/sizeof (WCHAR) ];
|
|||
|
UnicodeString.Length -= DfsData.LogRootDevName.Length;
|
|||
|
UnicodeString.MaximumLength -= DfsData.LogRootDevName.Length;
|
|||
|
|
|||
|
DeviceObject->Vcb.LogicalRoot.Buffer = ExAllocatePool( PagedPool,
|
|||
|
UnicodeString.Length );
|
|||
|
DeviceObject->Vcb.LogicalRoot.Length =
|
|||
|
DeviceObject->Vcb.LogicalRoot.MaximumLength =
|
|||
|
UnicodeString.Length;
|
|||
|
RtlMoveMemory( DeviceObject->Vcb.LogicalRoot.Buffer,
|
|||
|
UnicodeString.Buffer, UnicodeString.Length );
|
|||
|
|
|||
|
//
|
|||
|
// This is not documented anywhere, but calling IoCreateDevice has set
|
|||
|
// the DO_DEVICE_INITIALIZING flag in DeviceObject->Flags. Normally,
|
|||
|
// device objects are created only at driver init time, and IoLoadDriver
|
|||
|
// will clear this bit for all device objects created at init time.
|
|||
|
// Since in Dfs, we need to create and delete devices on the fly (ie,
|
|||
|
// via FsCtl), we need to manually clear this bit.
|
|||
|
//
|
|||
|
|
|||
|
DeviceObject->DeviceObject.Flags &= ~DO_DEVICE_INITIALIZING;
|
|||
|
|
|||
|
return STATUS_SUCCESS;
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsDeleteLogicalRoot
|
|||
|
//
|
|||
|
// Synopsis: Removes a logical root if found and possible.
|
|||
|
//
|
|||
|
// Arguments: [Name] -- Name of the Logical Root
|
|||
|
// [fForce] -- Whether to Forcibly delete logical root inspite of
|
|||
|
// open files.
|
|||
|
//
|
|||
|
// Returns: STATUS_SUCCESS -- If successfully deleted logical root
|
|||
|
//
|
|||
|
// STATUS_NO_SUCH_DEVICE -- If there is no logical root to
|
|||
|
// delete.
|
|||
|
//
|
|||
|
// STATUS_DEVICE_BUSY -- If fForce is false and there are open
|
|||
|
// files via this logical root.
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsDeleteLogicalRoot(
|
|||
|
IN PWSTR Name,
|
|||
|
IN BOOLEAN fForce
|
|||
|
)
|
|||
|
{
|
|||
|
UNICODE_STRING RootName;
|
|||
|
UNICODE_STRING RemainingPath;
|
|||
|
WCHAR RootBuffer[MAX_LOGICAL_ROOT_LEN + 2];
|
|||
|
PDFS_PKT_ENTRY PktEntry;
|
|||
|
PDFS_VCB Vcb;
|
|||
|
NTSTATUS Status;
|
|||
|
PLOGICAL_ROOT_DEVICE_OBJECT DeviceObject;
|
|||
|
BOOLEAN pktLocked;
|
|||
|
|
|||
|
//
|
|||
|
// The 2 extra spots are for holding :\ to form a path out of a
|
|||
|
// root name; ie, to go from root to a root:\ form.
|
|||
|
//
|
|||
|
DfsDbgTrace(0, Dbg, "DfsDeleteLogicalRoot -> %ws\n", Name);
|
|||
|
DfsDbgTrace(0, Dbg, "DfsDeleteLogicalRoot -> %s\n", fForce ? "TRUE":"FALSE");
|
|||
|
|
|||
|
|
|||
|
//
|
|||
|
// First see if the logical root even exists.
|
|||
|
//
|
|||
|
|
|||
|
ASSERT(ARGUMENT_PRESENT(Name));
|
|||
|
|
|||
|
RootName.Buffer = RootBuffer;
|
|||
|
RootName.MaximumLength = sizeof(RootBuffer);
|
|||
|
|
|||
|
Status = DfspLogRootNameToPath(Name, &RootName);
|
|||
|
|
|||
|
if (!NT_SUCCESS(Status))
|
|||
|
return(Status);
|
|||
|
|
|||
|
//
|
|||
|
// Acquire Pkt and DfsData, wait till we do so.
|
|||
|
//
|
|||
|
|
|||
|
PktAcquireExclusive(TRUE, &pktLocked);
|
|||
|
|
|||
|
ExAcquireResourceExclusive(&DfsData.Resource, TRUE);
|
|||
|
|
|||
|
Status = DfsFindLogicalRoot(&RootName, &Vcb, &RemainingPath);
|
|||
|
|
|||
|
if (!NT_SUCCESS(Status)) {
|
|||
|
|
|||
|
goto Cleanup;
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Check to see if there are open files via this volume.
|
|||
|
//
|
|||
|
|
|||
|
if (!fForce &&
|
|||
|
((Vcb->DirectAccessOpenCount != 0) ||
|
|||
|
(Vcb->OpenFileCount != 0))) {
|
|||
|
|
|||
|
Status = STATUS_DEVICE_BUSY;
|
|||
|
|
|||
|
goto Cleanup;
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Delete the credentials used by this connection
|
|||
|
//
|
|||
|
|
|||
|
DfsDeleteCredentials( Vcb->Credentials );
|
|||
|
|
|||
|
//
|
|||
|
// Get rid of the Dos Device
|
|||
|
//
|
|||
|
|
|||
|
DfsUndefineDosDevice( Name[0] );
|
|||
|
|
|||
|
//
|
|||
|
// Now, get rid of the Device itself. This is a bit tricky, because there
|
|||
|
// might be files open on this device. So, we reference the device and
|
|||
|
// call ObMakeTemporaryObject. This causes the object to be removed from
|
|||
|
// the NT Object table, but, since atleast our reference is active,
|
|||
|
// prevents the object from being freed. Then, we insert this object into
|
|||
|
// our DeletedVcb list. The timer routine will periodically wake up and
|
|||
|
// see if all references to this device have been released, at which
|
|||
|
// point the device will be finally freed.
|
|||
|
//
|
|||
|
|
|||
|
RemoveEntryList(&Vcb->VcbLinks);
|
|||
|
|
|||
|
InsertTailList( &DfsData.DeletedVcbQueue, &Vcb->VcbLinks );
|
|||
|
|
|||
|
DeviceObject = CONTAINING_RECORD( Vcb, LOGICAL_ROOT_DEVICE_OBJECT, Vcb);
|
|||
|
|
|||
|
ObReferenceObjectByPointer( DeviceObject, 0, NULL, KernelMode );
|
|||
|
|
|||
|
ObMakeTemporaryObject((PVOID) DeviceObject);
|
|||
|
|
|||
|
DeviceObject->DeviceObject.Flags &= ~DO_DEVICE_HAS_NAME;
|
|||
|
|
|||
|
Cleanup:
|
|||
|
|
|||
|
ExReleaseResource(&DfsData.Resource);
|
|||
|
|
|||
|
PktRelease();
|
|||
|
|
|||
|
return(Status);
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfspLogRootNameToPath
|
|||
|
//
|
|||
|
// Synopsis: Amazingly enough, all it does it takes a PWSTR, copies it into
|
|||
|
// a Unicode string's buffer, and appends a \ to the tail of the
|
|||
|
// buffer, thus making a path out of a Logical root name.
|
|||
|
//
|
|||
|
// Arguments: [Name] -- Name of logical root, like L"org"
|
|||
|
// [RootName] -- Destination for L"org\\"
|
|||
|
//
|
|||
|
// Returns: STATUS_BUFFER_OVERFLOW, STATUS_SUCCESS
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfspLogRootNameToPath(
|
|||
|
IN LPCWSTR Name,
|
|||
|
OUT PUNICODE_STRING RootName
|
|||
|
)
|
|||
|
{
|
|||
|
unsigned short i, nMaxNameLen;
|
|||
|
|
|||
|
//
|
|||
|
// The two extra spots are required to append a ":\" after the root name.
|
|||
|
//
|
|||
|
nMaxNameLen = (RootName->MaximumLength/sizeof(WCHAR)) - 2;
|
|||
|
|
|||
|
//
|
|||
|
// Copy the name
|
|||
|
//
|
|||
|
for (i = 0; Name[i] != UNICODE_NULL && i < nMaxNameLen; i++) {
|
|||
|
RootName->Buffer[i] = Name[i];
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Make sure entire name was copied before we ran out of space
|
|||
|
//
|
|||
|
if (Name[i] != UNICODE_NULL) {
|
|||
|
//
|
|||
|
// Someone sent in a name bigger than allowed.
|
|||
|
//
|
|||
|
return(STATUS_BUFFER_OVERFLOW);
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Append the ":\" to form a path
|
|||
|
//
|
|||
|
RootName->Length = i * sizeof(WCHAR);
|
|||
|
return(RtlAppendUnicodeToString(RootName, L":\\"));
|
|||
|
}
|
|||
|
|
|||
|
#define PackMem(buf, str, len, pulen) { \
|
|||
|
ASSERT(*(pulen) >= (len)); \
|
|||
|
RtlMoveMemory((buf) + *(pulen) - (len), (str), (len)); \
|
|||
|
*(pulen) -= (len); \
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetResourceFromVcb
|
|||
|
//
|
|||
|
// Synopsis: Given a DFS_VCB it constructs a NETRESOURCE struct into the buffer
|
|||
|
// passed in. At the same time it uses the end of the buffer to
|
|||
|
// fill in a string. If the buffer is insufficient in size the
|
|||
|
// required size is returned in "pulen". If everything succeeds
|
|||
|
// then the pulen arg is decremented to indicate remaining size
|
|||
|
// of buffer.
|
|||
|
//
|
|||
|
// Arguments: [Vcb] -- The source DFS_VCB
|
|||
|
// [ProviderName] -- Provider Name to stuff in the NETRESOURCE
|
|||
|
// [BufBegin] -- Start of actual buffer for computing offsets
|
|||
|
// [Buf] -- The NETRESOURCE structure to fill
|
|||
|
// [BufSize] -- On entry, size of buf. On return, contains
|
|||
|
// remaining size of buf.
|
|||
|
//
|
|||
|
// Returns: [STATUS_SUCCESS] -- Operation completed successfully.
|
|||
|
// [STATUS_BUFFER_OVERFLOW] -- buf is not big enough.
|
|||
|
//
|
|||
|
// Notes: This routine fills in a NETRESOURCE structure starting at
|
|||
|
// Buf. The strings in the NETRESOURCE are filled in starting
|
|||
|
// from the *end* (ie, starting at Buf + *BufSize)
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
NTSTATUS
|
|||
|
DfsGetResourceFromVcb(
|
|||
|
PDFS_VCB Vcb,
|
|||
|
PUNICODE_STRING ProviderName,
|
|||
|
PUCHAR BufBegin,
|
|||
|
PUCHAR Buf,
|
|||
|
PULONG BufSize
|
|||
|
)
|
|||
|
{
|
|||
|
LPNETRESOURCE netResource;
|
|||
|
ULONG sizeRequired = 0;
|
|||
|
WCHAR localDrive[ 3 ];
|
|||
|
|
|||
|
sizeRequired = sizeof(NETRESOURCE) +
|
|||
|
ProviderName->Length +
|
|||
|
sizeof(UNICODE_NULL) +
|
|||
|
3 * sizeof(WCHAR) + // lpLocalName D: etc.
|
|||
|
sizeof(UNICODE_PATH_SEP) +
|
|||
|
Vcb->LogRootPrefix.Length +
|
|||
|
sizeof(UNICODE_NULL);
|
|||
|
|
|||
|
if (*BufSize < sizeRequired) {
|
|||
|
*BufSize = sizeRequired;
|
|||
|
return(STATUS_BUFFER_OVERFLOW);
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Buffer is big enough, fill in the NETRESOURCE structure
|
|||
|
//
|
|||
|
|
|||
|
netResource = (LPNETRESOURCE) Buf;
|
|||
|
Buf += sizeof(NETRESOURCE);
|
|||
|
*BufSize -= sizeof(NETRESOURCE);
|
|||
|
|
|||
|
netResource->dwScope = RESOURCE_CONNECTED;
|
|||
|
netResource->dwType = RESOURCETYPE_DISK;
|
|||
|
netResource->dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
|
|||
|
netResource->dwUsage = RESOURCEUSAGE_CONNECTABLE;
|
|||
|
netResource->lpComment = NULL;
|
|||
|
|
|||
|
//
|
|||
|
// Fill in the provider name
|
|||
|
//
|
|||
|
|
|||
|
PackMem(Buf, L"", sizeof(L""), BufSize);
|
|||
|
PackMem(Buf, ProviderName->Buffer, ProviderName->Length, BufSize);
|
|||
|
netResource->lpProvider = (LPWSTR) (Buf + *BufSize - BufBegin);
|
|||
|
|
|||
|
//
|
|||
|
// Fill in the local name next
|
|||
|
//
|
|||
|
|
|||
|
localDrive[0] = Vcb->LogicalRoot.Buffer[0];
|
|||
|
localDrive[1] = UNICODE_DRIVE_SEP;
|
|||
|
localDrive[2] = UNICODE_NULL;
|
|||
|
|
|||
|
PackMem(Buf, localDrive, sizeof(localDrive), BufSize);
|
|||
|
netResource->lpLocalName = (LPWSTR) (Buf + *BufSize - BufBegin);
|
|||
|
|
|||
|
//
|
|||
|
// Fill in the remote name last
|
|||
|
//
|
|||
|
|
|||
|
PackMem(Buf, L"", sizeof(L""), BufSize);
|
|||
|
PackMem(Buf, Vcb->LogRootPrefix.Buffer, Vcb->LogRootPrefix.Length, BufSize);
|
|||
|
PackMem(Buf, UNICODE_PATH_SEP_STR, sizeof(UNICODE_PATH_SEP), BufSize);
|
|||
|
netResource->lpRemoteName = (LPWSTR) (Buf + *BufSize - BufBegin);
|
|||
|
|
|||
|
return(STATUS_SUCCESS);
|
|||
|
}
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetResourceFromCredentials
|
|||
|
//
|
|||
|
// Synopsis: Builds a NETRESOURCE structure for a device-less connection.
|
|||
|
// The LPWSTR members of NETRESOURCE actually contain offsets
|
|||
|
// from the BufBegin parameter.
|
|||
|
//
|
|||
|
// Arguments: [Creds] -- The source credentials
|
|||
|
// [ProviderName] -- Provider Name to stuff in the NETRESOURCE
|
|||
|
// [BufBegin] -- Start of actual buffer for computing offsets
|
|||
|
// [Buf] -- The NETRESOURCE structure to fill
|
|||
|
// [BufSize] -- On entry, size of buf. On return, contains
|
|||
|
// remaining size of buf.
|
|||
|
//
|
|||
|
// Returns: [STATUS_SUCCESS] -- Operation completed successfully.
|
|||
|
// [STATUS_BUFFER_OVERFLOW] -- buf is not big enough.
|
|||
|
//
|
|||
|
// Notes: This routine fills in a NETRESOURCE structure starting at
|
|||
|
// Buf. The strings in the NETRESOURCE are filled in starting
|
|||
|
// from the *end* (ie, starting at Buf + *BufSize)
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsGetResourceFromCredentials(
|
|||
|
PDFS_CREDENTIALS Creds,
|
|||
|
PUNICODE_STRING ProviderName,
|
|||
|
PUCHAR BufBegin,
|
|||
|
PUCHAR Buf,
|
|||
|
PULONG BufSize)
|
|||
|
{
|
|||
|
LPNETRESOURCE netResource = (LPNETRESOURCE) Buf;
|
|||
|
ULONG sizeRequired;
|
|||
|
|
|||
|
sizeRequired = sizeof(NETRESOURCE) +
|
|||
|
ProviderName->Length +
|
|||
|
sizeof(UNICODE_NULL) +
|
|||
|
2 * sizeof(UNICODE_PATH_SEP) +
|
|||
|
Creds->ServerName.Length +
|
|||
|
sizeof(UNICODE_PATH_SEP) +
|
|||
|
Creds->ShareName.Length +
|
|||
|
sizeof(UNICODE_NULL);
|
|||
|
|
|||
|
if (*BufSize < sizeRequired) {
|
|||
|
*BufSize = sizeRequired;
|
|||
|
return(STATUS_BUFFER_OVERFLOW);
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Buffer is big enough, fill in the NETRESOURCE structure
|
|||
|
//
|
|||
|
|
|||
|
Buf += sizeof(NETRESOURCE); // Start of string area
|
|||
|
*BufSize -= sizeof(NETRESOURCE);
|
|||
|
|
|||
|
netResource->dwScope = RESOURCE_CONNECTED;
|
|||
|
netResource->dwType = RESOURCETYPE_DISK;
|
|||
|
netResource->dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
|
|||
|
netResource->dwUsage = RESOURCEUSAGE_CONNECTABLE;
|
|||
|
netResource->lpComment = NULL;
|
|||
|
|
|||
|
netResource->lpLocalName = NULL;
|
|||
|
|
|||
|
//
|
|||
|
// Fill in the provider name
|
|||
|
//
|
|||
|
|
|||
|
PackMem(Buf, L"", sizeof(L""), BufSize);
|
|||
|
PackMem(Buf, ProviderName->Buffer, ProviderName->Length, BufSize);
|
|||
|
netResource->lpProvider = (LPWSTR) (Buf + *BufSize - BufBegin);
|
|||
|
|
|||
|
//
|
|||
|
// Fill in the remote name last
|
|||
|
//
|
|||
|
|
|||
|
PackMem(Buf, L"", sizeof(L""), BufSize);
|
|||
|
PackMem(Buf, Creds->ShareName.Buffer, Creds->ShareName.Length, BufSize);
|
|||
|
PackMem(Buf, UNICODE_PATH_SEP_STR, sizeof(UNICODE_PATH_SEP), BufSize);
|
|||
|
PackMem(Buf, Creds->ServerName.Buffer, Creds->ServerName.Length, BufSize);
|
|||
|
PackMem(Buf, UNICODE_PATH_SEP_STR, sizeof(UNICODE_PATH_SEP), BufSize);
|
|||
|
PackMem(Buf, UNICODE_PATH_SEP_STR, sizeof(UNICODE_PATH_SEP), BufSize);
|
|||
|
netResource->lpRemoteName = (LPWSTR) (Buf + *BufSize - BufBegin);
|
|||
|
|
|||
|
return(STATUS_SUCCESS);
|
|||
|
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
|
|||
|
BOOLEAN
|
|||
|
DfsLogicalRootExists(PWSTR pwszName)
|
|||
|
{
|
|||
|
|
|||
|
UNICODE_STRING RootName;
|
|||
|
UNICODE_STRING RemainingPath;
|
|||
|
WCHAR RootBuffer[MAX_LOGICAL_ROOT_LEN + 2];
|
|||
|
PDFS_VCB Vcb;
|
|||
|
NTSTATUS Status;
|
|||
|
|
|||
|
ASSERT(ARGUMENT_PRESENT(pwszName));
|
|||
|
RootName.Buffer = RootBuffer;
|
|||
|
RootName.MaximumLength = sizeof(RootBuffer);
|
|||
|
|
|||
|
Status = DfspLogRootNameToPath(pwszName, &RootName);
|
|||
|
if (!NT_SUCCESS(Status)) {
|
|||
|
return(FALSE);
|
|||
|
}
|
|||
|
|
|||
|
Status = DfsFindLogicalRoot(&RootName, &Vcb, &RemainingPath);
|
|||
|
if (!NT_SUCCESS(Status)) {
|
|||
|
|
|||
|
//
|
|||
|
// If this asserts, we need to fix the code above that creates the
|
|||
|
// Logical Root name, or fix DfsFindLogicalRoot.
|
|||
|
//
|
|||
|
ASSERT(Status != STATUS_OBJECT_PATH_SYNTAX_BAD);
|
|||
|
return(FALSE);
|
|||
|
}
|
|||
|
else {
|
|||
|
return(TRUE);
|
|||
|
}
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsDefineDosDevice
|
|||
|
//
|
|||
|
// Synopsis: Creates a dos device to a logical root
|
|||
|
//
|
|||
|
// Arguments:
|
|||
|
//
|
|||
|
// Returns:
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsDefineDosDevice(
|
|||
|
IN WCHAR Device,
|
|||
|
IN PUNICODE_STRING Target)
|
|||
|
{
|
|||
|
NTSTATUS status;
|
|||
|
HANDLE device;
|
|||
|
OBJECT_ATTRIBUTES ob;
|
|||
|
UNICODE_STRING deviceName;
|
|||
|
|
|||
|
RtlInitUnicodeString( &deviceName, L"\\??\\X:" );
|
|||
|
|
|||
|
deviceName.Buffer[ deviceName.Length/sizeof(WCHAR) - 2] = Device;
|
|||
|
|
|||
|
InitializeObjectAttributes(
|
|||
|
&ob,
|
|||
|
&deviceName,
|
|||
|
OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
|
|||
|
NULL,
|
|||
|
NULL);
|
|||
|
|
|||
|
status = ZwCreateSymbolicLinkObject(
|
|||
|
&device,
|
|||
|
SYMBOLIC_LINK_ALL_ACCESS,
|
|||
|
&ob,
|
|||
|
Target);
|
|||
|
|
|||
|
if (NT_SUCCESS(status))
|
|||
|
ZwClose( device );
|
|||
|
|
|||
|
return( status );
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsUndefineDosDevice
|
|||
|
//
|
|||
|
// Synopsis: Undefines a dos device
|
|||
|
//
|
|||
|
// Arguments:
|
|||
|
//
|
|||
|
// Returns:
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
NTSTATUS
|
|||
|
DfsUndefineDosDevice(
|
|||
|
IN WCHAR Device)
|
|||
|
{
|
|||
|
|
|||
|
NTSTATUS status;
|
|||
|
HANDLE device;
|
|||
|
OBJECT_ATTRIBUTES ob;
|
|||
|
UNICODE_STRING deviceName;
|
|||
|
|
|||
|
RtlInitUnicodeString( &deviceName, L"\\??\\X:" );
|
|||
|
|
|||
|
deviceName.Buffer[ deviceName.Length/sizeof(WCHAR) - 2] = Device;
|
|||
|
|
|||
|
InitializeObjectAttributes(
|
|||
|
&ob,
|
|||
|
&deviceName,
|
|||
|
OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
|
|||
|
NULL,
|
|||
|
NULL);
|
|||
|
|
|||
|
status = ZwOpenSymbolicLinkObject(
|
|||
|
&device,
|
|||
|
SYMBOLIC_LINK_QUERY | DELETE,
|
|||
|
&ob);
|
|||
|
|
|||
|
if (NT_SUCCESS(status)) {
|
|||
|
|
|||
|
status = ZwMakeTemporaryObject( device );
|
|||
|
|
|||
|
ZwClose( device );
|
|||
|
|
|||
|
}
|
|||
|
|
|||
|
return( status );
|
|||
|
|
|||
|
}
|