neighbor.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_NEIGHBOR_PACKET
struct	NEIGHBOR_CACHE_TABLE
struct	NEIGHBOR_CACHE_ENTRY

Macros
#define	NB_HASHMASK   0xF /* Hash mask for neighbor cache */
#define	NUD_INCOMPLETE   0x01
#define	NUD_PERMANENT   0x02
#define	NUD_STALE   0x04
#define	ARP_INCOMPLETE_TIMEOUT   3
#define	ARP_RATE   900
#define	ARP_COMPLETE_TIMEOUT   (ARP_RATE + 9)
#define	ARP_TIMEOUT_RETRANSMISSION   3

Typedefs
typedef VOID(*	PNEIGHBOR_PACKET_COMPLETE) (PVOID Context, PNDIS_PACKET Packet, NDIS_STATUS Status)
typedef struct _NEIGHBOR_PACKET	NEIGHBOR_PACKET
typedef struct _NEIGHBOR_PACKET *	PNEIGHBOR_PACKET
typedef struct NEIGHBOR_CACHE_TABLE	NEIGHBOR_CACHE_TABLE
typedef struct NEIGHBOR_CACHE_TABLE *	PNEIGHBOR_CACHE_TABLE
typedef struct NEIGHBOR_CACHE_ENTRY	NEIGHBOR_CACHE_ENTRY
typedef struct NEIGHBOR_CACHE_ENTRY *	PNEIGHBOR_CACHE_ENTRY

Functions
VOID	NBTimeout (VOID)
VOID	NBStartup (VOID)
VOID	NBShutdown (VOID)
VOID	NBSendSolicit (PNEIGHBOR_CACHE_ENTRY NCE)
PNEIGHBOR_CACHE_ENTRY	NBAddNeighbor (PIP_INTERFACE Interface, PIP_ADDRESS Address, PVOID LinkAddress, UINT LinkAddressLength, UCHAR Type, UINT EventTimer)
VOID	NBUpdateNeighbor (PNEIGHBOR_CACHE_ENTRY NCE, PVOID LinkAddress, UCHAR State)
PNEIGHBOR_CACHE_ENTRY	NBLocateNeighbor (PIP_ADDRESS Address, PIP_INTERFACE Interface)
PNEIGHBOR_CACHE_ENTRY	NBFindOrCreateNeighbor (PIP_INTERFACE Interface, PIP_ADDRESS Address, BOOLEAN NoTimeout)
BOOLEAN	NBQueuePacket (PNEIGHBOR_CACHE_ENTRY NCE, PNDIS_PACKET NdisPacket, PNEIGHBOR_PACKET_COMPLETE PacketComplete, PVOID PacketContext)
VOID	NBRemoveNeighbor (PNEIGHBOR_CACHE_ENTRY NCE)
ULONG	NBCopyNeighbors (PIP_INTERFACE Interface, PIPARP_ENTRY ArpTable)
VOID	NBResetNeighborTimeout (PIP_ADDRESS Address)
VOID	NBDestroyNeighborsForInterface (PIP_INTERFACE Interface)

Variables
NEIGHBOR_CACHE_TABLE	NeighborCache [NB_HASHMASK+1]

Macro Definition Documentation

ARP_COMPLETE_TIMEOUT

#define ARP_COMPLETE_TIMEOUT   (ARP_RATE + 9)

Definition at line 52 of file neighbor.h.

ARP_INCOMPLETE_TIMEOUT

#define ARP_INCOMPLETE_TIMEOUT   3

Definition at line 46 of file neighbor.h.

ARP_RATE

#define ARP_RATE   900

Definition at line 49 of file neighbor.h.

ARP_TIMEOUT_RETRANSMISSION

#define ARP_TIMEOUT_RETRANSMISSION   3

Definition at line 55 of file neighbor.h.

NB_HASHMASK

#define NB_HASHMASK   0xF /* Hash mask for neighbor cache */

Definition at line 10 of file neighbor.h.

NUD_INCOMPLETE

#define NUD_INCOMPLETE   0x01

Definition at line 41 of file neighbor.h.

NUD_PERMANENT

#define NUD_PERMANENT   0x02

Definition at line 42 of file neighbor.h.

NUD_STALE

#define NUD_STALE   0x04

Definition at line 43 of file neighbor.h.

Typedef Documentation

NEIGHBOR_CACHE_ENTRY

typedef struct NEIGHBOR_CACHE_ENTRY NEIGHBOR_CACHE_ENTRY

NEIGHBOR_CACHE_TABLE

typedef struct NEIGHBOR_CACHE_TABLE NEIGHBOR_CACHE_TABLE

NEIGHBOR_PACKET

typedef struct _NEIGHBOR_PACKET NEIGHBOR_PACKET

PNEIGHBOR_CACHE_ENTRY

typedef struct NEIGHBOR_CACHE_ENTRY * PNEIGHBOR_CACHE_ENTRY

PNEIGHBOR_CACHE_TABLE

typedef struct NEIGHBOR_CACHE_TABLE * PNEIGHBOR_CACHE_TABLE

PNEIGHBOR_PACKET

typedef struct _NEIGHBOR_PACKET * PNEIGHBOR_PACKET

PNEIGHBOR_PACKET_COMPLETE

typedef VOID(* PNEIGHBOR_PACKET_COMPLETE) (PVOID Context, PNDIS_PACKET Packet, NDIS_STATUS Status)

Definition at line 12 of file neighbor.h.

Function Documentation

NBAddNeighbor()

PNEIGHBOR_CACHE_ENTRY NBAddNeighbor	(	PIP_INTERFACE	Interface,
		PIP_ADDRESS	Address,
		PVOID	LinkAddress,
		UINT	LinkAddressLength,
		UCHAR	Type,
		UINT	EventTimer
	)

Definition at line 273 of file neighbor.c.

{
  PNEIGHBOR_CACHE_ENTRY NCE;
  ULONG HashValue;
  KIRQL OldIrql;
  IP_ADDRESS InternalAddress;
 
  TI_DbgPrint
      (DEBUG_NCACHE,
       ("Called. Interface (0x%X)  Address (0x%X)  "
    "LinkAddress (0x%X)  LinkAddressLength (%d)  State (0x%X)\n",
    Interface, Address, LinkAddress, LinkAddressLength, State));
 
  NCE = ExAllocatePoolWithTag
      (NonPagedPool, sizeof(NEIGHBOR_CACHE_ENTRY) + LinkAddressLength,
       NCE_TAG);
  if (NCE == NULL)
    {
      TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
      return NULL;
    }
 
  RtlCopyMemory(&InternalAddress, Address, sizeof(*Address));
 
  /* Map 127.x.x.x adresses to the loopback address (127.0.0.1) */
  if ((InternalAddress.Address.IPv4Address & LOOPBACK_ADDRMASK_IPv4) == (LOOPBACK_ADDRESS_IPv4 & LOOPBACK_ADDRMASK_IPv4))
    InternalAddress.Address.IPv4Address = LOOPBACK_ADDRESS_IPv4;
 
  NCE->Interface = Interface;
  NCE->Address = InternalAddress;
  NCE->LinkAddressLength = LinkAddressLength;
  NCE->LinkAddress = (PVOID)&NCE[1];
  if( LinkAddress )
      RtlCopyMemory(NCE->LinkAddress, LinkAddress, LinkAddressLength);
  else
      memset(NCE->LinkAddress, 0xff, LinkAddressLength);
  NCE->State = State;
  NCE->EventTimer = EventTimer;
  NCE->EventCount = 0;
  InitializeListHead( &NCE->PacketQueue );
 
  TI_DbgPrint(MID_TRACE,("NCE: %x\n", NCE));
 
  HashValue = *(PULONG)&InternalAddress.Address;
  HashValue ^= HashValue >> 16;
  HashValue ^= HashValue >> 8;
  HashValue ^= HashValue >> 4;
  HashValue &= NB_HASHMASK;
 
  TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
  NCE->Next = NeighborCache[HashValue].Cache;
  NeighborCache[HashValue].Cache = NCE;
 
  TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
 
  return NCE;
}

Referenced by ARPReceive(), InfoTdiSetArptableMIB(), IPAddInterfaceRoute(), and NBFindOrCreateNeighbor().

NBCopyNeighbors()

ULONG NBCopyNeighbors	(	PIP_INTERFACE	Interface,
		PIPARP_ENTRY	ArpTable
	)

Definition at line 649 of file neighbor.c.

{
  PNEIGHBOR_CACHE_ENTRY CurNCE;
  KIRQL OldIrql;
  UINT Size = 0, i;
 
  for (i = 0; i <= NB_HASHMASK; i++) {
      TcpipAcquireSpinLock(&NeighborCache[i].Lock, &OldIrql);
      for( CurNCE = NeighborCache[i].Cache;
       CurNCE;
       CurNCE = CurNCE->Next ) {
      if( CurNCE->Interface == Interface &&
              !AddrIsEqual( &CurNCE->Address, &CurNCE->Interface->Unicast ) ) {
          if( ArpTable ) {
          ArpTable[Size].Index = Interface->Index;
          ArpTable[Size].AddrSize = CurNCE->LinkAddressLength;
          RtlCopyMemory
              (ArpTable[Size].PhysAddr,
               CurNCE->LinkAddress,
               CurNCE->LinkAddressLength);
          ArpTable[Size].LogAddr = CurNCE->Address.Address.IPv4Address;
          if( CurNCE->State & NUD_PERMANENT )
              ArpTable[Size].Type = ARP_ENTRY_STATIC;
          else if( CurNCE->State & NUD_INCOMPLETE )
              ArpTable[Size].Type = ARP_ENTRY_INVALID;
          else
              ArpTable[Size].Type = ARP_ENTRY_DYNAMIC;
          }
          Size++;
      }
      }
      TcpipReleaseSpinLock(&NeighborCache[i].Lock, OldIrql);
  }
 
  return Size;
}

Referenced by InfoTdiQueryGetArptableMIB().

NBDestroyNeighborsForInterface()

VOID NBDestroyNeighborsForInterface

(

PIP_INTERFACE

Interface

)

Definition at line 237 of file neighbor.c.

{
    KIRQL OldIrql;
    PNEIGHBOR_CACHE_ENTRY *PrevNCE;
    PNEIGHBOR_CACHE_ENTRY NCE;
    ULONG i;
 
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
    for (i = 0; i <= NB_HASHMASK; i++)
    {
        TcpipAcquireSpinLockAtDpcLevel(&NeighborCache[i].Lock);
 
        for (PrevNCE = &NeighborCache[i].Cache;
             (NCE = *PrevNCE) != NULL;)
        {
            if (NCE->Interface == Interface)
            {
                /* Unlink and destroy the NCE */
                *PrevNCE = NCE->Next;
 
                NBFlushPacketQueue(NCE, NDIS_STATUS_REQUEST_ABORTED);
                ExFreePoolWithTag(NCE, NCE_TAG);
 
                continue;
            }
            else
            {
                PrevNCE = &NCE->Next;
            }
        }
 
        TcpipReleaseSpinLockFromDpcLevel(&NeighborCache[i].Lock);
    }
    KeLowerIrql(OldIrql);
}

Referenced by ReconfigureAdapter().

NBFindOrCreateNeighbor()

PNEIGHBOR_CACHE_ENTRY NBFindOrCreateNeighbor	(	PIP_INTERFACE	Interface,
		PIP_ADDRESS	Address,
		BOOLEAN	NoTimeout
	)

Definition at line 515 of file neighbor.c.

{
  PNEIGHBOR_CACHE_ENTRY NCE;
 
  TI_DbgPrint(DEBUG_NCACHE, ("Called. Interface (0x%X)  Address (0x%X).\n", Interface, Address));
 
  NCE = NBLocateNeighbor(Address, Interface);
  if (NCE == NULL)
    {
        TI_DbgPrint(MID_TRACE,("BCAST: %s\n", A2S(&Interface->Broadcast)));
        if( AddrIsEqual(Address, &Interface->Broadcast) ||
            AddrIsUnspecified(Address) ) {
            TI_DbgPrint(MID_TRACE,("Packet targeted at broadcast addr\n"));
            NCE = NBAddNeighbor(Interface, Address, NULL,
                                Interface->AddressLength, NUD_PERMANENT, 0);
        } else {
            NCE = NBAddNeighbor(Interface, Address, NULL,
                                Interface->AddressLength, NUD_INCOMPLETE, NoTimeout ? 0 : ARP_INCOMPLETE_TIMEOUT);
            if (!NCE) return NULL;
            NBSendSolicit(NCE);
        }
    }
 
  return NCE;
}

Referenced by RouteGetRouteToDestination(), and RouterCreateRoute().

NBLocateNeighbor()

PNEIGHBOR_CACHE_ENTRY NBLocateNeighbor	(	PIP_ADDRESS	Address,
		PIP_INTERFACE	Interface
	)

Definition at line 424 of file neighbor.c.

{
  PNEIGHBOR_CACHE_ENTRY NCE;
  UINT HashValue;
  KIRQL OldIrql;
  PIP_INTERFACE FirstInterface;
  IP_ADDRESS InternalAddress;
 
  TI_DbgPrint(DEBUG_NCACHE, ("Called. Address (0x%X).\n", Address));
 
  RtlCopyMemory(&InternalAddress, Address, sizeof(*Address));
 
  /* Map 127.x.x.x adresses to the loopback address (127.0.0.1) */
  if ((InternalAddress.Address.IPv4Address & LOOPBACK_ADDRMASK_IPv4) == (LOOPBACK_ADDRESS_IPv4 & LOOPBACK_ADDRMASK_IPv4))
    InternalAddress.Address.IPv4Address = LOOPBACK_ADDRESS_IPv4;
 
  HashValue = *(PULONG)&InternalAddress.Address;;
  HashValue ^= HashValue >> 16;
  HashValue ^= HashValue >> 8;
  HashValue ^= HashValue >> 4;
  HashValue &= NB_HASHMASK;
 
  TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
  /* If there's no adapter specified, we'll look for a match on
   * each one. */
  if (Interface == NULL)
  {
      FirstInterface = GetDefaultInterface();
      Interface = FirstInterface;
  }
  else
  {
      FirstInterface = NULL;
  }
 
  do
  {
      NCE = NeighborCache[HashValue].Cache;
      while (NCE != NULL)
      {
         if (NCE->Interface == Interface &&
             AddrIsEqual(&InternalAddress, &NCE->Address))
         {
             break;
         }
 
         NCE = NCE->Next;
      }
 
      if (NCE != NULL)
          break;
  }
  while ((FirstInterface != NULL) &&
         ((Interface = GetDefaultInterface()) != FirstInterface));
 
  if ((NCE == NULL) && (FirstInterface != NULL))
  {
      /* This time we'll even match loopback NCEs */
      NCE = NeighborCache[HashValue].Cache;
      while (NCE != NULL)
      {
         if (AddrIsEqual(&InternalAddress, &NCE->Address))
         {
             break;
         }
 
         NCE = NCE->Next;
      }
  }
 
  TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
 
  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 
  return NCE;
}

Referenced by ARPReceive(), DispTdiQueryIpHwAddress(), InfoTdiSetArptableMIB(), IPRemoveInterfaceRoute(), NBFindOrCreateNeighbor(), RawIPSendDatagram(), UDPSendDatagram(), and WaitForHwAddress().

NBQueuePacket()

BOOLEAN NBQueuePacket	(	PNEIGHBOR_CACHE_ENTRY	NCE,
		PNDIS_PACKET	NdisPacket,
		PNEIGHBOR_PACKET_COMPLETE	PacketComplete,
		PVOID	PacketContext
	)

Definition at line 555 of file neighbor.c.

{
  KIRQL OldIrql;
  PNEIGHBOR_PACKET Packet;
  UINT HashValue;
 
  TI_DbgPrint
      (DEBUG_NCACHE,
       ("Called. NCE (0x%X)  NdisPacket (0x%X).\n", NCE, NdisPacket));
 
  Packet = ExAllocatePoolWithTag( NonPagedPool, sizeof(NEIGHBOR_PACKET),
                                  NEIGHBOR_PACKET_TAG );
  if( !Packet ) return FALSE;
 
  /* FIXME: Should we limit the number of queued packets? */
 
  HashValue  = *(PULONG)(&NCE->Address.Address);
  HashValue ^= HashValue >> 16;
  HashValue ^= HashValue >> 8;
  HashValue ^= HashValue >> 4;
  HashValue &= NB_HASHMASK;
 
  TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
  Packet->Complete = PacketComplete;
  Packet->Context = PacketContext;
  Packet->Packet = NdisPacket;
  InsertTailList( &NCE->PacketQueue, &Packet->Next );
 
  TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
 
  if( !(NCE->State & NUD_INCOMPLETE) )
      NBSendPackets( NCE );
 
  return TRUE;
}

Referenced by IPSendFragment().

NBRemoveNeighbor()

VOID NBRemoveNeighbor

(

PNEIGHBOR_CACHE_ENTRY

NCE

)

Definition at line 604 of file neighbor.c.

{
  PNEIGHBOR_CACHE_ENTRY *PrevNCE;
  PNEIGHBOR_CACHE_ENTRY CurNCE;
  ULONG HashValue;
  KIRQL OldIrql;
 
  TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X).\n", NCE));
 
  HashValue  = *(PULONG)(&NCE->Address.Address);
  HashValue ^= HashValue >> 16;
  HashValue ^= HashValue >> 8;
  HashValue ^= HashValue >> 4;
  HashValue &= NB_HASHMASK;
 
  TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
  /* Search the list and remove the NCE from the list if found */
  for (PrevNCE = &NeighborCache[HashValue].Cache;
    (CurNCE = *PrevNCE) != NULL;
    PrevNCE = &CurNCE->Next)
    {
      if (CurNCE == NCE)
        {
          /* Found it, now unlink it from the list */
          *PrevNCE = CurNCE->Next;
 
      NBFlushPacketQueue( CurNCE, NDIS_STATUS_REQUEST_ABORTED );
          ExFreePoolWithTag(CurNCE, NCE_TAG);
 
      break;
        }
    }
 
  TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
}

Referenced by InfoTdiSetArptableMIB(), and IPRemoveInterfaceRoute().

NBResetNeighborTimeout()

VOID NBResetNeighborTimeout

(

PIP_ADDRESS

Address

)

Definition at line 394 of file neighbor.c.

{
    KIRQL OldIrql;
    UINT HashValue;
    PNEIGHBOR_CACHE_ENTRY NCE;
 
    TI_DbgPrint(DEBUG_NCACHE, ("Resetting NCE timout for 0x%s\n", A2S(Address)));
 
    HashValue  = *(PULONG)(&Address->Address);
    HashValue ^= HashValue >> 16;
    HashValue ^= HashValue >> 8;
    HashValue ^= HashValue >> 4;
    HashValue &= NB_HASHMASK;
 
    TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
    for (NCE = NeighborCache[HashValue].Cache;
         NCE != NULL;
         NCE = NCE->Next)
    {
         if (AddrIsEqual(Address, &NCE->Address))
         {
             NCE->EventCount = 0;
             break;
         }
    }
 
    TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
}

Referenced by IPDispatchProtocol().

NBSendSolicit()

VOID NBSendSolicit

(

PNEIGHBOR_CACHE_ENTRY

NCE

)

Definition at line 221 of file neighbor.c.

{
    TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X).\n", NCE));
 
    ARPTransmit(&NCE->Address,
                (NCE->State & NUD_INCOMPLETE) ? NULL : NCE->LinkAddress,
                NCE->Interface);
}

Referenced by NBFindOrCreateNeighbor(), and NBTimeout().

NBShutdown()

VOID NBShutdown

(

VOID

)

Definition at line 184 of file neighbor.c.

{
  PNEIGHBOR_CACHE_ENTRY NextNCE;
  PNEIGHBOR_CACHE_ENTRY CurNCE;
  KIRQL OldIrql;
  UINT i;
 
  TI_DbgPrint(DEBUG_NCACHE, ("Called.\n"));
 
  /* Remove possible entries from the cache */
  for (i = 0; i <= NB_HASHMASK; i++)
    {
      TcpipAcquireSpinLock(&NeighborCache[i].Lock, &OldIrql);
 
      CurNCE = NeighborCache[i].Cache;
      while (CurNCE) {
          NextNCE = CurNCE->Next;
 
          /* Flush wait queue */
      NBFlushPacketQueue( CurNCE, NDIS_STATUS_NOT_ACCEPTED );
 
          ExFreePoolWithTag(CurNCE, NCE_TAG);
 
      CurNCE = NextNCE;
      }
 
    NeighborCache[i].Cache = NULL;
 
    TcpipReleaseSpinLock(&NeighborCache[i].Lock, OldIrql);
  }
 
  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
}

Referenced by IPShutdown().

NBStartup()

VOID NBStartup

(

VOID

)

Definition at line 169 of file neighbor.c.

{
    UINT i;
 
    TI_DbgPrint(DEBUG_NCACHE, ("Called.\n"));
 
    for (i = 0; i <= NB_HASHMASK; i++) {
    NeighborCache[i].Cache = NULL;
    TcpipInitializeSpinLock(&NeighborCache[i].Lock);
    }
}

Referenced by IPStartup().

NBTimeout()

VOID NBTimeout

(

VOID

)

Definition at line 91 of file neighbor.c.

{
    UINT i;
    PNEIGHBOR_CACHE_ENTRY *PrevNCE;
    PNEIGHBOR_CACHE_ENTRY NCE;
    NDIS_STATUS Status;
 
    for (i = 0; i <= NB_HASHMASK; i++) {
        TcpipAcquireSpinLockAtDpcLevel(&NeighborCache[i].Lock);
 
        for (PrevNCE = &NeighborCache[i].Cache;
             (NCE = *PrevNCE) != NULL;) {
            if (NCE->State & NUD_INCOMPLETE)
            {
                /* Solicit for an address */
                NBSendSolicit(NCE);
                if (NCE->EventTimer == 0)
                {
                    NCE->EventCount++;
                    if (NCE->EventCount == ARP_INCOMPLETE_TIMEOUT)
                    {
                        NBFlushPacketQueue(NCE, NDIS_STATUS_NETWORK_UNREACHABLE);
                        NCE->EventCount = 0;
                    }
                }
            }
 
            /* Check if event timer is running */
            if (NCE->EventTimer > 0)  {
                ASSERT(!(NCE->State & NUD_PERMANENT));
                NCE->EventCount++;
 
                if ((NCE->EventCount > ARP_RATE &&
                     NCE->EventCount % ARP_TIMEOUT_RETRANSMISSION == 0) ||
                    (NCE->EventCount == ARP_RATE))
                {
                    /* We haven't gotten a packet from them in
                     * EventCount seconds so we mark them as stale
                     * and solicit now */
                    NCE->State |= NUD_STALE;
                    NBSendSolicit(NCE);
                }
                if (NCE->EventTimer - NCE->EventCount == 0) {
                    /* Unlink and destroy the NCE */
                    *PrevNCE = NCE->Next;
 
                    /* Choose the proper failure status */
                    if (NCE->State & NUD_INCOMPLETE)
                    {
                        /* We couldn't get an address to this IP at all */
                        Status = NDIS_STATUS_HOST_UNREACHABLE;
                    }
                    else
                    {
                        /* This guy was stale for way too long */
                        Status = NDIS_STATUS_REQUEST_ABORTED;
                    }
 
                    NBFlushPacketQueue(NCE, Status);
 
                    ExFreePoolWithTag(NCE, NCE_TAG);
 
                    continue;
                }
            }
            PrevNCE = &NCE->Next;
        }
 
        TcpipReleaseSpinLockFromDpcLevel(&NeighborCache[i].Lock);
    }
}

Referenced by IPTimeoutDpcFn().

NBUpdateNeighbor()

VOID NBUpdateNeighbor	(	PNEIGHBOR_CACHE_ENTRY	NCE,
		PVOID	LinkAddress,
		UCHAR	State
	)

Definition at line 353 of file neighbor.c.

{
    KIRQL OldIrql;
    UINT HashValue;
 
    TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X)  LinkAddress (0x%X)  State (0x%X).\n", NCE, LinkAddress, State));
 
    HashValue  = *(PULONG)(&NCE->Address.Address);
    HashValue ^= HashValue >> 16;
    HashValue ^= HashValue >> 8;
    HashValue ^= HashValue >> 4;
    HashValue &= NB_HASHMASK;
 
    TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
    RtlCopyMemory(NCE->LinkAddress, LinkAddress, NCE->LinkAddressLength);
    NCE->State = State;
    NCE->EventCount = 0;
 
    TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
 
    if( !(NCE->State & NUD_INCOMPLETE) )
    {
        if (NCE->EventTimer) NCE->EventTimer = ARP_COMPLETE_TIMEOUT;
        NBSendPackets( NCE );
    }
}

Referenced by ARPReceive(), and DispTdiQueryIpHwAddress().

Variable Documentation

NeighborCache

NEIGHBOR_CACHE_TABLE NeighborCache[NB_HASHMASK+1]

extern

Definition at line 13 of file neighbor.c.

Referenced by NBAddNeighbor(), NBCopyNeighbors(), NBDestroyNeighborsForInterface(), NBLocateNeighbor(), NBQueuePacket(), NBRemoveNeighbor(), NBResetNeighborTimeout(), NBSendPackets(), NBShutdown(), NBStartup(), NBTimeout(), and NBUpdateNeighbor().