|
|
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
arap.h
Abstract:
This module has defines, prototypes etc. specific to ARAP functionality
Author:
Shirish Koti
Revision History: 15 Nov 1996 Initial Version
--*/
//
// enable asserts when running checked stack on free builds
//
#if DBG
#ifdef ASSERT
#undef ASSERT
#endif
#define ASSERT(exp) \
{ \ if (!(exp)) \ { \ DbgPrint( "\n*** Assertion failed: %s (File %s, line %ld)\n", \ (exp),__FILE__, __LINE__); \ \ DbgBreakPoint(); \ } \}#endif
#define ATALK_CC_METHOD(_ControlCode) ((_ControlCode) & 0x03)
//
// Possible states for the connection (State field in ARAPCONN structure)
// IMPORTANT: order of these states matters! (comparisons other than == used)
//
#define MNP_IDLE 0 // creation state, after Ndiswan Line_Up
#define MNP_REQUEST 1 // this state never reached (client-side only)
#define MNP_RESPONSE 2 // sent LR response to the client
#define MNP_UP 3 // MNP connection is in data-phase
#define MNP_LDISCONNECTING 4 // disconnect from local (user ioctl)
#define MNP_RDISC_RCVD 5 // disconnect from remote received
#define MNP_RDISCONNECTING 6 // cleanup underway because of MNP_RDISC_RCVD
#define MNP_DISCONNECTED 7 // cleanup done, waiting for Ndiswan Line_Down
//
// possible header types (from the v42 alternative procedure spec)
//
#define MNP_LR 0x1
#define MNP_LD 0x2
#define MNP_LT 0x4
#define MNP_LT_V20CLIENT 0x84
#define MNP_LA 0x5
#define MNP_LN 0x6
#define MNP_LNA 0x7
#define MNP_MINPKT_SIZE 64
#define MNP_MAXPKT_SIZE 256
#define MNP_LR_CONST1 2
// type values for the various "variable" parms
#define MNP_LR_CONST2 1
#define MNP_LR_FRAMING 2
#define MNP_LR_NUMLTFRMS 3
#define MNP_LR_INFOLEN 4
#define MNP_LR_DATAOPT 8
#define MNP_LR_V42BIS 14
#define MNP_FRMMODE_OCTET 2
#define MNP_FRMMODE_BIT 3
#define MNP_FRMTYPE_OFFSET 4
#define ARAP_DGROUP_OFFSET 2
#define ARAP_DATA_OFFSET 3
// bit 6 is set for appletalk data, is clear for arap data
#define ARAP_SFLAG_PKT_DATA 0x40
#define ARAP_SFLAG_LAST_GROUP 0x10
//
// Flags bits (in ARAPCONN structure)
//
#define MNP_OPTIMIZED_DATA 0x00000001 // MNP negotiated for optimized data
#define MNP_V42BIS_NEGOTIATED 0x00000002 // MNP negotiated v42bis compression
#define ARAP_V20_CONNECTION 0x00000004 // v2.0 if bit set, v1.0 otherwise
#define ARAP_NODE_IN_USE 0x00000008 // used while acquiring node (dynamic mode)
#define ARAP_FINDING_NODE 0x00000010 // used while acquiring node (dynamic mode)
#define ARAP_CALLBACK_MODE 0x00000020 // used if we are calling back
#define ARAP_CONNECTION_UP 0x00000040 // ARAP connection is up, data phase entered
#define ARAP_DATA_WAITING 0x00000080 // data arrived, but no irp to fill it in
#define ARAP_REMOTE_DISCONN 0x00000100 // remote side issued the disconnect
#define DISCONNECT_NO_IRP 0x00000200 // waiting for irp to tell dll about disc.
#define RETRANSMIT_TIMER_ON 0x00000400 // retransmit timer is running
#define ARAP_LINK_DOWN 0x00000800 // link went down
#define ARAP_GOING_AWAY 0x00001000 // the connection is about to be freed!
// BUGBUG: currently set to be 200ms (1 => 100 ms)
#define ARAP_TIMER_INTERVAL 2
#define ARAP_MAX_RETRANSMITS 12
#define ARAP_HALF_MAX_RETRANSMITS (ARAP_MAX_RETRANSMITS/2)
// retry time will depend on link speed (also on how many retranmits of the
// same send have happened so far), but we'll fix min (1sec) and max (5sec)
#define ARAP_MIN_RETRY_INTERVAL 10
#define ARAP_MAX_RETRY_INTERVAL 50
// our limits (in bytes) for outstanding sends that are sitting on the queue
#define ARAP_SENDQ_LOWER_LIMIT 10000
#define ARAP_SENDQ_UPPER_LIMIT 12000
// our limits (in bytes) for outstanding recvs that are sitting on the queue
#define ARAP_RECVQ_LOWER_LIMIT 20000
#define ARAP_RECVQ_UPPER_LIMIT 30000
// on low-priority sends, we wait until we collect at least these many bytes
#define ARAP_SEND_COALESCE_SIZE_LIMIT 150
// max number of SRPs we will put in a low-priority MNP send
#define ARAP_SEND_COALESCE_SRP_LIMIT 200
// on low-priority sends, we wait until so much time has passed (in 100ms units)
#define ARAP_SEND_COALESCE_TIME_LIMIT 10
// BUGBUG: adjust these numbers for optimum usage/perf
#define ARAP_SMPKT_SIZE 100
#define ARAP_MDPKT_SIZE 300
#define ARAP_LGPKT_SIZE ARAP_MAXPKT_SIZE_INCOMING+10
#define ARAP_SENDBUF_SIZE 1000
#define ARAP_LGBUF_SIZE 4000
#define ARAP_HGBUF_SIZE 8100
// LAP src byte, LAP dest byte, LAP type byte
#define ARAP_LAP_HDRSIZE 3
// 2 srplen bytes, 1 Dgroup byte
#define ARAP_HDRSIZE 3
#define ARAP_NBP_BRRQ 0x11
#define ARAP_NBP_LKRQ 0x21
// 3rd and 4th bytes in the NBP pkt are the source network bytes
#define ARAP_NBP_SRCNET_OFFSET LDDP_DGRAM_OFFSET + 2
#define ARAP_NBP_OBJLEN_OFFSET LDDP_DGRAM_OFFSET + 7
#define ARAP_FAKE_ETHNET_HDRLEN 14
#define MNP_START_FLAG_LEN 3
#define MNP_STOP_FLAG_LEN 2
#define MNP_LT_HDR_LN(_pCon) ((_pCon->Flags & MNP_OPTIMIZED_DATA)? 3 : 5)
#define ARAP_SEND_PRIORITY_HIGH 1
#define ARAP_SEND_PRIORITY_MED 2
#define ARAP_SEND_PRIORITY_LOW 3
#define MNP_OVERHD(_pConn) \
( ARAP_FAKE_ETHNET_HDRLEN + \ MNP_START_FLAG_LEN + \ MNP_LT_HDR_LN(_pConn) + \ MNP_STOP_FLAG_LEN )
#define ADD_ONE(_x) (_x) = (((_x) == 0xff) ? 0 : ((_x)+1))
// seq num on LT frame: 5th byte if it's an Optimized data phase: 7th otherwise
#define LT_SEQ_NUM(_p, _pCon) \
(((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? (_p)[5] : (_p)[7])
#define LT_SEQ_OFFSET(_pCon) (((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? 5: 7)
#define LT_SRP_OFFSET(_pCon) (((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? 6: 8)
// this includes 2 bytes of crc bytes
#define LT_OVERHEAD(_pCon) (((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? 10 : 12)
// BUGBUG modify this to include any packet in the window
#define LT_OK_TO_ACCEPT(_sq, _pCon, _ok) \
(_ok = (_sq == _pCon->MnpState.NextToReceive))
//
// basically, (a > b)? except that a,b are seq numbers and wrap at 255
// Within a window of 8 pkts either side of 0, we have special cases
// we have assumed windowsize to be 8 here. Even if a different window
// size is negotiated, this should work just fine
// BUGBUG: should we use a bigger range, just to be sure?
//
#define LT_GREATER_THAN(_a,_b,_result) \
{ \ if ( (_a) >= 248 && (_b) >= 0 && (_b) < 8 ) \ { \ _result = FALSE; \ } \ else if ( (_a) >= 0 && (_a) < 8 && (_b) >= 248 ) \ { \ _result = TRUE; \ } \ else \ { \ _result = ((_a) > (_b)); \ } \}
#define LT_LESS_OR_EQUAL(_x,_y,_rslt) \
{ \ LT_GREATER_THAN(_x,_y,_rslt); \ _rslt = !(_rslt); \}
#define LT_MIN_LENGTH(_pCon) (((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? 6 : 8)
#define LA_MIN_LENGTH(_pCon) (((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? 7 : 9)
#define LN_MIN_LENGTH 8
// seq num on LA frame: 5th byte if it's an Optimized data phase: 7th otherwise
#define LA_SEQ_NUM(_p, _pCon) \
(((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? (_p)[5] : (_p)[7])
// rcv credit on LA frame: 6th byte if it's an Optimized data phase: 8th otherwise
#define LA_CREDIT(_p, _pCon) \
(((_pCon)->Flags & MNP_OPTIMIZED_DATA) ? (_p)[6] : (_p)[8])
// overhead for LT (optimized): 8 = 3(start flag)+3(LT hdr)+2(stop flag)
// (nonoptimized): 10 = 3(start flag)+5(LT hdr)+2(stop flag)
#define LN_ATTN_TYPE(_p) ((_p)[7])
#define LN_ATTN_SEQ(_p) ((_p)[4])
#define LN_DESTRUCTIVE 1
#define LN_NON_D_E 2
#define LN_NON_D_NON_E 3
// The states that the stack can assume (with respect to ARAP)
//
// ARAP_STATE_INIT -- arap engine (dll) hasn't open the stack
// ARAP_STATE_INACTIVE_WAITING -- stack inactive, but engine not notified yet
// ARAP_STATE_INACTIVE -- stack inactive, and engine notified
// ARAP_STATE_ACTIVE_WAITING -- stack ready, engine not notified yet (select not available)
// ARAP_STATE_ACTIVE -- stack ready, engine notified about it (via select)
//
#define ARAP_STATE_INACTIVE_WAITING 1
#define ARAP_STATE_INACTIVE 2
#define ARAP_STATE_ACTIVE_WAITING 3
#define ARAP_STATE_ACTIVE 4
#define ARAP_PORT_READY ( (AtalkDefaultPort != NULL) && \
(AtalkDefaultPort->pd_Flags & PD_ACTIVE) && \ (RasPortDesc != NULL) && \ (RasPortDesc->pd_Flags & PD_ACTIVE) )
#define ARAP_PNP_IN_PROGRESS ( ((AtalkDefaultPort != NULL) && \
(AtalkDefaultPort->pd_Flags & PD_PNP_RECONFIGURE)) || \ ((RasPortDesc != NULL) && \ (RasPortDesc->pd_Flags & PD_PNP_RECONFIGURE)) )
#define ARAP_INVALID_CONTEXT (PVOID)0x01020304
#define ARAP_GET_SNIFF_IRP(_pIrp) \
{ \ KIRQL _OldIrqlX; \ \ ACQUIRE_SPIN_LOCK(&ArapSpinLock, &_OldIrqlX); \ *(_pIrp) = ArapSniffIrp; \ ArapSniffIrp = NULL; \ RELEASE_SPIN_LOCK(&ArapSpinLock, _OldIrqlX); \}
#if DBG
#define ARAP_COMPLETE_IRP(_pIrp, _dwBytesToDll, _status, _returnStatus) \
{ \ PIO_STACK_LOCATION _pIrpSp; \ ULONG _IoControlCode; \ \ _pIrpSp = IoGetCurrentIrpStackLocation(_pIrp); \ _IoControlCode = _pIrpSp->Parameters.DeviceIoControl.IoControlCode; \ \ _pIrp->IoStatus.Information = _dwBytesToDll; \ _pIrp->IoStatus.Status = _status; \ \ DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO, \ ("Arap: completing pIrp %lx, Ioctl %lx, Status=%ld, DataLen=%ld\n", \ _pIrp,_IoControlCode,_status,_dwBytesToDll)); \ \ _pIrp->CancelRoutine = NULL; \ *_returnStatus = _pIrp->IoStatus.Status; \ IoCompleteRequest(_pIrp,IO_NETWORK_INCREMENT); \}#else
#define ARAP_COMPLETE_IRP(_pIrp, _dwBytesToDll, _status, _returnStatus) \
{ \ PIO_STACK_LOCATION _pIrpSp; \ \ _pIrpSp = IoGetCurrentIrpStackLocation(_pIrp); \ \ _pIrp->IoStatus.Information = _dwBytesToDll; \ _pIrp->IoStatus.Status = _status; \ \ \ _pIrp->CancelRoutine = NULL; \ *_returnStatus= _pIrp->IoStatus.Status; \ IoCompleteRequest(_pIrp,IO_NETWORK_INCREMENT); \}#endif
#define ARAP_SET_NDIS_CONTEXT(_pSndBuf,_pSndContxt) \
{ \ PPROTOCOL_RESD _pResd; \ PNDIS_PACKET _nPkt; \ \ _nPkt = (_pSndBuf)->sb_BuffHdr.bh_NdisPkt; \ _pResd = (PPROTOCOL_RESD)&_nPkt->ProtocolReserved; \ \ _pResd->Send.pr_Port = RasPortDesc; \ _pResd->Send.pr_SendCompletion = ArapNdisSendComplete; \ _pResd->Send.pr_BufferDesc = (PBUFFER_DESC)(_pSndBuf); \ if ((_pSndContxt) != NULL) \ { \ RtlCopyMemory(&_pResd->Send.pr_SendInfo, \ (_pSndContxt), \ sizeof(SEND_COMPL_INFO)); \ } \ else \ { \ RtlZeroMemory(&_pResd->Send.pr_SendInfo, sizeof(SEND_COMPL_INFO)); \ } \}
//
// we take a very simplistic view!
//
#define ARAP_ADJUST_RECVCREDIT(_pConn) \
{ \ if (_pConn->RecvsPending >= ARAP_RECVQ_UPPER_LIMIT) \ { \ DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, \ ("ARAP (%lx): recv credit dropped to 0 (%d)\n",_pConn,_pConn->RecvsPending));\ \ _pConn->MnpState.RecvCredit = 0; \ } \ else if (_pConn->RecvsPending >= ARAP_RECVQ_LOWER_LIMIT) \ { \ DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, \ ("ARAP (%lx): recv credit dropped to 1 (%d)\n",_pConn,_pConn->RecvsPending));\ \ _pConn->MnpState.RecvCredit = 1; \ } \ else \ { \ _pConn->MnpState.RecvCredit = _pConn->MnpState.WindowSize; \ } \}
#if DBG
#define ARAP_GET_RIGHTSIZE_RCVBUF(_size, _ppNewBuf) \
{ \ UCHAR _BlkId; \ PARAPBUF _pRcvBuf; \ USHORT _BufSize; \ DWORD _Signature; \ \ *(_ppNewBuf) = NULL; \ _pRcvBuf = NULL; \ \ if ((_size) <= ARAP_SMPKT_SIZE) \ { \ _BlkId = BLKID_ARAP_SMPKT; \ _BufSize = ARAP_SMPKT_SIZE; \ _Signature = ARAPSMPKT_SIGNATURE; \ } \ else if ((_size) <= ARAP_MDPKT_SIZE) \ { \ _BlkId = BLKID_ARAP_MDPKT; \ _BufSize = ARAP_MDPKT_SIZE; \ _Signature = ARAPMDPKT_SIGNATURE; \ } \ else if ((_size) <= ARAP_LGPKT_SIZE) \ { \ _BlkId = BLKID_ARAP_LGPKT; \ _BufSize = ARAP_LGPKT_SIZE; \ _Signature = ARAPLGPKT_SIGNATURE; \ } \ else if ((_size) <= ARAP_LGBUF_SIZE) \ { \ _BlkId = BLKID_ARAP_LGBUF; \ _BufSize = ARAP_LGBUF_SIZE; \ _Signature = ARAPLGBUF_SIGNATURE; \ } \ else \ { \ _BlkId = ARAP_UNLMTD_BUFF_ID; \ _BufSize = (USHORT)(_size); \ _Signature = ARAPUNLMTD_SIGNATURE; \ } \ \ if (_BlkId == ARAP_UNLMTD_BUFF_ID) \ { \ if ((_size) > 5000) \ { \ DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR, \ ("Arap: allocating %ld bytes rcv buf\n",_size)); \ } \ \ _pRcvBuf = (PARAPBUF)AtalkAllocMemory((_size) + sizeof(ARAPBUF)); \ } \ else \ { \ _pRcvBuf = (PARAPBUF)AtalkBPAllocBlock(_BlkId); \ } \ \ if (_pRcvBuf != NULL) \ { \ _pRcvBuf->Signature = _Signature; \ _pRcvBuf->BlockId = _BlkId; \ _pRcvBuf->BufferSize = _BufSize; \ _pRcvBuf->DataSize = 0; \ _pRcvBuf->CurrentBuffer = &(_pRcvBuf->Buffer[0]); \ *(_ppNewBuf) = _pRcvBuf; \ } \}
#define ARAP_FREE_RCVBUF(_pBuf) \
{ \ ASSERT( (_pBuf->Signature == ARAPSMPKT_SIGNATURE) || \ (_pBuf->Signature == ARAPMDPKT_SIGNATURE) || \ (_pBuf->Signature == ARAPLGPKT_SIGNATURE) || \ (_pBuf->Signature == ARAPLGBUF_SIGNATURE) || \ (_pBuf->Signature == ARAPUNLMTD_SIGNATURE) ); \ \ _pBuf->Signature -= 0x10210000; \ if (_pBuf->BlockId == ARAP_UNLMTD_BUFF_ID) \ { \ AtalkFreeMemory(_pBuf); \ } \ else \ { \ AtalkBPFreeBlock(_pBuf); \ } \}
#define ARAP_CHECK_RCVQ_INTEGRITY(_pConn) \
{ \ ASSERT( (DbgChkRcvQIntegrity(_pConn)) ); \}
#define MNP_DBG_TRACE(_pConn,_Seq,_FrmType) \
{ \ ArapDbgMnpHist(_pConn,_Seq,(_FrmType)); \} \
#define ARAP_DBG_TRACE(_pConn,_Loc,_Ptr,_D1,_D2,_D3) \
{ \ ArapDbgTrace(_pConn,_Loc,_Ptr,_D1,_D2,_D3); \}
#define ARAP_DUMP_DBG_TRACE(_pConn) ArapDumpSniffInfo(_pConn)
#else
#define ARAP_GET_RIGHTSIZE_RCVBUF(_size, _ppNewBuf) \
{ \ UCHAR _BlkId; \ PARAPBUF _pRcvBuf; \ USHORT _BufSize; \ \ *(_ppNewBuf) = NULL; \ _pRcvBuf = NULL; \ \ if ((_size) <= ARAP_SMPKT_SIZE) \ { \ _BlkId = BLKID_ARAP_SMPKT; \ _BufSize = ARAP_SMPKT_SIZE; \ } \ else if ((_size) <= ARAP_MDPKT_SIZE) \ { \ _BlkId = BLKID_ARAP_MDPKT; \ _BufSize = ARAP_MDPKT_SIZE; \ } \ else if ((_size) <= ARAP_LGPKT_SIZE) \ { \ _BlkId = BLKID_ARAP_LGPKT; \ _BufSize = ARAP_LGPKT_SIZE; \ } \ else if ((_size) <= ARAP_LGBUF_SIZE) \ { \ _BlkId = BLKID_ARAP_LGBUF; \ _BufSize = ARAP_LGBUF_SIZE; \ } \ else \ { \ _BlkId = ARAP_UNLMTD_BUFF_ID; \ _BufSize = (USHORT)(_size); \ } \ \ if (_BlkId == ARAP_UNLMTD_BUFF_ID) \ { \ _pRcvBuf = (PARAPBUF)AtalkAllocMemory((_size) + sizeof(ARAPBUF)); \ } \ else \ { \ _pRcvBuf = (PARAPBUF)AtalkBPAllocBlock(_BlkId); \ } \ \ if (_pRcvBuf != NULL) \ { \ _pRcvBuf->BlockId = _BlkId; \ _pRcvBuf->BufferSize = _BufSize; \ _pRcvBuf->DataSize = 0; \ _pRcvBuf->CurrentBuffer = &(_pRcvBuf->Buffer[0]); \ *(_ppNewBuf) = _pRcvBuf; \ } \}
#define ARAP_FREE_RCVBUF(_pBuf) \
{ \ if (_pBuf->BlockId == ARAP_UNLMTD_BUFF_ID) \ { \ AtalkFreeMemory(_pBuf); \ } \ else \ { \ AtalkBPFreeBlock(_pBuf); \ } \}
#define ARAP_CHECK_RCVQ_INTEGRITY(_pConn)
#define MNP_DBG_TRACE(_pConn,_Seq,_FrmType)
#define ARAP_DBG_TRACE(_pConn,_Loc,_Ptr,_D1,_D2,_D3)
#define ARAP_DUMP_DBG_TRACE(_pConn)
#endif // #if DBG
#define ARAP_BYTES_ON_RECVQ(_pConn,_BytesOnQ) \
{ \ DWORD _BytesSoFar=0; \ PLIST_ENTRY _pList; \ PARAPBUF _pArapBuf; \ \ *(_BytesOnQ) = 0; \ \ _pList = _pConn->ReceiveQ.Flink; \ while (_pList != &_pConn->ReceiveQ) \ { \ _pArapBuf = CONTAINING_RECORD(_pList, ARAPBUF, Linkage); \ _BytesSoFar += _pArapBuf->DataSize; \ \ _pList = _pArapBuf->Linkage.Flink; \ } \ \ *(_BytesOnQ) = _BytesSoFar; \}
#if DBG
#define ARAPTRACE(_x) DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO, _x)
#define DBGDUMPBYTES(_a,_b,_c,_d) DbgDumpBytes(_a,_b,_c,_d)
#define DBGTRACK_SEND_SIZE(_pConn,_Size) DbgTrackInfo(_pConn,_Size,1)
#else
#define ARAPTRACE(_x)
#define DBGDUMPBYTES(_a,_b,_c,_d)
#define DBGTRACK_SEND_SIZE(_pConn,_Size)
#endif
#define ARAPACTION_COMPLETE_IRP 1
#define ARAPACTION_CALL_COMPLETION 2
typedef struct _ADDRMGMT{ struct _ADDRMGMT * Next; USHORT Network; BYTE NodeBitMap[32]; // 255 nodes per net
}ADDRMGMT, *PADDRMGMT;
typedef struct _ARAPGLOB{ DWORD LowVersion; DWORD HighVersion; DWORD MnpInactiveTime; // tell dll after Mnp is inactive for this time
BOOLEAN V42bisEnabled; //
BOOLEAN SmartBuffEnabled; //
BOOLEAN NetworkAccess; // if FALSE, no routing (only this machine)
BOOLEAN DynamicMode; // we want the stack to get node address
NETWORKRANGE NetRange; PADDRMGMT pAddrMgmt; // addr allocation to clients (in static mode)
USHORT OurNetwkNum; // Network number of our default port
BYTE MaxLTFrames; // max LT frames outstanding (rcv window)
BOOLEAN SniffMode; // if TRUE, all pkts will be given to ARAP to "sniff"
BOOLEAN RouteAdded; // if in static mode, have we added a route?
} ARAPGLOB, *PARAPGLOB;
typedef struct _ARAPSTATS{ DWORD SendPreCompMax; // largest packet we have sent (before comp)
DWORD SendPostCompMax; // largest packet we have sent (after comp)
DWORD SendPreCompMin; // smallest packet we have sent (before comp)
DWORD SendPostCompMin; // smallest packet we have sent (after comp)
DWORD RecvPostDecompMax; // largest packet we have received (after decomp)
DWORD RecvPostDecomMin; // smallest packet we have received (after decomp)
} ARAPSTATS, *PARAPSTATS;
typedef VOID (*PARAP_SEND_COMPLETION)( struct _MNPSENDBUF * pMnpSendBuf, DWORD Status);
typedef struct _MNPSTATE{ // sequence numbers when we are receiving
BYTE NextToReceive; // next frame we expect to receive
BYTE LastSeqRcvd; // seq num of last pkt we successfully rcvd
BYTE LastAckSent; // seq num for which we sent the last ack
BYTE UnAckedRecvs; // how many packets we've recvd but not acked yet
BYTE RecvCredit; // how many more we can receive
BYTE HoleInSeq; // TRUE when we get a hole in receive sequence
BYTE ReceivingDup; // TRUE the moment we start receiving dup(s)
BYTE FirstDupSeq; // seq num where we started getting dup's
BYTE DupSeqBitMap; // bitmap of which seq nums we've got dups for
// BUGBUG: if we ever want windowsize of more than 8,
// we must make this a DWORD or something!
// sequence numbers when we are sending
BYTE LastAckRcvd; // last frame we have received ack for
BYTE NextToSend; // next frame we will send
BYTE SendCredit; // how many more we can send
BYTE UnAckedSends; // basically, number of sends on retransmitQ
BYTE MustRetransmit; // TRUE when we want retransmission to occur
BYTE RetransmitMode; // TRUE if we are in retransmit mode
// when we are processing the receives
BYTE NextToProcess; // next sequence we will process
BYTE MustAck; // if TRUE, send ack
// static info that we negotiated at connection time
BYTE WindowSize; // max pkts we can buffer (parm k)
BYTE UnAckedLimit; // num of unacked pkts after which we must ack
USHORT MaxPktSize; // N401 parm: this can be max 256
BYTE SynByte; BYTE DleByte; BYTE StxByte; BYTE EtxByte; BYTE LTByte;
} MNPSTATE, *PMNPSTATE;
typedef struct _ARAPDBGHISTORY{ USHORT TimeStamp; // when did this happen (relative to prev event)
USHORT Location; // where did this happen
BYTE Info[1]; // info specific to what/where happened
} ARAPDBGHISTORY, *PARAPDBGHISTORY;
#define DBG_HISTORY_BUF_SIZE 4000
typedef struct _DBGMNPHIST{ DWORD TimeStamp; DWORD FrameInfo;} DBGMNPHIST, *PDBGMNPHIST;
#define DBG_MNP_HISTORY_SIZE 80
typedef struct _ARAPCONN{ LIST_ENTRY Linkage;#if DBG
DWORD Signature;#endif
DWORD State; // connected, connecting etc
DWORD RefCount; // memory freed when this goes to 0
MNPSTATE MnpState; // MNP state info
DWORD Flags; // general flag kind of info
ATALK_NODEADDR NetAddr; // network address of the Arap client
PVOID pDllContext; // Araps context
PIRP pIoctlIrp; // irp sent down by the ARAP dll
PIRP pRecvIoctlIrp; // receive irp from ARAP dll
LIST_ENTRY MiscPktsQ; // pkts other than LT queued here
LIST_ENTRY ReceiveQ; // data indicated but not yet processed
LIST_ENTRY ArapDataQ; // data that's waiting for an irp from Arap
LIST_ENTRY HighPriSendQ; // high priority sends
LIST_ENTRY MedPriSendQ; // medium priority sends
LIST_ENTRY LowPriSendQ; // low priority sends
LIST_ENTRY SendAckedQ; // got ack, need to complete this send
LIST_ENTRY RetransmitQ; // data sent out, but not acked yet
DWORD SendsPending; // unacked/unsent sends (bytes) pending
DWORD RecvsPending; // rcvs (bytes) yet to be delivered
TIMERLIST RetryTimer; // the 401 timer (retransmit timer)
LONG LATimer; // the 402 timer
LONG T402Duration; // timer value for the 402 timer
LONG InactivityTimer; // the 403 timer
LONG T403Duration; // timer value for the 403 timer
LONG FlowControlTimer; // the 404 timer
LONG T404Duration; // timer value for the 404 timer
BYTE NdiswanHeader[14]; // 14 byte ethernet-like header
BYTE BlockId; // basically what size sends to use
BYTE UnUsed; ULONG LinkSpeed; // link speed in 100 bps units
STAT_INFO StatInfo; // statistics for this connection
LONG SendRetryTime; // send timer to fire after how much time
LONG SendRetryBaseTime; // send timer interval at init
ATALK_SPIN_LOCK SpinLock; KEVENT NodeAcquireEvent; // use while acquiring node (dynamic mode)
LONG LastNpbBrrq; // time we sent out a NBP_BRRQ pkt last
v42bis_connection_t *pV42bis;#if DBG
LARGE_INTEGER LastTimeStamp; // when did we last record history
DWORD DbgMnpIndex; DBGMNPHIST DbgMnpHist[DBG_MNP_HISTORY_SIZE]; PBYTE pDbgTraceBuffer; // where the sniff buffer starts
PBYTE pDbgCurrPtr; // currently pointing here in sniff buf
DWORD SniffedBytes; // how much does sniff buffer contain
#endif
} ARAPCONN, *PARAPCONN;
typedef struct _ARAPSNIFF{ DWORD Signature; DWORD TimeStamp; USHORT Length; BYTE StartSeq; BYTE EndSeq; DWORD UncompBytesSoFar;} ARAPSNIFF, *PARAPSNIFF;
typedef struct _ARAPQITEM{ WORK_QUEUE_ITEM WorkQItem; DWORD Action; PVOID Context1; PVOID Context2;} ARAPQITEM, *PARAPQITEM;
#if DBG
#define DBG_ARAP_CHECK_PAGED_CODE() \
{ \ if (AtalkPgLkSection[ARAP_SECTION].ls_LockCount <= 0) \ { \ DbgPrint("Arap code section not locked, count=%d\n", \ AtalkPgLkSection[ARAP_SECTION].ls_LockCount); \ ASSERT(0); \ } \}#define DBG_PPP_CHECK_PAGED_CODE() \
{ \ if (AtalkPgLkSection[PPP_SECTION].ls_LockCount <= 0) \ { \ DbgPrint("PPP code section not locked, count=%d\n", \ AtalkPgLkSection[PPP_SECTION].ls_LockCount); \ ASSERT(0); \ } \}#else
#define DBG_ARAP_CHECK_PAGED_CODE()
#define DBG_PPP_CHECK_PAGED_CODE()
#endif
#define ARAP_ID_BYTE1 0xAA
#define ARAP_ID_BYTE2 0xBB
#define PPP_ID_BYTE1 0xCC
#define PPP_ID_BYTE2 0xDD
typedef struct _ATCPCONN{ LIST_ENTRY Linkage;#if DBG
DWORD Signature;#endif
DWORD Flags; // general flag kind of info
DWORD RefCount; // memory freed when this goes to 0
ATALK_NODEADDR NetAddr; // network address of the Arap client
PVOID pDllContext; // Araps context
BYTE NdiswanHeader[14]; // 14 byte ethernet-like header
ATALK_SPIN_LOCK SpinLock; KEVENT NodeAcquireEvent; // use while acquiring node (dynamic mode)
} ATCPCONN, *PATCPCONN;
#define ATCP_NODE_IN_USE 0x1
#define ATCP_FINDING_NODE 0x2
#define ATCP_SUPPRESS_RTMP 0x4
#define ATCP_SUPPRESS_ALLBCAST 0x8
#define ATCP_DLL_SETUP_DONE 0x10
#define ATCP_LINE_UP_DONE 0x20
#define ATCP_CONNECTION_UP 0x40
#define ATCP_CONNECTION_CLOSING 0x80
// globals
extern struct _PORT_DESCRIPTOR *RasPortDesc;
// spinlock to guard the all the Arap global things
extern ATALK_SPIN_LOCK ArapSpinLock;
// global configuration info
extern ARAPGLOB ArapGlobs;
extern PIRP ArapSelectIrp;extern DWORD ArapConnections;extern DWORD ArapStackState;
extern DWORD PPPConnections;
#if DBG
extern PIRP ArapSniffIrp;extern ARAPSTATS ArapStatistics;extern DWORD ArapDumpLevel;extern DWORD ArapDumpLen;extern DWORD ArapDbgMnpSendSizes[30];extern DWORD ArapDbgMnpRecvSizes[30];extern DWORD ArapDbgArapSendSizes[15];extern DWORD ArapDbgArapRecvSizes[15];extern LARGE_INTEGER ArapDbgLastTraceTime;extern UCHAR ArapDbgLRPacket[30];#endif
|
