mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2972 lines
82 KiB
2972 lines
82 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
network.c
|
|
|
|
Abstract:
|
|
|
|
This module contains routines for interfacing the LAN Manager server
|
|
to the network.
|
|
|
|
Author:
|
|
|
|
Chuck Lenzmeier (chuckl) 7-Oct-1989
|
|
|
|
Environment:
|
|
|
|
File System Process, kernel mode only
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "network.tmh"
|
|
#pragma hdrstop
|
|
|
|
#include <ntddip.h>
|
|
#include <ntddtcp.h>
|
|
#include <ipfltdrv.h>
|
|
#include <tcpinfo.h>
|
|
#include <tdiinfo.h>
|
|
#include <nbtioctl.h>
|
|
|
|
#define BugCheckFileId SRV_FILE_NETWORK
|
|
|
|
//
|
|
// Local declarations
|
|
//
|
|
|
|
NTSTATUS
|
|
GetNetworkAddress (
|
|
IN PENDPOINT Endpoint
|
|
);
|
|
|
|
NTSTATUS
|
|
OpenEndpoint (
|
|
OUT PENDPOINT *Endpoint,
|
|
IN PUNICODE_STRING NetworkName,
|
|
IN PUNICODE_STRING TransportName,
|
|
IN PANSI_STRING TransportAddress,
|
|
IN PUNICODE_STRING DomainName,
|
|
IN ULONG TransportAddFlags,
|
|
IN BOOLEAN AlternateEndpoint
|
|
);
|
|
|
|
NTSTATUS
|
|
OpenNetbiosAddress (
|
|
IN OUT PENDPOINT Endpoint,
|
|
IN PVOID DeviceName,
|
|
IN PVOID NetbiosName
|
|
);
|
|
|
|
NTSTATUS
|
|
OpenNetbiosExAddress (
|
|
IN OUT PENDPOINT Endpoint,
|
|
IN PVOID DeviceName,
|
|
IN PVOID NetbiosName
|
|
);
|
|
|
|
NTSTATUS
|
|
OpenNonNetbiosAddress (
|
|
IN OUT PENDPOINT Endpoint,
|
|
IN PVOID DeviceName,
|
|
IN PVOID NetbiosName
|
|
);
|
|
|
|
NTSTATUS
|
|
OpenIpxSocket (
|
|
OUT PHANDLE Handle,
|
|
OUT PFILE_OBJECT *FileObject,
|
|
OUT PDEVICE_OBJECT *DeviceObject,
|
|
IN PVOID DeviceName,
|
|
IN USHORT Socket
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text( PAGE, SrvAddServedNet )
|
|
#pragma alloc_text( PAGE, SrvDeleteServedNet )
|
|
#pragma alloc_text( PAGE, SrvDoDisconnect )
|
|
#pragma alloc_text( PAGE, GetNetworkAddress )
|
|
#pragma alloc_text( PAGE, OpenEndpoint )
|
|
#pragma alloc_text( PAGE, OpenNetbiosAddress )
|
|
#pragma alloc_text( PAGE, OpenNonNetbiosAddress )
|
|
#pragma alloc_text( PAGE, OpenIpxSocket )
|
|
#pragma alloc_text( PAGE, SrvRestartAccept )
|
|
#pragma alloc_text( PAGE, RestartStartSend )
|
|
#pragma alloc_text( PAGE, GetIpxMaxBufferSize )
|
|
|
|
#endif
|
|
#if 0
|
|
NOT PAGEABLE -- SrvOpenConnection
|
|
NOT PAGEABLE -- SrvPrepareReceiveWorkItem
|
|
NOT PAGEABLE -- SrvStartSend
|
|
NOT PAGEABLE -- SrvStartSend2
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
SrvAddServedNet(
|
|
IN PUNICODE_STRING NetworkName,
|
|
IN PUNICODE_STRING TransportName,
|
|
IN PANSI_STRING TransportAddress,
|
|
IN PUNICODE_STRING DomainName,
|
|
IN ULONG TransportAddFlags,
|
|
IN DWORD PasswordLength,
|
|
IN PBYTE Password
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function initializes the server on a network. This
|
|
involves making the server known by creating a transport endpoint,
|
|
posting a Listen request, and setting up event handlers.
|
|
|
|
Arguments:
|
|
|
|
NetworkName - The administrative name of the network (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. For example, "NTSERVERbbbbbbbb".
|
|
|
|
DomainName - The name of the domain to service
|
|
|
|
Password/PasswordLength - used for mutual authentication (optional)
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Indicates whether the network was successfully started.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
PENDPOINT endpoint;
|
|
|
|
PAGED_CODE( );
|
|
|
|
IF_DEBUG(TRACE1) KdPrint(( "SrvAddServedNet entered\n" ));
|
|
|
|
//
|
|
// Call OpenEndpoint to open the transport provider, bind to the
|
|
// server address, and register the FSD receive event handler.
|
|
//
|
|
|
|
status = OpenEndpoint(
|
|
&endpoint,
|
|
NetworkName,
|
|
TransportName,
|
|
TransportAddress,
|
|
DomainName,
|
|
TransportAddFlags,
|
|
FALSE); // primary endpoint
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
KdPrint(( "SrvAddServedNet: unable to open endpoint %wZ for addr %z, status %X\n", TransportName, (PCSTRING)TransportAddress, status ));
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
//
|
|
// Dereference the endpoint. (When it was created, the reference
|
|
// count was incremented to account for our pointer.)
|
|
//
|
|
SrvDereferenceEndpoint( endpoint );
|
|
|
|
//
|
|
// Call OpenEndpoint to open the transport provider, bind to the
|
|
// server address, and register the FSD receive event handler. This is
|
|
// the auxillary endpoint registration in the new TDI address format. Since
|
|
// this is not supported by all the transports it cannot be deemed an error.
|
|
//
|
|
//
|
|
status = OpenEndpoint(
|
|
&endpoint,
|
|
NetworkName,
|
|
TransportName,
|
|
TransportAddress,
|
|
DomainName,
|
|
TransportAddFlags,
|
|
TRUE); // Alternate endpoint
|
|
|
|
if ( NT_SUCCESS( status ) ) {
|
|
SrvDereferenceEndpoint( endpoint );
|
|
}
|
|
|
|
if( PasswordLength ) {
|
|
SrvAddSecurityCredentials( TransportAddress, DomainName, PasswordLength, Password );
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} // SrvAddServedNet
|
|
|
|
|
|
NTSTATUS
|
|
SrvDeleteServedNet(
|
|
IN PUNICODE_STRING TransportName,
|
|
IN PANSI_STRING TransportAddress
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function causes the server to stop listening to a network.
|
|
|
|
Arguments:
|
|
|
|
TransportAddress - the transport address (e.g. \Device\Nbf\POPCORN
|
|
of the endpoint to delete.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Indicates whether the network was successfully stopped.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY listEntry;
|
|
PENDPOINT endpoint;
|
|
BOOLEAN match;
|
|
NTSTATUS status = STATUS_NONEXISTENT_NET_NAME;
|
|
|
|
PAGED_CODE( );
|
|
IF_DEBUG(TRACE1) KdPrint(( "SrvDeleteServedNet entered\n" ));
|
|
|
|
//
|
|
// Find the endpoint block with the specified name.
|
|
//
|
|
|
|
top:
|
|
ACQUIRE_LOCK( &SrvEndpointLock );
|
|
|
|
listEntry = SrvEndpointList.ListHead.Flink;
|
|
|
|
while ( listEntry != &SrvEndpointList.ListHead ) {
|
|
|
|
endpoint = CONTAINING_RECORD(
|
|
listEntry,
|
|
ENDPOINT,
|
|
GlobalEndpointListEntry
|
|
);
|
|
|
|
if( GET_BLOCK_STATE(endpoint) == BlockStateActive ) {
|
|
|
|
//
|
|
// We have a match if the transport name is correct and we either
|
|
// haven't specified a transport address, or if the transport
|
|
// address matches
|
|
//
|
|
match = (BOOLEAN)(
|
|
RtlEqualUnicodeString(
|
|
TransportName,
|
|
&endpoint->TransportName,
|
|
TRUE // case insensitive compare
|
|
)
|
|
&&
|
|
(
|
|
TransportAddress->Length == 0 ||
|
|
|
|
RtlEqualString(
|
|
(PSTRING)TransportAddress,
|
|
(PSTRING)&endpoint->TransportAddress,
|
|
TRUE // case insensitive compare
|
|
)
|
|
)
|
|
|
|
);
|
|
|
|
if ( match ) {
|
|
|
|
//
|
|
// The specified network name (endpoint) exists. Close the
|
|
// endpoint. This releases the endpoint lock.
|
|
//
|
|
|
|
SrvCloseEndpoint( endpoint );
|
|
|
|
status = STATUS_SUCCESS;
|
|
|
|
//
|
|
// Restart this loop, since this endpoint may have vaporized and
|
|
// the list might have changed because we dropped SrvEndpointLock.
|
|
//
|
|
// SrvCloseEndpoint will have marked this endpoint as BlockStateClosing,
|
|
// so we will not be in an infinite loop!
|
|
//
|
|
goto top;
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Go to the next one.
|
|
//
|
|
|
|
listEntry = listEntry->Flink;
|
|
|
|
}
|
|
|
|
//
|
|
// We are done. If we successfully matched an endpoint, we return STATUS_SUCCESS
|
|
//
|
|
|
|
RELEASE_LOCK( &SrvEndpointLock );
|
|
|
|
return status;
|
|
|
|
} // SrvDeleteServedNet
|
|
|
|
|
|
NTSTATUS
|
|
SrvDoDisconnect (
|
|
IN OUT PCONNECTION Connection
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function issues a Disconnect request on a network. The request
|
|
is performed synchronously -- control is not returned to the caller
|
|
until the request completes.
|
|
|
|
Arguments:
|
|
|
|
Connection - Supplies a pointer to an Connection Block
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Indicates whether the disconnect was successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE( );
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvDoDisconnect entered\n" ));
|
|
#if SRVDBG29
|
|
UpdateConnectionHistory( "SDSC", Connection->Endpoint, Connection );
|
|
#endif
|
|
|
|
ASSERT( !Connection->Endpoint->IsConnectionless );
|
|
|
|
//
|
|
// Issue the disconnect request.
|
|
//
|
|
|
|
status = SrvIssueDisconnectRequest(
|
|
Connection->FileObject,
|
|
&Connection->DeviceObject,
|
|
TDI_DISCONNECT_ABORT
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"SrvDoDisconnect: NtDeviceIoControlFile failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
#if SRVDBG29
|
|
if (status != STATUS_LINK_FAILED && status != STATUS_REMOTE_DISCONNECT) {
|
|
KdPrint(( "SRV: SrvDoDisconnect: SrvIssueDisconnectRequest failed\n" ));
|
|
DbgBreakPoint();
|
|
}
|
|
#endif
|
|
//
|
|
// Mark the connection as not reusable, because the transport
|
|
// probably still thinks it's active.
|
|
//
|
|
|
|
Connection->NotReusable = TRUE;
|
|
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
|
|
}
|
|
|
|
//
|
|
// Return the status of the I/O operation.
|
|
//
|
|
|
|
return status;
|
|
|
|
} // SrvDoDisconnect
|
|
|
|
|
|
NTSTATUS
|
|
SrvOpenConnection (
|
|
IN PENDPOINT Endpoint
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function opens a connection for an endpoint and queues it to
|
|
the endpoint's free connection list.
|
|
|
|
Arguments:
|
|
|
|
Endpoint - Supplies a pointer to an Endpoint Block
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Indicates whether the connection was successfully opened.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
PCONNECTION connection;
|
|
PPAGED_CONNECTION pagedConnection;
|
|
CHAR eaBuffer[sizeof(FILE_FULL_EA_INFORMATION) - 1 +
|
|
TDI_CONNECTION_CONTEXT_LENGTH + 1 +
|
|
sizeof(CONNECTION_CONTEXT)];
|
|
PFILE_FULL_EA_INFORMATION ea;
|
|
CONNECTION_CONTEXT UNALIGNED *ctx;
|
|
OBJECT_ATTRIBUTES objectAttributes;
|
|
IO_STATUS_BLOCK iosb;
|
|
KIRQL oldIrql;
|
|
PTABLE_HEADER tableHeader;
|
|
SHORT sidIndex;
|
|
USHORT i;
|
|
PTABLE_ENTRY entry = NULL;
|
|
TDI_PROVIDER_INFO providerInfo;
|
|
|
|
//
|
|
// Allocate a connection block.
|
|
//
|
|
|
|
SrvAllocateConnection( &connection );
|
|
|
|
if ( connection == NULL ) {
|
|
return STATUS_INSUFF_SERVER_RESOURCES;
|
|
}
|
|
|
|
pagedConnection = connection->PagedConnection;
|
|
|
|
//
|
|
// Allocate an entry in the endpoint's connection table.
|
|
//
|
|
|
|
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;
|
|
|
|
if ( tableHeader->FirstFreeEntry == -1 &&
|
|
SrvGrowTable(
|
|
tableHeader,
|
|
8,
|
|
0x7fff,
|
|
NULL ) == FALSE ) {
|
|
|
|
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 );
|
|
status = STATUS_INSUFF_SERVER_RESOURCES;
|
|
goto cleanup;
|
|
}
|
|
|
|
sidIndex = tableHeader->FirstFreeEntry;
|
|
entry = &tableHeader->Table[sidIndex];
|
|
tableHeader->FirstFreeEntry = entry->NextFreeEntry;
|
|
DEBUG entry->NextFreeEntry = -2;
|
|
if ( tableHeader->LastFreeEntry == sidIndex ) {
|
|
tableHeader->LastFreeEntry = -1;
|
|
}
|
|
|
|
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 );
|
|
|
|
if ( !Endpoint->IsConnectionless ) {
|
|
|
|
//
|
|
// Create the EA for the connection context.
|
|
//
|
|
|
|
ea = (PFILE_FULL_EA_INFORMATION)eaBuffer;
|
|
ea->NextEntryOffset = 0;
|
|
ea->Flags = 0;
|
|
ea->EaNameLength = TDI_CONNECTION_CONTEXT_LENGTH;
|
|
ea->EaValueLength = sizeof(CONNECTION_CONTEXT);
|
|
|
|
RtlCopyMemory( ea->EaName, StrConnectionContext, ea->EaNameLength + 1 );
|
|
|
|
ctx = (CONNECTION_CONTEXT UNALIGNED *)&ea->EaName[ea->EaNameLength + 1];
|
|
*ctx = connection;
|
|
|
|
//
|
|
// Create the connection file object.
|
|
//
|
|
|
|
SrvInitializeObjectAttributes_U(
|
|
&objectAttributes,
|
|
&Endpoint->TransportName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
status = NtCreateFile(
|
|
&pagedConnection->ConnectionHandle,
|
|
0,
|
|
&objectAttributes,
|
|
&iosb,
|
|
NULL,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
eaBuffer,
|
|
FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) +
|
|
ea->EaNameLength + 1 + ea->EaValueLength
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
IF_DEBUG(ERRORS) {
|
|
KdPrint(( "SrvOpenConnection: NtCreateFile failed: %X\n", status ));
|
|
}
|
|
goto cleanup;
|
|
}
|
|
SRVDBG_CLAIM_HANDLE( pagedConnection->ConnectionHandle, "CON", 7, connection );
|
|
|
|
//
|
|
// Obtain a referenced pointer to the file object.
|
|
//
|
|
|
|
status = ObReferenceObjectByHandle(
|
|
pagedConnection->ConnectionHandle,
|
|
0,
|
|
(POBJECT_TYPE) NULL,
|
|
KernelMode,
|
|
(PVOID *)&connection->FileObject,
|
|
NULL
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
SrvLogServiceFailure( SRV_SVC_OB_REF_BY_HANDLE, status );
|
|
|
|
//
|
|
// This internal error bugchecks the system.
|
|
//
|
|
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_IMPOSSIBLE,
|
|
"SrvOpenConnection: ObReferenceObjectByHandle failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
//
|
|
// Get the address of the device object for the endpoint.
|
|
//
|
|
|
|
connection->DeviceObject = IoGetRelatedDeviceObject(
|
|
connection->FileObject
|
|
);
|
|
|
|
//
|
|
// Associate the connection with the endpoint's address.
|
|
//
|
|
|
|
status = SrvIssueAssociateRequest(
|
|
connection->FileObject,
|
|
&connection->DeviceObject,
|
|
Endpoint->EndpointHandle
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_UNEXPECTED,
|
|
"SrvOpenConnection: SrvIssueAssociateRequest failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
goto cleanup;
|
|
}
|
|
|
|
IF_DEBUG(NET1) {
|
|
KdPrint(( "SrvOpenConnection: Connection on %p %z opened; handle %p, pointer %p\n", Endpoint,
|
|
(PCSTRING)&Endpoint->TransportAddress,
|
|
connection->PagedConnection->ConnectionHandle,
|
|
connection->FileObject ));
|
|
}
|
|
|
|
//
|
|
// Initialize the MaximumSendSize for the transport that we're using
|
|
//
|
|
|
|
status = SrvIssueTdiQuery(
|
|
connection->FileObject,
|
|
&connection->DeviceObject,
|
|
(PCHAR)&providerInfo,
|
|
sizeof(providerInfo),
|
|
TDI_QUERY_PROVIDER_INFO
|
|
);
|
|
|
|
//
|
|
// If we got the provider info, make sure the maximum send size is at
|
|
// least 1K-1. If we have no provider info, then maximum send size is 64KB.
|
|
//
|
|
|
|
if ( NT_SUCCESS(status) ) {
|
|
connection->MaximumSendSize = providerInfo.MaxSendSize;
|
|
if ( connection->MaximumSendSize < MIN_SEND_SIZE ) {
|
|
connection->MaximumSendSize = MIN_SEND_SIZE;
|
|
}
|
|
} else {
|
|
connection->MaximumSendSize = MAX_PARTIAL_BUFFER_SIZE;
|
|
}
|
|
|
|
|
|
} else { // if ( Endpoint->IsConnectionless )
|
|
if (sidIndex > 0xfff) {
|
|
// The IPXSID index can only span 12 bits
|
|
// Code needs to be added to ensure that we can try to locate
|
|
// an index less than 0xfff
|
|
status = STATUS_INSUFF_SERVER_RESOURCES;
|
|
goto cleanup;
|
|
}
|
|
|
|
// Give this the default initialization
|
|
connection->MaximumSendSize = MAX_PARTIAL_BUFFER_SIZE;
|
|
}
|
|
//
|
|
// Set the reference count on the connection to zero, in order to
|
|
// put it on the free list. (SrvAllocateConnection initialized the
|
|
// count to two.)
|
|
//
|
|
|
|
connection->BlockHeader.ReferenceCount = 0;
|
|
|
|
UPDATE_REFERENCE_HISTORY( connection, TRUE );
|
|
UPDATE_REFERENCE_HISTORY( connection, TRUE );
|
|
|
|
//
|
|
// Reference the endpoint and link the connection into the
|
|
// endpoint's free connection list.
|
|
//
|
|
|
|
connection->Endpoint = Endpoint;
|
|
connection->EndpointSpinLock =
|
|
&ENDPOINT_SPIN_LOCK(sidIndex & ENDPOINT_LOCK_MASK);
|
|
|
|
ACQUIRE_LOCK( &SrvEndpointLock );
|
|
|
|
SrvReferenceEndpoint( Endpoint );
|
|
|
|
ACQUIRE_SPIN_LOCK( connection->EndpointSpinLock, &oldIrql );
|
|
INCREMENT_IPXSID_SEQUENCE( entry->SequenceNumber );
|
|
if ( sidIndex == 0 && entry->SequenceNumber == 0 ) {
|
|
INCREMENT_IPXSID_SEQUENCE( entry->SequenceNumber );
|
|
}
|
|
|
|
connection->Sid = MAKE_IPXSID( sidIndex, entry->SequenceNumber );
|
|
connection->SidIndex = sidIndex;
|
|
|
|
entry->Owner = connection;
|
|
RELEASE_SPIN_LOCK( connection->EndpointSpinLock, oldIrql );
|
|
|
|
ACQUIRE_GLOBAL_SPIN_LOCK( Fsd, &oldIrql );
|
|
SrvInsertTailList(
|
|
&Endpoint->FreeConnectionList,
|
|
&connection->EndpointFreeListEntry
|
|
);
|
|
#if SRVDBG29
|
|
UpdateConnectionHistory( "OPEN", Endpoint, connection );
|
|
#endif
|
|
Endpoint->FreeConnectionCount++;
|
|
Endpoint->TotalConnectionCount++;
|
|
|
|
RELEASE_GLOBAL_SPIN_LOCK( Fsd, oldIrql );
|
|
|
|
IF_DEBUG(TDI) {
|
|
KdPrint(( "SrvOpenConnection created connection %p for endpoint %p; free %ld, total %ld\n", connection, Endpoint,
|
|
Endpoint->FreeConnectionCount,
|
|
Endpoint->TotalConnectionCount ));
|
|
}
|
|
|
|
RELEASE_LOCK( &SrvEndpointLock );
|
|
|
|
//
|
|
// The connection open was successful.
|
|
//
|
|
|
|
IF_DEBUG(TRACE1) {
|
|
KdPrint(( "SrvOpenConnection complete: %X\n", STATUS_SUCCESS ));
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
//
|
|
// Out-of-line error cleanup.
|
|
//
|
|
|
|
cleanup:
|
|
|
|
//
|
|
// Something failed. Clean up as appropriate.
|
|
//
|
|
|
|
if ( !Endpoint->IsConnectionless ) {
|
|
if ( connection->FileObject != NULL ) {
|
|
ObDereferenceObject( connection->FileObject );
|
|
}
|
|
if ( pagedConnection->ConnectionHandle != NULL ) {
|
|
SRVDBG_RELEASE_HANDLE( pagedConnection->ConnectionHandle, "CON", 12, connection );
|
|
SrvNtClose( pagedConnection->ConnectionHandle, FALSE );
|
|
}
|
|
}
|
|
|
|
if ( entry != NULL ) {
|
|
SrvRemoveEntryTable( tableHeader, sidIndex );
|
|
}
|
|
|
|
SrvFreeConnection( connection );
|
|
|
|
return status;
|
|
|
|
} // SrvOpenConnection
|
|
|
|
|
|
NTSTATUS
|
|
GetNetworkAddress (
|
|
IN PENDPOINT Endpoint
|
|
)
|
|
|
|
{
|
|
NTSTATUS status;
|
|
PCHAR adapterStatus;
|
|
PCHAR adapterAddress;
|
|
ANSI_STRING ansiString;
|
|
CHAR addressData[12+1];
|
|
ULONG i;
|
|
|
|
struct {
|
|
ULONG ActivityCount;
|
|
TA_IPX_ADDRESS LocalAddress;
|
|
} addressInfo;
|
|
|
|
PAGED_CODE( );
|
|
|
|
if ( !Endpoint->IsConnectionless ) {
|
|
|
|
//
|
|
// Allocate a buffer to receive adapter information.
|
|
//
|
|
// *** We want to get the ADAPTER_STATUS structure, but it is
|
|
// defined in the windows header file sdk\inc\nb30.h.
|
|
// Rather than including all the windows header files, just
|
|
// allocate about a page, which should always be enough for
|
|
// that structure.
|
|
//
|
|
|
|
adapterStatus = ALLOCATE_NONPAGED_POOL( 4080, BlockTypeAdapterStatus );
|
|
if ( adapterStatus == NULL ) {
|
|
return STATUS_INSUFF_SERVER_RESOURCES;
|
|
}
|
|
|
|
status = SrvIssueTdiQuery(
|
|
Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
adapterStatus,
|
|
4080,
|
|
TDI_QUERY_ADAPTER_STATUS
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_UNEXPECTED,
|
|
"GetNetworkAddress: SrvIssueTdiQuery failed: %X\n",
|
|
status,
|
|
NULL
|
|
);
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
DEALLOCATE_NONPAGED_POOL( adapterStatus );
|
|
return status;
|
|
}
|
|
|
|
adapterAddress = adapterStatus;
|
|
|
|
} else {
|
|
|
|
status = SrvIssueTdiQuery(
|
|
Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
(PCHAR)&addressInfo,
|
|
sizeof(addressInfo),
|
|
TDI_QUERY_ADDRESS_INFO
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_UNEXPECTED,
|
|
"GetNetworkAddress: SrvIssueTdiQuery failed: %X\n",
|
|
status,
|
|
NULL
|
|
);
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
return status;
|
|
}
|
|
|
|
Endpoint->LocalAddress = addressInfo.LocalAddress.Address[0].Address[0];
|
|
|
|
adapterAddress = addressInfo.LocalAddress.Address[0].Address[0].NodeAddress;
|
|
|
|
}
|
|
|
|
//
|
|
// Get an ANSI string that contains the adapter address.
|
|
//
|
|
|
|
ansiString.Buffer = addressData;
|
|
ansiString.Length = 12;
|
|
ansiString.MaximumLength = 13;
|
|
|
|
#define tohexdigit(a) ((CHAR)( (a) > 9 ? ((a) + 'a' - 0xA) : ((a) + '0') ))
|
|
|
|
for ( i = 0; i < 6; i++ ) {
|
|
addressData[2*i] = tohexdigit( (adapterAddress[i] >> 4) & 0x0F );
|
|
addressData[2*i+1] = tohexdigit( adapterAddress[i] & 0x0F );
|
|
}
|
|
|
|
addressData[12] = '\0';
|
|
|
|
//
|
|
// Convert the address string to Unicode.
|
|
//
|
|
|
|
status = RtlAnsiStringToUnicodeString(
|
|
&Endpoint->NetworkAddress,
|
|
&ansiString,
|
|
FALSE
|
|
);
|
|
ASSERT( NT_SUCCESS(status) );
|
|
|
|
if ( !Endpoint->IsConnectionless ) {
|
|
DEALLOCATE_NONPAGED_POOL( adapterStatus );
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} // GetNetworkAddress
|
|
|
|
|
|
NTSTATUS
|
|
OpenEndpoint (
|
|
OUT PENDPOINT *Endpoint,
|
|
IN PUNICODE_STRING NetworkName,
|
|
IN PUNICODE_STRING TransportName,
|
|
IN PANSI_STRING TransportAddress,
|
|
IN PUNICODE_STRING DomainName,
|
|
IN DWORD TransportAddFlags,
|
|
IN BOOLEAN AlternateEndpoint
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function opens a transport provider, simultaneously binding the
|
|
server's address to the transport endpoint, and registers a Receive
|
|
event handler for the endpoint.
|
|
|
|
Arguments:
|
|
|
|
Endpoint - Returns a pointer to an Endpoint Block
|
|
|
|
NetworkName - Supplies the administrative name of the network (e.g.,
|
|
NET1).
|
|
|
|
TransportName - The fully qualified name of the transport device.
|
|
For example, "\Device\Nbf".
|
|
|
|
TransportAddress - The exact name of the server to be used on the
|
|
specified transport. For NETBIOS-compatible networks, the
|
|
caller must upcase and blank-fill the name. For example,
|
|
"NTSERVERbbbbbbbb".
|
|
|
|
DomainName - name of domain to serve
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Indicates whether the network was successfully opened.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
PENDPOINT endpoint = NULL; // local copy of Endpoint
|
|
|
|
PAGED_CODE( );
|
|
|
|
IF_DEBUG(TRACE1) KdPrint(( "OpenEndpoint %wZ entered\n", TransportName ));
|
|
|
|
//
|
|
// Allocate an endpoint block.
|
|
//
|
|
|
|
SrvAllocateEndpoint(
|
|
&endpoint,
|
|
NetworkName,
|
|
TransportName,
|
|
TransportAddress,
|
|
DomainName
|
|
);
|
|
|
|
if ( endpoint == NULL ) {
|
|
IF_DEBUG(ERRORS) {
|
|
KdPrint(( "OpenEndpoint complete: %X\n",
|
|
STATUS_INSUFF_SERVER_RESOURCES ));
|
|
}
|
|
return STATUS_INSUFF_SERVER_RESOURCES;
|
|
}
|
|
|
|
if( TransportAddFlags & SRP_XADD_PRIMARY_MACHINE ) {
|
|
|
|
endpoint->IsPrimaryName = 1;
|
|
|
|
if( SrvComputerName.Buffer == NULL ) {
|
|
|
|
status = RtlAnsiStringToUnicodeString( &SrvComputerName, TransportAddress, TRUE );
|
|
|
|
if( NT_SUCCESS( status ) ) {
|
|
|
|
//
|
|
// Trim off the trailing spaces
|
|
//
|
|
|
|
while( SrvComputerName.Buffer[(SrvComputerName.Length-sizeof(WCHAR))/sizeof(WCHAR)]
|
|
== L' ' ) {
|
|
SrvComputerName.Length -= sizeof(WCHAR);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( NT_SUCCESS( status ) ) {
|
|
|
|
if( TransportAddFlags & SRP_XADD_REMAP_PIPE_NAMES ) {
|
|
endpoint->RemapPipeNames = 1;
|
|
}
|
|
|
|
if (AlternateEndpoint) {
|
|
|
|
status = OpenNetbiosExAddress(
|
|
endpoint,
|
|
TransportName,
|
|
TransportAddress->Buffer);
|
|
|
|
endpoint->AlternateAddressFormat = TRUE;
|
|
|
|
} else {
|
|
|
|
endpoint->AlternateAddressFormat = FALSE;
|
|
|
|
//
|
|
// Assume that the transport is a NetBIOS provider, and try to
|
|
// open the server's address using the NetBIOS name.
|
|
//
|
|
|
|
status = OpenNetbiosAddress(
|
|
endpoint,
|
|
TransportName,
|
|
TransportAddress->Buffer
|
|
);
|
|
|
|
//
|
|
// We could not open the transport as a NetBIOS provider. We will now try
|
|
// to see if it is a direct host IPX provider. However, if we have been
|
|
// configured to use Security Signatures, do not attempt direct host IPX since
|
|
// security signatures are not supported for direct host IPX transports
|
|
//
|
|
if ( !NT_SUCCESS(status) && SrvSmbSecuritySignaturesRequired == FALSE ) {
|
|
|
|
BOOLEAN isDuplicate = FALSE;
|
|
PLIST_ENTRY listEntry;
|
|
|
|
//
|
|
// Apparently the transport is not a NetBIOS provider. We can
|
|
// not open multiple connectionless providers through the same
|
|
// TransportName.
|
|
//
|
|
|
|
ACQUIRE_LOCK( &SrvEndpointLock );
|
|
|
|
for( listEntry = SrvEndpointList.ListHead.Flink;
|
|
listEntry != &SrvEndpointList.ListHead;
|
|
listEntry = listEntry->Flink ) {
|
|
|
|
PENDPOINT tmpEndpoint;
|
|
|
|
tmpEndpoint = CONTAINING_RECORD( listEntry, ENDPOINT, GlobalEndpointListEntry );
|
|
|
|
if( GET_BLOCK_STATE( tmpEndpoint ) == BlockStateActive &&
|
|
tmpEndpoint->IsConnectionless &&
|
|
RtlCompareUnicodeString( &tmpEndpoint->TransportName, TransportName, TRUE ) == 0 ) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
KdPrint(( "OpenEndpoint: Only one connectionless endpoint on %wZ allowed!\n",
|
|
TransportName ));
|
|
}
|
|
|
|
isDuplicate = TRUE;
|
|
status = STATUS_TOO_MANY_NODES;
|
|
break;
|
|
}
|
|
}
|
|
|
|
RELEASE_LOCK( &SrvEndpointLock );
|
|
|
|
//
|
|
// Try to open it as a connectionless provider.
|
|
//
|
|
if( isDuplicate == FALSE ) {
|
|
NTSTATUS status2;
|
|
|
|
status2 = OpenNonNetbiosAddress(
|
|
endpoint,
|
|
TransportName,
|
|
TransportAddress->Buffer
|
|
);
|
|
|
|
if( NT_SUCCESS( status2 ) ) {
|
|
status = status2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
//
|
|
// We couldn't open the provider as either a NetBIOS provider
|
|
// or as a connectionless provider.
|
|
//
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
KdPrint(( "OpenEndpoint: OpenAddress failed: %X\n", status ));
|
|
}
|
|
|
|
//
|
|
// Close all free connections.
|
|
//
|
|
|
|
EmptyFreeConnectionList( endpoint );
|
|
|
|
SrvFreeEndpoint( endpoint );
|
|
|
|
ACQUIRE_LOCK( &SrvEndpointLock );
|
|
SrvEndpointCount--;
|
|
RELEASE_LOCK( &SrvEndpointLock );
|
|
|
|
return status;
|
|
}
|
|
|
|
//
|
|
// Query the provider for the send entry point
|
|
//
|
|
|
|
SrvQuerySendEntryPoint(
|
|
endpoint->FileObject,
|
|
&endpoint->DeviceObject,
|
|
IOCTL_TDI_QUERY_DIRECT_SEND_HANDLER,
|
|
(PVOID*)&endpoint->FastTdiSend
|
|
);
|
|
|
|
//
|
|
// Query the provider for the send entry point
|
|
//
|
|
|
|
SrvQuerySendEntryPoint(
|
|
endpoint->FileObject,
|
|
&endpoint->DeviceObject,
|
|
IOCTL_TDI_QUERY_DIRECT_SENDDG_HANDLER,
|
|
(PVOID*)&endpoint->FastTdiSendDatagram
|
|
);
|
|
|
|
//
|
|
// The network open was successful. Link the new endpoint into the
|
|
// list of active endpoints. Return with a success status. (We
|
|
// don't dereference the endpoint because we're returning a pointer
|
|
// to the endpoint.)
|
|
//
|
|
|
|
SrvInsertEntryOrderedList( &SrvEndpointList, endpoint );
|
|
|
|
*Endpoint = endpoint;
|
|
|
|
IF_DEBUG(TRACE1) {
|
|
KdPrint(( "OpenEndpoint complete: %wZ %X\n", TransportName, STATUS_SUCCESS ));
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} // OpenEndpoint
|
|
|
|
NTSTATUS
|
|
SetupConnectionEndpointHandlers(
|
|
IN OUT PENDPOINT Endpoint)
|
|
{
|
|
NTSTATUS status;
|
|
ULONG i;
|
|
|
|
Endpoint->IsConnectionless = FALSE;
|
|
|
|
status = SrvVerifyDeviceStackSize(
|
|
Endpoint->EndpointHandle,
|
|
TRUE,
|
|
&Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
NULL
|
|
);
|
|
|
|
if ( !NT_SUCCESS( status ) ) {
|
|
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenNetbiosAddress: Verify Device Stack Size failed: %X\n",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Find the network address of the adapter used by corresponding to
|
|
// this endpoint.
|
|
//
|
|
|
|
GetNetworkAddress( Endpoint );
|
|
|
|
//
|
|
// Register the server's Receive event handler.
|
|
//
|
|
|
|
status = SrvIssueSetEventHandlerRequest(
|
|
Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
TDI_EVENT_RECEIVE,
|
|
(PVOID)SrvFsdTdiReceiveHandler,
|
|
Endpoint
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenNetbiosAddress: set receive event handler failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Register the server's Disconnect event handler.
|
|
//
|
|
|
|
status = SrvIssueSetEventHandlerRequest(
|
|
Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
TDI_EVENT_DISCONNECT,
|
|
(PVOID)SrvFsdTdiDisconnectHandler,
|
|
Endpoint
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_UNEXPECTED,
|
|
"OpenNetbiosAddress: set disconnect event handler failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Create a number of free connections for the endpoint. These
|
|
// connections will be used to service Connect events.
|
|
//
|
|
// *** If we fail in an attempt to create a connection, but we can
|
|
// successfully create at least one, we keep the endpoint. The
|
|
// cleanup code below depends on this behavior.
|
|
//
|
|
|
|
for ( i = 0; i < SrvFreeConnectionMinimum; i++ ) {
|
|
|
|
status = SrvOpenConnection( Endpoint );
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenNetbiosAddress: SrvOpenConnection failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
if ( i == 0 ) {
|
|
goto cleanup;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Register the server's Connect event handler.
|
|
//
|
|
// *** Note that Connect events can be delivered IMMEDIATELY upon
|
|
// completion of this request!
|
|
//
|
|
|
|
status = SrvIssueSetEventHandlerRequest(
|
|
Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
TDI_EVENT_CONNECT,
|
|
(PVOID)SrvFsdTdiConnectHandler,
|
|
Endpoint
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_UNEXPECTED,
|
|
"OpenNetbiosAddress: set connect event handler failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
goto cleanup;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
//
|
|
// Out-of-line error cleanup.
|
|
//
|
|
|
|
cleanup:
|
|
|
|
//
|
|
// Something failed. Clean up as appropriate.
|
|
//
|
|
|
|
if ( Endpoint->FileObject != NULL ) {
|
|
ObDereferenceObject( Endpoint->FileObject );
|
|
Endpoint->FileObject = NULL;
|
|
}
|
|
if ( Endpoint->EndpointHandle != NULL ) {
|
|
SRVDBG_RELEASE_HANDLE( Endpoint->EndpointHandle, "END", 14, Endpoint );
|
|
SrvNtClose( Endpoint->EndpointHandle, FALSE );
|
|
Endpoint->EndpointHandle = NULL;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
OpenNetbiosAddress (
|
|
IN OUT PENDPOINT Endpoint,
|
|
IN PVOID DeviceName,
|
|
IN PVOID NetbiosName
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
ULONG i;
|
|
|
|
CHAR eaBuffer[sizeof(FILE_FULL_EA_INFORMATION) +
|
|
TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
|
|
sizeof(TA_NETBIOS_ADDRESS)];
|
|
|
|
PAGED_CODE( );
|
|
|
|
status = TdiOpenNetbiosAddress(
|
|
&Endpoint->EndpointHandle,
|
|
eaBuffer,
|
|
DeviceName,
|
|
NetbiosName
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
IF_DEBUG( ERRORS ) {
|
|
KdPrint(( "TdiOpenNetbiosAddress( %wZ ) status %X\n", DeviceName, status ));
|
|
}
|
|
return status;
|
|
}
|
|
|
|
status = SetupConnectionEndpointHandlers(Endpoint);
|
|
|
|
return status;
|
|
} // OpenNetbiosAddress
|
|
|
|
NTSTATUS
|
|
OpenNetbiosExAddress(
|
|
IN OUT PENDPOINT Endpoint,
|
|
IN PVOID DeviceName,
|
|
IN PVOID NetbiosName
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
|
|
PFILE_FULL_EA_INFORMATION ea;
|
|
OBJECT_ATTRIBUTES objectAttributes;
|
|
IO_STATUS_BLOCK iosb;
|
|
|
|
ULONG length;
|
|
CHAR buffer[sizeof(FILE_FULL_EA_INFORMATION) +
|
|
TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
|
|
sizeof(TA_NETBIOS_EX_ADDRESS)];
|
|
|
|
TA_NETBIOS_EX_ADDRESS NetbiosExAddress;
|
|
PTDI_ADDRESS_NETBIOS_EX pTdiNetbiosExAddress;
|
|
PTDI_ADDRESS_NETBIOS pNetbiosAddress;
|
|
|
|
ULONG NetbiosExAddressLength;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Build the NETBIOS Extended address.
|
|
//
|
|
|
|
NetbiosExAddress.TAAddressCount = 1;
|
|
NetbiosExAddress.Address[0].AddressLength = TDI_ADDRESS_LENGTH_NETBIOS_EX;
|
|
NetbiosExAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_NETBIOS_EX;
|
|
|
|
pTdiNetbiosExAddress = NetbiosExAddress.Address[0].Address;
|
|
pNetbiosAddress = &pTdiNetbiosExAddress->NetbiosAddress;
|
|
pNetbiosAddress->NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_UNIQUE;
|
|
|
|
NetbiosExAddressLength = FIELD_OFFSET(TRANSPORT_ADDRESS,Address)
|
|
+ FIELD_OFFSET(TA_ADDRESS,Address)
|
|
+ FIELD_OFFSET(TDI_ADDRESS_NETBIOS_EX,NetbiosAddress)
|
|
+ TDI_ADDRESS_LENGTH_NETBIOS;
|
|
|
|
RtlCopyMemory(
|
|
pNetbiosAddress->NetbiosName,
|
|
NetbiosName,
|
|
NETBIOS_NAME_LEN);
|
|
|
|
// Copy the default endpoint name onto the NETBIOS Extended address.
|
|
RtlCopyMemory(
|
|
pTdiNetbiosExAddress->EndpointName,
|
|
SMBSERVER_LOCAL_ENDPOINT_NAME,
|
|
NETBIOS_NAME_LEN);
|
|
|
|
length = FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) +
|
|
TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
|
|
NetbiosExAddressLength;
|
|
ea = (PFILE_FULL_EA_INFORMATION)buffer;
|
|
|
|
ea->NextEntryOffset = 0;
|
|
ea->Flags = 0;
|
|
ea->EaNameLength = TDI_TRANSPORT_ADDRESS_LENGTH;
|
|
ea->EaValueLength = (USHORT)NetbiosExAddressLength;
|
|
|
|
RtlCopyMemory( ea->EaName, StrTransportAddress, ea->EaNameLength + 1 );
|
|
|
|
RtlCopyMemory(
|
|
&ea->EaName[ea->EaNameLength + 1],
|
|
&NetbiosExAddress,
|
|
NetbiosExAddressLength
|
|
);
|
|
|
|
InitializeObjectAttributes( &objectAttributes, DeviceName, OBJ_CASE_INSENSITIVE, NULL, NULL );
|
|
|
|
status = NtCreateFile (
|
|
&Endpoint->EndpointHandle,
|
|
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, // desired access
|
|
&objectAttributes, // object attributes
|
|
&iosb, // returned status information
|
|
NULL, // block size (unused)
|
|
0, // file attributes
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, // share access
|
|
FILE_CREATE, // create disposition
|
|
0, // create options
|
|
buffer, // EA buffer
|
|
length // EA length
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
IF_DEBUG( ERRORS ) {
|
|
KdPrint(("NtCreateFile %wZ NETBIOS_EX address status %X\n", DeviceName, status ));
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
Endpoint->IsNoNetBios = TRUE;
|
|
status = SetupConnectionEndpointHandlers(Endpoint);
|
|
|
|
IF_DEBUG( ERRORS ) {
|
|
if( !NT_SUCCESS( status ) ) {
|
|
KdPrint(("SetupConnectionEndpointHandlers failed, status %X\n", status ));
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
OpenNonNetbiosAddress (
|
|
IN OUT PENDPOINT Endpoint,
|
|
IN PVOID DeviceName,
|
|
IN PVOID NetbiosName
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
ULONG i;
|
|
ULONG numAdapters;
|
|
PULONG maxPktArray = NULL;
|
|
UCHAR buffer[sizeof(NWLINK_ACTION) + sizeof(IPX_ADDRESS_DATA) - 1];
|
|
PNWLINK_ACTION action;
|
|
PIPX_ADDRESS_DATA ipxAddressData;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Open the NetBIOS name socket.
|
|
//
|
|
|
|
status = OpenIpxSocket(
|
|
&Endpoint->NameSocketHandle,
|
|
&Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
DeviceName,
|
|
SMB_IPX_NAME_SOCKET
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
Endpoint->IsConnectionless = TRUE;
|
|
action = (PNWLINK_ACTION)buffer;
|
|
|
|
//
|
|
// Put the endpoint in broadcast reception mode.
|
|
//
|
|
|
|
action->Header.TransportId = 'XPIM'; // "MIPX"
|
|
action->Header.ActionCode = 0;
|
|
action->Header.Reserved = 0;
|
|
action->OptionType = NWLINK_OPTION_ADDRESS;
|
|
action->BufferLength = sizeof(action->Option);
|
|
action->Option = MIPX_RCVBCAST;
|
|
|
|
status = SrvIssueTdiAction(
|
|
Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
(PCHAR)action,
|
|
sizeof(NWLINK_ACTION)
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Tell the transport to give you the extended receive info
|
|
//
|
|
|
|
action->Header.TransportId = 'XPIM'; // "MIPX"
|
|
action->Header.ActionCode = 0;
|
|
action->Header.Reserved = 0;
|
|
action->OptionType = NWLINK_OPTION_ADDRESS;
|
|
action->BufferLength = sizeof(action->Option);
|
|
action->Option = MIPX_SETRCVFLAGS;
|
|
|
|
status = SrvIssueTdiAction(
|
|
Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
(PCHAR)action,
|
|
sizeof(NWLINK_ACTION)
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Get the max adapter number
|
|
//
|
|
|
|
action->Header.TransportId = 'XPIM'; // "MIPX"
|
|
action->Header.ActionCode = 0;
|
|
action->Header.Reserved = 0;
|
|
action->OptionType = NWLINK_OPTION_ADDRESS;
|
|
action->BufferLength = sizeof(action->Option) + sizeof(ULONG);
|
|
action->Option = MIPX_ADAPTERNUM2;
|
|
|
|
status = SrvIssueTdiAction(
|
|
Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
(PCHAR)action,
|
|
sizeof(NWLINK_ACTION) + sizeof(ULONG) - 1
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
numAdapters = *((PULONG)action->Data);
|
|
|
|
//
|
|
// Allocate an array to store the max pkt size for each adapter
|
|
//
|
|
|
|
maxPktArray = ALLOCATE_HEAP( numAdapters * sizeof(ULONG), BlockTypeBuffer );
|
|
|
|
if ( maxPktArray == NULL ) {
|
|
status = STATUS_INSUFF_SERVER_RESOURCES;
|
|
goto cleanup;
|
|
}
|
|
|
|
Endpoint->IpxMaxPacketSizeArray = maxPktArray;
|
|
Endpoint->MaxAdapters = numAdapters;
|
|
|
|
//
|
|
// Query the max pkt size for each adapter
|
|
//
|
|
|
|
action->Header.TransportId = 'XPIM'; // "MIPX"
|
|
action->Header.ActionCode = 0;
|
|
action->Header.Reserved = 0;
|
|
action->OptionType = NWLINK_OPTION_ADDRESS;
|
|
action->BufferLength = sizeof(action->Option) + sizeof(IPX_ADDRESS_DATA);
|
|
action->Option = MIPX_GETCARDINFO2;
|
|
ipxAddressData = (PIPX_ADDRESS_DATA)action->Data;
|
|
|
|
for ( i = 0; i < numAdapters; i++ ) {
|
|
|
|
ipxAddressData->adapternum = i;
|
|
|
|
status = SrvIssueTdiAction(
|
|
Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
(PCHAR)action,
|
|
sizeof(NWLINK_ACTION) + sizeof(IPX_ADDRESS_DATA) - 1
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// If this is a wan link, then we need to query the length each
|
|
// time we get a connection.
|
|
//
|
|
|
|
if ( ipxAddressData->wan ) {
|
|
maxPktArray[i] = 0;
|
|
} else {
|
|
maxPktArray[i] = ipxAddressData->maxpkt;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Find the network address of the adapter used by corresponding to
|
|
// this endpoint.
|
|
//
|
|
|
|
GetNetworkAddress( Endpoint );
|
|
|
|
//
|
|
// Register the name claim Receive Datagram event handler.
|
|
//
|
|
|
|
status = SrvIssueSetEventHandlerRequest(
|
|
Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
TDI_EVENT_RECEIVE_DATAGRAM,
|
|
(PVOID)SrvIpxNameDatagramHandler,
|
|
Endpoint
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenNonNetbiosAddress: set receive datagram event handler failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Claim the server name.
|
|
//
|
|
|
|
status = SrvIpxClaimServerName( Endpoint, NetbiosName );
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Open the server socket.
|
|
//
|
|
|
|
status = OpenIpxSocket(
|
|
&Endpoint->EndpointHandle,
|
|
&Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
DeviceName,
|
|
SMB_IPX_SERVER_SOCKET
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Create a number of free connections for the endpoint. These
|
|
// connections will be used to service Connect events.
|
|
//
|
|
// *** If we fail in an attempt to create a connection, but we can
|
|
// successfully create at least one, we keep the endpoint. The
|
|
// cleanup code below depends on this behavior.
|
|
//
|
|
|
|
for ( i = 0; i < SrvFreeConnectionMinimum; i++ ) {
|
|
|
|
status = SrvOpenConnection( Endpoint );
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenNonNetbiosAddress: SrvOpenConnection failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
if ( i == 0 ) {
|
|
goto cleanup;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Register the server Receive Datagram event handler.
|
|
//
|
|
|
|
status = SrvIssueSetEventHandlerRequest(
|
|
Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
TDI_EVENT_RECEIVE_DATAGRAM,
|
|
(PVOID)SrvIpxServerDatagramHandler,
|
|
Endpoint
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenNonNetbiosAddress: set receive datagram event handler failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Register the server Chained Receive Datagram event handler.
|
|
//
|
|
|
|
status = SrvIssueSetEventHandlerRequest(
|
|
Endpoint->FileObject,
|
|
&Endpoint->DeviceObject,
|
|
TDI_EVENT_CHAINED_RECEIVE_DATAGRAM,
|
|
(PVOID)SrvIpxServerChainedDatagramHandler,
|
|
Endpoint
|
|
);
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenNonNetbiosAddress: set chained receive datagram event handler failed: %X",
|
|
status,
|
|
NULL
|
|
);
|
|
SrvLogServiceFailure( SRV_SVC_NT_IOCTL_FILE, status );
|
|
goto cleanup;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
//
|
|
// Out-of-line error cleanup.
|
|
//
|
|
|
|
cleanup:
|
|
|
|
//
|
|
// Something failed. Clean up as appropriate.
|
|
//
|
|
|
|
if ( maxPktArray != NULL ) {
|
|
Endpoint->IpxMaxPacketSizeArray = NULL;
|
|
FREE_HEAP( maxPktArray );
|
|
}
|
|
if ( Endpoint->FileObject != NULL ) {
|
|
ObDereferenceObject( Endpoint->FileObject );
|
|
Endpoint->FileObject = NULL;
|
|
}
|
|
if ( Endpoint->EndpointHandle != NULL ) {
|
|
SRVDBG_RELEASE_HANDLE( Endpoint->EndpointHandle, "END", 14, Endpoint );
|
|
SrvNtClose( Endpoint->EndpointHandle, FALSE );
|
|
Endpoint->FileObject = NULL;
|
|
}
|
|
|
|
if ( Endpoint->NameSocketFileObject != NULL ) {
|
|
ObDereferenceObject( Endpoint->NameSocketFileObject );
|
|
Endpoint->NameSocketFileObject = NULL;
|
|
}
|
|
if ( Endpoint->NameSocketHandle != NULL ) {
|
|
SRVDBG_RELEASE_HANDLE( Endpoint->NameSocketHandle, "END", 14, Endpoint );
|
|
SrvNtClose( Endpoint->NameSocketHandle, FALSE );
|
|
Endpoint->NameSocketHandle = NULL;
|
|
}
|
|
|
|
return status;
|
|
|
|
} // OpenNonNetbiosAddress
|
|
|
|
|
|
NTSTATUS
|
|
OpenIpxSocket (
|
|
OUT PHANDLE Handle,
|
|
OUT PFILE_OBJECT *FileObject,
|
|
OUT PDEVICE_OBJECT *DeviceObject,
|
|
IN PVOID DeviceName,
|
|
IN USHORT Socket
|
|
)
|
|
{
|
|
NTSTATUS status;
|
|
ULONG length;
|
|
PFILE_FULL_EA_INFORMATION ea;
|
|
TA_IPX_ADDRESS ipxAddress;
|
|
OBJECT_ATTRIBUTES objectAttributes;
|
|
IO_STATUS_BLOCK iosb;
|
|
|
|
CHAR buffer[sizeof(FILE_FULL_EA_INFORMATION) +
|
|
TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
|
|
sizeof(TA_IPX_ADDRESS)];
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Build the IPX socket address.
|
|
//
|
|
|
|
length = FIELD_OFFSET( FILE_FULL_EA_INFORMATION, EaName[0] ) +
|
|
TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
|
|
sizeof(TA_IPX_ADDRESS);
|
|
ea = (PFILE_FULL_EA_INFORMATION)buffer;
|
|
|
|
ea->NextEntryOffset = 0;
|
|
ea->Flags = 0;
|
|
ea->EaNameLength = TDI_TRANSPORT_ADDRESS_LENGTH;
|
|
ea->EaValueLength = sizeof (TA_IPX_ADDRESS);
|
|
|
|
RtlCopyMemory( ea->EaName, StrTransportAddress, ea->EaNameLength + 1 );
|
|
|
|
//
|
|
// Create a copy of the NETBIOS address descriptor in a local
|
|
// first, in order to avoid alignment problems.
|
|
//
|
|
|
|
ipxAddress.TAAddressCount = 1;
|
|
ipxAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IPX;
|
|
ipxAddress.Address[0].AddressLength = sizeof (TDI_ADDRESS_IPX);
|
|
ipxAddress.Address[0].Address[0].Socket = Socket;
|
|
|
|
RtlCopyMemory(
|
|
&ea->EaName[ea->EaNameLength + 1],
|
|
&ipxAddress,
|
|
sizeof(TA_IPX_ADDRESS)
|
|
);
|
|
|
|
InitializeObjectAttributes( &objectAttributes, DeviceName, 0, NULL, NULL );
|
|
|
|
status = NtCreateFile (
|
|
Handle,
|
|
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, // desired access
|
|
&objectAttributes, // object attributes
|
|
&iosb, // returned status information
|
|
NULL, // block size (unused)
|
|
0, // file attributes
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, // share access
|
|
FILE_CREATE, // create disposition
|
|
0, // create options
|
|
buffer, // EA buffer
|
|
length // EA length
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
return status;
|
|
}
|
|
|
|
status = SrvVerifyDeviceStackSize(
|
|
*Handle,
|
|
TRUE,
|
|
FileObject,
|
|
DeviceObject,
|
|
NULL
|
|
);
|
|
|
|
if ( !NT_SUCCESS( status ) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"OpenIpxSocket: Verify Device Stack Size failed: %X\n",
|
|
status,
|
|
NULL
|
|
);
|
|
return status;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} // OpenIpxSocket
|
|
|
|
|
|
VOID
|
|
SrvPrepareReceiveWorkItem (
|
|
IN OUT PWORK_CONTEXT WorkContext,
|
|
IN BOOLEAN QueueItemToFreeList
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine initializes a Receive work item and optionally queues
|
|
it to a list anchored in the server FSD device object. The
|
|
transport receive event handler in the FSD dequeues work items from
|
|
this list and passes their associated IRPS to the transport
|
|
provider.
|
|
|
|
Arguments:
|
|
|
|
WorkContext - Supplies a pointer to the preallocated work context
|
|
block that represents the work item.
|
|
|
|
QueueItemToFreeList - If TRUE queue this work item on the receive
|
|
free queue.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSMB_HEADER header;
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvPrepareReceiveWorkItem entered\n" ));
|
|
|
|
//
|
|
// Set up pointers to the SMB header and parameters for the request
|
|
// and the response. Note that we currently write the response over
|
|
// the request. SMB processors must be able to handle this. We
|
|
// maintain separate request and response pointers so that we can
|
|
// use a separate buffer if necessary. Maintaining separate request
|
|
// and response parameter pointers also allows us to process AndX
|
|
// SMBs without having to pack the AndX commands as we go.
|
|
//
|
|
|
|
WorkContext->ResponseBuffer = WorkContext->RequestBuffer;
|
|
|
|
header = (PSMB_HEADER)WorkContext->RequestBuffer->Buffer;
|
|
|
|
WorkContext->RequestHeader = header;
|
|
WorkContext->RequestParameters = (PVOID)(header + 1);
|
|
|
|
WorkContext->ResponseHeader = header;
|
|
WorkContext->ResponseParameters = (PVOID)(header + 1);
|
|
|
|
//
|
|
// Set up the restart routine in the work context.
|
|
//
|
|
|
|
WorkContext->FsdRestartRoutine = SrvQueueWorkToFspAtDpcLevel;
|
|
WorkContext->FspRestartRoutine = SrvRestartReceive;
|
|
|
|
if ( QueueItemToFreeList ) {
|
|
|
|
//
|
|
// Queue the prepared receive work item to the FSD list.
|
|
//
|
|
|
|
GET_SERVER_TIME( WorkContext->CurrentWorkQueue, &WorkContext->Timestamp );
|
|
RETURN_FREE_WORKITEM( WorkContext );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Make the work item look like it's in use by setting its
|
|
// reference count to 1.
|
|
//
|
|
|
|
ASSERT( WorkContext->BlockHeader.ReferenceCount == 0 );
|
|
WorkContext->BlockHeader.ReferenceCount = 1;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
} // SrvPrepareReceiveWorkItem
|
|
|
|
|
|
VOID SRVFASTCALL
|
|
SrvRestartAccept (
|
|
IN OUT PWORK_CONTEXT WorkContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is the worker thread restart routine for Accept
|
|
requests. If the endpoint on which the connection was established
|
|
is no longer active, this routine disconnects the connection. This
|
|
is necessary because the connect indication handler cannot
|
|
atomically verify that the endpoint is active and install the active
|
|
connection. (This is because the handler runs at DPC level.)
|
|
|
|
This routine also checks the status of the TdiAccept. In case of
|
|
an error, it frees the connection.
|
|
|
|
If all is well, but the endpoint is short of free connections, a new
|
|
one is created.
|
|
|
|
Arguments:
|
|
|
|
WorkContext - Supplies a pointer to the work context block describing
|
|
server-specific context for the request.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCONNECTION connection;
|
|
PENDPOINT endpoint;
|
|
PIRP irp;
|
|
NTSTATUS status;
|
|
|
|
PAGED_CODE( );
|
|
|
|
IF_DEBUG(WORKER1) KdPrint(( " - SrvRestartAccept\n" ));
|
|
|
|
connection = WorkContext->Connection;
|
|
endpoint = WorkContext->Endpoint;
|
|
irp = WorkContext->Irp;
|
|
IF_DEBUG(TRACE2) {
|
|
KdPrint(( " connection %p, endpoint %p, IRP %p\n",
|
|
connection, endpoint, irp ));
|
|
}
|
|
|
|
//
|
|
// If the I/O request failed or was canceled, or if the endpoint
|
|
// block is closing, clean up.
|
|
//
|
|
|
|
ACQUIRE_LOCK( &SrvEndpointLock );
|
|
|
|
if ( irp->Cancel ||
|
|
!NT_SUCCESS(irp->IoStatus.Status) ||
|
|
(GET_BLOCK_STATE(endpoint) != BlockStateActive) ) {
|
|
|
|
RELEASE_LOCK( &SrvEndpointLock );
|
|
|
|
DEBUG {
|
|
KdPrint(( "SrvRestartAccept: Accept failed!" ));
|
|
if ( irp->Cancel ) {
|
|
KdPrint(( " I/O canceled\n" ));
|
|
} else if ( !NT_SUCCESS(irp->IoStatus.Status) ) {
|
|
KdPrint(( " I/O failed: %X\n", irp->IoStatus.Status ));
|
|
} else {
|
|
KdPrint(( " Endpoint no longer active\n" ));
|
|
}
|
|
}
|
|
|
|
//
|
|
// Close the connection. If the Accept succeeded, we need to
|
|
// issue a Disconnect.
|
|
//
|
|
|
|
#if SRVDBG29
|
|
if (irp->Cancel) {
|
|
UpdateConnectionHistory( "ACC1", endpoint, connection );
|
|
} else if (!NT_SUCCESS(irp->IoStatus.Status)) {
|
|
UpdateConnectionHistory( "ACC2", endpoint, connection );
|
|
} else {
|
|
UpdateConnectionHistory( "ACC3", endpoint, connection );
|
|
}
|
|
#endif
|
|
|
|
connection->DisconnectReason = DisconnectAcceptFailedOrCancelled;
|
|
SrvCloseConnection(
|
|
connection,
|
|
(BOOLEAN)(irp->Cancel || !NT_SUCCESS(irp->IoStatus.Status) ?
|
|
TRUE : FALSE) // RemoteDisconnect
|
|
);
|
|
|
|
} else {
|
|
|
|
PNBT_ADDRESS_PAIR_INFO AddressPairInfo;
|
|
UNICODE_STRING clientMachineName;
|
|
|
|
//
|
|
// The Accept worked, and the endpoint is still active. Create
|
|
// a new free connection, if necessary.
|
|
//
|
|
|
|
if ( endpoint->FreeConnectionCount < SrvFreeConnectionMinimum ) {
|
|
(VOID)SrvOpenConnection( endpoint );
|
|
}
|
|
|
|
RELEASE_LOCK( &SrvEndpointLock );
|
|
|
|
//
|
|
// Get the IP address of the client (if it has one)
|
|
//
|
|
AddressPairInfo = WorkContext->RequestBuffer->Buffer;
|
|
AddressPairInfo = (PNBT_ADDRESS_PAIR_INFO)(((ULONG_PTR)AddressPairInfo + 7) & ~7);
|
|
|
|
//
|
|
// Get the IP address of the client, if appropriate
|
|
//
|
|
status = SrvIssueTdiQuery( connection->FileObject,
|
|
&connection->DeviceObject,
|
|
(PCHAR)AddressPairInfo, sizeof( *AddressPairInfo ),
|
|
TDI_QUERY_ADDRESS_INFO
|
|
);
|
|
|
|
if( NT_SUCCESS( status ) &&
|
|
AddressPairInfo->AddressPair.TAAddressCount == 2 &&
|
|
AddressPairInfo->AddressPair.AddressIP.AddressType == TDI_ADDRESS_TYPE_IP ) {
|
|
|
|
PTCP_REQUEST_SET_INFORMATION_EX tcpSetInfo;
|
|
struct TCPKeepalive *keepAlive;
|
|
IO_STATUS_BLOCK iosb;
|
|
|
|
connection->ClientIPAddress = AddressPairInfo->AddressPair.AddressIP.Address.in_addr;
|
|
|
|
//
|
|
// We have an IP client. Set a reasonable keepalive interval.
|
|
//
|
|
tcpSetInfo = ALLOCATE_HEAP( sizeof(*tcpSetInfo) + sizeof( *keepAlive ), BlockTypeMisc );
|
|
|
|
if( tcpSetInfo != NULL ) {
|
|
|
|
RtlZeroMemory( tcpSetInfo, sizeof( *tcpSetInfo ) + sizeof( *keepAlive ) );
|
|
|
|
tcpSetInfo->ID.toi_entity.tei_entity = CO_TL_ENTITY;
|
|
tcpSetInfo->ID.toi_class = INFO_CLASS_PROTOCOL;
|
|
tcpSetInfo->ID.toi_type = INFO_TYPE_CONNECTION;
|
|
tcpSetInfo->ID.toi_id = TCP_SOCKET_KEEPALIVE_VALS;
|
|
|
|
tcpSetInfo->BufferSize = sizeof( *keepAlive );
|
|
keepAlive = (TCPKeepalive *)(&tcpSetInfo->Buffer[0]);
|
|
|
|
keepAlive->onoff = TRUE; // turn on keepalives
|
|
|
|
//
|
|
// keepalive time is the time to first keepalive transmission, by default it
|
|
// is 2 hours (7,200,000 milliseconds) for TCP. If there is no data transfer between
|
|
// client and server for keepalive time, the server will send first keepalive
|
|
// probe. Successive probes are determined by keepalive interval. If there is any
|
|
// data transfer, timer is reset to keepalive time.
|
|
//
|
|
// keepalive interval is the interval in milliseconds between keepalive transmissions
|
|
// until a response is received, by default it is 1000. Server sends a total of 10
|
|
// keepalive probes, keepalive interval apart, and if there is no response from the
|
|
// client, the connection is terminated.
|
|
//
|
|
keepAlive->keepalivetime = 2 * (60 * 1000); // 2 minutes
|
|
keepAlive->keepaliveinterval = 2 * 1000; // 2 seconds
|
|
|
|
//
|
|
// Set the keepalive values
|
|
//
|
|
(VOID)NtDeviceIoControlFile(
|
|
connection->PagedConnection->ConnectionHandle,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
&iosb,
|
|
IOCTL_NETBT_SET_TCP_CONNECTION_INFO,
|
|
tcpSetInfo, sizeof( *tcpSetInfo ) + sizeof( *keepAlive ),
|
|
NULL, 0
|
|
);
|
|
|
|
FREE_HEAP( tcpSetInfo );
|
|
}
|
|
|
|
} else {
|
|
|
|
connection->ClientIPAddress = 0;
|
|
}
|
|
|
|
//
|
|
// Convert the client machine name to unicode
|
|
//
|
|
|
|
clientMachineName.Buffer = connection->PagedConnection->ClientMachineName;
|
|
clientMachineName.MaximumLength =
|
|
(USHORT)(COMPUTER_NAME_LENGTH+1)*sizeof(WCHAR);
|
|
|
|
(VOID)RtlOemStringToUnicodeString(
|
|
&clientMachineName,
|
|
&connection->OemClientMachineNameString,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// Add the double backslashes to the length
|
|
//
|
|
|
|
connection->PagedConnection->ClientMachineNameString.Length =
|
|
(USHORT)(clientMachineName.Length + 2*sizeof(WCHAR));
|
|
|
|
}
|
|
|
|
SrvDereferenceWorkItem( WorkContext );
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvRestartAccept complete\n" ));
|
|
return;
|
|
|
|
} // SrvRestartAccept
|
|
|
|
|
|
VOID
|
|
SrvStartSend (
|
|
IN OUT PWORK_CONTEXT WorkContext,
|
|
IN PIO_COMPLETION_ROUTINE SendCompletionRoutine,
|
|
IN PMDL Mdl OPTIONAL,
|
|
IN ULONG SendOptions
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function starts a Send request. It is started as an
|
|
asynchronous I/O request. When the Send completes, it is delivered
|
|
via the I/O completion routine to the server FSD, which routes it to
|
|
the specified FsdRestartRoutine. (This may be
|
|
SrvQueueWorkToFspAtDpcLevel, which queues the work item to the FSP
|
|
at the FspRestartRoutine.)
|
|
|
|
Partial sends and chained sends are supported. A partial send is one
|
|
that is not the last segment of a "message" or "record". A chained
|
|
send is one made up of multiple virtually discontiguous buffers.
|
|
|
|
Arguments:
|
|
|
|
WorkContext - Supplies a pointer to a Work Context block. The
|
|
following fields of this structure must be valid:
|
|
|
|
TdiRequest
|
|
Irp (optional; actual address copied here)
|
|
Endpoint
|
|
Endpoint->FileObject
|
|
Endpoint->DeviceObject
|
|
Connection
|
|
Connection->ConnectionId
|
|
|
|
Mdl - Supplies a pointer to the first (or only) MDL describing the
|
|
data that is to be sent. To effect a chained send, the Next
|
|
pointer of each MDL in the chain must point to the next MDL;
|
|
the end of the chain is indicated by the NULL Next pointer.
|
|
|
|
The total length of the send is calculated by summing the
|
|
ByteCount fields of each MDL in the chain.
|
|
|
|
This parameter is optional. If it is omitted, a zero-length
|
|
message is sent.
|
|
|
|
SendOptions - Supplied TDI send options, which indicate whether this
|
|
send is the last (or only) in a "chain" of partial sends.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PTDI_REQUEST_KERNEL_SEND parameters;
|
|
PIO_STACK_LOCATION irpSp;
|
|
PIRP irp;
|
|
ULONG sendLength;
|
|
PDEVICE_OBJECT deviceObject;
|
|
PFILE_OBJECT fileObject;
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvStartSend entered\n" ));
|
|
|
|
ASSERT( !WorkContext->Endpoint->IsConnectionless );
|
|
|
|
//
|
|
// Set ProcessingCount to zero so this send cannot be cancelled.
|
|
// This is used together with setting the cancel flag to false below.
|
|
//
|
|
// WARNING: This still presents us with a tiny window where this
|
|
// send could be cancelled.
|
|
//
|
|
|
|
WorkContext->ProcessingCount = 0;
|
|
|
|
//
|
|
// Get the irp, device, and file objects
|
|
//
|
|
|
|
irp = WorkContext->Irp;
|
|
deviceObject = WorkContext->Connection->DeviceObject;
|
|
fileObject = WorkContext->Connection->FileObject;
|
|
|
|
CHECKIRP( irp );
|
|
|
|
if( irp->AssociatedIrp.SystemBuffer &&
|
|
(irp->Flags & IRP_DEALLOCATE_BUFFER) ) {
|
|
|
|
ExFreePool( irp->AssociatedIrp.SystemBuffer );
|
|
irp->Flags &= ~IRP_DEALLOCATE_BUFFER;
|
|
}
|
|
|
|
sendLength = WorkContext->ResponseBuffer->DataLength;
|
|
|
|
//
|
|
// Build the I/O request packet.
|
|
//
|
|
// *** Note that the connection block is not referenced to account
|
|
// for this I/O request. The WorkContext block already has a
|
|
// referenced pointer to the connection, and this pointer is not
|
|
// dereferenced until after the I/O completes.
|
|
//
|
|
|
|
ASSERT( irp->StackCount >= deviceObject->StackSize );
|
|
|
|
irp->Tail.Overlay.OriginalFileObject = fileObject;
|
|
irp->Tail.Overlay.Thread = WorkContext->CurrentWorkQueue->IrpThread;
|
|
DEBUG irp->RequestorMode = KernelMode;
|
|
//
|
|
// Get a pointer to the next stack location. This one is used to
|
|
// hold the parameters for the device I/O control request.
|
|
//
|
|
|
|
irpSp = IoGetNextIrpStackLocation( irp );
|
|
|
|
//
|
|
// Set up the completion routine.
|
|
//
|
|
|
|
IoSetCompletionRoutine(
|
|
irp,
|
|
SendCompletionRoutine,
|
|
(PVOID)WorkContext,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE
|
|
);
|
|
|
|
|
|
irpSp->FileObject = fileObject;
|
|
|
|
parameters = (PTDI_REQUEST_KERNEL_SEND)&irpSp->Parameters;
|
|
parameters->SendFlags = SendOptions;
|
|
parameters->SendLength = sendLength;
|
|
|
|
//
|
|
// For these two cases, InputBuffer is the buffered I/O "system
|
|
// buffer". Build an MDL for either read or write access,
|
|
// depending on the method, for the output buffer.
|
|
//
|
|
|
|
irp->MdlAddress = Mdl;
|
|
|
|
//
|
|
// If statistics are to be gathered for this work item, do so now.
|
|
//
|
|
|
|
UPDATE_STATISTICS(
|
|
WorkContext,
|
|
sendLength,
|
|
WorkContext->ResponseHeader->Command
|
|
);
|
|
|
|
#if DBG
|
|
if( sendLength >= sizeof( SMB_HEADER ) && sendLength <= 0xffff && Mdl ) {
|
|
|
|
PSMB_HEADER Smb = MmGetSystemAddressForMdl( Mdl );
|
|
|
|
if ( SmbGetAlignedUlong( (PULONG)Smb->Protocol ) == SMB_HEADER_PROTOCOL ) {
|
|
|
|
ULONG len;
|
|
PMDL tmpMdl;
|
|
|
|
//
|
|
// For debugging purposes, put extra data in the response smb. This will help us figure
|
|
// out what went wrong if the client detects an SMB format error
|
|
//
|
|
|
|
//
|
|
// Put the send length in PidHigh
|
|
//
|
|
SmbPutUshort( &Smb->PidHigh, (USHORT)sendLength );
|
|
|
|
//
|
|
// Put the overall MDL length in Pid. The transport is only supposed to transmit SendLength -- so
|
|
// this will help us figure out if the transport is sending too much data.
|
|
//
|
|
for( len = 0, tmpMdl = Mdl; tmpMdl != NULL; tmpMdl = tmpMdl->Next ) {
|
|
len += MmGetMdlByteCount( tmpMdl );
|
|
}
|
|
|
|
SmbPutUshort( &Smb->Pid, (USHORT)len );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// If we are doing security signatures, we need to sign this packet
|
|
//
|
|
if( sendLength &&
|
|
WorkContext->Connection &&
|
|
WorkContext->Connection->SmbSecuritySignatureActive == TRUE &&
|
|
WorkContext->NoResponseSmbSecuritySignature == FALSE ) {
|
|
|
|
SrvAddSmbSecuritySignature( WorkContext, Mdl, sendLength );
|
|
}
|
|
|
|
//
|
|
// Pass the request to the transport provider.
|
|
//
|
|
IF_DEBUG(TRACE2) {
|
|
KdPrint(( "SrvStartSend posting Send IRP %p\n", irp ));
|
|
}
|
|
|
|
//
|
|
// If SmbTrace is active and we're in a context where the SmbTrace
|
|
// shared section isn't accessible, send this off to the FSP.
|
|
//
|
|
|
|
WorkContext->Irp->Cancel = FALSE;
|
|
|
|
if ( SmbTraceActive[SMBTRACE_SERVER] ) {
|
|
|
|
if ((KeGetCurrentIrql() == DISPATCH_LEVEL) ||
|
|
(IoGetCurrentProcess() != SrvServerProcess) ) {
|
|
|
|
irpSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
|
|
irpSp->MinorFunction = TDI_SEND;
|
|
irp->AssociatedIrp.SystemBuffer = NULL;
|
|
irp->Flags = (ULONG)IRP_BUFFERED_IO;
|
|
|
|
WorkContext->Parameters2.StartSend.FspRestartRoutine =
|
|
WorkContext->FspRestartRoutine;
|
|
WorkContext->Parameters2.StartSend.SendLength = sendLength;
|
|
|
|
WorkContext->FspRestartRoutine = RestartStartSend;
|
|
SrvQueueWorkToFsp( WorkContext );
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
SMBTRACE_SRV( Mdl );
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Increment the pending operation count
|
|
//
|
|
InterlockedIncrement( &WorkContext->Connection->OperationsPendingOnTransport );
|
|
|
|
//
|
|
// Set the cancel flag to FALSE in case this was cancelled by
|
|
// the SrvSmbNtCancel routine.
|
|
//
|
|
|
|
if ( WorkContext->Endpoint->FastTdiSend ) {
|
|
|
|
INCREMENT_DEBUG_STAT2( SrvDbgStatistics.DirectSendsAttempted );
|
|
irpSp->MinorFunction = TDI_DIRECT_SEND;
|
|
DEBUG irpSp->DeviceObject = deviceObject;
|
|
IoSetNextIrpStackLocation( irp );
|
|
WorkContext->Endpoint->FastTdiSend( deviceObject, irp );
|
|
|
|
} else {
|
|
|
|
irpSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
|
|
irpSp->MinorFunction = TDI_SEND;
|
|
irp->AssociatedIrp.SystemBuffer = NULL;
|
|
irp->Flags = (ULONG)IRP_BUFFERED_IO;
|
|
|
|
(VOID)IoCallDriver( deviceObject, irp );
|
|
}
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvStartSend complete\n" ));
|
|
return;
|
|
|
|
} // SrvStartSend
|
|
|
|
VOID
|
|
SrvStartSend2 (
|
|
IN OUT PWORK_CONTEXT WorkContext,
|
|
IN PIO_COMPLETION_ROUTINE SendCompletionRoutine
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function starts a Send request. It is started as an
|
|
asynchronous I/O request. When the Send completes, it is delivered
|
|
via the I/O completion routine to the server FSD, which routes it to
|
|
the specified FsdRestartRoutine. (This may be
|
|
SrvQueueWorkToFspAtDpcLevel, which queues the work item to the FSP
|
|
at the FspRestartRoutine.)
|
|
|
|
Partial sends and chained sends are supported. A partial send is one
|
|
that is not the last segment of a "message" or "record". A chained
|
|
send is one made up of multiple virtually discontiguous buffers.
|
|
|
|
** This is identical to SrvStartSend except that the parameter mdl
|
|
is assumed to be ResponseBuffer->Mdl and sendOptions is assumed to be
|
|
0 **
|
|
|
|
Arguments:
|
|
|
|
WorkContext - Supplies a pointer to a Work Context block. The
|
|
following fields of this structure must be valid:
|
|
|
|
TdiRequest
|
|
Irp (optional; actual address copied here)
|
|
Endpoint
|
|
Endpoint->FileObject
|
|
Endpoint->DeviceObject
|
|
Connection
|
|
Connection->ConnectionId
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PTDI_REQUEST_KERNEL_SEND parameters;
|
|
PIO_STACK_LOCATION irpSp;
|
|
PIRP irp;
|
|
PDEVICE_OBJECT deviceObject;
|
|
PFILE_OBJECT fileObject;
|
|
|
|
PMDL mdl = WorkContext->ResponseBuffer->Mdl;
|
|
ULONG sendLength = WorkContext->ResponseBuffer->DataLength;
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvStartSend2 entered\n" ));
|
|
|
|
ASSERT( !WorkContext->Endpoint->IsConnectionless );
|
|
|
|
//
|
|
// Set ProcessingCount to zero so this send cannot be cancelled.
|
|
// This is used together with setting the cancel flag to false below.
|
|
//
|
|
// WARNING: This still presents us with a tiny window where this
|
|
// send could be cancelled.
|
|
//
|
|
|
|
WorkContext->ProcessingCount = 0;
|
|
|
|
//
|
|
// Get the irp, device, and file objects
|
|
//
|
|
|
|
irp = WorkContext->Irp;
|
|
deviceObject = WorkContext->Connection->DeviceObject;
|
|
fileObject = WorkContext->Connection->FileObject;
|
|
|
|
CHECKIRP( irp );
|
|
|
|
if( irp->AssociatedIrp.SystemBuffer &&
|
|
(irp->Flags & IRP_DEALLOCATE_BUFFER) ) {
|
|
|
|
ExFreePool( irp->AssociatedIrp.SystemBuffer );
|
|
irp->Flags &= ~IRP_DEALLOCATE_BUFFER;
|
|
}
|
|
|
|
//
|
|
// Build the I/O request packet.
|
|
//
|
|
// *** Note that the connection block is not referenced to account
|
|
// for this I/O request. The WorkContext block already has a
|
|
// referenced pointer to the connection, and this pointer is not
|
|
// dereferenced until after the I/O completes.
|
|
//
|
|
|
|
ASSERT( irp->StackCount >= deviceObject->StackSize );
|
|
|
|
irp->Tail.Overlay.OriginalFileObject = fileObject;
|
|
irp->Tail.Overlay.Thread = WorkContext->CurrentWorkQueue->IrpThread;
|
|
DEBUG irp->RequestorMode = KernelMode;
|
|
|
|
//
|
|
// Get a pointer to the next stack location. This one is used to
|
|
// hold the parameters for the device I/O control request.
|
|
//
|
|
|
|
irpSp = IoGetNextIrpStackLocation( irp );
|
|
|
|
//
|
|
// Set up the completion routine.
|
|
//
|
|
|
|
IoSetCompletionRoutine(
|
|
irp,
|
|
SendCompletionRoutine,
|
|
(PVOID)WorkContext,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE
|
|
);
|
|
|
|
irpSp->FileObject = fileObject;
|
|
|
|
parameters = (PTDI_REQUEST_KERNEL_SEND)&irpSp->Parameters;
|
|
parameters->SendFlags = 0;
|
|
parameters->SendLength = sendLength;
|
|
|
|
//
|
|
// For these two cases, InputBuffer is the buffered I/O "system
|
|
// buffer". Build an MDL for either read or write access,
|
|
// depending on the method, for the output buffer.
|
|
//
|
|
|
|
irp->MdlAddress = mdl;
|
|
|
|
//
|
|
// If statistics are to be gathered for this work item, do so now.
|
|
//
|
|
|
|
UPDATE_STATISTICS(
|
|
WorkContext,
|
|
sendLength,
|
|
WorkContext->ResponseHeader->Command
|
|
);
|
|
|
|
#if DBG
|
|
if( sendLength >= sizeof( SMB_HEADER ) && sendLength <= 0xffff && mdl ) {
|
|
|
|
PSMB_HEADER Smb = MmGetSystemAddressForMdl( mdl );
|
|
|
|
if ( SmbGetAlignedUlong( (PULONG)Smb->Protocol ) == SMB_HEADER_PROTOCOL ) {
|
|
|
|
ULONG len;
|
|
PMDL tmpMdl;
|
|
|
|
//
|
|
// For debugging purposes, put extra data in the response smb. This
|
|
// will help us figure out what went wrong if the client detects an
|
|
// SMB format error
|
|
//
|
|
|
|
//
|
|
// Put the send length in PidHigh
|
|
//
|
|
SmbPutUshort( &Smb->PidHigh, (USHORT)sendLength );
|
|
|
|
//
|
|
// Put the overall MDL length in Pid. The transport is only supposed
|
|
// to transmit SendLength -- so this will help us figure out if the
|
|
// transport is sending too much data.
|
|
//
|
|
for( len = 0, tmpMdl = mdl; tmpMdl != NULL; tmpMdl = tmpMdl->Next ) {
|
|
len += MmGetMdlByteCount( tmpMdl );
|
|
}
|
|
|
|
SmbPutUshort( &Smb->Pid, (USHORT)len );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// If we are doing security signatures, we need to sign this packet
|
|
//
|
|
if( sendLength &&
|
|
WorkContext->Connection &&
|
|
WorkContext->Connection->SmbSecuritySignatureActive == TRUE &&
|
|
WorkContext->NoResponseSmbSecuritySignature == FALSE ) {
|
|
|
|
SrvAddSmbSecuritySignature( WorkContext, mdl, sendLength );
|
|
}
|
|
|
|
//
|
|
// Pass the request to the transport provider.
|
|
//
|
|
|
|
IF_DEBUG(TRACE2) {
|
|
KdPrint(( "SrvStartSend2 posting Send IRP %p\n", irp ));
|
|
}
|
|
|
|
//
|
|
// If SmbTrace is active and we're in a context where the SmbTrace
|
|
// shared section isn't accessible, send this off to the FSP.
|
|
//
|
|
|
|
WorkContext->Irp->Cancel = FALSE;
|
|
|
|
if ( SmbTraceActive[SMBTRACE_SERVER] ) {
|
|
|
|
if ((KeGetCurrentIrql() == DISPATCH_LEVEL) ||
|
|
(IoGetCurrentProcess() != SrvServerProcess) ) {
|
|
|
|
irpSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
|
|
irpSp->MinorFunction = TDI_SEND;
|
|
irp->AssociatedIrp.SystemBuffer = NULL;
|
|
irp->Flags = (ULONG)IRP_BUFFERED_IO;
|
|
|
|
WorkContext->Parameters2.StartSend.FspRestartRoutine =
|
|
WorkContext->FspRestartRoutine;
|
|
WorkContext->Parameters2.StartSend.SendLength = sendLength;
|
|
|
|
WorkContext->FspRestartRoutine = RestartStartSend;
|
|
SrvQueueWorkToFsp( WorkContext );
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
SMBTRACE_SRV( mdl );
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Increment the pending operation count
|
|
//
|
|
InterlockedIncrement( &WorkContext->Connection->OperationsPendingOnTransport );
|
|
|
|
//
|
|
// Set the cancel flag to FALSE in case this was cancelled by
|
|
// the SrvSmbNtCancel routine.
|
|
//
|
|
|
|
if ( WorkContext->Endpoint->FastTdiSend ) {
|
|
|
|
INCREMENT_DEBUG_STAT2( SrvDbgStatistics.DirectSendsAttempted );
|
|
irpSp->MinorFunction = TDI_DIRECT_SEND;
|
|
DEBUG irpSp->DeviceObject = deviceObject;
|
|
IoSetNextIrpStackLocation( irp );
|
|
WorkContext->Endpoint->FastTdiSend( deviceObject, irp );
|
|
|
|
} else {
|
|
|
|
irpSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
|
|
irpSp->MinorFunction = TDI_SEND;
|
|
irp->AssociatedIrp.SystemBuffer = NULL;
|
|
irp->Flags = (ULONG)IRP_BUFFERED_IO;
|
|
|
|
(VOID)IoCallDriver( deviceObject, irp );
|
|
}
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvStartSend2 complete\n" ));
|
|
return;
|
|
|
|
} // SrvStartSend2
|
|
|
|
|
|
VOID SRVFASTCALL
|
|
RestartStartSend (
|
|
IN OUT PWORK_CONTEXT WorkContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
WorkContext - Supplies a pointer to a Work Context block.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PAGED_CODE( );
|
|
|
|
WorkContext->FspRestartRoutine =
|
|
WorkContext->Parameters2.StartSend.FspRestartRoutine;
|
|
|
|
SMBTRACE_SRV( WorkContext->Irp->MdlAddress );
|
|
|
|
//
|
|
// Increment the pending operation count
|
|
//
|
|
InterlockedIncrement( &WorkContext->Connection->OperationsPendingOnTransport );
|
|
|
|
//
|
|
// Set the cancel flag to FALSE in case this was cancelled by
|
|
// the SrvSmbNtCancel routine.
|
|
//
|
|
|
|
WorkContext->Irp->Cancel = FALSE;
|
|
(VOID)IoCallDriver(
|
|
IoGetNextIrpStackLocation( WorkContext->Irp )->DeviceObject,
|
|
WorkContext->Irp
|
|
);
|
|
|
|
IF_DEBUG(TRACE2) KdPrint(( "SrvRestartStartSend complete\n" ));
|
|
return;
|
|
|
|
} // RestartStartSend
|
|
|
|
ULONG
|
|
GetIpxMaxBufferSize(
|
|
PENDPOINT Endpoint,
|
|
ULONG AdapterNumber,
|
|
ULONG DefaultMaxBufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine computes the max buffer size the server negotiates
|
|
with the client. It takes the smaller of DefaultMaxBufferSize
|
|
and the max packet length returned by the ipx transport.
|
|
|
|
Arguments:
|
|
|
|
Endpoint - pointer to the endpoint corresponding to the ipx transport
|
|
AdapterNumber - the adapter number for which the max buffer size is to
|
|
be computed for.
|
|
DefaultMaxBufferSize - the maximum size that can be returned by this
|
|
routine.
|
|
|
|
Return Value:
|
|
|
|
The max buffer size to be negotiated by the server.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
ULONG maxBufferSize;
|
|
PNWLINK_ACTION action;
|
|
PIPX_ADDRESS_DATA ipxAddressData;
|
|
UCHAR buffer[sizeof(NWLINK_ACTION) + sizeof(IPX_ADDRESS_DATA) - 1];
|
|
|
|
PAGED_CODE( );
|
|
|
|
action = (PNWLINK_ACTION)buffer;
|
|
|
|
//
|
|
// Verify that the adapter number is within bounds
|
|
//
|
|
|
|
if ( AdapterNumber > Endpoint->MaxAdapters ) {
|
|
return DefaultMaxBufferSize;
|
|
}
|
|
|
|
//
|
|
// If value in array is non-zero, then this is not a wan link.
|
|
// Use that value.
|
|
//
|
|
|
|
if ( Endpoint->IpxMaxPacketSizeArray[AdapterNumber-1] != 0 ) {
|
|
|
|
maxBufferSize = MIN(
|
|
Endpoint->IpxMaxPacketSizeArray[AdapterNumber-1],
|
|
DefaultMaxBufferSize
|
|
);
|
|
|
|
return (maxBufferSize & ~3);
|
|
}
|
|
|
|
//
|
|
// This is a wan link, query the max packet size.
|
|
//
|
|
|
|
action->Header.TransportId = 'XPIM'; // "MIPX"
|
|
action->Header.ActionCode = 0;
|
|
action->Header.Reserved = 0;
|
|
action->OptionType = NWLINK_OPTION_ADDRESS;
|
|
action->BufferLength = sizeof(action->Option) + sizeof(IPX_ADDRESS_DATA);
|
|
action->Option = MIPX_GETCARDINFO2;
|
|
ipxAddressData = (PIPX_ADDRESS_DATA)action->Data;
|
|
|
|
ipxAddressData->adapternum = AdapterNumber - 1;
|
|
|
|
status = SrvIssueTdiAction(
|
|
Endpoint->NameSocketFileObject,
|
|
&Endpoint->NameSocketDeviceObject,
|
|
(PCHAR)action,
|
|
sizeof(NWLINK_ACTION) + sizeof(IPX_ADDRESS_DATA) - 1
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
return DefaultMaxBufferSize;
|
|
}
|
|
|
|
ASSERT( ipxAddressData->wan );
|
|
|
|
maxBufferSize = MIN(
|
|
(ULONG)ipxAddressData->maxpkt,
|
|
DefaultMaxBufferSize
|
|
);
|
|
|
|
return (maxBufferSize & ~3);
|
|
|
|
} // GetMaxIpxPacketSize
|
|
|
|
|
|
VOID
|
|
SrvpNotifyChangesToNetBt(
|
|
IN TDI_PNP_OPCODE PnPOpcode,
|
|
IN PUNICODE_STRING DeviceName,
|
|
IN PWSTR MultiSZBindList)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine should not be part of srv. It has been introduced into this
|
|
component to overcome current limitations in NetBt. The NetBt transport
|
|
exposes two kinds of devices -- the traditional NetBt device and the
|
|
new non Netbios device which make use of the NetBt framing code without the
|
|
name resolution aspects of it. The current implementation in NetBt exposes
|
|
the former devices on a per adapter basis while the second category of device
|
|
is exposed on a global basis ( one for all the adapters ). This poses
|
|
problems in disabling/enabling srv on a given adapter.
|
|
|
|
The correct solution is to expose the second category of devices on a per
|
|
adapter basis. Till it is done this workaround is reqd. With this workaround
|
|
whenever the server is notified of any changes to the binding string it turns
|
|
around and notifies the NetBt transport about these changes.
|
|
|
|
This routine is based upon the following assumptions ...
|
|
|
|
1) The notification from TDI is not done at raised IRQL.
|
|
|
|
2) The thread on which this notification occurs has enough access rights.
|
|
|
|
3) The notification to NetBt is done asynchronously with srv's reaction
|
|
to the change. The srv handles the PNP notification by passing it off to
|
|
user mode and have it come through the server service.
|
|
|
|
Arguments:
|
|
|
|
PNPOpcode - the PNP opcode
|
|
|
|
DeviceName - the transport for which this opcode is intended
|
|
|
|
MultiSZBindList - the binding list
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
HANDLE NetbioslessSmbHandle;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
UNICODE_STRING NetbioslessSmbName = {36,36, L"\\device\\NetbiosSmb"};
|
|
|
|
InitializeObjectAttributes(
|
|
&ObjectAttributes,
|
|
&NetbioslessSmbName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL );
|
|
|
|
Status = ZwCreateFile (
|
|
&NetbioslessSmbHandle,
|
|
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, // desired access
|
|
&ObjectAttributes, // object attributes
|
|
&IoStatusBlock, // returned status information
|
|
NULL, // block size (unused)
|
|
0, // file attributes
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, // share access
|
|
FILE_CREATE, // create disposition
|
|
0, // create options
|
|
NULL, // EA buffer
|
|
0 // EA length
|
|
);
|
|
|
|
if ( NT_SUCCESS(Status) ) {
|
|
NETBT_SMB_BIND_REQUEST NetBtNotificationParameters;
|
|
|
|
NetBtNotificationParameters.RequestType = SMB_SERVER;
|
|
NetBtNotificationParameters.PnPOpCode = PnPOpcode;
|
|
NetBtNotificationParameters.pDeviceName = DeviceName;
|
|
NetBtNotificationParameters.MultiSZBindList = MultiSZBindList;
|
|
|
|
Status = ZwDeviceIoControlFile(
|
|
NetbioslessSmbHandle,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&IoStatusBlock,
|
|
IOCTL_NETBT_SET_SMBDEVICE_BIND_INFO,
|
|
&NetBtNotificationParameters,
|
|
sizeof(NetBtNotificationParameters),
|
|
NULL,
|
|
0);
|
|
|
|
IF_DEBUG( ERRORS ) {
|
|
KdPrint(("NtFsControlFile %wZ in SrvpNotifyChangesToNetBt status %X\n", &NetbioslessSmbName, Status ));
|
|
}
|
|
|
|
Status = ZwClose(NetbioslessSmbHandle);
|
|
|
|
IF_DEBUG( ERRORS ) {
|
|
KdPrint(("NtCloseFile %wZ in SrvpNotifyChangesToNetBt status %X\n", &NetbioslessSmbName, Status ));
|
|
}
|
|
} else {
|
|
IF_DEBUG( ERRORS ) {
|
|
KdPrint(("NtCreateFile %wZ in SrvpNotifyChangesToNetBt status %X\n", &NetbioslessSmbName, Status ));
|
|
}
|
|
}
|
|
}
|
|
|
|
|