|
|
//+----------------------------------------------------------------------------
//
// Copyright (C) 1992, Microsoft Corporation.
//
// File: UPkt.c
//
// Contents: This module contains user mode functions which support
// operations on the DFS Partition Knowledge Table.
//
// Functions: PktOpen -
// PktClose -
// PktCreateEntry -
// PktCreateSubordinateEntry -
// PktFlushCache -
// PktDestroyEntry -
// PktModifyEntryGuid -
// PktSetRelationInfo -
//
// History:
//
// [mikese] I replaced MemAlloc's by malloc's, but consider using
// RtlAllocateHeap.
// Also, most of the routines in the module have a remarkably similar
// structure, and could probably be recoded using a common subroutine.
//
//-----------------------------------------------------------------------------
#include <ntifs.h>
#include <ntext.h>
#include "dfsmrshl.h"
#include "nodetype.h"
#include "libsup.h"
#include "upkt.h"
#include "dfsfsctl.h"
#include "fsctrl.h" // needed for FSCTL_DFS_PKT_FLUSH_CACHE
#define MAX_OUT_BUFFER_SIZE_RELINFO 0x1000
//+-------------------------------------------------------------------------
//
// Function: PktOpen, public
//
// Synopsis: Returns a handle to the Dfs PKT so operations can be made
// to it.
//
// Arguments:
//
// Returns: [STATUS_SUCCESS] -- Successfully opened the pkt.
//
// [STATUS_FS_DRIVER_REQUIRED] -- Dfs driver not loaded
//
//--------------------------------------------------------------------------
NTSTATUSPktOpen( IN OUT PHANDLE PktHandle, IN ACCESS_MASK DesiredAccess, IN ULONG ShareAccess, IN PUNICODE_STRING DfsNtPathName OPTIONAL){ NTSTATUS status; HANDLE dfsHandle;
status = DfsOpen(&dfsHandle, DfsNtPathName);
if(NT_SUCCESS(status)) {
*PktHandle = dfsHandle;
} else {
status = STATUS_FS_DRIVER_REQUIRED;
}
return status;}
//+-------------------------------------------------------------------------
//
// Function: PktClose, public
//
// Synopsis:
//
// Arguments:
//
// Returns: Nothing
//
//--------------------------------------------------------------------------
VOIDPktClose( IN HANDLE PktHandle){ NTSTATUS status = STATUS_SUCCESS;
if(NT_SUCCESS(status)) NtClose(PktHandle);}
//+-------------------------------------------------------------------------
//
// Function: PktCreateEntry, public
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//--------------------------------------------------------------------------
NTSTATUSPktCreateEntry( IN HANDLE PktHandle, IN ULONG EntryType, IN PDFS_PKT_ENTRY_ID EntryId, IN PDFS_PKT_ENTRY_INFO EntryInfo, IN ULONG CreateDisposition){ NTSTATUS status; DFS_PKT_CREATE_ENTRY_ARG arg; MARSHAL_BUFFER marshalBuffer; ULONG size;
arg.EntryType = EntryType; arg.EntryId = (*EntryId); arg.EntryInfo = (*EntryInfo); arg.CreateDisposition = CreateDisposition;
size = 0L; status = DfsRtlSize(&MiPktCreateEntryArg, &arg, &size); if(NT_SUCCESS(status)) {
PVOID buffer = malloc ( size );
if ( buffer == NULL ) return(STATUS_NO_MEMORY);
MarshalBufferInitialize(&marshalBuffer, size, buffer); status = DfsRtlPut( &marshalBuffer, &MiPktCreateEntryArg, &arg );
if(NT_SUCCESS(status)) {
status = DfsFsctl( PktHandle, FSCTL_DFS_PKT_CREATE_ENTRY, buffer, size, NULL, 0L ); } free(buffer); } return status;}
//+-------------------------------------------------------------------------
//
// Function: PktCreateSubordinateEntry, public
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//--------------------------------------------------------------------------
NTSTATUSPktCreateSubordinateEntry( IN HANDLE PktHandle, IN PDFS_PKT_ENTRY_ID SuperiorId, IN ULONG SubordinateType, IN PDFS_PKT_ENTRY_ID SubordinateId, IN PDFS_PKT_ENTRY_INFO SubordinateInfo OPTIONAL, IN ULONG CreateDisposition){ NTSTATUS status; DFS_PKT_CREATE_SUBORDINATE_ENTRY_ARG arg; MARSHAL_BUFFER marshalBuffer; ULONG size;
arg.EntryId = (*SuperiorId); arg.SubEntryType = SubordinateType; arg.SubEntryId = (*SubordinateId); arg.SubEntryInfo = (*SubordinateInfo); arg.CreateDisposition = CreateDisposition;
size = 0L; status = DfsRtlSize(&MiPktCreateSubordinateEntryArg, &arg, &size); if(NT_SUCCESS(status)) {
PVOID buffer = malloc ( size );
if ( buffer == NULL ) return(STATUS_NO_MEMORY);
MarshalBufferInitialize(&marshalBuffer, size, buffer); status = DfsRtlPut( &marshalBuffer, &MiPktCreateSubordinateEntryArg, &arg );
if(NT_SUCCESS(status)) {
status = DfsFsctl( PktHandle, FSCTL_DFS_PKT_CREATE_SUBORDINATE_ENTRY, buffer, size, NULL, 0L ); } free(buffer); } return status;}
//+-------------------------------------------------------------------------
//
// Function: PktDestroyEntry, public
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//--------------------------------------------------------------------------
NTSTATUSPktDestroyEntry( IN HANDLE PktHandle, IN DFS_PKT_ENTRY_ID victim){ NTSTATUS status; MARSHAL_BUFFER marshalBuffer; ULONG size;
size = 0L; status = DfsRtlSize(&MiPktEntryId, &victim, &size); if(NT_SUCCESS(status)) { PVOID buffer = malloc ( size );
if ( buffer == NULL ) return(STATUS_NO_MEMORY);
MarshalBufferInitialize(&marshalBuffer, size, buffer); status = DfsRtlPut( &marshalBuffer, &MiPktEntryId, &victim );
if(NT_SUCCESS(status)) {
status = DfsFsctl( PktHandle, FSCTL_DFS_PKT_DESTROY_ENTRY, buffer, size, NULL, 0L ); } free(buffer); } return status;}
//+-------------------------------------------------------------------------
//
// Function: PktGetRelationInfo, public
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// Notes: The relationalInfo structure should be made available
// by the caller but additional memory is allocated in here.
// The caller should deallocate all that memory himself.
//
//--------------------------------------------------------------------------
NTSTATUSPktGetRelationInfo( IN HANDLE PktHandle, IN PDFS_PKT_ENTRY_ID EntryId, IN OUT PDFS_PKT_RELATION_INFO RelationInfo){ NTSTATUS status; MARSHAL_BUFFER marshalBuffer; ULONG size; PVOID OutputBuffer;
size = 0L; status = DfsRtlSize(&MiPktEntryId, EntryId, &size); if(NT_SUCCESS(status)) { PVOID buffer = malloc ( size );
if ( buffer == NULL ) return(STATUS_NO_MEMORY);
MarshalBufferInitialize(&marshalBuffer, size, buffer); status = DfsRtlPut( &marshalBuffer, &MiPktEntryId, EntryId );
if(NT_SUCCESS(status)) {
// Do we want to retry with larger sizes?
OutputBuffer = malloc ( MAX_OUT_BUFFER_SIZE_RELINFO ); if ( OutputBuffer == NULL ) { status = STATUS_INSUFFICIENT_RESOURCES; } else {
status = DfsFsctl( PktHandle, FSCTL_DFS_PKT_GET_RELATION_INFO, buffer, size, OutputBuffer, MAX_OUT_BUFFER_SIZE_RELINFO);
//
// We can get rid of this right away.
//
if(NT_SUCCESS(status)) {
MarshalBufferInitialize( &marshalBuffer, MAX_OUT_BUFFER_SIZE_RELINFO, OutputBuffer );
status = DfsRtlGet( &marshalBuffer, &MiPktRelationInfo, RelationInfo ); }
free(OutputBuffer); } } free(buffer);
} //Status from DfsRtlSize
if (!NT_SUCCESS(status)) { RtlZeroMemory(RelationInfo, sizeof(DFS_PKT_RELATION_INFO)); }
return status;}
//+----------------------------------------------------------------------------
//
// Function: PktValidateLocalVolumeInfo, public
//
// Synopsis: Asks the Dfs driver to validate its local volume info with
// the one that is passed in.
//
// Arguments: [relationInfo] -- The DFS_PKT_RELATION_INFO to validate
// against.
//
// Returns: [STATUS_SUCCESS] -- Successfully validated local volume info
//
// [STATUS_REGISTRY_RECOVERED] -- Successfully validated info,
// but had to make changes to local info
//
// [DFS_STATUS_NOSUCH_LOCAL_VOLUME] -- The driver has no record
// of local volume described in relation info.
//
// [STATUS_UNSUCCESSFUL] -- Unable to fixup the local relation
// info. An appropriate message was logged to the
// local eventlog.
//
// [STATUS_DATA_ERROR] -- Passed in relationInfo is bogus.
//
// [STATUS_INSUFFICIENT_RESOURCES] -- Out of memory condition.
//
// [STATUS_FS_DRIVER_REQUIRED] -- Unable to open handle to the
// Dfs driver
//
//-----------------------------------------------------------------------------
NTSTATUSPktValidateLocalVolumeInfo( IN PDFS_PKT_RELATION_INFO relationInfo){ NTSTATUS status; HANDLE dfsHandle; MARSHAL_BUFFER marshalBuffer; PUCHAR pBuffer; ULONG cbBuffer;
status = DfsOpen(&dfsHandle, NULL);
if (NT_SUCCESS(status)) {
cbBuffer = 0;
status = DfsRtlSize( &MiPktRelationInfo, relationInfo, &cbBuffer );
if (NT_SUCCESS(status)) {
pBuffer = malloc( cbBuffer );
if (pBuffer != NULL) {
MarshalBufferInitialize(&marshalBuffer, cbBuffer, pBuffer);
status = DfsRtlPut( &marshalBuffer, &MiPktRelationInfo, relationInfo);
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
if (NT_SUCCESS(status)) {
status = DfsFsctl( dfsHandle, FSCTL_DFS_VERIFY_LOCAL_VOLUME_KNOWLEDGE, pBuffer, cbBuffer, NULL, 0);
}
if (pBuffer != NULL) free(pBuffer);
}
NtClose( dfsHandle );
}
return( status );
}
//+----------------------------------------------------------------------------
//
// Function: PktPruneLocalPartition
//
// Synopsis: Asks the Dfs Driver to get rid of a local volume that is
// not supposed to be supported by this server.
//
// Arguments: [EntryId] -- The entry id of the volume to prune.
//
// Returns: [STATUS_SUCCESS] -- Successfully pruned the volume
//
// [DFS_STATUS_NOSUCH_LOCAL_VOLUME] -- The driver has no record
// of local volume described in relation info.
//
// [STATUS_UNSUCCESSFUL] -- Unable to fixup the local relation
// info. An appropriate message was logged to the
// local eventlog.
//
// [STATUS_DATA_ERROR] -- Passed in relationInfo is bogus.
//
// [STATUS_INSUFFICIENT_RESOURCES] -- Out of memory condition.
//
// [STATUS_FS_DRIVER_REQUIRED] -- Unable to open handle to the
// Dfs driver
//
//-----------------------------------------------------------------------------
NTSTATUSPktPruneLocalPartition( IN PDFS_PKT_ENTRY_ID EntryId){ NTSTATUS status; HANDLE dfsHandle; MARSHAL_BUFFER marshalBuffer; PUCHAR pBuffer; ULONG cbBuffer;
status = DfsOpen(&dfsHandle, NULL);
if (NT_SUCCESS(status)) {
cbBuffer = 0;
status = DfsRtlSize( &MiPktEntryId, EntryId, &cbBuffer );
if (NT_SUCCESS(status)) {
pBuffer = malloc( cbBuffer );
if (pBuffer != NULL) {
MarshalBufferInitialize(&marshalBuffer, cbBuffer, pBuffer);
status = DfsRtlPut( &marshalBuffer, &MiPktEntryId, EntryId);
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
if (NT_SUCCESS(status)) {
status = DfsFsctl( dfsHandle, FSCTL_DFS_PRUNE_LOCAL_PARTITION, pBuffer, cbBuffer, NULL, 0);
}
if (pBuffer != NULL) free(pBuffer);
}
NtClose( dfsHandle );
}
return( status );}
//+----------------------------------------------------------------------------
//
// Function: PktIsChildnameLegal, public
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//-----------------------------------------------------------------------------
NTSTATUSPktIsChildnameLegal( IN PWCHAR pwszParent, IN PWCHAR pwszChild, IN GUID *pidChild){ HANDLE dfsHandle; NTSTATUS Status; DFS_PKT_ENTRY_ID idParent, idChild; MARSHAL_BUFFER marshalBuffer; PUCHAR pBuffer; ULONG cbBuffer;
RtlZeroMemory( &idParent, sizeof(DFS_PKT_ENTRY_ID) );
RtlZeroMemory( &idChild, sizeof(DFS_PKT_ENTRY_ID) );
RtlInitUnicodeString( &idParent.Prefix, pwszParent );
RtlInitUnicodeString( &idChild.Prefix, pwszChild );
idChild.Uid = *pidChild;
cbBuffer = 0;
Status = DfsOpen(&dfsHandle, NULL);
if (NT_SUCCESS(Status)) {
Status = DfsRtlSize( &MiPktEntryId, &idParent, &cbBuffer );
if (NT_SUCCESS(Status)) {
Status = DfsRtlSize( &MiPktEntryId, &idChild, &cbBuffer ); }
if (NT_SUCCESS(Status)) {
pBuffer = malloc( cbBuffer );
if (pBuffer != NULL) {
MarshalBufferInitialize( &marshalBuffer, cbBuffer, pBuffer );
Status = DfsRtlPut( &marshalBuffer, &MiPktEntryId, &idParent );
if (NT_SUCCESS(Status)) {
Status = DfsRtlPut( &marshalBuffer, &MiPktEntryId, &idChild );
}
if (NT_SUCCESS(Status)) {
Status = DfsFsctl( dfsHandle, FSCTL_DFS_IS_CHILDNAME_LEGAL, pBuffer, cbBuffer, NULL, 0L);
}
free( pBuffer );
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
NtClose( dfsHandle );
}
return( Status );
}
//+----------------------------------------------------------------------------
//
// Function: PktGetEntryType, public
//
// Synopsis: Given a prefix, this routine retrieves the entry type of the
// PktEntry
//
// Arguments: [pwszPrefix] -- The prefix whose PktEntry's type is required
// [pType] -- The type is returned here.
//
// Returns:
//
//-----------------------------------------------------------------------------
NTSTATUSPktGetEntryType( IN PWSTR pwszPrefix, IN PULONG pType){ HANDLE dfsHandle; NTSTATUS Status;
Status = DfsOpen(&dfsHandle, NULL);
if (NT_SUCCESS(Status)) {
Status = DfsFsctl( dfsHandle, FSCTL_DFS_GET_ENTRY_TYPE, pwszPrefix, wcslen(pwszPrefix) * sizeof(WCHAR), pType, sizeof(ULONG));
NtClose( dfsHandle );
}
return( Status );
}
//+----------------------------------------------------------------------------
//
// Function: DfsSetServiceState
//
// Synopsis: Sets the state of a service on a volume.
//
// Arguments: [VolumeId] -- The volume on which to operate
// [ServiceName] -- Name of service
// [State] -- Either 0 or DFS_SERVICE_TYPE_OFFLINE
//
// Returns: [STATUS_SUCCESS] -- The specified replica was set
// online/offline as speficied.
//
// [DFS_STATUS_NO_SUCH_ENTRY] -- The specified volume was not
// found, or the specified replica is not a server for
// the volume.
//
// [STATUS_DATA_ERROR] -- marshalling or unmarshalling error.
//
// [STATUS_INSUFFICIENT_RESOURCES] -- Out of memory situation.
//
// Status from opening handle to the Dfs driver.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsSetServiceState( IN PDFS_PKT_ENTRY_ID VolumeId, IN PWSTR ServiceName, IN ULONG State){ NTSTATUS status; HANDLE dfsHandle = NULL; DFS_DC_SET_SERVICE_STATE setSvcState; MARSHAL_BUFFER marshalBuffer; PUCHAR buffer = NULL; ULONG size;
status = DfsOpen( &dfsHandle, NULL );
if (NT_SUCCESS(status)) {
setSvcState.Id = *VolumeId; RtlInitUnicodeString( &setSvcState.ServiceName, ServiceName); setSvcState.State = State;
size = 0;
status = DfsRtlSize( &MiDCSetServiceState, &setSvcState, &size );
if (NT_SUCCESS(status)) {
buffer = (PUCHAR) malloc( size );
if (buffer == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (NT_SUCCESS(status)) {
MarshalBufferInitialize( &marshalBuffer, size, buffer );
status = DfsRtlPut( & marshalBuffer, &MiDCSetServiceState, &setSvcState );
}
if (NT_SUCCESS(status)) {
status = DfsFsctl( dfsHandle, FSCTL_DFS_SET_SERVICE_STATE, buffer, size, NULL, 0);
}
NtClose( dfsHandle );
if (buffer != NULL) {
free( buffer );
}
}
return( status );
}
//+----------------------------------------------------------------------------
//
// Function: DfsDCSetVolumeState
//
// Synopsis: Sets the state of a volume in the DCs. This will control
// whether referrals will be given out to this volume or not.
//
// Arguments: [VolumeId] -- The volume on which to operate
// [State] -- Either 0 or PKT_ENTRY_TYPE_OFFLINE
//
// Returns: [STATUS_SUCCESS] -- The specified replica was set
// online/offline as speficied.
//
// [DFS_STATUS_NO_SUCH_ENTRY] -- The specified volume was not
// found.
//
// [STATUS_DATA_ERROR] -- marshalling or unmarshalling error.
//
// [STATUS_INSUFFICIENT_RESOURCES] -- Out of memory situation.
//
// Status from opening handle to the Dfs driver.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsDCSetVolumeState( IN const PDFS_PKT_ENTRY_ID VolumeId, IN const ULONG State){ NTSTATUS status; HANDLE dfsHandle = NULL; DFS_SETSTATE_ARG setStateArg; MARSHAL_BUFFER marshalBuffer; PUCHAR buffer = NULL; ULONG size;
status = DfsOpen( &dfsHandle, NULL );
if (NT_SUCCESS(status)) {
setStateArg.Id = *VolumeId; setStateArg.Type = State;
size = 0;
status = DfsRtlSize( &MiSetStateArg, &setStateArg, &size );
if (NT_SUCCESS(status)) {
buffer = (PUCHAR) malloc( size );
if (buffer == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (NT_SUCCESS(status)) {
MarshalBufferInitialize( &marshalBuffer, size, buffer );
status = DfsRtlPut( & marshalBuffer, &MiSetStateArg, &setStateArg );
}
if (NT_SUCCESS(status)) {
status = DfsFsctl( dfsHandle, FSCTL_DFS_DC_SET_VOLUME_STATE, buffer, size, NULL, 0);
}
NtClose( dfsHandle );
if (buffer != NULL) {
free( buffer );
}
}
return( status );
}
//+----------------------------------------------------------------------------
//
// Function: DfsSetVolumeTimeout
//
// Synopsis: Sets the timeout of a volume in the DCs.
//
// Arguments: [VolumeId] -- The volume on which to operate
// [Timeout] -- Timeout, in seconds
//
// Returns: [STATUS_SUCCESS] -- The specified timeout was set as specified.
//
// [DFS_STATUS_NO_SUCH_ENTRY] -- The specified volume was not
// found.
//
// [STATUS_DATA_ERROR] -- marshalling or unmarshalling error.
//
// [STATUS_INSUFFICIENT_RESOURCES] -- Out of memory situation.
//
// Status from opening handle to the Dfs driver.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsSetVolumeTimeout( IN const PDFS_PKT_ENTRY_ID VolumeId, IN const ULONG Timeout){ NTSTATUS status; HANDLE dfsHandle = NULL; DFS_SET_VOLUME_TIMEOUT_ARG setVolTimeoutArg; MARSHAL_BUFFER marshalBuffer; PUCHAR buffer = NULL; ULONG size;
status = DfsOpen( &dfsHandle, NULL );
if (NT_SUCCESS(status)) {
setVolTimeoutArg.Id = *VolumeId; setVolTimeoutArg.Timeout = Timeout;
size = 0;
status = DfsRtlSize( &MiSetVolTimeoutArg, &setVolTimeoutArg, &size );
if (NT_SUCCESS(status)) {
buffer = (PUCHAR) malloc( size );
if (buffer == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
if (NT_SUCCESS(status)) {
MarshalBufferInitialize( &marshalBuffer, size, buffer );
status = DfsRtlPut( & marshalBuffer, &MiSetVolTimeoutArg, &setVolTimeoutArg );
}
if (NT_SUCCESS(status)) {
status = DfsFsctl( dfsHandle, FSCTL_DFS_SET_VOLUME_TIMEOUT, buffer, size, NULL, 0);
}
NtClose( dfsHandle );
if (buffer != NULL) {
free( buffer );
}
}
return( status );
}
//+----------------------------------------------------------------------------
//
// Function: DfsCreateSiteEntry
//
// Synopsis: Loads a Site entry into the dfs site table
//
// Arguments: [pInfoArg] -- DFS_CREATE_SITE_INFO_ARG with info to update
//
// Returns: Status from opening handle to the Dfs driver.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsCreateSiteEntry( PCHAR arg, ULONG size){ NTSTATUS status; HANDLE dfsHandle = NULL;
status = DfsOpen( &dfsHandle, NULL );
if (NT_SUCCESS(status)) {
status = DfsFsctl( dfsHandle, FSCTL_DFS_CREATE_SITE_INFO, arg, size, NULL, 0);
NtClose( dfsHandle );
}
return( status );}
//+----------------------------------------------------------------------------
//
// Function: DfsDeleteSiteEntry
//
// Synopsis: Loads a Site entry into the dfs site table
//
// Arguments: [pInfoArg] -- DFS_DELETE_SITE_INFO_ARG with info to update
//
// Returns: Status from opening handle to the Dfs driver.
//
//-----------------------------------------------------------------------------
NTSTATUSDfsDeleteSiteEntry( PCHAR arg, ULONG size){ NTSTATUS status; HANDLE dfsHandle = NULL;
status = DfsOpen( &dfsHandle, NULL );
if (NT_SUCCESS(status)) {
status = DfsFsctl( dfsHandle, FSCTL_DFS_DELETE_SITE_INFO, arg, size, NULL, 0);
NtClose( dfsHandle );
}
return( status );}
|
