able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/mup/logroot.c

1603 lines
44 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+----------------------------------------------------------------------------
//
// 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);
}
Reference in a new issue Copy permalink