3226 lines
80 KiB
C
3226 lines
80 KiB
C
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
zip.c
|
|
|
|
Abstract:
|
|
|
|
This module contains
|
|
|
|
Author:
|
|
|
|
Jameel Hyder (jameelh@microsoft.com)
|
|
Nikhil Kamkolkar (nikhilk@microsoft.com)
|
|
|
|
Revision History:
|
|
19 Jun 1992 Initial Version
|
|
|
|
Notes: Tab stop: 4
|
|
--*/
|
|
|
|
#include <atalk.h>
|
|
#pragma hdrstop
|
|
#define FILENUM ZIP
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, AtalkZipInit)
|
|
#pragma alloc_text(PAGEINIT, AtalkInitZipStartProcessingOnPort)
|
|
#pragma alloc_text(PAGEINIT, atalkZipGetZoneListForPort)
|
|
#pragma alloc_text(PAGE_RTR, AtalkZipPacketInRouter)
|
|
#pragma alloc_text(PAGE_RTR, atalkZipHandleNetInfo)
|
|
#pragma alloc_text(PAGE_RTR, atalkZipHandleReply)
|
|
#pragma alloc_text(PAGE_RTR, atalkZipHandleQuery)
|
|
#pragma alloc_text(PAGE_RTR, atalkZipHandleAtpRequest)
|
|
#pragma alloc_text(PAGE_RTR, atalkZipQueryTimer)
|
|
#pragma alloc_text(PAGE_NZ, AtalkZipGetMyZone)
|
|
#pragma alloc_text(PAGE_NZ, atalkZipGetMyZoneReply)
|
|
#pragma alloc_text(PAGE_NZ, AtalkZipGetZoneList)
|
|
#pragma alloc_text(PAGE_NZ, atalkZipGetZoneListReply)
|
|
#pragma alloc_text(PAGE_NZ, atalkZipZoneInfoTimer)
|
|
#pragma alloc_text(PAGE_NZ, atalkZipSendPacket)
|
|
#endif
|
|
|
|
|
|
/*** AtalkZipInit
|
|
*
|
|
*/
|
|
ATALK_ERROR
|
|
AtalkZipInit(
|
|
IN BOOLEAN Init
|
|
)
|
|
{
|
|
if (Init)
|
|
{
|
|
// Allocate space for zones
|
|
AtalkZonesTable = (PZONE *)AtalkAllocZeroedMemory(sizeof(PZONE) * NUM_ZONES_HASH_BUCKETS);
|
|
if (AtalkZonesTable == NULL)
|
|
{
|
|
return ATALK_RESR_MEM;
|
|
}
|
|
|
|
INITIALIZE_SPIN_LOCK(&AtalkZoneLock);
|
|
}
|
|
else
|
|
{
|
|
// At this point, we are unloading and there are no race conditions
|
|
// or lock contentions. Do not bother locking down the zones table
|
|
if (AtalkDesiredZone != NULL)
|
|
AtalkZoneDereference(AtalkDesiredZone);
|
|
if (AtalkZonesTable != NULL)
|
|
{
|
|
AtalkFreeMemory(AtalkZonesTable);
|
|
AtalkZonesTable = NULL;
|
|
}
|
|
}
|
|
return ATALK_NO_ERROR;
|
|
}
|
|
|
|
|
|
/*** AtalkZipStartProcessingOnPort
|
|
*
|
|
*/
|
|
BOOLEAN
|
|
AtalkInitZipStartProcessingOnPort(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PATALK_NODEADDR pRouterNode
|
|
)
|
|
{
|
|
ATALK_ADDR closeAddr;
|
|
ATALK_ERROR Status;
|
|
KIRQL OldIrql;
|
|
BOOLEAN RetCode = FALSE;
|
|
PDDP_ADDROBJ pZpDdpAddr=NULL;
|
|
|
|
// Switch the incoming zip handler to the router version
|
|
closeAddr.ata_Network = pRouterNode->atn_Network;
|
|
closeAddr.ata_Node = pRouterNode->atn_Node;
|
|
closeAddr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
|
|
do
|
|
{
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
pPortDesc->pd_Flags |= PD_ROUTER_STARTING;
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
|
|
// Close the non-router version of the handler and start the router version
|
|
AtalkDdpInitCloseAddress(pPortDesc, &closeAddr);
|
|
if (!ATALK_SUCCESS(Status = AtalkDdpOpenAddress(pPortDesc,
|
|
ZONESINFORMATION_SOCKET,
|
|
pRouterNode,
|
|
AtalkZipPacketInRouter,
|
|
NULL,
|
|
DDPPROTO_ANY,
|
|
NULL,
|
|
&pZpDdpAddr)))
|
|
{
|
|
DBGPRINT(DBG_COMP_RTMP, DBG_LEVEL_ERR,
|
|
("AtalkZipStartProcessingOnPort: AtalkDdpOpenAddress failed %ld\n",
|
|
Status));
|
|
break;
|
|
}
|
|
|
|
// mark the fact that this is an "internal" socket
|
|
pZpDdpAddr->ddpao_Flags |= DDPAO_SOCK_INTERNAL;
|
|
|
|
// Try to get or set the zone information
|
|
if (!atalkZipGetZoneListForPort(pPortDesc))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("AtalkZipStartProcessingOnPort: Failed to get zone list for port\n"));
|
|
break;
|
|
}
|
|
|
|
if (!atalkZipQryTmrRunning)
|
|
{
|
|
AtalkTimerInitialize(&atalkZipQTimer,
|
|
atalkZipQueryTimer,
|
|
ZIP_QUERY_TIMER);
|
|
AtalkTimerScheduleEvent(&atalkZipQTimer);
|
|
|
|
atalkZipQryTmrRunning = TRUE;
|
|
}
|
|
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
pPortDesc->pd_Flags &= ~PD_ROUTER_STARTING;
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
|
|
RetCode = TRUE;
|
|
} while (FALSE);
|
|
|
|
return RetCode;
|
|
}
|
|
|
|
|
|
/*** AtalkZipPacketIn
|
|
*
|
|
*/
|
|
VOID
|
|
AtalkZipPacketIn(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PBYTE pPkt,
|
|
IN USHORT PktLen,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN PATALK_ADDR pDstAddr,
|
|
IN ATALK_ERROR Status,
|
|
IN BYTE DdpType,
|
|
IN PVOID pHandlerCtx,
|
|
IN BOOLEAN OptimizedPath,
|
|
IN PVOID OptimizeCtx
|
|
)
|
|
{
|
|
BYTE CmdType, Flags;
|
|
BYTE ZoneLen, DefZoneLen, MulticastAddrLen;
|
|
PBYTE pZone, pDefZone, pMulticastAddr;
|
|
TIME TimeS, TimeE, TimeD;
|
|
ULONG Index;
|
|
|
|
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
|
|
|
|
TimeS = KeQueryPerformanceCounter(NULL);
|
|
do
|
|
{
|
|
if ((Status == ATALK_SOCKET_CLOSED) ||
|
|
(DdpType != DDPPROTO_ZIP))
|
|
break;
|
|
|
|
else if (Status != ATALK_NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (!EXT_NET(pPortDesc))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
if (PktLen < ZIP_CMD_OFF+1)
|
|
{
|
|
break;
|
|
}
|
|
|
|
CmdType = pPkt[ZIP_CMD_OFF];
|
|
|
|
// We only care about Zip Notifies and NetInfo replies
|
|
if (((CmdType != ZIP_NOTIFY) && (CmdType != ZIP_NETINFO_REPLY)) ||
|
|
(PktLen < (ZIP_ZONELEN_OFF + 1)))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// If it is a NetInfoReply, then we should be looking for either the
|
|
// default or the desired zone
|
|
if ((CmdType != ZIP_NETINFO_REPLY) &&
|
|
(pPortDesc->pd_Flags & (PD_FINDING_DEFAULT_ZONE | PD_FINDING_DESIRED_ZONE)))
|
|
break;
|
|
|
|
if ((CmdType == ZIP_NETINFO_REPLY) &&
|
|
!(pPortDesc->pd_Flags & (PD_FINDING_DEFAULT_ZONE | PD_FINDING_DESIRED_ZONE)))
|
|
break;
|
|
|
|
// If it is a Notify then the desired zone must be valid
|
|
if ((CmdType == ZIP_NOTIFY) &&
|
|
!(pPortDesc->pd_Flags & PD_VALID_DESIRED_ZONE))
|
|
break;
|
|
|
|
// We have a NetInfoReply or a Notify. Handle it
|
|
Flags = pPkt[ZIP_FLAGS_OFF];
|
|
Index = ZIP_ZONELEN_OFF;
|
|
|
|
ZoneLen = pPkt[ZIP_ZONELEN_OFF];
|
|
Index ++;
|
|
|
|
if ((ZoneLen > MAX_ZONE_LENGTH) || (PktLen < (Index + ZoneLen)))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
pZone = pPkt+Index;
|
|
Index += ZoneLen;
|
|
|
|
// If we are looking for a desired zone and we get a late default zone
|
|
// response then toss this packet
|
|
if ((CmdType == ZIP_NETINFO_REPLY) && (ZoneLen == 0) &&
|
|
(pPortDesc->pd_Flags & (PD_FINDING_DESIRED_ZONE)) &&
|
|
(pPortDesc->pd_InitialDesiredZone != NULL))
|
|
{
|
|
DBGPRINT(DBG_COMP_RTMP, DBG_LEVEL_ERR,
|
|
("AtalkZipPacketIn: dropping a NetInfoReply packet\n"));
|
|
break;
|
|
}
|
|
|
|
|
|
// If we're requesting the zone name, make sure the response matches
|
|
// our request. ZoneLen will be zero when we're looking for the def
|
|
// zone, so we won't do this test
|
|
if ((CmdType == ZIP_NETINFO_REPLY) &&
|
|
(ZoneLen != 0) &&
|
|
(pPortDesc->pd_InitialDesiredZone != NULL))
|
|
{
|
|
BOOLEAN NoMatch = FALSE;
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
ASSERT(!(pPortDesc->pd_Flags & PD_ROUTER_RUNNING) ||
|
|
(pPortDesc->pd_Flags & PD_FINDING_DESIRED_ZONE));
|
|
if (!AtalkFixedCompareCaseInsensitive(pZone,
|
|
ZoneLen,
|
|
pPortDesc->pd_InitialDesiredZone->zn_Zone,
|
|
pPortDesc->pd_InitialDesiredZone->zn_ZoneLen))
|
|
{
|
|
NoMatch = TRUE;
|
|
}
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
if (NoMatch)
|
|
break;
|
|
}
|
|
|
|
// If its a Notify, make sure we're in the zone that is being changed
|
|
if (CmdType == ZIP_NOTIFY)
|
|
{
|
|
BOOLEAN NoMatch = FALSE;
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
if (!AtalkFixedCompareCaseInsensitive(pZone, ZoneLen,
|
|
pPortDesc->pd_DesiredZone->zn_Zone,
|
|
pPortDesc->pd_DesiredZone->zn_ZoneLen))
|
|
{
|
|
NoMatch = TRUE;
|
|
}
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
if (NoMatch)
|
|
break;
|
|
}
|
|
|
|
if (PktLen < (Index + 1))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
MulticastAddrLen = pPkt[Index++];
|
|
if (MulticastAddrLen != pPortDesc->pd_BroadcastAddrLen)
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
if (PktLen < (Index + MulticastAddrLen))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
pMulticastAddr = pPkt + Index;
|
|
Index += MulticastAddrLen;
|
|
#if 0
|
|
if (Flags & ZIP_USE_BROADCAST_FLAG)
|
|
pMulticastAddr = pPortDesc->pd_BroadcastAddr;
|
|
#endif
|
|
// Grab second name, if needed or present
|
|
DefZoneLen = 0;
|
|
if ((CmdType == ZIP_NOTIFY) || (PktLen > Index))
|
|
{
|
|
if (PktLen < (Index+1))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
DefZoneLen = pPkt[Index++];
|
|
if ((DefZoneLen == 0) ||
|
|
(DefZoneLen > MAX_ZONE_LENGTH) ||
|
|
(PktLen < (Index+DefZoneLen)))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
pDefZone = pPkt+Index;
|
|
Index += DefZoneLen;
|
|
}
|
|
|
|
// Make default zone be the new one. We may not have a default/new
|
|
// zone in netinfo reply case and we requested for the correct zone
|
|
if (DefZoneLen == 0)
|
|
{
|
|
pDefZone = pZone;
|
|
DefZoneLen = ZoneLen;
|
|
}
|
|
|
|
// Make sure the port lock is released before calling any depend/ddp
|
|
// etc. routines.
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
|
|
// If we're just looking for the default zone, set here and note
|
|
// our mission completed
|
|
if ((pPortDesc->pd_Flags & PD_FINDING_DEFAULT_ZONE) &&
|
|
(ZoneLen == 0))
|
|
{
|
|
if (pPortDesc->pd_DefaultZone != NULL)
|
|
AtalkZoneDereference(pPortDesc->pd_DefaultZone);
|
|
pPortDesc->pd_DefaultZone = AtalkZoneReferenceByName(pDefZone, DefZoneLen);
|
|
if (pPortDesc->pd_DefaultZone == NULL)
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
RES_LOG_ERROR();
|
|
break;
|
|
}
|
|
pPortDesc->pd_Flags |= PD_VALID_DEFAULT_ZONE;
|
|
pPortDesc->pd_Flags &= ~PD_FINDING_DEFAULT_ZONE;
|
|
}
|
|
|
|
// Now we want to accept all of the information about 'thiszone'
|
|
// for the nodes on the current port
|
|
// If the new multicast address is different, remove the old and
|
|
// set the new. Don't allow changes to the 'broadcast' multicast
|
|
// address.
|
|
if (pPortDesc->pd_Flags & PD_FINDING_DESIRED_ZONE)
|
|
{
|
|
if (!AtalkFixedCompareCaseSensitive(pMulticastAddr,
|
|
MulticastAddrLen,
|
|
pPortDesc->pd_ZoneMulticastAddr,
|
|
MulticastAddrLen))
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
(*pPortDesc->pd_RemoveMulticastAddr)(pPortDesc,
|
|
pMulticastAddr,
|
|
FALSE,
|
|
NULL,
|
|
NULL);
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
}
|
|
|
|
if (!AtalkFixedCompareCaseSensitive(pMulticastAddr,
|
|
MulticastAddrLen,
|
|
pPortDesc->pd_BroadcastAddr,
|
|
MulticastAddrLen))
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
(*pPortDesc->pd_AddMulticastAddr)(pPortDesc,
|
|
pMulticastAddr,
|
|
FALSE,
|
|
NULL,
|
|
NULL);
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
}
|
|
|
|
RtlCopyMemory(pPortDesc->pd_ZoneMulticastAddr,
|
|
pMulticastAddr,
|
|
MulticastAddrLen);
|
|
}
|
|
|
|
// Finally set this cable range if this is a net info reply
|
|
if (CmdType == ZIP_NETINFO_REPLY)
|
|
{
|
|
GETSHORT2SHORT(&pPortDesc->pd_NetworkRange.anr_FirstNetwork,
|
|
pPkt+ZIP_CABLE_RANGE_START_OFF);
|
|
GETSHORT2SHORT(&pPortDesc->pd_NetworkRange.anr_LastNetwork,
|
|
pPkt+ZIP_CABLE_RANGE_END_OFF);
|
|
if (!(pPortDesc->pd_Flags & PD_ROUTER_STARTING))
|
|
{
|
|
pPortDesc->pd_ARouter.atn_Network = pSrcAddr->ata_Network;
|
|
pPortDesc->pd_ARouter.atn_Node = pSrcAddr->ata_Node;
|
|
}
|
|
pPortDesc->pd_Flags |= PD_SEEN_ROUTER_RECENTLY;
|
|
KeSetEvent(&pPortDesc->pd_SeenRouterEvent, IO_NETWORK_INCREMENT, FALSE);
|
|
}
|
|
|
|
// Now that we know the zone
|
|
if (pPortDesc->pd_Flags & PD_FINDING_DESIRED_ZONE)
|
|
{
|
|
pPortDesc->pd_Flags &= ~PD_FINDING_DESIRED_ZONE;
|
|
pPortDesc->pd_Flags |= PD_VALID_DESIRED_ZONE;
|
|
if (pPortDesc->pd_DesiredZone != NULL)
|
|
AtalkZoneDereference(pPortDesc->pd_DesiredZone);
|
|
pPortDesc->pd_DesiredZone = AtalkZoneReferenceByName(pDefZone, DefZoneLen);
|
|
if (pPortDesc->pd_DesiredZone == NULL)
|
|
{
|
|
pPortDesc->pd_Flags &= ~PD_VALID_DESIRED_ZONE;
|
|
RES_LOG_ERROR();
|
|
}
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
|
|
TimeE = KeQueryPerformanceCounter(NULL);
|
|
TimeD.QuadPart = TimeE.QuadPart - TimeS.QuadPart;
|
|
|
|
INTERLOCKED_ADD_LARGE_INTGR_DPC(
|
|
&pPortDesc->pd_PortStats.prtst_ZipPacketInProcessTime,
|
|
TimeD,
|
|
&AtalkStatsLock.SpinLock);
|
|
|
|
INTERLOCKED_INCREMENT_LONG_DPC(
|
|
&pPortDesc->pd_PortStats.prtst_NumZipPacketsIn,
|
|
&AtalkStatsLock.SpinLock);
|
|
} while (FALSE);
|
|
}
|
|
|
|
|
|
/*** AtalkZipPacketInRouter
|
|
*
|
|
*/
|
|
VOID
|
|
AtalkZipPacketInRouter(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PBYTE pPkt,
|
|
IN USHORT PktLen,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN PATALK_ADDR pDstAddr,
|
|
IN ATALK_ERROR Status,
|
|
IN BYTE DdpType,
|
|
IN PVOID pHandlerCtx,
|
|
IN BOOLEAN OptimizedPath,
|
|
IN PVOID OptimizeCtx
|
|
)
|
|
{
|
|
BYTE CmdType;
|
|
TIME TimeS, TimeE, TimeD;
|
|
|
|
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
|
|
|
|
TimeS = KeQueryPerformanceCounter(NULL);
|
|
do
|
|
{
|
|
if (Status == ATALK_SOCKET_CLOSED)
|
|
break;
|
|
|
|
else if (Status != ATALK_NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (DdpType == DDPPROTO_ZIP)
|
|
{
|
|
if (PktLen < ZIP_FIRST_NET_OFF)
|
|
{
|
|
break;
|
|
}
|
|
CmdType = pPkt[ZIP_CMD_OFF];
|
|
|
|
switch (CmdType)
|
|
{
|
|
case ZIP_NETINFO_REPLY:
|
|
case ZIP_NOTIFY:
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipPacketInRouter: Ignoring %s\n",
|
|
(CmdType == ZIP_NOTIFY) ? "Notify" : "NetInfoReply"));
|
|
break;
|
|
|
|
case ZIP_GET_NETINFO:
|
|
// We do not want to do a thing if we're starting up
|
|
if (pPortDesc->pd_Flags & PD_ROUTER_STARTING)
|
|
break;
|
|
|
|
if (!EXT_NET(pPortDesc))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
if (pPortDesc->pd_ZoneList == NULL)
|
|
break; // Not fully up yet !
|
|
|
|
if (PktLen < ZIP_REQ_ZONENAME_OFF)
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipPacketInRouter: GetNetInfo Port %Z\n",
|
|
&pPortDesc->pd_AdapterKey));
|
|
atalkZipHandleNetInfo(pPortDesc,
|
|
pDdpAddr,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
|
|
case ZIP_EXT_REPLY:
|
|
case ZIP_REPLY:
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipPacketInRouter: %sReply Port %Z\n",
|
|
(CmdType == ZIP_REPLY) ? "" : "Extended",
|
|
&pPortDesc->pd_AdapterKey));
|
|
atalkZipHandleReply(pDdpAddr, pSrcAddr, pPkt, PktLen);
|
|
break;
|
|
|
|
case ZIP_QUERY:
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipPacketInRouter: Query Port %Z\n",
|
|
&pPortDesc->pd_AdapterKey));
|
|
|
|
// We do not want to do a thing if we're starting up
|
|
if (pPortDesc->pd_Flags & PD_ROUTER_STARTING)
|
|
break;
|
|
|
|
atalkZipHandleQuery(pPortDesc, pDdpAddr, pSrcAddr, pPkt, PktLen);
|
|
break;
|
|
|
|
default:
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
}
|
|
else if (DdpType == DDPPROTO_ATP)
|
|
{
|
|
USHORT TrId, StartIndex;
|
|
|
|
if (PktLen < ATP_ZIP_START_INDEX_OFF+1)
|
|
{
|
|
ASSERT(0);
|
|
break;
|
|
}
|
|
|
|
// We do not want to do a thing if we're starting up
|
|
if (pPortDesc->pd_Flags & PD_ROUTER_STARTING)
|
|
break;
|
|
|
|
// This had better be a GetZoneList, a GetMyZone ATP request
|
|
if ((pPkt[ATP_CMD_CONTROL_OFF] & ATP_FUNC_MASK) != ATP_REQUEST)
|
|
break;
|
|
|
|
if (pPkt[ATP_BITMAP_OFF] != 1)
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
GETSHORT2SHORT(&TrId, pPkt + ATP_TRANS_ID_OFF);
|
|
CmdType = pPkt[ATP_ZIP_CMD_OFF];
|
|
|
|
if ((CmdType != ZIP_GET_ZONE_LIST) &&
|
|
(CmdType != ZIP_GET_MY_ZONE) &&
|
|
(CmdType != ZIP_GET_LOCAL_ZONES))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("ZIP: Received atp type command %d\n", CmdType));
|
|
|
|
// Get start index. Not meaningful for GetMyZone
|
|
GETSHORT2SHORT(&StartIndex, pPkt+ATP_ZIP_START_INDEX_OFF);
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipPacketInRouter: AtpRequest %d, Port %Z\n",
|
|
CmdType, &pPortDesc->pd_AdapterKey));
|
|
atalkZipHandleAtpRequest(pPortDesc, pDdpAddr, pSrcAddr,
|
|
CmdType, TrId, StartIndex);
|
|
}
|
|
} while (FALSE);
|
|
|
|
TimeE = KeQueryPerformanceCounter(NULL);
|
|
TimeD.QuadPart = TimeE.QuadPart - TimeS.QuadPart;
|
|
|
|
INTERLOCKED_ADD_LARGE_INTGR_DPC(
|
|
&pPortDesc->pd_PortStats.prtst_ZipPacketInProcessTime,
|
|
TimeD,
|
|
&AtalkStatsLock.SpinLock);
|
|
|
|
INTERLOCKED_INCREMENT_LONG_DPC(
|
|
&pPortDesc->pd_PortStats.prtst_NumZipPacketsIn,
|
|
&AtalkStatsLock.SpinLock);
|
|
}
|
|
|
|
|
|
/*** atalkZipHandleNetInfo
|
|
*
|
|
*/
|
|
VOID
|
|
atalkZipHandleNetInfo(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN PATALK_ADDR pDstAddr,
|
|
IN PBYTE pPkt,
|
|
IN USHORT PktLen
|
|
)
|
|
{
|
|
PBUFFER_DESC pBuffDesc;
|
|
BYTE ZoneLen;
|
|
PBYTE Datagram, pZoneName;
|
|
ATALK_ADDR SrcAddr = *pSrcAddr;
|
|
ATALK_ERROR error;
|
|
BOOLEAN UseDefZone = FALSE;
|
|
USHORT index;
|
|
SEND_COMPL_INFO SendInfo;
|
|
|
|
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
|
|
|
|
do
|
|
{
|
|
// Get the zone name out of the request
|
|
ZoneLen = pPkt[ZIP_REQ_ZONELEN_OFF];
|
|
if ((ZoneLen > MAX_ZONE_LENGTH) ||
|
|
(PktLen < (USHORT)(ZoneLen + ZIP_REQ_ZONENAME_OFF)))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
pZoneName = pPkt+ZIP_REQ_ZONENAME_OFF;
|
|
|
|
if ((pBuffDesc = AtalkAllocBuffDesc(NULL,
|
|
MAX_DGRAM_SIZE,
|
|
BD_CHAR_BUFFER | BD_FREE_BUFFER)) == NULL)
|
|
{
|
|
break;
|
|
}
|
|
Datagram = pBuffDesc->bd_CharBuffer;
|
|
|
|
// Format a GetNetInfo reply command
|
|
Datagram[ZIP_CMD_OFF] = ZIP_NETINFO_REPLY;
|
|
Datagram[ZIP_FLAGS_OFF] = 0;
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
if ((ZoneLen == 0) ||
|
|
!AtalkZoneNameOnList(pZoneName, ZoneLen, pPortDesc->pd_ZoneList))
|
|
{
|
|
Datagram[ZIP_FLAGS_OFF] |= ZIP_ZONE_INVALID_FLAG;
|
|
UseDefZone = TRUE;
|
|
}
|
|
|
|
if (AtalkZoneNumOnList(pPortDesc->pd_ZoneList) == 1)
|
|
Datagram[ZIP_FLAGS_OFF] |= ZIP_ONLYONE_ZONE_FLAG;
|
|
|
|
// Add our cable range
|
|
PUTSHORT2SHORT(&Datagram[ZIP_FIRST_NET_OFF],
|
|
pPortDesc->pd_NetworkRange.anr_FirstNetwork);
|
|
PUTSHORT2SHORT(Datagram +ZIP_LAST_NET_OFF,
|
|
pPortDesc->pd_NetworkRange.anr_LastNetwork);
|
|
|
|
// Echo back the requested zone name
|
|
Datagram[ZIP_REQ_ZONELEN_OFF] = ZoneLen;
|
|
RtlCopyMemory(Datagram+ZIP_REQ_ZONENAME_OFF, pZoneName, ZoneLen);
|
|
index = ZIP_REQ_ZONENAME_OFF + ZoneLen;
|
|
|
|
// Place in the correct zone multicast address
|
|
Datagram[index++] = (BYTE)(pPortDesc->pd_BroadcastAddrLen);
|
|
if (UseDefZone)
|
|
{
|
|
pZoneName = pPortDesc->pd_DefaultZone->zn_Zone;
|
|
ZoneLen = pPortDesc->pd_DefaultZone->zn_ZoneLen;
|
|
}
|
|
AtalkZipMulticastAddrForZone(pPortDesc, pZoneName, ZoneLen, Datagram + index);
|
|
|
|
index += pPortDesc->pd_BroadcastAddrLen;
|
|
|
|
// If we need it, add in the default zone
|
|
if (UseDefZone)
|
|
{
|
|
Datagram[index++] = ZoneLen = pPortDesc->pd_DefaultZone->zn_ZoneLen;
|
|
RtlCopyMemory(Datagram + index, pPortDesc->pd_DefaultZone->zn_Zone, ZoneLen);
|
|
index += ZoneLen;
|
|
}
|
|
|
|
// If the request came as a cable-wide broadcast and its
|
|
// source network is not valid for this port, then we want
|
|
// to respond to cable-wide broadcast rather than the source
|
|
if ((pDstAddr->ata_Network == CABLEWIDE_BROADCAST_NETWORK) &&
|
|
(pDstAddr->ata_Node == ATALK_BROADCAST_NODE) &&
|
|
!WITHIN_NETWORK_RANGE(pSrcAddr->ata_Network,
|
|
&pPortDesc->pd_NetworkRange) &&
|
|
!WITHIN_NETWORK_RANGE(pSrcAddr->ata_Network,
|
|
&AtalkStartupNetworkRange))
|
|
{
|
|
SrcAddr.ata_Network = CABLEWIDE_BROADCAST_NETWORK;
|
|
SrcAddr.ata_Node = ATALK_BROADCAST_NODE;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
|
|
// Set the length in the buffer descriptor.
|
|
AtalkSetSizeOfBuffDescData(pBuffDesc, index);
|
|
|
|
// Finally, send this out
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipHandleNetInfo: Sending Reply to %d.%d.%d\n",
|
|
SrcAddr.ata_Network, SrcAddr.ata_Node, SrcAddr.ata_Socket));
|
|
SendInfo.sc_TransmitCompletion = atalkZipSendComplete;
|
|
SendInfo.sc_Ctx1 = pBuffDesc;
|
|
// SendInfo.sc_Ctx2 = NULL;
|
|
// SendInfo.sc_Ctx3 = NULL;
|
|
error = AtalkDdpSend(pDdpAddr,
|
|
&SrcAddr,
|
|
DDPPROTO_ZIP,
|
|
FALSE,
|
|
pBuffDesc,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
&SendInfo);
|
|
if (!ATALK_SUCCESS(error))
|
|
{
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipHandleNetInfo: AtalkDdpSend %ld\n", error));
|
|
}
|
|
} while (FALSE);
|
|
}
|
|
|
|
|
|
/*** atalkZipHandleReply
|
|
*
|
|
*/
|
|
VOID
|
|
atalkZipHandleReply(
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN PBYTE pPkt,
|
|
IN USHORT PktLen
|
|
)
|
|
{
|
|
ULONG index, TotalNetCnt;
|
|
PRTE pRte = NULL;
|
|
PBYTE ZoneName;
|
|
USHORT NetNum;
|
|
BYTE CmdType, NwCnt, NumZonesOnNet, ZoneLen;
|
|
BOOLEAN RteLocked = FALSE;
|
|
BOOLEAN ExtReply = FALSE;
|
|
|
|
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipHandleReply: Enetered\n"));
|
|
|
|
// For a zip extended reply, the network count is really not
|
|
// the # of networks contained in the packet. It is the total #
|
|
// of zones on the single network that is described by the reply
|
|
NwCnt = NumZonesOnNet = pPkt[ZIP_NW_CNT_OFF];
|
|
CmdType = pPkt[ZIP_CMD_OFF];
|
|
|
|
do
|
|
{
|
|
// Walk through the reply packet (assuming we asked for the
|
|
// contained information). We're still using NwCnt when
|
|
// processing an extended reply, but that's okay 'cause it
|
|
// will certainly be at least the # of zones contained in
|
|
// this packet. The '+3' guarantees that we really have
|
|
// network # and node
|
|
for (index = ZIP_FIRST_NET_OFF, TotalNetCnt = 0;
|
|
(TotalNetCnt < NwCnt) && ((index + 3 ) <= PktLen);
|
|
TotalNetCnt ++)
|
|
{
|
|
if (pRte != NULL)
|
|
{
|
|
if (RteLocked)
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
RteLocked = FALSE;
|
|
}
|
|
AtalkRtmpDereferenceRte(pRte, FALSE);
|
|
pRte = NULL;
|
|
}
|
|
|
|
// Get the next netwotk #, if it's not in our routing
|
|
// table (or not the start of a range), then we certainly
|
|
// don't care about its zone name
|
|
GETSHORT2SHORT(&NetNum, pPkt+index);
|
|
index += sizeof(USHORT);
|
|
ZoneLen = pPkt[index++];
|
|
if (((pRte = AtalkRtmpReferenceRte(NetNum)) == NULL) ||
|
|
(pRte->rte_NwRange.anr_FirstNetwork != NetNum))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipHandleReply: Don't know about this range %d\n",
|
|
NetNum));
|
|
index += ZoneLen;
|
|
continue;
|
|
}
|
|
|
|
// Validate the zone name
|
|
if ((ZoneLen == 0) || (ZoneLen > MAX_ZONE_LENGTH) ||
|
|
((index + ZoneLen) > PktLen))
|
|
{
|
|
AtalkLogBadPacket(pDdpAddr->ddpao_Node->an_Port,
|
|
pSrcAddr,
|
|
NULL,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
// Conditionally move the zone name into the routing table
|
|
ZoneName = pPkt+index;
|
|
index += ZoneLen;
|
|
ACQUIRE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
RteLocked = TRUE;
|
|
|
|
if (AtalkZoneNameOnList(ZoneName, ZoneLen, pRte->rte_ZoneList))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipHandleReply: Already have this zone\n"));
|
|
continue;
|
|
}
|
|
|
|
// Check for somebody out there trying to add another zone to
|
|
// our directly connected non-extended network and we already
|
|
// know its zone.
|
|
if ((pRte->rte_NumHops == 0) &&
|
|
!EXT_NET(pRte->rte_PortDesc) &&
|
|
(AtalkZoneNumOnList(pRte->rte_ZoneList) == 1))
|
|
{
|
|
AtalkLogBadPacket(pDdpAddr->ddpao_Node->an_Port,
|
|
pSrcAddr,
|
|
NULL,
|
|
pPkt,
|
|
PktLen);
|
|
continue;
|
|
}
|
|
|
|
// Add to the list now
|
|
pRte->rte_ZoneList = AtalkZoneAddToList(pRte->rte_ZoneList,
|
|
ZoneName,
|
|
ZoneLen);
|
|
if (pRte->rte_ZoneList == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipHandleReply: Failed to add zone to list\n"));
|
|
pRte->rte_Flags &= ~RTE_ZONELIST_VALID;
|
|
continue;
|
|
}
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipHandleReply: # of zones known so far %d\n",
|
|
AtalkZoneNumOnList(pRte->rte_ZoneList)));
|
|
|
|
// If not an extended reply, we know that we have all
|
|
// of the information about a given network contained
|
|
// in this packet, so we can go ahead and mark the zone
|
|
// list valid now
|
|
if (!ExtReply)
|
|
pRte->rte_Flags |= RTE_ZONELIST_VALID;
|
|
}
|
|
|
|
// If we just handled an extended reply, do we now know all
|
|
// that we should know about the specified network ?
|
|
|
|
if (pRte != NULL)
|
|
{
|
|
if (ExtReply)
|
|
{
|
|
if (!RteLocked)
|
|
{
|
|
ACQUIRE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
RteLocked = TRUE;
|
|
}
|
|
if (AtalkZoneNumOnList(pRte->rte_ZoneList) >= NumZonesOnNet)
|
|
pRte->rte_Flags |= RTE_ZONELIST_VALID;
|
|
}
|
|
if (RteLocked)
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
// RteLocked = FALSE;
|
|
}
|
|
AtalkRtmpDereferenceRte(pRte, FALSE);
|
|
// pRte = NULL;
|
|
}
|
|
} while (FALSE);
|
|
}
|
|
|
|
/*** atalkZipHandleQuery
|
|
*
|
|
*/
|
|
VOID
|
|
atalkZipHandleQuery(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN PBYTE pPkt,
|
|
IN USHORT PktLen
|
|
)
|
|
{
|
|
PRTE pRte = NULL;
|
|
PBUFFER_DESC pBuffDesc,
|
|
pBuffDescStart = NULL,
|
|
*ppBuffDesc = &pBuffDescStart;
|
|
PZONE_LIST pZoneList;
|
|
PBYTE Datagram;
|
|
ATALK_ERROR error;
|
|
ULONG i, CurrNumZones, PrevNumZones, TotalNetCnt;
|
|
ULONG NwCnt, NetCntInPkt;
|
|
USHORT NetNum, Size;
|
|
BOOLEAN AllocNewBuffDesc = TRUE, NewPkt = TRUE;
|
|
BOOLEAN PortLocked = FALSE, RteLocked = FALSE;
|
|
BYTE CurrReply, NextReply;
|
|
SEND_COMPL_INFO SendInfo;
|
|
|
|
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
|
|
|
|
CurrNumZones = 0;
|
|
do
|
|
{
|
|
// Walk through the query packet building reply packets that
|
|
// have as much information as we know.
|
|
// When sending replies, we will always send a reply about a
|
|
// network that has more than one zone as an extended reply.
|
|
// As were walking the query list, and we encounter a couple of
|
|
// networks that have only one zone, we'll pack as many of
|
|
// these as we can into a non-extended reply
|
|
NwCnt = pPkt[ZIP_NW_CNT_OFF];
|
|
|
|
for (NetCntInPkt = 0, TotalNetCnt = 0, i = ZIP_FIRST_NET_OFF;
|
|
(TotalNetCnt < NwCnt) && ((i + sizeof(SHORT)) <= PktLen);
|
|
i += sizeof(USHORT), TotalNetCnt++)
|
|
{
|
|
// Dereference any previous Rtes
|
|
if (pRte != NULL)
|
|
{
|
|
if (RteLocked)
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
RteLocked = FALSE;
|
|
}
|
|
AtalkRtmpDereferenceRte(pRte, FALSE);
|
|
pRte = NULL;
|
|
}
|
|
if (PortLocked)
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
PortLocked = FALSE;
|
|
}
|
|
|
|
// Grab the next network number from the query packet,
|
|
// if we don't know about the network, or we don't know
|
|
// the zone name, continue with the next network number
|
|
GETSHORT2SHORT(&NetNum, pPkt+i);
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
|
|
if ((WITHIN_NETWORK_RANGE(NetNum,&pPortDesc->pd_NetworkRange)) &&
|
|
(pPortDesc->pd_ZoneList != NULL))
|
|
{
|
|
pZoneList = pPortDesc->pd_ZoneList;
|
|
PortLocked = TRUE;
|
|
}
|
|
else
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
if (((pRte = AtalkRtmpReferenceRte(NetNum)) == NULL) ||
|
|
(!WITHIN_NETWORK_RANGE(NetNum, &pRte->rte_NwRange)) ||
|
|
!(pRte->rte_Flags & RTE_ZONELIST_VALID))
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ACQUIRE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
pZoneList = pRte->rte_ZoneList;
|
|
RteLocked = TRUE;
|
|
}
|
|
}
|
|
|
|
next_reply:
|
|
|
|
if (AllocNewBuffDesc)
|
|
{
|
|
if ((pBuffDesc = AtalkAllocBuffDesc(NULL,
|
|
MAX_DGRAM_SIZE,
|
|
BD_CHAR_BUFFER | BD_FREE_BUFFER)) == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_RTMP, DBG_LEVEL_ERR,
|
|
("\natalkZipHandleQuery: AtalkAllocBuffDesc @1 failed\n"));
|
|
break;
|
|
}
|
|
|
|
Size = 0;
|
|
Datagram = pBuffDesc->bd_CharBuffer;
|
|
*ppBuffDesc = pBuffDesc;
|
|
pBuffDesc->bd_Next = NULL;
|
|
ppBuffDesc = &pBuffDesc->bd_Next;
|
|
AllocNewBuffDesc = FALSE;
|
|
}
|
|
|
|
// What type of response does this network want ?
|
|
// Copy the previous network's zone count. In case of the first
|
|
// pass, make it same.
|
|
PrevNumZones = CurrNumZones;
|
|
CurrNumZones = AtalkZoneNumOnList(pZoneList);
|
|
if (i == ZIP_FIRST_NET_OFF)
|
|
PrevNumZones = CurrNumZones;
|
|
|
|
ASSERT (CurrNumZones != 0);
|
|
|
|
NextReply = ZIP_REPLY;
|
|
if (CurrNumZones > 1)
|
|
{
|
|
// We start a new packet for each extended network
|
|
NewPkt = TRUE;
|
|
NextReply = ZIP_EXT_REPLY;
|
|
if (NetCntInPkt > 0)
|
|
{
|
|
Datagram[ZIP_CMD_OFF] = CurrReply;
|
|
if (CurrReply == ZIP_REPLY)
|
|
Datagram[ZIP_NW_CNT_OFF] = (BYTE)NetCntInPkt;
|
|
else Datagram[ZIP_NW_CNT_OFF] = (BYTE)PrevNumZones;
|
|
AllocNewBuffDesc = TRUE;
|
|
|
|
pBuffDesc->bd_Length = Size;
|
|
NetCntInPkt = 0;
|
|
goto next_reply;
|
|
}
|
|
}
|
|
|
|
// Walk the zone list
|
|
for (; pZoneList != NULL; pZoneList = pZoneList->zl_Next)
|
|
{
|
|
PZONE pZone = pZoneList->zl_pZone;
|
|
|
|
// If we're starting to build a new reply packet due to
|
|
// either:
|
|
//
|
|
// 1. first time through
|
|
// 2. packet full
|
|
// 3. switching reply types
|
|
//
|
|
// set the index to the first tuple position.
|
|
if (NewPkt || (CurrReply != NextReply))
|
|
{
|
|
if (NetCntInPkt > 0)
|
|
{
|
|
// Close the current buffdesc and open a new one
|
|
// Careful here with the CurrNumZones vs. PrevNumZones
|
|
// If we are going from ExtReply to a Reply, we need
|
|
// to get PrevNumZones. If we are continuing the
|
|
// same ExtReply then we need CurrNumZones.
|
|
Datagram[ZIP_CMD_OFF] = CurrReply;
|
|
if (CurrReply == ZIP_REPLY)
|
|
Datagram[ZIP_NW_CNT_OFF] = (BYTE)NetCntInPkt;
|
|
else
|
|
{
|
|
Datagram[ZIP_NW_CNT_OFF] = (BYTE)CurrNumZones;
|
|
if (CurrReply != NextReply)
|
|
Datagram[ZIP_NW_CNT_OFF] = (BYTE)PrevNumZones;
|
|
}
|
|
pBuffDesc->bd_Length = Size;
|
|
|
|
if ((pBuffDesc = AtalkAllocBuffDesc(NULL,MAX_DGRAM_SIZE,
|
|
BD_CHAR_BUFFER | BD_FREE_BUFFER)) == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_RTMP, DBG_LEVEL_ERR,
|
|
("\natalkZipHandleQuery: AtalkAllocBuffDesc @2 failed\n"));
|
|
break;
|
|
}
|
|
|
|
Size = 0;
|
|
Datagram = pBuffDesc->bd_CharBuffer;
|
|
|
|
*ppBuffDesc = pBuffDesc;
|
|
pBuffDesc->bd_Next = NULL;
|
|
ppBuffDesc = &pBuffDesc->bd_Next;
|
|
NetCntInPkt = 0;
|
|
}
|
|
Size = ZIP_FIRST_NET_OFF;
|
|
CurrReply = NextReply;
|
|
NewPkt = FALSE;
|
|
}
|
|
// We know the answer to the question. Pack a new
|
|
// network/zone tuple into the reply packet.
|
|
|
|
PUTSHORT2SHORT(Datagram+Size, NetNum);
|
|
Size += sizeof(USHORT);
|
|
Datagram[Size++] = pZone->zn_ZoneLen;
|
|
RtlCopyMemory(Datagram + Size,
|
|
pZone->zn_Zone,
|
|
pZone->zn_ZoneLen);
|
|
Size += pZone->zn_ZoneLen;
|
|
NetCntInPkt ++;
|
|
|
|
// If we can't hold another big tuple, signal that we
|
|
// should send on the next pass.
|
|
if ((Size + sizeof(USHORT) + sizeof(char) + MAX_ZONE_LENGTH)
|
|
>= MAX_DGRAM_SIZE)
|
|
{
|
|
NewPkt = TRUE;
|
|
}
|
|
}
|
|
|
|
if (pBuffDesc == NULL)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Dereference an rte if we broke out the loop above
|
|
if (pRte != NULL)
|
|
{
|
|
ASSERT(!PortLocked);
|
|
if (RteLocked)
|
|
{
|
|
RELEASE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
// RteLocked = FALSE;
|
|
}
|
|
AtalkRtmpDereferenceRte(pRte, FALSE);
|
|
// pRte = NULL;
|
|
}
|
|
if (PortLocked)
|
|
{
|
|
ASSERT(!RteLocked);
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
PortLocked = FALSE;
|
|
}
|
|
|
|
// Close the current buffdesc
|
|
if ((!AllocNewBuffDesc) && (pBuffDesc != NULL))
|
|
{
|
|
pBuffDesc->bd_Length = Size;
|
|
if (NetCntInPkt > 0)
|
|
{
|
|
Datagram[ZIP_CMD_OFF] = CurrReply;
|
|
if (CurrReply == ZIP_REPLY)
|
|
Datagram[ZIP_NW_CNT_OFF] = (BYTE)NetCntInPkt;
|
|
else Datagram[ZIP_NW_CNT_OFF] = (BYTE)CurrNumZones;
|
|
}
|
|
}
|
|
|
|
// We have a bunch of datagrams ready to be fired off.
|
|
// Make it so. Do not send any with zero lengths, however.
|
|
SendInfo.sc_TransmitCompletion = atalkZipSendComplete;
|
|
// SendInfo.sc_Ctx2 = NULL;
|
|
// SendInfo.sc_Ctx3 = NULL;
|
|
for (pBuffDesc = pBuffDescStart;
|
|
pBuffDesc != NULL;
|
|
pBuffDesc = pBuffDescStart)
|
|
{
|
|
pBuffDescStart = pBuffDesc->bd_Next;
|
|
|
|
if (pBuffDesc->bd_Length == 0)
|
|
{
|
|
ASSERT(pBuffDescStart == NULL);
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
break;
|
|
}
|
|
|
|
// Set the next ptr to be null. Length already set correctly.
|
|
pBuffDesc->bd_Next = NULL;
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipHandleQuery: Sending Reply to %d.%d.%d\n",
|
|
pSrcAddr->ata_Network, pSrcAddr->ata_Node, pSrcAddr->ata_Socket));
|
|
SendInfo.sc_Ctx1 = pBuffDesc;
|
|
error = AtalkDdpSend(pDdpAddr,
|
|
pSrcAddr,
|
|
DDPPROTO_ZIP,
|
|
FALSE,
|
|
pBuffDesc,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
&SendInfo);
|
|
if (!ATALK_SUCCESS(error))
|
|
{
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipHandleQuery: AtalkDdpSend %ld\n", error));
|
|
}
|
|
}
|
|
} while (FALSE);
|
|
|
|
if (PortLocked)
|
|
{
|
|
ASSERT(!RteLocked);
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
}
|
|
}
|
|
|
|
|
|
/*** atalkZipHandleAtpRequest
|
|
*
|
|
*/
|
|
VOID
|
|
atalkZipHandleAtpRequest(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN BYTE CmdType,
|
|
IN USHORT TrId,
|
|
IN USHORT StartIndex
|
|
)
|
|
{
|
|
PBUFFER_DESC pBuffDesc;
|
|
PBYTE Datagram, ZoneName;
|
|
PZONE pZone;
|
|
ATALK_ERROR error;
|
|
int i, ZoneLen, ZoneCnt, CurrZoneIndex, index;
|
|
BYTE LastFlag = 0;
|
|
SEND_COMPL_INFO SendInfo;
|
|
|
|
ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
|
|
|
|
do
|
|
{
|
|
// Allocate a buffer descriptor and initialize the header
|
|
if ((pBuffDesc = AtalkAllocBuffDesc(NULL, MAX_DGRAM_SIZE,
|
|
BD_CHAR_BUFFER | BD_FREE_BUFFER)) == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
Datagram = pBuffDesc->bd_CharBuffer;
|
|
Datagram[ATP_CMD_CONTROL_OFF] = ATP_RESPONSE + ATP_EOM_MASK;
|
|
Datagram[ATP_SEQ_NUM_OFF] = 0;
|
|
PUTSHORT2SHORT(Datagram + ATP_TRANS_ID_OFF, TrId);
|
|
SendInfo.sc_TransmitCompletion = atalkZipSendComplete;
|
|
SendInfo.sc_Ctx1 = pBuffDesc;
|
|
// SendInfo.sc_Ctx2 = NULL;
|
|
// SendInfo.sc_Ctx3 = NULL;
|
|
|
|
if (CmdType == ZIP_GET_MY_ZONE)
|
|
{
|
|
// We really shouldn't be getting this request on an
|
|
// extended network, but go ahead and reply with the
|
|
// "default zone" in this case, of course, reply with
|
|
// "desired zone" for non-extended nets. We are a router,
|
|
// so "desired zone" will always be valid -- as will the
|
|
// default zone for extended net.
|
|
|
|
PUTSHORT2SHORT(Datagram+ATP_ZIP_LAST_FLAG_OFF, 0);
|
|
PUTSHORT2SHORT(Datagram+ATP_ZIP_START_INDEX_OFF, 1);
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
|
|
if (EXT_NET(pPortDesc))
|
|
{
|
|
ZoneName = pPortDesc->pd_DefaultZone->zn_Zone;
|
|
ZoneLen = pPortDesc->pd_DefaultZone->zn_ZoneLen;
|
|
}
|
|
else
|
|
{
|
|
ZoneName = pPortDesc->pd_DesiredZone->zn_Zone;
|
|
ZoneLen = pPortDesc->pd_DesiredZone->zn_ZoneLen;
|
|
}
|
|
RtlCopyMemory(Datagram+ATP_DATA_OFF+1, ZoneName, ZoneLen);
|
|
Datagram[ATP_DATA_OFF] = (BYTE)ZoneLen;
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
|
|
// Set the length in the buffer descriptor.
|
|
AtalkSetSizeOfBuffDescData(pBuffDesc, (USHORT)(ATP_DATA_OFF + 1 + ZoneLen));
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipHandleAtpReq: Sending GetMyZone Reply to %d.%d.%d\n",
|
|
pSrcAddr->ata_Network, pSrcAddr->ata_Node, pSrcAddr->ata_Socket));
|
|
error = AtalkDdpSend(pDdpAddr,
|
|
pSrcAddr,
|
|
DDPPROTO_ATP,
|
|
FALSE,
|
|
pBuffDesc,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
&SendInfo);
|
|
if (!ATALK_SUCCESS(error))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipHandleAtpRequest: AtalkDdpSend %ld\n", error));
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Either a GetLocalZones or a GetZoneList. Fill the reply packet
|
|
// with as many zones as it'll hold starting at the requested
|
|
// start index
|
|
index = ATP_DATA_OFF;
|
|
|
|
if (CmdType == ZIP_GET_LOCAL_ZONES)
|
|
{
|
|
PZONE_LIST pZoneList;
|
|
|
|
// For GetLocalZones, we only want to count zones
|
|
// that are on the network that is directly connected
|
|
// to the port on which the request originated. Use the
|
|
// zone list on the port.
|
|
ACQUIRE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
for (pZoneList = pPortDesc->pd_ZoneList, ZoneCnt = 0, CurrZoneIndex = 0;
|
|
pZoneList != NULL;
|
|
pZoneList = pZoneList->zl_Next)
|
|
{
|
|
// If we have not seen StartIndex zones yet, keep going
|
|
if (++CurrZoneIndex < StartIndex)
|
|
continue;
|
|
|
|
pZone = pZoneList->zl_pZone;
|
|
|
|
// If this packet cannot hold more, we're done (for now)
|
|
// Fill in the zone count and the last flag
|
|
if ((index + pZone->zn_ZoneLen + 1) >= MAX_DGRAM_SIZE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Place zone name in the packet
|
|
ASSERT(pZone != NULL);
|
|
Datagram[index] = pZone->zn_ZoneLen;
|
|
RtlCopyMemory(Datagram+index+1,
|
|
pZone->zn_Zone,
|
|
pZone->zn_ZoneLen);
|
|
index += (pZone->zn_ZoneLen + 1);
|
|
ZoneCnt ++;
|
|
}
|
|
RELEASE_SPIN_LOCK_DPC(&pPortDesc->pd_Lock);
|
|
|
|
// We've build a packet, set the last flag, if applicable
|
|
LastFlag = (pZoneList == NULL) ? 1 : 0;
|
|
}
|
|
|
|
else // This is a ZIP_GET_ZONE_LIST
|
|
{
|
|
BOOLEAN PktFull = FALSE;
|
|
|
|
ASSERT (CmdType == ZIP_GET_ZONE_LIST);
|
|
|
|
// For GetZoneList, we want all the zones that we know
|
|
// of, so use the AtalkZoneTable.
|
|
ACQUIRE_SPIN_LOCK_DPC(&AtalkZoneLock);
|
|
for (i = 0, ZoneCnt = 0, CurrZoneIndex = 0;
|
|
(i < NUM_ZONES_HASH_BUCKETS) && !PktFull; i++)
|
|
{
|
|
for (pZone = AtalkZonesTable[i];
|
|
pZone != NULL;
|
|
pZone = pZone->zn_Next)
|
|
{
|
|
// If we have not seen StartIndex zones yet, keep going
|
|
if (++CurrZoneIndex < StartIndex)
|
|
continue;
|
|
|
|
// If this packet cannot hold more, we're done (for now)
|
|
// Fill in the zone count and the last flag
|
|
if ((index + pZone->zn_ZoneLen + 1) >= MAX_DGRAM_SIZE)
|
|
{
|
|
PktFull = TRUE;
|
|
break;
|
|
}
|
|
|
|
// Place zone name in the packet
|
|
Datagram[index] = pZone->zn_ZoneLen;
|
|
RtlCopyMemory(Datagram+index+1,
|
|
pZone->zn_Zone,
|
|
pZone->zn_ZoneLen);
|
|
index += (pZone->zn_ZoneLen + 1);
|
|
ZoneCnt ++;
|
|
}
|
|
}
|
|
RELEASE_SPIN_LOCK_DPC(&AtalkZoneLock);
|
|
|
|
// We've build a packet, set the last flag, if applicable
|
|
LastFlag = ((i == NUM_ZONES_HASH_BUCKETS) && (pZone == NULL)) ? 1 : 0;
|
|
}
|
|
|
|
// We've build a packet, set the last flag and # of zones in packet
|
|
Datagram[ATP_ZIP_LAST_FLAG_OFF] = LastFlag;
|
|
Datagram[ATP_ZIP_LAST_FLAG_OFF + 1] = 0;
|
|
PUTSHORT2SHORT(Datagram + ATP_ZIP_ZONE_CNT_OFF, ZoneCnt);
|
|
|
|
// Set the length in the buffer descriptor.
|
|
AtalkSetSizeOfBuffDescData(pBuffDesc, (USHORT)index);
|
|
|
|
// Finally, send this out
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipHandleAtpReq: Sending LocalZones Reply to %d.%d.%d\n",
|
|
pSrcAddr->ata_Network, pSrcAddr->ata_Node, pSrcAddr->ata_Socket));
|
|
error = AtalkDdpSend(pDdpAddr,
|
|
pSrcAddr,
|
|
DDPPROTO_ATP,
|
|
FALSE,
|
|
pBuffDesc,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
&SendInfo);
|
|
if (!ATALK_SUCCESS(error))
|
|
{
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipHandleAtpRequest: AtalkDdpSend %ld\n", error));
|
|
}
|
|
} while (FALSE);
|
|
}
|
|
|
|
|
|
/*** AtalkZipMulticastAddrForZone
|
|
*
|
|
*/
|
|
VOID
|
|
AtalkZipMulticastAddrForZone(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PBYTE pZone,
|
|
IN BYTE ZoneLen,
|
|
IN PBYTE MulticastAddr
|
|
)
|
|
{
|
|
USHORT CheckSum;
|
|
BYTE UpCasedZone[MAX_ZONE_LENGTH];
|
|
|
|
AtalkUpCase(pZone, ZoneLen, UpCasedZone);
|
|
|
|
// Caculate the checksum for the zone
|
|
CheckSum = AtalkDdpCheckSumBuffer(UpCasedZone, ZoneLen, 0);
|
|
|
|
switch (pPortDesc->pd_PortType)
|
|
{
|
|
case ELAP_PORT:
|
|
case FDDI_PORT:
|
|
RtlCopyMemory(MulticastAddr,
|
|
AtalkEthernetZoneMulticastAddrsHdr,
|
|
ELAP_MCAST_HDR_LEN);
|
|
|
|
MulticastAddr[ELAP_MCAST_HDR_LEN] =
|
|
AtalkEthernetZoneMulticastAddrs[CheckSum % ELAP_ZONE_MULTICAST_ADDRS];
|
|
break;
|
|
case TLAP_PORT:
|
|
RtlCopyMemory(MulticastAddr,
|
|
AtalkTokenRingZoneMulticastAddrsHdr,
|
|
TLAP_MCAST_HDR_LEN);
|
|
|
|
RtlCopyMemory(&MulticastAddr[TLAP_MCAST_HDR_LEN],
|
|
AtalkTokenRingZoneMulticastAddrs[CheckSum % TLAP_ZONE_MULTICAST_ADDRS],
|
|
TLAP_ADDR_LEN - TLAP_MCAST_HDR_LEN);
|
|
break;
|
|
default:
|
|
DBGBRK(DBG_LEVEL_FATAL);
|
|
KeBugCheck(0);
|
|
}
|
|
}
|
|
|
|
|
|
/*** AtalkZipGetNetworkInfoForNode
|
|
*
|
|
*/
|
|
BOOLEAN
|
|
AtalkZipGetNetworkInfoForNode(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PATALK_NODEADDR pNode,
|
|
IN BOOLEAN FindDefZone
|
|
)
|
|
{
|
|
PBUFFER_DESC pBuffDesc = NULL;
|
|
ATALK_ADDR SrcAddr, DstAddr;
|
|
ATALK_ERROR error;
|
|
USHORT NumReqs, DgLen;
|
|
BYTE DgCopy[ZIP_ZONENAME_OFF + MAX_ZONE_LENGTH];
|
|
KIRQL OldIrql;
|
|
BOOLEAN RetCode, Done;
|
|
SEND_COMPL_INFO SendInfo;
|
|
|
|
ASSERT(EXT_NET(pPortDesc));
|
|
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
|
|
if (FindDefZone)
|
|
{
|
|
pPortDesc->pd_Flags &= ~PD_VALID_DEFAULT_ZONE;
|
|
pPortDesc->pd_Flags |= PD_FINDING_DEFAULT_ZONE;
|
|
}
|
|
else
|
|
{
|
|
pPortDesc->pd_Flags &= ~PD_VALID_DESIRED_ZONE;
|
|
pPortDesc->pd_Flags |= PD_FINDING_DESIRED_ZONE;
|
|
}
|
|
|
|
// Get source and destination addresses
|
|
SrcAddr.ata_Network = pNode->atn_Network;
|
|
SrcAddr.ata_Node = pNode->atn_Node;
|
|
SrcAddr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
|
|
DstAddr.ata_Network = CABLEWIDE_BROADCAST_NETWORK;
|
|
DstAddr.ata_Node = ATALK_BROADCAST_NODE;
|
|
DstAddr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
|
|
// Build a ZipNetGetInfo datagram
|
|
DgCopy[ZIP_CMD_OFF] = ZIP_GET_NETINFO;
|
|
DgCopy[ZIP_FLAGS_OFF] = 0;
|
|
PUTSHORT2SHORT(DgCopy + ZIP_CABLE_RANGE_START_OFF, 0);
|
|
PUTSHORT2SHORT(DgCopy + ZIP_CABLE_RANGE_END_OFF, 0);
|
|
|
|
DgLen = ZIP_ZONENAME_OFF;
|
|
DgCopy[ZIP_ZONELEN_OFF] = 0;
|
|
if (!FindDefZone &&
|
|
(pPortDesc->pd_InitialDesiredZone != NULL))
|
|
{
|
|
DgCopy[ZIP_ZONELEN_OFF] = pPortDesc->pd_InitialDesiredZone->zn_ZoneLen;
|
|
RtlCopyMemory(DgCopy + ZIP_ZONENAME_OFF,
|
|
pPortDesc->pd_InitialDesiredZone->zn_Zone,
|
|
pPortDesc->pd_InitialDesiredZone->zn_ZoneLen);
|
|
DgLen += DgCopy[ZIP_ZONELEN_OFF];
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
|
|
for (NumReqs = 0;
|
|
NumReqs < ZIP_NUM_GETNET_INFOS;
|
|
NumReqs++)
|
|
{
|
|
Done = FindDefZone ?
|
|
((pPortDesc->pd_Flags & PD_VALID_DEFAULT_ZONE) != 0) :
|
|
((pPortDesc->pd_Flags & PD_VALID_DESIRED_ZONE) != 0);
|
|
|
|
if (Done)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ((pBuffDesc = AtalkAllocBuffDesc(NULL, DgLen,
|
|
BD_CHAR_BUFFER | BD_FREE_BUFFER)) == NULL)
|
|
{
|
|
break;
|
|
}
|
|
RtlCopyMemory(pBuffDesc->bd_CharBuffer, DgCopy, DgLen);
|
|
|
|
// Set the length in the buffer descriptor.
|
|
AtalkSetSizeOfBuffDescData(pBuffDesc, DgLen);
|
|
|
|
SendInfo.sc_TransmitCompletion = atalkZipSendComplete;
|
|
SendInfo.sc_Ctx1 = pBuffDesc;
|
|
// SendInfo.sc_Ctx2 = NULL;
|
|
// SendInfo.sc_Ctx3 = NULL;
|
|
|
|
error = AtalkDdpTransmit(pPortDesc,
|
|
&SrcAddr,
|
|
&DstAddr,
|
|
DDPPROTO_ZIP,
|
|
pBuffDesc,
|
|
NULL,
|
|
0,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
&SendInfo);
|
|
if (!ATALK_SUCCESS(error))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("AtalkZipGetNetworkInfoForNode: AtalkDdpTransmit %ld\n", error));
|
|
break;
|
|
}
|
|
pBuffDesc = NULL;
|
|
AtalkSleep(ZIP_GET_NETINFO_WAIT);
|
|
}
|
|
|
|
if (pBuffDesc != NULL)
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
if (FindDefZone)
|
|
{
|
|
pPortDesc->pd_Flags &= ~PD_FINDING_DEFAULT_ZONE;
|
|
}
|
|
else
|
|
{
|
|
pPortDesc->pd_Flags &= ~PD_FINDING_DESIRED_ZONE;
|
|
}
|
|
|
|
RetCode = FindDefZone ?
|
|
((pPortDesc->pd_Flags & PD_VALID_DEFAULT_ZONE) == PD_VALID_DEFAULT_ZONE) :
|
|
((pPortDesc->pd_Flags & PD_VALID_DESIRED_ZONE) == PD_VALID_DESIRED_ZONE);
|
|
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
|
|
return RetCode;
|
|
}
|
|
|
|
|
|
/*** AtalkZipGetMyZone
|
|
*
|
|
*/
|
|
ATALK_ERROR
|
|
AtalkZipGetMyZone(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN BOOLEAN fDesired,
|
|
IN OUT PAMDL pAMdl,
|
|
IN INT Size,
|
|
IN PACTREQ pActReq
|
|
)
|
|
{
|
|
PZIPCOMPLETIONINFO pZci = NULL;
|
|
ATALK_ERROR Status = ATALK_NO_ERROR;
|
|
ULONG BytesCopied;
|
|
PZONE pZone;
|
|
KIRQL OldIrql;
|
|
BOOLEAN Done = FALSE;
|
|
|
|
ASSERT (VALID_ACTREQ(pActReq));
|
|
|
|
if (Size < (MAX_ZONE_LENGTH + 1))
|
|
return ATALK_BUFFER_TOO_SMALL;
|
|
|
|
do
|
|
{
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
|
|
// For extended network, we either know or cannot find out
|
|
if (EXT_NET(pPortDesc))
|
|
{
|
|
BOOLEAN Yes = FALSE;
|
|
|
|
if (fDesired && (pPortDesc->pd_Flags & PD_VALID_DESIRED_ZONE))
|
|
{
|
|
pZone = pPortDesc->pd_DesiredZone;
|
|
Yes = TRUE;
|
|
}
|
|
else if (!fDesired && (pPortDesc->pd_Flags & PD_VALID_DEFAULT_ZONE))
|
|
{
|
|
pZone = pPortDesc->pd_DefaultZone;
|
|
Yes = TRUE;
|
|
}
|
|
if (Yes)
|
|
{
|
|
TdiCopyBufferToMdl( pZone->zn_Zone,
|
|
0,
|
|
pZone->zn_ZoneLen,
|
|
pAMdl,
|
|
0,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == pZone->zn_ZoneLen);
|
|
|
|
TdiCopyBufferToMdl( "",
|
|
0,
|
|
1,
|
|
pAMdl,
|
|
pZone->zn_ZoneLen,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == 1);
|
|
Done = TRUE;
|
|
}
|
|
}
|
|
|
|
// For non-extended networks, we need to ask a router. If we don't
|
|
// know about a router, return.
|
|
if (!Done &&
|
|
(EXT_NET(pPortDesc) ||
|
|
!(pPortDesc->pd_Flags & PD_SEEN_ROUTER_RECENTLY)))
|
|
{
|
|
TdiCopyBufferToMdl( "*",
|
|
0,
|
|
sizeof("*"),
|
|
pAMdl,
|
|
0,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == sizeof("*"));
|
|
Done = TRUE;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
|
|
if (Done)
|
|
{
|
|
(*pActReq->ar_Completion)(ATALK_NO_ERROR, pActReq);
|
|
break;
|
|
}
|
|
|
|
ASSERT (!EXT_NET(pPortDesc));
|
|
|
|
// Allocate a Completion info structure
|
|
if ((pZci = AtalkAllocMemory(sizeof(ZIPCOMPLETIONINFO))) == NULL)
|
|
{
|
|
Status = ATALK_RESR_MEM;
|
|
break;
|
|
}
|
|
|
|
// Initialize completion info
|
|
#if DBG
|
|
pZci->zci_Signature = ZCI_SIGNATURE;
|
|
#endif
|
|
INITIALIZE_SPIN_LOCK(&pZci->zci_Lock);
|
|
pZci->zci_RefCount = 1;
|
|
pZci->zci_pPortDesc = pPortDesc;
|
|
pZci->zci_pDdpAddr = NULL;
|
|
pZci->zci_pAMdl = pAMdl;
|
|
pZci->zci_BufLen = Size;
|
|
pZci->zci_pActReq = pActReq;
|
|
pZci->zci_Router.ata_Network = pPortDesc->pd_ARouter.atn_Network;
|
|
pZci->zci_Router.ata_Node = pPortDesc->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 = -1;
|
|
pZci->zci_AtpRequestType = ZIP_GET_MY_ZONE;
|
|
pZci->zci_Handler = atalkZipGetMyZoneReply;
|
|
AtalkTimerInitialize(&pZci->zci_Timer,
|
|
atalkZipZoneInfoTimer,
|
|
ZIP_GET_ZONEINFO_TIMER);
|
|
|
|
Status = atalkZipSendPacket(pZci, TRUE);
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipGetMyZone: atalkZipSendPacket %ld\n",
|
|
Status));
|
|
pZci->zci_FinalStatus = Status;
|
|
atalkZipDereferenceZci(pZci);
|
|
Status = ATALK_PENDING; // atalkZipDereferenceZci completes the req
|
|
}
|
|
} while (FALSE);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
/*** atalkZipGetMyZoneReply
|
|
*
|
|
*/
|
|
VOID
|
|
atalkZipGetMyZoneReply(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PBYTE pPkt,
|
|
IN USHORT PktLen,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN PATALK_ADDR pDstAddr,
|
|
IN ATALK_ERROR Status,
|
|
IN BYTE DdpType,
|
|
IN PZIPCOMPLETIONINFO pZci,
|
|
IN BOOLEAN OptimizePath,
|
|
IN PVOID OptimizeCtx
|
|
)
|
|
{
|
|
ULONG BytesCopied;
|
|
KIRQL OldIrql;
|
|
USHORT ZoneCnt;
|
|
BYTE ZoneLen;
|
|
|
|
do
|
|
{
|
|
if (Status == ATALK_SOCKET_CLOSED)
|
|
{
|
|
pZci->zci_pDdpAddr = NULL;
|
|
if (AtalkTimerCancelEvent(&pZci->zci_Timer, NULL))
|
|
atalkZipDereferenceZci(pZci);
|
|
pZci->zci_FinalStatus = Status;
|
|
atalkZipDereferenceZci(pZci);
|
|
break;
|
|
}
|
|
|
|
if ((Status != ATALK_NO_ERROR) ||
|
|
(DdpType != DDPPROTO_ATP) ||
|
|
(PktLen <= ATP_ZIP_FIRST_ZONE_OFF))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
// We should have one zone
|
|
GETSHORT2SHORT(&ZoneCnt, pPkt + ATP_ZIP_ZONE_CNT_OFF);
|
|
ZoneLen = pPkt[ATP_ZIP_FIRST_ZONE_OFF];
|
|
if ((ZoneCnt != 1) ||
|
|
(ZoneLen == 0) || (ZoneLen > MAX_ZONE_LENGTH))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipGetMyZoneReply: Bad reply\n"));
|
|
break;
|
|
}
|
|
|
|
if (AtalkTimerCancelEvent(&pZci->zci_Timer, NULL))
|
|
{
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
|
|
ACQUIRE_SPIN_LOCK(&pZci->zci_Lock, &OldIrql);
|
|
|
|
TdiCopyBufferToMdl( pPkt + ATP_ZIP_FIRST_ZONE_OFF + 1,
|
|
0,
|
|
ZoneLen,
|
|
pZci->zci_pAMdl,
|
|
0,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == ZoneLen);
|
|
|
|
TdiCopyBufferToMdl( "",
|
|
0,
|
|
1,
|
|
pZci->zci_pAMdl,
|
|
ZoneLen,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == 1);
|
|
pZci->zci_FinalStatus = ATALK_NO_ERROR;
|
|
RELEASE_SPIN_LOCK(&pZci->zci_Lock, OldIrql);
|
|
atalkZipDereferenceZci(pZci);
|
|
} while (FALSE);
|
|
}
|
|
|
|
|
|
/*** AtalkZipGetZoneList
|
|
*
|
|
*/
|
|
ATALK_ERROR
|
|
AtalkZipGetZoneList(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN BOOLEAN fLocalZones,
|
|
IN OUT PAMDL pAMdl,
|
|
IN INT Size,
|
|
IN PACTREQ pActReq
|
|
)
|
|
{
|
|
PZIPCOMPLETIONINFO pZci = NULL;
|
|
ATALK_ERROR Status = ATALK_NO_ERROR;
|
|
ULONG BytesCopied, index, NumZones;
|
|
KIRQL OldIrql;
|
|
BOOLEAN Done = FALSE, PortLocked = TRUE;
|
|
|
|
ASSERT (VALID_ACTREQ(pActReq));
|
|
|
|
if (Size < (MAX_ZONE_LENGTH + 1))
|
|
return ATALK_BUFFER_TOO_SMALL;
|
|
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
|
|
do
|
|
{
|
|
// If we don't know about a router, return.
|
|
if (!(pPortDesc->pd_Flags & PD_SEEN_ROUTER_RECENTLY))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_WARN,
|
|
("AtalkZipGetZoneList: Don't know a router !!!\n"));
|
|
TdiCopyBufferToMdl( "*",
|
|
0,
|
|
sizeof("*"),
|
|
pAMdl,
|
|
0,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == sizeof("*"));
|
|
Done = TRUE;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
PortLocked = FALSE;
|
|
|
|
if (Done)
|
|
{
|
|
((PZIP_GETZONELIST_PARAMS)(pActReq->ar_pParms))->ZonesAvailable = 1;
|
|
(*pActReq->ar_Completion)(ATALK_NO_ERROR, pActReq);
|
|
break;
|
|
}
|
|
|
|
// If we are a router, then simply copy the zones. Else send a
|
|
// a request to the router. DO NOT SEND A REQUEST IF WE ARE A
|
|
// ROUTER SINCE THAT WILL RESULT IN A HORRIBLE RECURSION RESULTING
|
|
// IN A DOUBLE FAULT (OUT OF STACK SPACE).
|
|
if (pPortDesc->pd_Flags & PD_ROUTER_RUNNING)
|
|
{
|
|
PZONE pZone;
|
|
|
|
NumZones = 0;
|
|
if (fLocalZones)
|
|
{
|
|
PZONE_LIST pZoneList;
|
|
|
|
// For GetLocalZones, we only want to count zones
|
|
// that are on the network that is directly connected
|
|
// to the port on which the request originated
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
for (index = 0, pZoneList = pPortDesc->pd_ZoneList;
|
|
pZoneList != NULL;
|
|
pZoneList = pZoneList->zl_Next)
|
|
{
|
|
pZone = pZoneList->zl_pZone;
|
|
|
|
ASSERT (pZone != NULL);
|
|
|
|
// If this packet cannot hold more, we're done
|
|
if ((INT)(index + pZone->zn_ZoneLen + 1) >= Size)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Place zone name in the packet
|
|
TdiCopyBufferToMdl( pZone->zn_Zone,
|
|
0,
|
|
pZone->zn_ZoneLen + 1,
|
|
pAMdl,
|
|
index,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == (ULONG)(pZone->zn_ZoneLen + 1));
|
|
|
|
NumZones ++;
|
|
index += (pZone->zn_ZoneLen + 1);
|
|
}
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
Status = (pZoneList != NULL) ?
|
|
ATALK_BUFFER_TOO_SMALL : ATALK_NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
BOOLEAN PktFull = FALSE;
|
|
INT i;
|
|
|
|
ACQUIRE_SPIN_LOCK(&AtalkZoneLock, &OldIrql);
|
|
for (i = 0, index = 0, PktFull = FALSE;
|
|
(i < NUM_ZONES_HASH_BUCKETS) && !PktFull;
|
|
i++)
|
|
{
|
|
for (pZone = AtalkZonesTable[i];
|
|
pZone != NULL;
|
|
pZone = pZone->zn_Next)
|
|
{
|
|
// If this packet cannot hold more, we're done
|
|
if ((INT)(index + pZone->zn_ZoneLen + 1) >= Size)
|
|
{
|
|
PktFull = TRUE;
|
|
break;
|
|
}
|
|
|
|
// Place zone name in the packet
|
|
TdiCopyBufferToMdl( pZone->zn_Zone,
|
|
0,
|
|
pZone->zn_ZoneLen + 1,
|
|
pAMdl,
|
|
index,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == (ULONG)(pZone->zn_ZoneLen + 1));
|
|
|
|
NumZones ++;
|
|
index += (pZone->zn_ZoneLen + 1);
|
|
}
|
|
}
|
|
RELEASE_SPIN_LOCK(&AtalkZoneLock, OldIrql);
|
|
Status = ((pZone != NULL) || ( i < NUM_ZONES_HASH_BUCKETS)) ?
|
|
ATALK_BUFFER_TOO_SMALL : ATALK_NO_ERROR;
|
|
}
|
|
((PZIP_GETZONELIST_PARAMS)
|
|
(pActReq->ar_pParms))->ZonesAvailable = NumZones;
|
|
if (ATALK_SUCCESS(Status))
|
|
{
|
|
(*pActReq->ar_Completion)(Status, pActReq);
|
|
}
|
|
break;
|
|
}
|
|
|
|
ASSERT ((pPortDesc->pd_Flags & PD_ROUTER_RUNNING) == 0);
|
|
|
|
// Allocate a Completion info structure
|
|
if ((pZci = AtalkAllocMemory(sizeof(ZIPCOMPLETIONINFO))) == NULL)
|
|
{
|
|
Status = ATALK_RESR_MEM;
|
|
break;
|
|
}
|
|
|
|
// Initialize completion info
|
|
#if DBG
|
|
pZci->zci_Signature = ZCI_SIGNATURE;
|
|
#endif
|
|
INITIALIZE_SPIN_LOCK(&pZci->zci_Lock);
|
|
pZci->zci_RefCount = 1;
|
|
pZci->zci_pPortDesc = pPortDesc;
|
|
pZci->zci_pDdpAddr = NULL;
|
|
pZci->zci_pAMdl = pAMdl;
|
|
pZci->zci_BufLen = Size;
|
|
pZci->zci_pActReq = pActReq;
|
|
pZci->zci_Router.ata_Network = pPortDesc->pd_ARouter.atn_Network;
|
|
pZci->zci_Router.ata_Node = pPortDesc->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);
|
|
if (fLocalZones)
|
|
pZci->zci_AtpRequestType = ZIP_GET_LOCAL_ZONES;
|
|
pZci->zci_Handler = atalkZipGetZoneListReply;
|
|
|
|
Status = atalkZipSendPacket(pZci, TRUE);
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("AtalkZipGetZoneList: atalkZipSendPacket %ld\n", Status));
|
|
pZci->zci_FinalStatus = Status;
|
|
atalkZipDereferenceZci(pZci);
|
|
Status = ATALK_PENDING; // atalkZipDereferenceZci completes the req
|
|
}
|
|
} while (FALSE);
|
|
|
|
if (PortLocked)
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
|
|
/*** atalkZipGetZoneListReply
|
|
*
|
|
*/
|
|
VOID
|
|
atalkZipGetZoneListReply(
|
|
IN PPORT_DESCRIPTOR pPortDesc,
|
|
IN PDDP_ADDROBJ pDdpAddr,
|
|
IN PBYTE pPkt,
|
|
IN USHORT PktLen,
|
|
IN PATALK_ADDR pSrcAddr,
|
|
IN PATALK_ADDR pDstAddr,
|
|
IN ATALK_ERROR Status,
|
|
IN BYTE DdpType,
|
|
IN PZIPCOMPLETIONINFO pZci,
|
|
IN BOOLEAN OptimizePath,
|
|
IN PVOID OptimizeCtx
|
|
)
|
|
{
|
|
PBYTE pZone;
|
|
ULONG dindex;
|
|
ULONG BytesCopied;
|
|
USHORT ZoneCnt;
|
|
BYTE ZoneLen;
|
|
BOOLEAN LastFlag, Overflow = FALSE;
|
|
|
|
ASSERT(VALID_ZCI(pZci));
|
|
|
|
do
|
|
{
|
|
if (Status == ATALK_SOCKET_CLOSED)
|
|
{
|
|
pZci->zci_pDdpAddr = NULL;
|
|
if (AtalkTimerCancelEvent(&pZci->zci_Timer, NULL))
|
|
{
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
pZci->zci_FinalStatus = Status;
|
|
atalkZipDereferenceZci(pZci);
|
|
break;
|
|
}
|
|
|
|
if ((Status != ATALK_NO_ERROR) ||
|
|
(DdpType != DDPPROTO_ATP) ||
|
|
(PktLen <= ATP_ZIP_FIRST_ZONE_OFF))
|
|
{
|
|
AtalkLogBadPacket(pPortDesc,
|
|
pSrcAddr,
|
|
pDstAddr,
|
|
pPkt,
|
|
PktLen);
|
|
break;
|
|
}
|
|
|
|
// We should have a zone list.
|
|
// Cancel the timer. Start it again if we have not got all the zones
|
|
if (AtalkTimerCancelEvent(&pZci->zci_Timer, NULL))
|
|
{
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipGetZoneListReply: More zones. Index %d, SizeLeft %d\n",
|
|
pZci->zci_ZoneCount, pZci->zci_BufLen - pZci->zci_NextZoneOff));
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&pZci->zci_Lock);
|
|
|
|
GETSHORT2SHORT(&ZoneCnt, pPkt + ATP_ZIP_ZONE_CNT_OFF);
|
|
LastFlag = FALSE;
|
|
if ((pPkt[ATP_ZIP_LAST_FLAG_OFF] != 0) ||
|
|
(ZoneCnt == 0))
|
|
LastFlag = TRUE;
|
|
dindex = ATP_ZIP_FIRST_ZONE_OFF;
|
|
|
|
while (ZoneCnt != 0)
|
|
{
|
|
// Pull out the next zone
|
|
ZoneLen = pPkt[dindex++];
|
|
if ((ZoneLen == 0) ||
|
|
(ZoneLen > MAX_ZONE_LENGTH) ||
|
|
(PktLen < (dindex + ZoneLen)))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipGetZoneListReply: Bad Zip reply\n"));
|
|
break;
|
|
}
|
|
pZone = pPkt + dindex;
|
|
dindex += ZoneLen;
|
|
if ((pZci->zci_NextZoneOff + ZoneLen + 1) > pZci->zci_BufLen)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipGetZoneList: Overflow\n"));
|
|
Overflow = TRUE;
|
|
break;
|
|
}
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("AtalkZipGetZoneList: Copying a zone (%d, %d)\n",
|
|
pZci->zci_ZoneCount,
|
|
pZci->zci_BufLen - pZci->zci_NextZoneOff));
|
|
TdiCopyBufferToMdl( pZone,
|
|
0,
|
|
ZoneLen,
|
|
pZci->zci_pAMdl,
|
|
pZci->zci_NextZoneOff,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == ZoneLen);
|
|
|
|
TdiCopyBufferToMdl( "",
|
|
0,
|
|
1,
|
|
pZci->zci_pAMdl,
|
|
pZci->zci_NextZoneOff + ZoneLen,
|
|
&BytesCopied);
|
|
pZci->zci_NextZoneOff += (ZoneLen + 1);
|
|
pZci->zci_ZoneCount ++;
|
|
ZoneCnt --;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pZci->zci_Lock);
|
|
|
|
if (Overflow || LastFlag)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipGetZoneListReply: All that we wanted\n"));
|
|
|
|
pZci->zci_FinalStatus = ATALK_NO_ERROR;
|
|
if (Overflow)
|
|
pZci->zci_FinalStatus = ATALK_BUFFER_TOO_SMALL;
|
|
((PZIP_GETZONELIST_PARAMS)
|
|
(pZci->zci_pActReq->ar_pParms))->ZonesAvailable =
|
|
pZci->zci_ZoneCount;
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipGetZoneListReply: Sending another packet\n"));
|
|
|
|
Status = atalkZipSendPacket(pZci, TRUE);
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("AtalkZipGetZoneListReply: atalkZipSendPacket %ld\n", Status));
|
|
pZci->zci_FinalStatus = Status;
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
}
|
|
} while (FALSE);
|
|
}
|
|
|
|
|
|
/*** atalkZipZoneInfoTimer
|
|
*
|
|
*/
|
|
LOCAL LONG FASTCALL
|
|
atalkZipZoneInfoTimer(
|
|
IN PTIMERLIST pTimer,
|
|
IN BOOLEAN TimerShuttingDown
|
|
)
|
|
{
|
|
PZIPCOMPLETIONINFO pZci;
|
|
ATALK_ERROR Status;
|
|
ULONG BytesCopied;
|
|
BOOLEAN Done = FALSE, RestartTimer = FALSE;
|
|
|
|
pZci = (PZIPCOMPLETIONINFO)CONTAINING_RECORD(pTimer, ZIPCOMPLETIONINFO, zci_Timer);
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipZoneInfoTimer: Entered for pZci = %lx\n", pZci));
|
|
|
|
ASSERT(VALID_ZCI(pZci));
|
|
|
|
do
|
|
{
|
|
ACQUIRE_SPIN_LOCK_DPC(&pZci->zci_Lock);
|
|
if (--(pZci->zci_ExpirationCount) != 0)
|
|
{
|
|
RestartTimer = TRUE;
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipZoneInfoTimer: Sending another packet\n", pZci));
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pZci->zci_Lock);
|
|
Status = atalkZipSendPacket(pZci, FALSE);
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
RestartTimer = FALSE;
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipZoneInfoTimer: atalkZipSendPacket %ld\n",
|
|
Status));
|
|
|
|
pZci->zci_FinalStatus = Status;
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (pZci->zci_AtpRequestType == ZIP_GET_MY_ZONE)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipZoneInfoTimer: Completing GetMyZone\n"));
|
|
|
|
TdiCopyBufferToMdl("*",
|
|
0,
|
|
sizeof("*"),
|
|
pZci->zci_pAMdl,
|
|
0,
|
|
&BytesCopied);
|
|
}
|
|
else // GET_ZONE_LIST
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipZoneInfoTimer: Completing GetZoneList\n"));
|
|
|
|
if ((pZci->zci_ZoneCount == 0) &&
|
|
((SHORT)(pZci->zci_NextZoneOff + sizeof("*")) < pZci->zci_BufLen))
|
|
{
|
|
pZci->zci_ZoneCount++;
|
|
TdiCopyBufferToMdl("*",
|
|
0,
|
|
sizeof("*"),
|
|
pZci->zci_pAMdl,
|
|
pZci->zci_NextZoneOff,
|
|
&BytesCopied);
|
|
ASSERT (BytesCopied == sizeof("*"));
|
|
}
|
|
((PZIP_GETZONELIST_PARAMS)
|
|
(pZci->zci_pActReq->ar_pParms))->ZonesAvailable =
|
|
pZci->zci_ZoneCount;
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pZci->zci_Lock);
|
|
atalkZipDereferenceZci(pZci); // Timer reference
|
|
|
|
pZci->zci_FinalStatus = ATALK_NO_ERROR;
|
|
atalkZipDereferenceZci(pZci);
|
|
ASSERT(!RestartTimer);
|
|
|
|
} while (FALSE);
|
|
|
|
return (RestartTimer ? ATALK_TIMER_REQUEUE : ATALK_TIMER_NO_REQUEUE);
|
|
}
|
|
|
|
|
|
/*** atalkZipSendPacket
|
|
*
|
|
*/
|
|
ATALK_ERROR
|
|
atalkZipSendPacket(
|
|
IN PZIPCOMPLETIONINFO pZci,
|
|
IN BOOLEAN EnqueueTimer
|
|
)
|
|
{
|
|
PBUFFER_DESC pBuffDesc;
|
|
ATALK_ERROR Status;
|
|
ATALK_ADDR DestAddr;
|
|
PBYTE Datagram;
|
|
SEND_COMPL_INFO SendInfo;
|
|
|
|
ASSERT (VALID_ZCI(pZci));
|
|
|
|
if (pZci->zci_pDdpAddr == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipSendPacket: Opening Ddp Socket\n"));
|
|
|
|
// Open a socket for handling replies
|
|
Status = AtalkDdpOpenAddress(pZci->zci_pPortDesc,
|
|
UNKNOWN_SOCKET,
|
|
NULL,
|
|
pZci->zci_Handler,
|
|
pZci,
|
|
0,
|
|
NULL,
|
|
&pZci->zci_pDdpAddr);
|
|
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipSendPacket: AtalkDdpOpenAddress %ld\n", Status));
|
|
return Status;
|
|
}
|
|
|
|
// mark the fact that this is an "internal" socket
|
|
pZci->zci_pDdpAddr->ddpao_Flags |= DDPAO_SOCK_INTERNAL;
|
|
|
|
}
|
|
|
|
ASSERT (VALID_DDP_ADDROBJ(pZci->zci_pDdpAddr));
|
|
|
|
// Alloc a buffer desciptor for the atp request
|
|
if ((pBuffDesc = AtalkAllocBuffDesc(pZci->zci_Datagram,
|
|
ZIP_GETZONELIST_DDPSIZE,
|
|
BD_CHAR_BUFFER)) == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipSendPacket: Couldn't allocate a buffdesc\n"));
|
|
AtalkDdpCloseAddress(pZci->zci_pDdpAddr, NULL, NULL);
|
|
return ATALK_RESR_MEM;
|
|
}
|
|
|
|
// Start the zone info timer
|
|
if (EnqueueTimer)
|
|
{
|
|
KIRQL OldIrql;
|
|
|
|
ACQUIRE_SPIN_LOCK(&pZci->zci_Lock, &OldIrql);
|
|
pZci->zci_RefCount ++; // For the timer
|
|
AtalkTimerScheduleEvent(&pZci->zci_Timer);
|
|
RELEASE_SPIN_LOCK(&pZci->zci_Lock, OldIrql);
|
|
}
|
|
|
|
// Build the Atp request and send it along
|
|
Datagram = pBuffDesc->bd_CharBuffer;
|
|
Datagram[ATP_CMD_CONTROL_OFF] = ATP_REQUEST;
|
|
Datagram[ATP_BITMAP_OFF] = 1;
|
|
Datagram[ATP_TRANS_ID_OFF] = 0;
|
|
Datagram[ATP_TRANS_ID_OFF+1] = 0;
|
|
Datagram[ATP_ZIP_CMD_OFF] = (BYTE)pZci->zci_AtpRequestType;
|
|
Datagram[ATP_ZIP_CMD_OFF+1] = 0;
|
|
|
|
PUTSHORT2SHORT(Datagram + ATP_ZIP_START_INDEX_OFF, pZci->zci_ZoneCount+1);
|
|
|
|
// Set the length in the buffer descriptor.
|
|
AtalkSetSizeOfBuffDescData(pBuffDesc, ZIP_GETZONELIST_DDPSIZE);
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipSendPacket: Sending the packet along\n"));
|
|
|
|
DestAddr = pZci->zci_Router;
|
|
SendInfo.sc_TransmitCompletion = atalkZipSendComplete;
|
|
SendInfo.sc_Ctx1 = pBuffDesc;
|
|
// SendInfo.sc_Ctx2 = NULL;
|
|
// SendInfo.sc_Ctx3 = NULL;
|
|
if (!ATALK_SUCCESS(Status = AtalkDdpSend(pZci->zci_pDdpAddr,
|
|
&DestAddr,
|
|
DDPPROTO_ATP,
|
|
FALSE,
|
|
pBuffDesc,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
&SendInfo)))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipSendPacket: AtalkDdpSend %ld\n", Status));
|
|
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
if (AtalkTimerCancelEvent(&pZci->zci_Timer, NULL))
|
|
{
|
|
atalkZipDereferenceZci(pZci);
|
|
}
|
|
}
|
|
else Status = ATALK_PENDING;
|
|
return Status;
|
|
}
|
|
|
|
|
|
/*** atalkZipDereferenceZci
|
|
*
|
|
*/
|
|
LOCAL VOID
|
|
atalkZipDereferenceZci(
|
|
IN PZIPCOMPLETIONINFO pZci
|
|
)
|
|
{
|
|
BOOLEAN Done;
|
|
KIRQL OldIrql;
|
|
|
|
ASSERT(VALID_ZCI(pZci));
|
|
|
|
ACQUIRE_SPIN_LOCK(&pZci->zci_Lock, &OldIrql);
|
|
Done = (--(pZci->zci_RefCount) == 0);
|
|
RELEASE_SPIN_LOCK(&pZci->zci_Lock, OldIrql);
|
|
|
|
if (Done)
|
|
{
|
|
if (pZci->zci_pDdpAddr != NULL)
|
|
AtalkDdpCloseAddress(pZci->zci_pDdpAddr, NULL, NULL);
|
|
(*pZci->zci_pActReq->ar_Completion)(pZci->zci_FinalStatus, pZci->zci_pActReq);
|
|
|
|
// Unlock the Zip stuff back again, if there are no more pending zip operations
|
|
AtalkUnlockZipIfNecessary();
|
|
AtalkFreeMemory(pZci);
|
|
}
|
|
}
|
|
|
|
|
|
// We do not want to send too many queries per invocation of the timer. This is to avoid
|
|
// spending too much time within the timer Dpc and also using up all of the Ndis packets
|
|
// and buffers during this.
|
|
#define MAX_QUERIES_PER_INVOCATION 75
|
|
|
|
// Structure used by the atalkZipQueryTimer routine
|
|
typedef struct _QueryTimerData
|
|
{
|
|
struct _QueryTimerData * qtd_Next;
|
|
BOOLEAN qtd_SkipThis;
|
|
PBUFFER_DESC qtd_pBuffDesc;
|
|
ATALK_ADDR qtd_DstAddr;
|
|
PDDP_ADDROBJ qtd_pDdpAddr;
|
|
} QTD, *PQTD;
|
|
|
|
/*** atalkZipQueryTimer
|
|
*
|
|
* When we are a router and if any of our RTEs do not have a valid zone list, we send
|
|
* out queries to other routers who do.
|
|
*/
|
|
LOCAL LONG FASTCALL
|
|
atalkZipQueryTimer(
|
|
IN PTIMERLIST pContext,
|
|
IN BOOLEAN TimerShuttingDown
|
|
)
|
|
{
|
|
PPORT_DESCRIPTOR pPortDesc;
|
|
ATALK_ADDR SrcAddr;
|
|
PRTE pRte;
|
|
PBYTE Datagram;
|
|
PQTD pQtd, pQtdStart = NULL, *ppQtd = &pQtdStart;
|
|
ATALK_ERROR Status;
|
|
int i, j;
|
|
SEND_COMPL_INFO SendInfo;
|
|
|
|
if (TimerShuttingDown)
|
|
return ATALK_TIMER_NO_REQUEUE;
|
|
|
|
// Go through the routing tables and send out a query to any network
|
|
// that we do not know the zone name of
|
|
ACQUIRE_SPIN_LOCK_DPC(&AtalkRteLock)
|
|
for (i = 0, j = 0;
|
|
(i < NUM_RTMP_HASH_BUCKETS) && (j <= MAX_QUERIES_PER_INVOCATION);
|
|
i++)
|
|
{
|
|
for (pRte = AtalkRoutingTable[i]; pRte != NULL; pRte = pRte->rte_Next)
|
|
{
|
|
if (pRte->rte_Flags & RTE_ZONELIST_VALID)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// If login is to restrict access to zones over dial up connection
|
|
// put restrictions here
|
|
if (pRte->rte_PortDesc == RasPortDesc)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Up the count of # of datagrams used. Do need exceed max.
|
|
if (++j >= MAX_QUERIES_PER_INVOCATION)
|
|
break;
|
|
|
|
if (((pQtd = AtalkAllocMemory(sizeof(QTD))) == NULL) ||
|
|
((pQtd->qtd_pBuffDesc = AtalkAllocBuffDesc(NULL,
|
|
ZIP_ONEZONEQUERY_DDPSIZE,
|
|
BD_CHAR_BUFFER | BD_FREE_BUFFER)) == NULL))
|
|
{
|
|
if (pQtd != NULL)
|
|
AtalkFreeMemory(pQtd);
|
|
break;
|
|
}
|
|
*ppQtd = pQtd;
|
|
pQtd->qtd_Next = NULL;
|
|
ppQtd = &pQtd->qtd_Next;
|
|
pQtd->qtd_SkipThis = FALSE;
|
|
Datagram = pQtd->qtd_pBuffDesc->bd_CharBuffer;
|
|
|
|
// Build the datagram and send it on its way
|
|
Datagram[ZIP_CMD_OFF] = ZIP_QUERY;
|
|
Datagram[ZIP_NW_CNT_OFF] = 1;
|
|
PUTSHORT2SHORT(Datagram+ZIP_FIRST_NET_OFF,
|
|
pRte->rte_NwRange.anr_FirstNetwork);
|
|
|
|
// Compute the source and destination
|
|
SrcAddr.ata_Network = pRte->rte_PortDesc->pd_ARouter.atn_Network;
|
|
SrcAddr.ata_Node = pRte->rte_PortDesc->pd_ARouter.atn_Node;
|
|
SrcAddr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
pQtd->qtd_DstAddr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
|
|
if (pRte->rte_NumHops == 0)
|
|
{
|
|
pQtd->qtd_DstAddr = SrcAddr;
|
|
}
|
|
else
|
|
{
|
|
pQtd->qtd_DstAddr.ata_Network = pRte->rte_NextRouter.atn_Network;
|
|
pQtd->qtd_DstAddr.ata_Node = pRte->rte_NextRouter.atn_Node;
|
|
}
|
|
|
|
// Map source address to the ddp address object (open socket)
|
|
AtalkDdpReferenceByAddr(pRte->rte_PortDesc,
|
|
&SrcAddr,
|
|
&pQtd->qtd_pDdpAddr,
|
|
&Status);
|
|
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipQueryTimer: DdpRefByAddr failed for %d.%d\n",
|
|
SrcAddr.ata_Network, SrcAddr.ata_Node));
|
|
pQtd->qtd_pDdpAddr = NULL;
|
|
pQtd->qtd_SkipThis = TRUE;
|
|
}
|
|
}
|
|
}
|
|
RELEASE_SPIN_LOCK_DPC(&AtalkRteLock);
|
|
|
|
// We have a bunch of datagrams ready to be fired off.
|
|
// Make it so.
|
|
SendInfo.sc_TransmitCompletion = atalkZipSendComplete;
|
|
// SendInfo.sc_Ctx2 = NULL;
|
|
// SendInfo.sc_Ctx3 = NULL;
|
|
for (pQtd = pQtdStart; pQtd != NULL; pQtd = pQtdStart)
|
|
{
|
|
pQtdStart = pQtd->qtd_Next;
|
|
|
|
// Set the length in the buffer descriptor.
|
|
AtalkSetSizeOfBuffDescData(pQtd->qtd_pBuffDesc, ZIP_ONEZONEQUERY_DDPSIZE);
|
|
|
|
SendInfo.sc_Ctx1 = pQtd->qtd_pBuffDesc;
|
|
if (pQtd->qtd_SkipThis ||
|
|
!ATALK_SUCCESS(AtalkDdpSend(pQtd->qtd_pDdpAddr,
|
|
&pQtd->qtd_DstAddr,
|
|
DDPPROTO_ZIP,
|
|
FALSE,
|
|
pQtd->qtd_pBuffDesc,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
&SendInfo)))
|
|
{
|
|
AtalkFreeBuffDesc(pQtd->qtd_pBuffDesc);
|
|
}
|
|
|
|
if (pQtd->qtd_pDdpAddr != NULL)
|
|
AtalkDdpDereferenceDpc(pQtd->qtd_pDdpAddr);
|
|
AtalkFreeMemory(pQtd);
|
|
}
|
|
|
|
return ATALK_TIMER_REQUEUE;
|
|
}
|
|
|
|
|
|
/*** atalkZipGetZoneListForPort
|
|
*
|
|
*/
|
|
LOCAL BOOLEAN
|
|
atalkZipGetZoneListForPort(
|
|
IN PPORT_DESCRIPTOR pPortDesc
|
|
)
|
|
{
|
|
PRTE pRte;
|
|
PBUFFER_DESC pBuffDesc = NULL;
|
|
ATALK_ADDR SrcAddr, DstAddr;
|
|
ATALK_ERROR Status;
|
|
KIRQL OldIrql;
|
|
int NumReqs = 0;
|
|
BOOLEAN RetCode = FALSE;
|
|
BYTE MulticastAddr[ELAP_ADDR_LEN];
|
|
SEND_COMPL_INFO SendInfo;
|
|
|
|
ASSERT (KeGetCurrentIrql() == LOW_LEVEL);
|
|
|
|
// Similar to RTMP finding out the network number attached to port, our
|
|
// task is to find out the zone list of the network attached to a
|
|
// particular port. We too don't want to mess up a working AppleTalk
|
|
// internet. So, spend a little while doing zone queries to see if the
|
|
// network already has a zone list -- if we find one, use it; else, we
|
|
// had better be a seed router.
|
|
|
|
// Set source and destination address
|
|
SrcAddr.ata_Node = pPortDesc->pd_ARouter.atn_Node;
|
|
SrcAddr.ata_Network = pPortDesc->pd_ARouter.atn_Network;
|
|
SrcAddr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
|
|
DstAddr.ata_Network = CABLEWIDE_BROADCAST_NETWORK;
|
|
DstAddr.ata_Node = ATALK_BROADCAST_NODE;
|
|
DstAddr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
|
|
if ((pRte = AtalkRtmpReferenceRte(pPortDesc->pd_NetworkRange.anr_FirstNetwork)) == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipGetZoneListForPort: Could not reference Rte for nwrange on port\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
// Blast a few queries and see if anybody knows our zone-name
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
pPortDesc->pd_Flags |= PD_FINDING_DEFAULT_ZONE;
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
|
|
SendInfo.sc_TransmitCompletion = atalkZipSendComplete;
|
|
// SendInfo.sc_Ctx2 = NULL;
|
|
// SendInfo.sc_Ctx3 = NULL;
|
|
|
|
while ((NumReqs < (ZIP_NUM_QUERIES * ZIP_NUM_RETRIES)) &&
|
|
!(pRte->rte_Flags & RTE_ZONELIST_VALID))
|
|
{
|
|
if ((NumReqs % ZIP_NUM_RETRIES) == 0)
|
|
{
|
|
if ((pBuffDesc = AtalkAllocBuffDesc(NULL, ZIP_ONEZONEQUERY_DDPSIZE,
|
|
BD_CHAR_BUFFER | BD_FREE_BUFFER)) == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pBuffDesc->bd_CharBuffer[ZIP_CMD_OFF] = ZIP_QUERY;
|
|
pBuffDesc->bd_CharBuffer[ZIP_NW_CNT_OFF] = 1;
|
|
PUTSHORT2SHORT(pBuffDesc->bd_CharBuffer + ZIP_FIRST_NET_OFF,
|
|
pPortDesc->pd_NetworkRange.anr_FirstNetwork);
|
|
|
|
// Set the length in the buffer descriptor.
|
|
AtalkSetSizeOfBuffDescData(pBuffDesc, ZIP_ONEZONEQUERY_DDPSIZE);
|
|
|
|
SendInfo.sc_Ctx1 = pBuffDesc;
|
|
Status = AtalkDdpTransmit(pPortDesc,
|
|
&SrcAddr,
|
|
&DstAddr,
|
|
DDPPROTO_ZIP,
|
|
pBuffDesc,
|
|
NULL,
|
|
0,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
&SendInfo);
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipGetZoneListForPort: AtalkDdpTransmit %ld\n", Status));
|
|
break;
|
|
}
|
|
pBuffDesc = NULL;
|
|
}
|
|
NumReqs++;
|
|
AtalkSleep(ZIP_QUERY_WAIT);
|
|
}
|
|
|
|
// We either got an answer or we did not. In the latter case we should
|
|
// be seeding.
|
|
do
|
|
{
|
|
if (pRte->rte_Flags & RTE_ZONELIST_VALID)
|
|
{
|
|
// We got an answer. The valid zone list is in the routing table
|
|
// Move it to the port descriptor
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
ACQUIRE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipGetZoneListForPort: Moving ZoneList from Rte to Port %Z\n",
|
|
&pPortDesc->pd_AdapterKey));
|
|
|
|
pPortDesc->pd_ZoneList = AtalkZoneCopyList(pRte->rte_ZoneList);
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&pRte->rte_Lock);
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
if (pPortDesc->pd_ZoneList == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipGetZoneListForPort: Failed to Move ZoneList from Rte to Port\n"));
|
|
break;
|
|
}
|
|
|
|
// If this is an extended network, we should already have "ThisZone"
|
|
// set (due to GetNetInfo's when we allocated this node), if not
|
|
// find out the true default zone
|
|
|
|
if (EXT_NET(pPortDesc))
|
|
{
|
|
PDDP_ADDROBJ pDdpAddr = NULL;
|
|
ATALK_ADDR Addr;
|
|
ATALK_ERROR Status;
|
|
|
|
// The router's Zip packet handler doesn't want to be told
|
|
// about zones (it thinks it knows), so it ignores
|
|
// NetInfoReplies. Switch back to the non-router Zip handler
|
|
// while we do a GetNetworkInfoForNode
|
|
Addr.ata_Node = pPortDesc->pd_ARouter.atn_Node;
|
|
Addr.ata_Network = pPortDesc->pd_ARouter.atn_Network;
|
|
Addr.ata_Socket = ZONESINFORMATION_SOCKET;
|
|
AtalkDdpReferenceByAddr(pPortDesc, &Addr, &pDdpAddr, &Status);
|
|
|
|
if (!ATALK_SUCCESS(Status))
|
|
{
|
|
DBGPRINT(DBG_COMP_RTMP, DBG_LEVEL_ERR,
|
|
("atalkZipGetZoneListForPort: AtalkDdpRefByAddr %ld for %d.%d\n",
|
|
Status, Addr.ata_Network, Addr.ata_Node));
|
|
break;
|
|
}
|
|
|
|
AtalkDdpNewHandlerForSocket(pDdpAddr,
|
|
AtalkZipPacketIn,
|
|
pPortDesc);
|
|
if ((!(pPortDesc->pd_Flags & PD_VALID_DESIRED_ZONE) &&
|
|
!AtalkZipGetNetworkInfoForNode(pPortDesc,
|
|
&pPortDesc->pd_ARouter,
|
|
FALSE)) ||
|
|
!AtalkZipGetNetworkInfoForNode(pPortDesc,
|
|
&pPortDesc->pd_ARouter,
|
|
TRUE))
|
|
{
|
|
AtalkDdpDereference(pDdpAddr);
|
|
break;
|
|
}
|
|
|
|
// Switch back the handler to the router's version
|
|
AtalkDdpNewHandlerForSocket(pDdpAddr,
|
|
AtalkZipPacketInRouter,
|
|
pPortDesc);
|
|
|
|
AtalkDdpDereference(pDdpAddr);
|
|
|
|
// The default zone had better be on the list we just
|
|
// received
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
if (!AtalkZoneOnList(pPortDesc->pd_DefaultZone,
|
|
pPortDesc->pd_ZoneList) ||
|
|
!AtalkZoneOnList(pPortDesc->pd_DesiredZone,
|
|
pPortDesc->pd_ZoneList))
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipGetZoneListForPort: Ext port, Default/Desired zone not on list\n"));
|
|
|
|
}
|
|
else RetCode = TRUE;
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
}
|
|
else
|
|
{
|
|
// On non-extended network, the one entry on the zone list
|
|
// should also be "ThisZone"
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
if (pPortDesc->pd_DesiredZone != NULL)
|
|
AtalkZoneDereference(pPortDesc->pd_DesiredZone);
|
|
AtalkZoneReferenceByPtr(pPortDesc->pd_DesiredZone =
|
|
pPortDesc->pd_ZoneList->zl_pZone);
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
RetCode = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// We did not get an answer. We had better be able to seed. There is
|
|
// a chance that we got "ThisZone" set when allocating our node and
|
|
// whatever router told us that went down before we could ask for the
|
|
// zone list - so de-allocate the multicast address, if any first
|
|
if ((pPortDesc->pd_Flags & (PD_EXT_NET | PD_VALID_DESIRED_ZONE)) ==
|
|
(PD_EXT_NET | PD_VALID_DESIRED_ZONE))
|
|
{
|
|
if (!AtalkFixedCompareCaseSensitive(pPortDesc->pd_ZoneMulticastAddr,
|
|
pPortDesc->pd_BroadcastAddrLen,
|
|
pPortDesc->pd_BroadcastAddr,
|
|
pPortDesc->pd_BroadcastAddrLen))
|
|
(*pPortDesc->pd_RemoveMulticastAddr)(pPortDesc,
|
|
pPortDesc->pd_ZoneMulticastAddr,
|
|
FALSE,
|
|
NULL,
|
|
NULL);
|
|
}
|
|
|
|
// Now we better know enough to seed
|
|
if (pPortDesc->pd_InitialZoneList == NULL)
|
|
{
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipGetZoneListForPort: %sExt port, NULL InitialZoneList\n",
|
|
EXT_NET(pPortDesc) ? "" : "Non"));
|
|
break;
|
|
}
|
|
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipGetZoneListForPort: Moving Initial ZoneList to Current on port %Z\n",
|
|
&pPortDesc->pd_AdapterKey));
|
|
|
|
pPortDesc->pd_ZoneList = AtalkZoneCopyList(pPortDesc->pd_InitialZoneList);
|
|
|
|
if (EXT_NET(pPortDesc))
|
|
{
|
|
// We need to seed the default zone too
|
|
AtalkZoneReferenceByPtr(pPortDesc->pd_DefaultZone =
|
|
pPortDesc->pd_InitialDefaultZone);
|
|
pPortDesc->pd_Flags |= PD_VALID_DEFAULT_ZONE;
|
|
if (pPortDesc->pd_InitialDesiredZone != NULL)
|
|
{
|
|
AtalkZoneReferenceByPtr(pPortDesc->pd_DesiredZone =
|
|
pPortDesc->pd_InitialDesiredZone);
|
|
}
|
|
else
|
|
{
|
|
AtalkZoneReferenceByPtr(pPortDesc->pd_DesiredZone =
|
|
pPortDesc->pd_InitialDefaultZone);
|
|
}
|
|
|
|
// Finally set the zone multicast address
|
|
AtalkZipMulticastAddrForZone(pPortDesc,
|
|
pPortDesc->pd_DesiredZone->zn_Zone,
|
|
pPortDesc->pd_DesiredZone->zn_ZoneLen,
|
|
MulticastAddr);
|
|
|
|
if (!AtalkFixedCompareCaseSensitive(MulticastAddr,
|
|
pPortDesc->pd_BroadcastAddrLen,
|
|
pPortDesc->pd_BroadcastAddr,
|
|
pPortDesc->pd_BroadcastAddrLen))
|
|
{
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
(*pPortDesc->pd_AddMulticastAddr)(pPortDesc,
|
|
MulticastAddr,
|
|
FALSE,
|
|
NULL,
|
|
NULL);
|
|
ACQUIRE_SPIN_LOCK(&pPortDesc->pd_Lock, &OldIrql);
|
|
}
|
|
RtlCopyMemory(pPortDesc->pd_ZoneMulticastAddr,
|
|
MulticastAddr,
|
|
pPortDesc->pd_BroadcastAddrLen);
|
|
}
|
|
else
|
|
{
|
|
// On non-extended networks, this (desired/default)should be the
|
|
// only one on zone-list
|
|
AtalkZoneReferenceByPtr(pPortDesc->pd_DesiredZone =
|
|
pPortDesc->pd_ZoneList->zl_pZone);
|
|
}
|
|
pPortDesc->pd_Flags |= PD_VALID_DESIRED_ZONE;
|
|
RELEASE_SPIN_LOCK(&pPortDesc->pd_Lock, OldIrql);
|
|
RetCode = TRUE;
|
|
} while (FALSE);
|
|
|
|
AtalkRtmpDereferenceRte(pRte, FALSE);
|
|
if (pBuffDesc != NULL)
|
|
{
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
}
|
|
return(RetCode);
|
|
}
|
|
|
|
|
|
|
|
|
|
/*** AtalkZipZoneReferenceByName
|
|
*
|
|
*/
|
|
PZONE
|
|
AtalkZoneReferenceByName(
|
|
IN PBYTE ZoneName,
|
|
IN BYTE ZoneLen
|
|
)
|
|
{
|
|
PZONE pZone;
|
|
BYTE Len;
|
|
KIRQL OldIrql;
|
|
ULONG i, Hash;
|
|
|
|
for (i = 0, Hash = 0, Len = ZoneLen;
|
|
Len > 0;
|
|
Len --, i++)
|
|
{
|
|
Hash <<= 1;
|
|
Hash += AtalkUpCaseTable[ZoneName[i]];
|
|
}
|
|
|
|
Hash %= NUM_ZONES_HASH_BUCKETS;
|
|
|
|
ACQUIRE_SPIN_LOCK(&AtalkZoneLock, &OldIrql);
|
|
|
|
for (pZone = AtalkZonesTable[Hash];
|
|
pZone != NULL;
|
|
pZone = pZone->zn_Next)
|
|
{
|
|
if (AtalkFixedCompareCaseInsensitive(ZoneName,
|
|
ZoneLen,
|
|
pZone->zn_Zone,
|
|
pZone->zn_ZoneLen))
|
|
{
|
|
pZone->zn_RefCount ++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pZone == NULL)
|
|
{
|
|
if ((pZone = (PZONE)AtalkAllocMemory(sizeof(ZONE) + ZoneLen)) != NULL)
|
|
{
|
|
pZone->zn_RefCount = 1;
|
|
pZone->zn_ZoneLen = ZoneLen;
|
|
RtlCopyMemory(pZone->zn_Zone, ZoneName, ZoneLen);
|
|
pZone->zn_Zone[ZoneLen] = 0;
|
|
AtalkLinkDoubleAtHead(AtalkZonesTable[Hash],
|
|
pZone,
|
|
zn_Next,
|
|
zn_Prev);
|
|
}
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&AtalkZoneLock, OldIrql);
|
|
return(pZone);
|
|
}
|
|
|
|
|
|
/*** AtalkZipZoneReferenceByPtr
|
|
*
|
|
*/
|
|
VOID
|
|
AtalkZoneReferenceByPtr(
|
|
IN PZONE pZone
|
|
)
|
|
{
|
|
KIRQL OldIrql;
|
|
|
|
ACQUIRE_SPIN_LOCK(&AtalkZoneLock, &OldIrql);
|
|
|
|
pZone->zn_RefCount++;
|
|
|
|
RELEASE_SPIN_LOCK(&AtalkZoneLock, OldIrql);
|
|
}
|
|
|
|
|
|
/*** AtalkZoneDereference
|
|
*
|
|
*/
|
|
VOID
|
|
AtalkZoneDereference(
|
|
IN PZONE pZone
|
|
)
|
|
{
|
|
KIRQL OldIrql;
|
|
|
|
ACQUIRE_SPIN_LOCK(&AtalkZoneLock, &OldIrql);
|
|
|
|
if (--pZone->zn_RefCount == 0)
|
|
{
|
|
AtalkUnlinkDouble(pZone, zn_Next, zn_Prev);
|
|
AtalkFreeMemory(pZone);
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK(&AtalkZoneLock, OldIrql);
|
|
}
|
|
|
|
|
|
/*** AtalkZipZoneFreeList
|
|
*
|
|
*/
|
|
VOID
|
|
AtalkZoneFreeList(
|
|
IN PZONE_LIST pZoneList
|
|
)
|
|
{
|
|
PZONE_LIST pNextZone;
|
|
|
|
for (; pZoneList != NULL; pZoneList = pNextZone)
|
|
{
|
|
pNextZone = pZoneList->zl_Next;
|
|
AtalkZoneDereference(pZoneList->zl_pZone);
|
|
AtalkFreeMemory(pZoneList);
|
|
}
|
|
}
|
|
|
|
|
|
/*** AtalkZoneNameOnList
|
|
*
|
|
*/
|
|
BOOLEAN
|
|
AtalkZoneNameOnList(
|
|
IN PBYTE ZoneName,
|
|
IN BYTE ZoneLen,
|
|
IN PZONE_LIST pZoneList
|
|
)
|
|
{
|
|
for ( ; pZoneList != NULL; pZoneList = pZoneList->zl_Next)
|
|
if (AtalkFixedCompareCaseInsensitive(pZoneList->zl_pZone->zn_Zone,
|
|
pZoneList->zl_pZone->zn_ZoneLen,
|
|
ZoneName, ZoneLen))
|
|
return(TRUE);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
/*** AtalkZipZoneOnList
|
|
*
|
|
*/
|
|
BOOLEAN
|
|
AtalkZoneOnList(
|
|
IN PZONE pZone,
|
|
IN PZONE_LIST pZoneList
|
|
)
|
|
{
|
|
for ( ; pZoneList != NULL; pZoneList = pZoneList->zl_Next)
|
|
if (pZoneList->zl_pZone == pZone)
|
|
return(TRUE);
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
/*** AtalkZipZone
|
|
*
|
|
*/
|
|
ULONG
|
|
AtalkZoneNumOnList(
|
|
IN PZONE_LIST pZoneList
|
|
)
|
|
{
|
|
ULONG Cnt;
|
|
|
|
for (Cnt = 0; pZoneList != NULL; pZoneList = pZoneList->zl_Next)
|
|
Cnt++;
|
|
return Cnt;
|
|
}
|
|
|
|
|
|
/*** AtalkZipZoneAddToList
|
|
*
|
|
*/
|
|
PZONE_LIST
|
|
AtalkZoneAddToList(
|
|
IN PZONE_LIST pZoneList,
|
|
IN PBYTE ZoneName,
|
|
IN BYTE ZoneLen
|
|
)
|
|
{
|
|
PZONE_LIST pNewZoneList;
|
|
PZONE pZone;
|
|
|
|
// Get memory for a new ZoneList node.
|
|
pNewZoneList = (PZONE_LIST)AtalkAllocMemory(sizeof(ZONE_LIST));
|
|
|
|
if (pNewZoneList != NULL)
|
|
{
|
|
if ((pZone = AtalkZoneReferenceByName(ZoneName, ZoneLen)) != NULL)
|
|
{
|
|
pNewZoneList->zl_Next = pZoneList;
|
|
pNewZoneList->zl_pZone = pZone;
|
|
}
|
|
else
|
|
{
|
|
AtalkZoneFreeList(pNewZoneList);
|
|
pNewZoneList = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AtalkZoneFreeList(pZoneList);
|
|
}
|
|
|
|
return(pNewZoneList);
|
|
}
|
|
|
|
|
|
/*** AtalkZipZoneCopyList
|
|
*
|
|
*/
|
|
PZONE_LIST
|
|
AtalkZoneCopyList(
|
|
IN PZONE_LIST pZoneList
|
|
)
|
|
{
|
|
PZONE_LIST pNewZoneList,
|
|
pZoneListStart = NULL,
|
|
*ppZoneList = &pZoneListStart;
|
|
|
|
for (; pZoneList != NULL; pZoneList = pZoneList = pZoneList->zl_Next)
|
|
{
|
|
pNewZoneList = AtalkAllocMemory(sizeof(ZONE_LIST));
|
|
if (pNewZoneList == NULL)
|
|
{
|
|
break;
|
|
}
|
|
pNewZoneList->zl_Next = NULL;
|
|
pNewZoneList->zl_pZone = pZoneList->zl_pZone;
|
|
*ppZoneList = pNewZoneList;
|
|
ppZoneList = &pNewZoneList->zl_Next;
|
|
AtalkZoneReferenceByPtr(pNewZoneList->zl_pZone);
|
|
}
|
|
if (pNewZoneList == NULL)
|
|
{
|
|
AtalkZoneFreeList(pZoneListStart);
|
|
}
|
|
return(pZoneListStart);
|
|
}
|
|
|
|
|
|
/*** atalkZipSendComplete
|
|
*
|
|
*/
|
|
VOID FASTCALL
|
|
atalkZipSendComplete(
|
|
IN NDIS_STATUS Status,
|
|
IN PSEND_COMPL_INFO pSendInfo
|
|
)
|
|
{
|
|
PBUFFER_DESC pBuffDesc = (PBUFFER_DESC)(pSendInfo->sc_Ctx1);
|
|
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_INFO,
|
|
("atalkZipSendComplete: Freeing BuffDesc %lx\n", pBuffDesc));
|
|
if (!ATALK_SUCCESS(Status))
|
|
DBGPRINT(DBG_COMP_ZIP, DBG_LEVEL_ERR,
|
|
("atalkZipSendComplete: Failed %lx, pBuffDesc %lx\n",
|
|
Status, pBuffDesc));
|
|
|
|
AtalkFreeBuffDesc(pBuffDesc);
|
|
}
|
|
|
|
#if DBG
|
|
VOID
|
|
AtalkZoneDumpTable(
|
|
VOID
|
|
)
|
|
{
|
|
int i;
|
|
PZONE pZone;
|
|
|
|
ACQUIRE_SPIN_LOCK_DPC(&AtalkZoneLock);
|
|
|
|
DBGPRINT(DBG_COMP_DUMP, DBG_LEVEL_FATAL, ("ZONETABLE: \n"));
|
|
for (i = 0; i < NUM_ZONES_HASH_BUCKETS; i ++)
|
|
{
|
|
for (pZone = AtalkZonesTable[i]; pZone != NULL; pZone = pZone->zn_Next)
|
|
{
|
|
DBGPRINT(DBG_COMP_DUMP, DBG_LEVEL_FATAL,
|
|
("\t\t%s\n", pZone->zn_Zone));
|
|
}
|
|
}
|
|
|
|
RELEASE_SPIN_LOCK_DPC(&AtalkZoneLock);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|