//+---------------------------------------------------------------------------- // // Copyright (C) 2000, Microsoft Corporation // // File: DfsRootFolder.cxx // // Contents: implements the base DFS Folder class // // Classes: DfsRootFolder. // // History: Dec. 8 2000, Author: udayh // //----------------------------------------------------------------------------- #include "DfsRootFolder.hxx" #include "dfsfilterapi.hxx" #include "rpc.h" #include "rpcdce.h" #include "DfsStore.hxx" #include "DelegationControl.hxx" // // logging includes. // #include "DfsRootFolder.tmh" #define FILETIMETO64(_f) (*(UINT64 *)(&(_f))) //+------------------------------------------------------------------------- // // Function: DfsRootFolder - Contstruct for the rootFolder class // // Arguments: NameContext - the Dfs Name context // pLogicalShare - the Logical Share name // ObType - the object type. Set to the derived class type. // pStatus - status of this call. // // Returns: NONE // // Description: This routine initializes the class variables of the // the root folder, and initialize the name context and // logical share name to the passed in values. // It also allocated and initializes the lock for the root // folder, as well as all the locks that will be assigned // to the child folders. // We then create a metadata name table and a logical namespace // prefix table. // //-------------------------------------------------------------------------- DfsRootFolder::DfsRootFolder( IN LPWSTR NameContext, IN LPWSTR RootRegKeyNameString, IN PUNICODE_STRING pLogicalShare, IN PUNICODE_STRING pPhysicalShare, IN DfsObjectTypeEnumeration ObType, OUT DFSSTATUS *pStatus ) : DfsFolder (NULL, NULL, ObType ) { ULONG LockNum; DFSSTATUS Status = ERROR_SUCCESS; RtlInitUnicodeString( &_DfsNameContext, NULL ); RtlInitUnicodeString( &_LogicalShareName, NULL ); RtlInitUnicodeString( &_RootRegKeyName, NULL ); RtlInitUnicodeString( &_PhysicalShareName, NULL ); RtlInitUnicodeString( &_ShareFilePathName, NULL ); RtlInitUnicodeString( &_DirectoryCreateRootPathName, NULL ); RtlInitUnicodeString( &_DfsVisibleContext, NULL ); _DirectoryCreateError = STATUS_SUCCESS; _pMetadataNameTable = NULL; _pLogicalPrefixTable = NULL; _IgnoreNameContext = FALSE; _CreateDirectories = FALSE; pStatistics = NULL; _pChildLocks = NULL; _ChildCount = 0; _CurrentErrors = 0; _RootFlags = 0; Status = DfsCreateUnicodeStringFromString( &_DfsNameContext, NameContext ); if ( Status == ERROR_SUCCESS ) { DfsGetNetbiosName( &_DfsNameContext, &_DfsNetbiosNameContext, NULL ); Status = DfsCreateUnicodeString( &_LogicalShareName, pLogicalShare ); } if ( Status == ERROR_SUCCESS ) { Status = DfsCreateUnicodeStringFromString( &_RootRegKeyName, RootRegKeyNameString ); } if ( Status == ERROR_SUCCESS ) { Status = DfsCreateUnicodeString( &_PhysicalShareName, pPhysicalShare ); } if ( Status == ERROR_SUCCESS ) { pStatistics = new DfsStatistics(); if (pStatistics == NULL) { Status = ERROR_NOT_ENOUGH_MEMORY; } } if ( Status == ERROR_SUCCESS ) { _pRootLock = new CRITICAL_SECTION; if ( _pRootLock == NULL ) { Status = ERROR_NOT_ENOUGH_MEMORY; } } if ( Status == ERROR_SUCCESS ) { InitializeCriticalSection( _pRootLock ); } if ( Status == ERROR_SUCCESS ) { _pLock = new CRITICAL_SECTION; if ( _pLock == NULL ) { Status = ERROR_NOT_ENOUGH_MEMORY; } } if ( Status == ERROR_SUCCESS ) { InitializeCriticalSection( _pLock ); _Flags = DFS_FOLDER_ROOT; // // Allocate the child locks, and initiailize them. // _pChildLocks = new CRITICAL_SECTION[ NUMBER_OF_SHARED_LINK_LOCKS ]; if ( _pChildLocks != NULL ) { for ( LockNum = 0; LockNum < NUMBER_OF_SHARED_LINK_LOCKS; LockNum++ ) { InitializeCriticalSection( &_pChildLocks[LockNum] ); } } else { Status = ERROR_NOT_ENOUGH_MEMORY; } } // // Initialize the prefix and nametable for this root. // if ( Status == ERROR_SUCCESS ) { Status = DfsInitializePrefixTable( &_pLogicalPrefixTable, FALSE, NULL ); } if ( Status == ERROR_SUCCESS ) { Status = DfsInitializeNameTable( 0, &_pMetadataNameTable ); } // // We have not assigned any of the child locks: set the lock index // to 0. This index provides us a mechanism of allocating locks // to the child folders in a round robin way. // _ChildLockIndex = 0; _LocalCreate = FALSE; pPrevRoot = pNextRoot = NULL; *pStatus = Status; } //+------------------------------------------------------------------------- // // Function: CreateLinkFolder - Create a DfsFolder and initialize it. // // Arguments: ChildName - metadata name of the child // pLinkName - the logical namespace name, relative to root // ppChildFolder - the returned child folder // // Returns: Status: Success or error status // // Description: This routine Creates a link folder and adds it to the // parent Root's table. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::CreateLinkFolder( IN LPWSTR ChildName, IN PUNICODE_STRING pLinkName, OUT DfsFolder **ppChildFolder ) { DfsFolder *pChildFolder = NULL; DFSSTATUS Status = ERROR_SUCCESS; const TCHAR * apszSubStrings[4]; DFS_TRACE_LOW( REFERRAL_SERVER, "Create Link Folder: MetaName %ws, Link %wZ\n", ChildName, pLinkName ); // // Create a new child folder. Allocate a lock for this child // and pass the lock along to the Folder constructor. // pChildFolder = new DfsFolder (this, GetChildLock() ); if ( pChildFolder == NULL ) { Status = ERROR_NOT_ENOUGH_MEMORY; } else { // // We successfully created the folder. Now set the metadata // and logical name of the child folder. // Status = pChildFolder->InitializeMetadataName( ChildName ); if ( Status == ERROR_SUCCESS ) { Status = pChildFolder->InitializeLogicalName( pLinkName ); } } if ( Status == ERROR_SUCCESS ) { // // We now acquire the child folder's write lock, and insert // the child into the parent's metadata and logical namespace // tables. // When adding/removing the child in one of these tables, // it is necessary to acquire the child folder lock since // we are setting state in the folder indicating whether the // child is in any of these tables. // Status = pChildFolder->AcquireWriteLock(); if ( Status == ERROR_SUCCESS ) { Status = InsertLinkFolderInMetadataTable( pChildFolder ); if ( Status == ERROR_SUCCESS ) { IncrementChildCount(); Status = InsertLinkFolderInLogicalTable( pChildFolder ); } pChildFolder->ReleaseLock(); } } if (Status == ERROR_SUCCESS) { DFSSTATUS CreateStatus; CreateStatus = SetupLinkReparsePoint( pChildFolder->GetFolderLogicalNameString() ); if(CreateStatus != STATUS_SUCCESS) { CreateStatus = RtlNtStatusToDosError(CreateStatus); apszSubStrings[0] = GetFolderLogicalNameString(); apszSubStrings[1] = GetDirectoryCreatePathName()->Buffer; GenerateEventLog(DFS_ERROR_CREATE_REPARSEPOINT_FAILURE, 2, apszSubStrings, CreateStatus); } DFS_TRACE_ERROR_LOW(CreateStatus, REFERRAL_SERVER, "Setup link reparse point child %p, link %wZ, Status %x\n", pChildFolder, pLinkName, Status); } // // If we are successful, return the newly created child folder. // We currently have a reference on the folder (the reference on // the folder when the folder was created) // // If we encountered an error, and the childFolder has been created, // get rid of out reference on this folder. This will usually // destroy the childFolder. // // if ( Status == ERROR_SUCCESS ) { *ppChildFolder = pChildFolder; pStatistics->UpdateLinkAdded(); } else { if ( pChildFolder != NULL ) { pChildFolder->ReleaseReference();; } } DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Create Link Folder: MetaName %ws, Child %p Status %x\n", ChildName, pChildFolder, Status ); return Status; } //+------------------------------------------------------------------------- // // Function: UpdateLinkFolder - Update a DfsFolder. // // Arguments: ChildName - metadata name of the child // pLinkName - the logical namespace name, relative to root // pChildFolder - the child folder // // Returns: Status: Success or error status // // Description: This routine TBD // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::UpdateLinkFolder( IN LPWSTR ChildName, IN PUNICODE_STRING pLinkName, IN DfsFolder *pChildFolder ) { BOOLEAN Removed; UNREFERENCED_PARAMETER(ChildName); UNREFERENCED_PARAMETER(pLinkName); pChildFolder->RemoveReferralData( NULL, &Removed ); pStatistics->UpdateLinkModified(); if (Removed == TRUE) { pStatistics->UpdateForcedCacheFlush(); } // // Create directories too. Delete old directories. // return ERROR_SUCCESS; } //+------------------------------------------------------------------------- // // Function: RemoveAllLinkFolders - Remove all folders of this root // // Arguments: None // // Returns: Status: Success or error status // // Description: This routine TBD // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::RemoveAllLinkFolders( BOOLEAN IsPermanent) { DFSSTATUS Status = ERROR_SUCCESS; DfsFolder *pChildFolder; ULONG Count = 0; while (Status == ERROR_SUCCESS) { Status = LookupFolder(&pChildFolder); if (Status == ERROR_SUCCESS) { Status = RemoveLinkFolder(pChildFolder, IsPermanent); pChildFolder->ReleaseReference(); Count++; } } DFS_TRACE_ERROR_HIGH( Status, REFERRAL_SERVER, "Remove all link folders Count %d Status %x\n", Count, Status); return Status; } //+------------------------------------------------------------------------- // // Function: RemoveLinkFolder - Update a DfsFolder. // // Arguments: ChildName - metadata name of the child // pLinkName - the logical namespace name, relative to root // pChildFolder - the child folder // // Returns: Status: Success or error status // // Description: This routine TBD // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::RemoveLinkFolder( IN DfsFolder *pChildFolder, BOOLEAN IsPermanent ) { DFSSTATUS Status = ERROR_SUCCESS; if (IsPermanent == TRUE) { // // try to tear down the link reparse point: return status ignored. // Status = TeardownLinkReparsePoint( pChildFolder->GetFolderLogicalNameString() ); DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "Tear down reparse for %p, status %x \n", pChildFolder, Status ); } Status = pChildFolder->AcquireWriteLock(); if ( Status == ERROR_SUCCESS ) { Status = RemoveLinkFolderFromMetadataTable( pChildFolder ); if ( Status == ERROR_SUCCESS ) { DecrementChildCount(); Status = RemoveLinkFolderFromLogicalTable( pChildFolder ); } pChildFolder->ReleaseLock(); } if (Status == ERROR_SUCCESS) { pStatistics->UpdateLinkDeleted(); } DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "Remove Link Folder %p, status %x \n", pChildFolder, Status ); return Status; } //+------------------------------------------------------------------------- // // Function: OpenLinkDirectory // // Arguments: DirectoryName - the full pathname to directory being created. // ShareMode - the share mode (share all or share none) // pDirHandle - pointer to return the opened handle // pIsNewlyCreated - was the directory created or existing. // // Returns: SUCCESS or error // // Description: This routine takes an NT pathname to the directory // representing the DFS link, and opens it, creating it // if it was not already existing. // It returns the open handle to the directory, and also // returns an indication whether a new directory was // created or an existing directory was opened. // //-------------------------------------------------------------------------- NTSTATUS DfsRootFolder::OpenLinkDirectory( LPWSTR DirectoryName, ULONG ShareMode, PHANDLE pDirHandle, PBOOLEAN pIsNewlyCreated ) { NTSTATUS NtStatus; // NtCreateFile OBJECT_ATTRIBUTES ObjectAttributes; ACCESS_MASK DesiredAccess; PLARGE_INTEGER AllocationSize; ULONG FileAttributes; ULONG CreateDisposition; ULONG CreateOptions; PVOID EaBuffer; ULONG EaLength; UNICODE_STRING ObjectName; IO_STATUS_BLOCK IoStatusBlock; RtlInitUnicodeString(&ObjectName, DirectoryName ); AllocationSize = NULL; FileAttributes = FILE_ATTRIBUTE_NORMAL; CreateDisposition = FILE_OPEN_IF; CreateOptions = FILE_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT; EaBuffer = NULL; EaLength = 0; DesiredAccess = FILE_READ_DATA | FILE_WRITE_DATA | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES; InitializeObjectAttributes ( &ObjectAttributes, &ObjectName, 0, NULL, NULL); NtStatus = NtCreateFile(pDirHandle, DesiredAccess, &ObjectAttributes, &IoStatusBlock, AllocationSize, FileAttributes, ShareMode, CreateDisposition, CreateOptions, EaBuffer, EaLength); DFSLOG("Open on %wS: Status %x\n", DirectoryName, NtStatus); if (NtStatus == STATUS_SUCCESS) { *pIsNewlyCreated = (IoStatusBlock.Information == FILE_CREATED)? TRUE : FALSE; } return NtStatus; } //+------------------------------------------------------------------------- // // Function: IsDirectoryReparsePoint // // Arguments: DirHandle - handle to open directory. // pReparsePoint - returned boolean: true if this directory is // a reparse point // pDfsReparsePoint - returned boolean: true if this // directory is a dfs reparse point // // // Returns: SUCCESS or error // // Description: This routine takes a handle to an open directory and // sets 2 booleans to indicate if this directory is a // reparse point, and if so, if this directory is a dfs // reparse point. The booleans are initialized if this // function returns success. // //-------------------------------------------------------------------------- NTSTATUS DfsRootFolder::IsDirectoryReparsePoint( IN HANDLE DirHandle, OUT PBOOLEAN pReparsePoint, OUT PBOOLEAN pDfsReparsePoint ) { NTSTATUS NtStatus; FILE_BASIC_INFORMATION BasicInfo; IO_STATUS_BLOCK IoStatusBlock; // //we assume these are not reparse points. // *pReparsePoint = FALSE; *pDfsReparsePoint = FALSE; // // Query for the basic information, which has the attributes. // NtStatus = NtQueryInformationFile( DirHandle, &IoStatusBlock, (PVOID)&BasicInfo, sizeof(BasicInfo), FileBasicInformation ); if (NtStatus == STATUS_SUCCESS) { // // If the attributes indicate reparse point, we have a reparse // point directory on our hands. // if ( BasicInfo.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT ) { FILE_ATTRIBUTE_TAG_INFORMATION FileTagInformation; *pReparsePoint = TRUE; NtStatus = NtQueryInformationFile( DirHandle, &IoStatusBlock, (PVOID)&FileTagInformation, sizeof(FileTagInformation), FileAttributeTagInformation ); if (NtStatus == STATUS_SUCCESS) { // // Checkif the tag indicates its a DFS reparse point, // and setup the return accordingly. // if (FileTagInformation.ReparseTag == IO_REPARSE_TAG_DFS) { *pDfsReparsePoint = TRUE; } } } } return NtStatus; } //+------------------------------------------------------------------------- // // Function: SetDfsReparsePoint // // Arguments: DirHandle - handle on open directory // // Returns: SUCCESS or error // // Description: This routine takes a handle to an open directory and // makes that directory a reparse point with the DFS tag // //-------------------------------------------------------------------------- NTSTATUS DfsRootFolder::SetDfsReparsePoint( IN HANDLE DirHandle ) { NTSTATUS NtStatus; REPARSE_DATA_BUFFER ReparseDataBuffer; IO_STATUS_BLOCK IoStatusBlock; // // Attempt to set a reparse point on the directory // RtlZeroMemory( &ReparseDataBuffer, sizeof(ReparseDataBuffer) ); ReparseDataBuffer.ReparseTag = IO_REPARSE_TAG_DFS; ReparseDataBuffer.ReparseDataLength = 0; NtStatus = NtFsControlFile( DirHandle, NULL, NULL, NULL, &IoStatusBlock, FSCTL_SET_REPARSE_POINT, &ReparseDataBuffer, REPARSE_DATA_BUFFER_HEADER_SIZE + ReparseDataBuffer.ReparseDataLength, NULL, 0 ); return NtStatus; } //+------------------------------------------------------------------------- // // Function: ClearDfsReparsePoint // // Arguments: DirHandle - handle on open directory // // Returns: SUCCESS or error // // Description: This routine takes a handle to an open directory and // makes that directory a reparse point with the DFS tag // //-------------------------------------------------------------------------- NTSTATUS DfsRootFolder::ClearDfsReparsePoint( IN HANDLE DirHandle ) { NTSTATUS NtStatus; REPARSE_DATA_BUFFER ReparseDataBuffer; IO_STATUS_BLOCK IoStatusBlock; // // Attempt to set a reparse point on the directory // RtlZeroMemory( &ReparseDataBuffer, sizeof(ReparseDataBuffer) ); ReparseDataBuffer.ReparseTag = IO_REPARSE_TAG_DFS; ReparseDataBuffer.ReparseDataLength = 0; NtStatus = NtFsControlFile( DirHandle, NULL, NULL, NULL, &IoStatusBlock, FSCTL_DELETE_REPARSE_POINT, &ReparseDataBuffer, REPARSE_DATA_BUFFER_HEADER_SIZE + ReparseDataBuffer.ReparseDataLength, NULL, 0 ); return NtStatus; } //+------------------------------------------------------------------------- // // Function: MorphLinkCollision // // Arguments: DirectoryName - Name of directory to morph. // // Returns: SUCCESS or error // // Description: This routine takes a NT pathname to a directory. It // renames that directory with a morphed name. // //-------------------------------------------------------------------------- NTSTATUS DfsRootFolder::MorphLinkCollision( LPWSTR DirectoryName ) { UNREFERENCED_PARAMETER(DirectoryName); return STATUS_NOT_SUPPORTED; } DFSSTATUS DfsRootFolder::TeardownLinkReparsePoint( LPWSTR LinkNameString ) { NTSTATUS NtStatus = STATUS_SUCCESS; HANDLE DirectoryHandle; UNICODE_STRING LinkName; BOOLEAN ImpersonationDisabled = FALSE; DfsDisableRpcImpersonation(&ImpersonationDisabled); if (IsRootFolderShareAcquired() == TRUE) { RtlInitUnicodeString( &LinkName, LinkNameString); NtStatus = OpenDirectory ( GetDirectoryCreatePathName(), FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, &DirectoryHandle, NULL ); if (NtStatus == STATUS_SUCCESS) { NtStatus = DeleteLinkReparsePoint( &LinkName, DirectoryHandle ); CloseDirectory( DirectoryHandle ); } } if (ImpersonationDisabled) { DfsReEnableRpcImpersonation(); } return NtStatus; } DFSSTATUS DfsRootFolder::SetupLinkReparsePoint( LPWSTR LinkNameString ) { NTSTATUS NtStatus = STATUS_SUCCESS; HANDLE DirectoryHandle; UNICODE_STRING LinkName; BOOLEAN ImpersonationDisabled = FALSE; DfsDisableRpcImpersonation(&ImpersonationDisabled); if (IsRootFolderShareAcquired() == TRUE) { RtlInitUnicodeString( &LinkName, LinkNameString); NtStatus = OpenDirectory ( GetDirectoryCreatePathName(), FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, &DirectoryHandle, NULL ); if (NtStatus == STATUS_SUCCESS) { NtStatus = CreateLinkReparsePoint( &LinkName, DirectoryHandle ); CloseDirectory( DirectoryHandle ); } if (NtStatus != STATUS_SUCCESS) { SetLastCreateDirectoryError(NtStatus); } } if (ImpersonationDisabled) { DfsReEnableRpcImpersonation(); } return NtStatus; } NTSTATUS DfsRootFolder::OpenDirectory( PUNICODE_STRING pDirectoryName, ULONG ShareMode, HANDLE RelativeHandle, PHANDLE pOpenedHandle, PBOOLEAN pIsNewlyCreated ) { NTSTATUS NtStatus; OBJECT_ATTRIBUTES ObjectAttributes; ACCESS_MASK DesiredAccess; PLARGE_INTEGER AllocationSize; ULONG FileAttributes; ULONG CreateDisposition; ULONG CreateOptions; IO_STATUS_BLOCK IoStatusBlock; AllocationSize = NULL; FileAttributes = FILE_ATTRIBUTE_NORMAL; CreateDisposition = FILE_OPEN_IF; CreateOptions = FILE_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT | FILE_SYNCHRONOUS_IO_NONALERT; DesiredAccess = FILE_READ_DATA | FILE_WRITE_DATA | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | SYNCHRONIZE; InitializeObjectAttributes ( &ObjectAttributes, pDirectoryName, //Object Name 0, //Attributes RelativeHandle, //Root handle NULL); //Security descriptor. NtStatus = NtCreateFile(pOpenedHandle, DesiredAccess, &ObjectAttributes, &IoStatusBlock, AllocationSize, FileAttributes, ShareMode, CreateDisposition, CreateOptions, NULL, // EaBuffer 0 ); // EaLength DFSLOG("Open on %wZ: Status %x\n", pDirectoryName, NtStatus); if ( (NtStatus == STATUS_SUCCESS) && (pIsNewlyCreated != NULL) ) { *pIsNewlyCreated = (IoStatusBlock.Information == FILE_CREATED)? TRUE : FALSE; } return NtStatus; } NTSTATUS DfsRootFolder::CreateLinkReparsePoint( PUNICODE_STRING pLinkName, HANDLE RelativeHandle ) { NTSTATUS NtStatus; ULONG ShareMode = 0; HANDLE DirectoryHandle; BOOLEAN IsNewlyCreated; DFSSTATUS DosStatus; NtStatus = OpenDirectory( pLinkName, ShareMode, RelativeHandle, &DirectoryHandle, &IsNewlyCreated ); if (NtStatus != STATUS_SUCCESS) { NtStatus = CreateLinkDirectories( pLinkName, RelativeHandle, &DirectoryHandle, &IsNewlyCreated ); } if (NtStatus == STATUS_SUCCESS) { NtStatus = SetDfsReparsePoint( DirectoryHandle); NtClose( DirectoryHandle); } DosStatus = RtlNtStatusToDosError(NtStatus); DFS_TRACE_ERROR_HIGH(DosStatus, REFERRAL_SERVER, "DirectoryName of interest %wZ: Create Reparse point Status %x\n", pLinkName, DosStatus); return DosStatus; } NTSTATUS DfsRootFolder::DeleteLinkReparsePoint( PUNICODE_STRING pDirectoryName, HANDLE ParentHandle ) { NTSTATUS NtStatus; HANDLE LinkDirectoryHandle; BOOLEAN IsReparsePoint, IsDfsReparsePoint; NtStatus = OpenDirectory( pDirectoryName, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, ParentHandle, &LinkDirectoryHandle, NULL ); if (NtStatus == STATUS_SUCCESS) { NtStatus = IsDirectoryReparsePoint( LinkDirectoryHandle, &IsReparsePoint, &IsDfsReparsePoint ); if ((NtStatus == STATUS_SUCCESS) && (IsDfsReparsePoint == TRUE) ) { NtStatus = ClearDfsReparsePoint( LinkDirectoryHandle ); } NtClose( LinkDirectoryHandle ); } if (NtStatus == STATUS_SUCCESS) { NtStatus = DeleteLinkDirectories( pDirectoryName, ParentHandle ); } return NtStatus; } NTSTATUS DfsRootFolder::CreateLinkDirectories( PUNICODE_STRING pLinkName, HANDLE RelativeHandle, PHANDLE pDirectoryHandle, PBOOLEAN pIsNewlyCreated ) { UNICODE_STRING DirectoryToCreate = *pLinkName; NTSTATUS NtStatus = STATUS_SUCCESS; ULONG ShareMode; HANDLE CurrentDirectory; ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, DirectoryToCreate.MaximumLength = DirectoryToCreate.Length; StripLastPathComponent( &DirectoryToCreate ); while ( (NtStatus == STATUS_SUCCESS) && (DirectoryToCreate.Length != 0) ) { NtStatus = OpenDirectory( &DirectoryToCreate, ShareMode, RelativeHandle, &CurrentDirectory, NULL ); if (NtStatus == ERROR_SUCCESS) { CloseDirectory( CurrentDirectory ); break; } NtStatus = StripLastPathComponent( &DirectoryToCreate ); } ShareMode = 0; while ( (NtStatus == STATUS_SUCCESS) && (DirectoryToCreate.Length != DirectoryToCreate.MaximumLength) ) { AddNextPathComponent( &DirectoryToCreate ); NtStatus = OpenDirectory( &DirectoryToCreate, ShareMode, RelativeHandle, &CurrentDirectory, pIsNewlyCreated ); if ( (NtStatus == ERROR_SUCCESS) && (DirectoryToCreate.Length != DirectoryToCreate.MaximumLength) ) { CloseDirectory( CurrentDirectory ); } } if (NtStatus == STATUS_SUCCESS) { *pDirectoryHandle = CurrentDirectory; } return NtStatus; } BOOLEAN DfsRootFolder::IsEmptyDirectory( HANDLE DirectoryHandle, PVOID pDirectoryBuffer, ULONG DirectoryBufferSize ) { NTSTATUS NtStatus; FILE_NAMES_INFORMATION *pFileInfo; ULONG NumberOfFiles = 1; BOOLEAN ReturnValue = FALSE; IO_STATUS_BLOCK IoStatus; NtStatus = NtQueryDirectoryFile ( DirectoryHandle, NULL, // no event NULL, // no apc routine NULL, // no apc context &IoStatus, pDirectoryBuffer, DirectoryBufferSize, FileNamesInformation, FALSE, // return single entry = false NULL, // filename FALSE ); // restart scan = false if (NtStatus == ERROR_SUCCESS) { pFileInfo = (FILE_NAMES_INFORMATION *)pDirectoryBuffer; while (pFileInfo->NextEntryOffset) { NumberOfFiles++; if (NumberOfFiles > 3) { break; } pFileInfo = (FILE_NAMES_INFORMATION *)((ULONG_PTR)(pFileInfo) + pFileInfo->NextEntryOffset); } if (NumberOfFiles <= 2) { ReturnValue = TRUE; } } return ReturnValue; } NTSTATUS DfsRootFolder::DeleteLinkDirectories( PUNICODE_STRING pLinkName, HANDLE RelativeHandle ) { UNICODE_STRING DirectoryToDelete = *pLinkName; NTSTATUS NtStatus = STATUS_SUCCESS; OBJECT_ATTRIBUTES ObjectAttributes; HANDLE CurrentDirectory = NULL; ULONG ShareMode = 0; const TCHAR * apszSubStrings[4]; ShareMode = FILE_SHARE_READ; // // dfsdev: fix this fixed size limit. it will hurt us in the future. // ULONG DirectoryBufferSize = 4096; PBYTE pDirectoryBuffer = new BYTE [DirectoryBufferSize]; if (pDirectoryBuffer == NULL) { NtStatus = STATUS_INSUFFICIENT_RESOURCES; } while ( (NtStatus == STATUS_SUCCESS) && (DirectoryToDelete.Length != 0) ) { NtStatus = OpenDirectory( &DirectoryToDelete, ShareMode, RelativeHandle, &CurrentDirectory, NULL ); if (NtStatus == ERROR_SUCCESS) { if (IsEmptyDirectory(CurrentDirectory, pDirectoryBuffer, DirectoryBufferSize) == FALSE) { CloseDirectory( CurrentDirectory ); apszSubStrings[0] = GetFolderLogicalNameString(); apszSubStrings[1] = GetDirectoryCreatePathName()->Buffer; GenerateEventLog(DFS_ERROR_DIRECTORY_NOT_EMPTY, 2, apszSubStrings, 0); break; } CloseDirectory( CurrentDirectory ); InitializeObjectAttributes ( &ObjectAttributes, &DirectoryToDelete, 0, RelativeHandle, NULL); NtStatus = NtDeleteFile( &ObjectAttributes ); StripLastPathComponent( &DirectoryToDelete ); } } if (pDirectoryBuffer != NULL) { delete [] pDirectoryBuffer; } return NtStatus; } VOID DfsRootFolder::CloseDirectory( HANDLE DirHandle ) { NtClose( DirHandle ); } //+------------------------------------------------------------------------- // // Function: AcquireRootShareDirectory // // Arguments: none // // Returns: Status: success if we passed all checks. // // Description: This routine checks to see if the share backing the // the dfs root actually exists. If it does, it confirms // that the filesystem hosting this directory supports // reparse points. Finally, it tells the driver to attach // to this directory. // If all of this works, we have acquired the root share. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::AcquireRootShareDirectory(void) { NTSTATUS NtStatus = STATUS_SUCCESS; DFSSTATUS Status = ERROR_SUCCESS; HANDLE DirHandle = NULL; PUNICODE_STRING pDirectoryName = NULL; PUNICODE_STRING pUseShare = NULL; BOOLEAN SubStringMatch = FALSE; BOOL Inserted = FALSE; OBJECT_ATTRIBUTES ObjectAttributes; IO_STATUS_BLOCK IoStatusBlock; ULONG pAttribInfoSize; PFILE_FS_ATTRIBUTE_INFORMATION pAttribInfo = NULL; const TCHAR * apszSubStrings[4]; pUseShare = GetRootPhysicalShareName(); DFS_TRACE_LOW(REFERRAL_SERVER, "AcquireRoot Share called for root %p, name %wZ\n", this, pUseShare); // // if either the root share is already acquired, or the library // was told that we are not interested in creating directories, we // are done. // if ( (IsRootFolderShareAcquired() == TRUE) || (DfsCheckCreateDirectories() == FALSE) ) { DFS_TRACE_LOW(REFERRAL_SERVER, "Root %p, Share Already acquired\n", this); return ERROR_SUCCESS; } // // first we get the logical share // Then we call into initialize directory information to setup the // physical share path etc. // Status = InitializeDirectoryCreateInformation(); // // If the directory create path is invalid, we are done. // if (Status == ERROR_SUCCESS) { pDirectoryName = GetDirectoryCreatePathName(); if ( (pDirectoryName == NULL) || (pDirectoryName->Buffer == NULL) || (pDirectoryName->Length == 0) ) { Status = ERROR_INVALID_PARAMETER; } } if (Status == ERROR_SUCCESS) { // // Now allocate space to fill the attribute information we // will query. // dfsdev: document why we allocate an additional max_path. // pAttribInfoSize = sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + MAX_PATH; pAttribInfo = (PFILE_FS_ATTRIBUTE_INFORMATION)new BYTE [pAttribInfoSize]; if (pAttribInfo != NULL) { InitializeObjectAttributes ( &ObjectAttributes, pDirectoryName, 0, //Attributes NULL, //Root handle NULL ); //Security descriptor. NtStatus = NtOpenFile( &DirHandle, (ACCESS_MASK)FILE_LIST_DIRECTORY | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT ); if (NtStatus == STATUS_SUCCESS) { // // Query for the basic information, which has the attributes. // NtStatus = NtQueryVolumeInformationFile( DirHandle, &IoStatusBlock, pAttribInfo, pAttribInfoSize, FileFsAttributeInformation ); if (NtStatus == STATUS_SUCCESS) { // // If the attributes indicate reparse point, we have a reparse // point directory on our hands. // if ( (pAttribInfo->FileSystemAttributes & FILE_SUPPORTS_REPARSE_POINTS) == 0) { NtStatus = STATUS_NOT_SUPPORTED; apszSubStrings[0] = pUseShare->Buffer; apszSubStrings[1] = pDirectoryName->Buffer; GenerateEventLog(DFS_ERROR_UNSUPPORTED_FILESYSTEM, 2, apszSubStrings, 0); } } CloseHandle (DirHandle); delete [] pAttribInfo; } if( NtStatus != STATUS_SUCCESS) { Status = RtlNtStatusToDosError(NtStatus); } } else { Status = ERROR_NOT_ENOUGH_MEMORY; } } DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "Root %p, Share check status %x\n", this, Status); // // Now check if we already know about parts of this path. // if there is overlap with other paths that we already know about, // we cannot handle this root, so reject it. // if (Status == ERROR_SUCCESS) { Status = DfsAddKnownDirectoryPath( pDirectoryName, pUseShare ); if (Status == ERROR_SUCCESS) { Inserted = TRUE; } else { apszSubStrings[0] = pUseShare->Buffer; apszSubStrings[1] = pDirectoryName->Buffer; GenerateEventLog(DFS_ERROR_OVERLAPPING_DIRECTORIES, 2, apszSubStrings, 0); } DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "Root %p, Share add known directory status %x\n", this, Status); } // // if we are here: we know this is a reparse point, and we have // inserted in the user mode database. // now call into the driver so it may attach to this filesystem. // if (Status == ERROR_SUCCESS) { Status = DfsUserModeAttachToFilesystem( pDirectoryName, pUseShare); DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "Root %p, user mode attach status %x\n", this, Status); } // // if we are successful, we acquired the root share, now mark // our state accordingly. // if (Status == ERROR_SUCCESS) { SetRootFolderShareAcquired(); } else { // // otherwise, clear up some of the work we just did. // ClearRootFolderShareAcquired(); if (Inserted == TRUE) { DfsRemoveKnownDirectoryPath( pDirectoryName, pUseShare); } } DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "AcquireRoot share for root %p, (%wZ) status %x\n", this, pUseShare, Status); return Status; } //+------------------------------------------------------------------------- // // Function: ReleaseRootShareDirectory // // Arguments: none // // Returns: Status: success if we are successful // // Description: This routine checks to see if the share backing the // the dfs root was acquired by us earlier. If so, we // tell the driver to releast its reference on this // share, and remove this information from our tables, // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::ReleaseRootShareDirectory(void) { NTSTATUS NtStatus = STATUS_SUCCESS; DFSSTATUS Status = ERROR_SUCCESS; PUNICODE_STRING pDirectoryName = NULL; PUNICODE_STRING pUseShare = NULL; PVOID pData = NULL; BOOLEAN SubStringMatch = FALSE; DFS_TRACE_LOW(REFERRAL_SERVER, "ReleaseRoot share for root %p\n", this); if (IsRootFolderShareAcquired() == TRUE) { // // get the logical share, and the physical directory backing the // share. // pUseShare = GetRootPhysicalShareName(); pDirectoryName = GetDirectoryCreatePathName(); if ( (pDirectoryName == NULL) || (pDirectoryName->Buffer == NULL) || (pDirectoryName->Length == 0) ) { Status = ERROR_INVALID_PARAMETER; } // // now, signal the driver to detach itself from this share. //dfsdev: if this fails, we are in an inconsistent state, since // we just removed it from our table above! // if (Status == ERROR_SUCCESS) { Status = DfsUserModeDetachFromFilesystem( pDirectoryName, pUseShare); DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "user mode detach path %wZ, %wZ: Status %x\n", pDirectoryName, pUseShare, Status ); } // // now, find the information in our database. if we did not find an // exact match, something went wrong and signal that. // if (Status == ERROR_SUCCESS) { DFSSTATUS RemoveStatus; RemoveStatus = DfsRemoveKnownDirectoryPath( pDirectoryName, pUseShare ); DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "RemoveKnownDirectory path %wZ, %wZ: Status %x\n", pDirectoryName, pUseShare, RemoveStatus ); } if (Status == ERROR_SUCCESS) { ClearRootFolderShareAcquired(); } } DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "Release root share %p, Status %x\n", this, Status ); return Status; } //+------------------------------------------------------------------------- // // Function: AddMetadataLink // // Arguments: // pLogicalName: the complete logical unc name of this link. // ReplicaServer: the target server for this link. // ReplicaPath: the target path on the server. // Comment : comment to be associated with this link. // // Returns: SUCCESS or error // // Description: This routine Adds a link to the metadata. // In future, ReplicaServer and ReplicaPath's // can be null, since we will allow links with // no targets. // dfsdev: make sure we do the right thing for // compat. // // Assumptions: the caller is responsible for mutual exclusion. // The caller is also responsible for ensuring // this link does not already exist in the // the metadata. // The caller is also responsible to make sure that this // name does not overlap an existing link. // (for example if link a/b exisits, link a or a/b/c are // overlapping links and should be disallowed.) //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::AddMetadataLink( PUNICODE_STRING pLogicalName, LPWSTR ReplicaServer, LPWSTR ReplicaPath, LPWSTR Comment ) { DFS_METADATA_HANDLE RootHandle = NULL; DFSSTATUS Status; UNICODE_STRING LinkMetadataName; UNICODE_STRING VisibleNameContext, UseName; DFS_NAME_INFORMATION NameInfo; DFS_REPLICA_LIST_INFORMATION ReplicaListInfo; DFS_REPLICA_INFORMATION ReplicaInfo; UUID NewUid; Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } Status = UuidCreate(&NewUid); if (Status == ERROR_SUCCESS) { Status = GetMetadataStore()->GenerateLinkMetadataName( &NewUid, &LinkMetadataName); } if (Status == ERROR_SUCCESS) { // // First get a handle to the // metadata. The handle has different meaning to different // underlying stores: for example the registry store may // use the handle as a key, while the ad store may use the // handle as a pointer in some cache. // Status = GetMetadataHandle( &RootHandle ); if (Status == ERROR_SUCCESS) { GetVisibleNameContext( NULL, &VisibleNameContext ); Status = GetMetadataStore()->GenerateMetadataLogicalName( &VisibleNameContext, pLogicalName, &UseName ); if (Status == ERROR_SUCCESS) { GetMetadataStore()->StoreInitializeNameInformation( &NameInfo, &UseName, &NewUid, Comment ); GetMetadataStore()->StoreInitializeReplicaInformation( &ReplicaListInfo, &ReplicaInfo, ReplicaServer, ReplicaPath ); Status = GetMetadataStore()->AddChild( RootHandle, &NameInfo, &ReplicaListInfo, &LinkMetadataName ); // // if we failed add child, we need to reset the // internal state to wipe out any work we did when // we were adding the child. // if (Status != ERROR_SUCCESS) { ReSynchronize(); } GetMetadataStore()->ReleaseMetadataLogicalName(&UseName ); // // if we successfully added the link, update the link information // so that we can pass this out in referrals, and create the appropriate // directories. // if (Status == ERROR_SUCCESS) { DFSSTATUS LinkUpdateStatus; LinkUpdateStatus = UpdateLinkInformation( RootHandle, LinkMetadataName.Buffer ); } } // // Finally, release the root handle we acquired earlier. // ReleaseMetadataHandle( RootHandle ); } GetMetadataStore()->ReleaseLinkMetadataName( &LinkMetadataName ); } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: RemoveMetadataLink // // Arguments: // pLogicalName: the link name relative to root share // // Returns: SUCCESS or error // // Description: This routine removes a link from the the metadata. // // Assumptions: the caller is responsible for mutual exclusion. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::RemoveMetadataLink( PUNICODE_STRING pLinkName ) { DFS_METADATA_HANDLE RootHandle; DFSSTATUS Status; LPWSTR LinkMetadataName; DfsFolder *pFolder; UNICODE_STRING Remaining; Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } // // First, look this link up in our local data structures. // Status = LookupFolderByLogicalName( pLinkName, &Remaining, &pFolder ); // // if an EXACT match was not found, we are done. // if ( (Status == ERROR_SUCCESS) && (Remaining.Length != 0) ) { pFolder->ReleaseReference(); Status = ERROR_NOT_FOUND; } // // we found the child folder. Now work on removing the metadata // and our local structures associated with this link. // if (Status == ERROR_SUCCESS) { // // Get a handle to our metadata. // Status = GetMetadataHandle( &RootHandle ); // //Now, look up the metadata name and remove it from the store. // if (Status == ERROR_SUCCESS) { LinkMetadataName = pFolder->GetFolderMetadataNameString(); Status = GetMetadataStore()->RemoveChild( RootHandle, LinkMetadataName ); if (Status != ERROR_SUCCESS) { ReSynchronize(); } ReleaseMetadataHandle( RootHandle ); // // If we successfully removed the child from the metadata, // remove the link folder associated with this child. This will // get rid of our data structure and related directory for that child. // if (Status == ERROR_SUCCESS) { DFSSTATUS RemoveStatus; RemoveStatus = RemoveLinkFolder( pFolder, TRUE ); // permanent removal } } pFolder->ReleaseReference(); } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: AddMetadataLinkReplica // // Arguments: // pLinkName: the link name relative to root share // ReplicaServer : the target server to add // ReplicaPath : the target path on the server. // // Returns: SUCCESS or error // // Description: This routine adds a target to an existing link. // // Assumptions: the caller is responsible for mutual exclusion. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::AddMetadataLinkReplica( PUNICODE_STRING pLinkName, LPWSTR ReplicaServer, LPWSTR ReplicaPath ) { DFS_METADATA_HANDLE RootHandle; DFSSTATUS Status = ERROR_SUCCESS; DfsFolder *pFolder; UNICODE_STRING Remaining; LPWSTR LinkMetadataName; // // If either the target server or the path is null, reject the request. // if ((ReplicaServer == NULL) || (ReplicaPath == NULL)) { return ERROR_INVALID_PARAMETER; } Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } // // Find the link folder associated with this logical name. // Status = LookupFolderByLogicalName( pLinkName, &Remaining, &pFolder ); // // If we did not find an EXACT match on the logical name, we are done. // if ( (Status == ERROR_SUCCESS) && (Remaining.Length != 0) ) { pFolder->ReleaseReference(); Status = ERROR_NOT_FOUND; } // // if we are successful so far, call the store with a handle to // the metadata to add this target. // if (Status == ERROR_SUCCESS) { // // get the metadata name for this link from the root folder. // LinkMetadataName = pFolder->GetFolderMetadataNameString(); // // Get a handle to the root metadata this root folder. // Status = GetMetadataHandle( &RootHandle ); if (Status == ERROR_SUCCESS) { Status = GetMetadataStore()->AddChildReplica( RootHandle, LinkMetadataName, ReplicaServer, ReplicaPath ); if (Status != ERROR_SUCCESS) { ReSynchronize(); } // // Release the metadata handle we acquired earlier. // ReleaseMetadataHandle( RootHandle ); } // // If we successfully added the target in the metadata, update the // link folder so that the next referral request will pick up the // new target. // if (Status == ERROR_SUCCESS) { DFSSTATUS UpdateStatus; UpdateStatus = UpdateLinkFolder( LinkMetadataName, pLinkName, pFolder ); // // dfsdev: log the update state. // } // // we are done with this link folder: release thre reference we got // when we looked it up. // pFolder->ReleaseReference(); } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: RemoveMetadataLinkReplica // // Arguments: // pLinkName: the link name relative to root share // ReplicaServer : the target server to remove // ReplicaPath : the target path on the server. // pLastReplica: pointer to boolean, returns true if the last // target on this link is being deleted. // // Returns: SUCCESS or error // // Description: This routine removes the target of an existing link. // // Assumptions: the caller is responsible for mutual exclusion. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::RemoveMetadataLinkReplica( PUNICODE_STRING pLinkName, LPWSTR ReplicaServer, LPWSTR ReplicaPath, PBOOLEAN pLastReplica ) { LPWSTR LinkMetadataName; DFS_METADATA_HANDLE RootHandle; UNICODE_STRING Remaining; DFSSTATUS Status; DfsFolder *pFolder; // // if either the target server or target path is empty, return error. // if ((ReplicaServer == NULL) || (ReplicaPath == NULL)) { return ERROR_INVALID_PARAMETER; } Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } // //find the link folder associated with this logical name. // Status = LookupFolderByLogicalName( pLinkName, &Remaining, &pFolder ); // // if we did not find an EXACT match on the logical name, we are done. // if ( (Status == ERROR_SUCCESS) && (Remaining.Length != 0) ) { pFolder->ReleaseReference(); Status = ERROR_NOT_FOUND; } // // Call the store to remove the target from this child. // if (Status == ERROR_SUCCESS) { // // Get the link metadata name from the folder. // LinkMetadataName = pFolder->GetFolderMetadataNameString(); // // Get the handle to the root metadata for this root folder. // Status = GetMetadataHandle( &RootHandle ); if (Status == ERROR_SUCCESS) { Status = GetMetadataStore()->RemoveChildReplica( RootHandle, LinkMetadataName, ReplicaServer, ReplicaPath, pLastReplica ); if (Status != ERROR_SUCCESS) { ReSynchronize(); } // // release the metadata handle we acquired a little bit earlier. // ReleaseMetadataHandle( RootHandle ); } // // if we are successful in removing the target, update the link // folder so that future referrals will no longer see the target // we just deleted. // if (Status == ERROR_SUCCESS) { DFSSTATUS UpdateStatus; UpdateStatus = UpdateLinkFolder( LinkMetadataName, pLinkName, pFolder ); DFSLOG("Remove link replica, update link folder status %x\n", UpdateStatus); } pFolder->ReleaseReference(); } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: EnumerateApiLinks // // Arguments: // LPWSTR DfsPathName : the dfs root to enumerate. // DWORD Level : the enumeration level // LPBYTE pBuffer : buffer to hold results. // LONG BufferSize, : buffer size // LPDWORD pEntriesRead : number of entries to read. // LPDWORD pResumeHandle : the starting child to read. // PLONG pNextSizeRequired : return value to hold size required in case of overflow. // // Returns: SUCCESS or error // // Description: This routine enumerates the dfs metadata information. // // Assumptions: the caller is responsible for mutual exclusion. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::EnumerateApiLinks( LPWSTR DfsPathName, DWORD Level, LPBYTE pBuffer, LONG BufferSize, LPDWORD pEntriesRead, LPDWORD pResumeHandle, PLONG pNextSizeRequired ) { DFSSTATUS Status; DFS_METADATA_HANDLE RootHandle; UNICODE_STRING VisibleNameContext; UNICODE_STRING DfsPath; Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } RtlInitUnicodeString( &DfsPath, DfsPathName ); // // Get the name context for this call. // do not use the user passed in name context within the path // for this call: if the user comes in with an ip address, we want // to return back the correct server/domain info to the caller // so the dfsapi results will not show the ip address etc. // GetVisibleNameContext( NULL, &VisibleNameContext ); // // Get the handle to the metadata for this root folder, and call // the store to enumerate the links. // Status = GetMetadataHandle( &RootHandle ); if (Status == ERROR_SUCCESS) { Status = GetMetadataStore()->EnumerateApiLinks( RootHandle, &VisibleNameContext, Level, pBuffer, BufferSize, pEntriesRead, pResumeHandle, pNextSizeRequired); // // Release the metadata handle. // ReleaseMetadataHandle( RootHandle ); } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: GetApiInformation // // Arguments: // PUNICODE DfsPathName : the dfs root name // PUNICODE pLinkName : the link within the root. // DWORD Level : the info level. // LPBYTE pBuffer : buffer to hold results. // LONG BufferSize, : buffer size // PLONG pSizeRequired : return value to hold size required in case of overflow. // // Returns: SUCCESS or error // // Description: This routine gets the required information for a given root or link // // Assumptions: the caller is responsible for mutual exclusion. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::GetApiInformation( PUNICODE_STRING pDfsName, PUNICODE_STRING pLinkName, DWORD Level, LPBYTE pBuffer, LONG BufferSize, PLONG pSizeRequired ) { UNREFERENCED_PARAMETER(pDfsName); DFSSTATUS Status; DFS_METADATA_HANDLE RootHandle; LPWSTR MetadataName; DfsFolder *pFolder; UNICODE_STRING VisibleNameContext; UNICODE_STRING Remaining; Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } // // // Do not base the context to use on the passed in dfsname: // it is important to pass back our correct information // in the api call. // // GetVisibleNameContext( NULL, &VisibleNameContext ); // // If the link name is empty, we are dealing with the root. // so set the metadata name to null. // if (pLinkName->Length == 0) { MetadataName = NULL; Status = ERROR_SUCCESS; } // // otherwise, lookup the link folder and get the metadataname for that link. // else { Status = LookupFolderByLogicalName( pLinkName, &Remaining, &pFolder ); // // if we did not find an EXACT match on the logical name, we are done. // if ( (Status == ERROR_SUCCESS) && (Remaining.Length != 0) ) { pFolder->ReleaseReference(); Status = ERROR_NOT_FOUND; } // // we had an exact match, so lookup the metadata name and release the // the reference on the folder. // if (Status == ERROR_SUCCESS) { MetadataName = pFolder->GetFolderMetadataNameString(); pFolder->ReleaseReference(); } } // // we got the metadata name: now call into the store to get the // required information for the metadata name. // if (Status == ERROR_SUCCESS) { // // Get the handle to the metadata for this root folder. // Status = GetMetadataHandle( &RootHandle ); if (Status == ERROR_SUCCESS) { Status = GetMetadataStore()->GetStoreApiInformation( RootHandle, &VisibleNameContext, MetadataName, Level, pBuffer, BufferSize, pSizeRequired); ReleaseMetadataHandle( RootHandle ); } } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: SetApiInformation // // Arguments: // PUNICODE pLinkName : the name of link relative to root share // LPWSTR Server, : the target server. // LPWSTR Share, : the target path within the server. // DWORD Level : the info level. // LPBYTE pBuffer : buffer that has the information to be set. // // Returns: SUCCESS or error // // Description: This routine sets the required information for a given root or link // // Assumptions: the caller is responsible for mutual exclusion. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::SetApiInformation( PUNICODE_STRING pLinkName, LPWSTR Server, LPWSTR Share, DWORD Level, LPBYTE pBuffer ) { DFSSTATUS Status; DFS_METADATA_HANDLE RootHandle; LPWSTR MetadataName; DfsFolder *pFolder; UNICODE_STRING Remaining; Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } // // if the link name is empty we are dealing with // the root itself. // dfsdev: we need to set the root metadata appropriately! // if (pLinkName->Length == 0) { MetadataName = NULL; Status = ERROR_SUCCESS; } // // else get to the link folder, and get // the link metadata name. // else { Status = LookupFolderByLogicalName( pLinkName, &Remaining, &pFolder ); // // if we did not find an EXACT match on the logical name, we are done. // if ( (Status == ERROR_SUCCESS) && (Remaining.Length != 0) ) { pFolder->ReleaseReference(); Status = ERROR_NOT_FOUND; } if (Status == ERROR_SUCCESS) { MetadataName = pFolder->GetFolderMetadataNameString(); // // if we got the metadataname, call the store with the // details so that it can associate the information // with this root or link. // // // Get the handle to the root of this metadata // Status = GetMetadataHandle( &RootHandle ); if (Status == ERROR_SUCCESS) { Status = GetMetadataStore()->SetStoreApiInformation( RootHandle, MetadataName, Server, Share, Level, pBuffer ); if (Status != ERROR_SUCCESS) { ReSynchronize(); } ReleaseMetadataHandle( RootHandle ); } // // If we successfully updated the metadata, update the // link folder so that the next referral request will pick up the // changes // if (Status == ERROR_SUCCESS) { DFSSTATUS UpdateStatus; UpdateStatus = UpdateLinkFolder( MetadataName, pLinkName, pFolder ); // // dfsdev: log the update state. // } pFolder->ReleaseReference(); } } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: LoadReferralData - Loads the referral data. // // Arguments: pReferralData - the referral data to load // // Returns: Status: Success or error code // // Description: This routine sets up the ReferralData instance to have // all the information necessary to create a referral. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::LoadReferralData( DfsFolderReferralData *pReferralData ) { DFS_METADATA_HANDLE RootMetadataHandle; DFSSTATUS Status; DfsFolder *pFolder; // // Get the Root key for this root folder. // DFS_TRACE_LOW( REFERRAL_SERVER, "LoadReferralData called, %p\n", pReferralData); Status = GetMetadataHandle( &RootMetadataHandle ); if ( Status == ERROR_SUCCESS ) { // // Now get the owning folder of the referralDAta. Note that // this does not give us a new reference on the Folder. // however, the folder is guaranteed to be around till // we return from this call, since the pReferralData that // was passed in to us cannot go away. // pFolder = pReferralData->GetOwningFolder(); DFS_TRACE_LOW( REFERRAL_SERVER, "Load referral data, Got Owning Folder %p\n", pFolder ); // // Now load the replica referral data for the passed in folder. // Status = LoadReplicaReferralData( RootMetadataHandle, pFolder->GetFolderMetadataNameString(), pReferralData ); DFS_TRACE_LOW( REFERRAL_SERVER, "LoadReferralData for %p replica data loaded %x\n", pReferralData, Status ); if ( Status == ERROR_SUCCESS ) { // // Load the policy referrral data for the passedin folder. // Status = LoadPolicyReferralData( RootMetadataHandle ); } ReleaseMetadataHandle( RootMetadataHandle ); } DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "Done load referral data %p, Status %x\n", pReferralData, Status); return Status; } //+------------------------------------------------------------------------- // // Function: UnloadReferralData - Unload the referral data. // // Arguments: pReferralData - the ReferralData instance to unload. // // Returns: Status: Success or Error status code. // // Description: This routine Unloads the referral data. It undoes what // the corresponding load routine did. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::UnloadReferralData( DfsFolderReferralData *pReferralData ) { DFSSTATUS Status; DFS_TRACE_LOW( REFERRAL_SERVER, "Unload referral data %p\n", pReferralData); Status = UnloadReplicaReferralData( pReferralData ); if ( Status == ERROR_SUCCESS ) { Status = UnloadPolicyReferralData( pReferralData ); } DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Unload referral data %p, Status %x\n", pReferralData, Status); return Status; } //+------------------------------------------------------------------------- // // Function: LoadReplicaReferralData - load the replica information. // // Arguments: RegKey - the registry key of the root folder, // RegistryName - Name of the registry key relative to to Root Key // pReferralData - the referral data to load. // // Returns: Status - Success or error status code. // // Description: This routine loads the replica referral data for the // the passed in ReferralData instance. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::LoadReplicaReferralData( DFS_METADATA_HANDLE RootMetadataHandle, LPWSTR MetadataName, DfsFolderReferralData *pReferralData ) { PDFS_REPLICA_LIST_INFORMATION pReplicaListInfo; PDFS_REPLICA_INFORMATION pReplicaInfo; PUNICODE_STRING pServerName; DfsReplica *pReplica; DFSSTATUS Status; ULONG Replica; DFS_TRACE_LOW( REFERRAL_SERVER, "Load Replica Referral Data %ws, for %p\n", MetadataName, pReferralData); pReferralData->pReplicas = NULL; // // Get the replica information. // Status = GetMetadataStore()->GetMetadataReplicaInformation(RootMetadataHandle, MetadataName, &pReplicaListInfo ); if ( Status == ERROR_SUCCESS ) { // // Set the appropriate count, and allocate the replicas // required. // pReferralData->ReplicaCount = pReplicaListInfo->ReplicaCount; if (pReferralData->ReplicaCount > 0) { pReferralData->pReplicas = new DfsReplica [ pReplicaListInfo->ReplicaCount ]; if ( pReferralData->pReplicas == NULL ) { Status = ERROR_NOT_ENOUGH_MEMORY; } } } // // Now, for each replica, set the replicas server name, the target // folder and the replica state. // if ( Status == ERROR_SUCCESS ) { for ( Replica = 0; (Replica < pReplicaListInfo->ReplicaCount) && (Status == ERROR_SUCCESS); Replica++ ) { pReplicaInfo = &pReplicaListInfo->pReplicas[Replica]; pReplica = &pReferralData->pReplicas[ Replica ]; pServerName = &pReplicaInfo->ServerName; // // If the servername is a ., this is a special case where // the servername is the root itself. In this case, // set the server name to the name of this machine. // if (IsLocalName(pServerName)) { GetVisibleNameContext( NULL, pServerName ); } Status = pReplica->SetTargetServer( pServerName ); if ( Status == ERROR_SUCCESS ) { Status = pReplica->SetTargetFolder( &pReplicaInfo->ShareName ); } if ( Status == ERROR_SUCCESS ) { if ( pReplicaInfo->ReplicaState & REPLICA_STORAGE_STATE_OFFLINE ) { pReplica->SetTargetOffline(); } } } // // Now release the replica information that was allocated // by the store. // GetMetadataStore()->ReleaseMetadataReplicaInformation( RootMetadataHandle, pReplicaListInfo ); } DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Done with Load Replica Referral Data %ws, for %p, Status %x\n", MetadataName, pReferralData, Status); return Status; } //+------------------------------------------------------------------------- // // Function: UnloadReplicaReferralData - Unload the replicas // // Arguments: pReferralData - the DfsFolderReferralData to unload // // Returns: Status: Success always. // // Description: This routine gets rid of the allocate replicas in the // folder's referral data. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::UnloadReplicaReferralData( DfsFolderReferralData *pReferralData ) { if (pReferralData->pReplicas != NULL) { delete [] pReferralData->pReplicas; pReferralData->pReplicas = NULL; } return ERROR_SUCCESS; } //+------------------------------------------------------------------------- // // Function: SetRootStandby - set the root in a standby mode. // // Arguments: none // // Returns: Status: Success always for now. // // Description: This routine checks if we are already in standby mode. // If not, it releases the root share directory, removes // all the link folders and set the root in a standby mode // DFSDEV: need to take into consideration synchronization // with other threads. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::SetRootStandby() { DFSSTATUS Status = ERROR_SUCCESS; Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } DFS_TRACE_LOW( REFERRAL_SERVER, "Root %p being set to standby\n", this); if (IsRootFolderStandby() == FALSE) { // // dfsdev:: ignore error returns from these calls? // DFSSTATUS ReleaseStatus; ReleaseStatus = ReleaseRootShareDirectory(); DFS_TRACE_ERROR_LOW( ReleaseStatus, REFERRAL_SERVER, "Release root share status %x\n", ReleaseStatus); RemoveAllLinkFolders( FALSE ); // Not a permanent removal SetRootFolderStandby(); } else { DFS_TRACE_LOW( REFERRAL_SERVER, "Root %p was already standby\n", this); } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: SetRootResynchronize - set the root in a ready mode. // // Arguments: none // // Returns: Status: Success always for now. // // Description: This routine checks if we are already in ready mode. // If not, it acquires the root share directory, calls // synchronize to add all the links back // DFSDEV: need to take into consideration synchronization // with other threads. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::SetRootResynchronize() { DFSSTATUS Status = ERROR_SUCCESS; DFSSTATUS RootStatus; Status = AcquireRootLock(); if (Status != ERROR_SUCCESS) { return Status; } DFS_TRACE_LOW( REFERRAL_SERVER, "Root %p being resynced\n", this); // // if the root folder is already marked available, we are done // otherwise, clear the standby mode, and try to bring this // root into a useable state. // if (!IsRootFolderAvailable()) { ClearRootFolderStandby(); // //need to take appropriate locks. // RootStatus = Synchronize(); DFS_TRACE_ERROR_LOW( RootStatus, REFERRAL_SERVER, "Set root resync: Synchronize status for %p is %x\n", this, RootStatus); } else { ReSynchronize(); } ReleaseRootLock(); return Status; } //+------------------------------------------------------------------------- // // Function: UpdateLinkInformation // // Arguments: // DfsMetadataHandle - the parent handle // LPWSTR ChildName - the child name // // Returns: Status: Success or Error status code // // Description: This routine reads the metadata for the child and, updates // the child folder if necessary. This includes adding // the folder if it does not exist, or if the folder exists // but the metadata is newer, ensuring that all future // request use the most upto date data. // //-------------------------------------------------------------------------- DFSSTATUS DfsRootFolder::UpdateLinkInformation( IN DFS_METADATA_HANDLE DfsHandle, LPWSTR ChildName ) { DFSSTATUS Status = ERROR_SUCCESS; ULONG Timeout = 0; PDFS_NAME_INFORMATION pChild = NULL; DfsFolder *pChildFolder = NULL; FILETIME LastModifiedTime; UNICODE_STRING LinkName; // // Now that we have the child name, get the name information // for this child. This is the logical namespace information // for this child. // Status = GetMetadataStore()->GetMetadataNameInformation( DfsHandle, ChildName, &pChild); if ( Status == ERROR_SUCCESS ) { Timeout = pChild->Timeout; // // we want to ignore the root entry here. hardcode 81 till // we get the defines in the right place // dfsdev: fix this. //if(pChild->Type == (PKT_ENTRY_TYPE_REFERRAL_SVC | PKT_ENTRY_TYPE_CAIRO)) if(pChild->Type == 0x81) { SetTimeout(Timeout); GetMetadataStore()->ReleaseMetadataNameInformation( DfsHandle, pChild ); return Status; } } if (Status == ERROR_SUCCESS) { LastModifiedTime = pChild->LastModifiedTime; // // Now translate the metadata logical name to a relative // link name: each store has its own behavior, so // the getlinkname function is implemented by each store. // Status = GetMetadataLogicalToLinkName(&pChild->Prefix, &LinkName); if ( Status == ERROR_SUCCESS ) { Status = LookupFolderByMetadataName( ChildName, &pChildFolder ); if ( Status == ERROR_SUCCESS ) { // // IF we already know this child, check if the child // has been updated since we last visited it. // If so, we need to update the child. // if ( pChildFolder->UpdateRequired( FILETIMETO64(LastModifiedTime) ) ) { DFSLOG("Updating child %p\n", pChildFolder ); Status = UpdateLinkFolder( ChildName, &LinkName, pChildFolder ); } // // we now check if we need to create root directories for even // those folders that we already know about. This may be true // when we had one or more errors creating the // directory when we initially created this folder or it may // be true when we are going from standby to master. // if (IsRootDirectoriesCreated() == FALSE) { DFSSTATUS CreateStatus; CreateStatus = SetupLinkReparsePoint(pChildFolder->GetFolderLogicalNameString()); DFSLOG("CreateStatus is %x\n", CreateStatus); } } else if ( Status == ERROR_NOT_FOUND ) { // // We have not seen this child before: create // a new one. // Status = CreateLinkFolder( ChildName, &LinkName, &pChildFolder ); DFSLOG("Adding new child %wS, %p status %x", ChildName, pChildFolder, Status ); } ReleaseMetadataLogicalToLinkName( &LinkName ); } // // Now release the name information of the child. // GetMetadataStore()->ReleaseMetadataNameInformation( DfsHandle, pChild ); } // // We were successful. We have a child folder that is // returned to us with a valid reference. Set the Last // modified time in the folder, and release our reference // on the child folder. // if ( Status == ERROR_SUCCESS ) { pChildFolder->SetTimeout(Timeout); pChildFolder->SetUSN( FILETIMETO64(LastModifiedTime) ); pChildFolder->ReleaseReference(); } return Status; } void DfsRootFolder::GenerateEventLog(DWORD EventMsg, WORD Substrings, const TCHAR * apszSubStrings[], DWORD Errorcode) { if(InterlockedIncrement(&_CurrentErrors) < DFS_MAX_ROOT_ERRORS) { DfsLogDfsEvent(EventMsg, Substrings, apszSubStrings, Errorcode); } }