able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/sfm/atalk/sys/arap.c

2905 lines
80 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
arap.c
Abstract:
This module implements routines specific to ARAP
Author:
Shirish Koti
Revision History:
15 Nov 1996 Initial Version
--*/
#include <atalk.h>
#pragma hdrstop
#define FILENUM ARAP
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, ArapProcessIoctl)
#pragma alloc_text(PAGE_ARAP, ArapMarkConnectionUp)
#pragma alloc_text(PAGE_ARAP, ArapIoctlRecv)
#pragma alloc_text(PAGE_ARAP, ArapExchangeParms)
#pragma alloc_text(PAGE_ARAP, ArapConnect)
#pragma alloc_text(PAGE_ARAP, ArapConnectComplete)
#pragma alloc_text(PAGE_ARAP, ArapDisconnect)
#pragma alloc_text(PAGE_ARAP, ArapGetAddr)
#pragma alloc_text(PAGE_ARAP, ArapGetStats)
#pragma alloc_text(PAGE_ARAP, ArapIoctlSend)
#pragma alloc_text(PAGE_ARAP, ArapSendPrepare)
#pragma alloc_text(PAGE_ARAP, ArapMnpSendComplete)
#pragma alloc_text(PAGE_ARAP, ArapIoctlSendComplete)
#pragma alloc_text(PAGE_ARAP, ArapDataToDll)
#pragma alloc_text(PAGE_ARAP, MnpSendAckIfReqd)
#pragma alloc_text(PAGE_ARAP, MnpSendLNAck)
#pragma alloc_text(PAGE_ARAP, ArapSendLDPacket)
#pragma alloc_text(PAGE_ARAP, ArapRetryTimer)
#endif
//***
//
// Function: ArapProcessIoctl
// Process all ioctls coming from the Ras-ARAP module
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapProcessIoctl(
IN PIRP pIrp
)
{
NTSTATUS status=STATUS_SUCCESS;
PIO_STACK_LOCATION pIrpSp;
ULONG IoControlCode;
PARAP_SEND_RECV_INFO pSndRcvInfo=NULL;
PATCPCONN pAtcpConn=NULL;
PARAPCONN pArapConn=NULL;
ATALK_NODEADDR ClientNode;
DWORD dwBytesToDll;
DWORD dwOrgIrql;
DWORD dwFlags;
DWORD dwInputBufLen;
DWORD dwOutputBufLen;
BOOLEAN fDerefDefPort=FALSE;
NTSTATUS ReturnStatus=STATUS_SUCCESS;
PAGED_CODE ();
dwOrgIrql = KeGetCurrentIrql();
ASSERT(dwOrgIrql < DISPATCH_LEVEL);
pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
IoControlCode = pIrpSp->Parameters.DeviceIoControl.IoControlCode;
dwInputBufLen = pIrpSp->Parameters.DeviceIoControl.InputBufferLength;
dwOutputBufLen = pIrpSp->Parameters.DeviceIoControl.OutputBufferLength;
ARAPTRACE(("Entered ArapProcessIoctl (%lx %lx)\n",pIrp, IoControlCode));
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
if (!pSndRcvInfo)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: SystemBuffer is NULL!! (ioctl = %lx,pIrp = %lx)\n",
pIrp,IoControlCode));
ARAP_COMPLETE_IRP(pIrp, 0, STATUS_INVALID_PARAMETER, &ReturnStatus);
return( ReturnStatus );
}
if (dwInputBufLen < sizeof(ARAP_SEND_RECV_INFO))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: irp %lx, too small input buffer (%d bytes)!\n",
pIrp,dwInputBufLen));
ARAP_COMPLETE_IRP(pIrp, 0, STATUS_INVALID_PARAMETER, &ReturnStatus);
return( ReturnStatus );
}
if (dwOutputBufLen < sizeof(ARAP_SEND_RECV_INFO))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: irp %lx, too small output buffer (%d bytes)!\n",
pIrp,dwOutputBufLen));
ARAP_COMPLETE_IRP(pIrp, 0, STATUS_INVALID_PARAMETER, &ReturnStatus);
return( ReturnStatus );
}
//
// handle PPP (ATCP) ioctls separately
//
if ((IoControlCode == IOCTL_ATCP_SETUP_CONNECTION) ||
(IoControlCode == IOCTL_ATCP_SUPPRESS_BCAST) ||
(IoControlCode == IOCTL_ATCP_CLOSE_CONNECTION))
{
if (IoControlCode == IOCTL_ATCP_SETUP_CONNECTION)
{
AtalkLockPPPIfNecessary();
ReturnStatus = PPPProcessIoctl(pIrp, pSndRcvInfo, IoControlCode, NULL);
return (ReturnStatus);
}
else
{
ClientNode.atn_Network = pSndRcvInfo->ClientAddr.ata_Network;
ClientNode.atn_Node = (BYTE)pSndRcvInfo->ClientAddr.ata_Node;
if (ClientNode.atn_Node != 0)
{
// find the right connection
pAtcpConn = FindAndRefPPPConnByAddr(ClientNode, &dwFlags);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: excuse me? Node is 0! Irp=%lx\n",pIrp));
ASSERT(0);
}
if (pAtcpConn)
{
PPPProcessIoctl(pIrp, pSndRcvInfo, IoControlCode, pAtcpConn);
// remove the refcount put in by FindAndRefPPPConnByAddr
DerefPPPConn(pAtcpConn);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: PPP Ioctl %lx but can't find conn %x.%x\n",
IoControlCode,pSndRcvInfo->ClientAddr.ata_Network,
pSndRcvInfo->ClientAddr.ata_Node));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
ARAP_COMPLETE_IRP(pIrp, sizeof(ARAP_SEND_RECV_INFO),
STATUS_SUCCESS, &ReturnStatus);
return (ReturnStatus);
}
}
return( STATUS_SUCCESS);
}
//
// NOTE: ALL THE ARAP CODE IS NOW DEFUNCT. To minimize code-churn, only small changes
// are done to disable ARAP. At some point in time, all the code needs to be cleaned up
// so ARAP-specific stuff is completely removed
//
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: ARAP not supported anymore!!\n"));
ASSERT(0);
ARAP_COMPLETE_IRP(pIrp, 0, STATUS_INVALID_PARAMETER, &ReturnStatus);
return( ReturnStatus );
}
if (!ArapAcceptIrp(pIrp, IoControlCode, &fDerefDefPort))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: irp %lx not accepted (%lx)\n", pIrp,IoControlCode));
ARAP_COMPLETE_IRP(pIrp, sizeof(ARAP_SEND_RECV_INFO), STATUS_SUCCESS, &ReturnStatus);
// remove that IrpProcess refcount
if (fDerefDefPort)
{
AtalkPortDereference(AtalkDefaultPort);
}
return( ReturnStatus);
}
if ((IoControlCode != IOCTL_ARAP_EXCHANGE_PARMS) &&
(IoControlCode != IOCTL_ARAP_GET_ZONE_LIST))
{
pArapConn = pSndRcvInfo->AtalkContext;
}
//
// if ths irp is for a specific connection, validate the connection first!
//
if ((pArapConn != NULL) && (!ArapConnIsValid(pArapConn)))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: conn %lx is gone! (ioctl = %lx)\n",
pArapConn,IoControlCode));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
ARAP_COMPLETE_IRP(pIrp, sizeof(ARAP_SEND_RECV_INFO), STATUS_SUCCESS, &ReturnStatus);
// remove that IrpProcess refcount
if (fDerefDefPort)
{
AtalkPortDereference(AtalkDefaultPort);
}
return( ReturnStatus);
}
dwBytesToDll = sizeof(ARAP_SEND_RECV_INFO);
// in most likelihood, we're going to return pending: mark it so
IoMarkIrpPending(pIrp);
switch (IoControlCode)
{
//
// receive parameters from the user-level, and return some of our own
//
case IOCTL_ARAP_EXCHANGE_PARMS:
// exchange of parms: if not already done, lock arap pages
AtalkLockArapIfNecessary();
status = ArapExchangeParms( pIrp );
dwBytesToDll = sizeof(EXCHGPARMS);
// exchange of parms done: unlock if possible
AtalkUnlockArapIfNecessary();
break;
case IOCTL_ARAP_SETUP_CONNECTION:
// new connection being established: if not already done, lock arap pages
AtalkLockArapIfNecessary();
pSndRcvInfo->StatusCode = ARAPERR_NO_ERROR;
status = STATUS_SUCCESS;
break;
//
// setup the low level arap connection link (aka Point-to-Point Link)
// (first time client dials in, we respond. At callback, we initiate;
// at callback time, we initiate the connection here)
//
case IOCTL_ARAP_MNP_CONN_RESPOND:
case IOCTL_ARAP_MNP_CONN_INITIATE:
status = ArapConnect( pIrp, IoControlCode );
break;
//
// obtain (or make up) an appletalk address for the client and return it
//
case IOCTL_ARAP_GET_ADDR:
status = ArapGetAddr( pIrp );
break;
//
// just mark the Arap connection as being established
//
case IOCTL_ARAP_CONNECTION_UP:
status = ArapMarkConnectionUp( pIrp );
break;
//
// dll wants the connection blown away: disconnect it
//
case IOCTL_ARAP_DISCONNECT:
status = ArapDisconnect( pIrp );
break;
//
// send the buffer given by the dll
//
case IOCTL_ARAP_SEND:
status = ArapIoctlSend( pIrp );
break;
//
// "direct irp": get data for the connection specified
//
case IOCTL_ARAP_RECV:
status = ArapIoctlRecv( pIrp );
break;
//
// "select irp": get data if there is for any connection
//
case IOCTL_ARAP_SELECT:
status = ArapProcessSelect( pIrp );
break;
#if DBG
//
// "sniff irp": return all the sniff info
//
case IOCTL_ARAP_SNIFF_PKTS:
status = ArapProcessSniff( pIrp );
break;
#endif
//
// engine wants the select irp unblocked (either because it's shutting
// down or because we want to shutdown)
//
case IOCTL_ARAP_CONTINUE_SHUTDOWN:
ArapUnblockSelect();
status = STATUS_SUCCESS;
break;
//
// get names of all the zones in the entire network
//
case IOCTL_ARAP_GET_ZONE_LIST:
ArapZipGetZoneStat( (PZONESTAT)pSndRcvInfo );
// (-4 to avoid 4 bytes from ZoneNames[1] field)
dwBytesToDll = ((PZONESTAT)pSndRcvInfo)->BufLen + sizeof(ZONESTAT) - 4;
status = STATUS_SUCCESS;
break;
default:
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessIoctl: Invalid Request %lx\n", IoControlCode));
status = STATUS_INVALID_PARAMETER;
}
if( status != STATUS_PENDING )
{
pIrpSp->Control &= ~SL_PENDING_RETURNED;
ARAP_COMPLETE_IRP(pIrp, dwBytesToDll, STATUS_SUCCESS, &ReturnStatus);
status = ReturnStatus;
}
//
// if this irp was for a specific connection, validation refcount was put
// on it: take that away
//
if (pArapConn)
{
DerefArapConn(pArapConn);
}
// remove that IrpProcess refcount
if (fDerefDefPort)
{
AtalkPortDereference(AtalkDefaultPort);
}
ASSERT(KeGetCurrentIrql() == dwOrgIrql);
return( status );
}
//***
//
// Function: ArapMarkConnectionUp
// Set the flags in our connection to mark that Arap connection
// has been established (by the dll) (we don't route until this
// happens)
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapMarkConnectionUp(
IN PIRP pIrp
)
{
PARAPCONN pArapConn;
PARAP_SEND_RECV_INFO pSndRcvInfo;
KIRQL OldIrql;
DBG_ARAP_CHECK_PAGED_CODE();
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pArapConn = (PARAPCONN)pSndRcvInfo->AtalkContext;
if (pArapConn == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapMarkConnectionUp: null conn\n"));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
return(STATUS_SUCCESS);
}
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
(" Yippeee! %s connection is up! (%x.%x @%lx)\n",
(pArapConn->Flags & ARAP_V20_CONNECTION)? "ARAP v2.0":"ARAP v1.0",
pArapConn->NetAddr.atn_Network,pArapConn->NetAddr.atn_Node,pArapConn));
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
pArapConn->Flags |= ARAP_CONNECTION_UP;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
pSndRcvInfo->StatusCode = ARAPERR_NO_ERROR;
return( STATUS_SUCCESS );
}
//***
//
// Function: ArapIoctlRecv
// Try to get data for the specified connection. If there is no
// data available, irp is just "queued"
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapIoctlRecv(
IN PIRP pIrp
)
{
PARAPCONN pArapConn;
PARAP_SEND_RECV_INFO pSndRcvInfo;
KIRQL OldIrql;
DBG_ARAP_CHECK_PAGED_CODE();
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pArapConn = (PARAPCONN)pSndRcvInfo->AtalkContext;
if (pArapConn == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapIoctlRecv: null conn\n"));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
return(STATUS_SUCCESS);
}
ARAPTRACE(("Entered ArapIoctlRecv (%lx %lx)\n",pIrp,pArapConn));
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
if (pArapConn->State >= MNP_LDISCONNECTING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapIoctlRecv: rejecting recv ioctl recvd during disconnect %lx\n", pArapConn));
pSndRcvInfo->StatusCode = ARAPERR_DISCONNECT_IN_PROGRESS;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return(STATUS_SUCCESS);
}
// we only allow one irp to be in progress at a time
if (pArapConn->pRecvIoctlIrp != NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, ("ArapIoctlRecv: rejecting recv \
(irp already in progress) %lx\n", pArapConn));
pSndRcvInfo->StatusCode = ARAPERR_IRP_IN_PROGRESS;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return(STATUS_SUCCESS);
}
pArapConn->pRecvIoctlIrp = pIrp;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
// see if we can satisfy this request
ArapDataToDll( pArapConn );
return( STATUS_PENDING );
}
//***
//
// Function: ArapExchangeParms
// Get configuration parameters from the dll, and return some info
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapExchangeParms(
IN PIRP pIrp
)
{
ZONESTAT ZoneStat;
KIRQL OldIrql;
PADDRMGMT pAddrMgmt;
PEXCHGPARMS pExchgParms;
DBG_ARAP_CHECK_PAGED_CODE();
ARAPTRACE(("Entered ArapExchangeParms (%lx)\n",pIrp));
pExchgParms = (PEXCHGPARMS)pIrp->AssociatedIrp.SystemBuffer;
// we enter this routine only if AtalkDefaultPort is referenced
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql);
ArapGlobs.LowVersion = pExchgParms->Parms.LowVersion;
ArapGlobs.HighVersion = pExchgParms->Parms.HighVersion;
ArapGlobs.MnpInactiveTime = pExchgParms->Parms.MnpInactiveTime;
ArapGlobs.V42bisEnabled = pExchgParms->Parms.V42bisEnabled;
ArapGlobs.SmartBuffEnabled = pExchgParms->Parms.SmartBuffEnabled;
ArapGlobs.NetworkAccess = pExchgParms->Parms.NetworkAccess;
ArapGlobs.DynamicMode = pExchgParms->Parms.DynamicMode;
ArapGlobs.NetRange.LowEnd = pExchgParms->Parms.NetRange.LowEnd;
ArapGlobs.NetRange.HighEnd = pExchgParms->Parms.NetRange.HighEnd;
ArapGlobs.MaxLTFrames = (BYTE)pExchgParms->Parms.MaxLTFrames;
ArapGlobs.SniffMode = pExchgParms->Parms.SniffMode;
ArapGlobs.pAddrMgmt = NULL;
// we only support dynamic mode
ASSERT(ArapGlobs.DynamicMode);
#if ARAP_STATIC_MODE
//
// allocate and initialize the bitmap for node allocation
//
if (!(ArapGlobs.DynamicMode))
{
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
if (!ArapValidNetrange(ArapGlobs.NetRange))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapExchangeParms: Netrange %lx - %lx is invalid\n",
ArapGlobs.NetRange.LowEnd,ArapGlobs.NetRange.HighEnd));
pExchgParms->StatusCode = ARAPERR_BAD_NETWORK_RANGE;
return (STATUS_SUCCESS);
}
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql);
if ( (pAddrMgmt = AtalkAllocZeroedMemory(sizeof(ADDRMGMT))) == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapExchangeParms: alloc for pAddrMgmt failed\n"));
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
pExchgParms->StatusCode = ARAPERR_OUT_OF_RESOURCES;
return (STATUS_SUCCESS);
}
//
// node numbers 0 and 255 are reserved, so mark them as occupied.
//
pAddrMgmt->NodeBitMap[0] |= 0x1;
pAddrMgmt->NodeBitMap[31] |= 0x80;
pAddrMgmt->Network = ArapGlobs.NetRange.LowEnd;
ArapGlobs.pAddrMgmt = pAddrMgmt;
}
#endif //ARAP_STATIC_MODE
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
//
// now, time to return some stack info to the dll.
//
// just an initial guess: dll will figure out the real number when an
// actual connection comes in
//
pExchgParms->Parms.NumZones = 50;
pExchgParms->Parms.ServerAddr.ata_Network =
AtalkDefaultPort->pd_Nodes->an_NodeAddr.atn_Network;
pExchgParms->Parms.ServerAddr.ata_Node =
AtalkDefaultPort->pd_Nodes->an_NodeAddr.atn_Node;
// copy the server zone in Pascal string format
if (AtalkDesiredZone)
{
pExchgParms->Parms.ServerZone[0] = AtalkDesiredZone->zn_ZoneLen;
RtlCopyMemory( &pExchgParms->Parms.ServerZone[1],
&AtalkDesiredZone->zn_Zone[0],
AtalkDesiredZone->zn_ZoneLen );
}
else if (AtalkDefaultPort->pd_DefaultZone)
{
pExchgParms->Parms.ServerZone[0] = AtalkDefaultPort->pd_DefaultZone->zn_ZoneLen;
RtlCopyMemory( &pExchgParms->Parms.ServerZone[1],
&AtalkDefaultPort->pd_DefaultZone->zn_Zone[0],
AtalkDefaultPort->pd_DefaultZone->zn_ZoneLen );
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("Arap: Server not in any zone?? Client won't see any zones!!\n"));
pExchgParms->Parms.ServerZone[0] = 0;
}
ArapGlobs.OurNetwkNum =
AtalkDefaultPort->pd_Nodes->an_NodeAddr.atn_Network;
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("Arap: ready to accept connections (Router net=%x node=%x)\n",
AtalkDefaultPort->pd_Nodes->an_NodeAddr.atn_Network,
AtalkDefaultPort->pd_Nodes->an_NodeAddr.atn_Node));
pExchgParms->StatusCode = ARAPERR_NO_ERROR;
// complete the irp successfully
return (STATUS_SUCCESS);
}
//***
//
// Function: ArapConnect
// Setup the MNP level connection with the client
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapConnect(
IN PIRP pIrp,
IN ULONG IoControlCode
)
{
KIRQL OldIrql;
PBYTE pFrame;
SHORT MnpLen;
SHORT FrameLen;
DWORD StatusCode=ARAPERR_NO_ERROR;
PMNPSENDBUF pMnpSendBuf=NULL;
PARAP_SEND_RECV_INFO pSndRcvInfo;
PARAPCONN pArapConn;
PNDIS_PACKET ndisPacket;
NDIS_STATUS ndisStatus;
DBG_ARAP_CHECK_PAGED_CODE();
ARAPTRACE(("Entered ArapConnect (%lx)\n",pIrp));
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pArapConn = FindArapConnByContx(pSndRcvInfo->pDllContext);
if (pArapConn == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapConnect: couldn't find pArapConn!\n"));
ASSERT(0);
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
return(STATUS_SUCCESS);
}
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql);
ArapConnections++;
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
#if ARAP_STATIC_MODE
// This will add a route (one-time only) for the ARAP network range
ArapAddArapRoute();
#endif //ARAP_STATIC_MODE
// first, write stack's context for dll's future use
pSndRcvInfo->AtalkContext = (PVOID)pArapConn;
//
// put a refcount for the connection (deref only when the connection gets
// disconnected *and* the dll is told about it).
// Also, initialize the v42bis stuff for this connection
//
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
if (pArapConn->pIoctlIrp != NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, ("ArapConnect: rejecting connect \
(irp already in progress) %lx\n", pArapConn));
pSndRcvInfo->StatusCode = ARAPERR_IRP_IN_PROGRESS;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return(STATUS_SUCCESS);
}
ASSERT(pArapConn->State == MNP_IDLE);
if (IoControlCode == IOCTL_ARAP_MNP_CONN_RESPOND)
{
pArapConn->State = MNP_RESPONSE;
}
//
// we're doing callback: do some fixing up
//
else
{
pArapConn->State = MNP_REQUEST;
pArapConn->Flags |= ARAP_CALLBACK_MODE;
pArapConn->MnpState.SendCredit = 8;
}
// Connect refcount: remove only after we tell dll that connection died
pArapConn->RefCount++;
// put MNPSend refcount
pArapConn->RefCount++;
pArapConn->pIoctlIrp = pIrp;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
KeInitializeEvent(&pArapConn->NodeAcquireEvent, NotificationEvent, FALSE);
StatusCode = ARAPERR_NO_ERROR;
//
// allocate buf to send out the connection response/request
//
if ((pMnpSendBuf = AtalkBPAllocBlock(BLKID_MNP_SMSENDBUF)) != NULL)
{
// get an ndis packet for this puppy
StatusCode = ArapGetNdisPacket(pMnpSendBuf);
}
if ((pMnpSendBuf == NULL) || (StatusCode != ARAPERR_NO_ERROR))
{
if (pMnpSendBuf)
{
ArapNdisFreeBuf(pMnpSendBuf);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapConnect: AtalkBPAllocBlock failed on %lx\n", pArapConn));
}
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
pArapConn->State = MNP_IDLE;
pSndRcvInfo->StatusCode = ARAPERR_OUT_OF_RESOURCES;
pSndRcvInfo->AtalkContext = ARAP_INVALID_CONTEXT;
pArapConn->pIoctlIrp = NULL;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
// didn't succeed: remove that connection refcount
DerefArapConn(pArapConn);
// and the MNPSend refcount
DerefArapConn(pArapConn);
// return success: we have already set our StatusCode to the right thing
return( STATUS_SUCCESS );
}
#if DBG
pMnpSendBuf->Signature = MNPSMSENDBUF_SIGNATURE;
#endif
// yes, we need this, in case we bail out
InitializeListHead(&pMnpSendBuf->Linkage);
pMnpSendBuf->SeqNum = 0; // Indication code expects this to be 0
pMnpSendBuf->RetryCount = 1;
pMnpSendBuf->RefCount = 1; // 1 MNP refcount
pMnpSendBuf->pArapConn = pArapConn;
pMnpSendBuf->ComplRoutine = ArapConnectComplete;
pMnpSendBuf->Flags = 1;
// when should we retransmit this pkt?
pMnpSendBuf->RetryTime = pArapConn->SendRetryTime + AtalkGetCurrentTick();
pFrame = &pMnpSendBuf->Buffer[0];
AtalkNdisBuildARAPHdr(pFrame, pArapConn);
pFrame += WAN_LINKHDR_LEN;
FrameLen = WAN_LINKHDR_LEN;
//
// are we just responding to a connection request?
//
if (IoControlCode == IOCTL_ARAP_MNP_CONN_RESPOND)
{
//
// pSndRcvInfo contains the client's connect request. Parse it and
// prepare a response as appropriate
//
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql);
StatusCode = PrepareConnectionResponse( pArapConn,
&pSndRcvInfo->Data[0],
pSndRcvInfo->DataLen,
pFrame,
&MnpLen);
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
if (StatusCode != ARAPERR_NO_ERROR)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapConnect: (%lx) response prep failed %ld\n", pArapConn,StatusCode));
ArapConnectComplete(pMnpSendBuf, StatusCode);
return( STATUS_PENDING );
}
FrameLen += MnpLen;
}
//
// no, actually we are initiating a connection (callback time)
// copy the frame we used in earlier setup (that dll kindly saved for us)
//
else
{
RtlCopyMemory(pFrame, (PBYTE)&pSndRcvInfo->Data[0], pSndRcvInfo->DataLen);
FrameLen += (USHORT)pSndRcvInfo->DataLen;
#if DBG
pArapConn->MnpState.SynByte = pSndRcvInfo->Data[0];
pArapConn->MnpState.DleByte = pSndRcvInfo->Data[1];
pArapConn->MnpState.StxByte = pSndRcvInfo->Data[2];
pArapConn->MnpState.EtxByte = MNP_ETX;
#endif
}
AtalkSetSizeOfBuffDescData(&pMnpSendBuf->sb_BuffDesc, FrameLen);
pMnpSendBuf->RefCount++; // 1 ndis count, since we'll send now
pMnpSendBuf->DataSize = FrameLen;
NdisAdjustBufferLength(pMnpSendBuf->sb_BuffHdr.bh_NdisBuffer,
pMnpSendBuf->DataSize);
// put this connection response on the retransmission queue
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
InsertTailList(&pArapConn->RetransmitQ, &pMnpSendBuf->Linkage);
pArapConn->SendsPending += pMnpSendBuf->DataSize;
pArapConn->MnpState.UnAckedSends++;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
ndisPacket = pMnpSendBuf->sb_BuffHdr.bh_NdisPkt;
NdisSend(&ndisStatus, RasPortDesc->pd_NdisBindingHandle, ndisPacket);
// if there was a problem sending, call the completion routine here
// retransmit logic will send it again
//
if (ndisStatus != NDIS_STATUS_PENDING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("MnpSendAck: NdisSend failed %lx\n",ndisStatus));
ArapNdisSendComplete(ARAPERR_SEND_FAILED, (PBUFFER_DESC)pMnpSendBuf, NULL);
}
//
// done. we'll complete the irp when the client responds (acks or response)
//
return( STATUS_PENDING );
}
//***
//
// Function: ArapConnectComplete
// Completion routine for the ArapConnect routine. This routine
// is called by the ArapRcvComplete routine when we get an ack
// for our Connection response (LR) frame
//
// Parameters: pMnpSendBuf - the send buff that contained the LR response
// StatusCode - how did it go?
//
// Return: none
//
//***$
VOID
ArapConnectComplete(
IN PMNPSENDBUF pMnpSendBuf,
IN DWORD StatusCode
)
{
KIRQL OldIrql;
PIRP pIrp;
PARAPCONN pArapConn;
PARAP_SEND_RECV_INFO pSndRcvInfo;
NTSTATUS ReturnStatus=STATUS_SUCCESS;
DBG_ARAP_CHECK_PAGED_CODE();
pArapConn = pMnpSendBuf->pArapConn;
if (StatusCode != ARAPERR_NO_ERROR)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapConnectComplete: (%x): conn setup failed (%d)!\n",
pArapConn,StatusCode));
//
// BUGBUG: change ArapCleanup to accept StatusCode as a parm (currently,
// the real reason behind disconnect is lost, so dll doesn't get it)
//
ArapCleanup(pArapConn);
DerefMnpSendBuf(pMnpSendBuf, FALSE);
return;
}
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
pIrp = pArapConn->pIoctlIrp;
pArapConn->pIoctlIrp = NULL;
pArapConn->SendsPending -= pMnpSendBuf->DataSize;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
ARAPTRACE(("Entered ArapConnectComplete (%lx %lx)\n",pIrp,pArapConn));
// if there is an irp (under normal conditions, should be), complete it
if (pIrp)
{
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pSndRcvInfo->StatusCode = StatusCode;
if (StatusCode != ARAPERR_NO_ERROR)
{
pSndRcvInfo->StatusCode = ARAPERR_DISCONNECT_IN_PROGRESS;
}
//
// copy the frame we used to establish the connection. In case of
// callback, dll will pass this back to initiate the connection
//
if (pSndRcvInfo->IoctlCode == IOCTL_ARAP_MNP_CONN_RESPOND)
{
pSndRcvInfo->DataLen = (DWORD)pMnpSendBuf->DataSize;
RtlCopyMemory((PBYTE)&pSndRcvInfo->Data[0],
(PBYTE)&pMnpSendBuf->Buffer[0],
(DWORD)pMnpSendBuf->DataSize);
}
ARAP_COMPLETE_IRP(pIrp,
pSndRcvInfo->DataLen + sizeof(ARAP_SEND_RECV_INFO),
STATUS_SUCCESS, &ReturnStatus);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapConnectComplete: (%x): no irp available!\n",pArapConn));
}
DerefMnpSendBuf(pMnpSendBuf, FALSE);
}
//***
//
// Function: ArapDisconnect
// Disconnect the connection
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapDisconnect(
IN PIRP pIrp
)
{
PARAPCONN pArapConn;
PARAP_SEND_RECV_INFO pSndRcvInfo;
DBG_ARAP_CHECK_PAGED_CODE();
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pArapConn = (PARAPCONN)pSndRcvInfo->AtalkContext;
if ((pArapConn == NULL) || (pArapConn == ARAP_INVALID_CONTEXT))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapDisconnect: null conn\n"));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
return(STATUS_SUCCESS);
}
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapDisconnect: rcvd DISCONNECT on %lx (irp=%lx)\n",pArapConn,pIrp));
// UserCode = 0xFF
pSndRcvInfo->StatusCode = ArapSendLDPacket(pArapConn, 0xFF);
ArapCleanup(pArapConn);
//
// done. let this irp complete: we'll notify the dll of
// 'disconnect-complete' (via select irp) when our cleanup completes
//
return(STATUS_SUCCESS);
}
//***
//
// Function: ArapGetAddr
// Get a network address for the remote client
// (if doing dynamic addressing, go to the net; otherwise, get one
// from the table we maintain)
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapGetAddr(
IN PIRP pIrp
)
{
PARAPCONN pArapConn;
PARAP_SEND_RECV_INFO pSndRcvInfo;
DWORD StatusCode = ARAPERR_NO_NETWORK_ADDR;
DBG_ARAP_CHECK_PAGED_CODE();
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pArapConn = (PARAPCONN)pSndRcvInfo->AtalkContext;
ARAPTRACE(("Entered ArapGetAddr (%lx %lx)\n",pIrp,pArapConn));
if (pArapConn == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapGetAddr: null conn\n"));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
return(STATUS_SUCCESS);
}
if (ArapGlobs.DynamicMode)
{
StatusCode = ArapGetDynamicAddr(pArapConn);
}
#if ARAP_STATIC_MODE
else
{
StatusCode = ArapGetStaticAddr(pArapConn);
}
#endif //ARAP_STATIC_MODE
pSndRcvInfo->StatusCode = StatusCode;
if (StatusCode == ARAPERR_NO_ERROR)
{
pSndRcvInfo->ClientAddr.ata_Network = pArapConn->NetAddr.atn_Network;
pSndRcvInfo->ClientAddr.ata_Node = pArapConn->NetAddr.atn_Node;
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapGetAddr: returning %d\n", StatusCode));
}
return( STATUS_SUCCESS );
}
// we don't really support this: why have the code!
#if 0
//***
//
// Function: ArapGetStats
// Return statistics (bytes in, bytes out, compressed etc.) about
// the specified connection
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapGetStats(
IN PIRP pIrp
)
{
PARAPCONN pArapConn;
PARAP_SEND_RECV_INFO pSndRcvInfo;
KIRQL OldIrql;
PSTAT_INFO pStatInfo;
DBG_ARAP_CHECK_PAGED_CODE();
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pArapConn = (PARAPCONN)pSndRcvInfo->AtalkContext;
if (pArapConn == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapGetStats: null conn\n"));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
return(STATUS_SUCCESS);
}
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapGetStats: returning stats for (%lx)\n",pArapConn));
pStatInfo = (PSTAT_INFO)&pSndRcvInfo->Data[0];
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
*pStatInfo = pArapConn->StatInfo;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
pSndRcvInfo->StatusCode = ARAPERR_NO_ERROR;
return( STATUS_SUCCESS );
}
#endif // #if 0 around ArapGetStats
//***
//
// Function: ArapIoctlSend
// Send the buffer given by the dll to the remote client.
// This routine calls the routine to prepare the send (v42bis
// compression and MNP bookkeeping) and then sends it out
//
// Parameters: pIrp - the irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapIoctlSend(
IN PIRP pIrp
)
{
KIRQL OldIrql;
BUFFER_DESC OrgBuffDesc;
PARAPCONN pArapConn;
PARAP_SEND_RECV_INFO pSndRcvInfo;
DWORD StatusCode=ARAPERR_NO_ERROR;
DBG_ARAP_CHECK_PAGED_CODE();
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pArapConn = (PARAPCONN)pSndRcvInfo->AtalkContext;
if (pArapConn == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapIoctlSend: null conn\n"));
pSndRcvInfo->StatusCode = ARAPERR_NO_SUCH_CONNECTION;
return(STATUS_SUCCESS);
}
ARAPTRACE(("Entered ArapIoctlSend (%lx %lx)\n",pIrp,pArapConn));
// save the irp so we can complete it in the completion routine
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
// we only allow one irp to be in progress at a time
if (pArapConn->pIoctlIrp != NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, ("ArapIoctlSend: rejecting send \
(irp already in progress) %lx\n", pArapConn));
pSndRcvInfo->StatusCode = ARAPERR_IRP_IN_PROGRESS;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return(STATUS_SUCCESS);
}
pArapConn->pIoctlIrp = pIrp;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
ASSERT(pSndRcvInfo->DataLen <= 618);
DBGDUMPBYTES("Dll send:", &pSndRcvInfo->Data[0],pSndRcvInfo->DataLen,1);
//
// get the send ready (compression, MNP bookkeeping etc.)
//
OrgBuffDesc.bd_Next = NULL;
OrgBuffDesc.bd_Length = (SHORT)pSndRcvInfo->DataLen;
OrgBuffDesc.bd_CharBuffer = &pSndRcvInfo->Data[0];
OrgBuffDesc.bd_Flags = BD_CHAR_BUFFER;
StatusCode = ArapSendPrepare( pArapConn,
&OrgBuffDesc,
ARAP_SEND_PRIORITY_HIGH );
if (StatusCode == ARAPERR_NO_ERROR)
{
//
// now, send that send over. Note that we don't care about the return
// code here: if this particular send fails, we still tell the dll that
// the send succeeded because our retransmission logic will take care
// of ensuring that the send gets there.
//
ArapNdisSend( pArapConn, &pArapConn->HighPriSendQ );
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapIoctlSend (%lx): ArapSendPrepare failed (%ld)\n",
pArapConn,StatusCode));
}
ArapIoctlSendComplete(StatusCode, pArapConn);
return( STATUS_PENDING );
}
//***
//
// Function: ArapProcessSelect
// Process the select irp issued by the dll
// This routine saves the select irp so that any connection that
// needs it can take it. Also, it sees if any of the connections
// is waiting for an irp to indicate a disconnect-complete or
// data to the dll. If so, that is completed here.
//
// Parameters: pIrp - the select irp to process
//
// Return: result of the operation
//
//***$
NTSTATUS
ArapProcessSelect(
IN PIRP pIrp
)
{
KIRQL OldIrql;
KIRQL OldIrql2;
PARAPCONN pDiscArapConn=NULL;
PARAPCONN pRcvArapConn=NULL;
PARAP_SEND_RECV_INFO pSndRcvInfo;
PLIST_ENTRY pList;
DWORD dwBytesToDll;
DWORD StatusCode;
NTSTATUS ReturnStatus;
ARAPTRACE(("Entered ArapProcessSelect (%lx)\n",pIrp));
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pDiscArapConn = NULL;
pRcvArapConn = NULL;
//
// it's possible that between the time the last select irp completed and
// this select came down, some activity that needs a select irp occured
// (e.g. a disconnect). See if we have hit such a condition
//
ArapDelayedNotify(&pDiscArapConn, &pRcvArapConn);
//
// if we found an arapconn that was waiting for a select irp to notify the
// dll of disconnect, do the good deed!
//
if (pDiscArapConn)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessSelect: completing delayed disconnect on %lx!\n", pDiscArapConn));
dwBytesToDll = 0;
#if DBG
//
// if we have some sniff info that we couldn't deliver earlier through
// the sniff irp, then give them through this irp: it's going back
// "empty" anyway!
//
if (pDiscArapConn->pDbgTraceBuffer && pDiscArapConn->SniffedBytes > 0)
{
dwBytesToDll = ArapFillIrpWithSniffInfo(pDiscArapConn,pIrp);
}
#endif
dwBytesToDll += sizeof(ARAP_SEND_RECV_INFO);
//
// no need for spinlock here
//
if (pDiscArapConn->Flags & ARAP_REMOTE_DISCONN)
{
StatusCode = ARAPERR_RDISCONNECT_COMPLETE;
}
else
{
StatusCode = ARAPERR_LDISCONNECT_COMPLETE;
}
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pSndRcvInfo->pDllContext = pDiscArapConn->pDllContext;
pSndRcvInfo->StatusCode = StatusCode;
pSndRcvInfo->DataLen = dwBytesToDll;
// we told (rather, will very shortly tell) dll: remove this link
pDiscArapConn->pDllContext = NULL;
// now that we told dll, remove 1 refcount
DerefArapConn( pDiscArapConn );
return(STATUS_SUCCESS);
}
IoAcquireCancelSpinLock(&OldIrql);
if (pIrp->Cancel)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessSelect: select irp %lx already cancelled!\n", pIrp));
IoReleaseCancelSpinLock(OldIrql);
ARAP_COMPLETE_IRP(pIrp, 0, STATUS_CANCELLED, &ReturnStatus);
return(ReturnStatus);
}
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql2);
if (ArapSelectIrp != NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessSelect: select irp %lx already in progress!\n", ArapSelectIrp));
ASSERT(0);
pSndRcvInfo->StatusCode = ARAPERR_IRP_IN_PROGRESS;
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql2);
IoReleaseCancelSpinLock(OldIrql);
return( STATUS_SUCCESS );
}
//
// does arap engine need to be told about some change?
//
if ( (ArapStackState == ARAP_STATE_ACTIVE_WAITING) ||
(ArapStackState == ARAP_STATE_INACTIVE_WAITING) )
{
if (ArapStackState == ARAP_STATE_ACTIVE_WAITING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessSelect: delayed notify: stack is now active!\n"));
ArapStackState = ARAP_STATE_ACTIVE;
pSndRcvInfo->StatusCode = ARAPERR_STACK_IS_ACTIVE;
}
else if (ArapStackState == ARAP_STATE_INACTIVE_WAITING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapProcessSelect: delayed notify: stack is now inactive!\n"));
ArapStackState = ARAP_STATE_INACTIVE;
pSndRcvInfo->StatusCode = ARAPERR_STACK_IS_NOT_ACTIVE;
}
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql2);
IoReleaseCancelSpinLock(OldIrql);
return( STATUS_SUCCESS );
}
//
// ok, most common case: we just need to stash this select irp!
//
ArapSelectIrp = pIrp;
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql2);
IoSetCancelRoutine(pIrp, (PDRIVER_CANCEL)AtalkTdiCancel);
IoReleaseCancelSpinLock(OldIrql);
//
// if there was an arapconn waiting for a select irp, pass on the data!
//
if (pRcvArapConn)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
("ArapProcessSelect: getting delayed data on %lx at %ld\n",
pRcvArapConn,AtalkGetCurrentTick()));
ARAP_DBG_TRACE(pRcvArapConn,11105,0,0,0,0);
ArapDataToDll( pRcvArapConn );
}
return(STATUS_PENDING);
}
//***
//
// Function: ArapDelayedNotify
// This routine checks to see if any of the arap connections was
// waiting for a select irp to come down to notify the dll that
// either the connection went away, or if there was any data waiting on a
// connection.
//
// Parameters: ppDiscArapConn - if a "disconnected" connection exists, it's returned
// in this pointer. If many exist, the first one lucks out.
// If none exists, null is returned here
// ppRecvArapConn - same as above except that the connection returned is
// the one where some data is waiting
//
// Return: none
//
//***$
VOID
ArapDelayedNotify(
OUT PARAPCONN *ppDiscArapConn,
OUT PARAPCONN *ppRecvArapConn
)
{
KIRQL OldIrql;
PARAPCONN pArapConn=NULL;
PLIST_ENTRY pList;
PARAPCONN pDiscArapConn=NULL;
PARAPCONN pRecvArapConn=NULL;
*ppDiscArapConn = NULL;
*ppRecvArapConn = NULL;
if (!RasPortDesc)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapDelayedNotify: RasPortDesc is NULL!\n"));
ASSERT(0);
return;
}
ACQUIRE_SPIN_LOCK(&RasPortDesc->pd_Lock, &OldIrql);
pList = RasPortDesc->pd_ArapConnHead.Flink;
while (pList != &RasPortDesc->pd_ArapConnHead)
{
pArapConn = CONTAINING_RECORD(pList, ARAPCONN, Linkage);
pList = pArapConn->Linkage.Flink;
ACQUIRE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
//
// if a connection has been disconnected and is waiting for a select
// irp to show up, find out who that is and let the caller know
//
if ((pArapConn->State == MNP_DISCONNECTED) &&
(pArapConn->Flags & DISCONNECT_NO_IRP))
{
pArapConn->Flags &= ~DISCONNECT_NO_IRP;
pDiscArapConn = pArapConn;
RELEASE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
break;
}
//
// if a connection has some data come in on it while select irp wasn't
// down yet, note down this connection
//
if ((pArapConn->State == MNP_UP) &&
(pArapConn->Flags & ARAP_CONNECTION_UP) &&
(!IsListEmpty(&pArapConn->ArapDataQ)))
{
pRecvArapConn = pArapConn;
}
RELEASE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
}
RELEASE_SPIN_LOCK(&RasPortDesc->pd_Lock,OldIrql);
if (pDiscArapConn)
{
*ppDiscArapConn = pDiscArapConn;
}
else if (pRecvArapConn)
{
*ppRecvArapConn = pRecvArapConn;
}
}
//***
//
// Function: ArapSendPrepare
// This routine takes an incoming buffer descriptor, compresses
// each of the buffers in it and passes the compressed data on to
// another routine which splits (or stuffs) the compressed bytes
// into MNP-level packets.
//
// Parameters: pArapConn - the connection in question
// pOrgBuffDesc - the buffer descriptor containing data buffer(s)
// Priority - how important is the data (highest priority = 1)
// 1 - directed DDP dgrams (all except NBP)
// 2 - directed DDP dgrams (NBP)
// 3 - all DDP-level broadcast (NBP only)
//
// Return: ARAPERR_NO_ERROR if things go well, otherwise errorcode
//
//***$
DWORD
ArapSendPrepare(
IN PARAPCONN pArapConn,
IN PBUFFER_DESC pOrgBuffDesc,
IN DWORD Priority
)
{
KIRQL OldIrql;
DWORD StatusCode=ARAPERR_NO_ERROR;
SHORT EthLen, MnpLen;
PBYTE pCurrBuff;
DWORD CurrBuffLen;
DWORD UncompressedDataLen;
PBYTE pCompressedData;
PBYTE pCompressedDataBuffer;
DWORD CompressedDataLen;
DWORD CDataLen;
PBUFFER_DESC pBuffDesc;
DWORD CompBufDataSize;
DBG_ARAP_CHECK_PAGED_CODE();
// BUGBUG: this line put in for now: remove it and make sure priority queue stuff works
Priority = ARAP_SEND_PRIORITY_HIGH;
ARAPTRACE(("Entered ArapSendPrepare (%lx %lx)\n",pArapConn,pOrgBuffDesc));
//
// it's essential to hold this lock until the entire send is compressed and
// put on the queue (Otherwise, we risk mixing up different sends!)
//
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
// are we disconnecting (or not up yet)? if so, don't accept this send
if (pArapConn->State != MNP_UP)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapSendPrepare: (%lx) state=%d, rejecting send\n",
pArapConn,pArapConn->State));
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return( ARAPERR_DISCONNECT_IN_PROGRESS );
}
// do we have too many sends queued up? if so, just drop this send
if (pArapConn->SendsPending > ARAP_SENDQ_UPPER_LIMIT)
{
// make sure it's not gone negative..
ASSERT(pArapConn->SendsPending < 0x100000);
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return( ARAPERR_OUT_OF_RESOURCES );
}
//
// allocate memory to store the compressed data
//
pCompressedDataBuffer = AtalkBPAllocBlock(BLKID_ARAP_SNDPKT);
if (pCompressedDataBuffer == NULL)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapSendPrepare: alloc for compressing data failed (%lx)\n", pArapConn));
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return( ARAPERR_OUT_OF_RESOURCES );
}
pBuffDesc = pOrgBuffDesc; // first buffer
CompressedDataLen = 0; // length of compressed data
CompBufDataSize = ARAP_SENDBUF_SIZE; // size of buffer in which to compress
pCompressedData = pCompressedDataBuffer; // ptr to buffer in which to compress
UncompressedDataLen = 0; // size of uncompressed data
#if DBG
//
// put in a guard signature to catch buffer overrun
//
*((DWORD *)&(pCompressedDataBuffer[ARAP_SENDBUF_SIZE-4])) = 0xdeadbeef;
#endif
//
// first, walk through the buffer descriptor chain and compress all the
// buffers.
//
while (pBuffDesc)
{
//
// is this a buffer?
//
if (pBuffDesc->bd_Flags & BD_CHAR_BUFFER)
{
pCurrBuff = pBuffDesc->bd_CharBuffer;
CurrBuffLen = pBuffDesc->bd_Length;
}
//
// nope, it's an mdl!
//
else
{
pCurrBuff = MmGetSystemAddressForMdlSafe(
pBuffDesc->bd_OpaqueBuffer,
NormalPagePriority);
if (pCurrBuff == NULL)
{
ASSERT(0);
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
AtalkBPFreeBlock(pCompressedDataBuffer);
return( ARAPERR_OUT_OF_RESOURCES );
}
CurrBuffLen = MmGetMdlByteCount(pBuffDesc->bd_OpaqueBuffer);
}
DBGDUMPBYTES("ArapSendPrepare (current buffer): ",pCurrBuff,CurrBuffLen,2);
UncompressedDataLen += CurrBuffLen;
ASSERT(UncompressedDataLen <= ARAP_LGPKT_SIZE);
// exclude the 2 srp length bytes
if (UncompressedDataLen > ARAP_MAXPKT_SIZE_OUTGOING+2)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapSendPrepare (%lx): send pkt exceeds limit\n",pArapConn));
ASSERT(0);
}
//
// compress the packet (if v42bis is on, that is)
//
if (pArapConn->Flags & MNP_V42BIS_NEGOTIATED)
{
StatusCode = v42bisCompress(pArapConn,
pCurrBuff,
CurrBuffLen,
pCompressedData,
CompBufDataSize,
&CDataLen);
}
//
// hmmm, no v42bis! just copy it as is and skip compression!
//
else
{
ASSERT(CompBufDataSize >= CurrBuffLen);
RtlCopyMemory(pCompressedData,
pCurrBuff,
CurrBuffLen);
CDataLen = CurrBuffLen;
StatusCode = ARAPERR_NO_ERROR;
}
#if DBG
// ... and, check our guard signature
ASSERT (*((DWORD *)&(pCompressedDataBuffer[ARAP_SENDBUF_SIZE-4])) == 0xdeadbeef);
#endif
if (StatusCode != ARAPERR_NO_ERROR)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, ("ArapSendPrepare (%lx):\
v42bisCompress returned %ld\n", pArapConn,StatusCode));
ASSERT(0);
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
AtalkBPFreeBlock(pCompressedDataBuffer);
return(StatusCode);
}
pCompressedData += CDataLen;
CompressedDataLen += CDataLen;
CompBufDataSize -= CDataLen;
pBuffDesc = pBuffDesc->bd_Next;
}
// we are about to send so many uncompressed bytes: update stats
pArapConn->StatInfo.BytesTransmittedUncompressed += UncompressedDataLen;
// this is how many bytes will go out on the wire: update stats
pArapConn->StatInfo.BytesTransmittedCompressed += CompressedDataLen;
//
// this is how many bytes will go out on the wire: update stats
// Note that we will be adding the start/stop etc. bytes to this count somewhere else
//
pArapConn->StatInfo.BytesSent += CompressedDataLen;
#if DBG
ArapStatistics.SendPreCompMax =
(UncompressedDataLen > ArapStatistics.SendPreCompMax)?
UncompressedDataLen : ArapStatistics.SendPreCompMax;
ArapStatistics.SendPostCompMax =
(CompressedDataLen > ArapStatistics.SendPostCompMax)?
CompressedDataLen : ArapStatistics.SendPostCompMax;
ArapStatistics.SendPreCompMin =
(UncompressedDataLen < ArapStatistics.SendPreCompMin)?
UncompressedDataLen : ArapStatistics.SendPreCompMin;
ArapStatistics.SendPostCompMin =
(CompressedDataLen < ArapStatistics.SendPostCompMin)?
CompressedDataLen : ArapStatistics.SendPostCompMin;
#endif
ARAP_DBG_TRACE(pArapConn,11205,pOrgBuffDesc,Priority,0,0);
// now go put the send on the queue (And yes: hold that lock)
StatusCode = ArapQueueSendBytes(pArapConn,
pCompressedDataBuffer,
CompressedDataLen,
Priority);
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
AtalkBPFreeBlock(pCompressedDataBuffer);
return(StatusCode);
}
//***
//
// Function: ArapMnpSendComplete
// Free up the buffer used for the MNP send. If the send failed
// then kill the connection (remember, it's not just one send
// failing but a failure after all the retransmission jing-bang)
//
// Parameters: pMnpSendBuf - the send buff that contained the LR response
// StatusCode - how did it go?
//
// Return: none
//
//***$
VOID ArapMnpSendComplete(
IN PMNPSENDBUF pMnpSendBuf,
IN DWORD StatusCode
)
{
PARAPCONN pArapConn;
DWORD State;
KIRQL OldIrql;
DBG_ARAP_CHECK_PAGED_CODE();
pArapConn = pMnpSendBuf->pArapConn;
ARAPTRACE(("Entered ArapMnpSendComplete (%lx %lx %lx)\n",
pMnpSendBuf,StatusCode,pArapConn));
// the send buffer is getting freed up: update the counter
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
State = pArapConn->State;
pArapConn->SendsPending -= pMnpSendBuf->DataSize;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
if ((StatusCode != ARAPERR_NO_ERROR) && (State < MNP_LDISCONNECTING))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapMnpSendComplete (%lx %lx): bad link? Tearing down connection\n",
StatusCode,pArapConn));
// link must have gone down: kill the connection!
ArapCleanup(pArapConn);
}
// mark that compl. routine has run
#if DBG
pMnpSendBuf->Signature -= 0x100;
#endif
// the send has been acked: take away the MNP refcount on the send
DerefMnpSendBuf(pMnpSendBuf, FALSE);
}
//***
//
// Function: ArapIoctlSendComplete
// This routine is called right after the send is done in
// ArapIoctlSend, to let the dll know what happened to the send.
//
// Parameters: Status - did the send actually succeed
// pArapConn - the connection in quesion
//
// Return: none
//
//***$
VOID
ArapIoctlSendComplete(
DWORD StatusCode,
PARAPCONN pArapConn
)
{
PIRP pIrp;
KIRQL OldIrql;
PARAP_SEND_RECV_INFO pSndRcvInfo;
NTSTATUS ReturnStatus=STATUS_SUCCESS;
DBG_ARAP_CHECK_PAGED_CODE();
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
pIrp = pArapConn->pIoctlIrp;
pArapConn->pIoctlIrp = NULL;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
ARAPTRACE(("Entered ArapIoctlSendComplete (%lx %lx)\n",pArapConn,pIrp));
//
// if there is a user-level irp pending, complete it here
//
if (pIrp)
{
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pSndRcvInfo->StatusCode = StatusCode;
// complete the irp (irp always completes successfully!)
ARAP_COMPLETE_IRP(pIrp, sizeof(ARAP_SEND_RECV_INFO), STATUS_SUCCESS, &ReturnStatus);
}
}
//***
//
// Function: ArapDataToDll
// This routine tries to complete a receive posted on a connection.
// When data arrives, if the Arap connection is established then
// this routine tries to complete a receive via the "select" irp.
// If the Arap connection is not yet established, then a receive
// is completed via a "direct" irp.
//
// Parameters: pArapConn - connection element in question
//
// Return: Number of bytes transferred to the dll
//
//***$
DWORD
ArapDataToDll(
IN PARAPCONN pArapConn
)
{
KIRQL OldIrql;
PLIST_ENTRY pRcvList;
PARAPBUF pArapBuf;
PARAP_SEND_RECV_INFO pSndRcvInfo=NULL;
PIRP pIrp;
USHORT SrpModLen;
DWORD dwBytesToDll;
DWORD StatusCode;
NTSTATUS ReturnStatus=STATUS_SUCCESS;
DBG_ARAP_CHECK_PAGED_CODE();
ARAPTRACE(("Entered ArapDataToDll (%lx)\n",pArapConn));
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
if (IsListEmpty(&pArapConn->ArapDataQ))
{
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return( 0 );
}
pRcvList = pArapConn->ArapDataQ.Flink;
pArapBuf = CONTAINING_RECORD(pRcvList, ARAPBUF, Linkage);
//
// if the ARAP connection is established, we can hand the data only
// to a select irp (dll won't post direct rcv's anymore)
//
if ( pArapConn->Flags & ARAP_CONNECTION_UP )
{
ArapGetSelectIrp(&pIrp);
StatusCode = ARAPERR_DATA;
}
//
// if the ARAP connection is not established yet, we must guarantee that
// we hand the data only to a direct rcv irp for this connection
//
else
{
pIrp = pArapConn->pRecvIoctlIrp;
pArapConn->pRecvIoctlIrp = NULL;
StatusCode = ARAPERR_NO_ERROR;
}
// no irp? just have to wait then
if (!pIrp)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
("ArapDataToDll: no select irp, data waiting %lx at %ld\n", pArapConn,AtalkGetCurrentTick()));
ARAP_DBG_TRACE(pArapConn,11505,0,0,0,0);
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return( 0 );
}
//
// now that we have irp, fill in the info, after unlinking the recv buf
//
RemoveEntryList(&pArapBuf->Linkage);
ASSERT(pArapConn->RecvsPending >= pArapBuf->DataSize);
pArapConn->RecvsPending -= pArapBuf->DataSize;
ARAP_ADJUST_RECVCREDIT(pArapConn);
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
ASSERT(pSndRcvInfo->DataLen >= pArapBuf->DataSize);
SrpModLen = pArapBuf->DataSize;
// ok, copy the data in
RtlCopyMemory( &pSndRcvInfo->Data[0],
pArapBuf->CurrentBuffer,
pArapBuf->DataSize );
// set the info (contexts need to be set each time in case of select)
pSndRcvInfo->AtalkContext = pArapConn;
pSndRcvInfo->pDllContext = pArapConn->pDllContext;
pSndRcvInfo->DataLen = SrpModLen;
pSndRcvInfo->StatusCode = StatusCode;
dwBytesToDll = SrpModLen + sizeof(ARAP_SEND_RECV_INFO);
DBGDUMPBYTES("Dll recv:", &pSndRcvInfo->Data[0],pSndRcvInfo->DataLen,1);
// ok, complete that irp now!
ARAP_COMPLETE_IRP(pIrp, dwBytesToDll, STATUS_SUCCESS, &ReturnStatus);
// done with that buffer: free it here
ARAP_FREE_RCVBUF(pArapBuf);
return(SrpModLen);
}
//***
//
// Function: MnpSendAckIfReqd
// This routine sends an ack to the remote client after making
// sure that condition(s) do exist warranting sending of an Ack.
//
// Parameters: pArapConn - connection element in question
//
// Return: none
//
//***$
VOID
MnpSendAckIfReqd(
IN PARAPCONN pArapConn,
IN BOOLEAN fForceAck
)
{
KIRQL OldIrql;
BYTE SeqToAck;
BYTE RecvCredit;
PMNPSENDBUF pMnpSendBuf;
PBYTE pFrame, pFrameStart;
BOOLEAN fOptimized=TRUE;
USHORT FrameLen;
PNDIS_PACKET ndisPacket;
NDIS_STATUS ndisStatus;
DWORD StatusCode;
BOOLEAN fMustSend;
DBG_ARAP_CHECK_PAGED_CODE();
ARAPTRACE(("Entered MnpSendAckIfReqd (%lx)\n",pArapConn));
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
//
// if we are not up yet (or are disconnecting), forget about this ack
//
if (pArapConn->State != MNP_UP)
{
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return;
}
fMustSend = FALSE;
//
// first, find out if we need to send an ack at all
//
//
// if we are told to send, just send it: don't question the decision!
//
if (fForceAck)
{
fMustSend = TRUE;
}
//
// spec says if we have one or more unacked pkts and there is no user data
// to send, then send it (what's user data got to do with this??)
//
// BUGBUG: for now, don't check for IsListEmpty(&pArapConn->HighPriSendQ)
#if 0
else if ( (pArapConn->MnpState.UnAckedRecvs > 0) &&
(IsListEmpty(&pArapConn->HighPriSendQ)) )
{
fMustSend = TRUE;
}
#endif
else if (pArapConn->MnpState.UnAckedRecvs > 0)
{
fMustSend = TRUE;
}
//
// if we haven't acked for a while (i.e. have received more than the
// acceptable number of unacked packets) then send it
//
else if (pArapConn->MnpState.UnAckedRecvs >= pArapConn->MnpState.UnAckedLimit)
{
fMustSend = TRUE;
}
if (!fMustSend)
{
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return;
}
StatusCode = ARAPERR_NO_ERROR;
// first, allocate a buff descriptor (before we change the state variables)
if ((pMnpSendBuf = AtalkBPAllocBlock(BLKID_MNP_SMSENDBUF)) != NULL)
{
StatusCode = ArapGetNdisPacket(pMnpSendBuf);
}
if ((pMnpSendBuf == NULL) || (StatusCode != ARAPERR_NO_ERROR))
{
if (pMnpSendBuf)
{
ArapNdisFreeBuf(pMnpSendBuf);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("MnpSendAckIfReqd: AtalkBPAllocBlock failed on %lx\n", pArapConn))
}
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
return;
}
// BUGBUG: for now, always send full size
//RecvCredit = pArapConn->MnpState.RecvCredit;
RecvCredit = pArapConn->MnpState.WindowSize;
// tell the client which is the last packet we got successfully
SeqToAck = pArapConn->MnpState.LastSeqRcvd;
#if DBG
if ((SeqToAck == pArapConn->MnpState.LastAckSent) && (pArapConn->MnpState.HoleInSeq++ > 1))
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
("MnpSendAckIfReqd: ack %x already sent earlier\n",SeqToAck));
}
#endif
pArapConn->MnpState.LastAckSent = pArapConn->MnpState.LastSeqRcvd;
// with this ack, we will be acking all the outstanding recv's
pArapConn->MnpState.UnAckedRecvs = 0;
// "stop" the 402 timer
pArapConn->LATimer = 0;
// reset the flow-control timer
pArapConn->FlowControlTimer = AtalkGetCurrentTick() +
pArapConn->T404Duration;
if (!(pArapConn->Flags & MNP_OPTIMIZED_DATA))
{
fOptimized = FALSE;
}
ARAP_DBG_TRACE(pArapConn,11605,0,SeqToAck,RecvCredit,0);
MNP_DBG_TRACE(pArapConn,SeqToAck,MNP_LA);
// put MNPSend refcount
pArapConn->RefCount++;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
#if DBG
pMnpSendBuf->Signature = MNPSMSENDBUF_SIGNATURE;
InitializeListHead(&pMnpSendBuf->Linkage);
#endif
pMnpSendBuf->RetryCount = 0; // not relevant here
pMnpSendBuf->RefCount = 1; // remove when send completes
pMnpSendBuf->pArapConn = pArapConn;
pMnpSendBuf->ComplRoutine = NULL;
pMnpSendBuf->Flags = 1;
pFrame = pFrameStart = &pMnpSendBuf->Buffer[0];
AtalkNdisBuildARAPHdr(pFrame, pArapConn);
pFrame += WAN_LINKHDR_LEN;
//
// put the start flags
//
*pFrame++ = pArapConn->MnpState.SynByte;
*pFrame++ = pArapConn->MnpState.DleByte;
*pFrame++ = pArapConn->MnpState.StxByte;
//
// now, put the body of the Ack frame
//
if (fOptimized)
{
*pFrame++ = 3; // length indication
*pFrame++ = 5; // type indication
*pFrame++ = SeqToAck; // Receive seq number ( N(R) )
*pFrame++ = RecvCredit; // receive credit ( N(k) )
}
else
{
*pFrame++ = 7; // length indication
*pFrame++ = 5; // type indication
*pFrame++ = 1; // var type
*pFrame++ = 1; // var len
*pFrame++ = SeqToAck; // receive seq number ( N(R) )
*pFrame++ = 2; // var type
*pFrame++ = 1; // var len
*pFrame++ = RecvCredit; // receive credit ( N(k) )
}
//
// now finally, put the stop flags (no need for spinlock: this won't change!)
//
*pFrame++ = pArapConn->MnpState.DleByte;
*pFrame++ = pArapConn->MnpState.EtxByte;
FrameLen = (USHORT)(pFrame - pFrameStart);
AtalkSetSizeOfBuffDescData(&pMnpSendBuf->sb_BuffDesc, FrameLen);
NdisAdjustBufferLength(pMnpSendBuf->sb_BuffHdr.bh_NdisBuffer,FrameLen);
//
// send the packet over. We need to go directly, and not via ArapNdisSend
// because this packet needs to be delivered just once, regardless of
// whether send window is open
//
ndisPacket = pMnpSendBuf->sb_BuffHdr.bh_NdisPkt;
NdisSend(&ndisStatus, RasPortDesc->pd_NdisBindingHandle, ndisPacket);
// if there was a problem sending, call the completion routine here
if (ndisStatus != NDIS_STATUS_PENDING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("MnpSendAckIfReqd: NdisSend failed %lx\n",ndisStatus));
ArapNdisSendComplete(ARAPERR_SEND_FAILED, (PBUFFER_DESC)pMnpSendBuf, NULL);
}
}
//***
//
// Function: MnpSendLNAck
// This routine sends an LN ack to the remote client, acknowleding
// receipt of an LN frame
//
// Parameters: pArapConn - connection element in question
//
// Return: none
//
//***$
VOID
MnpSendLNAck(
IN PARAPCONN pArapConn,
IN BYTE LnSeqToAck
)
{
KIRQL OldIrql;
PMNPSENDBUF pMnpSendBuf;
PBYTE pFrame, pFrameStart;
USHORT FrameLen;
PNDIS_PACKET ndisPacket;
NDIS_STATUS ndisStatus;
DWORD StatusCode;
DBG_ARAP_CHECK_PAGED_CODE();
ARAPTRACE(("Entered MnpSendLNAck (%lx), %d\n",pArapConn,LnSeqToAck));
StatusCode = ARAPERR_NO_ERROR;
// first, allocate a buff descriptor
if ((pMnpSendBuf = AtalkBPAllocBlock(BLKID_MNP_SMSENDBUF)) != NULL)
{
StatusCode = ArapGetNdisPacket(pMnpSendBuf);
}
if (pMnpSendBuf == NULL || (StatusCode != ARAPERR_NO_ERROR))
{
if (pMnpSendBuf)
{
ArapNdisFreeBuf(pMnpSendBuf);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("MnpSendLNAck: AtalkBPAllocBlock failed on %lx\n", pArapConn))
}
return;
}
#if DBG
pMnpSendBuf->Signature = MNPSMSENDBUF_SIGNATURE;
InitializeListHead(&pMnpSendBuf->Linkage);
#endif
pMnpSendBuf->RetryCount = 0; // not relevant here
pMnpSendBuf->RefCount = 1; // remove when send completes
pMnpSendBuf->pArapConn = pArapConn;
pMnpSendBuf->ComplRoutine = NULL;
pMnpSendBuf->Flags = 1;
pFrame = pFrameStart = &pMnpSendBuf->Buffer[0];
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
// if we are disconnecting, forget about sending this ack
if (pArapConn->State >= MNP_LDISCONNECTING)
{
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
ArapNdisFreeBuf(pMnpSendBuf);
return;
}
// put MNPSend refcount
pArapConn->RefCount++;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
AtalkNdisBuildARAPHdr(pFrame, pArapConn);
pFrame += WAN_LINKHDR_LEN;
//
// put the start flags
//
*pFrame++ = pArapConn->MnpState.SynByte;
*pFrame++ = pArapConn->MnpState.DleByte;
*pFrame++ = pArapConn->MnpState.StxByte;
//
// now, put the body of the Ack frame
//
*pFrame++ = 4; // length indication
*pFrame++ = 7; // type indication
*pFrame++ = 1; // var type
*pFrame++ = 1; // var len
*pFrame++ = LnSeqToAck; //
//
// now finally, put the stop flags
//
*pFrame++ = pArapConn->MnpState.DleByte;
*pFrame++ = pArapConn->MnpState.EtxByte;
FrameLen = (USHORT)(pFrame - pFrameStart);
AtalkSetSizeOfBuffDescData(&pMnpSendBuf->sb_BuffDesc, FrameLen);
NdisAdjustBufferLength(pMnpSendBuf->sb_BuffHdr.bh_NdisBuffer,FrameLen);
//
// send the packet over. We need to go directly, and not via ArapNdisSend
// because this packet needs to be delivered just once, regardless of
// whether send window is open
//
ndisPacket = pMnpSendBuf->sb_BuffHdr.bh_NdisPkt;
NdisSend(&ndisStatus, RasPortDesc->pd_NdisBindingHandle, ndisPacket);
// if there was a problem sending, call the completion routine here
if (ndisStatus != NDIS_STATUS_PENDING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("MnpSendLNAck: NdisSend failed %lx\n",ndisStatus));
ArapNdisSendComplete(ARAPERR_SEND_FAILED, (PBUFFER_DESC)pMnpSendBuf, NULL);
}
}
//***
//
// Function: ArapSendLDPacket
// This routine sends a Disconnect (LD) packet to the client
//
// Parameters: pArapConn - the connection
//
// Return: result of the operation
//
//***$
DWORD
ArapSendLDPacket(
IN PARAPCONN pArapConn,
IN BYTE UserCode
)
{
PBYTE pFrame, pFrameStart;
USHORT FrameLen;
PNDIS_PACKET ndisPacket;
NDIS_STATUS ndisStatus;
PMNPSENDBUF pMnpSendBuf;
KIRQL OldIrql;
DWORD StatusCode;
DBG_ARAP_CHECK_PAGED_CODE();
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapSendLDPacket: sending DISCONNECT on %lx\n",pArapConn));
StatusCode = ARAPERR_NO_ERROR;
//
// allocate buf to send out the disconnection request
//
if ((pMnpSendBuf = AtalkBPAllocBlock(BLKID_MNP_SMSENDBUF)) != NULL)
{
StatusCode = ArapGetNdisPacket(pMnpSendBuf);
}
if ((pMnpSendBuf == NULL) || (StatusCode != ARAPERR_NO_ERROR))
{
if (pMnpSendBuf)
{
ArapNdisFreeBuf(pMnpSendBuf);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapSendLDPacket: AtalkBPAllocBlock failed on %lx\n", pArapConn));
}
return(ARAPERR_OUT_OF_RESOURCES);
}
#if DBG
pMnpSendBuf->Signature = MNPSMSENDBUF_SIGNATURE;
InitializeListHead(&pMnpSendBuf->Linkage);
#endif
pMnpSendBuf->RetryCount = 0; // not relevant here
pMnpSendBuf->RefCount = 1; // remove when send completes
pMnpSendBuf->pArapConn = pArapConn;
pMnpSendBuf->ComplRoutine = NULL;
pMnpSendBuf->Flags = 1;
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
//
// if we are already disconnecting (say remote disconnected), just say ok
//
if (pArapConn->State >= MNP_LDISCONNECTING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, ("ArapSendLDPacket: silently \
discarding disconnect (already in progress) %lx\n", pArapConn));
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
ArapNdisFreeBuf(pMnpSendBuf);
return(ARAPERR_DISCONNECT_IN_PROGRESS);
}
// Disconnect refcount: protect pArapConn until disconnect is complete
pArapConn->RefCount++;
// put MNPSend refcount
pArapConn->RefCount++;
pArapConn->State = MNP_LDISCONNECTING;
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
pFrame = pFrameStart = &pMnpSendBuf->Buffer[0];
AtalkNdisBuildARAPHdr(pFrame, pArapConn);
pFrame += WAN_LINKHDR_LEN;
//
// put the start flags
//
*pFrame++ = pArapConn->MnpState.SynByte;
*pFrame++ = pArapConn->MnpState.DleByte;
*pFrame++ = pArapConn->MnpState.StxByte;
//
// now, put the body of the LD frame
//
*pFrame++ = 7; // length indication
*pFrame++ = 2; // type indication for LD
*pFrame++ = 1; // var type
*pFrame++ = 1; // var len
*pFrame++ = 0xFF; // User-initiated disconnect
*pFrame++ = 2; // var type
*pFrame++ = 1; // var len
*pFrame++ = UserCode;
//
// now finally, put the stop flags
//
*pFrame++ = pArapConn->MnpState.DleByte;
*pFrame++ = pArapConn->MnpState.EtxByte;
FrameLen = (USHORT)(pFrame - pFrameStart);
AtalkSetSizeOfBuffDescData(&pMnpSendBuf->sb_BuffDesc, FrameLen);
NdisAdjustBufferLength(pMnpSendBuf->sb_BuffHdr.bh_NdisBuffer,FrameLen);
ARAP_SET_NDIS_CONTEXT(pMnpSendBuf, NULL);
ndisPacket = pMnpSendBuf->sb_BuffHdr.bh_NdisPkt;
// send the packet over (and don't bother checking return code!)
NdisSend(&ndisStatus, RasPortDesc->pd_NdisBindingHandle, ndisPacket);
// if there was a problem sending, call the completion routine here
if (ndisStatus != NDIS_STATUS_PENDING)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapSendLDPacket: NdisSend failed %lx\n",ndisStatus));
ArapNdisSendComplete(ARAPERR_SEND_FAILED, (PBUFFER_DESC)pMnpSendBuf, NULL);
}
// remove the disconnect refcount
DerefArapConn(pArapConn);
return(ARAPERR_NO_ERROR);
}
//***
//
// Function: ArapRetryTimer
// This is the general purpose timer routine for ARAP.
// It checks
// if the ack timer (LATimer) has expired (if yes, send ack)
// if the flowcontrol timer has expired (if yes, send ack)
// if the inactivity timer has expired (if yes, send ack)
// if the retransmit timer has expired (if yes, retransmit)
//
// Parameters: pTimer - the context for the timer that just fired
// TimerShuttingDown - this is TRUE if timer is shutting down
//
// Return: none
//
//***$
LONG FASTCALL
ArapRetryTimer(
IN PTIMERLIST pTimer,
IN BOOLEAN TimerShuttingDown
)
{
PARAPCONN pArapConn;
PLIST_ENTRY pList;
PMNPSENDBUF pMnpSendBuf;
BOOLEAN fRetransmit=FALSE;
BOOLEAN fMustSendAck = FALSE;
BOOLEAN fKill=FALSE;
BOOLEAN fMustFlowControl=FALSE;
BOOLEAN fInactiveClient=FALSE;
LONG CurrentTime;
PIRP pIrp=NULL;
NTSTATUS ReturnStatus=STATUS_SUCCESS;
DBG_ARAP_CHECK_PAGED_CODE();
pArapConn = CONTAINING_RECORD(pTimer, ARAPCONN, RetryTimer);
ARAPTRACE(("Entered ArapRetryTimer (%lx)\n",pArapConn));
ACQUIRE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
//
// if the global timer is shutting down, or if the connection isn't in the
// right state (e.g. it is disconnecting), then don't requeue the timer
//
if ( TimerShuttingDown ||
(pArapConn->State <= MNP_IDLE) || (pArapConn->State > MNP_UP) )
{
pArapConn->Flags &= ~RETRANSMIT_TIMER_ON;
RELEASE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
if (TimerShuttingDown)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapRetryTimer: timer shut down, killing conn (%lx)\n",pArapConn));
ArapCleanup(pArapConn);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapRetryTimer: (%lx) invalid state (%d), not requeing timer\n",
pArapConn,pArapConn->State));
}
// remove the timer refcount
DerefArapConn(pArapConn);
return ATALK_TIMER_NO_REQUEUE;
}
CurrentTime = AtalkGetCurrentTick();
//
// has the 402 timer expired? if yes, we must send an ack
// (a value of 0 signifies that the 402 timer is not "running")
//
if ( (pArapConn->LATimer != 0) && (CurrentTime >= pArapConn->LATimer) )
{
//
// make sure there is a receive that needs to be acked (if sent the ack
// just before this timer fired, don't send the ack again)
//
if (pArapConn->MnpState.UnAckedRecvs)
{
fMustSendAck = TRUE;
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapRetryTimer: 402 timer fired, forcing ack out (%d, now %d)\n",
pArapConn->LATimer,CurrentTime));
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapRetryTimer: saved on on ack (UnAckedRecvs = 0)\n",pArapConn));
}
}
//
// has the flow control timer "expired"? If so, we must send an ack and
// reset the timer
// (a value of 0 signifies that the flow control timer is not "running")
//
else if ( (pArapConn->FlowControlTimer != 0) &&
(CurrentTime >= pArapConn->FlowControlTimer) )
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
("ArapRetryTimer: flow-control timer, forcing ack (%d, now %d)\n",
pArapConn->FlowControlTimer,CurrentTime));
fMustFlowControl = TRUE;
pArapConn->FlowControlTimer = CurrentTime + pArapConn->T404Duration;
}
//
// if the client been inactive for a long time, we must tell dll
//
else if (CurrentTime >= pArapConn->InactivityTimer)
{
// first make sure we can get the select irp
ArapGetSelectIrp(&pIrp);
// if we managed to get a select irp, reset the timer so we don't keep
// informing the dll after every tick after this point!
//
if (pIrp)
{
pArapConn->InactivityTimer = pArapConn->T403Duration + CurrentTime;
fInactiveClient = TRUE;
}
}
//
// Has the retransmit timer expired? If so, we need to retransmit
//
else
{
//
// look at the first entry of the retransmit queue. If it's time is up, do
// the retransmit thing. Otherwise, we are done. (All others in the queue
// will be retransmitted after this first one is acked, so ignore for now)
//
pList = pArapConn->RetransmitQ.Flink;
// no entries on the retransmit queue? we're done!
if (pList == &pArapConn->RetransmitQ)
{
RELEASE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
return ATALK_TIMER_REQUEUE;
}
pMnpSendBuf = CONTAINING_RECORD(pList, MNPSENDBUF, Linkage);
// is it time to retransmit yet?
if (CurrentTime >= pMnpSendBuf->RetryTime)
{
if (pMnpSendBuf->RetryCount >= ARAP_MAX_RETRANSMITS)
{
fKill = TRUE;
RemoveEntryList(&pMnpSendBuf->Linkage);
ASSERT(pArapConn->MnpState.UnAckedSends >= 1);
// not really important, since we're about to disconnect!
pArapConn->MnpState.UnAckedSends--;
ASSERT(pArapConn->SendsPending >= pMnpSendBuf->DataSize);
InitializeListHead(&pMnpSendBuf->Linkage);
}
else
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
("ArapRetryTimer: timer fired, retransmitting....%x (%ld now %ld)\n",
pMnpSendBuf->SeqNum,pMnpSendBuf->RetryTime,CurrentTime));
if (pMnpSendBuf->RetryCount > 8)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapRetryTimer: buf %lx of %lx retransmitted %d times!\n",
pMnpSendBuf,pArapConn,pMnpSendBuf->RetryCount));
}
pArapConn->MnpState.RetransmitMode = TRUE;
pArapConn->MnpState.MustRetransmit = TRUE;
fRetransmit = TRUE;
}
}
}
RELEASE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
// force an ack out (that's what TRUE does)
if (fMustSendAck || fMustFlowControl)
{
MnpSendAckIfReqd(pArapConn, TRUE);
}
// if we must retransmit, go for it.
//
else if (fRetransmit)
{
ArapNdisSend(pArapConn, &pArapConn->RetransmitQ);
}
//
// if we retransmitted too many times, let the completion routine know.
// (it will probably kill the connection)
//
else if (fKill)
{
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapRetryTimer: too many retransmits (%lx), disconnecting %lx\n",
pMnpSendBuf,pArapConn));
(pMnpSendBuf->ComplRoutine)(pMnpSendBuf, ARAPERR_SEND_FAILED);
}
//
// if the connection has been inactive for longer than the limit (given to
// us by the dll), then tell dll about it
//
else if (fInactiveClient)
{
PARAP_SEND_RECV_INFO pSndRcvInfo;
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
("ArapRetryTimer: (%lx) inactive, telling dll (%lx)\n",pArapConn, pIrp));
ASSERT(pIrp != NULL);
pSndRcvInfo = (PARAP_SEND_RECV_INFO)pIrp->AssociatedIrp.SystemBuffer;
pSndRcvInfo->pDllContext = pArapConn->pDllContext;
pSndRcvInfo->AtalkContext = pArapConn;
pSndRcvInfo->StatusCode = ARAPERR_CONN_INACTIVE;
ARAP_COMPLETE_IRP(pIrp, sizeof(ARAP_SEND_RECV_INFO), STATUS_SUCCESS, &ReturnStatus);
return ReturnStatus;
}
return ATALK_TIMER_REQUEUE;
}
Reference in a new issue Copy permalink