windows-server-2003/net/sfm/atalk/sys/arapatk.c

/*++

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