mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1602 lines
44 KiB
1602 lines
44 KiB
//+----------------------------------------------------------------------------
|
|
//
|
|
// 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"
|
|
|
|
#include <stdio.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, DfsGetResourceFromDevlessRoot )
|
|
#pragma alloc_text( PAGE, DfsLogicalRootExists )
|
|
|
|
#endif
|
|
|
|
#ifdef TERMSRV
|
|
|
|
//
|
|
// Maximum character string length of a session Id (decimal)
|
|
//
|
|
|
|
#define SESSIONID_MAX_LEN 10
|
|
|
|
//
|
|
// Maximum characters string length of a session ID [10] (decimal) or
|
|
// logon ID [16] (hex, base 16)
|
|
//
|
|
#define ID_MAX_LEN 16
|
|
|
|
#endif // TERMSRV
|
|
|
|
//
|
|
// Global that denotes whether LUID device maps are enabled
|
|
// TRUE - LUID device maps are enabled
|
|
// FALSE - LUID device maps are not enabled
|
|
// Defined in nt\base\fs\mup\dfsinit.c
|
|
//
|
|
extern BOOL DfsLUIDDeviceMapsEnabled;
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// 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
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
#ifdef TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsFindLogicalRoot(
|
|
IN PUNICODE_STRING PrefixPath,
|
|
IN ULONG SessionID,
|
|
IN PLUID LogonID,
|
|
OUT PDFS_VCB *Vcb,
|
|
OUT PUNICODE_STRING RemainingPath
|
|
)
|
|
|
|
#else // TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsFindLogicalRoot(
|
|
IN PUNICODE_STRING PrefixPath,
|
|
IN PLUID LogonID,
|
|
OUT PDFS_VCB *Vcb,
|
|
OUT PUNICODE_STRING RemainingPath
|
|
)
|
|
|
|
#endif // TERMSRV
|
|
{
|
|
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", ULongToPtr(Status) );
|
|
return(Status);
|
|
}
|
|
|
|
RemainingPath->Length = (USHORT)(i * sizeof (WCHAR));
|
|
|
|
//
|
|
// Search for the logical root in all known DFS_VCBs
|
|
//
|
|
|
|
ExAcquireResourceSharedLite(&DfsData.Resource, TRUE);
|
|
for ( Link = DfsData.VcbQueue.Flink;
|
|
Link != &DfsData.VcbQueue;
|
|
Link = Link->Flink ) {
|
|
|
|
*Vcb = CONTAINING_RECORD( Link, DFS_VCB, VcbLinks );
|
|
|
|
#ifdef TERMSRV
|
|
if ((SessionID == INVALID_SESSIONID) ||
|
|
(SessionID == (*Vcb)->SessionID)) {
|
|
#endif
|
|
if ( RtlEqualLuid(LogonID, &(*Vcb)->LogonID) ) {
|
|
if (RtlEqualString( (PSTRING)&(*Vcb)->LogicalRoot,
|
|
(PSTRING)RemainingPath, (BOOLEAN)TRUE) ) {
|
|
break;
|
|
}
|
|
}
|
|
#ifdef TERMSRV
|
|
}
|
|
#endif // TERMSRV
|
|
}
|
|
if (Link == &DfsData.VcbQueue) {
|
|
Status = STATUS_NO_SUCH_DEVICE;
|
|
ExReleaseResourceLite(&DfsData.Resource);
|
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(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;
|
|
ExReleaseResourceLite(&DfsData.Resource);
|
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(Status) );
|
|
return(Status);
|
|
}
|
|
|
|
ExReleaseResourceLite(&DfsData.Resource);
|
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(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
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#ifdef TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsInitializeLogicalRoot(
|
|
IN LPCWSTR Name,
|
|
IN PUNICODE_STRING Prefix OPTIONAL,
|
|
IN PDFS_CREDENTIALS Credentials OPTIONAL,
|
|
IN USHORT VcbFlags,
|
|
IN ULONG SessionID,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#else // TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsInitializeLogicalRoot(
|
|
IN LPCWSTR Name,
|
|
IN PUNICODE_STRING Prefix OPTIONAL,
|
|
IN PDFS_CREDENTIALS Credentials OPTIONAL,
|
|
IN USHORT VcbFlags,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
|
|
#endif // TERMSRV
|
|
{
|
|
UNICODE_STRING UnicodeString = DfsData.LogRootDevName;
|
|
UNICODE_STRING LogRootPrefix;
|
|
UNICODE_STRING RootName, RemainingPath;
|
|
UNICODE_STRING LogicalRoot;
|
|
|
|
#ifdef TERMSRV
|
|
|
|
//
|
|
// The SessionID suffix is :SessionID where SessionID is 10 digits max.
|
|
//
|
|
|
|
UNICODE_STRING DeviceString;
|
|
WCHAR DeviceBuffer[MAX_LOGICAL_ROOT_LEN + ID_MAX_LEN + sizeof(WCHAR)];
|
|
UNICODE_STRING IDString;
|
|
WCHAR IDBuffer[ID_MAX_LEN + 1]; // +1 for UNICODE_NULL
|
|
|
|
#endif // TERMSRV
|
|
|
|
WCHAR *TmpBuf;
|
|
PDFS_VCB Vcb;
|
|
WCHAR RootBuffer[MAX_LOGICAL_ROOT_LEN];
|
|
PDFS_PKT_ENTRY pktEntry = NULL;
|
|
|
|
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);
|
|
}
|
|
|
|
#ifdef TERMSRV
|
|
Status = DfsFindLogicalRoot(&RootName, SessionID, LogonID, &Vcb, &RemainingPath);
|
|
#else
|
|
Status = DfsFindLogicalRoot(&RootName, &Vcb, LogonID, &RemainingPath);
|
|
#endif
|
|
|
|
ASSERT(Status != STATUS_OBJECT_PATH_SYNTAX_BAD);
|
|
if (Status != STATUS_NO_SUCH_DEVICE) {
|
|
return(STATUS_OBJECT_NAME_COLLISION);
|
|
}
|
|
|
|
#ifdef TERMSRV
|
|
|
|
//
|
|
// For multiuser,
|
|
// If LUID device maps are enabled,
|
|
// then we add the LogonID to the devicename - e.g.
|
|
// net use f: to a DFS share for logon ID 0x000000000003a3f0 will create
|
|
// a symbolic link with the following format:
|
|
// \??\f: -> \Device\WinDfs\f:000000000003a3f0
|
|
//
|
|
// If LUID device maps are not enabled,
|
|
// then we add the SessionID to the devicename - e.g.
|
|
// net use f: to a DFS share for session ID 3 will create a symbolic link
|
|
// \DosDevices\f::3 -> \device\WinDfs\f:3
|
|
// In the VCB we store the SessionID for matching purposes.
|
|
// Both the symbolic link and the object name shall contain the SessionID
|
|
// in the name. However, in deviceObject->Vcb.LogicalRoot.Buffer, the
|
|
// name does not contain the SessionID. To find a matching VCB, both the name
|
|
// and SessionID must match.
|
|
//
|
|
|
|
DeviceString.Buffer = DeviceBuffer;
|
|
DeviceString.MaximumLength = sizeof(DeviceBuffer);
|
|
DeviceString.Length = 0;
|
|
|
|
//
|
|
// Build the UnicodeString without the SessionID or LogonID
|
|
//
|
|
|
|
RtlAppendUnicodeToString(&UnicodeString, (LPWSTR)Name);
|
|
|
|
|
|
if( SessionID != INVALID_SESSIONID) {
|
|
|
|
if( (DfsLUIDDeviceMapsEnabled == TRUE) &&
|
|
(LogonID != NULL) &&
|
|
(sizeof(*LogonID) == sizeof(LUID)) ) {
|
|
//
|
|
// Build the DeviceString with the LogonID
|
|
//
|
|
_snwprintf( IDBuffer,
|
|
sizeof(IDBuffer)/sizeof(WCHAR),
|
|
L"%08x%08x",
|
|
LogonID->HighPart,
|
|
LogonID->LowPart );
|
|
|
|
RtlInitUnicodeString( &IDString, IDBuffer );
|
|
}
|
|
else {
|
|
//
|
|
// Build the DeviceString with the SessionID
|
|
//
|
|
IDString.Buffer = IDBuffer;
|
|
IDString.MaximumLength = sizeof(IDBuffer);
|
|
IDString.Length = 0;
|
|
|
|
RtlIntegerToUnicodeString(SessionID, 10, &IDString);
|
|
}
|
|
|
|
RtlCopyUnicodeString(&DeviceString, &DfsData.LogRootDevName);
|
|
RtlAppendUnicodeToString(&DeviceString, (LPWSTR)Name);
|
|
RtlAppendUnicodeToString(&DeviceString,L":");
|
|
RtlAppendUnicodeStringToString(&DeviceString, &IDString);
|
|
DeviceString.MaximumLength = DeviceString.Length;
|
|
|
|
//
|
|
// Next, try to setup the Dos Device link
|
|
//
|
|
|
|
if (Prefix) {
|
|
Status = DfsDefineDosDevice( Name[0], &DeviceString );
|
|
if (!NT_SUCCESS(Status)) {
|
|
return( Status );
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
|
|
ASSERT( Prefix == FALSE );
|
|
}
|
|
|
|
#else // TERMSRV
|
|
|
|
//
|
|
// 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 );
|
|
}
|
|
}
|
|
|
|
#endif // TERMSRV
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
LogRootPrefix.Buffer = NULL;
|
|
|
|
if (Prefix && Prefix->Length > 0) {
|
|
LogRootPrefix.Length = Prefix->Length;
|
|
LogRootPrefix.MaximumLength = LogRootPrefix.Length + sizeof(WCHAR);
|
|
LogRootPrefix.Buffer = ExAllocatePoolWithTag(
|
|
PagedPool,
|
|
LogRootPrefix.MaximumLength,
|
|
' puM');
|
|
|
|
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.
|
|
//
|
|
|
|
if (Prefix) {
|
|
NTSTATUS DeleteStatus;
|
|
|
|
DeleteStatus = DfsUndefineDosDevice( Name[0] );
|
|
|
|
ASSERT(NT_SUCCESS(DeleteStatus));
|
|
}
|
|
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
} else {
|
|
RtlInitUnicodeString(&LogRootPrefix, NULL);
|
|
}
|
|
|
|
//
|
|
// Save the logical root name for the DFS_VCB structure. Remember, above
|
|
// we had UnicodeString to be of the form L"\Device\WinDfs\org". Now,
|
|
// we copy UnicodeString, then adjust the buffer and length fields so that
|
|
// the Buffer points to the beginning of the L"org"; Then, we allocate
|
|
// space for LogicalRootBuffer, and copy the name to it!
|
|
//
|
|
|
|
LogicalRoot = UnicodeString;
|
|
|
|
LogicalRoot.Buffer = &LogicalRoot.Buffer[ DfsData.LogRootDevName.Length/sizeof (WCHAR) ];
|
|
LogicalRoot.Length -= DfsData.LogRootDevName.Length;
|
|
LogicalRoot.MaximumLength -= DfsData.LogRootDevName.Length;
|
|
|
|
//
|
|
// Now dup the buffer that LogicalRoot uses
|
|
//
|
|
|
|
TmpBuf = ExAllocatePoolWithTag( PagedPool,
|
|
LogicalRoot.Length,
|
|
' puM');
|
|
|
|
if (TmpBuf == NULL) {
|
|
|
|
//
|
|
// Couldn't allocate memory! Ok to return with error code, since
|
|
// we still haven't changed the state of the IO subsystem yet.
|
|
//
|
|
|
|
if (LogRootPrefix.Buffer != NULL) {
|
|
|
|
ExFreePool(LogRootPrefix.Buffer);
|
|
|
|
}
|
|
|
|
if (Prefix) {
|
|
NTSTATUS DeleteStatus;
|
|
|
|
DeleteStatus = DfsUndefineDosDevice( Name[0] );
|
|
|
|
ASSERT(NT_SUCCESS(DeleteStatus));
|
|
}
|
|
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
|
|
} else {
|
|
|
|
RtlMoveMemory( TmpBuf,
|
|
LogicalRoot.Buffer,
|
|
LogicalRoot.Length );
|
|
|
|
LogicalRoot.Buffer = TmpBuf;
|
|
|
|
}
|
|
|
|
//
|
|
// Create the device object for the logical root.
|
|
//
|
|
|
|
#ifdef TERMSRV
|
|
|
|
Status = IoCreateDevice( DfsData.DriverObject,
|
|
sizeof( LOGICAL_ROOT_DEVICE_OBJECT ) -
|
|
sizeof( DEVICE_OBJECT ),
|
|
(SessionID != INVALID_SESSIONID) ?
|
|
&DeviceString : &UnicodeString,
|
|
FILE_DEVICE_DFS,
|
|
FILE_REMOTE_DEVICE,
|
|
FALSE,
|
|
(PDEVICE_OBJECT *) &DeviceObject );
|
|
|
|
#else // TERMSRV
|
|
|
|
Status = IoCreateDevice( DfsData.DriverObject,
|
|
sizeof( LOGICAL_ROOT_DEVICE_OBJECT ) -
|
|
sizeof( DEVICE_OBJECT ),
|
|
&UnicodeString,
|
|
FILE_DEVICE_DFS,
|
|
FILE_REMOTE_DEVICE,
|
|
FALSE,
|
|
(PDEVICE_OBJECT *) &DeviceObject );
|
|
|
|
#endif // TERMSRV
|
|
|
|
if ( !NT_SUCCESS( Status ) ) {
|
|
if (LogRootPrefix.Buffer) {
|
|
ExFreePool(LogRootPrefix.Buffer);
|
|
ExFreePool(LogicalRoot.Buffer);
|
|
}
|
|
if (Prefix) {
|
|
NTSTATUS DeleteStatus;
|
|
|
|
DeleteStatus = DfsUndefineDosDevice( Name[0] );
|
|
|
|
ASSERT(NT_SUCCESS(DeleteStatus));
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Pin the pkt entry in the cache by incrementing the Usecount
|
|
//
|
|
|
|
if (LogRootPrefix.Buffer != NULL && LogRootPrefix.Length > 0) {
|
|
|
|
UNICODE_STRING prefix = LogRootPrefix;
|
|
USHORT i, j;
|
|
|
|
//
|
|
// We want to work with the \server\share part of the prefix only,
|
|
// so count up to 3 backslashes, then stop.
|
|
//
|
|
|
|
for (i = j = 0; i < prefix.Length/sizeof(WCHAR) && j < 3; i++) {
|
|
|
|
if (prefix.Buffer[i] == UNICODE_PATH_SEP) {
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
prefix.Length = (j >= 3) ? (i-1) * sizeof(WCHAR) : i * sizeof(WCHAR);
|
|
|
|
pktEntry = PktLookupEntryByPrefix(&DfsData.Pkt,
|
|
&prefix,
|
|
&RemainingPath);
|
|
|
|
if (pktEntry != NULL && RemainingPath.Length == 0) {
|
|
|
|
InterlockedIncrement(&pktEntry->UseCount);
|
|
|
|
}
|
|
else {
|
|
pktEntry = NULL;
|
|
}
|
|
}
|
|
|
|
DeviceObject->DeviceObject.StackSize = 5;
|
|
|
|
DfsInitializeVcb ( NULL,
|
|
&DeviceObject->Vcb,
|
|
&LogRootPrefix,
|
|
Credentials,
|
|
(PDEVICE_OBJECT)DeviceObject );
|
|
|
|
DeviceObject->Vcb.VcbState |= VcbFlags;
|
|
|
|
#ifdef TERMSRV
|
|
DeviceObject->Vcb.SessionID = SessionID;
|
|
#endif
|
|
DeviceObject->Vcb.pktEntry = pktEntry;
|
|
|
|
RtlCopyLuid(&DeviceObject->Vcb.LogonID, LogonID);
|
|
|
|
//
|
|
// Above we preallocated the buffer we need here. So just use it.
|
|
//
|
|
|
|
DeviceObject->Vcb.LogicalRoot = LogicalRoot;
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsDeleteLogicalRoot(
|
|
IN PWSTR Name,
|
|
IN BOOLEAN fForce,
|
|
IN ULONG SessionID,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#else // TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsDeleteLogicalRoot(
|
|
IN PWSTR Name,
|
|
IN BOOLEAN fForce,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#endif // TERMSRV
|
|
{
|
|
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;
|
|
PDFS_PKT_ENTRY pktEntry;
|
|
|
|
//
|
|
// 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);
|
|
|
|
ExAcquireResourceExclusiveLite(&DfsData.Resource, TRUE);
|
|
|
|
#ifdef TERMSRV
|
|
Status = DfsFindLogicalRoot(&RootName, SessionID, LogonID, &Vcb, &RemainingPath);
|
|
#else // TERMSRV
|
|
Status = DfsFindLogicalRoot(&RootName, LogonID, &Vcb, &RemainingPath);
|
|
#endif // TERMSRV
|
|
|
|
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
|
|
//
|
|
|
|
if (Vcb->Credentials != NULL) {
|
|
DfsDeleteCredentials( Vcb->Credentials );
|
|
}
|
|
|
|
//
|
|
// Get rid of the Dos Device
|
|
//
|
|
|
|
DfsUndefineDosDevice( Name[0] );
|
|
|
|
//
|
|
// Dec ref count on pkt entry
|
|
//
|
|
if (Vcb->pktEntry != NULL) {
|
|
InterlockedDecrement(&Vcb->pktEntry->UseCount);
|
|
|
|
Vcb->pktEntry = NULL;
|
|
}
|
|
|
|
//
|
|
// 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:
|
|
|
|
ExReleaseResourceLite(&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)
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
#if defined (_WIN64)
|
|
typedef struct _DFS_NETRESOURCE32 {
|
|
DWORD dwScope;
|
|
DWORD dwType;
|
|
DWORD dwDisplayType;
|
|
DWORD dwUsage;
|
|
ULONG lpLocalName;
|
|
ULONG lpRemoteName;
|
|
ULONG lpComment ;
|
|
ULONG lpProvider;
|
|
}DFS_NETRESOURCE32, *PDFS_NETRESOURCE32;
|
|
|
|
#endif
|
|
|
|
NTSTATUS
|
|
DfsGetResourceFromVcb(
|
|
PIRP pIrp,
|
|
PDFS_VCB Vcb,
|
|
PUNICODE_STRING ProviderName,
|
|
PUCHAR BufBegin,
|
|
PUCHAR Buf,
|
|
PULONG BufSize,
|
|
PULONG pResourceSize
|
|
|
|
)
|
|
{
|
|
LPNETRESOURCE netResource = (LPNETRESOURCE) Buf;
|
|
ULONG sizeRequired = 0, ResourceSize;
|
|
WCHAR localDrive[ 3 ];
|
|
ULONG32 CommentOffset, ProviderOffset, LocalNameOffset, RemoteNameOffset;
|
|
|
|
#if defined (_WIN64)
|
|
if (IoIs32bitProcess(pIrp)) {
|
|
ResourceSize = sizeof(DFS_NETRESOURCE32);
|
|
}
|
|
else
|
|
#endif
|
|
ResourceSize = sizeof(NETRESOURCE);
|
|
|
|
*pResourceSize = ResourceSize;
|
|
|
|
sizeRequired = ResourceSize +
|
|
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
|
|
//
|
|
|
|
Buf += ResourceSize;
|
|
*BufSize -= ResourceSize;
|
|
|
|
netResource->dwScope = RESOURCE_CONNECTED;
|
|
netResource->dwType = RESOURCETYPE_DISK;
|
|
netResource->dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
|
|
netResource->dwUsage = RESOURCEUSAGE_CONNECTABLE;
|
|
|
|
CommentOffset = 0;
|
|
//
|
|
// Fill in the provider name
|
|
//
|
|
|
|
PackMem(Buf, L"", sizeof(L""), BufSize);
|
|
PackMem(Buf, ProviderName->Buffer, ProviderName->Length, BufSize);
|
|
ProviderOffset = (ULONG32)(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);
|
|
LocalNameOffset = (ULONG32)(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);
|
|
RemoteNameOffset = (ULONG32)(Buf + *BufSize - BufBegin);
|
|
|
|
#if defined (_WIN64)
|
|
if (IoIs32bitProcess(pIrp)) {
|
|
PDFS_NETRESOURCE32 pNetResource32 = (PDFS_NETRESOURCE32)netResource;
|
|
|
|
pNetResource32->lpComment = CommentOffset;
|
|
pNetResource32->lpProvider = ProviderOffset;
|
|
pNetResource32->lpLocalName = LocalNameOffset;
|
|
pNetResource32->lpRemoteName = RemoteNameOffset;
|
|
}
|
|
else {
|
|
#endif
|
|
|
|
netResource->lpComment = (LPWSTR)UIntToPtr( CommentOffset );
|
|
netResource->lpProvider = (LPWSTR)UIntToPtr( ProviderOffset );
|
|
netResource->lpLocalName = (LPWSTR)UIntToPtr( LocalNameOffset );
|
|
netResource->lpRemoteName = (LPWSTR)UIntToPtr( RemoteNameOffset );
|
|
#if defined (_WIN64)
|
|
}
|
|
#endif
|
|
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: DfsGetResourceFromDevlessRoot
|
|
//
|
|
// Synopsis: Builds a NETRESOURCE structure for a device-less connection.
|
|
// The LPWSTR members of NETRESOURCE actually contain offsets
|
|
// from the BufBegin parameter.
|
|
//
|
|
// Arguments: [Drt] -- The DevicelessRoot structure
|
|
// [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
|
|
DfsGetResourceFromDevlessRoot(
|
|
PIRP pIrp,
|
|
PDFS_DEVLESS_ROOT pDrt,
|
|
PUNICODE_STRING ProviderName,
|
|
PUCHAR BufBegin,
|
|
PUCHAR Buf,
|
|
PULONG BufSize,
|
|
PULONG pResourceSize)
|
|
{
|
|
LPNETRESOURCE netResource = (LPNETRESOURCE) Buf;
|
|
ULONG sizeRequired = 0, ResourceSize;
|
|
WCHAR localDrive[ 3 ];
|
|
ULONG32 CommentOffset, ProviderOffset, LocalNameOffset, RemoteNameOffset;
|
|
#if defined (_WIN64)
|
|
if (IoIs32bitProcess(pIrp)) {
|
|
ResourceSize = sizeof(DFS_NETRESOURCE32);
|
|
}
|
|
else
|
|
#endif
|
|
ResourceSize = sizeof(NETRESOURCE);
|
|
|
|
*pResourceSize = ResourceSize;
|
|
|
|
sizeRequired = ResourceSize +
|
|
ProviderName->Length +
|
|
sizeof(UNICODE_NULL) +
|
|
2 * sizeof(UNICODE_PATH_SEP) +
|
|
pDrt->DevlessPath.Length +
|
|
sizeof(UNICODE_NULL);
|
|
|
|
if (*BufSize < sizeRequired) {
|
|
*BufSize = sizeRequired;
|
|
return(STATUS_BUFFER_OVERFLOW);
|
|
}
|
|
|
|
//
|
|
// Buffer is big enough, fill in the NETRESOURCE structure
|
|
//
|
|
|
|
Buf += ResourceSize;
|
|
*BufSize -= ResourceSize;
|
|
|
|
netResource->dwScope = RESOURCE_CONNECTED;
|
|
netResource->dwType = RESOURCETYPE_DISK;
|
|
netResource->dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
|
|
netResource->dwUsage = RESOURCEUSAGE_CONNECTABLE;
|
|
|
|
CommentOffset = 0;
|
|
LocalNameOffset = 0;
|
|
|
|
//
|
|
// Fill in the provider name
|
|
//
|
|
|
|
PackMem(Buf, L"", sizeof(L""), BufSize);
|
|
PackMem(Buf, ProviderName->Buffer, ProviderName->Length, BufSize);
|
|
ProviderOffset = (ULONG32)(Buf + *BufSize - BufBegin);
|
|
|
|
//
|
|
// Fill in the remote name last
|
|
//
|
|
|
|
PackMem(Buf, L"", sizeof(L""), BufSize);
|
|
PackMem(Buf, pDrt->DevlessPath.Buffer, pDrt->DevlessPath.Length, BufSize);
|
|
|
|
PackMem(Buf, UNICODE_PATH_SEP_STR, sizeof(UNICODE_PATH_SEP), BufSize);
|
|
|
|
RemoteNameOffset = (ULONG32)(Buf + *BufSize - BufBegin);
|
|
|
|
#if defined (_WIN64)
|
|
if (IoIs32bitProcess(pIrp)) {
|
|
PDFS_NETRESOURCE32 pNetResource32 = (PDFS_NETRESOURCE32)netResource;
|
|
|
|
pNetResource32->lpComment = CommentOffset;
|
|
pNetResource32->lpProvider = ProviderOffset;
|
|
pNetResource32->lpLocalName = LocalNameOffset;
|
|
pNetResource32->lpRemoteName = RemoteNameOffset;
|
|
}
|
|
else {
|
|
#endif
|
|
|
|
netResource->lpComment = (LPWSTR)UIntToPtr( CommentOffset );
|
|
netResource->lpProvider = (LPWSTR)UIntToPtr( ProviderOffset );
|
|
netResource->lpLocalName = (LPWSTR)UIntToPtr( LocalNameOffset );
|
|
netResource->lpRemoteName = (LPWSTR)UIntToPtr( RemoteNameOffset );
|
|
#if defined (_WIN64)
|
|
}
|
|
#endif
|
|
|
|
return(STATUS_SUCCESS);
|
|
|
|
|
|
}
|
|
|
|
|
|
#ifdef TERMSRV
|
|
|
|
BOOLEAN
|
|
DfsLogicalRootExists(
|
|
IN PWSTR pwszName,
|
|
IN ULONG SessionID,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#else // TERMSRV
|
|
|
|
BOOLEAN
|
|
DfsLogicalRootExists(
|
|
IN PWSTR pwszName,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#endif // TERMSRV
|
|
{
|
|
|
|
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);
|
|
}
|
|
|
|
#ifdef TERMSRV
|
|
Status = DfsFindLogicalRoot(&RootName, SessionID, LogonID, &Vcb, &RemainingPath);
|
|
#else // TERMSRV
|
|
Status = DfsFindLogicalRoot(&RootName, LogonId, &Vcb, &RemainingPath);
|
|
#endif // TERMSRV
|
|
|
|
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;
|
|
WCHAR Buf[25];
|
|
|
|
wcscpy(Buf, L"\\??\\X:");
|
|
RtlInitUnicodeString( &deviceName, Buf);
|
|
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;
|
|
WCHAR Buf[25];
|
|
|
|
wcscpy(Buf, L"\\??\\X:");
|
|
RtlInitUnicodeString( &deviceName, Buf);
|
|
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 );
|
|
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: DfsFindDevlessRoot, local
|
|
//
|
|
// Synopsis: DfsFindDevlessRoot takes as input a UNC name
|
|
// looks up the DFS_DEVLESS_ROOT associated with the root,
|
|
// and returns the DevlessRoot
|
|
//
|
|
// Arguments: [Path] -- Input path name
|
|
// [Drt] -- Returns DFS_DEVLESS_ROOT which corresponds to
|
|
// the root for the Path
|
|
//
|
|
// Returns: NTSTATUS:
|
|
// STATUS_SUCCESS if Drt found
|
|
// STATUS_NO_SUCH_DEVICE - root name not found
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
#ifdef TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsFindDevlessRoot(
|
|
IN PUNICODE_STRING Path,
|
|
IN ULONG SessionID,
|
|
IN PLUID LogonID,
|
|
OUT PDFS_DEVLESS_ROOT *Drt
|
|
)
|
|
|
|
#else // TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsFindDevlessRoot(
|
|
IN PUNICODE_STRING Path,
|
|
IN PLUID LogonID,
|
|
OUT PDFS_DEVLESS_ROOT *Drt,
|
|
)
|
|
|
|
#endif // TERMSRV
|
|
{
|
|
PLIST_ENTRY Link;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
DfsDbgTrace(+1, Dbg, "DfsFindDevlessRoot...%wZ\n", Path);
|
|
|
|
//
|
|
// Search for the devless ROOT.
|
|
//
|
|
|
|
ExAcquireResourceSharedLite(&DfsData.Resource, TRUE);
|
|
|
|
for ( Link = DfsData.DrtQueue.Flink;
|
|
Link != &DfsData.DrtQueue;
|
|
Link = Link->Flink ) {
|
|
|
|
*Drt = CONTAINING_RECORD( Link, DFS_DEVLESS_ROOT, DrtLinks );
|
|
|
|
#ifdef TERMSRV
|
|
if ((SessionID == INVALID_SESSIONID) ||
|
|
(SessionID == (*Drt)->SessionID)) {
|
|
#endif
|
|
if ( RtlEqualLuid(LogonID, &(*Drt)->LogonID) ) {
|
|
if (RtlEqualString( (PSTRING)&(*Drt)->DevlessPath,
|
|
(PSTRING)Path, (BOOLEAN)TRUE) ) {
|
|
break;
|
|
}
|
|
}
|
|
#ifdef TERMSRV
|
|
}
|
|
#endif // TERMSRV
|
|
}
|
|
if (Link == &DfsData.DrtQueue) {
|
|
Status = STATUS_NO_SUCH_DEVICE;
|
|
ExReleaseResourceLite(&DfsData.Resource);
|
|
DfsDbgTrace(-1, Dbg, "DfsFindDevlessRoot -> %08lx\n", ULongToPtr(Status) );
|
|
return(Status);
|
|
}
|
|
|
|
ExReleaseResourceLite(&DfsData.Resource);
|
|
DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(Status) );
|
|
return(Status);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: DfsInitializeDevlessRoot, public
|
|
//
|
|
// Synopsis: Allocate and initialize storage for a Deviceless root.
|
|
//
|
|
// Effects: A DFS_DEVLESS_ROOT structure is created.
|
|
//
|
|
// Arguments: [Name] -- Pathname that is the deviceless root.
|
|
// [Credentials] -- The credentials to use when accessing files
|
|
// via this logical root.
|
|
//
|
|
// 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.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#ifdef TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsInitializeDevlessRoot(
|
|
IN PUNICODE_STRING Name,
|
|
IN PDFS_CREDENTIALS Credentials OPTIONAL,
|
|
IN ULONG SessionID,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#else // TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsInitializeDevlessRoot(
|
|
IN PUNICODE_STRING Name,
|
|
IN PDFS_CREDENTIALS Credentials OPTIONAL,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#endif // TERMSRV
|
|
{
|
|
|
|
PDFS_DEVLESS_ROOT Drt;
|
|
PDFS_PKT_ENTRY pktEntry = NULL;
|
|
UNICODE_STRING DevlessRootName;
|
|
NTSTATUS Status;
|
|
|
|
DfsDbgTrace(0, Dbg, "DfsInitializeDevlessRoot -> %wZ\n", Name);
|
|
|
|
#ifdef TERMSRV
|
|
Status = DfsFindDevlessRoot(Name, SessionID, LogonID, &Drt);
|
|
#else
|
|
Status = DfsFindDevlessRoot(Name, LogonID, &Drt);
|
|
#endif
|
|
|
|
if (Status != STATUS_NO_SUCH_DEVICE) {
|
|
//
|
|
// this means we found a device. In the devless Root case, this means
|
|
// we dont have to do any more work. Just return a success response.
|
|
// However, we still have the credentials which the caller assumes
|
|
// we will be using. Get rid of it here and return success.
|
|
//
|
|
DfsDeleteCredentials(Credentials);
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
Drt = ExAllocatePoolWithTag( PagedPool,
|
|
sizeof(DFS_DEVLESS_ROOT),
|
|
' puM');
|
|
if (Drt == NULL) {
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
//
|
|
// Before we initialize the Drt, 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_DEVLESS_ROOT.
|
|
//
|
|
|
|
DevlessRootName.Length = Name->Length;
|
|
DevlessRootName.MaximumLength = DevlessRootName.Length + sizeof(WCHAR);
|
|
DevlessRootName.Buffer = ExAllocatePoolWithTag(
|
|
PagedPool,
|
|
DevlessRootName.MaximumLength,
|
|
' puM');
|
|
|
|
if (DevlessRootName.Buffer != NULL) {
|
|
RtlMoveMemory(DevlessRootName.Buffer,
|
|
Name->Buffer,
|
|
Name->MaximumLength);
|
|
|
|
DevlessRootName.Buffer[Name->Length/sizeof(WCHAR)] = UNICODE_NULL;
|
|
} else {
|
|
ExFreePool(Drt);
|
|
return(STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
//
|
|
// Pin the pkt entry in the cache by incrementing the Usecount
|
|
//
|
|
|
|
if (DevlessRootName.Buffer != NULL && DevlessRootName.Length > 0) {
|
|
|
|
UNICODE_STRING prefix = DevlessRootName;
|
|
USHORT i, j;
|
|
UNICODE_STRING RemainingPath;
|
|
|
|
//
|
|
// We want to work with the \server\share part of the prefix only,
|
|
// so count up to 3 backslashes, then stop.
|
|
//
|
|
|
|
for (i = j = 0; i < prefix.Length/sizeof(WCHAR) && j < 3; i++) {
|
|
if (prefix.Buffer[i] == UNICODE_PATH_SEP) {
|
|
j++;
|
|
}
|
|
}
|
|
|
|
prefix.Length = (j >= 3) ? (i-1) * sizeof(WCHAR) : i * sizeof(WCHAR);
|
|
|
|
pktEntry = PktLookupEntryByPrefix(&DfsData.Pkt,
|
|
&prefix,
|
|
&RemainingPath);
|
|
|
|
if (pktEntry != NULL && RemainingPath.Length == 0) {
|
|
|
|
InterlockedIncrement(&pktEntry->UseCount);
|
|
|
|
}
|
|
else {
|
|
pktEntry = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
DfsInitializeDrt ( Drt,
|
|
&DevlessRootName,
|
|
Credentials);
|
|
|
|
#ifdef TERMSRV
|
|
Drt->SessionID = SessionID;
|
|
#endif
|
|
Drt->pktEntry = pktEntry;
|
|
RtlCopyLuid(&Drt->LogonID, LogonID);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: DfsDeleteDevlessRoot
|
|
//
|
|
// Synopsis: Removes a Devless root if found and possible.
|
|
//
|
|
// Arguments: [Name] -- Name of the Logical Root
|
|
//
|
|
// Returns: STATUS_SUCCESS -- If successfully deleted logical root
|
|
//
|
|
// STATUS_NO_SUCH_DEVICE -- If there is no logical root to
|
|
// delete.
|
|
//
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsDeleteDevlessRoot(
|
|
IN PUNICODE_STRING Name,
|
|
IN ULONG SessionID,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#else // TERMSRV
|
|
|
|
NTSTATUS
|
|
DfsDeleteDevlessRoot(
|
|
IN PUNICODE_STRING Name,
|
|
IN PLUID LogonID
|
|
)
|
|
|
|
#endif // TERMSRV
|
|
{
|
|
PDFS_PKT_ENTRY PktEntry;
|
|
PDFS_DEVLESS_ROOT Drt;
|
|
NTSTATUS Status;
|
|
BOOLEAN pktLocked;
|
|
PDFS_PKT_ENTRY pktEntry;
|
|
|
|
DfsDbgTrace(0, Dbg, "DfsDeleteDevlessRoot -> %wZ\n", Name);
|
|
|
|
//
|
|
// Acquire Pkt and DfsData, wait till we do so.
|
|
//
|
|
|
|
PktAcquireExclusive(TRUE, &pktLocked);
|
|
|
|
ExAcquireResourceExclusiveLite(&DfsData.Resource, TRUE);
|
|
|
|
#ifdef TERMSRV
|
|
Status = DfsFindDevlessRoot(Name, SessionID, LogonID, &Drt);
|
|
#else // TERMSRV
|
|
Status = DfsFindDevlessRoot(Name, LogonID, &Drt);
|
|
#endif // TERMSRV
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Delete the credentials used by this connection
|
|
//
|
|
|
|
DfsDeleteCredentials( Drt->Credentials );
|
|
|
|
if (Drt->pktEntry != NULL) {
|
|
InterlockedDecrement(&Drt->pktEntry->UseCount);
|
|
|
|
Drt->pktEntry = NULL;
|
|
}
|
|
|
|
RemoveEntryList(&Drt->DrtLinks);
|
|
|
|
if (Drt->DevlessPath.Buffer) {
|
|
ExFreePool(Drt->DevlessPath.Buffer);
|
|
}
|
|
ExFreePool(Drt);
|
|
|
|
Cleanup:
|
|
|
|
ExReleaseResourceLite(&DfsData.Resource);
|
|
|
|
PktRelease();
|
|
|
|
return(Status);
|
|
}
|