|
|
//+----------------------------------------------------------------------------
//
// Copyright (C) 2000, Microsoft Corporation
//
// File: DfsRegistryStore.cxx
//
// Contents: the Registry DFS Store class, this contains the registry
// specific functionality.
//
// Classes: DfsRegistryStore.
//
// History: Dec. 8 2000, Author: udayh
//
//-----------------------------------------------------------------------------
#include "DfsRegistryStore.hxx"
#include "DfsRegistryRootFolder.hxx"
#include "DfsFilterApi.hxx"
#include "dfsmisc.h"
#include "domainControllerSupport.hxx"
#include "DfsRegStrings.hxx"
#include "shlwapi.h"
#include "align.h"
//
// logging specific includes
//
#include "DfsRegistryStore.tmh"
externDFSSTATUSMigrateDfs( LPWSTR MachineName);
//+----------------------------------------------------------------------------
//
// Class: DfsRegistryStore
//
// Synopsis: This class inherits the basic DfsStore, and extends it
// to include the registry specific functionality.
//
//-----------------------------------------------------------------------------
LPWSTR DfsRegistryNameString = L"ID";LPWSTR DfsRegistryRecoveryString = L"Recovery";LPWSTR DfsRegistryReplicaString = L"Svc";LPWSTR DfsRegistryDfsDriverLocation = DFS_REG_DFS_DRIVER_LOCATION;LPWSTR DfsLocalVolumesValue = DFS_REG_LOCAL_VOLUMES_CHILD;extern LPWSTR DfsVolumesLocation;
//+-------------------------------------------------------------------------
//
// 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 registry 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.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::StoreRecognizer( LPWSTR Name ){ DFSSTATUS Status = ERROR_SUCCESS; HKEY OldStandaloneDfsKey = NULL; HKEY StandaloneDfsKey = NULL; BOOLEAN MachineContacted = FALSE;
//
// Make sure the namespace is the name of a machine. Registry based
// dfs exist only on machines.
//
if (IsEmptyString(Name) == FALSE) { Status = DfsIsThisAMachineName( Name ); if(Status != ERROR_SUCCESS) { return Status; } }
DFS_TRACE_LOW(REFERRAL_SERVER, "DfsRegistryStore:StoreRecognizer, Name %ws Is Machine Status %x\n", Name, Status);
//
// we now find all the migrated multiple roots standalone DFS's as
// well as the old single root standalone DFS, and add them to our
// in memory metadata.
//
Status = GetNewStandaloneRegistryKey( Name, FALSE, &MachineContacted, &StandaloneDfsKey ); if (Status == ERROR_SUCCESS) { Status = StoreRecognizeNewDfs( Name, StandaloneDfsKey );
RegCloseKey( StandaloneDfsKey ); }
//
// Need to refine the return status further: success should mean
// machine is not std dfs or we have read the std dfs data correctly.
//
DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Dfs registry store recognizser, 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.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::StoreRecognizer ( LPWSTR DfsNameContext, PUNICODE_STRING pLogicalShare ){ DFSSTATUS Status;
Status = DfsIsThisAMachineName( DfsNameContext );
if (Status == ERROR_SUCCESS) { Status = StoreRecognizeNewDfs( DfsNameContext, pLogicalShare ); }
DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "DfsRegistryStore:StoreRecognizer (remote), Status %x\n", Status); return Status;}
DFSSTATUSDfsRegistryStore::LookupDotNetRootByName( LPWSTR ShareName, DfsRootFolder **ppRootFolder ){
DFSSTATUS Status = ERROR_SUCCESS; HKEY DfsKey = NULL; HKEY DfsRootKey = NULL;
Status = GetNewStandaloneRegistryKey( NULL, FALSE, NULL, &DfsKey ); if (Status == ERROR_SUCCESS) { Status = RegOpenKeyEx( DfsKey, ShareName, 0, KEY_READ, &DfsRootKey );
RegCloseKey(DfsKey );
if (Status == ERROR_SUCCESS) { Status = GetRootFolder( NULL, ShareName, DfsRootKey, ppRootFolder ); RegCloseKey(DfsRootKey); } }
return Status;}
DFSSTATUSDfsRegistryStore::LookupOldRootByName( LPWSTR ShareName, DfsRootFolder **ppRootFolder ){
DFSSTATUS Status = ERROR_SUCCESS; HKEY DfsKey = NULL; HKEY DfsRootKey = NULL; UNICODE_STRING LogicalShare;
Status = GetOldStandaloneRegistryKey( NULL, FALSE, NULL, &DfsRootKey );
if (Status == ERROR_SUCCESS) { Status = GetRootPhysicalShare( DfsRootKey, &LogicalShare); if (Status == ERROR_SUCCESS) { if (_wcsicmp(ShareName, LogicalShare.Buffer) != 0) { Status = ERROR_NOT_FOUND;
ReleaseRootLogicalShare( &LogicalShare ); } }
if(Status == ERROR_SUCCESS) { Status = MigrateDfs( L"" ); if(Status == ERROR_SUCCESS) {
Status = GetRootFolder( L"", ShareName, &LogicalShare, &LogicalShare, ppRootFolder ); }
ReleaseRootLogicalShare( &LogicalShare ); }
if(DfsRootKey != NULL) { RegCloseKey( DfsRootKey ); } }
return Status;}
DFSSTATUSDfsRegistryStore::LookupNewRootByName( LPWSTR ShareName, DfsRootFolder **ppRootFolder ){ DFSSTATUS Status = ERROR_NOT_FOUND;
if(DfsIsMachineCluster()) { Status = LookupOldRootByName (ShareName, ppRootFolder); if(Status != ERROR_SUCCESS) { Status = LookupDotNetRootByName (ShareName, ppRootFolder); } } return Status;}
#if 0
//+-------------------------------------------------------------------------
//
// Function: StoreRecognizeOldStandaloneDfs - recognizer for single root dfs
//
// Arguments: Name - the namespace of interest.
// HKEY OldDfsKey.
//
// Returns: Status
// ERROR_SUCCESS on success
// ERROR status code otherwise
//
//
// Description: This routine reads a single root from the old standalone
// location, and loads it in if the root exists.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::StoreRecognizeOldStandaloneDfs( LPWSTR MachineName, HKEY OldDfsKey ){ DfsRootFolder *pRootFolder = NULL; DFSSTATUS Status = ERROR_SUCCESS; DFSSTATUS RootStatus = ERROR_SUCCESS; UNICODE_STRING LogicalRoot; UNICODE_STRING DfsNameContext; UNREFERENCED_PARAMETER(MachineName);
RtlZeroMemory(&LogicalRoot, sizeof(LogicalRoot)); //
// Check if we have a root folder read from the old dfs location
// ("domainroot"). If we have not seen the root already, and one
// exists, a new root folder gets created.
// Status = DfsGetRegValueString (OldDfsKey,
// DfsRootShareValueName,
// &LogicalRoot);
Status = GetRootPhysicalShare(OldDfsKey,&LogicalRoot); if(Status == ERROR_SUCCESS) {
RtlInitUnicodeStringEx( &DfsNameContext, NULL);
//
// Check if we already know about this root. If we do, this
// routine gives us a referenced root folder which we can return.
// If not, we create a brand new root folder.
//
Status = LookupRoot( &DfsNameContext, &LogicalRoot, &pRootFolder );
//
// we did not find a root, so create a new one.
//
if ( Status != ERROR_SUCCESS ) { Status = MigrateStdDfs( L"", OldDfsKey, (LPWSTR) LogicalRoot.Buffer, (LPWSTR) LogicalRoot.Buffer, FALSE); if(Status == ERROR_SUCCESS) {
//
// Now get either an existing root by this name,
// or create a new one.
//
RootStatus = GetRootFolder( L"", LogicalRoot.Buffer, &LogicalRoot, &LogicalRoot, &pRootFolder );
if (RootStatus == ERROR_SUCCESS) {
//
// Call the synchronize method on the root to
// update it with the latest children.
// Again, ignore the error since we need to move
// on to the next root.
// dfsdev: need eventlog to signal this.
//
RootStatus = pRootFolder->Synchronize();
//
// If the Synchronize above had succeeded, then it would
// all the reparse points that the root needs. Now we n
// this volume as one that has DFS reparse points so th
// to perform garbage collection on this volume later o
//
(VOID)pRootFolder->AddReparseVolumeToList();
} } }
ReleaseRootPhysicalShare( &LogicalRoot ); }
if(pRootFolder != NULL) { pRootFolder->ReleaseReference(); } return Status;}#endif
#if 0
DFSSTATUSDfsRegistryStore::StoreRecognizeOldStandaloneDfs( LPWSTR MachineName, HKEY OldDfsKey ){ DfsRootFolder *pRootFolder = NULL; DFSSTATUS Status = ERROR_SUCCESS;
//
// Check if we have a root folder read from the old dfs location
// ("domainroot"). If we have not seen the root already, and one
// exists, a new root folder gets created.
//
Status = GetRootFolder( MachineName, NULL, OldDfsKey, &pRootFolder );
//
// We got a root folder. call synchronize on it to update its contents.
// The synchronize method fills the root with the most upto date
// children data.
//
if (Status == ERROR_SUCCESS) {
DFSSTATUS RootStatus;
//
// now acquire the root share directory. If this
// fails, we continue our operation: we can continue
// with synchonize and not create directories.
// dfsdev:we need to post a eventlog or something when
// we run into this.
//
RootStatus = pRootFolder->AcquireRootShareDirectory();
//
// Call the synchronize method on the root to
// update it with the latest children.
// Again, ignore the error since we need to move
// on to the next root.
// dfsdev: need eventlog to signal this.
//
RootStatus = pRootFolder->Synchronize();
DFSLOG("Root folder for %ws, Synchronize status %x\n", RootStatus );
// Release our reference on the root folder.
pRootFolder->ReleaseReference(); } return Status;}#endif
//+-------------------------------------------------------------------------
//
// Function: CreateNewRootFolder - creates a new root folder
//
// Arguments: Name - the namespace of interest.
// pPrefix - the logical share for this DFs.
// ppRoot - the newly created root.
//
//
// Returns: Status
// ERROR_SUCCESS on success
// ERROR status code otherwise
//
//
// Description: This routine creates a new registry root folder, and
// adds it to the list of known roots.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::CreateNewRootFolder ( LPWSTR MachineName, 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 DfsRegistryRootFolder( MachineName, RootRegKeyName, pLogicalShare, pPhysicalShare, this, &Status );
if ( pNewRoot == NULL ) { 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 { if(pNewRoot != NULL) { pNewRoot->ReleaseReference(); pNewRoot = NULL; } }
DFS_TRACE_ERROR_LOW(Status, REFERRAL_SERVER, "RegistryStore::CreateNewRootFolder. New root %p, for root %wZ (%wZ) on machine %ws. Status %x\n", *ppRoot, pLogicalShare, pPhysicalShare, MachineName, Status);
return Status;}
//+-------------------------------------------------------------------------
//
// Function: GetMetadata- Gets the DFS metadata information
//
// Arguments: DfsMetadataKey - The key under which the information exists
// RelativeName - the name of the subkey, having info of interest
// RegistryValueNameString - The value name that holds the info.
// ppData - the pointer that holds data buffer being returned
// pDataSize - pointer to size of data being returned.
//
// Returns: Status
// STATUS_SUCCESS if we could read the information,
// error status otherwise.
//
//
// Description: This routine reads the value of interest under the specified
// key/subkey. The information is read in a buffer allocated
// by this routine, and the buffer is returned to the caller.
// It is the caller's responsibility to free this buffer when
// done.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::GetMetadata ( IN HKEY DfsMetadataKey, IN LPWSTR RelativeName, IN LPWSTR RegistryValueNameString, OUT PVOID *ppData, OUT ULONG *pDataSize, OUT PFILETIME pLastModifiedTime){
HKEY NewKey = NULL; HKEY UseKey = NULL; PVOID pDataBuffer = NULL; ULONG DataSize, DataType; DFSSTATUS Status = ERROR_SUCCESS;
//
// If a relative name was passed in, we need to open a subkey under the
// passed in key. Otherwise, we already have a key open to the information
// of interest.
//
if ( RelativeName != NULL ) { Status = RegOpenKeyEx( DfsMetadataKey, RelativeName, 0, KEY_READ, &NewKey ); if ( Status == ERROR_SUCCESS ) { UseKey = NewKey; } else { DFS_TRACE_HIGH( REFERRAL_SERVER, "registry store, GetMetadata-RegOpenKeyEx %ws status=%d\n", RelativeName, Status); } } else { UseKey = DfsMetadataKey; }
//
// Get the largest size of any value under the key of interest, so we know
// how much we need to allocate in the worst case.
// (If a subkey has 3 values, this returns the maximum memory size required
// to read any one of the values.)
//
if ( Status == ERROR_SUCCESS ) { Status = RegQueryInfoKey( UseKey, // Key
NULL, // Class string
NULL, // Size of class string
NULL, // Reserved
NULL, // # of subkeys
NULL, // max size of subkey name
NULL, // max size of class name
NULL, // # of values
NULL, // max size of value name
&DataSize, // max size of value data,
NULL, // security descriptor
pLastModifiedTime ); // Last write time
}
//
// We have the required size now: allocate a buffer for that size and
// read the value we are interested in.
//
if ( Status == ERROR_SUCCESS ) { pDataBuffer = new BYTE [DataSize];
if ( pDataBuffer == NULL ) { Status = ERROR_NOT_ENOUGH_MEMORY; } else { Status = RegQueryValueEx( UseKey, RegistryValueNameString, NULL, &DataType, (LPBYTE)pDataBuffer, &DataSize ); //
// If the format of data is not a certain type (usually binary type for DFS)
// we have bogus data.
//
if ( (Status == ERROR_SUCCESS) && (DataType != DFS_REGISTRY_DATA_TYPE) ) { Status = ERROR_INVALID_DATA; } } }
//
// If we are successful in reading the value, pass the allcoated buffer and
// size back to caller. Otherwise, free up the allocate buffer and return
// error status to the caller.
//
if ( Status == ERROR_SUCCESS ) { *ppData = pDataBuffer; *pDataSize = DataSize; } else { if ( pDataBuffer != NULL ) { delete [] pDataBuffer; } }
//
// If we did open a new key, it is time to close it now.
//
if ( NewKey != NULL ) RegCloseKey(NewKey);
DFS_TRACE_LOW( REFERRAL_SERVER, "registry store, GetMetadata-leaving %ws status=%d\n", RelativeName, Status);
return Status;}
//+-------------------------------------------------------------------------
//
// Function: SetMetadata- Sets the DFS metadata information
//
// Arguments: DfsMetadataKey - The key under which the information exists
// RelativeName - the name of the subkey, to store info
// RegistryValueNameString - The value name that holds the info.
// pData - the pointer that holds data buffer
// DataSize - Size of data
//
// Returns: Status
// STATUS_SUCCESS if we could write the information,
// error status otherwise.
//
//
// Description: This routine writes the value of interest under the specified
// key/subkey.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::SetMetadata ( IN HKEY DfsMetadataKey, IN LPWSTR RelativeName, IN LPWSTR RegistryValueNameString, IN PVOID pData, IN ULONG DataSize ){
HKEY UseKey = NULL; DFSSTATUS Status = ERROR_SUCCESS;
//
// If a relative name was passed in, we need to open a subkey under the
// passed in key. Otherwise, we already have a key open to the information
// of interest.
//
Status = RegOpenKeyEx( DfsMetadataKey, RelativeName, 0, KEY_READ | KEY_WRITE, &UseKey );
//
// Store the value against the passed in value string
//
if (Status == ERROR_SUCCESS) { Status = RegSetValueEx( UseKey, RegistryValueNameString, NULL, DFS_REGISTRY_DATA_TYPE, (LPBYTE)pData, DataSize ); RegCloseKey(UseKey); }
DFS_TRACE_LOW( REFERRAL_SERVER, "registry store, SetMetadata-RegOpenKeyEx %ws status=%d\n", RelativeName, Status);
return Status;}
//+-------------------------------------------------------------------------
//
// Function: GetRootKey - get the root key
//
// Arguments: Name - the namespace of interest.
// pMachineContacted - did we contact the machine?
// pDfsRootKey - the returned key.
//
// Returns: Status
// ERROR_SUCCESS on success
// ERROR status code otherwise
//
//
// Description: This routine connects to the appropriate machine, and
// opens the DFS metadata information in the registry.
// If it succeeds, the machine hosts a registry DFs, and
// the opened key is returned.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::GetRootKey( LPWSTR MachineName, LPWSTR ChildName, BOOLEAN *pMachineContacted, OUT PHKEY pDfsRootKey ){ DFSSTATUS Status; HKEY DfsStdRegistryKey; LPWSTR UseChildName = NULL;
if (IsEmptyString(ChildName) == FALSE) { UseChildName = ChildName; }
//
// If there is no childname specified, we are dealing with the
// old style dfs: a single root exists on the machine under "domainroot".
// so open that key, and return it.
// If a childname is specified, we are dealing with a migrated
// dfs. Open the specified child in the new location.
//
if (UseChildName != NULL) { Status = GetNewStandaloneRegistryKey( MachineName, FALSE, pMachineContacted, &DfsStdRegistryKey );
if (Status == ERROR_SUCCESS) { //
// We then open the required child key, and close
// the parents key.
//
Status = RegOpenKeyEx( DfsStdRegistryKey, ChildName, 0, KEY_READ, pDfsRootKey );
RegCloseKey( DfsStdRegistryKey ); } } else { //
// no name was specified. This must be the old standalone
// child. (single root)
//
Status = GetOldStandaloneRegistryKey( MachineName, FALSE, pMachineContacted, pDfsRootKey ); }
DFSLOG("DfsRegistryStore::GetDfsRootKey %ws Machine, Contacted %d Status %x\n", MachineName, pMachineContacted ? *pMachineContacted : 2, Status );
return Status;}
//+-------------------------------------------------------------------------
//
// Function: GetDataRecoveryInformation - Gets recovery info
//
// Arguments: DfsMetadataKey - an open key to the registry.
// RelativeName - Name of a subkey under the above key.
// pRecoveryState - The recovery state we read.
//
// Returns: Status
// STATUS_SUCCESS if we could read the information
// error status otherwise.
//
//
// Description: This routine read the RECOVERY value for the Root or link of
// a dfs tree and returns with the value.
// A non-zero state means that some recovery is required.
// Note that there is more information in the RECOVERY value than
// the state. Currently, we ignore that information and just return
// the state.
// In the future, we dont plan to use this value.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::GetDataRecoveryState ( IN HKEY DfsMetadataKey, IN LPWSTR RelativeName, OUT PULONG pRecoveryState ){ DFSSTATUS Status = ERROR_SUCCESS; PVOID DataBuffer = NULL, CurrentBuffer; ULONG DataSize, CurrentSize;
Status = GetMetadata (DfsMetadataKey, RelativeName, DfsRegistryRecoveryString, &DataBuffer, &DataSize, NULL ); // we dont care about last mod time.
//
// We are currently interested in the first word in the data stream.
// This holds the recovery state.
//
if ( Status == STATUS_SUCCESS ) { CurrentBuffer = DataBuffer; CurrentSize = DataSize; Status = PackGetULong( pRecoveryState, &CurrentBuffer, &CurrentSize ); }
ReleaseMetadataBlob( DataBuffer );
//
// If we could not read the value, then we return success and
// and indicate state of 0. This is so that we can support roots
// or links that dont have this value.
//
if ( Status != ERROR_SUCCESS ) { DFSLOG("DfsRegistryStore::DfsGetDataRecoveryState Status %x\n", Status);
*pRecoveryState = 0; Status = ERROR_SUCCESS; }
return Status;}
INIT_STANDALONE_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 MiDfsIdProperty). If the stream
// does not have the sufficient
// info, ERROR_INVALID_DATA is returned back.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::PackGetNameInformation( IN PDFS_NAME_INFORMATION pDfsNameInfo, IN OUT PVOID *ppBuffer, IN OUT PULONG pSizeRemaining){ DFSSTATUS Status;
//
// Get the name information from the binary stream.
//
Status = PackGetInformation( (ULONG_PTR)pDfsNameInfo, ppBuffer, pSizeRemaining, &MiStdDfsIdProperty ); //
// Immediately following the name value is a timeout value.
// This is not in the MiDfsIdProperty because it appers that some
// of the older DFS may not have the timeout value.
//
if ( Status == ERROR_SUCCESS ) { pDfsNameInfo->LastModifiedTime = pDfsNameInfo->PrefixTimeStamp;
Status = PackGetULong(&pDfsNameInfo->Timeout, ppBuffer, pSizeRemaining); //
// Use a default value if we cannot get the timeout value in
// the stream.
//
if ( Status != ERROR_SUCCESS ) { pDfsNameInfo->Timeout = 300; // hard code this value.
Status = ERROR_SUCCESS; } }
if (Status == ERROR_SUCCESS) { if ((pDfsNameInfo->Type & 0x80) == 0x80) { pDfsNameInfo->State |= DFS_VOLUME_FLAVOR_STANDALONE; } }
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.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::PackSetNameInformation( IN PDFS_NAME_INFORMATION pDfsNameInfo, IN OUT PVOID *ppBuffer, IN OUT PULONG pSizeRemaining){ DFSSTATUS Status;
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, &MiStdDfsIdProperty );
//
// Follow that info with the timeout information.
//
if ( Status == ERROR_SUCCESS ) { Status = PackSetULong( pDfsNameInfo->Timeout, ppBuffer, pSizeRemaining); }
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.
//
//--------------------------------------------------------------------------
ULONGDfsRegistryStore::PackSizeNameInformation( IN PDFS_NAME_INFORMATION pDfsNameInfo ){ ULONG Size;
Size = PackSizeInformation( (ULONG_PTR)pDfsNameInfo, &MiStdDfsIdProperty );
Size += PackSizeULong();
return Size;}
//+-------------------------------------------------------------------------
//
// 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.
//
//--------------------------------------------------------------------------
DFSSTATUSDfsRegistryStore::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; ULONG NameBlobSize, ReplicaBlobSize;
Status = CreateNameInformationBlob( pNameInfo, &pNameBlob, &NameBlobSize );
if (Status == ERROR_SUCCESS) { Status = CreateReplicaListInformationBlob( pReplicaListInfo, &pReplicaBlob, &ReplicaBlobSize );
if (Status == ERROR_SUCCESS) { Status = CreateNewChild( DfsHandle, pNameBlob, NameBlobSize, pReplicaBlob, ReplicaBlobSize, pMetadataName );
ReleaseMetadataReplicaBlob( pReplicaBlob, ReplicaBlobSize ); } ReleaseMetadataNameBlob( pNameBlob, NameBlobSize ); } return Status;}
DFSSTATUSDfsRegistryStore::CreateNewChild( IN DFS_METADATA_HANDLE DfsHandle, IN PVOID pNameBlob, IN ULONG NameBlobSize, IN PVOID pReplicaBlob, IN ULONG ReplicaBlobSize, IN PUNICODE_STRING pMetadataName ){ HKEY DfsMetadataKey; DFSSTATUS Status; HKEY ChildKey; DfsMetadataKey = (HKEY)ExtractFromMetadataHandle( DfsHandle );
//
// Now create the child with this name
//
Status = RegCreateKeyEx( DfsMetadataKey, pMetadataName->Buffer, 0, L"", REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &ChildKey, NULL );
//
// Now set the name and replica information on this newly created
// key.
//
if (Status == ERROR_SUCCESS) { Status = SetMetadata( ChildKey, NULL, DfsRegistryNameString, pNameBlob, NameBlobSize ); if (Status == ERROR_SUCCESS) { Status = SetMetadata( ChildKey, NULL, DfsRegistryReplicaString, pReplicaBlob, ReplicaBlobSize ); } //
// we are done with the child key: close it here.
//
RegCloseKey (ChildKey);
//
// if we were unsuccessful in adding the name and
// replica details, get rid of the new child registry entry.
//
if (Status != ERROR_SUCCESS) { DFSSTATUS DeleteStatus;
DeleteStatus = RegDeleteKey( DfsMetadataKey, pMetadataName->Buffer );
DFSLOG("Created Key, but failed to add values %x. Delete Status %x\n", Status, DeleteStatus ); } }
return Status;}
DFSSTATUSDfsRegistryStore::RemoveChild( IN DFS_METADATA_HANDLE DfsHandle, LPWSTR ChildName )
{ DFSSTATUS Status; HKEY DfsMetadataKey;
DfsMetadataKey = (HKEY)ExtractFromMetadataHandle( DfsHandle );
Status = RegDeleteKey( DfsMetadataKey, ChildName );
return Status;}
DFSSTATUSDfsRegistryStore::CreateStandaloneRoot( LPWSTR MachineName, LPWSTR LogicalShare, LPWSTR Comment ){ DFSSTATUS Status = ERROR_SUCCESS; HKEY StdDfsKey = NULL; HKEY StdDfsShareKey = NULL; DfsRootFolder *pRootFolder = NULL; PVOID pBlob = NULL; ULONG BlobSize = 0; DFS_NAME_INFORMATION NameInfo; DFS_REPLICA_LIST_INFORMATION ReplicaListInfo; DFS_REPLICA_INFORMATION ReplicaInfo; UNICODE_STRING DfsMachine; UNICODE_STRING DfsShare;
DFS_TRACE_LOW( REFERRAL_SERVER, "registry store, create root %ws\n", LogicalShare);
Status = DfsRtlInitUnicodeStringEx( &DfsMachine, MachineName ); if(Status != ERROR_SUCCESS) { Status = ERROR_INVALID_PARAMETER; DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "CreateStandaloneRoot, DfsRtlInitUnicodeStringEx - create root %ws, status %x\n", LogicalShare, Status); return Status; }
Status = DfsRtlInitUnicodeStringEx( &DfsShare, LogicalShare ); if(Status != ERROR_SUCCESS) { Status = ERROR_INVALID_PARAMETER; DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "CreateStandaloneRoot, DfsRtlInitUnicodeStringEx - create root %ws, status %x\n", LogicalShare, Status); return Status; }
RtlZeroMemory(&NameInfo, sizeof(DFS_NAME_INFORMATION));
if (DfsIsSpecialDomainShare(&DfsShare)) { Status = ERROR_INVALID_PARAMETER; DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "registry store, Special Share - create root %ws, status %x\n", LogicalShare, Status); return Status; }
Status = LookupRoot( &DfsMachine, &DfsShare, &pRootFolder );
DFS_TRACE_LOW( REFERRAL_SERVER, "registry store, create root, lookup root %p, status %x\n", pRootFolder, Status);
if (Status == ERROR_SUCCESS) { pRootFolder->ReleaseReference();
Status = ERROR_FILE_EXISTS;
return Status; }
Status = GetNewStandaloneRegistryKey( MachineName, TRUE, // write permission required
NULL, &StdDfsKey ); if (Status == ERROR_SUCCESS) { UNICODE_STRING LogicalName;
RtlInitUnicodeString( &LogicalName, LogicalShare ); StoreInitializeNameInformation( &NameInfo, &LogicalName, NULL, Comment ); NameInfo.Type |= 0x80;
StoreInitializeReplicaInformation( &ReplicaListInfo, &ReplicaInfo, (MachineName == NULL) ? L"." : MachineName, LogicalShare ); } if (Status == ERROR_SUCCESS) {#if defined (DFS_FUTURES)
//
// Check if we need to store the root as a guid instead of
// the root name itself.
// It is probably not necessary, but for some reason if we need
// to, we can scavenge this code.
//
//
// get an unique metadata name for the root.
//
Status = DfsGenerateUuidString(&UuidString);#endif
Status = RegCreateKeyEx( StdDfsKey, LogicalShare, 0, L"", REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, NULL, &StdDfsShareKey, NULL ); if (Status == ERROR_SUCCESS) { size_t LogicalShareCchLength = 0; Status = DfsStringCchLength( LogicalShare, MAXUSHORT, &LogicalShareCchLength ); if (Status == ERROR_SUCCESS) { LogicalShareCchLength++; // NULL Terminator
Status = RegSetValueEx( StdDfsShareKey, DfsRootShareValueName, 0, REG_SZ, (PBYTE)LogicalShare, LogicalShareCchLength * sizeof(WCHAR) ); }
if (Status == ERROR_SUCCESS) { Status = RegSetValueEx( StdDfsShareKey, DfsLogicalShareValueName, 0, REG_SZ, (PBYTE)LogicalShare, LogicalShareCchLength * sizeof(WCHAR) ); }
if (Status == ERROR_SUCCESS) { Status = CreateNameInformationBlob( &NameInfo, &pBlob, &BlobSize); if (Status == ERROR_SUCCESS) { Status = SetMetadata( StdDfsShareKey, NULL, DfsRegistryNameString, pBlob, BlobSize ); ReleaseMetadataNameBlob(pBlob, BlobSize ); } }
if (Status == ERROR_SUCCESS) { Status = CreateReplicaListInformationBlob( &ReplicaListInfo, &pBlob, &BlobSize); if (Status == ERROR_SUCCESS) { Status = SetMetadata( StdDfsShareKey, NULL, DfsRegistryReplicaString, pBlob, BlobSize ); ReleaseMetadataNameBlob( pBlob, BlobSize ); } } if (Status == ERROR_SUCCESS) { Status = GetRootFolder( MachineName, LogicalShare, &DfsShare, &DfsShare, &pRootFolder ); if (Status == ERROR_SUCCESS) { //
// Now, acquire the root share directory. If we fail
// this, we deny the creation of the root.
// acquire root share directory converts the root share
// to a physical path, checks if that supports
// reparse points, and if so tells the dfs driver
// to attach to the drive.
// if any of these fail, we cannot proceed.
//
Status = pRootFolder->AcquireRootShareDirectory();
if (Status != ERROR_SUCCESS) { //
// make a best effort to remove ourselves
// dont care about status return, thoug
// we may want to log it.
//dfsdev: add logging.
//
RemoveRootFolder(pRootFolder, TRUE ); // permanent removal
} //
// now mark the root folder as synchronized:
// this is true since this root is empty.
//
if (Status == ERROR_SUCCESS) { pRootFolder->SetRootFolderSynchronized(); }
pRootFolder->ReleaseReference(); }
DFSLOG("Add Standalone Root, adding root folder status %x\n", Status); }
RegCloseKey( StdDfsShareKey ); if (Status != ERROR_SUCCESS) { RegDeleteKey( StdDfsKey, LogicalShare ); } }
#if defined (DFS_FUTURES)
DfsReleaseUuidString(&UuidString);#endif
RegCloseKey( StdDfsKey ); } DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "registry store, create root %ws, status %x\n", LogicalShare, Status); return Status;}
DFSSTATUSDfsRegistryStore::DeleteStandaloneRoot( LPWSTR MachineName, LPWSTR LogicalShare )
{ DFSSTATUS Status = ERROR_SUCCESS; HKEY DfsKey = NULL; DfsRootFolder *pRootFolder = NULL; LPWSTR RootRegistryName = NULL; LPWSTR UseChildName = NULL; UNICODE_STRING DfsMachine; UNICODE_STRING DfsShare;
DFS_TRACE_LOW( REFERRAL_SERVER, "Delete Standalone root %ws\n", LogicalShare);
Status = DfsRtlInitUnicodeStringEx( &DfsMachine, MachineName ); if(Status != ERROR_SUCCESS) { Status = ERROR_INVALID_PARAMETER; DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "DeleteStandaloneRoot, DfsRtlInitUnicodeStringEx - create root %ws, status %x\n", LogicalShare, Status); return Status; }
Status = DfsRtlInitUnicodeStringEx( &DfsShare, LogicalShare ); if(Status != ERROR_SUCCESS) { Status = ERROR_INVALID_PARAMETER; DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "DeleteStandaloneRoot, DfsRtlInitUnicodeStringEx - create root %ws, status %x\n", LogicalShare, Status); return Status; }
Status = LookupRoot( &DfsMachine, &DfsShare, &pRootFolder );
DFS_TRACE_LOW( REFERRAL_SERVER, "Delete Standalone root, lookup root %p, status %x\n", pRootFolder, Status);
if (Status == ERROR_SUCCESS) { Status = pRootFolder->AcquireRootLock(); if (Status == ERROR_SUCCESS) { pRootFolder->SetRootFolderDeleteInProgress(); pRootFolder->ReleaseRootLock(); } }
if (Status == ERROR_SUCCESS) { RootRegistryName = pRootFolder->GetRootRegKeyNameString();
UseChildName = (IsEmptyString(RootRegistryName) == TRUE) ? NULL : RootRegistryName;
if (UseChildName == NULL) { Status = GetOldDfsRegistryKey( MachineName, TRUE, NULL, &DfsKey ); if (Status == ERROR_SUCCESS) { Status = SHDeleteKey( DfsKey, DfsOldStandaloneChild);
RegCloseKey( DfsKey ); } } else { Status = GetNewStandaloneRegistryKey( MachineName, TRUE, NULL, &DfsKey ); if (Status == ERROR_SUCCESS) { Status = SHDeleteKey( DfsKey, UseChildName ); RegCloseKey( DfsKey ); }
} }
//
// DfsDev: needs fixing.
//
if (Status == ERROR_SUCCESS) { NTSTATUS DeleteStatus;
//
// Release the root folder that we had acquired earlier for
// this root.
//
DeleteStatus = RemoveRootFolder( pRootFolder, TRUE ); // permanent removal
DFS_TRACE_ERROR_LOW( DeleteStatus, REFERRAL_SERVER, "remove root folder %p (%ws) status %x\n", pRootFolder, LogicalShare, DeleteStatus);
DeleteStatus = pRootFolder->ReleaseRootShareDirectory(); DFS_TRACE_ERROR_LOW( DeleteStatus, REFERRAL_SERVER, "release root share for %ws status %x\n", LogicalShare, DeleteStatus);
pRootFolder->ReleaseReference(); }
DFS_TRACE_ERROR_LOW( Status, REFERRAL_SERVER, "Delete Standalone root for %ws, done, status %x\n", LogicalShare, Status); return Status;}
DFSSTATUSDfsRegistryStore::EnumerateApiLinks( IN DFS_METADATA_HANDLE DfsHandle, PUNICODE_STRING pRootName, DWORD Level, LPBYTE pBuffer, LONG BufferSize, LPDWORD pEntriesToRead, LPDWORD pResumeHandle, PLONG pSizeRequired ){ HKEY DfsKey = NULL; ULONG ChildNum = 0; DFSSTATUS Status = ERROR_SUCCESS; BOOLEAN OverFlow = FALSE; LONG HeaderSize = 0; LONG EntriesRead = 0; LONG EntriesToRead = *pEntriesToRead; LONG SizeRequired = 0; LONG EntryCount = 0;
LPBYTE pLinkBuffer = NULL; LONG LinkBufferSize = 0;
LPBYTE CurrentBuffer = NULL; LPBYTE NewBuffer = NULL; LONG SizeRemaining = 0; DFSSTATUS PackStatus = ERROR_SUCCESS; ULONG_PTR SizeDiff; DWORD CchMaxName = 0; DWORD CchChildName = 0; LPWSTR ChildName = NULL; Status = DfsApiSizeLevelHeader( Level, &HeaderSize ); if (Status != ERROR_SUCCESS) { return Status; }
DfsKey = (HKEY)ExtractFromMetadataHandle( DfsHandle );
OverFlow = FALSE;
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; }
if (EntryCount == 0) { Status = GetStoreApiInformationBuffer ( DfsHandle, pRootName, NULL, Level, &pLinkBuffer, &LinkBufferSize ); if (Status == ERROR_SUCCESS) { SizeRequired += ROUND_UP_COUNT(LinkBufferSize, ALIGN_QUAD);
if (OverFlow == FALSE) { 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++; } }
if (Status != ERROR_SUCCESS ) { return Status; } ChildNum = EntryCount - 1;
//
// First find the length of the longest subkey
// and allocate a buffer big enough for it.
//
Status = RegQueryInfoKey( DfsKey, // Key
NULL, // Class string
NULL, // Size of class string
NULL, // Reserved
NULL, // # of subkeys
&CchMaxName, // max size of subkey name in TCHARs
NULL, // max size of class name
NULL, // # of values
NULL, // max size of value name
NULL, // max size of value data,
NULL, // security descriptor
NULL ); // Last write time
if (Status == ERROR_SUCCESS) { CchMaxName++; // Space for the NULL terminator.
ChildName = (LPWSTR) new WCHAR [CchMaxName]; if (ChildName == NULL) { Status = ERROR_NOT_ENOUGH_MEMORY; } }
if (Status == ERROR_SUCCESS) { do { //
// For each child, get the child name.
//
if (EntriesToRead && EntriesRead >= EntriesToRead) { break; }
CchChildName = CchMaxName; //
// Now enumerate the children, starting from the first child.
//
Status = RegEnumKeyEx( DfsKey, ChildNum, ChildName, &CchChildName, NULL, NULL, NULL, NULL );
ChildNum++;
if (Status == ERROR_SUCCESS) { Status = GetStoreApiInformationBuffer( DfsHandle, pRootName, ChildName, Level, &pLinkBuffer, &LinkBufferSize );
if (Status == ERROR_SUCCESS) { SizeRequired += ROUND_UP_COUNT(LinkBufferSize, ALIGN_QUAD); if (OverFlow == FALSE) { 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++; } } } while (Status == ERROR_SUCCESS);
delete [] ChildName; } *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;}
DFSSTATUSDfsRegistryStore::GetMetadataNameBlob( DFS_METADATA_HANDLE RootHandle, LPWSTR MetadataName, PVOID *ppData, PULONG pDataSize, PFILETIME pLastModifiedTime ) { HKEY DfsMetadataKey; DFSSTATUS Status;
DfsMetadataKey = (HKEY)ExtractFromMetadataHandle( RootHandle );
Status = GetMetadata( DfsMetadataKey, MetadataName, DfsRegistryNameString, ppData, pDataSize, pLastModifiedTime );
return Status;}
DFSSTATUSDfsRegistryStore::GetMetadataReplicaBlob( DFS_METADATA_HANDLE RootHandle, LPWSTR MetadataName, PVOID *ppData, PULONG pDataSize, PFILETIME pLastModifiedTime ){ HKEY DfsMetadataKey; DFSSTATUS Status;
DfsMetadataKey = (HKEY)ExtractFromMetadataHandle( RootHandle );
Status = GetMetadata( DfsMetadataKey, MetadataName, DfsRegistryReplicaString, ppData, pDataSize, pLastModifiedTime );
return Status;}
DFSSTATUSDfsRegistryStore::SetMetadataNameBlob( DFS_METADATA_HANDLE RootHandle, LPWSTR MetadataName, PVOID pData, ULONG DataSize )
{ HKEY DfsMetadataKey; DFSSTATUS Status;
DfsMetadataKey = (HKEY)ExtractFromMetadataHandle( RootHandle );
Status = SetMetadata( DfsMetadataKey, MetadataName, DfsRegistryNameString, pData, DataSize ); return Status;}
DFSSTATUSDfsRegistryStore::SetMetadataReplicaBlob( DFS_METADATA_HANDLE RootHandle, LPWSTR MetadataName, PVOID pData, ULONG DataSize ){ HKEY DfsMetadataKey; DFSSTATUS Status;
DfsMetadataKey = (HKEY)ExtractFromMetadataHandle( RootHandle );
Status = SetMetadata( DfsMetadataKey, MetadataName, DfsRegistryReplicaString, pData, DataSize );
return Status;}
//
// This removes the target share from the
// Microsoft\Dfs\Roots\Domain registry key.
//
DFSSTATUSDfsRegistryStore::CleanRegEntry( LPWSTR MachineName, LPWSTR LogicalShare ){ HKEY DfsKey; DFSSTATUS Status; DFSSTATUS RetStatus = ERROR_NOT_FOUND; HKEY DfsDriverKey; //
// If we can open the old registry key,
// then we assume we are dealing with an
// old style single root standalone system.
//
Status = GetDfsRegistryKey (MachineName, DfsRegistryHostLocation, //DfsHost
TRUE, NULL, &DfsKey ); //
// Delete the \DfsHost\Volumes key and all its values.
//
if (Status == ERROR_SUCCESS) { Status = SHDeleteKey( DfsKey, DfsVolumesLocation );
RegCloseKey( DfsKey );
if (Status == ERROR_SUCCESS) { // Something succeeded. We'll return that.
RetStatus = Status; // Delete the DfsDriver\LocalVolumes key as well.
Status = GetDfsRegistryKey (MachineName, DfsRegistryDfsDriverLocation, //System\CCS\Services\DfsDriver
TRUE, NULL, &DfsDriverKey ); //
// Delete the \LocalVolumes key and all its values.
//
if (Status == ERROR_SUCCESS) { Status = SHDeleteKey( DfsDriverKey, DfsLocalVolumesValue ); RegCloseKey( DfsDriverKey );
// We don't bother to recreate the DfsHost\Volumes key on error. For all external
// purposes the root should have disappeared now.
} } } //
// BUG 732833: Clean .Net location whether the Win2K location exists or not.
// We need both locations to co-exist on mix-mode cluster machines.
//
Status = GetNewStandaloneRegistryKey( MachineName, TRUE, NULL, &DfsKey ); if (Status == ERROR_SUCCESS) { Status = SHDeleteKey( DfsKey, LogicalShare ); if (Status == ERROR_SUCCESS) { RetStatus = Status; } RegCloseKey( DfsKey ); }
DFS_TRACE_LOW( REFERRAL_SERVER, "registry store, CleanRegistry %ws status=%d\n", MachineName, Status);
return RetStatus;
UNREFERENCED_PARAMETER( LogicalShare );}
|
