You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1393 lines
38 KiB
1393 lines
38 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
arapatk.c
|
|
|
|
Abstract:
|
|
|
|
This module implements routines that directly interface with Atalk stack
|
|
|
|
Author:
|
|
|
|
Shirish Koti
|
|
|
|
Revision History:
|
|
15 Nov 1996 Initial Version
|
|
|
|
--*/
|
|
|
|
#define ARAP_LOCALS
|
|
#include <atalk.h>
|
|
#pragma hdrstop
|
|
|
|
#define FILENUM ARAPATK
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE_ARAP, ArapRoutePacketFromWan)
|
|
#pragma alloc_text(PAGE_ARAP, ArapRoutePacketToWan)
|
|
#pragma alloc_text(PAGE_ARAP, ArapOkToForward)
|
|
#pragma alloc_text(PAGE_ARAP, ArapAddArapRoute)
|
|
#pragma alloc_text(PAGE_ARAP, ArapDeleteArapRoute)
|
|
#pragma alloc_text(PAGE_ARAP, ArapGetDynamicAddr)
|
|
#pragma alloc_text(PAGE_ARAP, ArapGetStaticAddr)
|
|
#pragma alloc_text(PAGE_ARAP, ArapValidNetrange)
|
|
#pragma alloc_text(PAGE_ARAP, ArapZipGetZoneStat)
|
|
#pragma alloc_text(PAGE_ARAP, ArapZipGetZoneStatCompletion)
|
|
#endif
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapRoutePacketFromWan
|
|
// This routine picks up a packet from the phone line and forwards
|
|
// it on to the lan. It does some "fixing up" of the packet so that
|
|
// to the stack, it looks like any other packet from the lan
|
|
//
|
|
// Parameters: pArapConn - connection element for whom data has come in
|
|
// pArapBuf - buffer containing the packet
|
|
//
|
|
// Return: none
|
|
//
|
|
//***$
|
|
|
|
VOID
|
|
ArapRoutePacketFromWan(
|
|
IN PARAPCONN pArapConn,
|
|
IN PARAPBUF pArapBuf
|
|
)
|
|
{
|
|
|
|
PBYTE packet;
|
|
USHORT DataSize;
|
|
USHORT checksum;
|
|
USHORT RevNet;
|
|
BYTE RevNode;
|
|
PBYTE pZoneNamePtr;
|
|
USHORT BytesToZoneName=0;
|
|
LONG CurrentTime;
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
DBGDUMPBYTES("ArapRoutePacketFromWan:",&pArapBuf->Buffer[0], pArapBuf->DataSize,4);
|
|
|
|
packet = pArapBuf->CurrentBuffer;
|
|
DataSize = pArapBuf->DataSize;
|
|
|
|
ASSERT(packet[2] == 0x50);
|
|
|
|
ASSERT(packet[3] == 0 && packet[4] == 0 && packet[5] == 2);
|
|
|
|
// skip 3 bytes (past the SrpLen (2) and Dgroup (1) bytes)
|
|
packet += ARAP_DATA_OFFSET;
|
|
DataSize -= ARAP_DATA_OFFSET;
|
|
|
|
//
|
|
// see if we need to calculate the checksum. The LAP header is 0's if
|
|
// checksum is not included in the pkt, 1's otherwise.
|
|
//
|
|
checksum = 0;
|
|
if (*packet == 1 && *(packet+1) == 1)
|
|
{
|
|
checksum = 1;
|
|
}
|
|
|
|
// skip the LAP header
|
|
packet += ARAP_LAP_HDRSIZE;
|
|
DataSize -= ARAP_LAP_HDRSIZE;
|
|
|
|
|
|
#if DBG
|
|
if (packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_RTMPRESPONSEORDATA)
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("ArapRoutePacketFromWan: got RTMPRESPONSEORDATA pkt!!\n"));
|
|
ASSERT(0);
|
|
}
|
|
|
|
if (packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_RTMPREQUEST)
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("ArapRoutePacketFromWan: got RTMPREQUEST pkt!!\n"));
|
|
ASSERT(0);
|
|
}
|
|
|
|
if (packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_ZIP)
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("ArapRoutePacketFromWan: got ZIP pkt!!\n"));
|
|
ASSERT(0);
|
|
}
|
|
#endif
|
|
|
|
|
|
// fill in the length and checksum in the ddp header ("fix-up" ddp hdr)
|
|
PUTSHORT2SHORT(&packet[LDDP_LEN_OFFSET], DataSize);
|
|
PUTSHORT2SHORT(&packet[LDDP_CHECKSUM_OFFSET], 0);
|
|
|
|
//
|
|
// we need to "fix up" NBP requests. If this is a BrRq request (Function=1,
|
|
// and TupleCount=1), we need to patch up the datagram
|
|
//
|
|
if (packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_NBP &&
|
|
packet[LDDP_DGRAM_OFFSET] == ARAP_NBP_BRRQ)
|
|
{
|
|
|
|
//
|
|
// let's treat nbp lookups as lower priority items!
|
|
// if we have a lot of stuff sitting on the recv or the send the queue
|
|
// then drop this nbp lookup broadcast (because otherwise it will only
|
|
// generate more packets (and chooser won't deal with them anyway!)
|
|
//
|
|
if ((packet[LDDP_DEST_NODE_OFFSET] == ATALK_BROADCAST_NODE) &&
|
|
((pArapConn->SendsPending > ARAP_SENDQ_LOWER_LIMIT) ||
|
|
(pArapConn->RecvsPending > ARAP_SENDQ_LOWER_LIMIT)) )
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("ArapRoutePacketFromWan: dropping NBP bcast to lan (%d %d bytes)\n",
|
|
pArapConn->SendsPending,pArapConn->RecvsPending));
|
|
return;
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
|
need to save old packet. Drop this packet only if it compares with the old one
|
|
If something changed (say zone name!), send the packet over even if it's less than
|
|
5 sec. Also, delta should be probably 35 or something (for 3 pkts)
|
|
|
|
CurrentTime = AtalkGetCurrentTick();
|
|
|
|
//
|
|
// Chooser keeps sending the Brrq request out. Cut it out! If we have
|
|
// sent a request out (on Mac's behalf) less than 5 seconds ago, drop this!
|
|
//
|
|
if (CurrentTime - pArapConn->LastNpbBrrq < 50)
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("ArapRoutePacketFromWan: dropping NBP_BRRQ (last %ld now %ld)\n",
|
|
pArapConn->LastNpbBrrq,CurrentTime));
|
|
return;
|
|
}
|
|
|
|
pArapConn->LastNpbBrrq = CurrentTime;
|
|
#endif
|
|
|
|
|
|
#if 0
|
|
// get to where the zone name is
|
|
|
|
BytesToZoneName = ARAP_NBP_OBJLEN_OFFSET;
|
|
|
|
// skip the object (along with the object len byte)
|
|
BytesToZoneName += packet[ARAP_NBP_OBJLEN_OFFSET] + 1;
|
|
|
|
// skip the type (along with the object len byte)
|
|
BytesToZoneName += packet[BytesToZoneName] + 1;
|
|
|
|
// this is where the zonelen field starts
|
|
pZoneNamePtr = packet + BytesToZoneName;
|
|
|
|
if (*pZoneNamePtr == 0 || *(pZoneNamePtr+1) == '*')
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("ArapRoutePacketFromWan: * zone name (%lx,%lx)\n",packet,pZoneNamePtr));
|
|
}
|
|
|
|
#endif
|
|
|
|
if (ArapGlobs.NetworkAccess)
|
|
{
|
|
//
|
|
// if router is running, fix the packet so that the router thinks this
|
|
// is a pkt from any other net client on the lan
|
|
//
|
|
if (AtalkDefaultPort->pd_Flags & PD_ROUTER_RUNNING)
|
|
{
|
|
RevNet = AtalkDefaultPort->pd_RouterNode->an_NodeAddr.atn_Network;
|
|
RevNode = AtalkDefaultPort->pd_RouterNode->an_NodeAddr.atn_Node;
|
|
}
|
|
|
|
//
|
|
// router is not running. Do we know who the router is?
|
|
//
|
|
else if (AtalkDefaultPort->pd_Flags & PD_SEEN_ROUTER_RECENTLY)
|
|
{
|
|
RevNet = AtalkDefaultPort->pd_ARouter.atn_Network;
|
|
RevNode = AtalkDefaultPort->pd_ARouter.atn_Node;
|
|
}
|
|
|
|
//
|
|
// nope, send it to cable-wide bcast
|
|
//
|
|
else
|
|
{
|
|
// "fix-up" the nbp request
|
|
packet[LDDP_DGRAM_OFFSET] = ARAP_NBP_LKRQ;
|
|
|
|
RevNet = CABLEWIDE_BROADCAST_NETWORK;
|
|
RevNode = ATALK_BROADCAST_NODE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// hmmm: client is not allowed to access network resources: just pretend
|
|
// it's local broadcast, and pkt-forwarding logic will take care of it
|
|
//
|
|
else
|
|
{
|
|
// "fix-up" the nbp request
|
|
packet[LDDP_DGRAM_OFFSET] = ARAP_NBP_LKRQ;
|
|
|
|
RevNet = CABLEWIDE_BROADCAST_NETWORK;
|
|
RevNode = ATALK_BROADCAST_NODE;
|
|
}
|
|
|
|
PUTSHORT2SHORT(&packet[LDDP_DEST_NETWORK_OFFSET], RevNet);
|
|
packet[LDDP_DEST_NODE_OFFSET] = RevNode;
|
|
}
|
|
|
|
if (checksum)
|
|
{
|
|
checksum = AtalkDdpCheckSumBuffer(packet, DataSize, 0);
|
|
PUTSHORT2SHORT(&packet[LDDP_CHECKSUM_OFFSET], checksum);
|
|
}
|
|
|
|
AtalkDdpPacketIn(AtalkDefaultPort, NULL, packet, DataSize, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapRoutePacketToWan
|
|
// This routine picks up a packet from the lan, checks to see if
|
|
// it must be forwarded to any of the ARAP clients and does the
|
|
// good deed.
|
|
//
|
|
// Parameters: pDestAddr - who is this packet addressed to? (potentially bcast)
|
|
// pSrcAddr - who sent this packet
|
|
// Protocol - what packet is it? (ATP, NBP, etc.)
|
|
// packet - buffer containing the packet
|
|
// PktLen - how big is the packet
|
|
// broadcast - is this a broadcast packet?
|
|
// pDelivered - set on return: did we forward it to any dial-in
|
|
// client (set to TRUE only for directed dgrams)
|
|
//
|
|
// Return: none
|
|
//
|
|
//***$
|
|
|
|
VOID
|
|
ArapRoutePacketToWan(
|
|
IN ATALK_ADDR *pDestAddr,
|
|
IN ATALK_ADDR *pSrcAddr,
|
|
IN BYTE Protocol,
|
|
IN PBYTE packet,
|
|
IN USHORT PktLen,
|
|
IN BOOLEAN broadcast,
|
|
OUT PBOOLEAN pDelivered
|
|
)
|
|
{
|
|
|
|
KIRQL OldIrql;
|
|
PARAPCONN pArapConn;
|
|
PARAPCONN pPrevArapConn;
|
|
PLIST_ENTRY pConnList;
|
|
BUFFER_DESC InBuffDesc;
|
|
BUFFER_DESC BuffDesc;
|
|
BYTE ArapHdr[ARAP_LAP_HDRSIZE + ARAP_HDRSIZE];
|
|
PBYTE pArapHdrPtr;
|
|
ATALK_NODEADDR DestNode;
|
|
DWORD StatusCode;
|
|
DWORD dwFlags;
|
|
USHORT SrpLen;
|
|
DWORD Priority;
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
// assume for now
|
|
*pDelivered = FALSE;
|
|
|
|
// no network access for dial-in guys? don't send this out to them
|
|
if (!ArapGlobs.NetworkAccess)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// if this is an RTMP or ZIP bcast, drop it since ARAP clients don't
|
|
// care for these packets
|
|
//
|
|
|
|
if (broadcast)
|
|
{
|
|
if ((packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_RTMPREQUEST) ||
|
|
(packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_RTMPRESPONSEORDATA) )
|
|
{
|
|
DBGDUMPBYTES("ArapFrmLan: bcast pkt:",packet, LDDP_HDR_LEN+4,6);
|
|
return;
|
|
}
|
|
|
|
if (packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_ZIP)
|
|
{
|
|
DBGDUMPBYTES("ArapFrmLan: bcast pkt:",packet, LDDP_HDR_LEN+4,6);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// this is a unicast: see if this addr belongs to an ARAP client
|
|
//
|
|
else
|
|
{
|
|
DestNode.atn_Network = pDestAddr->ata_Network;
|
|
DestNode.atn_Node = pDestAddr->ata_Node;
|
|
|
|
pArapConn = FindAndRefArapConnByAddr(DestNode, &dwFlags);
|
|
|
|
// no ARAP client for this dest. address? Done here
|
|
if (pArapConn == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!(dwFlags & ARAP_CONNECTION_UP))
|
|
{
|
|
DerefArapConn(pArapConn);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// setup a buffer descriptor for the incoming packet
|
|
InBuffDesc.bd_Next = NULL;
|
|
InBuffDesc.bd_Length = PktLen;
|
|
InBuffDesc.bd_CharBuffer = packet;
|
|
InBuffDesc.bd_Flags = BD_CHAR_BUFFER;
|
|
|
|
//
|
|
// setup the header
|
|
//
|
|
pArapHdrPtr = &ArapHdr[0];
|
|
|
|
// don't count the 2 length bytes
|
|
SrpLen = PktLen + ARAP_LAP_HDRSIZE + ARAP_HDRSIZE - sizeof(USHORT);
|
|
|
|
PUTSHORT2SHORT(pArapHdrPtr, SrpLen);
|
|
pArapHdrPtr += sizeof(USHORT);
|
|
|
|
// the Dgroup byte
|
|
*pArapHdrPtr++ = (ARAP_SFLAG_PKT_DATA | ARAP_SFLAG_LAST_GROUP);
|
|
|
|
// the LAP hdr
|
|
*pArapHdrPtr++ = 0;
|
|
*pArapHdrPtr++ = 0;
|
|
*pArapHdrPtr++ = 2;
|
|
|
|
|
|
// setup a buffer descriptor for the header we are going to put
|
|
BuffDesc.bd_Next = &InBuffDesc;
|
|
BuffDesc.bd_Length = ARAP_LAP_HDRSIZE + ARAP_HDRSIZE;
|
|
BuffDesc.bd_CharBuffer = &ArapHdr[0];
|
|
BuffDesc.bd_Flags = BD_CHAR_BUFFER;
|
|
|
|
|
|
//
|
|
// if this datagram is not a broadcast, see if we can find a dial-in client
|
|
// with this destination address
|
|
//
|
|
if (!broadcast)
|
|
{
|
|
//
|
|
// ok, we found a connection: whether or not we actually give data to
|
|
// him, let the caller know that we found who this data was meant for
|
|
//
|
|
*pDelivered = TRUE;
|
|
|
|
//
|
|
// some packets can't be sent to the dial-in client: how about this one?
|
|
//
|
|
if (!ArapOkToForward(pArapConn,packet,PktLen, &Priority))
|
|
{
|
|
DerefArapConn(pArapConn);
|
|
return;
|
|
}
|
|
|
|
DBGDUMPBYTES("ArapRoutePacketToWan Directed Dgram:",packet,PktLen,4);
|
|
|
|
//
|
|
// ok, this packet is for the dial-in guy: send it
|
|
//
|
|
StatusCode = ArapSendPrepare(pArapConn, &BuffDesc, Priority);
|
|
|
|
if (StatusCode == ARAPERR_NO_ERROR)
|
|
{
|
|
// Send the packet(s)
|
|
ArapNdisSend(pArapConn, &pArapConn->HighPriSendQ);
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("ArapRoutePacketToWan: (%lx) Prep failed %d\n",pArapConn,StatusCode));
|
|
}
|
|
|
|
// remove that refcount put in by FindAndRefArapConnByAddr
|
|
DerefArapConn(pArapConn);
|
|
|
|
return;
|
|
}
|
|
|
|
DBGDUMPBYTES("ArapRoutePacketToWan Broadcast Dgram:",packet,PktLen,4);
|
|
|
|
|
|
//
|
|
// it's a broadcast packet: must send it to all the dial-in guys
|
|
//
|
|
|
|
pArapConn = NULL;
|
|
pPrevArapConn = NULL;
|
|
|
|
while (1)
|
|
{
|
|
ACQUIRE_SPIN_LOCK(&RasPortDesc->pd_Lock, &OldIrql);
|
|
|
|
//
|
|
// first, let's find the right connection to work on
|
|
//
|
|
while (1)
|
|
{
|
|
// if we're in the middle of the list, get to the next guy
|
|
if (pArapConn != NULL)
|
|
{
|
|
pConnList = pArapConn->Linkage.Flink;
|
|
}
|
|
// we're just starting: get the guy at the head of the list
|
|
else
|
|
{
|
|
pConnList = RasPortDesc->pd_ArapConnHead.Flink;
|
|
}
|
|
|
|
// finished all?
|
|
if (pConnList == &RasPortDesc->pd_ArapConnHead)
|
|
{
|
|
RELEASE_SPIN_LOCK(&RasPortDesc->pd_Lock, OldIrql);
|
|
|
|
if (pPrevArapConn)
|
|
{
|
|
DerefArapConn(pPrevArapConn);
|
|
}
|
|
return;
|
|
}
|
|
|
|
pArapConn = CONTAINING_RECORD(pConnList, ARAPCONN, Linkage);
|
|
|
|
// make sure this connection needs rcv processing
|
|
ACQUIRE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
|
|
|
|
//
|
|
// if this connection is being disconnected, skip it
|
|
//
|
|
if (pArapConn->State >= MNP_LDISCONNECTING)
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_WARN,
|
|
("ArapRoutePacketToWan: (%lx) invalid state %d, skipping\n",
|
|
pArapConn,pArapConn->State));
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
|
|
|
|
// go try the next connection
|
|
continue;
|
|
}
|
|
|
|
// let's make sure this connection stays around till we finish
|
|
pArapConn->RefCount++;
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pArapConn->SpinLock);
|
|
|
|
break;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&RasPortDesc->pd_Lock, OldIrql);
|
|
|
|
//
|
|
// remove the refcount on the previous connection we put in earlier
|
|
//
|
|
if (pPrevArapConn)
|
|
{
|
|
DerefArapConn(pPrevArapConn);
|
|
}
|
|
|
|
ASSERT(pPrevArapConn != pArapConn);
|
|
|
|
pPrevArapConn = pArapConn;
|
|
|
|
|
|
//
|
|
// if the connection isn't up yet, don't forward this
|
|
// (note that we don't hold spinlock here, this being a hot path:
|
|
// the worst that can happen is we'll drop a broadcast: big deal!)
|
|
//
|
|
if (!(pArapConn->Flags & ARAP_CONNECTION_UP))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
//
|
|
// is it ok for us send this packet to this client ?
|
|
//
|
|
if (!ArapOkToForward(pArapConn,packet,PktLen, &Priority))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
StatusCode = ArapSendPrepare(pArapConn, &BuffDesc, Priority);
|
|
|
|
if (StatusCode == ARAPERR_NO_ERROR)
|
|
{
|
|
// Send the packet(s)
|
|
ArapNdisSend(pArapConn, &pArapConn->HighPriSendQ);
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT(DBG_COMP_ROUTER, DBG_LEVEL_ERR,
|
|
("Arap...FromLan: (%lx) Arap..Prep failed %d\n",pArapConn,StatusCode));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapOkToForward
|
|
// This routine checks to see if we can (or must) forward this
|
|
// packet to the dial-in client. Certain packets (e.g. a bcast pkt
|
|
// that originated from this client) shouldn't be sent back to the
|
|
// client: this routine makes those checks.
|
|
//
|
|
// Parameters: pArapConn - the connection in question
|
|
// packet - buffer containing the packet
|
|
// packetLen - how big is the packet
|
|
// pPriority - set on return:
|
|
// 1 - all non-NBP data directed to this client
|
|
// 2 - all NBP data directed to this client
|
|
// 3 - all broadcast data
|
|
//
|
|
// Return: TRUE if it's ok to (or if we must!) forward the packet,
|
|
// FALSE otherwise
|
|
//
|
|
//***$
|
|
|
|
BOOLEAN
|
|
ArapOkToForward(
|
|
IN PARAPCONN pArapConn,
|
|
IN PBYTE packet,
|
|
IN USHORT packetLen,
|
|
OUT DWORD *pPriority
|
|
)
|
|
{
|
|
|
|
ATALK_NODEADDR NetAddr;
|
|
BOOLEAN fBcastPkt=FALSE;
|
|
BOOLEAN fNbpPkt=FALSE;
|
|
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
GETSHORT2SHORT(&NetAddr.atn_Network, &packet[LDDP_SRC_NETWORK_OFFSET]);
|
|
NetAddr.atn_Node = packet[LDDP_SRC_NODE_OFFSET];
|
|
|
|
//
|
|
// packet has client's own addr as DDP src addr? if so, drop it
|
|
//
|
|
if (NODEADDR_EQUAL(&NetAddr, &pArapConn->NetAddr))
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
|
|
("ArapOkToForward: dropping pkt: DDP src=client's addr (%lx)\n",pArapConn));
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
if (packet[LDDP_PROTO_TYPE_OFFSET] == DDPPROTO_NBP)
|
|
{
|
|
fNbpPkt = TRUE;
|
|
}
|
|
|
|
if (packet[LDDP_DEST_NODE_OFFSET] == ATALK_BROADCAST_NODE)
|
|
{
|
|
fBcastPkt = TRUE;
|
|
|
|
//
|
|
// is this an nbp query packet?
|
|
//
|
|
if (fNbpPkt && (packet[LDDP_DGRAM_OFFSET] == 0x21))
|
|
{
|
|
GETSHORT2SHORT(&NetAddr.atn_Network, &packet[15]);
|
|
NetAddr.atn_Node = packet[17];
|
|
|
|
// originated from the client? if so, we shouldn't return this!
|
|
if (NODEADDR_EQUAL(&NetAddr, &pArapConn->NetAddr))
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
|
|
("ArapOkToForward: dropping pkt originating from client!\n"));
|
|
|
|
return(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// if this is a broadcast packet, then we drop it under certain conditions:
|
|
// (no need for spinlock here: if we make a wrong decision, no big deal)
|
|
//
|
|
if (fBcastPkt)
|
|
{
|
|
|
|
// are in currently in the retransmit mode? if so, drop this bcast pkt
|
|
if (pArapConn->MnpState.RetransmitMode)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
//
|
|
// queue getting full? drop this broadcast packet to make room for more
|
|
// important pkts
|
|
//
|
|
if (pArapConn->SendsPending >= ARAP_SENDQ_LOWER_LIMIT)
|
|
{
|
|
// make sure it's not gone negative..
|
|
ASSERT(pArapConn->SendsPending < 0x100000);
|
|
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapOkToForward: (%lx) send getting full (%ld), dropping nbp pkt\n",
|
|
pArapConn,pArapConn->SendsPending));
|
|
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// now that we are forwarding the packet to the client, set the priority
|
|
// right. All broadcast packets are lowest priority, no big deal if they are
|
|
// delivered late (or never). Nbp packets are usually for chooser: put them
|
|
// after the directed data packets
|
|
//
|
|
|
|
if (fBcastPkt)
|
|
{
|
|
*pPriority = ARAP_SEND_PRIORITY_LOW;
|
|
}
|
|
else if (fNbpPkt)
|
|
{
|
|
*pPriority = ARAP_SEND_PRIORITY_MED;
|
|
}
|
|
else
|
|
{
|
|
*pPriority = ARAP_SEND_PRIORITY_HIGH;
|
|
}
|
|
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapGetDynamicAddr
|
|
// This routine gets a network address for a dial-in client.
|
|
// It does the same AARP logic as if it were acquiring a
|
|
// node-address for the host itself.
|
|
// This routine is called only if we are in the dynamic mode.
|
|
//
|
|
// Parameters: pArapConn - the connection for which we need a network addr
|
|
//
|
|
// Return: ARAPERR_NO_ERROR if all went well.
|
|
//
|
|
//***$
|
|
|
|
DWORD
|
|
ArapGetDynamicAddr(
|
|
IN PARAPCONN pArapConn
|
|
)
|
|
{
|
|
ATALK_NODEADDR NetAddr;
|
|
ATALK_NETWORKRANGE NetRange;
|
|
BOOLEAN fFound=FALSE;
|
|
KIRQL OldIrql;
|
|
DWORD StatusCode=ARAPERR_STACK_NOT_UP;
|
|
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
ASSERT(AtalkDefaultPort != NULL);
|
|
|
|
//
|
|
// go find a node address on the default port (we'll never get this far if
|
|
// default port isn't up yet)
|
|
//
|
|
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
|
|
|
|
ASSERT(!(pArapConn->Flags & ARAP_FINDING_NODE));
|
|
|
|
pArapConn->Flags |= ARAP_FINDING_NODE;
|
|
|
|
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
|
|
|
|
AtalkLockInitIfNecessary();
|
|
|
|
// if we are stuck in the startup range, use that range for dial-in guys, too
|
|
if (WITHIN_NETWORK_RANGE(AtalkDefaultPort->pd_NetworkRange.anr_LastNetwork,
|
|
&AtalkStartupNetworkRange))
|
|
{
|
|
NetRange = AtalkStartupNetworkRange;
|
|
}
|
|
else
|
|
{
|
|
NetRange = AtalkDefaultPort->pd_NetworkRange;
|
|
}
|
|
|
|
fFound = AtalkInitAarpForNodeInRange(AtalkDefaultPort,
|
|
(PVOID)pArapConn,
|
|
FALSE,
|
|
NetRange,
|
|
&NetAddr);
|
|
|
|
AtalkUnlockInitIfNecessary();
|
|
|
|
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
|
|
|
|
pArapConn->Flags &= ~ARAP_FINDING_NODE;
|
|
|
|
if (fFound)
|
|
{
|
|
// store that adddr!
|
|
pArapConn->NetAddr.atn_Network = NetAddr.atn_Network;
|
|
pArapConn->NetAddr.atn_Node = NetAddr.atn_Node;
|
|
|
|
pArapConn->Flags |= ARAP_NODE_IN_USE;
|
|
StatusCode = ARAPERR_NO_ERROR;
|
|
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_INFO,
|
|
("ArapGetDynamicAddr: found addr for ARAP client = %lx %lx\n",
|
|
NetAddr.atn_Network,NetAddr.atn_Node));
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapGetDynamicAddr: ARAP: no more network addr left?\n"));
|
|
|
|
pArapConn->Flags &= ~ARAP_NODE_IN_USE;
|
|
pArapConn->NetAddr.atn_Network = 0;
|
|
pArapConn->NetAddr.atn_Node = 0;
|
|
StatusCode = ARAPERR_NO_NETWORK_ADDR;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
|
|
|
|
return(StatusCode);
|
|
}
|
|
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapZipGetZoneStat
|
|
// This routine is called to find out the names (or number) of all
|
|
// the zones on the network.
|
|
//
|
|
// Parameters: pZoneStat - on return, we fill this structure in with the
|
|
// requested info (number and/or names of all the zones)
|
|
// Request - caller wants just the number of zones or names, too
|
|
//
|
|
// Return: Nothing
|
|
//
|
|
//***$
|
|
|
|
VOID
|
|
ArapZipGetZoneStat(
|
|
IN OUT PZONESTAT pZoneStat
|
|
)
|
|
{
|
|
int i;
|
|
PZONE pZone;
|
|
DWORD NumZones;
|
|
DWORD StatusCode;
|
|
KIRQL OldIrql;
|
|
PBYTE pBufPtr;
|
|
PBYTE pAllocedBuf=NULL;
|
|
DWORD BufferSize;
|
|
DWORD BytesCopied;
|
|
DWORD BytesNeeded;
|
|
ATALK_ERROR Status;
|
|
PZIPCOMPLETIONINFO pZci;
|
|
PMDL pMdl=NULL;
|
|
ACTREQ ActReq;
|
|
ZIP_GETZONELIST_PARAMS ZipParms;
|
|
KEVENT ZoneComplEvent;
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
BufferSize = pZoneStat->BufLen;
|
|
|
|
pBufPtr = &pZoneStat->ZoneNames[0];
|
|
|
|
StatusCode = ARAPERR_NO_ERROR;
|
|
BytesCopied = 0;
|
|
NumZones = 0;
|
|
|
|
if (AtalkDefaultPort->pd_Flags & PD_ROUTER_RUNNING)
|
|
{
|
|
BytesNeeded = 0;
|
|
|
|
ACQUIRE_SPIN_LOCK(&AtalkZoneLock, &OldIrql);
|
|
|
|
for (i = 0; (i < NUM_ZONES_HASH_BUCKETS); i++)
|
|
{
|
|
for (pZone = AtalkZonesTable[i]; pZone != NULL; pZone = pZone->zn_Next)
|
|
{
|
|
NumZones++;
|
|
|
|
BytesNeeded += (pZone->zn_ZoneLen + 1);
|
|
|
|
// if there is room, copy it in
|
|
if (BufferSize >= BytesNeeded)
|
|
{
|
|
RtlCopyMemory(pBufPtr,
|
|
&pZone->zn_Zone[0],
|
|
pZone->zn_ZoneLen);
|
|
|
|
pBufPtr += pZone->zn_ZoneLen;
|
|
|
|
*pBufPtr++ = '\0';
|
|
|
|
BytesCopied += (pZone->zn_ZoneLen + 1);
|
|
}
|
|
else
|
|
{
|
|
StatusCode = ARAPERR_BUF_TOO_SMALL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&AtalkZoneLock, OldIrql);
|
|
}
|
|
|
|
//
|
|
// we are not a router: send the request over to the A-router
|
|
//
|
|
else
|
|
{
|
|
BytesNeeded = BufferSize;
|
|
|
|
pMdl = AtalkAllocAMdl(pBufPtr,BufferSize);
|
|
if (pMdl == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapZipGetZoneStat: couldn't allocate Mdl\n"));
|
|
|
|
StatusCode = ARAPERR_OUT_OF_RESOURCES;
|
|
goto ArapZipGetZoneStat_Exit;
|
|
}
|
|
|
|
|
|
KeInitializeEvent(&ZoneComplEvent, NotificationEvent, FALSE);
|
|
|
|
pZci = (PZIPCOMPLETIONINFO)AtalkAllocMemory(sizeof(ZIPCOMPLETIONINFO));
|
|
if (pZci == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapZipGetZoneStat: couldn't allocate pZci\n"));
|
|
|
|
StatusCode = ARAPERR_OUT_OF_RESOURCES;
|
|
goto ArapZipGetZoneStat_Exit;
|
|
}
|
|
|
|
ZipParms.ZonesAvailable = 0;
|
|
ActReq.ar_StatusCode = ARAPERR_NO_ERROR;
|
|
|
|
#if DBG
|
|
ActReq.ar_Signature = ACTREQ_SIGNATURE;
|
|
#endif
|
|
ActReq.ar_pIrp = NULL;
|
|
ActReq.ar_pParms = &ZipParms;
|
|
ActReq.ar_pAMdl = NULL;
|
|
ActReq.ar_MdlSize = 0;
|
|
ActReq.ar_ActionCode = 0;
|
|
ActReq.ar_DevType = 0;
|
|
ActReq.ar_Completion = ArapZipGetZoneStatCompletion;
|
|
ActReq.ar_CmplEvent = &ZoneComplEvent;
|
|
ActReq.ar_pZci = (PVOID)pZci;
|
|
|
|
|
|
// Initialize completion info
|
|
#if DBG
|
|
pZci->zci_Signature = ZCI_SIGNATURE;
|
|
#endif
|
|
INITIALIZE_SPIN_LOCK(&pZci->zci_Lock);
|
|
pZci->zci_RefCount = 1;
|
|
pZci->zci_pPortDesc = AtalkDefaultPort;
|
|
pZci->zci_pDdpAddr = NULL;
|
|
pZci->zci_pAMdl = pMdl;
|
|
pZci->zci_BufLen = BufferSize;
|
|
pZci->zci_pActReq = &ActReq;
|
|
pZci->zci_Router.ata_Network = AtalkDefaultPort->pd_ARouter.atn_Network;
|
|
pZci->zci_Router.ata_Node = AtalkDefaultPort->pd_ARouter.atn_Node;
|
|
pZci->zci_Router.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
pZci->zci_ExpirationCount = ZIP_GET_ZONEINFO_RETRIES;
|
|
pZci->zci_NextZoneOff = 0;
|
|
pZci->zci_ZoneCount = 0;
|
|
pZci->zci_AtpRequestType = ZIP_GET_ZONE_LIST;
|
|
AtalkTimerInitialize(&pZci->zci_Timer,
|
|
atalkZipZoneInfoTimer,
|
|
ZIP_GET_ZONEINFO_TIMER);
|
|
|
|
pZci->zci_Handler = atalkZipGetZoneListReply;
|
|
|
|
// completion routine will unlock
|
|
AtalkLockZipIfNecessary();
|
|
|
|
Status = atalkZipSendPacket(pZci, TRUE);
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("ArapZipGetZoneStat: atalkZipSendPacket failed %ld\n", Status));
|
|
pZci->zci_FinalStatus = Status;
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
|
|
KeWaitForSingleObject(&ZoneComplEvent,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL);
|
|
|
|
NumZones = ZipParms.ZonesAvailable;
|
|
StatusCode = ActReq.ar_StatusCode;
|
|
|
|
if (StatusCode == ARAPERR_BUF_TOO_SMALL)
|
|
{
|
|
BytesNeeded = (2*BufferSize);
|
|
}
|
|
|
|
BytesCopied = BufferSize;
|
|
|
|
AtalkFreeAMdl(pMdl);
|
|
}
|
|
|
|
|
|
ArapZipGetZoneStat_Exit:
|
|
|
|
pZoneStat->NumZones = NumZones;
|
|
pZoneStat->BufLen = BytesCopied;
|
|
pZoneStat->BytesNeeded = BytesNeeded;
|
|
|
|
pZoneStat->StatusCode = StatusCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapZipGetZoneStatCompletion
|
|
// This routine is the completion routine: after we get all the
|
|
// responses for the zone query, this gets called. Simply set an
|
|
// event so the caller is unblocked
|
|
//
|
|
// Parameters: pActReq - context
|
|
//
|
|
// Return: Nothing
|
|
//
|
|
//***$
|
|
|
|
VOID
|
|
ArapZipGetZoneStatCompletion(
|
|
IN ATALK_ERROR ErrorCode,
|
|
IN PACTREQ pActReq
|
|
)
|
|
{
|
|
|
|
PKEVENT pEvent;
|
|
PZIPCOMPLETIONINFO pZci;
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
if (ErrorCode != ATALK_NO_ERROR && ErrorCode != ATALK_BUFFER_TOO_SMALL)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("ArapZipGetZoneStatCompletion: failure %lx\n", ErrorCode));
|
|
}
|
|
|
|
pZci = (PZIPCOMPLETIONINFO)(pActReq->ar_pZci);
|
|
|
|
pEvent = pActReq->ar_CmplEvent;
|
|
|
|
ASSERT((pZci->zci_FinalStatus == ATALK_NO_ERROR) ||
|
|
(pZci->zci_FinalStatus == ATALK_BUFFER_TOO_SMALL));
|
|
|
|
if (pZci->zci_FinalStatus == ATALK_NO_ERROR)
|
|
{
|
|
pActReq->ar_StatusCode = ARAPERR_NO_ERROR;
|
|
}
|
|
else if (pZci->zci_FinalStatus == ATALK_BUFFER_TOO_SMALL)
|
|
{
|
|
pActReq->ar_StatusCode = ARAPERR_BUF_TOO_SMALL;
|
|
}
|
|
else
|
|
{
|
|
pActReq->ar_StatusCode = ARAPERR_UNEXPECTED_RESPONSE;
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("ArapZipGetZoneStat: failure %lx\n", pZci->zci_FinalStatus));
|
|
}
|
|
|
|
KeSetEvent(pEvent,IO_NETWORK_INCREMENT,FALSE);
|
|
}
|
|
|
|
|
|
#if ARAP_STATIC_MODE
|
|
|
|
//***
|
|
//
|
|
// Function: ArapGetStaticAddr
|
|
// Get a network address for the remote client when we are
|
|
// configured for static addressing
|
|
// We represent every client as one bit: if the bit is on, the
|
|
// corresponding address is taken, otherwise it's free.
|
|
// So, 255 clients represented using 32 bytes. Each pAddrMgmt
|
|
// block represents 255 clients (scalability not a problem here!)
|
|
//
|
|
// Parameters: pArapConn - connection element for the remote client in question
|
|
//
|
|
// Return: status of the operation (ARAPERR_....)
|
|
//
|
|
//***$
|
|
|
|
DWORD
|
|
ArapGetStaticAddr(
|
|
IN PARAPCONN pArapConn
|
|
)
|
|
{
|
|
KIRQL OldIrql;
|
|
PADDRMGMT pAddrMgmt;
|
|
PADDRMGMT pPrevAddrMgmt;
|
|
USHORT Network;
|
|
BYTE Node;
|
|
BOOLEAN found=FALSE;
|
|
BYTE BitMask;
|
|
DWORD i;
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
ARAPTRACE(("Entered ArapGetStaticAddr (%lx)\n",pArapConn));
|
|
|
|
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql);
|
|
|
|
pAddrMgmt = ArapGlobs.pAddrMgmt;
|
|
|
|
while (1)
|
|
{
|
|
Network = pAddrMgmt->Network;
|
|
|
|
// see if there is any open slot. 255 nodes represented by 32x8 bits
|
|
for (i=0; i<32; i++)
|
|
{
|
|
if (pAddrMgmt->NodeBitMap[i] != 0xff)
|
|
{
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
// find out the first bit in this byte that is off
|
|
BitMask = 0x1;
|
|
Node = 0;
|
|
while (pAddrMgmt->NodeBitMap[i] & BitMask)
|
|
{
|
|
BitMask <<= 1;
|
|
Node += 1;
|
|
}
|
|
|
|
// we are taking this node: set that bit!
|
|
pAddrMgmt->NodeBitMap[i] |= BitMask;
|
|
|
|
// now, account for all the previous bytes that were full
|
|
Node += (BYTE)(i*8);
|
|
|
|
break;
|
|
}
|
|
|
|
// all the nodes on this network are taken! move to the next network
|
|
pPrevAddrMgmt = pAddrMgmt;
|
|
pAddrMgmt = pAddrMgmt->Next;
|
|
|
|
// looks like we need to allocate the next network structure
|
|
if (pAddrMgmt == NULL)
|
|
{
|
|
//
|
|
// we just finished looking at the high end of the permissible network
|
|
// range? well, out of luck then!
|
|
//
|
|
if (Network == ArapGlobs.NetRange.HighEnd)
|
|
{
|
|
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
|
|
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapGetStaticAddr: no more network addr left\n"));
|
|
|
|
return(ARAPERR_NO_NETWORK_ADDR);
|
|
}
|
|
|
|
if ( (pAddrMgmt = AtalkAllocZeroedMemory(sizeof(ADDRMGMT))) == NULL)
|
|
{
|
|
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
|
|
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapGetStaticAddr: alloc failed\n"));
|
|
|
|
return(ARAPERR_OUT_OF_RESOURCES);
|
|
}
|
|
|
|
Network++;
|
|
pAddrMgmt->Next = NULL;
|
|
pAddrMgmt->Network = Network;
|
|
pPrevAddrMgmt->Next = pAddrMgmt;
|
|
|
|
Node = 1;
|
|
//
|
|
// node numbers 0 and 255 are reserved, so mark them as occupied.
|
|
// Also, we just took node 1, so mark that as well
|
|
//
|
|
pAddrMgmt->NodeBitMap[0] |= (0x1 | 0x2);
|
|
pAddrMgmt->NodeBitMap[31] |= 0x80;
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
|
|
|
|
// store that adddr!
|
|
ACQUIRE_SPIN_LOCK(&pArapConn->SpinLock, &OldIrql);
|
|
pArapConn->NetAddr.atn_Network = Network;
|
|
pArapConn->NetAddr.atn_Node = Node;
|
|
RELEASE_SPIN_LOCK(&pArapConn->SpinLock, OldIrql);
|
|
|
|
return( ARAPERR_NO_ERROR );
|
|
}
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapAddArapRoute
|
|
// If we are in the static mode of network address allocation, we
|
|
// need to add a route in our table corresponding to the network
|
|
// range allocated for the dial-in clients.
|
|
// This routine does that. In case of dynamic mode, it's a no-op.
|
|
// This is a one-time thing, and we only do it when the first
|
|
// connection comes in (instead of doing at startup).
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Return: None
|
|
//
|
|
//***$
|
|
|
|
VOID
|
|
ArapAddArapRoute(
|
|
IN VOID
|
|
)
|
|
{
|
|
|
|
ATALK_NETWORKRANGE NwRange;
|
|
KIRQL OldIrql;
|
|
BOOLEAN fAddRoute = FALSE;
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
//
|
|
// add a route only if router is enabled, and we are in the Static mode of
|
|
// network allocation, and we haven't already added it
|
|
//
|
|
|
|
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql);
|
|
|
|
if ((AtalkDefaultPort->pd_Flags & PD_ROUTER_RUNNING) &&
|
|
(!ArapGlobs.DynamicMode) &&
|
|
(!ArapGlobs.RouteAdded))
|
|
{
|
|
ArapGlobs.RouteAdded = TRUE;
|
|
fAddRoute = TRUE;
|
|
|
|
ASSERT(ArapConnections >= 1);
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
|
|
|
|
|
|
if (fAddRoute)
|
|
{
|
|
NwRange.anr_FirstNetwork = ArapGlobs.NetRange.LowEnd;
|
|
NwRange.anr_LastNetwork = ArapGlobs.NetRange.HighEnd;
|
|
|
|
atalkRtmpCreateRte(NwRange,
|
|
RasPortDesc,
|
|
&AtalkDefaultPort->pd_Nodes->an_NodeAddr,
|
|
0);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapDeleteArapRoute
|
|
// If there is a routine called ArapAddArapRoute, we have got to
|
|
// have a routine called ArapDeleteArapRoute.
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Return: None
|
|
//
|
|
//***$
|
|
|
|
VOID
|
|
ArapDeleteArapRoute(
|
|
IN VOID
|
|
)
|
|
{
|
|
|
|
KIRQL OldIrql;
|
|
BOOLEAN fDeleteRoute = FALSE;
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
//
|
|
// delete a route only if added it earlier and the connections went to 0
|
|
//
|
|
ACQUIRE_SPIN_LOCK(&ArapSpinLock, &OldIrql);
|
|
if (ArapGlobs.RouteAdded && ArapConnections == 0)
|
|
{
|
|
ArapGlobs.RouteAdded = FALSE;
|
|
fDeleteRoute = TRUE;
|
|
}
|
|
RELEASE_SPIN_LOCK(&ArapSpinLock, OldIrql);
|
|
|
|
if (fDeleteRoute)
|
|
{
|
|
atalkRtmpRemoveRte(ArapGlobs.NetRange.LowEnd);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//***
|
|
//
|
|
// Function: ArapValidNetrange
|
|
// This routine is called if we configured to be in the static
|
|
// mode of addr allocation, when the dll first "binds" to us.
|
|
// It verifies that the network range allocated by the admin is
|
|
// valid and doesn't overlap with any of the network ranges known
|
|
// to us through the route table.
|
|
//
|
|
// Parameters: NetRange - the network range configured for dial-in clients
|
|
//
|
|
// Return: TRUE if the range is valid,
|
|
// FALSE if it overlaps with any of the existing network ranges
|
|
//
|
|
//***$
|
|
|
|
BOOLEAN
|
|
ArapValidNetrange(
|
|
IN NETWORKRANGE NetRange
|
|
)
|
|
{
|
|
BOOLEAN fRangeIsValid=TRUE;
|
|
KIRQL OldIrql;
|
|
PRTE pRte, pNext;
|
|
int i;
|
|
|
|
|
|
|
|
DBG_ARAP_CHECK_PAGED_CODE();
|
|
|
|
if (NetRange.LowEnd == 0 || NetRange.HighEnd == 0)
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapValidNetrange: Invalid network range\n"));
|
|
#if DBG
|
|
DbgDumpNetworkNumbers();
|
|
#endif
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
fRangeIsValid = TRUE;
|
|
|
|
ACQUIRE_SPIN_LOCK(&AtalkRteLock, &OldIrql);
|
|
|
|
for (i = 0; i < NUM_RTMP_HASH_BUCKETS; i++)
|
|
{
|
|
for (pRte = AtalkRoutingTable[i]; pRte != NULL; pRte = pNext)
|
|
{
|
|
pNext = pRte->rte_Next;
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
|
|
if ( (IN_NETWORK_RANGE(NetRange.LowEnd,pRte)) ||
|
|
(IN_NETWORK_RANGE(NetRange.HighEnd,pRte)) )
|
|
{
|
|
DBGPRINT(DBG_COMP_RAS, DBG_LEVEL_ERR,
|
|
("ArapValidNetrange: range in conflict\n"));
|
|
|
|
fRangeIsValid = FALSE;
|
|
RELEASE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
break;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
}
|
|
|
|
if (!fRangeIsValid)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&AtalkRteLock, OldIrql);
|
|
|
|
#if DBG
|
|
if (!fRangeIsValid)
|
|
{
|
|
DbgDumpNetworkNumbers();
|
|
}
|
|
#endif
|
|
|
|
return(fRangeIsValid);
|
|
}
|
|
#endif //ARAP_STATIC_MODE
|
|
|