//+---------------------------------------------------------------------------- // // 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 #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); }