/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
blkendp.c
Abstract:
This module implements routines for managing endpoint blocks.
Author:
Chuck Lenzmeier (chuckl) 4-Oct-1989
Revision History:
--*/
#include "precomp.h"
#include "blkendp.tmh"
#pragma hdrstop
#define BugCheckFileId SRV_FILE_BLKENDP
#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGE, SrvAllocateEndpoint )
#pragma alloc_text( PAGE, SrvCheckAndReferenceEndpoint )
#pragma alloc_text( PAGE, SrvCloseEndpoint )
#pragma alloc_text( PAGE, SrvDereferenceEndpoint )
#pragma alloc_text( PAGE, SrvFreeEndpoint )
#pragma alloc_text( PAGE, SrvReferenceEndpoint )
#pragma alloc_text( PAGE, SrvFindNamedEndpoint )
#endif
#if 0
NOT PAGEABLE -- EmptyFreeConnectionList
NOT PAGEABLE -- WalkConnectionTable
#endif
VOID
SrvAllocateEndpoint (
OUT PENDPOINT *Endpoint,
IN PUNICODE_STRING NetworkName,
IN PUNICODE_STRING TransportName,
IN PANSI_STRING TransportAddress,
IN PUNICODE_STRING DomainName
)
/*++
Routine Description:
This function allocates an Endpoint Block from the system nonpaged
pool.
Arguments:
Endpoint - Returns a pointer to the endpoint block, or NULL if no
pool was available.
NetworkName - Supplies a pointer to the network name (e.g., NET1).
TransportName - The fully qualified name of the transport device.
For example, "\Device\Nbf".
TransportAddress - The fully qualified address (or name ) of the
server's endpoint. This name is used exactly as specified. For
NETBIOS-compatible networks, the caller must upcase and
blank-fill the name. E.g., "\Device\Nbf\NTSERVERbbbbbbbb".
DomainName - the domain being serviced by this endpoint
Return Value:
None.
--*/
{
CLONG length;
PENDPOINT endpoint;
NTSTATUS status;
PAGED_CODE( );
//
// Attempt to allocate from nonpaged pool.
//
length = sizeof(ENDPOINT) +
NetworkName->Length + sizeof(*NetworkName->Buffer) +
TransportName->Length + sizeof(*TransportName->Buffer) +
TransportAddress->Length + sizeof(*TransportAddress->Buffer) +
RtlOemStringToUnicodeSize( TransportAddress ) +
DNLEN * sizeof( *DomainName->Buffer ) +
DNLEN + sizeof(CHAR);
endpoint = ALLOCATE_NONPAGED_POOL( length, BlockTypeEndpoint );
*Endpoint = endpoint;
if ( endpoint == NULL ) {
INTERNAL_ERROR (
ERROR_LEVEL_EXPECTED,
"SrvAllocateEndpoint: Unable to allocate %d bytes from nonpaged "
"pool.",
length,
NULL
);
return;
}
IF_DEBUG(HEAP) {
SrvPrint1( "SrvAllocateEndpoint: Allocated endpoint at %p\n",
endpoint );
}
//
// Initialize the endpoint block. Zero it first.
//
RtlZeroMemory( endpoint, length );
SET_BLOCK_TYPE_STATE_SIZE( endpoint, BlockTypeEndpoint, BlockStateActive, length );
endpoint->BlockHeader.ReferenceCount = 2; // allow for Active status
// and caller's pointer
//
// Allocate connection table.
//
SrvAllocateTable(
&endpoint->ConnectionTable,
6, // !!!
TRUE
);
if ( endpoint->ConnectionTable.Table == NULL ) {
DEALLOCATE_NONPAGED_POOL( endpoint );
*Endpoint = NULL;
return;
}
InitializeListHead( &endpoint->FreeConnectionList );
#if SRVDBG29
UpdateConnectionHistory( "INIT", endpoint, NULL );
#endif
//
// Copy the network name, transport name, and server address, and domain
// name into the block.
//
endpoint->NetworkName.Length = NetworkName->Length;
endpoint->NetworkName.MaximumLength =
(SHORT)(NetworkName->Length + sizeof(*NetworkName->Buffer));
endpoint->NetworkName.Buffer = (PWCH)(endpoint + 1);
RtlCopyMemory(
endpoint->NetworkName.Buffer,
NetworkName->Buffer,
NetworkName->Length
);
endpoint->TransportName.Length = TransportName->Length;
endpoint->TransportName.MaximumLength =
(SHORT)(TransportName->Length + sizeof(*TransportName->Buffer));
endpoint->TransportName.Buffer =
(PWCH)((PCHAR)endpoint->NetworkName.Buffer +
endpoint->NetworkName.MaximumLength);
RtlCopyMemory(
endpoint->TransportName.Buffer,
TransportName->Buffer,
TransportName->Length
);
endpoint->ServerName.MaximumLength = (USHORT)RtlOemStringToUnicodeSize( TransportAddress );
endpoint->ServerName.Length = 0;
endpoint->ServerName.Buffer = endpoint->TransportName.Buffer +
endpoint->TransportName.MaximumLength / sizeof( WCHAR );
endpoint->TransportAddress.Length = TransportAddress->Length;
endpoint->TransportAddress.MaximumLength =
(SHORT)(TransportAddress->Length + 1);
endpoint->TransportAddress.Buffer =
(PCHAR)endpoint->ServerName.Buffer +
endpoint->ServerName.MaximumLength;
RtlCopyMemory(
endpoint->TransportAddress.Buffer,
TransportAddress->Buffer,
TransportAddress->Length
);
status = RtlOemStringToUnicodeString( &endpoint->ServerName, TransportAddress, FALSE );
if (!NT_SUCCESS(status)) {
DbgPrint("SRv ENDPOINT Name translation failed status %lx\n",status);
KdPrint(("SRv ENDPOINT Name translation failed status %lx\n",status));
}
//
// Trim the trailing blanks off the end of servername
//
while( endpoint->ServerName.Length &&
endpoint->ServerName.Buffer[ (endpoint->ServerName.Length / sizeof(WCHAR))-1 ] == L' ' ) {
endpoint->ServerName.Length -= sizeof( WCHAR );
}
endpoint->DomainName.Length = DomainName->Length;
endpoint->DomainName.MaximumLength = DNLEN * sizeof( *endpoint->DomainName.Buffer );
endpoint->DomainName.Buffer = (PWCH)((PCHAR)endpoint->TransportAddress.Buffer +
TransportAddress->MaximumLength);
RtlCopyMemory(
endpoint->DomainName.Buffer,
DomainName->Buffer,
DomainName->Length
);
endpoint->OemDomainName.Length = (SHORT)RtlUnicodeStringToOemSize( DomainName );
endpoint->OemDomainName.MaximumLength = DNLEN + sizeof( CHAR );
endpoint->OemDomainName.Buffer = (PCHAR)endpoint->DomainName.Buffer +
endpoint->DomainName.MaximumLength;
status = RtlUnicodeStringToOemString(
&endpoint->OemDomainName,
&endpoint->DomainName,
FALSE // Do not allocate the OEM string
);
ASSERT( NT_SUCCESS(status) );
//
// Initialize the network address field.
//
endpoint->NetworkAddress.Buffer = endpoint->NetworkAddressData;
endpoint->NetworkAddress.Length = sizeof( endpoint->NetworkAddressData ) -
sizeof(endpoint->NetworkAddressData[0]);
endpoint->NetworkAddress.MaximumLength = sizeof( endpoint->NetworkAddressData );
//
// Increment the count of endpoints in the server.
//
ACQUIRE_LOCK( &SrvEndpointLock );
SrvEndpointCount++;
RELEASE_LOCK( &SrvEndpointLock );
INITIALIZE_REFERENCE_HISTORY( endpoint );
INCREMENT_DEBUG_STAT( SrvDbgStatistics.EndpointInfo.Allocations );
return;
} // SrvAllocateEndpoint
BOOLEAN SRVFASTCALL
SrvCheckAndReferenceEndpoint (
PENDPOINT Endpoint
)
/*++
Routine Description:
This function atomically verifies that an endpoint is active and
increments the reference count on the endpoint if it is.
Arguments:
Endpoint - Address of endpoint
Return Value:
BOOLEAN - Returns TRUE if the endpoint is active, FALSE otherwise.
--*/
{
PAGED_CODE( );
//
// Acquire the lock that guards the endpoint's state field.
//
ACQUIRE_LOCK( &SrvEndpointLock );
//
// If the endpoint is active, reference it and return TRUE.
//
if ( GET_BLOCK_STATE(Endpoint) == BlockStateActive ) {
SrvReferenceEndpoint( Endpoint );
RELEASE_LOCK( &SrvEndpointLock );
return TRUE;
}
//
// The endpoint isn't active. Return FALSE.
//
RELEASE_LOCK( &SrvEndpointLock );
return FALSE;
} // SrvCheckAndReferenceEndpoint
VOID
SrvCloseEndpoint (
IN PENDPOINT Endpoint
)
/*++
Routine Description:
This function closes a transport endpoint.
*** This function must be called with SrvEndpointLock held exactly
once. The lock is released on exit.
Arguments:
Endpoint - Supplies a pointer to an Endpoint Block
Return Value:
None.
--*/
{
USHORT index;
PCONNECTION connection;
PAGED_CODE( );
ASSERT( ExIsResourceAcquiredExclusiveLite(&RESOURCE_OF(SrvEndpointLock)) );
if ( GET_BLOCK_STATE(Endpoint) == BlockStateActive ) {
IF_DEBUG(BLOCK1) SrvPrint1( "Closing endpoint at %p\n", Endpoint );
SET_BLOCK_STATE( Endpoint, BlockStateClosing );
//
// Close all active connections.
//
index = (USHORT)-1;
while ( TRUE ) {
//
// Get the next active connection in the table. If no more
// are available, WalkConnectionTable returns NULL.
// Otherwise, it returns a referenced pointer to a
// connection.
//
connection = WalkConnectionTable( Endpoint, &index );
if ( connection == NULL ) {
break;
}
//
// We don't want to hold the endpoint lock while we close the
// connection (this causes lock level problems). Since we
// already have a referenced pointer to the connection, this
// is safe.
//
RELEASE_LOCK( &SrvEndpointLock );
#if SRVDBG29
UpdateConnectionHistory( "CEND", Endpoint, connection );
#endif
connection->DisconnectReason = DisconnectEndpointClosing;
SrvCloseConnection( connection, FALSE );
ACQUIRE_LOCK( &SrvEndpointLock );
SrvDereferenceConnection( connection );
}
//
// Close all free connections.
//
EmptyFreeConnectionList( Endpoint );
//
// We don't need to hold the endpoint lock anymore.
//
RELEASE_LOCK( &SrvEndpointLock );
//
// Close the endpoint file handle. This causes all pending
// requests to be aborted. It also deregisters all event
// handlers.
//
// *** Note that we have a separate reference to the file
// object, in addition to the handle. We don't release that
// reference until all activity on the endpoint has ceased
// (in SrvDereferenceEndpoint).
//
SRVDBG_RELEASE_HANDLE( Endpoint->EndpointHandle, "END", 2, Endpoint );
SrvNtClose( Endpoint->EndpointHandle, FALSE );
if ( Endpoint->IsConnectionless ) {
SRVDBG_RELEASE_HANDLE( Endpoint->NameSocketHandle, "END", 2, Endpoint );
SrvNtClose( Endpoint->NameSocketHandle, FALSE );
}
//
// Dereference the endpoint (to indicate that it's no longer
// open).
//
SrvDereferenceEndpoint( Endpoint );
INCREMENT_DEBUG_STAT( SrvDbgStatistics.EndpointInfo.Closes );
} else {
RELEASE_LOCK( &SrvEndpointLock );
}
return;
} // SrvCloseEndpoint
VOID SRVFASTCALL
SrvDereferenceEndpoint (
IN PENDPOINT Endpoint
)
/*++
Routine Description:
This function decrements the reference count on an endpoint. If the
reference count goes to zero, the endpoint block is deleted.
Arguments:
Endpoint - Address of endpoint
Return Value:
None.
--*/
{
ULONG newEndpointCount;
PAGED_CODE( );
//
// Enter a critical section and decrement the reference count on the
// block.
//
ACQUIRE_LOCK( &SrvEndpointLock );
IF_DEBUG(REFCNT) {
SrvPrint2( "Dereferencing endpoint %p; old refcnt %lx\n",
Endpoint, Endpoint->BlockHeader.ReferenceCount );
}
ASSERT( GET_BLOCK_TYPE( Endpoint ) == BlockTypeEndpoint );
ASSERT( (LONG)Endpoint->BlockHeader.ReferenceCount > 0 );
UPDATE_REFERENCE_HISTORY( Endpoint, TRUE );
if ( --Endpoint->BlockHeader.ReferenceCount == 0 ) {
//
// The new reference count is 0, meaning that it's time to
// delete this block.
//
ASSERT( GET_BLOCK_STATE(Endpoint) != BlockStateActive );
//
// Decrement the count of endpoints in the server. If the new
// count is zero, set the endpoint event.
//
ASSERT( SrvEndpointCount >= 1 );
newEndpointCount = --SrvEndpointCount;
RELEASE_LOCK( &SrvEndpointLock );
if ( newEndpointCount == 0 ) {
KeSetEvent( &SrvEndpointEvent, 0, FALSE );
}
//
// Remove the endpoint from the global list of endpoints.
//
SrvRemoveEntryOrderedList( &SrvEndpointList, Endpoint );
//
// Dereference the file object pointer. (The handle to the file
// object was closed in SrvCloseEndpoint.)
//
ObDereferenceObject( Endpoint->FileObject );
if ( Endpoint->IsConnectionless ) {
ObDereferenceObject( Endpoint->NameSocketFileObject );
}
//
// Free the endpoint block's storage.
//
SrvFreeEndpoint( Endpoint );
} else {
RELEASE_LOCK( &SrvEndpointLock );
}
return;
} // SrvDereferenceEndpoint
VOID
SrvFreeEndpoint (
IN PENDPOINT Endpoint
)
/*++
Routine Description:
This function returns an Endpoint Block to the system nonpaged pool.
Arguments:
Endpoint - Address of endpoint
Return Value:
None.
--*/
{
PAGED_CODE( );
DEBUG SET_BLOCK_TYPE_STATE_SIZE( Endpoint, BlockTypeGarbage, BlockStateDead, -1 );
DEBUG Endpoint->BlockHeader.ReferenceCount = (ULONG)-1;
TERMINATE_REFERENCE_HISTORY( Endpoint );
if ( Endpoint->IpxMaxPacketSizeArray != NULL ) {
FREE_HEAP( Endpoint->IpxMaxPacketSizeArray );
}
if ( Endpoint->ConnectionTable.Table != NULL ) {
SrvFreeTable( &Endpoint->ConnectionTable );
}
DEALLOCATE_NONPAGED_POOL( Endpoint );
IF_DEBUG(HEAP) SrvPrint1( "SrvFreeEndpoint: Freed endpoint block at %p\n", Endpoint );
INCREMENT_DEBUG_STAT( SrvDbgStatistics.EndpointInfo.Frees );
return;
} // SrvFreeEndpoint
VOID
SrvReferenceEndpoint (
PENDPOINT Endpoint
)
/*++
Routine Description:
This function increments the reference count on an endpoint block.
Arguments:
Endpoint - Address of endpoint
Return Value:
None.
--*/
{
PAGED_CODE( );
//
// Enter a critical section and increment the reference count on the
// endpoint.
//
ACQUIRE_LOCK( &SrvEndpointLock );
ASSERT( (LONG)Endpoint->BlockHeader.ReferenceCount > 0 );
ASSERT( GET_BLOCK_TYPE(Endpoint) == BlockTypeEndpoint );
ASSERT( GET_BLOCK_STATE(Endpoint) == BlockStateActive );
UPDATE_REFERENCE_HISTORY( Endpoint, FALSE );
Endpoint->BlockHeader.ReferenceCount++;
IF_DEBUG(REFCNT) SrvPrint2( "Referencing endpoint %p; new refcnt %lx\n",
Endpoint, Endpoint->BlockHeader.ReferenceCount );
RELEASE_LOCK( &SrvEndpointLock );
return;
} // SrvReferenceEndpoint
BOOLEAN
SrvFindNamedEndpoint(
IN PUNICODE_STRING ServerName,
OUT PBOOLEAN RemapPipeNames OPTIONAL
)
/*++
Routine Description:
This routine returns TRUE of any endpoint is supporting 'ServerName'.
Additionally, set the RemapPipeNames variable from the found endpoint.
--*/
{
PLIST_ENTRY listEntry;
PENDPOINT endpoint = NULL;
PAGED_CODE( );
if( ARGUMENT_PRESENT( RemapPipeNames ) ) {
*RemapPipeNames = FALSE;
}
//
// Find an endpoint block supporting the specified name.
//
ACQUIRE_LOCK_SHARED( &SrvEndpointLock );
for( listEntry = SrvEndpointList.ListHead.Flink;
listEntry != &SrvEndpointList.ListHead;
endpoint = NULL, listEntry = listEntry->Flink ) {
endpoint = CONTAINING_RECORD(
listEntry,
ENDPOINT,
GlobalEndpointListEntry
);
//
// Skip any inappropriate endpoints
//
if( GET_BLOCK_STATE( endpoint ) != BlockStateActive ||
endpoint->IsConnectionless ||
(ARGUMENT_PRESENT( RemapPipeNames ) && endpoint->IsNoNetBios) ) {
continue;
}
//
// See if this endpoint literally matches the name we're looking for
//
if( RtlEqualUnicodeString( ServerName, &endpoint->ServerName, TRUE ) ) {
break;
}
//
// We might have a case where the ServerName is something like
// server.dns.company.com
// but the endpoint netbios name is only 'server'. We should match this
//
if( endpoint->ServerName.Length < ServerName->Length ) {
UNICODE_STRING shortServerName;
shortServerName = *ServerName;
shortServerName.Length = endpoint->ServerName.Length;
if (RtlEqualUnicodeString( &endpoint->ServerName, &shortServerName, TRUE)) {
if (endpoint->ServerName.Length < ((NETBIOS_NAME_LEN - 1) * sizeof(WCHAR))) {
if (ServerName->Buffer[ shortServerName.Length / sizeof( WCHAR ) ] == L'.') {
break;
}
} else {
if (endpoint->ServerName.Length == (NETBIOS_NAME_LEN - 1) * sizeof(WCHAR)) {
break;
}
}
}
}
//
// See if this endpoint domain name literally matches the name we're
// looking for. The following two tests against the domain name are
// required to cover the case when there are certain components that
// use the domain name to talk to the server. Given the way name resolution
// records are setup this used to work before this checkin. This change
// breaks them. These tests provide us the backward compatibility.
//
if( RtlEqualUnicodeString( ServerName, &endpoint->DomainName, TRUE ) ) {
break;
}
//
// We might have a case where the ServerName is something like
// server.dns.company.com
// but the endpoint netbios name is only 'server'. We should match this
//
if( endpoint->DomainName.Length < ServerName->Length ) {
UNICODE_STRING shortServerName;
shortServerName = *ServerName;
shortServerName.Length = endpoint->DomainName.Length;
if (RtlEqualUnicodeString( &endpoint->DomainName, &shortServerName, TRUE)) {
if (endpoint->DomainName.Length <= (NETBIOS_NAME_LEN * sizeof(WCHAR))) {
if (ServerName->Buffer[ shortServerName.Length / sizeof( WCHAR ) ] == L'.') {
break;
}
} else {
if (endpoint->DomainName.Length == (NETBIOS_NAME_LEN - 1) * sizeof(WCHAR)) {
break;
}
}
}
}
}
if( ARGUMENT_PRESENT( RemapPipeNames ) && endpoint != NULL ) {
*RemapPipeNames = ( endpoint->RemapPipeNames == TRUE );
}
RELEASE_LOCK( &SrvEndpointLock );
return endpoint != NULL;
}
VOID
EmptyFreeConnectionList (
IN PENDPOINT Endpoint
)
{
PCONNECTION connection;
PLIST_ENTRY listEntry;
KIRQL oldIrql;
//
// *** In order to synchronize with the TDI connect handler in
// the FSD, which only uses a spin lock to serialize access
// to the free connection list (and does not check the
// endpoint state), we need to atomically capture the list
// head and empty the list.
//
ACQUIRE_GLOBAL_SPIN_LOCK( Fsd, &oldIrql );
listEntry = Endpoint->FreeConnectionList.Flink;
InitializeListHead( &Endpoint->FreeConnectionList );
#if SRVDBG29
UpdateConnectionHistory( "CLOS", Endpoint, NULL );
#endif
RELEASE_GLOBAL_SPIN_LOCK( Fsd, oldIrql );
while ( listEntry != &Endpoint->FreeConnectionList ) {
connection = CONTAINING_RECORD(
listEntry,
CONNECTION,
EndpointFreeListEntry
);
listEntry = listEntry->Flink;
SrvCloseFreeConnection( connection );
}
return;
} // EmptyFreeConnectionList
PCONNECTION
WalkConnectionTable (
IN PENDPOINT Endpoint,
IN OUT PUSHORT Index
)
{
USHORT i;
PTABLE_HEADER tableHeader;
PCONNECTION connection;
KIRQL oldIrql;
ACQUIRE_SPIN_LOCK( &ENDPOINT_SPIN_LOCK(0), &oldIrql );
for ( i = 1; i < ENDPOINT_LOCK_COUNT ; i++ ) {
ACQUIRE_DPC_SPIN_LOCK( &ENDPOINT_SPIN_LOCK(i) );
}
tableHeader = &Endpoint->ConnectionTable;
for ( i = *Index + 1; i < tableHeader->TableSize; i++ ) {
connection = (PCONNECTION)tableHeader->Table[i].Owner;
if ( (connection != NULL) &&
(GET_BLOCK_STATE(connection) == BlockStateActive) ) {
*Index = i;
SrvReferenceConnectionLocked( connection );
goto exit;
}
}
connection = NULL;
exit:
for ( i = ENDPOINT_LOCK_COUNT-1 ; i > 0 ; i-- ) {
RELEASE_DPC_SPIN_LOCK( &ENDPOINT_SPIN_LOCK(i) );
}
RELEASE_SPIN_LOCK( &ENDPOINT_SPIN_LOCK(0), oldIrql );
return connection;
} // WalkConnectionTable