|
|
/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
create4.c
Abstract:
This implements the NDS create routines.
Author:
Cory West [CoryWest] 23-Feb-1995
--*/
#include "Procs.h"
#define Dbg (DEBUG_TRACE_NDS)
//
// Pageable.
//
#pragma alloc_text( PAGE, NdsCreateTreeScb )
#pragma alloc_text( PAGE, ConnectBinderyVolume )
#pragma alloc_text( PAGE, HandleVolumeAttach )
#pragma alloc_text( PAGE, NdsGetDsObjectFromPath )
#pragma alloc_text( PAGE, NdsVerifyObject )
#pragma alloc_text( PAGE, NdsVerifyContext )
#pragma alloc_text( PAGE, NdsMapObjectToServerShare )
//
// Not page-able:
//
// NdsSelectConnection (holds a spin lock)
//
NTSTATUSNdsSelectConnection( PIRP_CONTEXT pIrpContext, PUNICODE_STRING puTreeName, PUNICODE_STRING puUserName, PUNICODE_STRING puPassword, BOOL DeferredLogon, BOOL UseBinderyConnections, PNONPAGED_SCB *ppNpScb)/*++
Routine Description:
Find a nearby tree connection point for the given tree.
DeferredLogon tells us whether or not we need to initiate a login/authenticate exchange yet. If we have credentials to a tree, we are NOT allowed to hand off a connection that has not been logged in because the view of the tree may be different from what it is supposed to be.
UseBinderyConnections tells us whether or not we want to return bindery authenticated connections as valid nds browse points.
Return Value:
Scb to a server that belongs to the tree we want.
--*/{
NTSTATUS Status = STATUS_BAD_NETWORK_PATH;
PLOGON pLogon; PLIST_ENTRY ScbQueueEntry; KIRQL OldIrql;
PNONPAGED_SCB pFirstNpScb, pNextNpScb; PNONPAGED_SCB pFoundNpScb = NULL; PSCB pScb; LARGE_INTEGER Uid;
PNONPAGED_SCB pOriginalNpScb; PSCB pOriginalScb;
PNDS_SECURITY_CONTEXT pNdsContext; SECURITY_SUBJECT_CONTEXT SubjectContext; BOOL PasswordExpired = FALSE;
//
// Save the original server pointers.
//
pOriginalNpScb = pIrpContext->pNpScb; pOriginalScb = pIrpContext->pScb;
Uid = pIrpContext->Specific.Create.UserUid;
//
// Determine if we need a guest browse connection.
//
if ( DeferredLogon ) {
NwAcquireExclusiveRcb( &NwRcb, TRUE ); pLogon = FindUser( &Uid, FALSE ); NwReleaseRcb( &NwRcb );
if ( pLogon ) {
Status = NdsLookupCredentials( pIrpContext, puTreeName, pLogon, &pNdsContext, CREDENTIAL_READ, FALSE );
if ( NT_SUCCESS( Status ) ) {
if ( ( pNdsContext->Credential != NULL ) && ( pNdsContext->CredentialLocked == FALSE ) ) {
DebugTrace( 0, Dbg, "Forcing authenticated browse to %wZ.\n", puTreeName ); DeferredLogon = FALSE; }
NwReleaseCredList( pLogon, pIrpContext ); } } }
//
// Start at the head of the SCB list.
//
KeAcquireSpinLock(&ScbSpinLock, &OldIrql);
if ( ScbQueue.Flink == &ScbQueue ) { KeReleaseSpinLock( &ScbSpinLock, OldIrql); return STATUS_BAD_NETWORK_PATH; }
ScbQueueEntry = ScbQueue.Flink; pFirstNpScb = CONTAINING_RECORD( ScbQueueEntry, NONPAGED_SCB, ScbLinks ); pNextNpScb = pFirstNpScb;
//
// Leave the first SCB referenced since we need it to
// be there for when we walk all the way around the list.
//
NwReferenceScb( pFirstNpScb ); NwReferenceScb( pNextNpScb );
KeReleaseSpinLock( &ScbSpinLock, OldIrql);
while ( TRUE ) {
//
// Check to see if the SCB we have is in the correct tree
// and is usable. Make sure we skip over the permanent
// npscb since it isn't a tree connection. The current
// SCB is always referenced while we're in here.
//
if ( pNextNpScb->pScb ) {
pScb = pNextNpScb->pScb;
if ( RtlEqualUnicodeString( puTreeName, &pScb->NdsTreeName, TRUE ) && Uid.QuadPart == pScb->UserUid.QuadPart ) {
pIrpContext->pNpScb = pNextNpScb; pIrpContext->pScb = pNextNpScb->pScb; NwAppendToQueueAndWait( pIrpContext );
switch ( pNextNpScb->State ) {
case SCB_STATE_RECONNECT_REQUIRED:
//
// Reconnect to the server. This is not
// a valid path for an anonymous create,
// so there's no chance that we'll get
// a name collision.
//
Status = ConnectToServer( pIrpContext, NULL );
if (!NT_SUCCESS(Status)) { break; }
pNextNpScb->State = SCB_STATE_LOGIN_REQUIRED;
case SCB_STATE_LOGIN_REQUIRED:
//
// See if we can login if requested.
//
if ( !DeferredLogon ) {
Status = DoNdsLogon( pIrpContext, puUserName, puPassword );
if ( !NT_SUCCESS( Status ) ) { break; }
//
// If we get a warning from this, we need to return it!
//
if ( Status == NWRDR_PASSWORD_HAS_EXPIRED ) { PasswordExpired = TRUE; }
//
// Do we have to re-license the connection?
//
if ( ( pScb->VcbCount > 0 ) || ( pScb->OpenNdsStreams > 0 ) ) {
Status = NdsLicenseConnection( pIrpContext );
if ( !NT_SUCCESS( Status ) ) { Status = STATUS_REMOTE_SESSION_LIMIT; break; } }
pNextNpScb->State = SCB_STATE_IN_USE; }
case SCB_STATE_IN_USE:
if ( pNextNpScb->State == SCB_STATE_IN_USE ) {
if ( ( !UseBinderyConnections ) && ( pNextNpScb->pScb->UserName.Length != 0 ) ) {
//
// We may not want to use a connection that has been
// bindery authenticated to read the NDS tree because
// we don't have a way to validate that the NDS and
// bindery users are the same.
//
Status = STATUS_ACCESS_DENIED; break; }
//
// Verify that we have security rights to this server.
//
Status = CheckScbSecurity( pIrpContext, pNextNpScb->pScb, puUserName, puPassword, ( BOOLEAN )DeferredLogon );
if ( !NT_SUCCESS( Status ) ) { break; }
//
// Check SCB security might return with state login required.
//
if ( ( pNextNpScb->State == SCB_STATE_LOGIN_REQUIRED ) && ( !DeferredLogon ) ) {
Status = DoNdsLogon( pIrpContext, puUserName, puPassword );
if ( !NT_SUCCESS( Status ) ) { break; }
pNextNpScb->State = SCB_STATE_IN_USE; }
} else {
//
// If we picked up an already good SCB and the
// login was deferred, set success and continue.
//
ASSERT( DeferredLogon == TRUE ); Status = STATUS_SUCCESS; }
pFoundNpScb = pNextNpScb; DebugTrace( 0, Dbg, "NdsSelectConnection: NpScb = %lx\n", pFoundNpScb ); break;
default:
break;
}
NwDequeueIrpContext( pIrpContext, FALSE );
if ( pFoundNpScb ) { ASSERT( NT_SUCCESS( Status ) ); break; }
if ( Status == STATUS_WRONG_PASSWORD || Status == STATUS_NO_SUCH_USER ) { NwDereferenceScb( pNextNpScb ); break; }
//
// Restore the server pointers.
//
pIrpContext->pNpScb = pOriginalNpScb; pIrpContext->pScb = pOriginalScb;
} }
//
// Otherwise, get the next one in the list. Don't
// forget to skip the list head.
//
KeAcquireSpinLock( &ScbSpinLock, &OldIrql );
ScbQueueEntry = pNextNpScb->ScbLinks.Flink;
if ( ScbQueueEntry == &ScbQueue ) { ScbQueueEntry = ScbQueue.Flink; }
NwDereferenceScb( pNextNpScb ); pNextNpScb = CONTAINING_RECORD( ScbQueueEntry, NONPAGED_SCB, ScbLinks );
if ( pNextNpScb == pFirstNpScb ) {
KeReleaseSpinLock( &ScbSpinLock, OldIrql ); Status = STATUS_BAD_NETWORK_PATH; break; }
//
// Otherwise, reference this SCB and continue.
//
NwReferenceScb( pNextNpScb ); KeReleaseSpinLock( &ScbSpinLock, OldIrql );
}
NwDereferenceScb( pFirstNpScb ); *ppNpScb = pFoundNpScb;
if ( ( NT_SUCCESS( Status ) ) && ( PasswordExpired ) ) { Status = NWRDR_PASSWORD_HAS_EXPIRED; }
return Status;}
NTSTATUSNdsCreateTreeScb( IN PIRP_CONTEXT pIrpContext, IN OUT PSCB *ppScb, IN PUNICODE_STRING puTree, IN PUNICODE_STRING puUserName, IN PUNICODE_STRING puPassword, IN BOOLEAN DeferredLogon, IN BOOLEAN DeleteOnClose)/*++
Description:
Given a tree name, find us a connection point to the tree. This is done by getting the server addresses out of the bindery and looking up the names of the servers for those addresses.
When we are all done we need to return the preferred connection point in ppScb.
Arguments:
pIrpContext - irp context for this request ppScb - pointer to a pointer to the scb that we want puTree - tree we want to talk to
--*/{
NTSTATUS Status;
PLARGE_INTEGER pUid; PNONPAGED_SCB pNpExistingScb;
UNICODE_STRING UidServerName; PSCB pTreeScb = NULL;
PSCB pNearestTreeScb = NULL; PNONPAGED_SCB pNpNearestTreeScb = NULL;
PSCB pNearbyScb = NULL; BOOLEAN fOnNearbyQueue = FALSE; PIRP_CONTEXT pExtraIrpContext = NULL;
UNICODE_STRING ScanTreeName; WCHAR ScanBuffer[NDS_TREE_NAME_LEN + 2]; int i;
IPXaddress DirServerAddress; CHAR DirServerName[MAX_SERVER_NAME_LENGTH]; ULONG dwLastOid = (ULONG)-1;
UNICODE_STRING CredentialName; PUNICODE_STRING puConnectName;
PAGED_CODE();
UidServerName.Buffer = NULL;
//
// Make sure the tree name is reasonable, first.
//
if ( ( !puTree ) || ( !puTree->Length ) || ( puTree->Length / sizeof( WCHAR ) ) > NDS_TREE_NAME_LEN ) {
*ppScb = NULL; //***Terminal Server Merge
return STATUS_INVALID_PARAMETER; }
//
// If this is an extended credential create, munge the name.
//
RtlInitUnicodeString( &CredentialName, NULL );
if ( ( pIrpContext->Specific.Create.fExCredentialCreate ) && ( !IsCredentialName( puTree ) ) ) {
Status = BuildExCredentialServerName( puTree, puUserName, &CredentialName );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
puConnectName = &CredentialName;
} else {
puConnectName = puTree; }
//
// First check to see if we already have a connection
// to this tree that we can use... If so, this will
// leave the irp context pointed at that server for us.
//
// This time around, don't use bindery authenticated
// connections to browse the tree.
//
Status = NdsSelectConnection( pIrpContext, puConnectName, puUserName, puPassword, DeferredLogon, FALSE, &pNpExistingScb );
if ( NT_SUCCESS( Status ) && pNpExistingScb ) { *ppScb = pNpExistingScb->pScb; ASSERT( *ppScb != NULL ); ASSERT( NT_SUCCESS( Status ) ); goto ExitWithCleanup; }
//
// If there was an authentication failure, bail out.
//
if ( Status == STATUS_NO_SUCH_USER || Status == STATUS_WRONG_PASSWORD ) { goto ExitWithCleanup; *ppScb = NULL; //Terminal Server code merge
}
//
// Otherwise, we need to select a dir server. To do this,
// we have to look up dir server names by address. To do
// this we create an SCB for synchronization with the name
// *tree*, which isn't a valid server name.
//
ScanTreeName.Length = sizeof( WCHAR ); ScanTreeName.MaximumLength = sizeof( ScanBuffer ); ScanTreeName.Buffer = ScanBuffer;
ScanBuffer[0] = L'*'; RtlAppendUnicodeStringToString( &ScanTreeName, puTree ); ScanBuffer[( ScanTreeName.Length / sizeof( WCHAR ) )] = L'*'; ScanTreeName.Length += sizeof( WCHAR );
//
// Now make it a uid server name.
//
Status = MakeUidServer( &UidServerName, &pIrpContext->Specific.Create.UserUid, &ScanTreeName );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
NwFindScb( &pTreeScb, pIrpContext, &UidServerName, &ScanTreeName );
if ( !pTreeScb ) { DebugTrace( 0, Dbg, "Failed to get a tree scb for synchronization.\n", 0 ); goto ExitWithCleanup; }
//
// Get a nearby server connection and prepare to
// do the bindery scan for tree connection points.
// Don't forget to copy the user uid for security.
//
if ( !NwAllocateExtraIrpContext( &pExtraIrpContext, pTreeScb->pNpScb ) ) {
Status = STATUS_INSUFFICIENT_RESOURCES; goto ExitWithCleanup;
}
pExtraIrpContext->Specific.Create.UserUid.QuadPart = pIrpContext->Specific.Create.UserUid.QuadPart;
//
// Append a wildcard to the tree name for the bindery scan.
//
ScanTreeName.Length = 0; ScanTreeName.MaximumLength = sizeof( ScanBuffer ); ScanTreeName.Buffer = ScanBuffer;
RtlCopyUnicodeString( &ScanTreeName, puTree );
i = ScanTreeName.Length / sizeof( WCHAR );
while( i <= NDS_TREE_NAME_LEN ) { ScanBuffer[i++] = L'_'; }
ScanBuffer[NDS_TREE_NAME_LEN] = L'*'; ScanTreeName.Length = (NDS_TREE_NAME_LEN + 1) * sizeof( WCHAR );
DebugTrace( 0, Dbg, "Scanning for NDS tree %wZ.\n", puTree );
//
// Now we lookup the dir server addresses in the bindery and
// try to make dir server connections.
//
while ( TRUE ) {
if ( ( pNearbyScb ) && ( !fOnNearbyQueue ) ) {
//
// Get back to the head of the nearby server so we can continue
// looking for dir servers. If the nearby server is no good anymore,
// dereference the connection and set the nearby scb pointer to
// NULL. This will cause us to get a new nearby server when we
// continue.
//
NwAppendToQueueAndWait( pExtraIrpContext );
if ( !( ( pNearbyScb->pNpScb->State == SCB_STATE_LOGIN_REQUIRED ) || ( pNearbyScb->pNpScb->State == SCB_STATE_IN_USE ) ) ) {
NwDequeueIrpContext( pExtraIrpContext, FALSE ); NwDereferenceScb( pNearbyScb->pNpScb ); pNearbyScb = NULL;
//
// Don't restart the search. If our bindery server went down in
// the middle of a connect, the connect will fail and that's ok.
// If we restart the search we can end up in this loop forever.
//
} else {
fOnNearbyQueue = TRUE; }
}
//
// Get a bindery server to talk to if we don't have one. This may
// be our first time through this loop, or our server may have
// gone bad (see above).
//
// Optimization: What if this CreateScb returns a valid dir server
// for the tree we are looking for? We should use it!!
//
if ( !pNearbyScb ) { Status = CreateScb( &pNearbyScb, pExtraIrpContext, NULL, NULL, NULL, NULL, TRUE, FALSE );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
ASSERT( pExtraIrpContext->pNpScb == pNearbyScb->pNpScb ); ASSERT( pExtraIrpContext->pScb == pNearbyScb );
NwAppendToQueueAndWait( pExtraIrpContext ); fOnNearbyQueue = TRUE;
}
//
// Look up the dir server address from our nearby server.
//
Status = ExchangeWithWait( pExtraIrpContext, SynchronousResponseCallback, "SdwU", NCP_ADMIN_FUNCTION, NCP_SCAN_BINDERY_OBJECT, dwLastOid, OT_DIRSERVER, &ScanTreeName );
if ( !NT_SUCCESS( Status ) ) {
//
// We're out of options for dir servers.
//
Status = STATUS_BAD_NETWORK_PATH; break; }
Status = ParseResponse( pExtraIrpContext, pExtraIrpContext->rsp, pExtraIrpContext->ResponseLength, "Nd_r", &dwLastOid, sizeof( WORD ), DirServerName, MAX_SERVER_NAME_LENGTH );
if ( !NT_SUCCESS( Status ) ) { break; }
Status = ExchangeWithWait ( pExtraIrpContext, SynchronousResponseCallback, "Swbrbp", NCP_ADMIN_FUNCTION, NCP_QUERY_PROPERTY_VALUE, OT_DIRSERVER, 0x30, DirServerName, MAX_SERVER_NAME_LENGTH, 1, // Segment number
NET_ADDRESS_PROPERTY );
if ( !NT_SUCCESS( Status ) ) {
DebugTrace( 0, Dbg, "No net address property for this dir server.\n", 0 ); continue; }
Status = ParseResponse( pExtraIrpContext, pExtraIrpContext->rsp, pExtraIrpContext->ResponseLength, "Nr", &DirServerAddress, sizeof(TDI_ADDRESS_IPX) );
if ( !NT_SUCCESS( Status ) ) {
DebugTrace( 0, Dbg, "Couldn't parse net address property for this dir server.\n", 0 ); continue; }
//
// We get back some odd socket number here, but we really want to
// connect to the NCP socket.
//
DirServerAddress.Socket = NCP_SOCKET;
//
// We know the address of the dir server, so do an anonymous
// create to it. Use the original irp context so the uid is
// correct. Note that we have to dequeue from the nearby scb
// in case we are referred to that server!
//
NwDequeueIrpContext( pExtraIrpContext, FALSE ); fOnNearbyQueue = FALSE;
NwDequeueIrpContext( pIrpContext, FALSE );
Status = CreateScb( &pNearestTreeScb, pIrpContext, NULL, &DirServerAddress, puUserName, puPassword, DeferredLogon, DeleteOnClose );
if ( !NT_SUCCESS( Status ) ) {
if ( Status == STATUS_NO_SUCH_USER || Status == STATUS_WRONG_PASSWORD || Status == STATUS_ACCESS_DENIED || Status == STATUS_ACCOUNT_DISABLED || Status == STATUS_LOGIN_TIME_RESTRICTION || Status == STATUS_REMOTE_SESSION_LIMIT || Status == STATUS_CONNECTION_COUNT_LIMIT || Status == STATUS_NETWORK_CREDENTIAL_CONFLICT || Status == STATUS_PASSWORD_EXPIRED ) { break; }
continue; }
//
// If the server we got back was bindery authenticated,
// it is NOT a valid dir server for us to use (yet)!!
//
if ( pNearestTreeScb->UserName.Length != 0 ) {
Status = STATUS_ACCESS_DENIED; NwDequeueIrpContext( pIrpContext, FALSE ); NwDereferenceScb( pNearestTreeScb->pNpScb );
continue; }
//
// Otherwise, we're golden. Break out of here!
//
DebugTrace( 0, Dbg, "Dir server: %wZ\n", &pNearestTreeScb->UidServerName ); *ppScb = pNearestTreeScb; ASSERT( NT_SUCCESS( Status ) ); break;
} //
// We have been wholly unable to get a browse connection
// to this tree. Try again but this time allow the use
// of connections that are bindery authenticated. We don't
// need the nearby server anymore.
//
if ( pNearbyScb ) {
NwDequeueIrpContext( pExtraIrpContext, FALSE ); NwDereferenceScb( pNearbyScb->pNpScb ); }
if ( ( Status != STATUS_SUCCESS ) && ( Status != STATUS_NO_SUCH_USER ) && ( Status != STATUS_WRONG_PASSWORD ) && ( Status != STATUS_ACCESS_DENIED ) && ( Status != STATUS_ACCOUNT_DISABLED ) && ( Status != STATUS_LOGIN_TIME_RESTRICTION ) && ( Status != STATUS_REMOTE_SESSION_LIMIT ) && ( Status != STATUS_CONNECTION_COUNT_LIMIT ) && ( Status != STATUS_NETWORK_CREDENTIAL_CONFLICT ) && ( Status != STATUS_PASSWORD_EXPIRED ) ) {
Status = NdsSelectConnection( pIrpContext, puConnectName, puUserName, puPassword, DeferredLogon, TRUE, &pNpExistingScb );
if ( NT_SUCCESS( Status ) && pNpExistingScb ) { *ppScb = pNpExistingScb->pScb; ASSERT( *ppScb != NULL ); } }
ExitWithCleanup:
//
// Clean up and bail.
//
if ( pExtraIrpContext ) { NwFreeExtraIrpContext( pExtraIrpContext ); }
if ( UidServerName.Buffer != NULL ) { FREE_POOL( UidServerName.Buffer ); }
if ( pTreeScb ) { NwDereferenceScb( pTreeScb->pNpScb ); }
if ( CredentialName.Buffer ) { FREE_POOL( CredentialName.Buffer ); }
if (!NT_SUCCESS(Status)) { *ppScb = NULL; }
return Status;
}
NTSTATUSConnectBinderyVolume( PIRP_CONTEXT pIrpContext, PUNICODE_STRING puServerName, PUNICODE_STRING puVolumeName)/*++
Description:
Given a server name and a volume, try to connect the volume. This is used in QueryPath to pre-connect a volume.
--*/{
NTSTATUS Status; PSCB pScb; PVCB pVcb;
PAGED_CODE();
//
// Try making a server connection with this name.
//
Status = CreateScb( &pScb, pIrpContext, puServerName, NULL, NULL, NULL, FALSE, FALSE );
if ( !NT_SUCCESS( Status ) ) { return Status; }
DebugTrace( 0, Dbg, "Bindery volume connect got server %wZ\n", puServerName );
//
// If we succeeded, do a standard bindery volume attach.
//
NwAppendToQueueAndWait( pIrpContext ); NwAcquireOpenLock( );
try {
pVcb = NwFindVcb( pIrpContext, puVolumeName, RESOURCETYPE_ANY, 0, FALSE, FALSE );
} finally {
NwReleaseOpenLock( );
}
if ( pVcb == NULL ) {
Status = STATUS_BAD_NETWORK_PATH;
} else {
//
// We should not have jumped servers since this was explicit.
//
ASSERT( pScb == pIrpContext->pScb );
//
// Remove NwFindVcb reference. Don't supply an IrpContext
// so the Vcb doesn't get destroyed immediately after we just
// created it because no-one else has it referenced.
//
NwDereferenceVcb( pVcb, NULL, FALSE ); DebugTrace( 0, Dbg, "Bindery volume connect got volume %wZ\n", puVolumeName ); }
NwDequeueIrpContext( pIrpContext, FALSE ); NwDereferenceScb( pIrpContext->pNpScb ); return Status;
}
NTSTATUSHandleVolumeAttach( PIRP_CONTEXT pIrpContext, PUNICODE_STRING puServerName, PUNICODE_STRING puVolumeName)/*++
Description:
This function is only callable from the QUERY_PATH code path!
This functions takes a server name and volume name from QueryPath() and resolves it into a server/volume connection. The server/volume name can be plain or can refer to an nds tree and the nds path to a volume object.
In the nds case, we only verify that the volume object exists.
Arguments:
pIrpContext - irp context for this request puServerName - server name or nds tree name puVolumeName - volume name or nds path to volume object
--*/{
NTSTATUS Status; PSCB pScb;
UNICODE_STRING uDsObject; DWORD dwVolumeOid, dwObjectType;
PAGED_CODE();
//
// Try the bindery server/volume case first.
//
Status = ConnectBinderyVolume( pIrpContext, puServerName, puVolumeName ); if ( NT_SUCCESS( Status ) ) { return Status; }
if ( Status == STATUS_NETWORK_UNREACHABLE ) {
// IPX is not bound to anything that is currently
// up (which means it's probably bound only to the
// RAS WAN wrapper). Don't waste time looking for
// a ds tree.
//
return STATUS_BAD_NETWORK_PATH; }
//
// See if this is a tree name and get a ds connection.
//
pIrpContext->Specific.Create.NdsCreate = TRUE;
Status = NdsCreateTreeScb( pIrpContext, &pScb, puServerName, NULL, NULL, TRUE, FALSE );
if ( !NT_SUCCESS( Status ) ) { return Status; }
//
// If we have a tree, resolve the volume object.
// TRACKING: We should actually check to see if we
// already have a connection to this object before
// we hit the ds.
//
Status = NdsGetDsObjectFromPath( pIrpContext, &uDsObject );
if ( !NT_SUCCESS( Status ) ) { NwDereferenceScb( pIrpContext->pNpScb ); return Status; }
Status = NdsVerifyObject( pIrpContext, // irp context for the request
&uDsObject, // path to volume object
TRUE, // allow a server jump
DEFAULT_RESOLVE_FLAGS, // resolver flags
&dwVolumeOid, // volume oid from the ds
&dwObjectType ); // volume or print queue
//
// We may have jumped servers in the VerifyObject code,
// so just make sure we dereference the correct server.
//
NwDereferenceScb( pIrpContext->pNpScb ); return Status;
}
NTSTATUSNdsGetDsObjectFromPath( IN PIRP_CONTEXT pIrpContext, OUT PUNICODE_STRING puDsObject)/*++
Description:
Take the full path from the create irp context and extract out the ds path of the desired object.
The supplied unicode string shouldn't have a buffer; it will be set up to point into the user's buffer referred to by the irp context.
Arguments:
pIrpContext - an irp context from a create path request puDsObject - unicode string that will refer to the correct ds path
--*/{
DWORD dwPathSeparators; USHORT NewHead;
PAGED_CODE();
//
// The VolumeName is one of the following:
//
// \X:\Server\Volume.Object.Path
// \Server\Volume.Object.Path
//
*puDsObject = pIrpContext->Specific.Create.VolumeName;
//
// Skip the leading slash.
//
puDsObject->Length -= sizeof( WCHAR ); puDsObject->Buffer += 1;
//
// How many more are there to overcome?
//
NewHead = 0; dwPathSeparators = pIrpContext->Specific.Create.DriveLetter ? 2 : 1;
while ( NewHead < puDsObject->Length && dwPathSeparators ) {
if ( puDsObject->Buffer[NewHead/sizeof(WCHAR)] == OBJ_NAME_PATH_SEPARATOR ) { dwPathSeparators--; }
NewHead += sizeof( WCHAR ); }
if ( dwPathSeparators || NewHead == puDsObject->Length) {
//
// Something wasn't formed right in the volume name.
//
return STATUS_BAD_NETWORK_PATH; }
puDsObject->Length -= NewHead; puDsObject->Buffer += NewHead/sizeof(WCHAR);
//
// If there is a leading dot, skip it.
//
if ( puDsObject->Buffer[0] == L'.' ) {
puDsObject->Length -= sizeof( WCHAR ); puDsObject->Buffer += 1; }
puDsObject->MaximumLength = puDsObject->Length;
DebugTrace( 0, Dbg, "DS object: %wZ\n", puDsObject );
return STATUS_SUCCESS;}
NTSTATUSNdsVerifyObject( IN PIRP_CONTEXT pIrpContext, IN PUNICODE_STRING puDsObject, IN BOOLEAN fAllowServerJump, IN DWORD dwResolverFlags, OUT PDWORD pdwDsOid, OUT PDWORD pdwObjectType)/*++
Description:
This function verifies that a ds path refers to a volume object, print queue, or a dir map. It returns the oid of the object.
If fAllowServerJump is set to false, this simply looks up the oid on the current server but doesn't verify the object type. This routine checks all appropriate contexts for the object, unlike ResolveNameKm.
Parameters:
pIrpContext - irp context for this request, pointed to the ds server puDsObject - path to the object in the ds fAllowServerJump - allow a server jump to take place pdwDsOid - destination of the ds oid of the object pdwObjectType - NDS_OBJECTTYPE_VOLUME, NDS_OBJECTTYPE_QUEUE, or NDS_OBJECTTYPE_DIRMAP
--*/{
NTSTATUS Status;
PNDS_SECURITY_CONTEXT pCredentials = NULL; PUNICODE_STRING puAppendableContext;
UNICODE_STRING uFdnObject; WCHAR FdnObject[MAX_NDS_NAME_CHARS];
PLOGON pLogon; PSCB pScb; USHORT i;
LOCKED_BUFFER NdsRequest; DWORD dwObjectOid, dwObjectType;
UNICODE_STRING uVolume; UNICODE_STRING uQueue; UNICODE_STRING uDirMap;
UNICODE_STRING uReplyString; WCHAR ReplyBuffer[32]; BOOLEAN fHoldingCredentialList = FALSE; BOOLEAN fPartiallyDistinguished = FALSE;
PLIST_ENTRY ListHead; PLIST_ENTRY Entry; PNDS_OBJECT_CACHE_ENTRY ObjectEntry = NULL; LARGE_INTEGER CurrentTick; BOOLEAN UseEntry = FALSE; BOOLEAN ObjectCacheLocked = FALSE;
PAGED_CODE();
NdsRequest.pRecvBufferVa = NULL;
//
// Get the user credentials.
//
pScb = pIrpContext->pNpScb->pScb;
NwAcquireExclusiveRcb( &NwRcb, TRUE ); pLogon = FindUser( &pScb->UserUid, FALSE ); NwReleaseRcb( &NwRcb );
//
// Get the credential. We don't care if it's locked or
// not since we're just querying the ds.
//
// Also, get to the head of the queue before you grab
// the credentials and call NdsResolveNameKm
//
NwAppendToQueueAndWait ( pIrpContext );
if ( pLogon ) {
Status = NdsLookupCredentials( pIrpContext, &pScb->NdsTreeName, pLogon, &pCredentials, CREDENTIAL_READ, FALSE );
if ( NT_SUCCESS( Status ) ) { ASSERT( pCredentials != NULL ); fHoldingCredentialList = TRUE; }
}
//
// Check to see if we have already seen this request.
// If the ObjectCacheBuffer is NULL, then there is no cache
// for this SCB.
//
if( pScb->ObjectCacheBuffer != NULL ) {
//
// Acquire the cache lock so that the cache can be messed with.
// This wait should never fail, but if it does, act as if there
// is no cache for this SCB. The lock is released before returning
// from this function.
//
Status = KeWaitForSingleObject( &(pScb->ObjectCacheLock), Executive, KernelMode, FALSE, NULL );
if( NT_SUCCESS(Status) ) {
//
// Reference this SCB so it cannot go away, and
// remember it is locked and referenced.
//
NwReferenceScb( pScb->pNpScb ); ObjectCacheLocked = TRUE;
//
// Walk the cache looking for a match.
//
ListHead = &(pScb->ObjectCacheList); Entry = ListHead->Flink;
while( Entry != ListHead ) {
ObjectEntry = CONTAINING_RECORD( Entry, NDS_OBJECT_CACHE_ENTRY, Links );
//
// Three things are checked; the object name, the AllowServerJump flag,
// and the Resolver flags. If these all match, then this exact request has
// been seen before and the results are already known. If any one of these
// does not match, then the request is different.
//
if( RtlEqualUnicodeString( puDsObject, &(ObjectEntry->ObjectName), TRUE ) && fAllowServerJump == ObjectEntry->AllowServerJump && dwResolverFlags == ObjectEntry->ResolverFlags ) {
//
// A match was found, but the timeout and SCB must be looked at to
// see if this entry needs to be refreshed.
//
KeQueryTickCount( &CurrentTick );
if( ObjectEntry->Scb != NULL && CurrentTick.QuadPart < ObjectEntry->Timeout.QuadPart ) {
UseEntry = TRUE; }
//
// If an entry was found, exit the loop. This needs to
// happen regardless of whether the data in the entry is
// valid. If the data is not valid, then it will be update
// in the code below.
//
break; }
Entry = Entry->Flink; }
if( Entry == ListHead ) {
//
// No entry was found. Reuse the oldest entry in the cache.
//
Entry = ListHead->Blink; ObjectEntry = CONTAINING_RECORD( Entry, NDS_OBJECT_CACHE_ENTRY, Links );
} else if( UseEntry == TRUE ) {
//
// An entry was found and its data is up to date.
// Just return the data in the cache and save network bandwidth.
//
dwObjectOid = ObjectEntry->DsOid; dwObjectType = ObjectEntry->ObjectType;
//
// If needed, simulate a server jump by changing the SCB in the IRP_CONTEXT.
//
if( ObjectEntry->Scb != pScb ) {
NwDequeueIrpContext( pIrpContext, FALSE );
NwReferenceScb( ObjectEntry->Scb->pNpScb ); pIrpContext->pScb = ObjectEntry->Scb; pIrpContext->pNpScb = ObjectEntry->Scb->pNpScb; NwDereferenceScb( pScb->pNpScb );
NwAppendToQueueAndWait( pIrpContext ); }
goto CompletedObject; }
//
// At this point we are going to reuse an exisiting entry. If there is an
// SCB pointed to by it, dereference it.
//
if( ObjectEntry->Scb != NULL ) {
NwDereferenceScb( ObjectEntry->Scb->pNpScb ); ObjectEntry->Scb = NULL; } } }
//
// Check to see if it's at least partially distinguished already.
//
i = 0; while (i < puDsObject->Length / sizeof( WCHAR ) ) {
if ( puDsObject->Buffer[i++] == L'.' ) { fPartiallyDistinguished = TRUE; } }
//
// If it's partially distinguished, try it without the context first.
//
if ( fPartiallyDistinguished ) {
Status = NdsResolveNameKm ( pIrpContext, puDsObject, &dwObjectOid, fAllowServerJump, dwResolverFlags );
if ( NT_SUCCESS( Status ) ) {
DebugTrace( 0, Dbg, "VerifyObject: %wZ\n", puDsObject ); goto GetObjectType; } }
//
// If that failed, or if it wasn't partially distinguished,
// see if there's a current context we can append.
//
if ( ( pCredentials ) && ( pCredentials->CurrentContext.Length ) ) {
if ( ( puDsObject->Length + pCredentials->CurrentContext.Length ) < sizeof( FdnObject ) ) {
//
// Append the context.
//
uFdnObject.MaximumLength = sizeof( FdnObject ); uFdnObject.Buffer = FdnObject;
RtlCopyMemory( FdnObject, puDsObject->Buffer, puDsObject->Length ); uFdnObject.Length = puDsObject->Length;
if ( uFdnObject.Buffer[( uFdnObject.Length / sizeof( WCHAR ) ) - 1] == L'.' ) { uFdnObject.Length -= sizeof( WCHAR ); }
if ( pCredentials->CurrentContext.Buffer[0] != L'.' ) { uFdnObject.Buffer[uFdnObject.Length / sizeof( WCHAR )] = L'.'; uFdnObject.Length += sizeof( WCHAR ); }
RtlCopyMemory( ((BYTE *)FdnObject) + uFdnObject.Length, pCredentials->CurrentContext.Buffer, pCredentials->CurrentContext.Length );
uFdnObject.Length += pCredentials->CurrentContext.Length;
//
// Resolve this name.
//
Status = NdsResolveNameKm ( pIrpContext, &uFdnObject, &dwObjectOid, fAllowServerJump, dwResolverFlags );
if ( NT_SUCCESS( Status ) ) {
DebugTrace( 0, Dbg, "VerifyObject: %wZ\n", &uFdnObject ); goto GetObjectType; }
}
}
//
// This is not a valid name.
//
DebugTrace( 0, Dbg, "VerifyObject: No ds object to resolve.\n", 0 );
if( ObjectCacheLocked == TRUE ) {
NwDereferenceScb( pScb->pNpScb );
KeReleaseSemaphore( &(pScb->ObjectCacheLock), 0, 1, FALSE );
ObjectCacheLocked = FALSE; }
if ( fHoldingCredentialList ) { NwReleaseCredList( pLogon, pIrpContext ); fHoldingCredentialList = FALSE; }
return STATUS_BAD_NETWORK_PATH;
GetObjectType:
if ( fHoldingCredentialList ) { NwReleaseCredList( pLogon, pIrpContext ); fHoldingCredentialList = FALSE; }
//
// If a server jump is not allowed, we don't need to worry
// about getting the object type.
//
if ( !fAllowServerJump ) { dwObjectType = 0; goto CompletedObject; }
//
// Resolve the object and get its information.
//
Status = NdsAllocateLockedBuffer( &NdsRequest, NDS_BUFFER_SIZE );
if ( !NT_SUCCESS( Status ) ) { if( ObjectCacheLocked == TRUE ) {
NwDereferenceScb( pScb->pNpScb );
KeReleaseSemaphore( &(pScb->ObjectCacheLock), 0, 1, FALSE );
ObjectCacheLocked = FALSE; }
return STATUS_INSUFFICIENT_RESOURCES; }
Status = FragExWithWait( pIrpContext, NDSV_READ_ENTRY_INFO, &NdsRequest, "DD", 0, dwObjectOid );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
Status = NdsCompletionCodetoNtStatus( &NdsRequest );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
//
// Verify that it's a volume object.
//
RtlInitUnicodeString( &uVolume, VOLUME_ATTRIBUTE ); RtlInitUnicodeString( &uQueue, QUEUE_ATTRIBUTE ); RtlInitUnicodeString( &uDirMap, DIR_MAP_ATTRIBUTE );
uReplyString.Length = 0; uReplyString.MaximumLength = sizeof( ReplyBuffer ); uReplyString.Buffer = ReplyBuffer;
Status = ParseResponse( NULL, NdsRequest.pRecvBufferVa, NdsRequest.dwBytesWritten, "G_T", sizeof( NDS_RESPONSE_GET_OBJECT_INFO ), &uReplyString );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
dwObjectType = 0;
if ( !RtlCompareUnicodeString( &uVolume, &uReplyString, FALSE ) ) { dwObjectType = NDS_OBJECTTYPE_VOLUME; } else if ( !RtlCompareUnicodeString( &uQueue, &uReplyString, FALSE ) ) { dwObjectType = NDS_OBJECTTYPE_QUEUE; } else if ( !RtlCompareUnicodeString( &uDirMap, &uReplyString, FALSE ) ) { dwObjectType = NDS_OBJECTTYPE_DIRMAP; }
if ( !dwObjectType ) {
DebugTrace( 0, Dbg, "DS object is not a connectable type.\n", 0 ); Status = STATUS_OBJECT_PATH_SYNTAX_BAD; goto ExitWithCleanup; }
CompletedObject:
//
// See if the cache needs to be updated. If an entry was
// found in the cache or the oldest is being replace, then
// ObjectEntry will point to that entry, but UseEntry will
// be FALSE. If the data from the cache was used, then
// UseEntry will be TRUE. If the cache is disabled or there
// was some other problem, then ObjectEntry will be NULL.
//
if( ObjectEntry != NULL && UseEntry == FALSE ) {
//
// Store the results in the cache entry.
//
ObjectEntry->DsOid = dwObjectOid; ObjectEntry->ObjectType = dwObjectType;
ObjectEntry->Scb = pIrpContext->pScb; NwReferenceScb( ObjectEntry->Scb->pNpScb );
//
// Store the information describing the request.
//
ObjectEntry->ResolverFlags = dwResolverFlags; ObjectEntry->AllowServerJump = fAllowServerJump;
RtlCopyUnicodeString( &(ObjectEntry->ObjectName), puDsObject );
//
// Set the timeout.
//
KeQueryTickCount( &CurrentTick ); ObjectEntry->Timeout.QuadPart = CurrentTick.QuadPart + (NdsObjectCacheTimeout * 100);
//
// Remove this entry from wherever it is in the list, and
// insert it on the front.
//
RemoveEntryList( Entry ); InsertHeadList( ListHead, Entry ); }
if ( pdwDsOid ) { *pdwDsOid = dwObjectOid; }
if ( pdwObjectType ) { *pdwObjectType = dwObjectType; }
Status = STATUS_SUCCESS;
ExitWithCleanup:
if( ObjectCacheLocked == TRUE ) {
NwDereferenceScb( pScb->pNpScb );
KeReleaseSemaphore( &(pScb->ObjectCacheLock), 0, 1, FALSE ); }
if ( fHoldingCredentialList ) { NwReleaseCredList( pLogon, pIrpContext ); }
if ( NdsRequest.pRecvBufferVa ) { NdsFreeLockedBuffer( &NdsRequest ); }
return Status;}
NTSTATUSNdsVerifyContext( PIRP_CONTEXT pIrpContext, PUNICODE_STRING puTree, PUNICODE_STRING puContext)/*++
Given a context and a tree, verify that the context is a valid container in the tree.
This call may cause the irpcontex to jump servers to an referred dir server. If so, the scb pointers in the irp context will be updated, the old server will be dereferenced, and the new server will hold the reference for this request.
--*/{
NTSTATUS Status; DWORD dwOid, dwSubordinates; LOCKED_BUFFER NdsRequest; PSCB pScb, pTreeScb; PNONPAGED_SCB pNpScb;
PAGED_CODE();
//
// Establish a browse connection to the tree we want to query.
//
NdsRequest.pRecvBufferVa = NULL;
pScb = pIrpContext->pScb; pNpScb = pIrpContext->pNpScb;
Status = NdsCreateTreeScb( pIrpContext, &pTreeScb, puTree, NULL, NULL, TRUE, FALSE );
if ( !NT_SUCCESS( Status ) ) { pTreeScb = NULL; goto ExitWithCleanup; }
Status = NdsResolveNameKm ( pIrpContext, puContext, &dwOid, TRUE, DEFAULT_RESOLVE_FLAGS );
if ( !NT_SUCCESS( Status ) ) { DebugTrace( 0, Dbg, "NdsVerifyContext: resolve failed.\n", 0 ); goto ExitWithCleanup; }
Status = NdsAllocateLockedBuffer( &NdsRequest, NDS_BUFFER_SIZE );
if ( !NT_SUCCESS( Status ) ) { Status = STATUS_INSUFFICIENT_RESOURCES; NdsRequest.pRecvBufferVa = NULL; goto ExitWithCleanup; }
Status = FragExWithWait( pIrpContext, NDSV_READ_ENTRY_INFO, &NdsRequest, "DD", 0, dwOid );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
Status = NdsCompletionCodetoNtStatus( &NdsRequest );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
//
// Verify that it's a volume object by checking the
// third DWORD, which is the subordinate count.
//
Status = ParseResponse( NULL, NdsRequest.pRecvBufferVa, NdsRequest.dwBytesWritten, "G_D", 2 * sizeof( DWORD ), &dwSubordinates );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
if ( !dwSubordinates ) {
DebugTrace( 0, Dbg, "No subordinates in VerifyContext.\n", 0 ); Status = STATUS_INVALID_PARAMETER; goto ExitWithCleanup; }
//
// Success!
//
ExitWithCleanup:
//
// We may have jumped servers in the resolve name call,
// so make sure we dereference the correct SCB!
//
if ( pTreeScb ) { NwDereferenceScb( pIrpContext->pNpScb ); }
//
// Restore the connection to the original server.
//
NwDequeueIrpContext( pIrpContext, FALSE ); pIrpContext->pScb = pScb; pIrpContext->pNpScb = pNpScb;
if ( NdsRequest.pRecvBufferVa ) { NdsFreeLockedBuffer( &NdsRequest ); }
return Status;}
NTSTATUSNdsMapObjectToServerShare( PIRP_CONTEXT pIrpContext, PSCB *ppScb, PUNICODE_STRING puServerSharePath, BOOLEAN CreateTreeConnection, PDWORD pdwObjectId)/*++
Description:
This function takes a pointer to a tree scb and an irp context for a create request. It looks up the ds object from the create request in the ds and maps it to the appropriate server/share duple.
The FullPathName and VolumeName strings in the create section of the irp context are updated and a connection to the real host server is established so that the create request can continue as desired.
--*/{
NTSTATUS Status; LOCKED_BUFFER NdsRequest;
UNICODE_STRING uServerAttribute; UNICODE_STRING uVolumeAttribute; UNICODE_STRING uQueueAttribute; UNICODE_STRING uPathAttribute;
UNICODE_STRING uHostServer; UNICODE_STRING uRealServerName; UNICODE_STRING uHostVolume; UNICODE_STRING uHostPath; UNICODE_STRING uIntermediateVolume;
UNICODE_STRING uDsObjectPath; DWORD dwObjectOid, dwObjectType, dwDirMapType;
DWORD dwTotalPathLen; USHORT usSrv; PSCB pOldScb, pNewServerScb;
UNICODE_STRING UserName, Password; ULONG ShareType;
PAGED_CODE();
//
// Set up strings and buffers.
//
RtlInitUnicodeString( &uServerAttribute, HOST_SERVER_ATTRIBUTE ); RtlInitUnicodeString( &uVolumeAttribute, HOST_VOLUME_ATTRIBUTE ); RtlInitUnicodeString( &uQueueAttribute, HOST_QUEUE_ATTRIBUTE ); RtlInitUnicodeString( &uPathAttribute, HOST_PATH_ATTRIBUTE );
RtlInitUnicodeString( &uHostServer, NULL ); RtlInitUnicodeString( &uRealServerName, NULL ); RtlInitUnicodeString( &uHostVolume, NULL ); RtlInitUnicodeString( &uHostPath, NULL ); RtlInitUnicodeString( &uIntermediateVolume, NULL );
Status = NdsAllocateLockedBuffer( &NdsRequest, NDS_BUFFER_SIZE );
if ( !NT_SUCCESS( Status ) ) { return Status; }
uHostServer.Buffer = ALLOCATE_POOL( PagedPool, 4 * MAX_NDS_NAME_SIZE );
if ( !uHostServer.Buffer ) {
NdsFreeLockedBuffer( &NdsRequest ); return STATUS_INSUFFICIENT_RESOURCES; }
uHostServer.MaximumLength = MAX_NDS_NAME_SIZE;
uHostVolume.Buffer = ( PWCHAR )(((BYTE *)uHostServer.Buffer) + MAX_NDS_NAME_SIZE); uHostVolume.MaximumLength = MAX_NDS_NAME_SIZE;
uHostPath.Buffer = ( PWCHAR )(((BYTE *)uHostVolume.Buffer) + MAX_NDS_NAME_SIZE); uHostPath.MaximumLength = MAX_NDS_NAME_SIZE;
uIntermediateVolume.Buffer = ( PWCHAR )(((BYTE *)uHostPath.Buffer) + MAX_NDS_NAME_SIZE); uIntermediateVolume.MaximumLength = MAX_NDS_NAME_SIZE;
//
// First get the object id from the ds.
//
Status = NdsGetDsObjectFromPath( pIrpContext, &uDsObjectPath );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
pOldScb = pIrpContext->pScb;
Status = NdsVerifyObject( pIrpContext, &uDsObjectPath, TRUE, // allow server jumping
DEFAULT_RESOLVE_FLAGS, &dwObjectOid, &dwObjectType );
//
// We may have jumped servers.
//
*ppScb = pIrpContext->pScb;
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
//
// If this is a dir map, grab the target volume and re-verify
// the object for connectability.
//
if ( dwObjectType == NDS_OBJECTTYPE_DIRMAP ) {
//
// First get the volume object and path.
//
Status = NdsReadAttributesKm( pIrpContext, dwObjectOid, &uPathAttribute, &NdsRequest );
if ( !NT_SUCCESS( Status )) { goto ExitWithCleanup; }
//
// Dig out the volume path and the directory path.
//
Status = ParseResponse( NULL, NdsRequest.pRecvBufferVa, NdsRequest.dwBytesWritten, "G_____S_ST", sizeof( DWORD ), // completion code
sizeof( DWORD ), // iter handle
sizeof( DWORD ), // info type
sizeof( DWORD ), // attribute count
sizeof( DWORD ), // syntax id
NULL, // attribute name
3 * sizeof( DWORD ), // unknown
&uIntermediateVolume, // ds volume
&uHostPath ); // dir map path
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
//
// Verify the target volume object.
//
Status = NdsVerifyObject( pIrpContext, &uIntermediateVolume, TRUE, DEFAULT_RESOLVE_FLAGS, &dwObjectOid, &dwDirMapType );
//
// We may have jumped servers.
//
*ppScb = pIrpContext->pScb;
if ( !NT_SUCCESS( Status )) { goto ExitWithCleanup; }
ASSERT( dwDirMapType == NDS_OBJECTTYPE_VOLUME );
}
//
// Get the server (for any connectable object).
//
Status = NdsReadStringAttribute( pIrpContext, dwObjectOid, &uServerAttribute, &uHostServer );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
//
// Get the host volume or queue.
//
if ( dwObjectType == NDS_OBJECTTYPE_VOLUME || dwObjectType == NDS_OBJECTTYPE_DIRMAP ) {
Status = NdsReadStringAttribute( pIrpContext, dwObjectOid, &uVolumeAttribute, &uHostVolume );
} else if ( dwObjectType == NDS_OBJECTTYPE_QUEUE ) {
Status = NdsReadStringAttribute( pIrpContext, dwObjectOid, &uQueueAttribute, &uHostVolume );
} else {
Status = STATUS_BAD_NETWORK_PATH;
}
if ( !NT_SUCCESS( Status )) { goto ExitWithCleanup; }
//
// Dig out the actual server name from the X.500 name.
//
Status = NdsGetServerBasicName( &uHostServer, &uRealServerName );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
//
// Make sure we have enough space in the new buffer to format
// the new connect string of \X:\Server\Share\Path,
// \LPTX\Server\Share\Path, or \Server\Share\Path.
//
dwTotalPathLen = uRealServerName.Length + uHostVolume.Length; dwTotalPathLen += ( sizeof( L"\\\\" ) - sizeof( L"" ) );
//
// Account for the correct prefix. We count on single character
// drive and printer letters here. Again, maybe unwise later on.
//
if ( pIrpContext->Specific.Create.DriveLetter ) {
if ( dwObjectType == NDS_OBJECTTYPE_VOLUME || dwObjectType == NDS_OBJECTTYPE_DIRMAP ) {
dwTotalPathLen += ( sizeof( L"X:\\" ) - sizeof( L"" ) );
} else if ( dwObjectType == NDS_OBJECTTYPE_QUEUE ) {
dwTotalPathLen += ( sizeof( L"LPT1\\" ) - sizeof( L"" ) );
} else {
Status = STATUS_BAD_NETWORK_PATH; goto ExitWithCleanup; } }
//
// Count space for the path and filename if present.
//
if ( pIrpContext->Specific.Create.PathName.Length ) { dwTotalPathLen += pIrpContext->Specific.Create.PathName.Length; }
if ( dwObjectType == NDS_OBJECTTYPE_DIRMAP ) { dwTotalPathLen += uHostPath.Length; dwTotalPathLen += ( sizeof( L"\\" ) - sizeof( L"" ) ); }
if ( pIrpContext->Specific.Create.FileName.Length ) { dwTotalPathLen += pIrpContext->Specific.Create.FileName.Length; dwTotalPathLen += ( sizeof( L"\\" ) - sizeof( L"" ) ); }
if ( dwTotalPathLen > puServerSharePath->MaximumLength ) {
DebugTrace( 0 , Dbg, "NdsMapObjectToServerShare: Buffer too small.\n", 0 ); Status = STATUS_BUFFER_TOO_SMALL; goto ExitWithCleanup; }
//
// First dequeue the irp context from the dir server we've been
// talking to, then make the connect to the new server. We logged
// in earlier so this will get us an authenticated connection.
//
NwDequeueIrpContext( pIrpContext, FALSE );
//
// Since it's possible for us to get attaching to a bindery
// authenticated resource, we have to dig out the user name
// and password for the create call!!
//
ReadAttachEas( pIrpContext->pOriginalIrp, &UserName, &Password, &ShareType, NULL );
Status = CreateScb( &pNewServerScb, pIrpContext, &uRealServerName, NULL, &UserName, &Password, FALSE, FALSE );
if ( !NT_SUCCESS( Status ) ) { goto ExitWithCleanup; }
ASSERT( pNewServerScb->pNpScb->State == SCB_STATE_IN_USE );
NwDereferenceScb( (*ppScb)->pNpScb ); *ppScb = pNewServerScb;
//
// Re-query the OID of the print queue object on this server
// or it could be wrong. Do not permit any sort of a server
// jump this time.
//
if ( dwObjectType == NDS_OBJECTTYPE_QUEUE ) {
Status = NdsVerifyObject( pIrpContext, &uDsObjectPath, FALSE, RSLV_CREATE_ID, &dwObjectOid, NULL );
if ( !NT_SUCCESS( Status )) { goto ExitWithCleanup; }
}
if ( pdwObjectId ) { *pdwObjectId = dwObjectOid; }
//
// Re-format the path strings in the irp context. The nds share
// length tells us how much of the NDS share name is interesting
// for getting the directory handle.
//
usSrv = 0; pIrpContext->Specific.Create.dwNdsShareLength = 0;
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR; puServerSharePath->Length = sizeof( WCHAR ); usSrv += sizeof( WCHAR );
//
// Set the proper prefix for this connect type.
//
if ( pIrpContext->Specific.Create.DriveLetter ) {
if ( dwObjectType == NDS_OBJECTTYPE_QUEUE ) {
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = L'L'; usSrv += sizeof( WCHAR );
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = L'P'; usSrv += sizeof( WCHAR );
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = L'T'; usSrv += sizeof( WCHAR ); }
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = pIrpContext->Specific.Create.DriveLetter; usSrv += sizeof( WCHAR );
if ( dwObjectType != NDS_OBJECTTYPE_QUEUE ) {
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = L':'; usSrv += sizeof( WCHAR ); }
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR; usSrv += sizeof( WCHAR );
puServerSharePath->Length = usSrv; }
//
// Append the server name.
//
RtlAppendUnicodeStringToString( puServerSharePath, &uRealServerName ); usSrv += uRealServerName.Length;
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR; puServerSharePath->Length += sizeof( WCHAR ); usSrv += sizeof( WCHAR );
//
// Append the volume for volumes or the full ds path to
// the print queue for queues.
//
if ( dwObjectType == NDS_OBJECTTYPE_VOLUME || dwObjectType == NDS_OBJECTTYPE_DIRMAP ) {
RtlAppendUnicodeStringToString( puServerSharePath, &uHostVolume ); usSrv += uHostVolume.Length; pIrpContext->Specific.Create.dwNdsShareLength += uHostVolume.Length;
} else if ( dwObjectType == NDS_OBJECTTYPE_QUEUE ) {
RtlAppendUnicodeStringToString( puServerSharePath, &uDsObjectPath ); usSrv += uDsObjectPath.Length; pIrpContext->Specific.Create.dwNdsShareLength += uDsObjectPath.Length;
}
//
// Append the dir map path.
//
if ( dwObjectType == NDS_OBJECTTYPE_DIRMAP ) {
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR; puServerSharePath->Length += sizeof( WCHAR ); usSrv += sizeof( WCHAR ); pIrpContext->Specific.Create.dwNdsShareLength += sizeof( WCHAR );
RtlAppendUnicodeStringToString( puServerSharePath, &uHostPath ); usSrv += uHostPath.Length; pIrpContext->Specific.Create.dwNdsShareLength += uHostPath.Length;
}
//
// Handle the path and file if they exist.
//
if ( pIrpContext->Specific.Create.PathName.Length ) {
ASSERT( dwObjectType != NDS_OBJECTTYPE_QUEUE ); RtlAppendUnicodeStringToString( puServerSharePath, &pIrpContext->Specific.Create.PathName ); usSrv += pIrpContext->Specific.Create.PathName.Length;
//
// If this is a tree connection, then include the path in
// the share name so that the map point is correct.
//
if ( CreateTreeConnection ) { pIrpContext->Specific.Create.dwNdsShareLength += pIrpContext->Specific.Create.PathName.Length; } }
if ( pIrpContext->Specific.Create.FileName.Length ) {
ASSERT( dwObjectType != NDS_OBJECTTYPE_QUEUE );
puServerSharePath->Buffer[usSrv/sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR; puServerSharePath->Length += sizeof( WCHAR ); usSrv += sizeof( WCHAR );
RtlAppendUnicodeStringToString( puServerSharePath, &pIrpContext->Specific.Create.FileName ); usSrv += pIrpContext->Specific.Create.FileName.Length;
//
// If this is a tree connection, then include the file in
// the share name so that the map point is correct.
//
if ( CreateTreeConnection ) { pIrpContext->Specific.Create.dwNdsShareLength += sizeof( WCHAR ); pIrpContext->Specific.Create.dwNdsShareLength += pIrpContext->Specific.Create.FileName.Length; } }
//
// Record the object type in the irp context.
//
pIrpContext->Specific.Create.dwNdsObjectType = dwObjectType;
DebugTrace( 0, Dbg, "DS Object path is %wZ\n", &pIrpContext->Specific.Create.FullPathName ); DebugTrace( 0, Dbg, "Resolved path is %wZ\n", puServerSharePath );
ExitWithCleanup:
NdsFreeLockedBuffer( &NdsRequest ); FREE_POOL( uHostServer.Buffer ); return Status;}
|
