2905 lines
80 KiB
C
2905 lines
80 KiB
C
/*++
|
|
|
|
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;
|
|
}
|
|
|
|
|