/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corp., 1993 **/
/**********************************************************************/
/*
VxdIsol.c
This file roughly corresponds to ntisol.c and contains VxD specific
portions of the NBT driver
FILE HISTORY:
Johnl 15-Apr-1993 Created
*/
#include <nbtprocs.h>
#include <nbtioctl.h>
//
// Used by VxdFindClientElement
//
enum CLIENT_TYPE
{
CLIENT_BC,
CLIENT_LOCAL
} ;
//
// Counts the number of items in the list Head
//
// Assumes pEntry is defined in the procedure
//
#define COUNT_ELEMENTS( Head, Count ) \
for ( pEntry = (Head).Flink ; \
pEntry != &(Head); \
pEntry = pEntry->Flink ) \
{ \
(Count)++ ; \
}
extern BOOLEAN CachePrimed;
extern BOOL fInInit;
//
// this is used for AdapterStatus and FindName calls because we need to retain
// the info, so can't have it as a local var (both these calls are synchronous
// so need not worry about stomping on this memory)
//
TA_NETBIOS_ADDRESS tanb_global ;
NCBERR VxdNameToClient( tDEVICECONTEXT * pDeviceContext,
CHAR * pName,
UCHAR * pNameNum,
tCLIENTELE * * ppClientEle ) ;
//-------------------------------------------------------------------------
//
// Allocates and frees the SESS_SETUP_CONTEXT contents (not the context
// itself).
//
TDI_STATUS AllocSessSetupContext( PSESS_SETUP_CONTEXT pSessSetupContext,
BOOL fListenOnStar ) ;
void FreeSessSetupContext( PSESS_SETUP_CONTEXT pSessSetupContext ) ;
NCBERR VxdInitSessionSetup( tDEVICECONTEXT * pDeviceContext,
TDI_REQUEST * pRequest,
PSESS_SETUP_CONTEXT * ppSessSetupContext,
NCB * pNCB ) ;
BOOL VxdCopySessionStatus( tDEVICECONTEXT * pDeviceContext,
tCLIENTELE * pClientEle,
PSESSION_HEADER pSessionHeader,
PSESSION_BUFFER * ppSessionBuff,
ULONG * pRemainingSize ) ;
//-------------------------------------------------------------------------
//
// NCB Reset context structures
//
//
typedef struct
{
//
// Number of active sessions we are waiting on to close
//
int cActiveSessions ;
//
// Number of active names we have to wait to finish deregistering
//
int cActiveNames ;
//
// NCB Error if reset failed (failed to resize session table for example)
//
UCHAR errncb ;
} RESET_CONTEXT, *PRESET_CONTEXT ;
NCBERR VxdResetContinue( tDEVICECONTEXT * pDeviceContext, NCB * pNCB ) ;
#define DISCONNECT_TIMEOUT 15000
//-------------------------------------------------------------------------
//
// Last valid NCB name and logical session number
//
#define MAX_NCB_NUMS 254
#define ANY_NAME 255
NTSTATUS
PostInit_Proc();
//******************* Pageable Routine Declarations ****************
#ifdef ALLOC_PRAGMA
#pragma CTEMakePageable(PAGE, PostInit_Proc)
#endif
//******************* Pageable Routine Declarations ****************
/*******************************************************************
NAME: VxdDgramSend
SYNOPSIS: Vxd specific Send Datagram code
ENTRY: pDeviceContext - Device to send the datagram on
pNCB - NCB that contains the datagram data/dest
RETURNS: NT_SUCCESS if successful, error otherwise
NOTES:
HISTORY:
Johnl 19-Apr-1993 Created
********************************************************************/
NCBERR VxdDgramSend( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
NTSTATUS status;
LONG lSentLength;
TDI_REQUEST Request;
tDGRAMHDR *pDgramHdr;
tCLIENTELE *pClientEle;
char *pName ;
NCBERR errNCB ;
TDI_CONNECTION_INFORMATION SendInfo ;
TA_NETBIOS_ADDRESS tanb ;
errNCB = VxdFindClientElement( pDeviceContext,
pNCB->ncb_num,
&pClientEle,
CLIENT_LOCAL ) ;
if ( errNCB )
{
DbgPrint("VxdDgramSend: VxdFindClientElement Failed\r\n") ;
return errNCB ;
}
ASSERT( pClientEle->Verify == NBT_VERIFY_CLIENT ) ;
if ( pClientEle->fDeregistered )
return NRC_NOWILD ;
//
// If broadcast, then use "*" for destination name
//
if ( (pNCB->ncb_command & ~ASYNCH) == NCBDGSENDBC )
{
//
// Name must stay valid after call
//
static char BcastName[NCBNAMSZ] = "* " ;
pName = BcastName ;
}
else
{
pName = pNCB->ncb_callname ;
}
//
// Initialize the transport address
//
// It's Ok to pass automatic variables to NbtSendDatagram,
// the necessary data is copied out before returning
//
InitNBTDIConnectInfo( &SendInfo, &tanb, pName ) ;
Request.Handle.AddressHandle = pClientEle;
status = NbtSendDatagram(
&Request,
&SendInfo,
pNCB->ncb_length,
&lSentLength,
pNCB->ncb_buffer, // user data
pDeviceContext,
(PIRP) pNCB );
errNCB = MapTDIStatus2NCBErr( status ) ;
if ( errNCB != NRC_GOODRET && errNCB != NRC_PENDING)
{
DbgPrint("VxdDgramSend - returning ncb status 0x" ) ;
DbgPrintNum( (ULONG) errNCB ) ;
DbgPrint("\r\n") ;
}
else
{
//
// Since NbtSendDatagram always buffers datagram sends, we need to
// complete the NCB here since NbtSendDatagram will not complete
// the data gram
//
CTEIoComplete(pNCB,status,pNCB->ncb_length);
}
return errNCB ;
}
/*******************************************************************
NAME: VxdDgramReceive
SYNOPSIS: Vxd specific Datagram Receive code
ENTRY: pDeviceContext - Device to send the datagram on
pNCB - NCB that contains the datagram data/dest
RETURNS: NT_SUCCESS if successful, error otherwise
NOTES: For a receive datagram, the name number is who we want to
receive to, and the call name will be set to who we
received from. The name number may be 0xff to indicate
receive to any name from anyone.
HISTORY:
Johnl 19-Apr-1993 Created
********************************************************************/
NCBERR VxdDgramReceive( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
TDI_REQUEST Request;
ULONG ReceivedLength;
tCLIENTELE * pClientEle ;
NCBERR errNCB ;
TDI_CONNECTION_INFORMATION RcvInfo ;
TDI_CONNECTION_INFORMATION SendInfo ;
NTSTATUS status ;
if ( pNCB->ncb_num != ANY_NAME )
{
//
// For the RcvBC case, this just confirms the ncb_num is valid, the
// pClientEle is replaced with the broadcast client element (mif
// tests invalid ncb_nums with broadcasts).
//
if ( errNCB = VxdFindClientElement( pDeviceContext,
pNCB->ncb_num,
&pClientEle,
CLIENT_LOCAL ) )
{
return errNCB ;
}
if ( pClientEle->fDeregistered )
return NRC_NOWILD ;
if ( (pNCB->ncb_command & ~ASYNCH) == NCBDGRECVBC )
{
if ( errNCB = VxdFindClientElement( pDeviceContext,
pNCB->ncb_num,
&pClientEle,
CLIENT_BC ) )
if ( errNCB )
return NRC_NAMERR ;
}
Request.Handle.AddressHandle = pClientEle ;
status = NbtReceiveDatagram(
&Request,
NULL, //pTdiRequest->ReceiveDatagramInformation,
NULL, //pTdiRequest->ReturnDatagramInformation,
pNCB->ncb_length,
&ReceivedLength,
pNCB->ncb_buffer, // user data
pDeviceContext,
pNCB );
if ( status == STATUS_PENDING )
return NRC_PENDING ;
}
else
{
tRCVELE * pRcvEle = (tRCVELE *)CTEAllocMem(sizeof(tRCVELE));
if (!pRcvEle)
return NRC_NORES ;
pRcvEle->pIrp = pNCB ;
pRcvEle->ReceiveInfo = NULL ;
pRcvEle->ReturnedInfo = NULL;
pRcvEle->RcvLength = pNCB->ncb_length ;
pRcvEle->pRcvBuffer = pNCB->ncb_buffer ;
InsertTailList( &pDeviceContext->RcvDGAnyFromAnyHead,
&pRcvEle->Linkage );
return NRC_PENDING ;
}
//
// Status should always be pending or error
//
ASSERT( status != TDI_SUCCESS ) ;
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdCall
SYNOPSIS: Attempts to setup a session with the corresponding listen
ENTRY: pDeviceContext - Adapter to call on
pNCB - NCB that contains the call command
RETURNS:
NOTES: Before we can do the listen we must first open the
connection and associate the address.
The reserve field of the NCB is used as a SESS_SETUP_CONTEXT
structure
HISTORY:
Johnl 14-May-1993 Created
********************************************************************/
NCBERR VxdCall( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
NTSTATUS status;
NCBERR errNCB ;
TDI_REQUEST Request;
PSESS_SETUP_CONTEXT pSessSetupContext = NULL ;
if ( ( pNCB->ncb_name[0] == '*' )
|| ( pNCB->ncb_callname[0] == '*' ) )
{
return NRC_NOWILD ;
}
if ( errNCB = VxdInitSessionSetup( pDeviceContext,
&Request,
&pSessSetupContext,
pNCB ))
{
return errNCB ;
}
status = NbtConnect( &Request,
0, // Use system timeout
pSessSetupContext->pRequestConnect,
pSessSetupContext->pReturnConnect,
pNCB
);
if ( !NT_SUCCESS(status) )
{
VxdTearDownSession( pDeviceContext,
(tCONNECTELE*)Request.Handle.ConnectionContext,
pSessSetupContext,
NULL ) ;
}
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdSend
SYNOPSIS: Sends a netbios request
ENTRY: pDeviceContext - Adapter to call on
pNCB - NCB that contains the send command
EXIT:
RETURNS:
NOTES: pNCB->ncb_lsn - Session number to Send on
pNCB->ncb_reserved will contain a pointer to a tSESSIONHDR
for this NCB (freed in VxdIoComplete).
No-ack sends are treated like normal sends.
HISTORY:
Johnl 8-Jun-1993 Created
********************************************************************/
NCBERR VxdSend( tDEVICECONTEXT *pDeviceContext, NCB * pNCB )
{
NTSTATUS status ;
NCBERR errNCB ;
tCONNECTELE * pConnEle;
CTELockHandle OldIrq;
tLOWERCONNECTION * pLowerConn;
tSESSIONHDR * pHdr=NULL;
tBUFFERCHAINSEND SendBuff ;
TDI_REQUEST Request ;
ULONG SentSize ;
ULONG SendFlags = 0 ;
PSEND_CONTEXT pSendCont = (PSEND_CONTEXT) pNCB->ncb_reserve ;
ASSERT( sizeof(SEND_CONTEXT) <=
sizeof(pNCB->ncb_reserve)+sizeof(pNCB->ncb_event)) ;
if ( errNCB = VxdFindConnectElement( pDeviceContext,
pNCB,
&pConnEle ))
{
return errNCB ;
}
ASSERT( pConnEle->Verify == NBT_VERIFY_CONNECTION ) ;
pLowerConn = (tLOWERCONNECTION *)pConnEle->pLowerConnId ;
// check the state of the connection
if (pConnEle->state == NBT_SESSION_UP)
{
if ( GetSessionHdr( &pHdr ))
{
//
// If this is part of a chain send, set up the 2nd buffer
//
if ( ((pNCB->ncb_command & ~ASYNCH) == NCBCHAINSEND) ||
((pNCB->ncb_command & ~ASYNCH) == NCBCHAINSENDNA) )
{
SendBuff.Length2 = *((WORD*)pNCB->ncb_callname) ;
SendBuff.pBuffer2 = *((PUCHAR*)(pNCB->ncb_callname+2)) ;
SendFlags |= CHAIN_SEND_FLAG ;
DbgPrint("VxdSend - Doing chain send\r\n") ;
}
else
{
SendBuff.Length2 = 0 ;
}
pHdr->Type = NBT_SESSION_MESSAGE ;
pHdr->Flags = NBT_SESSION_FLAGS ;
pHdr->UlongLength = htonl(pNCB->ncb_length + SendBuff.Length2) ;
pSendCont->pHdr = pHdr ;
//
// Only sends that can time out are put on the timeout list
//
if ( (pSendCont->STO = pConnEle->STO) != NCB_INFINITE_TIME_OUT )
{
InsertTailList( &NbtConfig.SendTimeoutHead, &pSendCont->ListEntry ) ;
}
SendBuff.tBuff.pDgramHdr = pHdr ;
SendBuff.tBuff.HdrLength = sizeof( *pHdr ) ;
SendBuff.tBuff.pBuffer = pNCB->ncb_buffer ;
SendBuff.tBuff.Length = pNCB->ncb_length ;
#ifdef DEBUG
if ( !pNCB->ncb_length ) // Make sure 0 length buffers do
SendBuff.tBuff.pBuffer = NULL ; // the right thing
#endif
Request.RequestNotifyObject = VxdIoComplete ;
Request.RequestContext = pNCB ;
Request.Handle.ConnectionContext = pConnEle->pLowerConnId->pFileObject ;
status = TdiSend( &Request,
0,
(USHORT) SendBuff.tBuff.HdrLength +
SendBuff.tBuff.Length + SendBuff.Length2,
&SentSize,
(tBUFFER*) &SendBuff,
SendFlags ) ;
ASSERT( !NT_SUCCESS( status ) ||
(SentSize == (SendBuff.tBuff.HdrLength +
SendBuff.tBuff.Length + SendBuff.Length2)) ) ;
pLowerConn->BytesSent += SentSize;
return NRC_PENDING ;
//
// if TdiSend fails, it will call the completion routine (directly
// or eventually, Vxdiocomplete) which will remove this from the list
// so, don't remove it here also or we overwrite redir's code segment!!
//
// //
// // Remove from the timeout list if an error occurred
// //
// if ( !NT_SUCCESS( status ) &&
// pConnEle->STO != NCB_INFINITE_TIME_OUT )
// {
// RemoveEntryList( &pSendCont->ListEntry ) ;
// }
}
else
{
status = STATUS_INSUFFICIENT_RESOURCES ;
goto ErrorExit ;
}
}
else
{
status = TDI_INVALID_CONNECTION ;
}
if ( !NT_SUCCESS( status ) )
goto ErrorExit ;
return MapTDIStatus2NCBErr( status ) ;
ErrorExit:
if ( pHdr )
FreeSessionHdr( pHdr ) ;
DbgPrint("VxdSend returning NCB error: 0x") ;
DbgPrintNum( MapTDIStatus2NCBErr( status ) ) ; DbgPrint("\r\n") ;
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdReceiveAny
SYNOPSIS: Handles a request to accept data from any open session
ENTRY: pDeviceContext - Adapter to call on
pNCB - NCB that contains the receive command
EXIT:
RETURNS:
NOTES: pNCB->ncb_lsn - Session set to who to receive from if
an indication is found
The most common case (for WFW rdr) is to Receive on
a particular name number w/o any waiting connections
HISTORY:
Johnl 8-Jun-1993 Created
********************************************************************/
NCBERR VxdReceiveAny( tDEVICECONTEXT *pDeviceContext, NCB * pNCB )
{
NTSTATUS status;
NCBERR errNCB ;
tLOWERCONNECTION * pLowerConn;
tCLIENTELE * pClientEle = NULL ;
PLIST_ENTRY pEntry, pHead ;
#ifdef DEBUG
DbgPrint("VxdReceiveAny posted: Ncb length, Rcv Buff Address: 0x") ;
DbgPrintNum( pNCB->ncb_length ) ; DbgPrint(", 0x") ;
DbgPrintNum( (ULONG) pNCB->ncb_buffer ) ; DbgPrint("\r\n") ;
#endif
//
// If they've given us a name number to receive on, find it
//
if ( pNCB->ncb_num != ANY_NAME )
{
if ( errNCB = VxdFindClientElement( pDeviceContext,
pNCB->ncb_num,
&pClientEle,
CLIENT_LOCAL ) )
{
DbgPrint("VxdReceiveAny - Couldn't find name number\r\n") ;
return errNCB ;
}
if ( !pClientEle->fDeregistered )
{
if ( IsListEmpty( &pDeviceContext->PartialRcvHead ) )
{
goto QueueRcv ;
}
}
else
{
return NRC_NOWILD ;
}
}
else
{
if ( IsListEmpty( &pDeviceContext->PartialRcvHead ) )
{
goto QueueRcv ;
}
}
//
// Scan for all active sessions looking for one that has indicated
// data that will satisfy this ReceiveAny
//
pHead = &pDeviceContext->PartialRcvHead ;
pEntry = pHead->Flink ;
ASSERT( pEntry );
while ( pEntry != pHead )
{
DbgPrint("VxdReceiveAny: scanning lower connections for partial receive\r\n") ;
pLowerConn = CONTAINING_RECORD( pEntry, tLOWERCONNECTION, PartialRcvList ) ;
ASSERT( pLowerConn->State < NBT_DISCONNECTING );
//
// If Receive any from any, then the first one we find
// will work, otherwise compare the names
//
if ( pNCB->ncb_num == ANY_NAME )
break ;
else
{
if ( CTEMemCmp( pClientEle->pAddress->pNameAddr->Name,
pLowerConn->pUpperConnection->pClientEle->
pAddress->pNameAddr->Name,
NETBIOS_NAME_SIZE ) == NETBIOS_NAME_SIZE )
{
break ;
}
}
pEntry = pEntry->Flink ;
}
if ( pEntry != pHead )
{
DbgPrint("VxdReceiveAny: Found partial receive, calling VxdReceive\r\n") ;
ASSERT (pLowerConn->fOnPartialRcvList == TRUE);
RemoveEntryList( &pLowerConn->PartialRcvList ) ;
pLowerConn->fOnPartialRcvList = FALSE;
InitializeListHead(&pLowerConn->PartialRcvList);
//
// Now find the session number this receive is taking place on
//
if ( errNCB = VxdFindLSN( pDeviceContext,
pLowerConn->pUpperConnection,
&pNCB->ncb_lsn ))
{
return errNCB ;
}
return VxdReceive( pDeviceContext, pNCB, FALSE ) ;
}
else
{
//
// Nothing active so queue it
//
PRCV_CONTEXT prcvCont ;
QueueRcv:
if ( !GetRcvContext( &prcvCont ))
return NRC_NORESOURCES ;
InitRcvContext( prcvCont, NULL, pNCB ) ;
InitNDISBuff( &prcvCont->ndisBuff,
pNCB->ncb_buffer,
pNCB->ncb_length,
NULL ) ;
prcvCont->usFlags = TDI_RECEIVE_NORMAL;
*((PRCV_CONTEXT*)&pNCB->ncb_reserve) = prcvCont ;
if ( pNCB->ncb_num != ANY_NAME )
{
ASSERT( pClientEle != NULL ) ;
InsertTailList( &pClientEle->RcvAnyHead,
&prcvCont->ListEntry ) ;
return NRC_PENDING ;
}
else
{
InsertTailList( &pDeviceContext->RcvAnyFromAnyHead,
&prcvCont->ListEntry ) ;
}
}
return NRC_PENDING ;
}
/*******************************************************************
NAME: VxdReceive
SYNOPSIS: Worker for VxdReceive and VxdReceiveAny
ENTRY: pDeviceContext - Adapter to call on
pNCB - NCB that contains the receive command
fReceive - TRUE if we got here via a Receive ncb
- FALSE if we got here via a ReceiveAny ncb
EXIT:
RETURNS:
NOTES: pNCB->ncb_reserved will contain a pointer to a RCV_CONTEXT
for this NCB.
VxdReceiveAny calls this on an element where state==NBT_SESSION_UP
and StateRcv == PARTIAL_RCV, thus the receive context should
never be added to pConnele->RcvHead.
HISTORY:
Johnl 8-Jun-1993 Created
********************************************************************/
NCBERR VxdReceive( tDEVICECONTEXT * pDeviceContext, NCB * pNCB, BOOL fReceive )
{
NTSTATUS status;
NCBERR errNCB ;
tCONNECTELE * pConnEle;
CTELockHandle OldIrq;
tLOWERCONNECTION * pLowerConn;
PRCV_CONTEXT prcvCont ;
if ( errNCB = VxdFindConnectElement( pDeviceContext,
pNCB,
&pConnEle ))
{
return errNCB ;
}
ASSERT( pConnEle->Verify == NBT_VERIFY_CONNECTION ) ;
pLowerConn = pConnEle->pLowerConnId;
DbgPrint("VxdReceive posted: Ncb length, Rcv buff Address: 0x") ;
DbgPrintNum( pNCB->ncb_length ) ; DbgPrint(", 0x") ;
DbgPrintNum( (ULONG) pNCB->ncb_buffer ) ; DbgPrint("\r\n") ;
//
// Setup the receive context tracker
//
if ( GetRcvContext( &prcvCont ))
{
InitRcvContext( prcvCont, pLowerConn, pNCB ) ;
InitNDISBuff( &prcvCont->ndisBuff,
pNCB->ncb_buffer,
pNCB->ncb_length,
NULL ) ;
prcvCont->RTO = pConnEle->RTO ;
prcvCont->usFlags = TDI_RECEIVE_NORMAL;
*((PRCV_CONTEXT*)&pNCB->ncb_reserve) = prcvCont ;
//
// If data is not available, queue the request, otherwise get the
// data
//
if ( pLowerConn->StateRcv != PARTIAL_RCV )
{
//
// Make sure a RcvAny didn't get to here
//
ASSERT( (pNCB->ncb_command & ~ASYNCH)== NCBRECV ) ;
if ( !pConnEle->Orig && fReceive )
{
prcvCont->usFlags = TDI_RECEIVE_NO_RESPONSE_EXP ;
}
InsertTailList(&pConnEle->RcvHead,
&prcvCont->ListEntry);
return NRC_PENDING ;
}
else
{
TDI_REQUEST Request ;
UINT cbReceiveLength ;
static USHORT usFlags = TDI_RECEIVE_NORMAL ;
DbgPrint("VxdReceive:A Rcv Buffer posted when data in the transport, InXport= 0x") ;
DbgPrintNum( pConnEle->BytesInXport ) ;
DbgPrint("\r\n") ;
pConnEle->OffsetFromStart = 0 ;
Request.RequestNotifyObject = CompletionRcv ;
Request.RequestContext = prcvCont ;
Request.Handle.ConnectionContext = pLowerConn->pFileObject ;
pConnEle->pIrpRcv = NULL ; // Buffer in the transport
pLowerConn->StateRcv = FILL_IRP ;
RemoveEntryList( &pLowerConn->PartialRcvList ) ;
pLowerConn->fOnPartialRcvList = FALSE;
InitializeListHead(&pLowerConn->PartialRcvList);
cbReceiveLength = min( pNCB->ncb_length,
pConnEle->TotalPcktLen-pConnEle->BytesRcvd ) ;
//
// Don't pass zero length buffers to the transport
//
if ( !cbReceiveLength )
{
CompletionRcv( prcvCont, STATUS_SUCCESS, 0 ) ;
return NRC_GOODRET ;
}
//
// if it's an incoming session and this is a receive (as opp. to
// receive-any) then give transport a hint that there is no response
// coming back (trying to solve the raw-write-to-smb-server-perf problem)
//
if ( !pConnEle->Orig && fReceive )
{
usFlags = TDI_RECEIVE_NO_RESPONSE_EXP ;
}
status = TdiVxdReceive( &Request,
&usFlags,
&cbReceiveLength,
&prcvCont->ndisBuff ) ;
if ( status == STATUS_PENDING )
return NRC_PENDING ;
//
// Should always get pending unless a real error occurs
//
if ( !NT_SUCCESS(status) )
{
DbgPrint("VxdReceive - TdiReceive failed, error 0x") ;
DbgPrintNum( status ) ;
DbgPrint("\r\n") ;
CTEIoComplete( pNCB, status, 0 ) ;
}
}
}
else
return NRC_NORESOURCES ;
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdHangup
SYNOPSIS: Sets up a session Hangup
ENTRY: pDeviceContext -
pNCB - NCB that contains Hangup command
RETURNS:
NOTES: The code is similar to VxdDisconnectHandler. If this
changes, the VxdDisconnectHandler will probably have to
change
HISTORY:
Johnl 12-Jul-1993 Created
********************************************************************/
NCBERR VxdHangup( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
TDI_STATUS tdistatus ;
tCONNECTELE * pConnEle ;
NCBERR errNCB ;
TDI_REQUEST Request ;
ULONG TimeOut = DISCONNECT_TIMEOUT ;
tCLIENTELE * pClientEle ;
tLOWERCONNECTION * pLowerConn;
if ( errNCB = VxdFindConnectElement( pDeviceContext,
pNCB,
&pConnEle ))
{
//
// If the session was already closed but the client hasn't been
// notified, notify them now
//
if ( errNCB == NRC_SCLOSED )
{
CTEIoComplete( pNCB, STATUS_SUCCESS, 0 ) ;
errNCB = NRC_GOODRET ;
}
return errNCB ;
}
ASSERT( (pConnEle->Verify == NBT_VERIFY_CONNECTION) ||
(pConnEle->Verify == NBT_VERIFY_CONNECTION_DOWN)) ;
if ( tdistatus = VxdCompleteSessionNcbs( pDeviceContext, pConnEle ) )
{
DbgPrint("VxdHangup: Error return from VxdCompleteSessionNcbs\r\n") ;
}
if ( pClientEle = pConnEle->pClientEle )
{
ASSERT( pClientEle->Verify == NBT_VERIFY_CLIENT ||
pClientEle->Verify == NBT_VERIFY_CLIENT_DOWN ) ;
}
pLowerConn = pConnEle->pLowerConnId ;
if ( pLowerConn &&
(pLowerConn->fOnPartialRcvList == TRUE) &&
pLowerConn->StateRcv == PARTIAL_RCV )
{
RemoveEntryList( &pLowerConn->PartialRcvList ) ;
pLowerConn->fOnPartialRcvList = FALSE;
InitializeListHead(&pLowerConn->PartialRcvList);
}
Request.Handle.ConnectionContext = pConnEle ;
tdistatus = NbtDisconnect( &Request,
&TimeOut,
TDI_DISCONNECT_RELEASE,
NULL,
NULL,
NULL ) ;
if ( tdistatus && tdistatus != TDI_PENDING )
{
DbgPrint("VxdHangup: Warning: NbtDisconnect returned error\r\n") ;
}
tdistatus = NbtCloseConnection( &Request,
NULL,
pDeviceContext,
NULL ) ;
if ( tdistatus && tdistatus != TDI_PENDING )
{
DbgPrint("VxdHangup: Warning: NbtCloseConnection returned error\r\n") ;
}
tdistatus = NbtDisassociateAddress( &Request ) ;
if ( tdistatus )
{
DbgPrint("VxdHangup: NbtDisassociateAddress returned 0x") ;
DbgPrintNum( tdistatus ) ; DbgPrint("\r\n") ;
}
REQUIRE( NBUnregister( pDeviceContext, pNCB->ncb_lsn, NB_SESSION )) ;
//
// If this name has been deleted but there were active sessions, check
// to see if this is the last session, if so, delete the name
//
if ( pClientEle &&
pClientEle->fDeregistered &&
!ActiveSessions(pClientEle) )
{
UCHAR NameNum ;
if ( !VxdFindNameNum( pDeviceContext, pClientEle->pAddress, &NameNum ))
{
(void) VxdCleanupAddress( pDeviceContext,
NULL,
pClientEle,
NameNum,
TRUE ) ;
}
}
CTEIoComplete( pNCB, STATUS_SUCCESS, 0 ) ;
return NRC_GOODRET ;
}
/*******************************************************************
NAME: VxdListen
SYNOPSIS: Sets up a session listen
ENTRY: pDeviceContext -
pNCB - NCB that contains listen command
RETURNS:
NOTES: Before we can do the listen we must first open the
connection and associate the address.
The reserve field of the NCB is used as a SESS_SETUP_CONTEXT
structure
HISTORY:
Johnl 14-May-1993 Created
********************************************************************/
NCBERR VxdListen( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
NTSTATUS status;
NCBERR errNCB ;
TDI_REQUEST Request;
PSESS_SETUP_CONTEXT pSessSetupContext = NULL ;
if ( errNCB = VxdInitSessionSetup( pDeviceContext,
&Request,
&pSessSetupContext,
pNCB ))
{
return errNCB ;
}
status = NbtListen( &Request,
TDI_QUERY_ACCEPT,
*pNCB->ncb_callname != '*' ?
pSessSetupContext->pRequestConnect : NULL,
pSessSetupContext->pReturnConnect,
pNCB
);
if ( !NT_SUCCESS( status ) )
{
VxdTearDownSession( pDeviceContext,
Request.Handle.ConnectionContext,
pSessSetupContext,
NULL ) ;
}
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdOpenName
SYNOPSIS: Creates an Address object in response to AddName or
AddGroupName.
ENTRY: pDeviceContext - Device name is being added to
pNCB - NCB AddName submission
RETURNS: STATUS_SUCCESS if successful, error code otherwise
NOTES:
HISTORY:
Johnl 20-Apr-1993 Created
********************************************************************/
NCBERR VxdOpenName( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
NTSTATUS status ;
TDI_REQUEST tdiRequest ;
TDI_ADDRESS_NETBIOS tdiaddr ;
if ( pNCB->ncb_name[0] == '*' ||
pNCB->ncb_name[0] == '\0' )
{
return NRC_NOWILD ;
}
//
// Fill in the TDI structures appropriately
//
switch ( pNCB->ncb_command & ~ASYNCH )
{
case NCBADDGRNAME:
tdiaddr.NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_GROUP ;
break ;
case NCBADDNAME:
tdiaddr.NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_UNIQUE ;
break ;
default:
ASSERTMSG("VxdOpenName: Unexpected command type!\n", FALSE ) ;
return NRC_SYSTEM ;
}
CTEMemCopy( tdiaddr.NetbiosName,
pNCB->ncb_name,
sizeof(pNCB->ncb_name) ) ;
status = NbtOpenAddress( &tdiRequest,
&tdiaddr,
pDeviceContext->IpAddress,
NULL, // Security descriptor
pDeviceContext,
pNCB ) ;
if ( NT_SUCCESS( status ))
{
//
// Set our event handler to catch "Receive Any" and "Receve
// Any From Any" NCBs
//
REQUIRE( !NbtSetEventHandler( (tCLIENTELE*)tdiRequest.Handle.AddressHandle,
TDI_EVENT_RECEIVE,
ReceiveAnyHandler,
(tCLIENTELE*)tdiRequest.Handle.AddressHandle )) ;
//
// Set an event handler to cleanup up Netbios specific stuff on
// disconnect
//
REQUIRE( !NbtSetEventHandler( (tCLIENTELE*)tdiRequest.Handle.AddressHandle,
TDI_EVENT_DISCONNECT,
VxdDisconnectHandler,
(tCLIENTELE*)tdiRequest.Handle.AddressHandle)) ;
}
//
// If we open a non-unique name twice (such as a group name) then
// NbtOpenAddress doesn't complete the IRP it just returns success.
//
if ( status == TDI_SUCCESS )
{
CTEIoComplete( pNCB, status, (ULONG) tdiRequest.Handle.AddressHandle ) ;
}
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdCloseName
SYNOPSIS: Called in response to a Netbios Delete Name request
ENTRY: pDeviceContext - Device name should be deleted from
pNCB - Netbios Delete name submission
RETURNS: STATUS_SUCCESS if successful, error code otherwise
NOTES:
HISTORY:
Johnl 23-Apr-1993 Created
********************************************************************/
NCBERR VxdCloseName( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
tCLIENTELE * pClientEle ;
TDI_STATUS tdistatus ;
UCHAR NameNum ;
NCBERR errNCB ;
if ( pNCB->ncb_name[0] == '*' ||
pNCB->ncb_name[0] == '\0' )
{
return NRC_NOWILD ;
}
if ( errNCB = VxdNameToClient( pDeviceContext,
pNCB->ncb_name,
&NameNum,
&pClientEle ))
{
return errNCB ;
}
//
// If any sessions are open on this name, delay deletion till last name is
// closed
//
if ( ActiveSessions( pClientEle ) )
{
VxdCleanupAddress( pDeviceContext, pNCB, pClientEle, NameNum, FALSE ) ;
CTEIoComplete( pNCB, STATUS_NRC_ACTSES, 0 ) ;
return NRC_GOODRET ;
}
//
// No open sessions so blow away the name
//
return VxdCleanupAddress( pDeviceContext, pNCB, pClientEle, NameNum, TRUE ) ;
}
/*******************************************************************
NAME: ActiveSessions
SYNOPSIS: Returns TRUE if pClientEle has any active sessions
ENTRY: pClientEle - Client element to check
********************************************************************/
BOOL ActiveSessions( tCLIENTELE * pClientEle )
{
PLIST_ENTRY pHead, pEntry ;
pHead = &pClientEle->ConnectActive ;
pEntry = pClientEle->ConnectActive.Flink ;
while ( pHead != pEntry )
{
tCONNECTELE * pConnEle = CONTAINING_RECORD( pEntry, tCONNECTELE, Linkage ) ;
if ( pConnEle->state > NBT_ASSOCIATED )
{
return TRUE ;
}
pEntry = pEntry->Flink ;
}
return FALSE ;
}
/*******************************************************************
NAME: VxdCleanupAddress
SYNOPSIS: Prepares a name for deletion and optionally deletes it
ENTRY: pDeviceContext - Adapter we are dealing with
pNCB - Delete name NCB
pClientEle - Client of address element to delete
NameNum - Name number in table we are deleting
fDeleteAddress - TRUE if address should be deleted
EXIT: The address element will be marked as deregistered and all
non-session NCBs will be completed. The address element
may optionally be deleted also.
NOTES: This routine will complete pNCB as appropriate.
HISTORY:
Johnl 22-Sep-1993 Created
********************************************************************/
NCBERR VxdCleanupAddress( tDEVICECONTEXT * pDeviceContext,
NCB * pNCB,
tCLIENTELE * pClientEle,
UCHAR NameNum,
BOOL fDeleteAddress )
{
TDI_REQUEST Request ;
NCBERR errNCB ;
tCLIENTELE * pClientEleBcast ;
TDI_STATUS tdistatus ;
USHORT NameType ;
PLIST_ENTRY pHead, pEntry ;
PLIST_ENTRY pNextEntry;
tLISTENREQUESTS * pListen ;
PRCV_CONTEXT prcvCont ;
tRCVELE * prcvEle ;
pClientEle->fDeregistered = TRUE ;
//
// Delete all outstanding listens on this name
//
while ( !IsListEmpty( &pClientEle->ListenHead ))
{
pEntry = RemoveHeadList( &pClientEle->ListenHead ) ;
pListen = CONTAINING_RECORD( pEntry, tLISTENREQUESTS, Linkage ) ;
CTEIoComplete( pListen->pIrp, STATUS_NETWORK_NAME_DELETED, 0 ) ;
CTEMemFree( pListen ) ;
}
//
// Delete all outstanding datagram receives on this name
//
while ( !IsListEmpty( &pClientEle->RcvDgramHead ))
{
pEntry = RemoveHeadList( &pClientEle->RcvDgramHead ) ;
prcvEle = CONTAINING_RECORD( pEntry, tRCVELE, Linkage ) ;
CTEIoComplete( prcvEle->pIrp, STATUS_NETWORK_NAME_DELETED, 0 ) ;
CTEMemFree( prcvEle ) ;
}
//
// Delete all outstanding datagram broadcast receives on this name number
//
errNCB = VxdFindClientElement( pDeviceContext,
0,
&pClientEleBcast,
CLIENT_BC ) ;
if ( !errNCB )
{
//
// Scan the NCBs looking for a receive on this name number
//
pHead = &pClientEleBcast->RcvDgramHead ;
pEntry = pClientEleBcast->RcvDgramHead.Flink ;
while ( pEntry != pHead )
{
prcvEle = CONTAINING_RECORD( pEntry, tRCVELE, Linkage ) ;
pNextEntry = pEntry->Flink ;
if ( ((NCB*)prcvEle->pIrp)->ncb_num == NameNum )
{
RemoveEntryList( pEntry ) ;
CTEIoComplete( prcvEle->pIrp, STATUS_NETWORK_NAME_DELETED, 0 ) ;
CTEMemFree( prcvEle ) ;
}
pEntry = pNextEntry ;
}
}
//
// Delete all outstanding Receive Anys on this name
//
while ( !IsListEmpty( &pClientEle->RcvAnyHead ))
{
pEntry = RemoveHeadList( &pClientEle->RcvAnyHead ) ;
prcvCont = CONTAINING_RECORD( pEntry, RCV_CONTEXT, ListEntry ) ;
ASSERT( prcvCont->Signature == RCVCONT_SIGN ) ;
CTEIoComplete( prcvCont->pNCB, STATUS_NETWORK_NAME_DELETED, 0 ) ;
}
tdistatus = TDI_SUCCESS;
if ( fDeleteAddress )
{
Request.Handle.ConnectionContext = pClientEle ;
tdistatus = NbtCloseAddress( &Request,
NULL, //&RequestStatus,
pDeviceContext,
pNCB ) ;
if ( (tdistatus != TDI_PENDING) && pNCB )
CTEIoComplete( pNCB, tdistatus, 0 ) ;
REQUIRE( NBUnregister( pDeviceContext, NameNum, NB_NAME )) ;
DbgPrint("VxdCloseName: NBUnregistered:NameNum = 0x") ;
DbgPrintNum( NameNum ) ;
DbgPrint(" ClientEle = 0x") ;
DbgPrintNum( pClientEle ) ;
DbgPrint("\r\n") ;
if ( !NT_SUCCESS( tdistatus ))
{
DbgPrint("VxdCloseName: NbtCloseAddress failed with status 0x") ;
DbgPrintNum( tdistatus ) ; DbgPrint("\r\n") ;
}
}
return MapTDIStatus2NCBErr( tdistatus ) ;
}
/*******************************************************************
NAME: VxdAccept
SYNOPSIS: Accepts an indicated listen
ENTRY: pConnectElem - Upper part of connection we're about to
setup
pNCB - Original Listen request
RETURNS: TDI_SUCCESS if successful error code otherwise
NOTES:
HISTORY:
Johnl 27-May-1993 Created
********************************************************************/
TDI_STATUS VxdAccept( tCONNECTELE * pConnectElem, NCB * pNCB )
{
TDI_REQUEST Request ;
PSESS_SETUP_CONTEXT pSessSetupCont = (PSESS_SETUP_CONTEXT) pNCB->ncb_reserve ;
TDI_STATUS status ;
Request.Handle.ConnectionContext = pConnectElem ;
status = NbtAccept( &Request,
pSessSetupCont->pRequestConnect,
pSessSetupCont->pReturnConnect,
NULL ) ;
if ( !NT_SUCCESS(status) )
{
DbgPrint( "VxdAccept: NbtAccept returned " ) ;
DbgPrintNum( status ) ;
DbgPrint("\r\n") ;
}
//
// It's OK if the accept is pending because it's just the
// session setup acknowledgement
//
if ( status == TDI_PENDING )
status = TDI_SUCCESS ;
return status ;
}
/*******************************************************************
NAME: VxdAdapterStatus
SYNOPSIS: Gets the requested adapter status
ENTRY: pDeviceContext - Adapter status to get
pNCB - Pointer to requesting NCB
EXIT:
NOTES:
HISTORY:
Johnl 10-Aug-1993 Created
********************************************************************/
NCBERR VxdAdapterStatus( tDEVICECONTEXT * pDeviceContext,
NCB * pNCB,
ULONG Ipaddr
)
{
TDI_STATUS status ;
PADAPTER_STATUS pAdapterStatus ;
ULONG ActualSize;
ULONG Size = pNCB->ncb_length ;
//
// Ipaddr will always be 0 except in one case: if we came here
// via nbtstat -A
//
if ( !Ipaddr && *pNCB->ncb_callname == '*' )
{
//
// Get the local adapter status
//
DbgPrint("VxdAdapterStatus: AStat for local (*)\r\n") ;
status = NbtQueryAdapterStatus( pDeviceContext,
&pAdapterStatus,
&Size ) ;
if ( !status || status == TDI_BUFFER_OVERFLOW )
{
ActualSize = min( pNCB->ncb_length, Size ) ;
CTEMemCopy( pNCB->ncb_buffer,
pAdapterStatus,
ActualSize) ;
pNCB->ncb_length = ActualSize;
CTEFreeMem( pAdapterStatus ) ;
CTEIoComplete( pNCB, status, 0 ) ;
//
// Return a successful status (buffer overflow denoted
// in NCB)
//
status = NRC_GOODRET ;
}
}
else
{
ULONG IpAddrsList[2];
IpAddrsList[0] = Ipaddr;
IpAddrsList[1] = 0;
status = NbtSendNodeStatus( pDeviceContext,
pNCB->ncb_callname,
pNCB,
IpAddrsList,
0,
NodeStatusDone);
}
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdFindName
SYNOPSIS: Gets the requested adapter status
ENTRY: pDeviceContext - Adapter status to get
pNCB - Pointer to requesting NCB
EXIT:
NOTES:
HISTORY:
Johnl 04-Oct-1993 Created
********************************************************************/
NCBERR VxdFindName( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
TDI_STATUS status ;
TDI_CONNECTION_INFORMATION RequestInfo ;
DbgPrint("VxdFindName: Entered\r\n") ;
InitNBTDIConnectInfo( &RequestInfo, &tanb_global, pNCB->ncb_callname ) ;
status = NbtQueryFindName( &RequestInfo,
pDeviceContext,
pNCB,
FALSE ) ;
if ( status == STATUS_SUCCESS )
{
CTEIoComplete( pNCB, STATUS_SUCCESS, 0xffffffff ) ;
return STATUS_SUCCESS ;
}
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdSessionStatus
SYNOPSIS: Gets the requested Session status
ENTRY: pDeviceContext - Session status to get
pNCB - Pointer to requesting NCB
EXIT:
NOTES: VxdCopySessionStatus will automatically complete the NCB
if the buffer overflows. Otherwise we will.
HISTORY:
Johnl 23-Aug-1993 Created
********************************************************************/
NCBERR VxdSessionStatus( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
TDI_STATUS status = STATUS_SUCCESS ;
PSESSION_HEADER pSessionHeader = (PSESSION_HEADER) pNCB->ncb_buffer ;
PSESSION_BUFFER pSessionBuff ;
ULONG RemainingSize = pNCB->ncb_length ;
tNAMEADDR * pNameAddr = NULL ;
tCLIENTELE * pClientEle = NULL ;
tCLIENTELE * pClientEleBcast = NULL ;
USHORT NameType ;
PLIST_ENTRY pEntry ;
UCHAR i ;
NCBERR errNCB ;
if ( RemainingSize < sizeof(SESSION_HEADER) )
{
CTEIoComplete( pNCB, STATUS_INVALID_BUFFER_SIZE, 0 ) ;
return NRC_GOODRET ;
}
pSessionHeader->sess_name = 0 ;
pSessionHeader->num_sess = 0 ;
pSessionHeader->rcv_dg_outstanding = 0 ;
pSessionHeader->rcv_any_outstanding = 0 ;
//
// For broadcast datagram statistics
//
errNCB = VxdFindClientElement( pDeviceContext,
0,
&pClientEleBcast,
CLIENT_BC ) ;
if ( errNCB )
return errNCB ;
//
// Get all sessions?
//
if ( pNCB->ncb_name[0] == '*' )
{
for ( i = 1 ; i <= pDeviceContext->cMaxSessions ; i++ )
{
if ( pDeviceContext->pSessionTable[i] != NULL )
{
pClientEle = pDeviceContext->pSessionTable[i]->pClientEle ;
//
// Both normal receives and broadcast receives are
// kept on the same list
//
COUNT_ELEMENTS( pClientEle->RcvDgramHead,
pSessionHeader->rcv_dg_outstanding ) ;
COUNT_ELEMENTS( pClientEle->RcvAnyHead,
pSessionHeader->rcv_any_outstanding ) ;
}
}
//
// Only one broadcast client element per adapter
//
COUNT_ELEMENTS( pClientEleBcast->RcvDgramHead,
pSessionHeader->rcv_dg_outstanding ) ;
COUNT_ELEMENTS( pDeviceContext->RcvDGAnyFromAnyHead,
pSessionHeader->rcv_dg_outstanding ) ;
pSessionHeader->sess_name = 0xff ;
RemainingSize -= sizeof( SESSION_HEADER ) ;
pSessionBuff = (PSESSION_BUFFER) (pSessionHeader + 1) ;
//
// From this device context, traverse all of the Address elements
// and all of its Client elements and all of its Connect Elements
//
for ( pEntry = NbtConfig.AddressHead.Flink ;
pEntry != &NbtConfig.AddressHead && !status ;
pEntry = pEntry->Flink )
{
PLIST_ENTRY pEntryClient ;
tADDRESSELE * pAddrEle = CONTAINING_RECORD( pEntry,
tADDRESSELE,
Linkage ) ;
ASSERT( pAddrEle->Verify == NBT_VERIFY_ADDRESS ) ;
//
// Only get addresses for this adapter
//
if ( pAddrEle->pDeviceContext != pDeviceContext )
continue ;
for ( pEntryClient = pAddrEle->ClientHead.Flink ;
pEntryClient != &pAddrEle->ClientHead ;
pEntryClient = pEntryClient->Flink )
{
tCLIENTELE * pClientEle = CONTAINING_RECORD( pEntryClient,
tCLIENTELE,
Linkage ) ;
PLIST_ENTRY pEntryConn ;
ASSERT( pClientEle->Verify == NBT_VERIFY_CLIENT ||
pClientEle->Verify == NBT_VERIFY_CLIENT_DOWN ) ;
if (!VxdCopySessionStatus( pDeviceContext,
pClientEle,
pSessionHeader,
&pSessionBuff,
&RemainingSize ))
{
status = STATUS_BUFFER_OVERFLOW ;
break ;
}
}
}
}
else
{
if ( errNCB = VxdNameToClient( pDeviceContext,
pNCB->ncb_name,
&pSessionHeader->sess_name,
&pClientEle ))
{
return errNCB ;
}
COUNT_ELEMENTS( pClientEle->RcvDgramHead,
pSessionHeader->rcv_dg_outstanding ) ;
COUNT_ELEMENTS( pClientEleBcast->RcvDgramHead,
pSessionHeader->rcv_dg_outstanding ) ;
COUNT_ELEMENTS( pDeviceContext->RcvDGAnyFromAnyHead,
pSessionHeader->rcv_dg_outstanding ) ;
COUNT_ELEMENTS( pClientEle->RcvAnyHead,
pSessionHeader->rcv_any_outstanding ) ;
RemainingSize -= sizeof( SESSION_HEADER ) ;
pSessionBuff = (PSESSION_BUFFER) (pSessionHeader + 1) ;
if ( !VxdCopySessionStatus( pDeviceContext,
pClientEle,
pSessionHeader,
&pSessionBuff,
&RemainingSize ))
{
status = STATUS_BUFFER_OVERFLOW ;
}
}
CTEIoComplete( pNCB,
status,
sizeof(SESSION_HEADER) +
pSessionHeader->num_sess * sizeof(SESSION_BUFFER) ) ;
return NRC_GOODRET ;
}
/*******************************************************************
NAME: VxdCopySessionStatus
SYNOPSIS: Copies all of the sessions associated with pClientEle
ENTRY: pDeviceContext - Adapter to use
pClientEle - Client to retrieve all sessions for
pSessionHeader - Session status header
pSessionBuff - Pointer to beginning of session buffers
pRemainingSize - Remaining size of buffer
RETURNS: TRUE if all session information was transferred,
FALSE if we ran out of buffer space
NOTES:
HISTORY:
Johnl 23-Aug-1993 Created
********************************************************************/
BOOL VxdCopySessionStatus( tDEVICECONTEXT * pDeviceContext,
tCLIENTELE * pClientEle,
PSESSION_HEADER pSessionHeader,
PSESSION_BUFFER * ppSessionBuff,
ULONG * pRemainingSize )
{
PLIST_ENTRY pEntryConn ;
tCONNECTELE * pConnectEle ;
for ( pEntryConn = pClientEle->ConnectActive.Flink ;
pEntryConn != &pClientEle->ConnectActive ;
pEntryConn = pEntryConn->Flink )
{
PLIST_ENTRY pEntry ;
BOOL fFillRemote = FALSE ;
pConnectEle = CONTAINING_RECORD( pEntryConn,
tCONNECTELE,
Linkage ) ;
ASSERT( pConnectEle->Verify == NBT_VERIFY_CONNECTION ||
pConnectEle->Verify == NBT_VERIFY_CONNECTION_DOWN ) ;
if ( *pRemainingSize < sizeof(SESSION_BUFFER) )
{
return FALSE ;
}
*pRemainingSize -= sizeof(SESSION_BUFFER) ;
pSessionHeader->num_sess++ ;
(*ppSessionBuff)->rcvs_outstanding = 0 ;
(*ppSessionBuff)->sends_outstanding = 0 ; // Always 0
REQUIRE( !VxdFindLSN( pDeviceContext, pConnectEle, &(*ppSessionBuff)->lsn )) ;
COUNT_ELEMENTS( pConnectEle->RcvHead,
(*ppSessionBuff)->rcvs_outstanding ) ;
//
// Set the session state
//
switch ( pConnectEle->state )
{
case NBT_CONNECTING: // establishing Transport connection
if ( pConnectEle->Orig )
(*ppSessionBuff)->state = CALL_PENDING ;
else
(*ppSessionBuff)->state = LISTEN_OUTSTANDING ;
break ;
case NBT_SESSION_INBOUND: // waiting for a session request after tcp connectio
case NBT_SESSION_WAITACCEPT: // waiting for accept after a listen has been satis
(*ppSessionBuff)->state = LISTEN_OUTSTANDING ;
break ;
case NBT_SESSION_OUTBOUND: // waiting for a session response after tcp connecti
fFillRemote = TRUE ;
(*ppSessionBuff)->state = CALL_PENDING ;
case NBT_SESSION_UP: // got positive response
fFillRemote = TRUE ;
(*ppSessionBuff)->state = SESSION_ESTABLISHED ;
break ;
case NBT_DISCONNECTING: // sent a disconnect down to Tcp, but it hasn't comp
(*ppSessionBuff)->state = HANGUP_PENDING;
break ;
case NBT_DISCONNECTED: // a session has been disconnected but not closed wit
(*ppSessionBuff)->state = HANGUP_COMPLETE;
break ;
case NBT_IDLE: // Shouldn't be on ConnectActive list
case NBT_ASSOCIATED:
default:
ASSERT( FALSE ) ;
(*ppSessionBuff)->state = SESSION_ABORTED ;
break ;
}
//
// Copy local and/or remote name
//
CTEMemCopy( (*ppSessionBuff)->local_name,
pClientEle->pAddress->pNameAddr->Name,
NCBNAMSZ ) ;
if ( fFillRemote )
{
CTEMemCopy( (*ppSessionBuff)->remote_name,
pConnectEle->RemoteName,
NCBNAMSZ ) ;
}
(*ppSessionBuff)++ ;
}
return TRUE ;
}
/*******************************************************************
NAME: VxdReset
SYNOPSIS: Clears out the name tables and completes all outstanding NCBs
ENTRY: pDeviceContext - Adapter status to get
pNCB - Pointer to requesting NCB
EXIT:
NOTES: If a session is active then we have to wait till we disconnect
the connection before deleting the name. We keep count of the
active sessions and call the VxdResetContinue function after
all session disconnects have been completed.
It is assumed this is made as a "wait" call.
HISTORY:
Johnl 16-Aug-1993 Created
********************************************************************/
NCBERR VxdReset( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
UCHAR i ;
TDI_STATUS tdistatus ;
PLIST_ENTRY pHead, pEntry ;
PRESET_CONTEXT pRstCont = (PRESET_CONTEXT) pNCB->ncb_reserve ;
pRstCont->cActiveSessions = 0 ;
pRstCont->cActiveNames = 0 ;
pRstCont->errncb = NRC_GOODRET ;
//
// Kill off all of the Receive any from any NCBs
//
while ( !IsListEmpty(&pDeviceContext->RcvAnyFromAnyHead))
{
PRCV_CONTEXT prcvCont ;
pEntry = RemoveHeadList( &pDeviceContext->RcvAnyFromAnyHead ) ;
prcvCont = CONTAINING_RECORD( pEntry, RCV_CONTEXT, ListEntry ) ;
ASSERT( prcvCont->Signature == RCVCONT_SIGN ) ;
CTEIoComplete( prcvCont->pNCB,
STATUS_CONNECTION_DISCONNECTED,
0 ) ;
}
//
// Kill off all of the Receive any datagrams from any
//
while ( !IsListEmpty(&pDeviceContext->RcvDGAnyFromAnyHead))
{
tRCVELE * pRcvEle ;
pEntry = RemoveHeadList( &pDeviceContext->RcvDGAnyFromAnyHead ) ;
pRcvEle = CONTAINING_RECORD( pEntry, tRCVELE, Linkage ) ;
CTEIoComplete( pRcvEle->pIrp,
STATUS_NETWORK_NAME_DELETED, // NRC_NAMERR
0 ) ;
CTEMemFree( pRcvEle ) ;
}
//
// Disconnect all sessions
//
for ( i = 1 ; i <= pDeviceContext->cMaxSessions ; i++ )
{
//
// This will also prevent any listens from being accepted on the
// connection
//
if ( pDeviceContext->pSessionTable[i] != NULL )
{
TDI_REQUEST Request ;
ULONG TimeOut = DISCONNECT_TIMEOUT ;
tCONNECTELE * pConnEle= pDeviceContext->pSessionTable[i] ;
Request.Handle.ConnectionContext = pConnEle ;
pRstCont->cActiveSessions++ ;
tdistatus = NbtDisconnect( &Request,
&TimeOut,
TDI_DISCONNECT_RELEASE,
NULL,
NULL,
pNCB ) ;
if ( tdistatus != TDI_PENDING )
{
pRstCont->cActiveSessions-- ;
tdistatus = NbtCloseConnection( &Request,
NULL,
pDeviceContext,
NULL ) ;
REQUIRE( NBUnregister( pDeviceContext, i, NB_SESSION )) ;
}
}
}
//
// If no active sessions, then go ahead and delete all the names
//
if ( !pRstCont->cActiveSessions )
{
pRstCont->cActiveSessions = -1 ;
return VxdResetContinue( pDeviceContext, pNCB ) ;
}
return NRC_GOODRET ;
}
/*******************************************************************
NAME: VxdResetContinue
SYNOPSIS: Finishes the reset after all sessions have been successfully
shutdown
ENTRY: pDeviceContext - Adapter status to get
pNCB - Pointer to requesting NCB
EXIT:
NOTES:
HISTORY:
Johnl 16-Aug-1993 Created
********************************************************************/
NCBERR VxdResetContinue( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
UCHAR i ;
TDI_STATUS tdistatus ;
PLIST_ENTRY pHead, pEntry ;
PRESET_CONTEXT pRstCont = (PRESET_CONTEXT) pNCB->ncb_reserve ;
PNCB pNCBPerm ;
DbgPrint("VxdResetContinue entered\r\n") ;
//
// Now that all of the sessions have been disconnected, close each
// connection
//
for ( i = 1 ; i <= pDeviceContext->cMaxSessions ; i++ )
{
if ( pDeviceContext->pSessionTable[i] != NULL )
{
TDI_REQUEST Request ;
tCONNECTELE * pConnEle = pDeviceContext->pSessionTable[i] ;
Request.Handle.ConnectionContext = pConnEle ;
tdistatus = NbtCloseConnection( &Request,
NULL,
pDeviceContext,
NULL ) ;
REQUIRE( NBUnregister( pDeviceContext, i, NB_SESSION )) ;
}
}
//
// Delete all the names (including the permanent name)
//
for ( i = 0 ; i <= pDeviceContext->cMaxNames ; i++ )
{
if ( pDeviceContext->pNameTable[i] != NULL )
{
TDI_REQUEST Request ;
Request.Handle.ConnectionContext = pDeviceContext->pNameTable[i] ;
pRstCont->cActiveNames++ ;
tdistatus = NbtCloseAddress( &Request,
NULL, //&RequestStatus,
pDeviceContext,
pNCB ) ;
if ( tdistatus != TDI_PENDING )
pRstCont->cActiveNames-- ;
//
// Go ahead and remove the name from the table since nobody
// will be able to re-register with it since this is a "wait" cmd
//
REQUIRE( NBUnregister( pDeviceContext, i, NB_NAME )) ;
}
}
//
// Resize the session table If an error occurs, keep the old
// session table.
//
if ( pNCB->ncb_lsn != pDeviceContext->cMaxSessions )
{
UCHAR MaxSess = (UCHAR) pNCB->ncb_lsn ? pNCB->ncb_lsn : 6 ;
PVOID pSess = CTEAllocMem((USHORT)((MaxSess+1)*sizeof(tCONNECTELE*))) ;
if ( !pSess )
{
pRstCont->errncb = NRC_NORESOURCES ;
}
else
{
CTEFreeMem( pDeviceContext->pSessionTable ) ;
pDeviceContext->cMaxSessions = MaxSess ;
pDeviceContext->pSessionTable = pSess ;
CTEZeroMemory( &pDeviceContext->pSessionTable[0],
(pDeviceContext->cMaxSessions+1)*sizeof(tCONNECTELE*) ) ;
}
}
//
// Set current session/name numbers back to 1
//
pDeviceContext->iNcbNum = 1 ;
pDeviceContext->iLSNum = 1 ;
//
// re-add the permanent name for this adapter, non-fatal if it fails
//
if ( !NT_SUCCESS( NbtAddPermanentName( pDeviceContext )))
{
CDbgPrint( DBGFLAG_ERROR,
("VxdResetContinue: Warning - Failed to add permanent name")) ;
}
if ( !pRstCont->cActiveNames )
CTEIoComplete( pNCB, NRC_GOODRET, 0 ) ;
return NRC_GOODRET ;
}
/*******************************************************************
NAME: VxdCancel
SYNOPSIS: Attempts to cancel the NCB pointed at by ncb_buffer
ENTRY: pDeviceContext - Adapter status to get
pNCB - Pointer to requesting NCB
EXIT:
NOTES:
HISTORY:
Johnl 18-Aug-1993 Created
********************************************************************/
NCBERR VxdCancel( tDEVICECONTEXT * pDeviceContext, NCB * pNCB )
{
NCB * pNCBCancelled = (NCB*) pNCB->ncb_buffer ;
tCONNECTELE * pConnEle ;
tCLIENTELE * pClientEle ;
NCBERR errNCB = NRC_GOODRET ;
TDI_STATUS tdistatus ;
PLIST_ENTRY pHead, pEntry ;
USHORT NameType ;
tNAMEADDR * pNameAddr ;
tLISTENREQUESTS * pListen ;
PRCV_CONTEXT prcvCont ; // Used for session receives
tRCVELE * prcvEle ; // Used for Datagram receives
if ( pNCB->ncb_lana_num != pNCBCancelled->ncb_lana_num )
{
DbgPrint("VxdCancel: Attempt to cancel NCB w/ different lana\r\n") ;
return NRC_BRIDGE ;
}
if ( pNCB->ncb_retcode != NRC_PENDING )
return NRC_CANOCCR ;
switch ( pNCBCancelled->ncb_command & ~ASYNCH )
{
case NCBSEND:
case NCBSENDNA:
case NCBCHAINSEND:
case NCBCHAINSENDNA:
case NCBRECV:
//
// Cancelling a session NCB automatically closes the session
//
if ( VxdFindConnectElement( pDeviceContext,
pNCBCancelled,
&pConnEle ))
{
DbgPrint("VxdCancel: Attempted to cancel send NCB on non-existent session\r\n") ;
break ;
}
if ( (pNCBCancelled->ncb_command & ~ASYNCH) == NCBRECV )
{
errNCB = NRC_CANOCCR ;
for ( pEntry = pConnEle->RcvHead.Flink ;
pEntry != &pConnEle->RcvHead ;
pEntry = pEntry->Flink )
{
prcvCont = CONTAINING_RECORD( pEntry, RCV_CONTEXT, ListEntry ) ;
ASSERT( prcvCont->Signature == RCVCONT_SIGN ) ;
if ( prcvCont->pNCB == pNCBCancelled )
{
RemoveEntryList( pEntry ) ;
CTEIoComplete( prcvCont->pNCB, STATUS_CANCELLED, 0 ) ;
errNCB = NRC_GOODRET ;
break ;
}
}
}
else
{
//
// Sends are immediately submitted to the transport, tell
// caller it's too late to cancel. The transport will complete
// the NCB when we close the connection below.
//
errNCB = NRC_CANOCCR ;
}
REQUIRE( !VxdCompleteSessionNcbs( pDeviceContext, pConnEle )) ;
VxdTearDownSession( pDeviceContext,
pConnEle,
NULL,
NULL ) ;
//
// Only remove from table if we've told the client
//
if ( pConnEle->Flags & NB_CLIENT_NOTIFIED )
{
REQUIRE( NBUnregister( pDeviceContext,
pNCBCancelled->ncb_lsn,
NB_SESSION )) ;
}
break ;
case NCBCANCEL:
errNCB = NRC_CANCEL ; // Can't cancel a cancel
break ;
case NCBLISTEN:
//
// Lookup the Client Element associated with this name, then scan
// the listen NCBs for one that matches the one being cancelled
//
if ( errNCB = VxdNameToClient( pDeviceContext,
pNCBCancelled->ncb_name,
NULL,
&pClientEle ))
{
DbgPrint("VxdCancel: Tried to cancel listen on non-existent name\r\n") ;
errNCB = NRC_CANOCCR ;
break ;
}
errNCB = NRC_CANOCCR ;
for ( pEntry = pClientEle->ListenHead.Flink ;
pEntry != &pClientEle->ListenHead ;
pEntry = pEntry->Flink )
{
pListen = CONTAINING_RECORD( pEntry, tLISTENREQUESTS, Linkage ) ;
if ( pListen->pIrp == pNCBCancelled )
{
DbgPrint("VxdCancel: Cancelling NCB 0x") ;
DbgPrintNum( (ULONG) pNCBCancelled ) ; DbgPrint("\r\n") ;
RemoveEntryList( &pListen->Linkage ) ;
CTEIoComplete( pNCBCancelled, STATUS_CANCELLED, 0 ) ;
CTEMemFree( pListen ) ;
errNCB = NRC_GOODRET ;
break ;
}
}
break ;
case NCBCALL:
//
// Search the ConnectActive list for our NCB and cleanup that
// connection
//
if ( errNCB = VxdNameToClient( pDeviceContext,
pNCBCancelled->ncb_name,
NULL,
&pClientEle ))
{
DbgPrint("VxdCancel: Tried to cancel call on non-existent name\r\n") ;
errNCB = NRC_CANOCCR ;
break ;
}
errNCB = NRC_CANOCCR ;
for ( pEntry = pClientEle->ConnectActive.Flink ;
pEntry != &pClientEle->ConnectActive ;
pEntry = pEntry->Flink )
{
pConnEle = CONTAINING_RECORD( pEntry, tCONNECTELE, Linkage ) ;
if ( pConnEle->pIrp == pNCBCancelled )
{
tDGRAM_SEND_TRACKING * pTracker = (tDGRAM_SEND_TRACKING*)
pConnEle->pIrpRcv ;
//
// if it's too late, just say we can't cancel it
//
if (pConnEle->state >= NBT_SESSION_OUTBOUND)
{
errNCB = NRC_CANOCCR ;
break;
}
//
// yes, we can cancel it. we just mark the tracker to say
// this call is cancelled: both the original ncb and this
// cancel ncb will get completed at some stage.
//
DbgPrint("VxdCancel: Cancelling NCB 0x") ;
DbgPrintNum( (ULONG) pNCBCancelled ) ; DbgPrint("\r\n") ;
pTracker->Flags |= TRACKER_CANCELLED;
pConnEle->pIrpDisc = pNCB;
return NRC_GOODRET ;
}
}
break ;
case NCBDGRECV:
if ( pNCBCancelled->ncb_num == ANY_NAME )
{
pHead = &pDeviceContext->RcvDGAnyFromAnyHead ;
}
else
{
if ( errNCB = VxdFindClientElement( pDeviceContext,
pNCBCancelled->ncb_num,
&pClientEle,
CLIENT_LOCAL ) )
{
ASSERT( FALSE ) ;
break ;
}
pHead = &pClientEle->RcvDgramHead ;
}
errNCB = NRC_CANOCCR ;
for ( pEntry = pHead->Flink ;
pEntry != pHead ;
pEntry = pEntry->Flink )
{
prcvEle = CONTAINING_RECORD( pEntry, tRCVELE, Linkage ) ;
if ( prcvEle->pIrp == pNCBCancelled )
{
RemoveEntryList( pEntry ) ;
CTEIoComplete( pNCBCancelled, STATUS_CANCELLED, 0 ) ;
CTEMemFree( prcvEle ) ;
errNCB = NRC_GOODRET ;
break ;
}
}
break ;
case NCBDGRECVBC:
//
// For receive broadcast datagrams, we have to look through the list
// of clients on the Broadcast Address.
//
errNCB = VxdFindClientElement( pDeviceContext,
0,
&pClientEle,
CLIENT_BC ) ;
if ( !errNCB )
{
errNCB = NRC_CANOCCR ;
for ( pEntry = pClientEle->RcvDgramHead.Flink ;
pEntry != &pClientEle->RcvDgramHead ;
pEntry = pEntry->Flink )
{
prcvEle = CONTAINING_RECORD( pEntry, tRCVELE, Linkage ) ;
if ( prcvEle->pIrp == pNCBCancelled )
{
RemoveEntryList( pEntry ) ;
CTEMemFree( prcvEle ) ;
CTEIoComplete( pNCBCancelled, STATUS_CANCELLED, 0 ) ;
errNCB = NRC_GOODRET ;
break ;
}
}
}
break ;
case NCBRECVANY:
if ( pNCBCancelled->ncb_num == ANY_NAME )
pHead = &pDeviceContext->RcvAnyFromAnyHead ;
else
{
if ( errNCB = VxdFindClientElement( pDeviceContext,
pNCBCancelled->ncb_num,
&pClientEle,
CLIENT_LOCAL ) )
{
ASSERT( FALSE ) ;
break ;
}
pHead = &pClientEle->RcvAnyHead ;
}
errNCB = NRC_CANOCCR ;
pEntry = pHead->Flink ;
while ( pEntry != pHead )
{
prcvCont = CONTAINING_RECORD( pEntry, RCV_CONTEXT, ListEntry ) ;
ASSERT( prcvCont->Signature == RCVCONT_SIGN ) ;
if ( prcvCont->pNCB == pNCBCancelled )
{
RemoveEntryList( pEntry ) ;
CTEIoComplete( prcvCont->pNCB, STATUS_CANCELLED, 0 ) ;
errNCB = NRC_GOODRET ;
break ;
}
pEntry = pEntry->Flink ;
}
break ;
default:
errNCB = NRC_CANCEL ;
}
CTEIoComplete( pNCB, errNCB, 0 ) ;
//
// No, no! Don't touch that ncb after completing it!
//
//pNCB->ncb_retcode = errNCB ;
//pNCB->ncb_cmd_cplt = errNCB ;
return errNCB ;
}
/*******************************************************************
NAME: VxdIoComplete
SYNOPSIS: Let's the NCB know that all processing is done by setting
the command completion fields and calling the post routine
if available.
ENTRY: pirp - Pointer to the NCB to notify that we are done
(or NULL if this didn't come from the Netbios I/F
status - Status of the completion
ulExtra - Extra parameter
NOTES: This is the procedure that CTEIoComplete maps to and is
roughly equivilent to "completing" an IRP.
HISTORY:
Johnl 27-Apr-1993 Created
********************************************************************/
VOID VxdIoComplete( PCTE_IRP pirp,
NTSTATUS status,
ULONG ulExtra )
{
NCB * pNCB = pirp ;
NCBERR errNCB = NRC_GOODRET ;
PSESS_SETUP_CONTEXT pSessSetupCont ;
BOOL fAsync ;
tDEVICECONTEXT * pDeviceContext ;
PRESET_CONTEXT pRstCont ;
PSEND_CONTEXT pSendCont ;
tCONNECTELE * pConnEle ;
DbgPrint("VxdIoComplete: Completing NCB; Cmd, Addr, TDI status: 0x") ;
if ( pNCB )
{
DbgPrintNum( pNCB->ncb_command ) ;
DbgPrint(" 0x") ; DbgPrintNum( (ULONG) pNCB ) ;
DbgPrint(" 0x") ; DbgPrintNum( status ) ;
DbgPrint("\r\n") ;
}
else
DbgPrint("NULL\r\n") ;
//
// If no NCB to complete then we're done
//
if ( !pNCB )
return ;
fAsync = !!(pNCB->ncb_command & ASYNCH) ;
pDeviceContext = GetDeviceContext( pNCB ) ;
ASSERT(pDeviceContext);
//
// Note that we drop through the below case statement even if an error
// occurred because some commands need to free stuff before completing
// the NCB.
//
if ( status != STATUS_SUCCESS &&
( pNCB->ncb_command & ~ASYNCH) != NCBCANCEL )
{
errNCB = MapTDIStatus2NCBErr( status ) ;
}
//
// Fill in any items in the NCB struct if necessary
//
switch( pNCB->ncb_command & ~ASYNCH )
{
case NCBRECVANY: // lsn was set when the receive was posted
case NCBRECV:
FreeRcvContext( *((PRCV_CONTEXT*)&pNCB->ncb_reserve) ) ;
if ( errNCB && errNCB != NRC_INCOMP )
{
break ;
}
ASSERT( ulExtra <= 0xffff ) ;
ASSERT( pNCB->ncb_length >= ulExtra ) ;
pNCB->ncb_length = (WORD) ulExtra ;
DbgPrint("\tSetting length to 0x") ;
DbgPrintNum( ulExtra ) ;
DbgPrint("\r\n") ;
break ;
case NCBSSTAT:
case NCBDGRECV:
case NCBDGRECVBC:
if ( errNCB && errNCB != NRC_INCOMP )
break ;
ASSERT( ulExtra <= 0xffff ) ;
ASSERT( pNCB->ncb_length >= ulExtra ) ;
pNCB->ncb_length = (WORD) ulExtra ;
DbgPrint("\tSetting length to 0x") ;
DbgPrintNum( ulExtra ) ;
DbgPrint("\r\n") ;
break ;
case NCBASTAT:
case NCBFINDNAME:
if ( errNCB && errNCB != NRC_INCOMP )
break ;
if ( ulExtra != 0xffffffff ) // Means buffer length already set
pNCB->ncb_length = (WORD) ulExtra ;
DbgPrint("\tAStat/Findname length is 0x") ;
DbgPrintNum( (ULONG) pNCB->ncb_length ) ;
DbgPrint("\r\n") ;
break ;
case NCBSEND:
case NCBSENDNA:
case NCBCHAINSEND:
case NCBCHAINSENDNA:
pSendCont = (PSEND_CONTEXT) pNCB->ncb_reserve ;
if ( errNCB )
{
//
// Sends are immediately given to the transport, so if a
// timeout occurs, we'll first be completed by the timeout
// code, then we'll be completed by the transport closing
// the connection.
//
if ( errNCB != NRC_CMDTMO &&
pSendCont->STO == NCB_TIMED_OUT )
{
//
// The transport has completed this NCB in response to the
// Close connection because of a send timeout. Map the
// error to timeout and complete back to the client. The
// session is dead so don't disconnect it again. The send
// has already been removed from the timeout list.
//
errNCB = NRC_CMDTMO ;
}
else
{
BOOL fTimedOutNCB = pSendCont->STO == NCB_TIMED_OUT ;
//
// Remove from timeout list
//
if ( pSendCont->STO != NCB_INFINITE_TIME_OUT )
RemoveEntryList( &pSendCont->ListEntry ) ;
//
// Kill the session
//
if ( VxdFindConnectElement( pDeviceContext,
pNCB,
&pConnEle ))
{
//
// There maybe multiple sends on this session, only the
// first should disconnect
//
CTEFreeMem( pSendCont->pHdr ) ;
DbgPrint("VxdIoComplete: Error occurred on non-existent session\r\n") ;
break ;
}
REQUIRE( !VxdCompleteSessionNcbs( pDeviceContext, pConnEle )) ;
//
// Only remove from table if we've told the client
//
if ( pConnEle->Flags & NB_CLIENT_NOTIFIED )
{
REQUIRE( NBUnregister( pDeviceContext,
pNCB->ncb_lsn,
NB_SESSION )) ;
}
VxdTearDownSession( pDeviceContext,
pConnEle,
NULL,
NULL ) ;
if ( fTimedOutNCB ) // pSendCont may already have been freed
{
//
// The Close Connection above will cause the transport to
// complete this send with a session closed error, wait
// for that before completing back to the client.
//
return ;
}
}
}
else
{
if ( pSendCont->STO != NCB_INFINITE_TIME_OUT )
RemoveEntryList( &pSendCont->ListEntry ) ;
}
FreeSessionHdr( pSendCont->pHdr ) ;
break ;
case NCBDGSEND:
case NCBDGSENDBC:
//
// Nothing to do
//
break ;
//
// Need to set the ncb_num field for the following commands. Note
// that the ulExtra parameter will contain a pointer to the address
// element that was just added for this name.
//
case NCBADDNAME:
case NCBADDGRNAME:
if ( errNCB )
break ;
if ( !NBRegister( pDeviceContext,
&pNCB->ncb_num,
(tCLIENTELE *) ulExtra,
NB_NAME ))
{
TDI_REQUEST Request ;
TDI_STATUS tdistatus ;
errNCB = NRC_NAMTFUL ;
Request.Handle.ConnectionContext = (tCLIENTELE *) ulExtra ;
tdistatus = NbtCloseAddress( &Request,
NULL, //&RequestStatus,
pDeviceContext,
NULL ) ;
ASSERT( NT_SUCCESS( tdistatus )) ;
}
else
{
DbgPrint("\tRegistered Name number ") ;
DbgPrintNum( pNCB->ncb_num ) ;
DbgPrint(" for Address Element ") ;
DbgPrintNum( ulExtra ) ;
DbgPrint("\r\n") ;
}
break ;
#if 0
//
// Private NBT NCB type for processing the permanent name
//
case NCBADD_PERMANENT_NAME:
CTEFreeMem( pNCB ) ;
if ( errNCB )
{
DbgPrint("VxdIoComplete: Failed to add permanent name!\r\n") ;
}
else
{
ASSERT( pDeviceContext->pNameTable[0] == NULL ) ;
pDeviceContext->pNameTable[0] = (tCLIENTELE *) ulExtra ;
}
//
// Don't do any further processing of this NCB. Not only did
// we just free it, nobody is looking for it.
//
return ;
#endif
case NCBCALL:
case NCBLISTEN:
pSessSetupCont = (PSESS_SETUP_CONTEXT) pNCB->ncb_reserve ;
if ( errNCB )
{
VxdTearDownSession( pDeviceContext,
pSessSetupCont->pConnEle,
pSessSetupCont,
NULL ) ;
break ;
}
//
// Put the connection in our LSN table and copy out the connecting
// name if necessary
//
if ( !NBRegister( pDeviceContext,
&pNCB->ncb_lsn,
(tCONNECTELE *) ulExtra,
NB_SESSION ))
{
VxdTearDownSession( pDeviceContext,
(tCONNECTELE *) ulExtra,
NULL,
NULL ) ;
errNCB = NRC_LOCTFUL ;
}
else
{
tCONNECTELE * pConnEle = (tCONNECTELE*) ulExtra ;
//
// Were we listenning for '*'? If so, copy out the connecting
// name.
//
if ( pSessSetupCont->fIsWorldListen )
{
DbgPrint( "VxdIoComplete: World listen accepted \"" ) ;
DbgPrint( pConnEle->RemoteName ) ;
DbgPrint("\" for connection endpoint\r\n") ;
CTEMemCopy( pNCB->ncb_callname,
pConnEle->RemoteName,
NCBNAMSZ ) ;
}
((tCONNECTELE *)ulExtra)->RTO = pNCB->ncb_rto ;
((tCONNECTELE *)ulExtra)->STO = pNCB->ncb_sto ;
((tCONNECTELE *)ulExtra)->Flags = 0 ;
//
// Don't delete the connection element until the client has been
// notified that the connection is down
//
((tCONNECTELE *)ulExtra)->RefCount++ ;
DbgPrint("\tRegistered Session number ") ;
DbgPrintNum( pNCB->ncb_lsn ) ;
DbgPrint(" for Connection Element ") ;
DbgPrintNum( (ULONG) pConnEle ) ;
DbgPrint("\r\n") ;
}
FreeSessSetupContext( pSessSetupCont ) ;
//
// If we're in WAITACCEPT, then this is a Listen that needs to
// be accepted
//
if ( ((tCONNECTELE *)ulExtra)->state == NBT_SESSION_WAITACCEPT )
{
//
// Accept the connection
//
VxdAccept( (tCONNECTELE *) ulExtra, NULL ) ;
}
break ;
case NCBRESET:
pRstCont = (PRESET_CONTEXT) pNCB->ncb_reserve ;
if ( pRstCont->cActiveSessions != -1 ||
pRstCont->cActiveNames )
{
DbgPrint("VxdIoComplete: Disconnect/Name de-reg completed from Reset, remaining disconnects, names: ") ;
DbgPrintNum( pRstCont->cActiveSessions ) ;
DbgPrintNum( pRstCont->cActiveNames ) ; DbgPrint("\r\n") ;
//
// Only complete the Reset NCB after all session have been
// disconnected and the names have been released on the network
//
if ( pRstCont->cActiveSessions != -1 )
{
if ( --pRstCont->cActiveSessions == 0 )
{
//
// Starts the name deletion process
//
pRstCont->cActiveSessions = -1 ;
VxdResetContinue( pDeviceContext, pNCB ) ;
}
return ;
}
if ( --pRstCont->cActiveNames != 0 )
{
return ;
}
}
if ( !errNCB )
errNCB = pRstCont->errncb ;
// Fall through
case NCBUNLINK:
pNCB->ncb_retcode = errNCB ;
pNCB->ncb_cmd_cplt = errNCB ;
goto SkipPost ;
case NCBCANCEL:
pNCB->ncb_retcode = errNCB ;
pNCB->ncb_cmd_cplt = errNCB ;
break;
case NCBHANGUP:
case NCBDELNAME:
case NCBTRACE:
break ;
default:
DbgPrint("VxdIoComplete: Unexpected NCB command: 0x") ;
DbgPrintNum( pNCB->ncb_command ) ; DbgPrint("\r\n") ;
break ;
}
if ( pNCB->ncb_retcode == NRC_PENDING )
{
pNCB->ncb_retcode = errNCB ;
pNCB->ncb_cmd_cplt = errNCB ;
}
else
{
if ( (pNCB->ncb_command & ~ASYNCH) != NCBCANCEL )
{
CTEPrint("VxdIoComplete: ncb_retcode already set!\r\n") ;
CTEPrint("\tCommand: 0x") ; DbgPrintNum(pNCB->ncb_command) ;
CTEPrint(" NCB Address: 0x") ; DbgPrintNum( (ULONG) pNCB ) ;
}
goto SkipPost ;
}
//
// call the post-routine only if this was a no-wait call and if
// the post-routine has been specified!
//
if ( fAsync && pNCB->ncb_post )
{
typedef void (CALLBACK * VXDNCBPost )( void ) ;
VXDNCBPost ncbpost = (VXDNCBPost) pNCB->ncb_post ;
//
// Clients are expecting EBX to point to the NCB (instead of
// pushing it on the stack...). The post routine may trash
// ebp also, so save it.
//
_asm push ebp ;
_asm mov ebx, pNCB ;
ncbpost() ;
_asm pop ebp ;
}
SkipPost:
//
// Now that we've completed the NCB, unblock if it was a Wait NCB
//
if ( !fAsync )
{
PBLOCKING_NCB_CONTEXT pBlkNcbContext;
PLIST_ENTRY pHead, pEntry ;
//
// find the blocking ncb context from the list corresponding to this ncb
//
pHead = &NbtConfig.BlockingNcbs;
pEntry = pHead->Flink;
while( pEntry != pHead )
{
pBlkNcbContext = CONTAINING_RECORD( pEntry, BLOCKING_NCB_CONTEXT, Linkage ) ;
if (pBlkNcbContext->pNCB == pNCB)
break;
else
pBlkNcbContext = NULL;
pEntry = pEntry->Flink;
}
if (pBlkNcbContext)
{
ASSERT(pBlkNcbContext->Verify == NBT_VERIFY_BLOCKING_NCB);
//
// if the ncb is blocked for completion, remove the context from
// the list first (important!) and then signal the thread that we
// are done. Then free the memory.
//
if ( pBlkNcbContext->fBlocked )
{
RemoveEntryList(&pBlkNcbContext->Linkage);
CTESignal( pBlkNcbContext->pWaitNCBBlock, 0 ) ;
CTEFreeMem(pBlkNcbContext->pWaitNCBBlock);
CTEFreeMem(pBlkNcbContext);
}
else
{
pBlkNcbContext->fNCBCompleted = TRUE;
}
}
else
{
DbgPrint("VxdIoComplete: didn't find blocking ncb context\r\n") ;
DbgPrint("for NCB Address: 0x") ; DbgPrintNum( (ULONG) pNCB ) ;
}
}
}
/*******************************************************************
NAME: VxdInitSessionSetup
SYNOPSIS: Common initialization required for Call and Listen
ENTRY: pDeviceContext - Adapter to setup on
pRequest - Request to fill in if successful
ppSessSetupContext - Context to be filled
pNCB - NCB doing the call/listen
EXIT:
RETURNS: NRC_GOODRET if successful, error code otherwise
NOTES:
HISTORY:
Johnl 26-May-1993 Created
********************************************************************/
NCBERR VxdInitSessionSetup( tDEVICECONTEXT * pDeviceContext,
TDI_REQUEST * pRequest,
PSESS_SETUP_CONTEXT * ppSessSetupContext,
NCB * pNCB )
{
NTSTATUS status;
NCBERR errNCB ;
TDI_REQUEST_STATUS RequestStatus ;
tCLIENTELE * pClientEle ;
tCONNECTELE * pConnEle ;
tNAMEADDR * pNameAddr ;
USHORT NameType ;
BOOL fIsListen = ((pNCB->ncb_command & ~ASYNCH)
== NCBLISTEN) ;
*ppSessSetupContext = NULL ;
//
// Lookup the Client Element associated with this name and verify
// it's valid
//
if ( errNCB = VxdNameToClient( pDeviceContext,
pNCB->ncb_name,
NULL,
&pClientEle ))
{
return errNCB ;
}
if ( pClientEle->fDeregistered )
return NRC_NOWILD ;
//
// Request.Handle.ConnectionContext will contain Connection
// element after we open the connection
//
if ( status = NbtOpenConnection( pRequest,
NULL, //ConnectionContext, // Passed to connect and disconnect handlers
pDeviceContext ) )
{
return MapTDIStatus2NCBErr( status ) ;
}
//
// Initialize the connection context (used by Vxd disconnect handler)
//
pConnEle = (tCONNECTELE *) pRequest->Handle.ConnectionContext ;
pConnEle->ConnectContext = pConnEle ;
if ( status = NbtAssociateAddress( pRequest,
pClientEle,
NULL ))
{
goto ErrorExit1 ;
}
ASSERT( sizeof( SESS_SETUP_CONTEXT ) <= (sizeof( pNCB->ncb_reserve ) +
sizeof( pNCB->ncb_event )) ) ;
*ppSessSetupContext = (PSESS_SETUP_CONTEXT) pNCB->ncb_reserve ;
if ( status = AllocSessSetupContext( *ppSessSetupContext,
*pNCB->ncb_callname == '*' ) )
goto ErrorExit0 ;
//
// Listen for '*' uses a NULL Request remote address
//
if ( *pNCB->ncb_callname != '*' )
{
InitNBTDIConnectInfo( (*ppSessSetupContext)->pRequestConnect,
(*ppSessSetupContext)->pRequestConnect->RemoteAddress,
pNCB->ncb_callname ) ;
}
InitNBTDIConnectInfo( (*ppSessSetupContext)->pReturnConnect,
(*ppSessSetupContext)->pReturnConnect->RemoteAddress,
pNCB->ncb_name ) ;
(*ppSessSetupContext)->fIsWorldListen = (pNCB->ncb_callname[0] == '*') ;
(*ppSessSetupContext)->pConnEle = pConnEle ;
return NRC_GOODRET ;
ErrorExit0:
if ( !(NbtDisassociateAddress( pRequest ) == TDI_SUCCESS))
CTEPrint("VxdInitSessionSetup: AllocSesssetupContext failed and DisassociateAddress failed\r\n") ;
ErrorExit1:
REQUIRE( NbtCloseConnection( pRequest,
&RequestStatus,
pDeviceContext,
NULL ) == TDI_SUCCESS ) ;
return MapTDIStatus2NCBErr( status ) ;
}
/*******************************************************************
NAME: VxdFindClientElement
SYNOPSIS: Finds the appropriate client element
ENTRY: pDeviceContext - Device to search on
ncbnum - NCB Name Number
ppClientEle - Receives result of search
Type - If CLIENT_BC (broadcast), then the Broadcast client
element for the pDeviceContext adapter is returned
RETURNS: STATUS_SUCCESS if the name is found, error code otherwise
NOTES: The device context points to a list of Address elements (one
address element for each Netbios name in the system). Each
address element has a Client Element list hanging off of it.
We return the first client element off of the Address Element
as there shouldn't be more then one client (is this true?).
HISTORY:
Johnl 23-Apr-1993 Created
********************************************************************/
NCBERR VxdFindClientElement( tDEVICECONTEXT * pDeviceContext,
UCHAR ncbnum,
tCLIENTELE * * ppClientEle,
enum CLIENT_TYPE Type )
{
ASSERT( pDeviceContext != NULL ) ;
if ( !pDeviceContext )
return NRC_SYSTEM ;
if ( Type != CLIENT_BC )
{
if ( ncbnum > pDeviceContext->cMaxNames || !pDeviceContext->pNameTable[ncbnum] )
return NRC_ILLNN ;
*ppClientEle = (tCLIENTELE *) pDeviceContext->pNameTable[ncbnum] ;
return NRC_GOODRET ;
}
else
{
NTSTATUS status;
tCLIENTELE * pClientEleBcast ;
UCHAR pName[NETBIOS_NAME_SIZE];
tNAMEADDR * pNameAddr;
PLIST_ENTRY pHead;
PLIST_ENTRY pEntry;
//
// find the * name in the local hash table
//
CTEZeroMemory(pName,NETBIOS_NAME_SIZE);
pName[0] = '*';
status = FindInHashTable(NbtConfig.pLocalHashTbl,
pName,
NbtConfig.pScope,
&pNameAddr);
if (NT_SUCCESS(status))
{
pHead = &pNameAddr->pAddressEle->ClientHead;
pEntry = pHead->Flink;
while ( pEntry != pHead )
{
pClientEleBcast = CONTAINING_RECORD( pEntry, tCLIENTELE, Linkage ) ;
if ( pClientEleBcast->pDeviceContext == pDeviceContext )
{
*ppClientEle = pClientEleBcast ;
break ;
}
pEntry = pEntry->Flink ;
}
}
else
{
return(NRC_ILLNN);
}
if ( pEntry == pHead )
return NRC_ILLNN ;
}
return NRC_GOODRET ;
}
/*******************************************************************
NAME: VxdFindConnectElement
SYNOPSIS: Finds the appropriate connect element from the
session number
ENTRY: pDeviceContext - Device to search on
lsn - NCB LS Number
ppConnectEle - Receives result of search
RETURNS: NRC_GOODRET if successful, error otherwise
NOTES: LSN 0 will be disallowed because pSessionTable[0] is always
NULL
HISTORY:
Johnl 23-Apr-1993 Created
********************************************************************/
NCBERR VxdFindConnectElement( tDEVICECONTEXT * pDeviceContext,
NCB * pNCB,
tCONNECTELE * * ppConnectEle )
{
UCHAR lsn ;
ASSERT( pNCB != NULL ) ;
ASSERT( pDeviceContext != NULL ) ;
if ( !pDeviceContext || !pNCB )
return NRC_SYSTEM ;
lsn = pNCB->ncb_lsn ;
if ( lsn > pDeviceContext->cMaxSessions || !pDeviceContext->pSessionTable[lsn] )
return NRC_SNUMOUT ;
*ppConnectEle = pDeviceContext->pSessionTable[lsn] ;
//
// Check to see if the connection is down but the NB client hasn't been
// notified, if so notify them and remove the session from the table
//
if ( ( (*ppConnectEle)->state == NBT_ASSOCIATED ||
(*ppConnectEle)->state == NBT_IDLE ) &&
(*ppConnectEle)->RefCount == 1 )
{
DbgPrint("VxdFindConnectElement: Deleting connection element\r\n") ;
NbtDereferenceConnection( *ppConnectEle ) ;
REQUIRE( NBUnregister( pDeviceContext, lsn, NB_SESSION )) ;
return NRC_SCLOSED ;
}
return NRC_GOODRET ;
}
/*******************************************************************
NAME: VxdFindLSN
SYNOPSIS: Finds a session number from its tCONNECTELE *.
ENTRY: pDeviceContext - Device to search on
pConnectEle - Connect element to find
plsn - Index pConnectEle was found at
NOTES:
HISTORY:
Johnl 07-Jul-1993 Created
********************************************************************/
NCBERR VxdFindLSN( tDEVICECONTEXT * pDeviceContext,
tCONNECTELE * pConnectEle,
UCHAR * plsn )
{
ASSERT( (pDeviceContext != NULL) && (pConnectEle != NULL) && (plsn != NULL)) ;
ASSERT( pConnectEle->Verify == NBT_VERIFY_CONNECTION ||
pConnectEle->Verify == NBT_VERIFY_CONNECTION_DOWN ) ;
for ( *plsn = 0 ; *plsn <= pDeviceContext->cMaxSessions ; (*plsn)++ )
{
if ( pDeviceContext->pSessionTable[*plsn] == pConnectEle )
return NRC_GOODRET ;
}
ASSERT( FALSE ) ;
return NRC_SNUMOUT ;
}
/*******************************************************************
NAME: VxdFindNameNum
SYNOPSIS: Finds a name number from its tADDRESSELE *.
ENTRY: pDeviceContext - Device to search on
pAddressEle - Address element to find
pNum - Index pAddressEle was found at
NOTES:
HISTORY:
Johnl 07-Jul-1993 Created
********************************************************************/
NCBERR VxdFindNameNum( tDEVICECONTEXT * pDeviceContext,
tADDRESSELE * pAddressEle,
UCHAR * pNum )
{
tCLIENTELE *pClientEle;
ASSERT( (pDeviceContext != NULL) && (pAddressEle != NULL) && (pNum != NULL)) ;
ASSERT( pAddressEle->Verify == NBT_VERIFY_ADDRESS ) ;
for ( *pNum = 0 ; *pNum <= pDeviceContext->cMaxNames ; (*pNum)++ )
{
pClientEle = pDeviceContext->pNameTable[*pNum];
if ( (pClientEle) && (pClientEle->pAddress == pAddressEle ) )
return NRC_GOODRET ;
}
return NRC_ILLNN ;
}
/*******************************************************************
NAME: VxdNameToClient
SYNOPSIS: Converts a ncb_callname to the corresponding client element
in the name table
ENTRY: pDeviceContext - Device to search on
pchName - Name to find
pNameNum - Index into table name number is at (Optional)
ppClientEle - Client element in the name table
NOTES:
HISTORY:
Johnl 15-Oct-1993 Created
********************************************************************/
NCBERR VxdNameToClient( tDEVICECONTEXT * pDeviceContext,
CHAR * pName,
UCHAR * pNameNum,
tCLIENTELE * * ppClientEle )
{
USHORT NameType ;
tNAMEADDR * pNameAddr ;
UCHAR NameNum ;
NTSTATUS status;
//
// Lookup the Client Element associated with this name
//
if ( pName[0] == '*' )
{
return NRC_NOWILD ; // Also means name not found
}
status = FindInHashTable(
NbtConfig.pLocalHashTbl,
pName,
NbtConfig.pScope,
&pNameAddr);
if (!NT_SUCCESS(status))
{
return NRC_NOWILD ; // Also means name not found
}
//
// if the name is not registered on the adapter (provided by the client)
// tell the client so!
//
if ( pNameAddr->AdapterMask &&
!(pNameAddr->AdapterMask & pDeviceContext->AdapterNumber) )
{
DbgPrint("VxdNameToClient: wrong DeviceContext element\r\n") ;
return NRC_NOWILD ;
}
if ( VxdFindNameNum( pDeviceContext, pNameAddr->pAddressEle, &NameNum ))
{
ASSERT( FALSE ) ;
return NRC_NOWILD ;
}
REQUIRE( !VxdFindClientElement( pDeviceContext,
NameNum,
ppClientEle,
CLIENT_LOCAL )) ;
ASSERT( (*ppClientEle)->Verify == NBT_VERIFY_CLIENT ) ;
if ( pNameNum != NULL )
*pNameNum = NameNum ;
return NRC_GOODRET ;
}
/*******************************************************************
NAME: NBRegister
SYNOPSIS: Finds the next available slot in apElem and assigns
pElem to that slot according to Netbios rules
ENTRY: pDeviceContext - Adapter we are adding name to
pNCBNum - Receives the found free slot
pElem - Element we are registering
NbTable - Indicates the Name table or session table
EXIT: *pNCBNum will point to the found slot and
apElem[*pNCBNum] will point to pElem
RETURNS: TRUE if we found a free slot, FALSE if the table was
full.
NOTES: The Netbios spec states that returned NCB nums and Logical
Session numbers increase to 254 until they wrap to 1 (0
is reserved for the adapter name).
HISTORY:
Johnl 28-Apr-1993 Created
********************************************************************/
BOOL NBRegister( tDEVICECONTEXT * pDeviceContext,
UCHAR * pNCBNum,
PVOID pElem,
NB_TABLE_TYPE NbTable )
{
UCHAR i ;
BOOL fFound = FALSE ;
BOOL fPassTwo = FALSE ;
UCHAR MaxNCBNum ;
UCHAR * piCurrent ;
PVOID * apElem ;
ASSERT( pElem != NULL ) ;
if ( NbTable == NB_NAME )
{
MaxNCBNum = pDeviceContext->cMaxNames ;
apElem = pDeviceContext->pNameTable ;
piCurrent = &pDeviceContext->iNcbNum ;
}
else
{
MaxNCBNum = pDeviceContext->cMaxSessions ;
apElem = pDeviceContext->pSessionTable ;
piCurrent = &pDeviceContext->iLSNum ;
}
//
// Find the next free name number and store it in pNCBNum
//
for ( i = *piCurrent ; ; i++ )
{
if ( i > MaxNCBNum )
i = 1 ;
if ( !apElem[i] )
{
fFound = TRUE ;
break ;
}
//
// Second time we hit *piCurrent means there are no free slots
//
if ( i == *piCurrent)
{
if ( fPassTwo )
break ;
else
fPassTwo = TRUE ;
}
}
if ( fFound )
{
apElem[i] = pElem ;
*pNCBNum = *piCurrent = i ;
(*piCurrent)++ ;
if ( *piCurrent > MaxNCBNum )
*piCurrent = 1 ;
}
return fFound ;
}
/*******************************************************************
NAME: NBUnregister
SYNOPSIS: Invalidates the passed netbios number
ENTRY: NCBNum - Name number to unregister
EXIT: The name number entry will be set to NULL
RETURNS: TRUE if we freed the slot, FALSE if the name wasn't
registered in the first place or it's out of range
NOTES:
HISTORY:
Johnl 05-May-1993 Created
********************************************************************/
BOOL NBUnregister( tDEVICECONTEXT * pDeviceContext,
UCHAR NCBNum,
NB_TABLE_TYPE NbTable )
{
UCHAR MaxNCBNum ;
PVOID * apElem ;
if ( NbTable == NB_NAME )
{
MaxNCBNum = pDeviceContext->cMaxNames ;
apElem = pDeviceContext->pNameTable ;
}
else
{
MaxNCBNum = pDeviceContext->cMaxSessions ;
apElem = pDeviceContext->pSessionTable ;
}
if ( NCBNum > MaxNCBNum || apElem[NCBNum] == NULL )
{
return FALSE ;
}
apElem[NCBNum] = NULL ;
return TRUE ;
}
/*******************************************************************
NAME: VxdCompleteSessionNcbs
SYNOPSIS: Finds all NCBs attached to a session and completes them
ENTRY: pDeviceContext - Device we are on
pConnEle - Session connection element to complete NCBs on
NOTES:
HISTORY:
Johnl 16-Aug-1993 Broke out as common code
********************************************************************/
TDI_STATUS VxdCompleteSessionNcbs( tDEVICECONTEXT * pDeviceContext,
tCONNECTELE * pConnEle )
{
PLIST_ENTRY pHead, pEntry ;
PRCV_CONTEXT prcvCont ;
BOOL fCompleteToClient = TRUE ;
UCHAR lsn ;
NCBERR errNCB ;
BOOL fAnyFound = FALSE ;
ASSERT( pConnEle != NULL ) ;
ASSERT( pConnEle->Verify == NBT_VERIFY_CONNECTION ||
pConnEle->Verify == NBT_VERIFY_CONNECTION_DOWN ) ;
if ( errNCB = VxdFindLSN( pDeviceContext,
pConnEle,
&lsn ))
{
//
// This shouldn't happen but watch for it in case we get in a
// weird situation
//
DbgPrint("VxdCompleteSessionNCBs - Warning: VxdFindLsn failed\r\n") ;
return STATUS_UNSUCCESSFUL ;
}
//
// Complete the first RcvAny
//
if ( pConnEle->pClientEle &&
!IsListEmpty( &pConnEle->pClientEle->RcvAnyHead ))
{
pEntry = RemoveHeadList( &pConnEle->pClientEle->RcvAnyHead ) ;
prcvCont = CONTAINING_RECORD( pEntry, RCV_CONTEXT, ListEntry ) ;
ASSERT( prcvCont->Signature == RCVCONT_SIGN ) ;
//
// Set the session number so the client knows which session is going
// away.
//
prcvCont->pNCB->ncb_lsn = lsn ;
CTEIoComplete( prcvCont->pNCB,
STATUS_CONNECTION_DISCONNECTED,
0 ) ;
fAnyFound = TRUE ;
}
//
// Now kill all of the outstanding receives. Sends are completed as
// they are submitted so nothing to kill.
//
while ( !IsListEmpty( &pConnEle->RcvHead ))
{
pEntry = RemoveHeadList( &pConnEle->RcvHead ) ;
prcvCont = CONTAINING_RECORD( pEntry, RCV_CONTEXT, ListEntry ) ;
ASSERT( prcvCont->Signature == RCVCONT_SIGN ) ;
CTEIoComplete( prcvCont->pNCB,
STATUS_CONNECTION_DISCONNECTED,
0 ) ;
fAnyFound = TRUE ;
}
//
// Once the client has been notified, deref the connection
// element so the memory will be deleted when the connection is
// closed. If the client wasn't notified, then the connection remains
// in our table until the next NCB on this session.
//
if ( fAnyFound &&
!(pConnEle->Flags & NB_CLIENT_NOTIFIED) )
{
DbgPrint("CompleteSessionNcbs - Marking connection as notified\r\n") ;
pConnEle->Flags |= NB_CLIENT_NOTIFIED ;
NbtDereferenceConnection( pConnEle ) ;
}
return TDI_SUCCESS ;
}
/*******************************************************************
NAME: VxdTearDownSession
SYNOPSIS: Closes a session and deletes its session context
ENTRY: pConnEle - Pointer to connection session element to close
pCont - Session context to delete (or NULL to ignore)
pSessSetupContext - Session context to delete if non-NULL
pNCB - NCB to complete after disconnect finishes
NOTES:
HISTORY:
Johnl 16-Aug-1993 Commonized
********************************************************************/
void VxdTearDownSession( tDEVICECONTEXT * pDeviceContext,
tCONNECTELE * pConnEle,
PSESS_SETUP_CONTEXT pSessSetupContext,
NCB * pNCB )
{
TDI_STATUS tdistatus ;
TDI_REQUEST Request ;
if ( pConnEle != NULL )
{
ASSERT((pConnEle->Verify == NBT_VERIFY_CONNECTION) ||
(pConnEle->Verify == NBT_VERIFY_CONNECTION_DOWN)) ;
Request.Handle.ConnectionContext = pConnEle ;
tdistatus = NbtDisconnect( &Request, 0, TDI_DISCONNECT_ABORT, NULL, NULL, NULL ) ;
if ( tdistatus && tdistatus != TDI_PENDING )
{
DbgPrint("VxdTearDownSession - NbtDisconnect returned error " ) ;
DbgPrintNum( tdistatus ) ;
DbgPrint("\r\n") ;
}
tdistatus = NbtCloseConnection( &Request,
NULL,
pDeviceContext,
NULL ) ;
if ( tdistatus && tdistatus != TDI_PENDING )
{
DbgPrint("VxdTearDownSession - NbtCloseConnection returned error " ) ;
DbgPrintNum( tdistatus ) ;
DbgPrint("\r\n") ;
}
}
if ( pSessSetupContext )
FreeSessSetupContext( pSessSetupContext ) ;
}
/*******************************************************************
NAME: AllocSessSetupContext
SYNOPSIS: Allocates and initializes a listen context structure
ENTRY: pSessSetupContext - Pointer to structure
fListenOnStar - TRUE if the request remote address should
be left as NULL
NOTES:
HISTORY:
Johnl 19-May-1993 Created
********************************************************************/
TDI_STATUS AllocSessSetupContext( PSESS_SETUP_CONTEXT pSessSetupContext,
BOOL fListenOnStar )
{
CTEZeroMemory( pSessSetupContext, sizeof( SESS_SETUP_CONTEXT ) ) ;
if ( !(pSessSetupContext->pRequestConnect =
CTEAllocMem( sizeof( TDI_CONNECTION_INFORMATION ))) ||
!(pSessSetupContext->pReturnConnect =
CTEAllocMem( sizeof( TDI_CONNECTION_INFORMATION))) )
{
goto ErrorExit1 ;
}
pSessSetupContext->pRequestConnect->RemoteAddress = NULL ;
pSessSetupContext->pReturnConnect->RemoteAddress = NULL ;
if ( !(pSessSetupContext->pReturnConnect->RemoteAddress =
CTEAllocMem( sizeof( TA_NETBIOS_ADDRESS ))) ||
(!fListenOnStar &&
!(pSessSetupContext->pRequestConnect->RemoteAddress =
CTEAllocMem( sizeof( TA_NETBIOS_ADDRESS )))) )
{
goto ErrorExit0 ;
}
return TDI_SUCCESS ;
ErrorExit0:
if ( pSessSetupContext->pRequestConnect->RemoteAddress)
CTEFreeMem( pSessSetupContext->pRequestConnect->RemoteAddress ) ;
if ( pSessSetupContext->pReturnConnect->RemoteAddress)
CTEFreeMem( pSessSetupContext->pReturnConnect->RemoteAddress ) ;
ErrorExit1:
if ( pSessSetupContext->pRequestConnect)
CTEFreeMem( pSessSetupContext->pRequestConnect ) ;
if ( pSessSetupContext->pReturnConnect)
CTEFreeMem( pSessSetupContext->pReturnConnect ) ;
return TDI_NO_RESOURCES ;
}
/*******************************************************************
NAME: FreeSessSetupContext
SYNOPSIS: Frees a successfully initialized listen context
ENTRY: pSessSetupContext - Context to be freed
HISTORY:
Johnl 19-May-1993 Created
********************************************************************/
void FreeSessSetupContext( PSESS_SETUP_CONTEXT pSessSetupContext )
{
if ( pSessSetupContext->pRequestConnect->RemoteAddress )
CTEFreeMem( pSessSetupContext->pRequestConnect->RemoteAddress ) ;
CTEFreeMem( pSessSetupContext->pReturnConnect->RemoteAddress ) ;
CTEFreeMem( pSessSetupContext->pRequestConnect ) ;
CTEFreeMem( pSessSetupContext->pReturnConnect ) ;
}
/*******************************************************************
NAME: DelayedSessEstablish
SYNOPSIS: This routine is called by VxdScheduleDelayedEvent.
After name query is successful, we typically make a tcp
connection. We delay that step until later so that stack
usage is reduced. (yes, there is only 4k of stack on chicago!)
ENTRY: pContext - context that contains the actual parms
RETURNS: Nothing
HISTORY:
Koti Dec. 19, 94
********************************************************************/
VOID DelayedSessEstablish( PVOID pContext )
{
tDGRAM_SEND_TRACKING *pTracker;
NTSTATUS status;
COMPLETIONCLIENT pClientCompletion;
//
// get our parameters out
//
pTracker = ((NBT_WORK_ITEM_CONTEXT *)pContext)->pTracker;
status = (NTSTATUS)((NBT_WORK_ITEM_CONTEXT *)pContext)->pClientContext;
pClientCompletion = ((NBT_WORK_ITEM_CONTEXT *)pContext)->ClientCompletion;
CTEMemFree(pContext);
CompleteClientReq(pClientCompletion,
pTracker,
status);
}
/*******************************************************************
NAME: VxdApiWorker
SYNOPSIS: When clients such as another vxd or a V86 app (such as
nbtstat.exe) make requests for information or some service,
this is the routine that gets called.
ENTRY: OpCode - what info or service is being requested
ClientBuffer - buffer in which to pass info
ClientBufLen - how big is the buffer
RETURNS: ErrorCode from the operation (0 if success)
HISTORY:
Koti 16-Jun-1994 Created
********************************************************************/
NTSTATUS
VxdApiWorker(
DWORD Ioctl,
PVOID ClientOutBuffer,
DWORD ClientOutBufLen,
PVOID ClientInBuffer,
DWORD ClientInBufLen,
DWORD fOkToTrashInputBuffer
)
{
NTSTATUS status;
USHORT OpCode;
int i;
USHORT NumLanas;
PCHAR pchBuffer;
DWORD dwSize;
DWORD dwBytesToCopy;
PULONG pIpAddr;
PLIST_ENTRY pEntry,pHead;
tDEVICECONTEXT *pDeviceContext;
NCB ncb;
UCHAR retcode;
tIPANDNAMEINFO *pIpAndNameInfo;
tIPCONFIG_INFO *pIpCfg;
status = STATUS_SUCCESS;
dwSize = ClientOutBufLen;
// always use the first adapter on the list
pDeviceContext = CONTAINING_RECORD(NbtConfig.DeviceContexts.Flink,tDEVICECONTEXT,Linkage);
OpCode = (USHORT)Ioctl;
switch (OpCode)
{
// nbtstat -<any option>
case IOCTL_NETBT_GET_IP_ADDRS :
if (ClientOutBufLen < sizeof(ULONG)*(NbtConfig.AdapterCount + 1))
{
return( STATUS_BUFFER_OVERFLOW );
}
if (!ClientOutBuffer)
{
return( STATUS_INVALID_PARAMETER );
}
pIpAddr = (PULONG )ClientOutBuffer;
pEntry = pHead = &NbtConfig.DeviceContexts;
while ((pEntry = pEntry->Flink) != pHead)
{
pDeviceContext = CONTAINING_RECORD(pEntry,tDEVICECONTEXT,Linkage);
if (pDeviceContext->IpAddress)
{
*pIpAddr = pDeviceContext->IpAddress;
pIpAddr++;
}
}
//
// put a 0 address on the end
//
*pIpAddr = 0;
status = STATUS_SUCCESS;
break;
// nbtstat -n (or -N)
case IOCTL_NETBT_GET_LOCAL_NAMES :
// nbtstat -c
case IOCTL_NETBT_GET_REMOTE_NAMES :
if (!ClientOutBuffer || ClientOutBufLen == 0)
return (STATUS_INSUFFICIENT_RESOURCES);
if (OpCode == IOCTL_NETBT_GET_REMOTE_NAMES )
{
// make this null, so NbtQueryAda..() knows this is for remote
pDeviceContext = NULL;
}
// return an array of netbios names that are registered
status = NbtQueryAdapterStatus(pDeviceContext,
&pchBuffer,
&dwSize);
break;
// nbtstat -r
case IOCTL_NETBT_GET_BCAST_NAMES :
// return an array of netbios names that are registered
status = NbtQueryBcastVsWins(pDeviceContext,&pchBuffer,&dwSize);
break;
// nbtstat -R
case IOCTL_NETBT_PURGE_CACHE :
status = NbtResyncRemoteCache();
break;
// nbtstat -s, nbtstat -S
case IOCTL_NETBT_GET_CONNECTIONS :
// return an array of netbios names that are registered
status = NbtQueryConnectionList(NULL,
&pchBuffer,
&dwSize);
break;
// nbtstat -a, nbtstat -A
case IOCTL_NETBT_ADAPTER_STATUS:
if (!ClientOutBuffer)
{
return( STATUS_INVALID_PARAMETER );
}
CTEZeroMemory( &ncb, sizeof(NCB) );
ncb.ncb_command = NCBASTAT;
ncb.ncb_buffer = ClientOutBuffer;
ncb.ncb_length = ClientOutBufLen;
ncb.ncb_lana_num = pDeviceContext->iLana;
if (!ClientInBuffer)
{
return( STATUS_INVALID_PARAMETER );
}
pIpAndNameInfo = (tIPANDNAMEINFO *)ClientInBuffer;
//
// see if Ipaddress is specified: if yes, use it
//
if ( pIpAndNameInfo->IpAddress )
{
ncb.ncb_callname[0] = '*';
retcode = VNBT_NCB_X( &ncb, 0, &pIpAndNameInfo->IpAddress, 0, 0 );
}
//
// no ipaddress: use the name that's given to us
//
else
{
CTEMemCopy(
&ncb.ncb_callname[0],
&(pIpAndNameInfo->NetbiosAddress.Address[0].Address[0].NetbiosName[0]),
NCBNAMSZ );
retcode = VNBT_NCB_X( &ncb, 0, 0, 0, 0 );
}
status = STATUS_UNSUCCESSFUL;
if (!retcode)
{
if (ncb.ncb_retcode == NRC_GOODRET)
status = STATUS_SUCCESS;
else if (ncb.ncb_retcode == NRC_INCOMP)
status = TDI_BUFFER_OVERFLOW;
}
break;
// ipconfig queries us for nodetype and scope
case IOCTL_NETBT_IPCONFIG_INFO:
dwBytesToCopy = sizeof(tIPCONFIG_INFO) +
NbtConfig.ScopeLength;
if ( !ClientOutBuffer || ClientOutBufLen < dwBytesToCopy )
{
status = STATUS_BUFFER_OVERFLOW;
break;
}
pIpCfg = (tIPCONFIG_INFO *)ClientOutBuffer;
NumLanas = 0;
for ( i = 0; i < NBT_MAX_LANAS; i++)
{
if (LanaTable[i].pDeviceContext != NULL)
{
pDeviceContext = LanaTable[i].pDeviceContext;
pIpCfg->LanaInfo[NumLanas].LanaNumber = pDeviceContext->iLana;
pIpCfg->LanaInfo[NumLanas].IpAddress = pDeviceContext->IpAddress;
pIpCfg->LanaInfo[NumLanas].NameServerAddress = pDeviceContext->lNameServerAddress;
pIpCfg->LanaInfo[NumLanas].BackupServer = pDeviceContext->lBackupServer;
pIpCfg->LanaInfo[NumLanas].lDnsServerAddress = pDeviceContext->lDnsServerAddress;
pIpCfg->LanaInfo[NumLanas].lDnsBackupServer = pDeviceContext->lDnsBackupServer;
NumLanas++;
}
}
pIpCfg->NumLanas = NumLanas;
pIpCfg->NodeType = NodeType;
pIpCfg->ScopeLength = NbtConfig.ScopeLength;
CTEMemCopy( &pIpCfg->szScope[0],
NbtConfig.pScope,
NbtConfig.ScopeLength );
status = STATUS_SUCCESS;
break;
default:
status = STATUS_NOT_SUPPORTED;
break;
}
//
// Copy the output into user's buffer
//
if ( (OpCode == IOCTL_NETBT_GET_LOCAL_NAMES) ||
(OpCode == IOCTL_NETBT_GET_REMOTE_NAMES) ||
(OpCode == IOCTL_NETBT_GET_CONNECTIONS) ||
(OpCode == IOCTL_NETBT_GET_BCAST_NAMES) )
{
if ( NT_SUCCESS(status) || (status == STATUS_BUFFER_OVERFLOW))
{
if ( status == STATUS_BUFFER_OVERFLOW )
{
dwBytesToCopy = ClientOutBufLen;
}
else
{
dwBytesToCopy = dwSize;
status = STATUS_SUCCESS;
}
CTEMemCopy( ClientOutBuffer, pchBuffer, dwBytesToCopy ) ;
CTEMemFree((PVOID)pchBuffer);
}
}
//
// we may be called either through the vxd entry point which 16 bit apps
// will do (for now, only nbtstat.exe), or through the file system api's
// which 32 bit apps will do via CreateFile and ioctl.
// If we came here through file system (i.e.VNBT_DeviceIoControl called us)
// then don't trash the input buffer since the status gets passed back as
// it is. For 16 bit apps (i.e.VNBT_Api_Handler called us), the only way
// we can pass status back (without major changes all over) is through the
// input buffer.
//
if ( ClientInBuffer && fOkToTrashInputBuffer )
{
*(NTSTATUS *)ClientInBuffer = status;
}
return( status );
}
/*******************************************************************
NAME: PostInit_Proc
SYNOPSIS: After the whole system is initialized, we get the
Sys_Vm_Init message and that's when this routine gets called.
This can be used for any post-processing, but for now we
only use it to load lmhosts (this way, we can load all the
#INCLUDE files which have UNC's in them, since now we know
the net is up).
RETURNS: ErrorCode from the operation (0 if success)
HISTORY:
Koti 12-Jul-1994 Created
********************************************************************/
NTSTATUS
PostInit_Proc()
{
LONG lRetcode;
CachePrimed = FALSE;
CTEPagedCode();
lRetcode = PrimeCache( NbtConfig.pLmHosts,
NULL,
TRUE,
NULL) ;
if (lRetcode != -1)
{
CachePrimed = TRUE ;
}
}
/*******************************************************************
NAME: CTEAllocInitMem
SYNOPSIS: Allocates memory during driver initialization
NOTES: If first allocation fails, we refill the heap spare and
try again. We can only do this during driver initialization
because the act of refilling may yield the current
thread.
HISTORY:
Johnl 27-Aug-1993 Created
********************************************************************/
PVOID CTEAllocInitMem( ULONG cbBuff )
{
PVOID pv = CTEAllocMem( cbBuff ) ;
if ( pv )
{
return pv ;
}
else if ( fInInit )
{
DbgPrint("CTEAllocInitMem: Failed allocation, trying again\r\n") ;
CTERefillMem() ;
pv = CTEAllocMem( cbBuff ) ;
}
return pv ;
}