Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2354 lines
72 KiB

//+----------------------------------------------------------------------------
//
// Copyright (C) 2000, Microsoft Corporation
//
// File: DfsADBlobStore.cxx
//
// Contents: the AD Blob DFS Store class, this contains the registry
// specific functionality.
//
// Classes: DfsADBlobStore.
//
// History: Dec. 8 2000, Author: udayh
// April 9 2001 Rohanp - Added ADSI specific code
//
//-----------------------------------------------------------------------------
#include "DfsADBlobStore.hxx"
#include "DfsADBlobRootFolder.hxx"
#include "DfsFilterApi.hxx"
#include "dfsmisc.h"
#include "lmdfs.h"
#include "shlwapi.h"
#include "align.h"
#include "dfserror.hxx"
#include "DomainControllerSupport.hxx"
#include "dfsadsiapi.hxx"
#include "dfsinit.hxx"
#include "DfsAdBlobStore.tmh"
//+----------------------------------------------------------------------------
//
// Class: DfsADBlobStore.
//
// Synopsis: This class inherits the basic DfsStore, and extends it
// to include the blob DS specific functionality.
//
//-----------------------------------------------------------------------------
//+-------------------------------------------------------------------------
//
// Function: StoreRecognizer - the recognizer for the store.
//
// Arguments: Name - the namespace of interest.
//
// Returns: Status
// ERROR_SUCCESS on success
// ERROR status code otherwise
//
//
// Description: This routine checks if the specified namespace holds
// a domain based DFS. If it does, it reads in the
// root in that namespace and creates and adds it to our
// list of known roots, if it doesn't already exist in our list.
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::StoreRecognizer(
LPWSTR Name )
{
DFSSTATUS Status = ERROR_SUCCESS;
HKEY ADBlobDfsKey;
BOOLEAN MachineContacted = FALSE;
DFSSTATUS NewDfsStatus = ERROR_SUCCESS;
//
// Make sure the namespace is the name of a machine. FT based
// dfs exist only on domains.
//
if (IsEmptyString(Name) == FALSE)
{
Status = DfsIsThisADomainName( Name );
}
DFS_TRACE_LOW(REFERRAL_SERVER, "DfsADBlob:StoreRecognizer, %ws Is domain Status %x\n",
Name, Status);
//
// Now, open the registry key where we store all the DFS root
// information.
//
if ( Status == ERROR_SUCCESS )
{
Status = GetNewADBlobRegistryKey( Name,
FALSE, // write permission not required
&MachineContacted,
&ADBlobDfsKey );
if (Status == ERROR_SUCCESS)
{
Status = StoreRecognizeNewDfs( Name,
ADBlobDfsKey );
RegCloseKey( ADBlobDfsKey );
}
}
//
// Need to refine the return status further: success should mean
// machine is not domain dfs or we have read the domain dfs data
// correctly.
//
DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "DfsADBlob:StoreRecognizer, Status %x\n",
Status);
return Status;
}
//+-------------------------------------------------------------------------
//
// Function: StoreRecognizer - the recognizer for the store.
//
// Arguments: DfsNameContext - the namespace of interest.
// LogicalShare
//
// Returns: Status
// ERROR_SUCCESS on success
// ERROR status code otherwise
//
//
// Description: This routine checks if the specified namespace holds
// a domain based DFS. If it does, it reads in the
// root in that namespace and creates and adds it to our
// list of known roots, if it doesn't already exist in our list.
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::StoreRecognizer (
LPWSTR DfsNameContext,
PUNICODE_STRING pLogicalShare )
{
DFSSTATUS Status;
Status = DfsIsThisADomainName( DfsNameContext );
if (Status == ERROR_SUCCESS)
{
Status = StoreRecognizeNewDfs( DfsNameContext,
pLogicalShare );
}
DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "DfsADBlob:StoreRecognizer (remote), Status %x\n",
Status);
return Status;
}
//+-------------------------------------------------------------------------
//
// Function: CreateNewRootFolder - creates a new root folder
//
// Arguments:
// LPWSTR DfsNameContextString - name context string
// LPWSTR RootRegKeyName - the registry holding the information about this root.
// PUNICODE_STRING pLogicalShare - the logical share name.
// PUNICODE_STRING pPhysicalShare - the physical share name.
// DfsRootFolder **ppRoot - root to return.
//
//
// Returns: Status
// ERROR_SUCCESS on success
// ERROR status code otherwise
//
//
// Description: This routine creates a new root folder, and
// adds it to the list of known roots.
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::CreateNewRootFolder (
LPWSTR DfsNameContextString,
LPWSTR RootRegKeyName,
PUNICODE_STRING pLogicalShare,
PUNICODE_STRING pPhysicalShare,
DfsRootFolder **ppRoot )
{
DFSSTATUS Status = ERROR_SUCCESS;
DfsRootFolder *pNewRoot = NULL;
//
// Create a new instance of the RegistryRootFolder class.
// This gives us a reference RootFolder.
//
pNewRoot = new DfsADBlobRootFolder( DfsNameContextString,
RootRegKeyName,
pLogicalShare,
pPhysicalShare,
this,
&Status );
if ( NULL == pNewRoot )
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
if ( ERROR_SUCCESS == Status )
{
//
// AddRootFolder to the list of known roots. AddRootFolder
// is responsible to acquire any reference on the root folder
// if it is storing a reference to this root.
Status = AddRootFolder( pNewRoot, NewRootList );
if ( ERROR_SUCCESS == Status )
{
//
// We were successful, return the reference root. The reference
// that we are returning is the create reference on the new root.
//
*ppRoot = pNewRoot;
}
else
{
pNewRoot->ReleaseReference();
pNewRoot = NULL;
}
}
else
{
//
// Our constructor may have failed. E.g. DC may be down.
// Release our reference to this root and unwind.
//
if (pNewRoot != NULL) {
pNewRoot->ReleaseReference();
pNewRoot = NULL;
}
}
DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "ADBlobStore::CreateNewRootFolder. New root %p, for share %wZ (%wZ) on machine %ws. Status %x\n",
pNewRoot, pLogicalShare, pPhysicalShare, DfsNameContextString, Status);
return Status;
}
//+-------------------------------------------------------------------------
//
// Function: GetMetadataReplicaBlob - gets the replica blob
//
// Arguments: DfsMetadataHandle - the handle to the root
// MetadataName - name of the metadata
// ppBlob - the replica blob
// pBlobSize-size of blob
// pLastModifiedTime - time the blob was last modified
//
// Returns: Status
// STATUS_SUCCESS if we could read the information
// error status otherwise.
//
//
// Description: This routine read the replica blob and returns a copy
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::GetMetadataReplicaBlob(
IN DFS_METADATA_HANDLE DfsMetadataHandle,
IN LPWSTR MetadataName,
OUT PVOID *ppBlob,
OUT PULONG pBlobSize,
OUT PFILETIME pLastModifiedTime )
{
UNREFERENCED_PARAMETER(pLastModifiedTime); // dfsdev: investigate.
DFSSTATUS Status = ERROR_SUCCESS;
PVOID pMetadata;
ULONG MetadataSize;
PVOID pUseBlob;
ULONG UseBlobSize;
PVOID pReplicaBlob = NULL;
ULONG ReplicaBlobSize;
PDFS_NAME_INFORMATION pNameInformation = NULL;
Status = GetMetadata( (PVOID)DfsMetadataHandle,
MetadataName,
NULL,
&pMetadata,
&MetadataSize,
NULL); // pass NULL For time information.
if (Status == ERROR_SUCCESS)
{
pNameInformation = new DFS_NAME_INFORMATION;
if(pNameInformation != NULL)
{
RtlZeroMemory (pNameInformation, sizeof(DFS_NAME_INFORMATION));
pUseBlob = ((PDFSBLOB_DATA)(pMetadata))->pBlob;
UseBlobSize = MetadataSize;
Status = PackGetNameInformation( pNameInformation,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
PackGetULong( &ReplicaBlobSize,
&pUseBlob,
&UseBlobSize );
if(ReplicaBlobSize > UseBlobSize)
{
Status = ERROR_INVALID_DATA;
}
else
{
pReplicaBlob = (PVOID) new unsigned char [ReplicaBlobSize];
if(pReplicaBlob != NULL)
{
RtlCopyMemory(pReplicaBlob, pUseBlob, ReplicaBlobSize);
}
else
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
}
}
delete pNameInformation;
}
else
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
ReleaseMetadata( (PVOID)DfsMetadataHandle, pMetadata );
}
//
// If we were successful, return the read in information. Otherwise free
// up the allocate resources and return error.
//
if ( Status == STATUS_SUCCESS )
{
*ppBlob = pReplicaBlob;
*pBlobSize = ReplicaBlobSize;
}
return Status;
}
//+-------------------------------------------------------------------------
//
// Function: GetMetadataNameBlob - gets the name blob
//
// Arguments: DfsMetadataHandle - the handle to the root
// MetadataName - name of the metadata
// ppBlob - the name blob
// pBlobSize-size of blob
// pLastModifiedTime - time the blob was last modified
//
// Returns: Status
// STATUS_SUCCESS if we could read the information
// error status otherwise.
//
//
// Description: This routine read the name blob and returns a copy.
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::GetMetadataNameBlob(
IN DFS_METADATA_HANDLE DfsMetadataHandle,
IN LPWSTR MetadataName,
OUT PVOID *ppBlob,
OUT PULONG pBlobSize,
OUT PFILETIME pLastModifiedTime )
{
DFSSTATUS Status = ERROR_SUCCESS;
PVOID pMetadata;
ULONG MetadataSize;
PVOID pBlob, pUseBlob;
ULONG UseBlobSize, NameBlobSize;
PVOID pNameBlob = NULL;
PDFS_NAME_INFORMATION pNameInformation = NULL;
Status = GetMetadata( (PVOID)DfsMetadataHandle,
MetadataName,
NULL,
&pMetadata,
&MetadataSize,
pLastModifiedTime);
if (Status == ERROR_SUCCESS)
{
pNameInformation = new DFS_NAME_INFORMATION;
if(pNameInformation != NULL)
{
RtlZeroMemory (pNameInformation, sizeof(DFS_NAME_INFORMATION));
pBlob = ((PDFSBLOB_DATA)(pMetadata))->pBlob;
pUseBlob = pBlob;
UseBlobSize = MetadataSize;
Status = PackGetNameInformation( pNameInformation,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
NameBlobSize = MetadataSize - UseBlobSize;
pNameBlob = (PVOID) new unsigned char [NameBlobSize ];
if(pNameBlob != NULL)
{
RtlCopyMemory(pNameBlob, pBlob, NameBlobSize );
}
else
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
}
delete pNameInformation;
}
else
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
ReleaseMetadata( (PVOID)DfsMetadataHandle, pMetadata );
}
//
// If we were successful, return the read in information. Otherwise free
// up the allocate resources and return error.
//
if ( Status == STATUS_SUCCESS )
{
*ppBlob = pNameBlob;
*pBlobSize = NameBlobSize;
}
return Status;
}
DFSSTATUS
DfsADBlobStore::SetMetadataNameBlob(
DFS_METADATA_HANDLE RootHandle,
LPWSTR MetadataName,
PVOID pNameBlob,
ULONG NameBlobSize )
{
PVOID pReplicaBlob, pNewBlob;
ULONG ReplicaBlobSize, NewBlobSize;
FILETIME LastTime;
DFSSTATUS Status;
Status = GetMetadataReplicaBlob( RootHandle,
MetadataName,
&pReplicaBlob,
&ReplicaBlobSize,
&LastTime );
if (Status == ERROR_SUCCESS)
{
NewBlobSize = NameBlobSize + ReplicaBlobSize;
Status = AllocateMetadataBlob( &pNewBlob,
NewBlobSize );
if (Status == ERROR_SUCCESS)
{
RtlCopyMemory(pNewBlob, pNameBlob, NameBlobSize);
RtlCopyMemory((PVOID)((ULONG_PTR)pNewBlob + NameBlobSize),
pReplicaBlob,
ReplicaBlobSize );
Status = SetMetadata( (PVOID)RootHandle,
MetadataName,
NULL,
pNewBlob,
NewBlobSize );
ReleaseMetadataBlob( pNewBlob );
}
ReleaseMetadataReplicaBlob(pReplicaBlob, ReplicaBlobSize );
}
return Status;
}
DFSSTATUS
DfsADBlobStore::SetMetadataReplicaBlob(
DFS_METADATA_HANDLE RootHandle,
LPWSTR MetadataName,
PVOID pReplicaBlob,
ULONG ReplicaBlobSize )
{
PVOID pNameBlob, pRemainingBlob;
ULONG NameBlobSize, RemainingBlobSize;
PVOID pOldBlob, pNewBlob, pUseBlob;
ULONG OldBlobSize, NewBlobSize, UseBlobSize;
ULONG OldReplicaBlobSize;
PVOID pMetadata;
ULONG MetadataSize;
DFSSTATUS Status;
DFS_NAME_INFORMATION NameInformation;
Status = GetMetadata( (PVOID)RootHandle,
MetadataName,
NULL,
&pMetadata,
&MetadataSize,
NULL);
if (Status == ERROR_SUCCESS)
{
pNameBlob = pOldBlob = ((PDFSBLOB_DATA)(pMetadata))->pBlob;
OldBlobSize = MetadataSize;
Status = PackGetNameInformation( &NameInformation,
&pOldBlob,
&OldBlobSize );
if (Status == ERROR_SUCCESS)
{
Status = PackGetULong( &OldReplicaBlobSize,
&pOldBlob,
&OldBlobSize );
if (Status == ERROR_SUCCESS)
{
pRemainingBlob = (PVOID)((ULONG_PTR)pOldBlob + OldReplicaBlobSize);
RemainingBlobSize = OldBlobSize - OldReplicaBlobSize;
}
}
if (Status == ERROR_SUCCESS)
{
NameBlobSize = PackSizeNameInformation( &NameInformation );
NewBlobSize = NameBlobSize + sizeof(ULONG) + ReplicaBlobSize + RemainingBlobSize;
Status = AllocateMetadataBlob( &pNewBlob, NewBlobSize );
if (Status == ERROR_SUCCESS)
{
SYSTEMTIME CurrentTime;
FILETIME ModifiedTime;
pUseBlob = pNewBlob;
UseBlobSize = NewBlobSize;
GetSystemTime( &CurrentTime);
if (SystemTimeToFileTime( &CurrentTime, &ModifiedTime ))
{
NameInformation.LastModifiedTime = ModifiedTime;
}
Status = PackSetNameInformation( &NameInformation,
&pUseBlob,
&UseBlobSize);
//
// At this point, we better have enough space for
// the rest of the stuff. Otherwise we have an
// internal computing problem.
//
if (Status == ERROR_SUCCESS)
{
if (UseBlobSize < (sizeof(ULONG) + ReplicaBlobSize + RemainingBlobSize))
{
Status = ERROR_INVALID_DATA;
}
}
if (Status == ERROR_SUCCESS)
{
Status = PackSetULong( ReplicaBlobSize,
&pUseBlob,
&UseBlobSize );
}
if (Status == ERROR_SUCCESS)
{
RtlCopyMemory(pUseBlob, pReplicaBlob, ReplicaBlobSize );
pUseBlob = (PVOID)((ULONG_PTR)pUseBlob + ReplicaBlobSize);
UseBlobSize -= ReplicaBlobSize;
RtlCopyMemory(pUseBlob, pRemainingBlob, RemainingBlobSize );
Status = SetMetadata( (PVOID)RootHandle,
MetadataName,
NULL,
pNewBlob,
NewBlobSize );
}
ReleaseMetadataBlob( pNewBlob );
}
else
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
}
ReleaseMetadata((PVOID)RootHandle, pMetadata );
}
return Status;
}
INIT_ADBLOB_DFS_ID_PROPERTY_INFO();
//+-------------------------------------------------------------------------
//
// Function: PackGetNameInformation - Unpacks the root/link name info
//
// Arguments: pDfsNameInfo - pointer to the info to fill.
// ppBuffer - pointer to buffer that holds the binary stream.
// pSizeRemaining - pointer to size of above buffer
//
// Returns: Status
// ERROR_SUCCESS if we could unpack the name info
// error status otherwise.
//
//
// Description: This routine expects the binary stream to hold all the
// information that is necessary to return a complete name
// info structure (as defined by MiADBlobDfsIdProperty). If the stream
// does not have the sufficient
// info, ERROR_INVALID_DATA is returned back.
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::PackGetNameInformation(
IN PDFS_NAME_INFORMATION pDfsNameInfo,
IN OUT PVOID *ppBuffer,
IN OUT PULONG pSizeRemaining)
{
DFSSTATUS Status = STATUS_SUCCESS;
//
// Get the name information from the binary stream.
//
Status = PackGetInformation( (ULONG_PTR)pDfsNameInfo,
ppBuffer,
pSizeRemaining,
&MiADBlobDfsIdProperty );
if (Status == ERROR_SUCCESS)
{
pDfsNameInfo->LastModifiedTime = pDfsNameInfo->PrefixTimeStamp;
if ((pDfsNameInfo->Type & 0x80) == 0x80)
{
pDfsNameInfo->State |= DFS_VOLUME_FLAVOR_AD_BLOB;
}
}
return Status;
}
//+-------------------------------------------------------------------------
//
// Function: PackSetNameInformation - Packs the root/link name info
//
// Arguments: pDfsNameInfo - pointer to the info to pack.
// ppBuffer - pointer to buffer that holds the binary stream.
// pSizeRemaining - pointer to size of above buffer
//
// Returns: Status
// ERROR_SUCCESS if we could pack the name info
// error status otherwise.
//
//
// Description: This routine takes the passedin name information and
// stores it in the binary stream passed in.
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::PackSetNameInformation(
IN PDFS_NAME_INFORMATION pDfsNameInfo,
IN OUT PVOID *ppBuffer,
IN OUT PULONG pSizeRemaining)
{
DFSSTATUS Status;
if ((pDfsNameInfo->Type & 0x80) == 0x80)
{
pDfsNameInfo->State &= ~DFS_VOLUME_FLAVORS;
}
pDfsNameInfo->PrefixTimeStamp = pDfsNameInfo->LastModifiedTime;
pDfsNameInfo->StateTimeStamp = pDfsNameInfo->LastModifiedTime;
pDfsNameInfo->CommentTimeStamp = pDfsNameInfo->LastModifiedTime;
//
// Store the DfsNameInfo in the stream first.
//
Status = PackSetInformation( (ULONG_PTR)pDfsNameInfo,
ppBuffer,
pSizeRemaining,
&MiADBlobDfsIdProperty );
return Status;
}
//+-------------------------------------------------------------------------
//
// Function: PackSizeNameInformation - Gets the size of the name info.
//
// Arguments: pDfsNameInfo - info to size.
//
// Returns: Status
// ULONG - size needed
//
// Description: This routine gets us the size of the binary stream
// required to pack the passed in name info.
//
//--------------------------------------------------------------------------
ULONG
DfsADBlobStore::PackSizeNameInformation(
IN PDFS_NAME_INFORMATION pDfsNameInfo )
{
ULONG Size;
Size = PackSizeInformation( (ULONG_PTR)pDfsNameInfo,
&MiADBlobDfsIdProperty );
return Size;
}
DFSSTATUS
DfsADBlobStore::GetMetadata (
IN PVOID DfsMetadataKey,
IN LPWSTR RelativeName,
IN LPWSTR RegistryValueNameString,
OUT PVOID *ppData,
OUT ULONG *pDataSize,
OUT PFILETIME pLastModifiedTime)
{
DFSSTATUS Status = ERROR_SUCCESS;
PVOID pDataBuffer = NULL;
DfsADBlobCache * pBlobCache = NULL;
ULONG DataSize = 0;
ULONG DataType = 0;
PDFSBLOB_DATA BlobData;
UNICODE_STRING BlobName;
UNREFERENCED_PARAMETER (RegistryValueNameString);
UNREFERENCED_PARAMETER (pLastModifiedTime);
Status = DfsRtlInitUnicodeStringEx( &BlobName, RelativeName );
if(Status != ERROR_SUCCESS)
{
return Status;
}
pBlobCache = (DfsADBlobCache *)ExtractFromMetadataHandle( DfsMetadataKey );
Status = pBlobCache->GetNamedBlob(&BlobName, &BlobData);
if(Status == STATUS_SUCCESS)
{
*ppData = (PVOID) BlobData;
*pDataSize = BlobData->Size;
}
return Status;
}
DFSSTATUS
DfsADBlobStore::SetMetadata (
IN PVOID DfsMetadataKey,
IN LPWSTR RelativeName,
IN LPWSTR RegistryValueNameString,
IN PVOID pData,
IN ULONG DataSize)
{
DFSSTATUS Status = ERROR_SUCCESS;
DfsADBlobCache * pBlobCache = NULL;
UNICODE_STRING BlobName;
UNREFERENCED_PARAMETER (RegistryValueNameString);
Status = DfsRtlInitUnicodeStringEx( &BlobName, RelativeName );
if(Status != ERROR_SUCCESS)
{
return Status;
}
pBlobCache = (DfsADBlobCache *)ExtractFromMetadataHandle( DfsMetadataKey );
Status = pBlobCache->StoreBlobInCache(&BlobName, (PBYTE) pData, DataSize);
if (Status == ERROR_SUCCESS)
{
Status = pBlobCache->WriteBlobToAd();
}
DFS_TRACE_LOW(REFERRAL_SERVER, "Done Setting metadata for %p %ws, Status %x\n", pBlobCache, RelativeName, Status);
return Status;
}
DFSSTATUS
DfsADBlobStore::RemoveMetadata (
IN PVOID DfsMetadataKey,
IN LPWSTR RelativeName)
{
DFSSTATUS Status = ERROR_SUCCESS;
DfsADBlobCache * pBlobCache = NULL;
UNICODE_STRING BlobName;
Status = DfsRtlInitUnicodeStringEx( &BlobName, RelativeName );
if(Status != ERROR_SUCCESS)
{
return Status;
}
pBlobCache = (DfsADBlobCache *)ExtractFromMetadataHandle( DfsMetadataKey );
Status = pBlobCache->RemoveNamedBlob( &BlobName );
if (Status == ERROR_SUCCESS)
{
Status = pBlobCache->WriteBlobToAd();
}
return Status;
}
DFSSTATUS
DfsADBlobStore::CreateADBlobRoot(
LPWSTR MachineName,
LPWSTR DCName,
LPWSTR PhysicalShare,
LPWSTR LogicalShare,
LPWSTR Comment,
BOOLEAN NewRoot)
{
DFSSTATUS Status= ERROR_SUCCESS;
HKEY DfsKey = NULL;
DfsRootFolder *pRootFolder = NULL;
DfsRootFolder *pLookupRootFolder = NULL;
BOOLEAN IsLastRootTarget = FALSE;
UNICODE_STRING DfsMachine;
UNICODE_STRING DfsShare;
UNICODE_STRING DfsPhysicalShare;
//
// We had decided to disallow mismatch on Logical and physical
// shares, but we are just going to document this.
//
#if 0
if (_wcsicmp(LogicalShare, PhysicalShare) != 0)
{
return ERROR_INVALID_NAME;
}
#endif
DFS_TRACE_LOW( REFERRAL_SERVER, "Dfs ad blob store, create root %ws\n", LogicalShare);
Status = DfsRtlInitUnicodeStringEx( &DfsShare, LogicalShare );
if(Status != ERROR_SUCCESS)
{
return Status;
}
Status = DfsRtlInitUnicodeStringEx( &DfsPhysicalShare, PhysicalShare );
if(Status != ERROR_SUCCESS)
{
return Status;
}
Status = DfsRtlInitUnicodeStringEx( &DfsMachine, MachineName );
if(Status != ERROR_SUCCESS)
{
return Status;
}
if (DfsIsSpecialDomainShare(&DfsShare) ||
DfsIsSpecialDomainShare(&DfsPhysicalShare))
{
Status = ERROR_INVALID_PARAMETER;
DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Dfs ad blob store, special share - create root %ws, status %x\n", LogicalShare, Status);
return Status;
}
Status = LookupRoot( &DfsMachine,
&DfsShare,
&pLookupRootFolder );
DFS_TRACE_LOW( REFERRAL_SERVER, "Dfs ad blob store, looup root %p, status %x\n", pRootFolder, Status);
if (Status == ERROR_SUCCESS)
{
pLookupRootFolder->ReleaseReference();
//
// DO NOT CHANGE this error code. A change here will affect the client
// The client will tear down the root if we return any other
// error code here, so be very careful.
//
// We also need to return here: the rest of the code assumes this.
//
DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Dfs ad blob store, Already Exists - create root %ws, status %x\n", LogicalShare, Status);
return ERROR_ALREADY_EXISTS;
}
Status = DfsCheckServerRootHandlingCapability();
if (Status != ERROR_SUCCESS)
{
return Status;
}
Status = GetNewADBlobRegistryKey( MachineName,
TRUE, // write permission required
NULL,
&DfsKey );
if (Status == ERROR_SUCCESS)
{
Status = SetupADBlobRootKeyInformation( DfsKey,
LogicalShare,
PhysicalShare );
//RegCloseKey( DfsKey );
}
if (Status == ERROR_SUCCESS)
{
Status = GetRootFolder( NULL,
LogicalShare,
&DfsShare,
&DfsPhysicalShare,
&pRootFolder );
if (Status == ERROR_SUCCESS)
{
Status = pRootFolder->RootRequestPrologue( DCName );
if (Status == ERROR_SUCCESS)
{
Status = AddRootToBlob( MachineName,
pRootFolder,
NewRoot, //NewRoot,
LogicalShare,
PhysicalShare,
Comment );
if ((Status == ERROR_FILE_EXISTS) ||
(Status == ERROR_ALREADY_EXISTS))
{
Status = ERROR_SUCCESS;
}
if (Status == ERROR_SUCCESS)
{
Status = DfsUpdateRootRemoteServerName( LogicalShare,
DCName,
MachineName,
PhysicalShare,
TRUE );
}
if (Status == ERROR_SUCCESS)
{
Status = pRootFolder->AcquireRootShareDirectory();
//
// now mark the root folder as synchronized:
// this is true since this root is empty.
//
if (Status == ERROR_SUCCESS)
{
pRootFolder->SetRootFolderSynchronized();
}
}
else
{
(void) pRootFolder->ReleaseRootShareDirectory();
}
pRootFolder->RootRequestEpilogue();
}
}
}
if (Status != ERROR_SUCCESS)
{
DFSSTATUS LocalStatus = ERROR_SUCCESS;
LocalStatus = RegDeleteKey( DfsKey,
LogicalShare );
LocalStatus = DfsUpdateRootRemoteServerName( LogicalShare,
DCName,
MachineName,
PhysicalShare,
FALSE );
if(pRootFolder)
{
LocalStatus = pRootFolder->RootRequestPrologue( DCName );
if (LocalStatus == ERROR_SUCCESS)
{
LocalStatus = RemoveRootFromBlob( pRootFolder,
MachineName,
PhysicalShare,
&IsLastRootTarget );
pRootFolder->RootRequestEpilogue();
}
if(IsLastRootTarget)
{
DfsDeleteDfsRootObject( DCName,
LogicalShare);
}
RemoveRootFolder(pRootFolder, TRUE);
}
}
if(pRootFolder)
{
pRootFolder->ReleaseReference();
}
if(DfsKey != NULL)
{
RegCloseKey( DfsKey );
}
//
// At this point we CANNOT return ERROR_ALREADY_EXISTS. The client
// will use this code to mean that the DS object it creates is not
// cleaned up.
//
// Does not mean that ERROR_NOT_SUPPORTED is a better error, but till
// we find one, this should suffice.
//
if (Status == ERROR_ALREADY_EXISTS)
{
Status = ERROR_NOT_SUPPORTED;
}
DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Dfs ad blob store, create root %ws, status %x\n", LogicalShare, Status);
return Status;
}
DFSSTATUS
DfsADBlobStore::DeleteADBlobRoot(
LPWSTR MachineName,
LPWSTR DCName,
LPWSTR PhysicalShare,
LPWSTR LogicalShare )
{
DFSSTATUS Status = ERROR_SUCCESS;
UNICODE_STRING DfsMachine;
UNICODE_STRING DfsShare;
DfsRootFolder *pRootFolder = NULL;
BOOLEAN IsLastRootTarget = FALSE;
DFS_TRACE_LOW(REFERRAL_SERVER, "AdBlob: delete ad blob root %ws\n", LogicalShare);
Status = DfsRtlInitUnicodeStringEx( &DfsMachine, MachineName );
if (Status != ERROR_SUCCESS)
{
return Status;
}
Status = DfsRtlInitUnicodeStringEx( &DfsShare, LogicalShare );
if (Status != ERROR_SUCCESS)
{
return Status;
}
Status = LookupRoot( &DfsMachine,
&DfsShare,
&pRootFolder );
DFS_TRACE_LOW(REFERRAL_SERVER, "AdBlob: delete ad blob root %ws, Lookup root %p, Status %x\n", LogicalShare, pRootFolder, Status);
if (Status == ERROR_SUCCESS)
{
PUNICODE_STRING pRootPhysicalShare;
UNICODE_STRING DfsPhysicalShare;
pRootPhysicalShare = pRootFolder->GetRootPhysicalShareName();
Status = DfsRtlInitUnicodeStringEx( &DfsPhysicalShare, PhysicalShare);
if (Status == ERROR_SUCCESS)
{
if (RtlCompareUnicodeString( &DfsPhysicalShare,
pRootPhysicalShare,
TRUE) != 0)
{
Status = ERROR_INVALID_PARAMETER;
}
}
if (Status != ERROR_SUCCESS)
{
pRootFolder->ReleaseReference();
}
}
if (Status == ERROR_SUCCESS)
{
Status = pRootFolder->RootApiRequestPrologue(TRUE,
DCName);
if (Status == ERROR_SUCCESS)
{
Status = DoesUserHaveAccess(pRootFolder, GENERIC_ALL);
if (Status == ERROR_SUCCESS)
{
Status = pRootFolder->AcquireRootLock();
if(Status == ERROR_SUCCESS)
{
pRootFolder->SetRootFolderDeleteInProgress();
pRootFolder->ReleaseRootLock();
}
}
if (Status == ERROR_SUCCESS)
{
Status = CleanRegEntry( MachineName, LogicalShare );
if (Status == ERROR_SUCCESS)
{
Status = DfsUpdateRootRemoteServerName( LogicalShare,
DCName,
MachineName,
PhysicalShare,
FALSE );
}
//
// Update blob and write it back.
//
if (Status == ERROR_SUCCESS)
{
// dfsdev: move this function to rootfolder class.
Status = RemoveRootFromBlob( pRootFolder,
MachineName,
PhysicalShare,
&IsLastRootTarget );
}
NTSTATUS DeleteStatus;
//
// we are done with this folder. Release the root share directory
// we had acquired earlier on: this will tell the driver we are
// no longer interested on the specified drive.
//
DeleteStatus = RemoveRootFolder( pRootFolder, TRUE );
DFS_TRACE_ERROR_HIGH( DeleteStatus, REFERRAL_SERVER, "remove root folder status %x\n", DeleteStatus);
DeleteStatus = pRootFolder->ReleaseRootShareDirectory();
DFS_TRACE_ERROR_LOW( DeleteStatus, REFERRAL_SERVER, "release root dir status %x\n", DeleteStatus);
}
pRootFolder->RootApiRequestEpilogue(TRUE,
Status );
}
pRootFolder->ReleaseReference();
#if 0
if(Status != ERROR_SUCCESS)
{
DFS_TRACE_HIGH(REFERRAL_SERVER, "remove root folder failed. Trying to recreate root \n");
CreateADBlobRoot(MachineName,
DCName,
PhysicalShare,
LogicalShare,
L"",
TRUE );
}
#endif
}
DFS_TRACE_LOW(REFERRAL_SERVER, "AdBlob: delete ad blob root %p (%ws), Status %x\n",
pRootFolder, LogicalShare, Status);
return Status;
}
DFSSTATUS
DfsADBlobStore::DeleteADBlobRootForced(
LPWSTR MachineName,
LPWSTR DCName,
LPWSTR PhysicalShare,
LPWSTR LogicalShare )
{
DFSSTATUS Status = ERROR_SUCCESS;
UNICODE_STRING DfsMachine;
UNICODE_STRING DfsShare;
DfsRootFolder *pRootFolder = NULL;
BOOLEAN IsLastRootTarget = FALSE;
DFS_TRACE_LOW(REFERRAL_SERVER, "AdBlob: delete ad blob root %ws\n", LogicalShare);
Status = DfsRtlInitUnicodeStringEx( &DfsMachine, MachineName );
if (Status != ERROR_SUCCESS)
{
return Status;
}
Status = DfsRtlInitUnicodeStringEx( &DfsShare, LogicalShare );
if (Status != ERROR_SUCCESS)
{
return Status;
}
Status = GetCompatRootFolder( &DfsShare,
&pRootFolder );
DFS_TRACE_LOW(REFERRAL_SERVER, "AdBlob: forced delete ad blob root %ws, Lookup root %p, Status %x\n", LogicalShare, pRootFolder, Status);
if (Status == ERROR_SUCCESS)
{
Status = pRootFolder->RootApiRequestPrologue(TRUE,
DCName);
if (Status == ERROR_SUCCESS)
{
Status = DoesUserHaveAccess(pRootFolder, GENERIC_ALL);
if (Status == ERROR_SUCCESS)
{
Status = pRootFolder->AcquireRootLock();
if(Status == ERROR_SUCCESS)
{
pRootFolder->SetRootFolderDeleteInProgress();
pRootFolder->ReleaseRootLock();
}
}
if (Status == ERROR_SUCCESS)
{
Status = DfsUpdateRootRemoteServerName( LogicalShare,
DCName,
MachineName,
PhysicalShare,
FALSE );
if (Status == ERROR_SUCCESS)
{
Status = RemoveRootFromBlob( pRootFolder,
MachineName,
PhysicalShare,
&IsLastRootTarget );
}
}
pRootFolder->RootApiRequestEpilogue(TRUE,
Status );
}
pRootFolder->ReleaseReference();
}
return Status;
}
DFSSTATUS
DfsADBlobStore::RemoveChild(
DFS_METADATA_HANDLE DfsHandle,
LPWSTR ChildName )
{
return RemoveMetadata( (PVOID)DfsHandle, ChildName );
}
//+-------------------------------------------------------------------------
//
// Function: AddChild - Add a child to the metadata.
//
// Arguments:
// DfsMetadataHandle - the Metadata key for the root.
// PUNICODE_STRING pLinkLogicalName - the logical name of the child
// LPWSTR ReplicaServer - the first target server for this link.
// LPWSTR ReplicaPath - the target path for this link
// LPWSTR Comment - the comment to be associated with this link.
// LPWSTR pMetadataName - the metadata name for the child, returned..
//
//
// Returns: Status:
//
// Description: This routine adds a child to the Root metadata. It packs
// the link name into the name information. If the replica
// information exists, it packs that into the replica info.
// It then saves the name and replica streams under the
// Childkey.
// NOTE: this function does not require that the link
// have atleast one replica. Any such requirements
// should be enforced by the caller.
//
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::AddChild(
IN DFS_METADATA_HANDLE DfsHandle,
IN PDFS_NAME_INFORMATION pNameInfo,
IN PDFS_REPLICA_LIST_INFORMATION pReplicaListInfo,
IN PUNICODE_STRING pMetadataName)
{
DFSSTATUS Status;
PVOID pNameBlob, pReplicaBlob, pNewBlob, pUseBlob;
ULONG NameBlobSize, ReplicaBlobSize, NewBlobSize, UseBlobSize;
Status = CreateNameInformationBlob( pNameInfo,
&pNameBlob,
&NameBlobSize );
if (Status == ERROR_SUCCESS)
{
Status = CreateReplicaListInformationBlob( pReplicaListInfo,
&pReplicaBlob,
&ReplicaBlobSize );
if (Status == ERROR_SUCCESS)
{
NewBlobSize = NameBlobSize + sizeof(ULONG) + ReplicaBlobSize +
3 * sizeof(ULONG);
Status = AllocateMetadataBlob( &pNewBlob,
NewBlobSize );
if (Status == ERROR_SUCCESS)
{
pUseBlob = pNewBlob;
UseBlobSize = NewBlobSize;
RtlCopyMemory( pUseBlob, pNameBlob, NameBlobSize );
pUseBlob = (PVOID)((ULONG_PTR)pUseBlob + NameBlobSize);
UseBlobSize -= NameBlobSize;
PackSetULong( ReplicaBlobSize,
&pUseBlob,
&UseBlobSize );
RtlCopyMemory(pUseBlob, pReplicaBlob, ReplicaBlobSize );
pUseBlob = (PVOID)((ULONG_PTR)pUseBlob + ReplicaBlobSize);
UseBlobSize -= ReplicaBlobSize;
PackSetULong( 4,
&pUseBlob,
&UseBlobSize );
PackSetULong( 0,
&pUseBlob,
&UseBlobSize );
PackSetULong( pNameInfo->Timeout,
&pUseBlob,
&UseBlobSize );
Status = SetMetadata( (PVOID)DfsHandle,
pMetadataName->Buffer,
NULL,
pNewBlob,
NewBlobSize );
ReleaseMetadataBlob( pNewBlob );
}
ReleaseMetadataReplicaBlob( pReplicaBlob, ReplicaBlobSize );
}
ReleaseMetadataNameBlob( pNameBlob, NameBlobSize );
}
return Status;
}
DFSSTATUS
DfsADBlobStore::EnumerateApiLinks(
IN DFS_METADATA_HANDLE DfsHandle,
PUNICODE_STRING pRootName,
DWORD Level,
LPBYTE pBuffer,
LONG BufferSize,
LPDWORD pEntriesToRead,
LPDWORD pResumeHandle,
PLONG pSizeRequired )
{
DFSSTATUS Status = ERROR_SUCCESS;
BOOLEAN OverFlow = FALSE;
LONG HeaderSize = 0;
LONG EntriesRead = 0;
LONG EntriesToRead = *pEntriesToRead;
LONG SizeRequired = 0;
LONG EntryCount = 0;
ULONG ChildNum = 0;
LPBYTE pLinkBuffer = NULL;
LONG LinkBufferSize = 0;
LPBYTE CurrentBuffer = NULL;
LPBYTE NewBuffer = NULL;
LONG SizeRemaining = 0;
DfsADBlobCache * pBlobCache = NULL;
PDFSBLOB_DATA pBlobData = NULL;
LONG CurrentCount = 0;
ULONG_PTR SizeDiff;
DFSBOB_ITER Iter;
pBlobCache = (DfsADBlobCache *)ExtractFromMetadataHandle( DfsHandle );
OverFlow = FALSE;
Status = DfsApiSizeLevelHeader( Level, &HeaderSize );
if (Status != ERROR_SUCCESS)
{
return Status;
}
SizeRequired = ROUND_UP_COUNT(EntriesToRead * HeaderSize, ALIGN_QUAD);
if (EntriesToRead * HeaderSize < BufferSize )
{
CurrentBuffer = (LPBYTE)((ULONG_PTR)pBuffer + EntriesToRead * HeaderSize);
SizeRemaining = BufferSize - EntriesToRead * HeaderSize;
}
else
{
CurrentBuffer = pBuffer;
SizeRemaining = 0;
OverFlow = TRUE;
}
if(pResumeHandle)
{
EntryCount = *pResumeHandle;
}
CurrentCount = 0;
pBlobData = pBlobCache->FindFirstBlob(&Iter);
while ((pBlobData != NULL) &&
CurrentCount < EntryCount )
{
CurrentCount++;
pBlobData = pBlobCache->FindNextBlob(&Iter);
}
while ((pBlobData != NULL) && (pBlobCache->IsStaleBlob(pBlobData)))
{
pBlobData = pBlobCache->FindNextBlob(&Iter);
}
if (pBlobData == NULL)
{
Status = ERROR_NO_MORE_ITEMS;
}
while ((pBlobData != NULL) &&
(Status == ERROR_SUCCESS))
{
//
// For each child, get the child name.
//
if (EntriesToRead && EntriesRead >= EntriesToRead)
{
break;
}
Status = GetStoreApiInformationBuffer( DfsHandle,
pRootName,
pBlobData->BlobName.Buffer,
Level,
&pLinkBuffer,
&LinkBufferSize );
if (Status == ERROR_SUCCESS)
{
SizeRequired += ROUND_UP_COUNT(LinkBufferSize, ALIGN_QUAD);
if (OverFlow == FALSE)
{
DFSSTATUS PackStatus;
PackStatus = PackageEnumerationInfo( Level,
EntriesRead,
pLinkBuffer,
pBuffer,
&CurrentBuffer,
&SizeRemaining );
if (PackStatus == ERROR_BUFFER_OVERFLOW)
{
OverFlow = TRUE;
}
NewBuffer = (LPBYTE)ROUND_UP_POINTER( CurrentBuffer, ALIGN_LPVOID);
SizeDiff = (NewBuffer - CurrentBuffer);
if ((LONG)SizeDiff > SizeRemaining)
{
SizeRemaining = 0;
}
else
{
SizeRemaining -= (LONG)SizeDiff;
}
CurrentBuffer = NewBuffer;
}
ReleaseStoreApiInformationBuffer( pLinkBuffer );
EntryCount++;
EntriesRead++;
}
pBlobData = pBlobCache->FindNextBlob(&Iter);
while ((pBlobData != NULL) && (pBlobCache->IsStaleBlob(pBlobData)))
{
pBlobData = pBlobCache->FindNextBlob(&Iter);
}
if (pBlobData == NULL)
{
Status = ERROR_NO_MORE_ITEMS;
}
}
pBlobCache->FindCloseBlob(&Iter);
*pSizeRequired = SizeRequired;
if (Status == ERROR_NO_MORE_ITEMS)
{
if (EntriesRead)
{
if (OverFlow)
{
Status = ERROR_BUFFER_OVERFLOW;
}
else
{
Status = ERROR_SUCCESS;
}
}
}
else if (OverFlow)
{
Status = ERROR_BUFFER_OVERFLOW;
}
if (Status == ERROR_SUCCESS)
{
if(pResumeHandle)
{
*pResumeHandle = EntryCount;
}
*pEntriesToRead = EntriesRead;
}
return Status;
}
DFSSTATUS
DfsADBlobStore::AddRootToBlob(
LPWSTR MachineName,
DfsRootFolder *pRootFolder,
BOOLEAN NewRoot,
LPWSTR LogicalShare,
LPWSTR ShareName,
LPWSTR Comment )
{
DFS_METADATA_HANDLE RootHandle;
DFSSTATUS Status;
UNICODE_STRING DomainName;
UNICODE_STRING LogicalName, RootMetadataName;
DFS_NAME_INFORMATION NameInfo;
DFS_REPLICA_LIST_INFORMATION ReplicaListInfo;
DFS_REPLICA_INFORMATION ReplicaInfo;
UUID NewUid;
LPWSTR RootMetadataNameString = NULL;
Status = DfsRtlInitUnicodeStringEx( &RootMetadataName, RootMetadataNameString);
if (Status != ERROR_SUCCESS)
{
return Status;
}
Status = UuidCreate(&NewUid);
if (Status != ERROR_SUCCESS)
{
return Status;
}
Status = pRootFolder->GetMetadataHandle( &RootHandle );
if (Status == ERROR_SUCCESS)
{
if (NewRoot == FALSE)
{
Status = pRootFolder->Synchronize(FALSE, TRUE);
if (Status == ERROR_SUCCESS)
{
Status = RootEntryExists((PVOID)RootHandle, &NewRoot);
}
}
if (Status == ERROR_SUCCESS)
{
if (NewRoot)
{
Status = DfsGetDomainName(&DomainName);
if (Status == ERROR_SUCCESS)
{
Status = DfsCreateUnicodePathString( &LogicalName,
1, // 1 leading path seperator.
DomainName.Buffer,
LogicalShare);
if (Status == ERROR_SUCCESS)
{
StoreInitializeNameInformation( &NameInfo,
&LogicalName,
&NewUid,
Comment );
NameInfo.Type |= PKT_ENTRY_TYPE_REFERRAL_SVC;
StoreInitializeReplicaInformation( &ReplicaListInfo,
&ReplicaInfo,
MachineName,
ShareName );
Status = AddChild( RootHandle,
&NameInfo,
&ReplicaListInfo,
&RootMetadataName );
DfsFreeUnicodeString( &LogicalName);
}
DfsFreeUnicodeString( &DomainName );
}
}
else
{
Status = AddChildReplica( RootHandle,
RootMetadataNameString,
MachineName,
ShareName );
}
}
pRootFolder->ReleaseMetadataHandle( RootHandle );
}
return Status;
}
DFSSTATUS
DfsADBlobStore::RemoveRootFromBlob(
DfsRootFolder *pRootFolder,
LPWSTR MachineName,
LPWSTR ShareName,
PBOOLEAN pLastRoot )
{
DFS_METADATA_HANDLE RootHandle;
DFSSTATUS Status = ERROR_SUCCESS;
BOOLEAN LastRoot = FALSE;
DfsADBlobCache *pBlobCache = NULL;
LPWSTR RootMetadataNameString = NULL;
Status = pRootFolder->GetMetadataHandle( &RootHandle );
if (Status == ERROR_SUCCESS)
{
Status = RemoveChildReplica( RootHandle,
RootMetadataNameString,
MachineName,
ShareName,
&LastRoot,
TRUE);
if((Status == ERROR_SUCCESS) || (Status == ERROR_LAST_ADMIN))
{
if (LastRoot)
{
pBlobCache = (DfsADBlobCache *)ExtractFromMetadataHandle( RootHandle);
pBlobCache->InvalidateCache();
pBlobCache->WriteBlobToAd();
}
Status = ERROR_SUCCESS;
}
pRootFolder->ReleaseMetadataHandle( RootHandle );
}
if (Status == ERROR_SUCCESS)
{
*pLastRoot = LastRoot;
}
return Status;
}
DFSSTATUS
DfsADBlobStore::GetMetadataNameInformation(
IN DFS_METADATA_HANDLE RootHandle,
IN LPWSTR MetadataName,
OUT PDFS_NAME_INFORMATION *ppInfo )
{
PVOID pBlob, pUseBlob;
ULONG UseBlobSize, ReplicaBlobSize, RecoveryBlobSize;
FILETIME BlobModifiedTime;
PVOID pMetadata;
ULONG MetadataSize;
PDFS_NAME_INFORMATION pNewInfo = NULL;
DFSSTATUS Status;
Status = GetMetadata( (PVOID)RootHandle,
MetadataName,
NULL,
&pMetadata,
&MetadataSize,
&BlobModifiedTime);
if (Status == ERROR_SUCCESS)
{
pBlob = ((PDFSBLOB_DATA)(pMetadata))->pBlob;
pNewInfo = new DFS_NAME_INFORMATION;
if (pNewInfo != NULL)
{
RtlZeroMemory (pNewInfo, sizeof(DFS_NAME_INFORMATION));
pUseBlob = pBlob;
UseBlobSize = MetadataSize;
Status = PackGetNameInformation( pNewInfo,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
Status = PackGetULong( &ReplicaBlobSize,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
if(ReplicaBlobSize > UseBlobSize)
{
Status = ERROR_INVALID_DATA;
}
else
{
pUseBlob = (PVOID)((ULONG_PTR)pUseBlob + ReplicaBlobSize);
UseBlobSize -= ReplicaBlobSize;
}
}
}
if (Status == ERROR_SUCCESS)
{
Status = PackGetULong( &RecoveryBlobSize,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
if(RecoveryBlobSize > UseBlobSize)
{
Status = ERROR_INVALID_DATA;
}
else
{
pUseBlob = (PVOID)((ULONG_PTR)pUseBlob + RecoveryBlobSize);
UseBlobSize -= RecoveryBlobSize;
}
}
}
if (Status == ERROR_SUCCESS)
{
Status = PackGetULong( &pNewInfo->Timeout,
&pUseBlob,
&UseBlobSize );
}
if (Status != ERROR_SUCCESS)
{
ReleaseMetadata( (PVOID)RootHandle, pMetadata );
delete pNewInfo;
}
}
else
{
Status = ERROR_NOT_ENOUGH_MEMORY;
}
}
if (Status == ERROR_SUCCESS)
{
pNewInfo->pData = pMetadata;
pNewInfo->DataSize = MetadataSize;
*ppInfo = pNewInfo;
}
return Status;
}
VOID
DfsADBlobStore::ReleaseMetadataNameInformation(
IN DFS_METADATA_HANDLE RootHandle,
IN PDFS_NAME_INFORMATION pNameInfo )
{
ReleaseMetadata( (PVOID)RootHandle, pNameInfo->pData );
delete [] pNameInfo;
}
DFSSTATUS
DfsADBlobStore::SetMetadataNameInformation(
IN DFS_METADATA_HANDLE RootHandle,
IN LPWSTR MetadataName,
IN PDFS_NAME_INFORMATION pNameInfo )
{
PVOID pBlob, pUseBlob, pNewBlob;
ULONG UseBlobSize, NewBlobSize;
ULONG ReplicaBlobSize, RecoveryBlobSize;
DFSSTATUS Status;
PVOID pNameBlob;
ULONG NameBlobSize;
FILETIME BlobModifiedTime;
PVOID pMetadata;
ULONG MetadataSize;
SYSTEMTIME CurrentTime;
FILETIME ModifiedTime;
GetSystemTime( &CurrentTime);
if (SystemTimeToFileTime( &CurrentTime, &ModifiedTime ))
{
pNameInfo->LastModifiedTime = ModifiedTime;
}
Status = CreateNameInformationBlob( pNameInfo,
&pNameBlob,
&NameBlobSize );
if (Status == ERROR_SUCCESS)
{
Status = GetMetadata( (PVOID)RootHandle,
MetadataName,
NULL,
&pMetadata,
&MetadataSize,
&BlobModifiedTime);
}
if (Status == ERROR_SUCCESS)
{
DFS_NAME_INFORMATION NameInformation;
pBlob = ((PDFSBLOB_DATA)(pMetadata))->pBlob;
pUseBlob = pBlob;
UseBlobSize = MetadataSize;
Status = PackGetNameInformation( &NameInformation,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
NewBlobSize = NameBlobSize + UseBlobSize;
Status = AllocateMetadataBlob( &pNewBlob,
NewBlobSize );
if (Status == ERROR_SUCCESS)
{
RtlCopyMemory(pNewBlob, pNameBlob, NameBlobSize);
RtlCopyMemory((PVOID)((ULONG_PTR)pNewBlob + NameBlobSize),
pUseBlob,
UseBlobSize );
pUseBlob = (PVOID)((ULONG_PTR)pNewBlob + NameBlobSize);
if (Status == ERROR_SUCCESS)
{
Status = PackGetULong( &ReplicaBlobSize,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
pUseBlob = (PVOID)((ULONG_PTR)pUseBlob + ReplicaBlobSize);
UseBlobSize -= ReplicaBlobSize;
}
}
if (Status == ERROR_SUCCESS)
{
Status = PackGetULong( &RecoveryBlobSize,
&pUseBlob,
&UseBlobSize );
if (Status == ERROR_SUCCESS)
{
pUseBlob = (PVOID)((ULONG_PTR)pUseBlob + RecoveryBlobSize);
UseBlobSize -= RecoveryBlobSize;
}
}
if (Status == ERROR_SUCCESS)
{
Status = PackSetULong( pNameInfo->Timeout,
&pUseBlob,
&UseBlobSize );
}
if (Status == ERROR_SUCCESS)
{
Status = SetMetadata( (PVOID)RootHandle,
MetadataName,
NULL,
pNewBlob,
NewBlobSize );
}
ReleaseMetadataBlob( pNewBlob );
}
}
ReleaseMetadata( (PVOID)RootHandle, pMetadata );
}
return Status;
}
//+-------------------------------------------------------------------------
//
// Function: RenameLinks
//
// Arguments:
// RootHandle - handle to root's metadata
// OldDomainName
// NewDomainName
//
// Returns: SUCCESS or error
//
// Description: Renames all links referencing the old domain name to the new.
// To do that, this retrieves NameInformation as well as ReplicaInformation
// from the blob cache. Once done, the metadata are written back to the
// cache. Flushing the metadata to the AD or aborting the changes is
// the caller's responsibility.
//--------------------------------------------------------------------------
DFSSTATUS
DfsADBlobStore::RenameLinks(
DFS_METADATA_HANDLE RootHandle,
IN PUNICODE_STRING pLinkMetadataName,
IN PUNICODE_STRING pOldDomainName,
IN PUNICODE_STRING pNewDomainName)
{
DFSSTATUS Status;
//
// Change the NameInfo structure first.
//
Status = RenameNameInfo( RootHandle,
pLinkMetadataName,
pNewDomainName,
pOldDomainName );
//
// We've successfully renamed the prefix in the NameInfo. Now see if there are
// any links to change in the Replica List.
//
if (Status == ERROR_SUCCESS)
{
Status = RenameReplicaInfo( RootHandle,
pLinkMetadataName,
pNewDomainName,
pOldDomainName);
}
return Status;
}
//
// RenameNameInfoPrefix - replace both the Prefix and the ShortPrefix.
// SUCCESS indicates a successful rename.
//
//
DFSSTATUS
DfsADBlobStore::RenameNameInfo(
IN DFS_METADATA_HANDLE RootHandle,
IN PUNICODE_STRING pLinkMetadataName,
IN PUNICODE_STRING pNewDomainName,
IN PUNICODE_STRING pOldDomainName)
{
DFSSTATUS Status;
PDFS_NAME_INFORMATION pNameInfo;
UNICODE_STRING FirstComponent;
Status = GetMetadataNameInformation( RootHandle,
pLinkMetadataName->Buffer,
&pNameInfo);
if (Status != ERROR_SUCCESS)
{
return Status;
}
//
// Sanity check the Prefix string of the NameInfo.
// Although the LinkMetadataName is NULL for
// the root the NameInfo->Prefix has the real name.
//
Status = DfsGetFirstComponent( &pNameInfo->Prefix, &FirstComponent, NULL );
if ((Status != ERROR_SUCCESS) ||
(RtlEqualDomainName(pOldDomainName, &FirstComponent) == FALSE))
{
ReleaseMetadataNameInformation( RootHandle, pNameInfo );
return Status;
}
//
// We have a match. Just replace that first component with the
// new domain name. The substitution happens in place, so we ideally should save
// the old pointer to patch back the nameinfo snapshot afterwards.
//
Status = GenerateMetadataLogicalName(pNewDomainName,
&pNameInfo->Prefix,
&pNameInfo->Prefix);
if (Status == ERROR_SUCCESS)
{
//
// Similarly, change the ShortPrefix as well. We don't just assume
// that they are identical, although in practice they are currently.
//
Status = GenerateMetadataLogicalName(pNewDomainName,
&pNameInfo->ShortPrefix,
&pNameInfo->ShortPrefix);
// We don't bother to modify the timestamps.
//
// We don't bother to undo our previous changes if we get errors.
// The understanding is that the whole metadata blob will be
// thrown away without getting written back to the AD. Just free the old
// NameInfo strings on our way out.
//
if (Status == ERROR_SUCCESS)
{
Status = SetMetadataNameInformation( RootHandle,
pLinkMetadataName->Buffer,
pNameInfo );
ReleaseMetadataLogicalName( &pNameInfo->ShortPrefix );
}
ReleaseMetadataLogicalName( &pNameInfo->Prefix );
}
//
// Release our snapshot of the blob. This doesn't write the changes back to the cache;
// the SetMetadata above does that.
//
ReleaseMetadataNameInformation( RootHandle, pNameInfo );
return Status;
}
//
// RenameReplicaInfo - Walk through the replica list and replace stale domain names.
//
DFSSTATUS
DfsADBlobStore::RenameReplicaInfo(
IN DFS_METADATA_HANDLE RootHandle,
IN PUNICODE_STRING pLinkMetadataName,
IN PUNICODE_STRING pNewDomainName,
IN PUNICODE_STRING pOldDomainName)
{
DFSSTATUS Status;
PUNICODE_STRING pReplicaName;
PDFS_REPLICA_LIST_INFORMATION pReplicaList;
BOOLEAN RenamedLink = FALSE;
ULONG i;
//
// Get a snapshot of the replica set.
//
Status = GetMetadataReplicaInformation( RootHandle,
pLinkMetadataName->Buffer,
&pReplicaList );
if (Status != ERROR_SUCCESS)
{
return Status;
}
//
// Go through all its links looking for a match of the stale domain name.
//
for (i = 0; i < pReplicaList->ReplicaCount; i++)
{
pReplicaName = &pReplicaList->pReplicas[i].ServerName;
//
// The names must match to change the replica.
//
if (!RtlEqualDomainName( pOldDomainName, pReplicaName ))
{
continue;
}
// XXX: Ideally we should keep a pointer to the old ServerName
// and put it back after we SetMetadata and before we release
// this NameInfo snapshot. The current logic basically assumes that losing
// the old pointer doesn't end in a memory leak (TRUE currently).
//
Status = DfsRtlInitUnicodeStringEx( pReplicaName, pNewDomainName->Buffer );
if (Status != ERROR_SUCCESS)
{
// The rootfolder will resynchronize to revert the changes.
break;
}
RenamedLink = TRUE;
}
if ((Status == ERROR_SUCCESS) &&
(RenamedLink))
{
//
// Put the blob back in the cache if we've changed any of it.
// We don't need to make this operation atomic with respect to
// NameInfo changes because if any of these fails, the caller's supposed to
// purge the cache with a ReSynchronize().
//
Status = SetMetadataReplicaInformation( RootHandle,
pLinkMetadataName->Buffer,
pReplicaList );
}
ReleaseMetadataReplicaInformation( RootHandle, pReplicaList );
return Status;
}
//
// This removes the target share from the
// Microsoft\Dfs\Roots\Domain registry key.
//
DFSSTATUS
DfsADBlobStore::CleanRegEntry(
LPWSTR MachineName,
LPWSTR LogicalShare
)
{
HKEY FtDfsKey;
DFSSTATUS Status;
DFSSTATUS RetStatus = ERROR_NOT_FOUND;
Status = GetNewADBlobRegistryKey( MachineName,
TRUE, // write permission required
NULL,
&FtDfsKey );
if (Status == ERROR_SUCCESS)
{
Status = RegDeleteKey( FtDfsKey,
LogicalShare );
// Return success only if something got successfully deleted.
if (Status == ERROR_SUCCESS)
{
RetStatus = Status;
}
RegCloseKey( FtDfsKey );
}
return RetStatus;
}
DFSSTATUS
DfsADBlobStore::GenerateApiLogicalPath (
IN PUNICODE_STRING pRootName,
IN PUNICODE_STRING pMetadataPrefix,
IN PUNICODE_STRING pApiLogicalName )
{
DFSSTATUS Status;
UNICODE_STRING FirstComponent;
UNICODE_STRING Remaining;
//
// For the ad blob store, the metadata prefix holds the
// name context, the share name and the link name.
// However, we will want to replace the first component
// with the rootname, so that when domains are renamed,
// we keep passing back correct information even though
// the blob has not been updated.
//
if (DfsCheckSubstitutePaths())
{
Status = DfsGetFirstComponent( pMetadataPrefix,
&FirstComponent,
&Remaining );
if (Status == ERROR_SUCCESS)
{
Status = DfsCreateUnicodePathStringFromUnicode( pApiLogicalName,
2, // 2 leading path sep
pRootName,
&Remaining );
}
} else
{
//
// The caller has disabled path name substitution because she wants to see
// things as is. So just make a copy.
//
Status = DfsCreateUnicodePathStringFromUnicode(pApiLogicalName,
2, // 2 leading path separators
pMetadataPrefix,
NULL);
}
return Status;
}
DFSSTATUS
DfsADBlobStore::GetCompatRootFolder(
PUNICODE_STRING pName,
DfsRootFolder **ppNewRoot )
{
DfsADBlobRootFolder *pNewRoot = NULL;
UNICODE_STRING DomainName;
DFSSTATUS Status = ERROR_SUCCESS;
*ppNewRoot = NULL;
Status = DfsGetDomainName( &DomainName );
if (Status != ERROR_SUCCESS)
{
return Status;
}
pNewRoot = new DfsADBlobRootFolder( DomainName.Buffer,
L"Unknown",
pName,
pName,
this,
&Status );
//
// The root folder made a copy of this, so we are safe to delete.
//
DfsReleaseDomainName( &DomainName );
// The new operator may fail.
if (pNewRoot == NULL)
{
Status = ERROR_NOT_ENOUGH_MEMORY;
return Status;
}
if (Status == ERROR_SUCCESS)
{
pNewRoot->ResetCreateDirectories();
//set this so we read from this DC, instead of the PDC.
pNewRoot->SetRootScalabilityMode();
Status = pNewRoot->Synchronize( TRUE );
if (Status == ERROR_SUCCESS)
{
*ppNewRoot = pNewRoot;
}
}
if (Status != ERROR_SUCCESS)
{
ASSERT(pNewRoot);
pNewRoot->ReleaseReference();
}
return Status;
}
DFSSTATUS
DfsADBlobStore::DoesUserHaveAccess(DfsRootFolder *pRootFolder,
DWORD DesiredAccess)
{
DFS_METADATA_HANDLE RootHandle = NULL;
DFSSTATUS Status = ERROR_SUCCESS;
DfsADBlobCache *pBlobCache = NULL;
Status = pRootFolder->GetMetadataHandle( &RootHandle );
if (Status == ERROR_SUCCESS)
{
pBlobCache = (DfsADBlobCache *)ExtractFromMetadataHandle( RootHandle);
Status = pBlobCache->DfsDoesUserHaveAccess(DesiredAccess);
pRootFolder->ReleaseMetadataHandle( RootHandle );
}
return Status;
}