ReactOS  0.4.14-dev-593-g1793dcc
neighbor.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS TCP/IP protocol driver
4  * FILE: network/neighbor.c
5  * PURPOSE: Neighbor address cache
6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7  * REVISIONS:
8  * CSH 01/08-2000 Created
9  */
10 
11 #include "precomp.h"
12 
14 
16  PNDIS_PACKET NdisPacket,
19  TI_DbgPrint(MID_TRACE, ("Called\n"));
21  ASSERT_KM_POINTER(Packet->Complete);
22  Packet->Complete( Packet->Context, Packet->Packet, Status );
23  TI_DbgPrint(MID_TRACE, ("Completed\n"));
25  TI_DbgPrint(MID_TRACE, ("Freed\n"));
26 }
27 
29  PLIST_ENTRY PacketEntry;
32 
33  ASSERT(!(NCE->State & NUD_INCOMPLETE));
34 
35  HashValue = *(PULONG)(&NCE->Address.Address);
36  HashValue ^= HashValue >> 16;
37  HashValue ^= HashValue >> 8;
38  HashValue ^= HashValue >> 4;
40 
41  /* Send any waiting packets */
42  while ((PacketEntry = ExInterlockedRemoveHeadList(&NCE->PacketQueue,
44  {
45  Packet = CONTAINING_RECORD( PacketEntry, NEIGHBOR_PACKET, Next );
46 
48  (MID_TRACE,
49  ("PacketEntry: %x, NdisPacket %x\n",
50  PacketEntry, Packet->Packet));
51 
52  PC(Packet->Packet)->DLComplete = NBCompleteSend;
53  PC(Packet->Packet)->Context = Packet;
54 
55  NCE->Interface->Transmit
56  ( NCE->Interface->Context,
57  Packet->Packet,
58  0,
59  NCE->LinkAddress,
61  }
62 }
63 
64 /* Must be called with table lock acquired */
67  PLIST_ENTRY PacketEntry;
69 
70  while( !IsListEmpty(&NCE->PacketQueue) ) {
71  PacketEntry = RemoveHeadList(&NCE->PacketQueue);
73  ( PacketEntry, NEIGHBOR_PACKET, Next );
74 
76 
78  (MID_TRACE,
79  ("PacketEntry: %x, NdisPacket %x\n",
80  PacketEntry, Packet->Packet));
81 
82  ASSERT_KM_POINTER(Packet->Complete);
83  Packet->Complete( Packet->Context,
84  Packet->Packet,
85  ErrorCode );
86 
88  }
89 }
90 
92 /*
93  * FUNCTION: Neighbor address cache timeout handler
94  * NOTES:
95  * This routine is called by IPTimeout to remove outdated cache
96  * entries.
97  */
98 {
99  UINT i;
100  PNEIGHBOR_CACHE_ENTRY *PrevNCE;
103 
104  for (i = 0; i <= NB_HASHMASK; i++) {
106 
107  for (PrevNCE = &NeighborCache[i].Cache;
108  (NCE = *PrevNCE) != NULL;) {
109  if (NCE->State & NUD_INCOMPLETE)
110  {
111  /* Solicit for an address */
112  NBSendSolicit(NCE);
113  if (NCE->EventTimer == 0)
114  {
115  NCE->EventCount++;
117  {
119  NCE->EventCount = 0;
120  }
121  }
122  }
123 
124  /* Check if event timer is running */
125  if (NCE->EventTimer > 0) {
126  ASSERT(!(NCE->State & NUD_PERMANENT));
127  NCE->EventCount++;
128 
129  if ((NCE->EventCount > ARP_RATE &&
130  NCE->EventCount % ARP_TIMEOUT_RETRANSMISSION == 0) ||
131  (NCE->EventCount == ARP_RATE))
132  {
133  /* We haven't gotten a packet from them in
134  * EventCount seconds so we mark them as stale
135  * and solicit now */
136  NCE->State |= NUD_STALE;
137  NBSendSolicit(NCE);
138  }
139  if (NCE->EventTimer - NCE->EventCount == 0) {
140  /* Unlink and destroy the NCE */
141  *PrevNCE = NCE->Next;
142 
143  /* Choose the proper failure status */
144  if (NCE->State & NUD_INCOMPLETE)
145  {
146  /* We couldn't get an address to this IP at all */
148  }
149  else
150  {
151  /* This guy was stale for way too long */
153  }
154 
156 
158 
159  continue;
160  }
161  }
162  PrevNCE = &NCE->Next;
163  }
164 
166  }
167 }
168 
170 /*
171  * FUNCTION: Starts the neighbor cache
172  */
173 {
174  UINT i;
175 
176  TI_DbgPrint(DEBUG_NCACHE, ("Called.\n"));
177 
178  for (i = 0; i <= NB_HASHMASK; i++) {
181  }
182 }
183 
185 /*
186  * FUNCTION: Shuts down the neighbor cache
187  */
188 {
189  PNEIGHBOR_CACHE_ENTRY NextNCE;
190  PNEIGHBOR_CACHE_ENTRY CurNCE;
191  KIRQL OldIrql;
192  UINT i;
193 
194  TI_DbgPrint(DEBUG_NCACHE, ("Called.\n"));
195 
196  /* Remove possible entries from the cache */
197  for (i = 0; i <= NB_HASHMASK; i++)
198  {
200 
201  CurNCE = NeighborCache[i].Cache;
202  while (CurNCE) {
203  NextNCE = CurNCE->Next;
204 
205  /* Flush wait queue */
207 
208  ExFreePoolWithTag(CurNCE, NCE_TAG);
209 
210  CurNCE = NextNCE;
211  }
212 
214 
216  }
217 
218  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
219 }
220 
222 /*
223  * FUNCTION: Sends a neighbor solicitation message
224  * ARGUMENTS:
225  * NCE = Pointer to NCE of neighbor to solicit
226  * NOTES:
227  * May be called with lock held on NCE's table
228  */
229 {
230  TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X).\n", NCE));
231 
232  ARPTransmit(&NCE->Address,
233  (NCE->State & NUD_INCOMPLETE) ? NULL : NCE->LinkAddress,
234  NCE->Interface);
235 }
236 
238 {
239  KIRQL OldIrql;
240  PNEIGHBOR_CACHE_ENTRY *PrevNCE;
242  ULONG i;
243 
245  for (i = 0; i <= NB_HASHMASK; i++)
246  {
248 
249  for (PrevNCE = &NeighborCache[i].Cache;
250  (NCE = *PrevNCE) != NULL;)
251  {
252  if (NCE->Interface == Interface)
253  {
254  /* Unlink and destroy the NCE */
255  *PrevNCE = NCE->Next;
256 
259 
260  continue;
261  }
262  else
263  {
264  PrevNCE = &NCE->Next;
265  }
266  }
267 
269  }
271 }
272 
276  PVOID LinkAddress,
277  UINT LinkAddressLength,
278  UCHAR State,
279  UINT EventTimer)
280 /*
281  * FUNCTION: Adds a neighbor to the neighbor cache
282  * ARGUMENTS:
283  * Interface = Pointer to interface
284  * Address = Pointer to IP address
285  * LinkAddress = Pointer to link address (may be NULL)
286  * LinkAddressLength = Length of link address
287  * State = State of NCE
288  * RETURNS:
289  * Pointer to NCE, NULL there is not enough free resources
290  * NOTES:
291  * The NCE if referenced for the caller if created. The NCE retains
292  * a reference to the IP address if it is created, the caller is
293  * responsible for providing this reference
294  */
295 {
298  KIRQL OldIrql;
299 
301  (DEBUG_NCACHE,
302  ("Called. Interface (0x%X) Address (0x%X) "
303  "LinkAddress (0x%X) LinkAddressLength (%d) State (0x%X)\n",
304  Interface, Address, LinkAddress, LinkAddressLength, State));
305 
307  (NonPagedPool, sizeof(NEIGHBOR_CACHE_ENTRY) + LinkAddressLength,
308  NCE_TAG);
309  if (NCE == NULL)
310  {
311  TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
312  return NULL;
313  }
314 
315  NCE->Interface = Interface;
316  NCE->Address = *Address;
317  NCE->LinkAddressLength = LinkAddressLength;
318  NCE->LinkAddress = (PVOID)&NCE[1];
319  if( LinkAddress )
320  RtlCopyMemory(NCE->LinkAddress, LinkAddress, LinkAddressLength);
321  else
322  memset(NCE->LinkAddress, 0xff, LinkAddressLength);
323  NCE->State = State;
324  NCE->EventTimer = EventTimer;
325  NCE->EventCount = 0;
327 
328  TI_DbgPrint(MID_TRACE,("NCE: %x\n", NCE));
329 
330  HashValue = *(PULONG)&Address->Address;
331  HashValue ^= HashValue >> 16;
332  HashValue ^= HashValue >> 8;
333  HashValue ^= HashValue >> 4;
335 
337 
340 
342 
343  return NCE;
344 }
345 
348  PVOID LinkAddress,
349  UCHAR State)
350 /*
351  * FUNCTION: Update link address information in NCE
352  * ARGUMENTS:
353  * NCE = Pointer to NCE to update
354  * LinkAddress = Pointer to link address
355  * State = State of NCE
356  * NOTES:
357  * The link address and state is updated. Any waiting packets are sent
358  */
359 {
360  KIRQL OldIrql;
361  UINT HashValue;
362 
363  TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X) LinkAddress (0x%X) State (0x%X).\n", NCE, LinkAddress, State));
364 
365  HashValue = *(PULONG)(&NCE->Address.Address);
366  HashValue ^= HashValue >> 16;
367  HashValue ^= HashValue >> 8;
368  HashValue ^= HashValue >> 4;
370 
372 
373  RtlCopyMemory(NCE->LinkAddress, LinkAddress, NCE->LinkAddressLength);
374  NCE->State = State;
375  NCE->EventCount = 0;
376 
378 
379  if( !(NCE->State & NUD_INCOMPLETE) )
380  {
381  if (NCE->EventTimer) NCE->EventTimer = ARP_COMPLETE_TIMEOUT;
382  NBSendPackets( NCE );
383  }
384 }
385 
386 VOID
388 {
389  KIRQL OldIrql;
390  UINT HashValue;
392 
393  TI_DbgPrint(DEBUG_NCACHE, ("Resetting NCE timout for 0x%s\n", A2S(Address)));
394 
395  HashValue = *(PULONG)(&Address->Address);
396  HashValue ^= HashValue >> 16;
397  HashValue ^= HashValue >> 8;
398  HashValue ^= HashValue >> 4;
400 
402 
403  for (NCE = NeighborCache[HashValue].Cache;
404  NCE != NULL;
405  NCE = NCE->Next)
406  {
407  if (AddrIsEqual(Address, &NCE->Address))
408  {
409  NCE->EventCount = 0;
410  break;
411  }
412  }
413 
415 }
416 
420 /*
421  * FUNCTION: Locates a neighbor in the neighbor cache
422  * ARGUMENTS:
423  * Address = Pointer to IP address
424  * Interface = Pointer to IP interface
425  * RETURNS:
426  * Pointer to NCE, NULL if not found
427  * NOTES:
428  * If the NCE is found, it is referenced. The caller is
429  * responsible for dereferencing it again after use
430  */
431 {
433  UINT HashValue;
434  KIRQL OldIrql;
435  PIP_INTERFACE FirstInterface;
436 
437  TI_DbgPrint(DEBUG_NCACHE, ("Called. Address (0x%X).\n", Address));
438 
439  HashValue = *(PULONG)&Address->Address;
440  HashValue ^= HashValue >> 16;
441  HashValue ^= HashValue >> 8;
442  HashValue ^= HashValue >> 4;
444 
446 
447  /* If there's no adapter specified, we'll look for a match on
448  * each one. */
449  if (Interface == NULL)
450  {
451  FirstInterface = GetDefaultInterface();
452  Interface = FirstInterface;
453  }
454  else
455  {
456  FirstInterface = NULL;
457  }
458 
459  do
460  {
462  while (NCE != NULL)
463  {
464  if (NCE->Interface == Interface &&
465  AddrIsEqual(Address, &NCE->Address))
466  {
467  break;
468  }
469 
470  NCE = NCE->Next;
471  }
472 
473  if (NCE != NULL)
474  break;
475  }
476  while ((FirstInterface != NULL) &&
477  ((Interface = GetDefaultInterface()) != FirstInterface));
478 
479  if ((NCE == NULL) && (FirstInterface != NULL))
480  {
481  /* This time we'll even match loopback NCEs */
483  while (NCE != NULL)
484  {
485  if (AddrIsEqual(Address, &NCE->Address))
486  {
487  break;
488  }
489 
490  NCE = NCE->Next;
491  }
492  }
493 
495 
496  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
497 
498  return NCE;
499 }
500 
504  BOOLEAN NoTimeout)
505 /*
506  * FUNCTION: Tries to find a neighbor and if unsuccesful, creates a new NCE
507  * ARGUMENTS:
508  * Interface = Pointer to interface to use (in case NCE is not found)
509  * Address = Pointer to IP address
510  * RETURNS:
511  * Pointer to NCE, NULL if there is not enough free resources
512  * NOTES:
513  * The NCE is referenced if found or created. The caller is
514  * responsible for dereferencing it again after use
515  */
516 {
518 
519  TI_DbgPrint(DEBUG_NCACHE, ("Called. Interface (0x%X) Address (0x%X).\n", Interface, Address));
520 
522  if (NCE == NULL)
523  {
524  TI_DbgPrint(MID_TRACE,("BCAST: %s\n", A2S(&Interface->Broadcast)));
525  if( AddrIsEqual(Address, &Interface->Broadcast) ||
527  TI_DbgPrint(MID_TRACE,("Packet targeted at broadcast addr\n"));
529  Interface->AddressLength, NUD_PERMANENT, 0);
530  } else {
532  Interface->AddressLength, NUD_INCOMPLETE, NoTimeout ? 0 : ARP_INCOMPLETE_TIMEOUT);
533  if (!NCE) return NULL;
534  NBSendSolicit(NCE);
535  }
536  }
537 
538  return NCE;
539 }
540 
543  PNDIS_PACKET NdisPacket,
544  PNEIGHBOR_PACKET_COMPLETE PacketComplete,
545  PVOID PacketContext)
546 /*
547  * FUNCTION: Queues a packet on an NCE for later transmission
548  * ARGUMENTS:
549  * NCE = Pointer to NCE to queue packet on
550  * NdisPacket = Pointer to NDIS packet to queue
551  * RETURNS:
552  * TRUE if the packet was successfully queued, FALSE if not
553  */
554 {
555  KIRQL OldIrql;
557  UINT HashValue;
558 
560  (DEBUG_NCACHE,
561  ("Called. NCE (0x%X) NdisPacket (0x%X).\n", NCE, NdisPacket));
562 
565  if( !Packet ) return FALSE;
566 
567  /* FIXME: Should we limit the number of queued packets? */
568 
569  HashValue = *(PULONG)(&NCE->Address.Address);
570  HashValue ^= HashValue >> 16;
571  HashValue ^= HashValue >> 8;
572  HashValue ^= HashValue >> 4;
574 
576 
577  Packet->Complete = PacketComplete;
578  Packet->Context = PacketContext;
579  Packet->Packet = NdisPacket;
580  InsertTailList( &NCE->PacketQueue, &Packet->Next );
581 
583 
584  if( !(NCE->State & NUD_INCOMPLETE) )
585  NBSendPackets( NCE );
586 
587  return TRUE;
588 }
589 
592 /*
593  * FUNCTION: Removes a neighbor from the neighbor cache
594  * ARGUMENTS:
595  * NCE = Pointer to NCE to remove from cache
596  * NOTES:
597  * The NCE must be in a safe state
598  */
599 {
600  PNEIGHBOR_CACHE_ENTRY *PrevNCE;
601  PNEIGHBOR_CACHE_ENTRY CurNCE;
603  KIRQL OldIrql;
604 
605  TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X).\n", NCE));
606 
607  HashValue = *(PULONG)(&NCE->Address.Address);
608  HashValue ^= HashValue >> 16;
609  HashValue ^= HashValue >> 8;
610  HashValue ^= HashValue >> 4;
612 
614 
615  /* Search the list and remove the NCE from the list if found */
616  for (PrevNCE = &NeighborCache[HashValue].Cache;
617  (CurNCE = *PrevNCE) != NULL;
618  PrevNCE = &CurNCE->Next)
619  {
620  if (CurNCE == NCE)
621  {
622  /* Found it, now unlink it from the list */
623  *PrevNCE = CurNCE->Next;
624 
626  ExFreePoolWithTag(CurNCE, NCE_TAG);
627 
628  break;
629  }
630  }
631 
633 }
634 
637  PIPARP_ENTRY ArpTable)
638 {
639  PNEIGHBOR_CACHE_ENTRY CurNCE;
640  KIRQL OldIrql;
641  UINT Size = 0, i;
642 
643  for (i = 0; i <= NB_HASHMASK; i++) {
645  for( CurNCE = NeighborCache[i].Cache;
646  CurNCE;
647  CurNCE = CurNCE->Next ) {
648  if( CurNCE->Interface == Interface &&
649  !AddrIsEqual( &CurNCE->Address, &CurNCE->Interface->Unicast ) ) {
650  if( ArpTable ) {
651  ArpTable[Size].Index = Interface->Index;
652  ArpTable[Size].AddrSize = CurNCE->LinkAddressLength;
654  (ArpTable[Size].PhysAddr,
655  CurNCE->LinkAddress,
656  CurNCE->LinkAddressLength);
657  ArpTable[Size].LogAddr = CurNCE->Address.Address.IPv4Address;
658  if( CurNCE->State & NUD_PERMANENT )
659  ArpTable[Size].Type = ARP_ENTRY_STATIC;
660  else if( CurNCE->State & NUD_INCOMPLETE )
661  ArpTable[Size].Type = ARP_ENTRY_INVALID;
662  else
663  ArpTable[Size].Type = ARP_ENTRY_DYNAMIC;
664  }
665  Size++;
666  }
667  }
669  }
670 
671  return Size;
672 }
BOOLEAN AddrIsUnspecified(PIP_ADDRESS Address)
Definition: address.c:113
#define ARP_TIMEOUT_RETRANSMISSION
Definition: neighbor.h:55
#define TI_DbgPrint(_t_, _x_)
Definition: debug.h:45
#define ARP_INCOMPLETE_TIMEOUT
Definition: neighbor.h:46
IPv4_RAW_ADDRESS IPv4Address
Definition: ip.h:26
#define NDIS_STATUS_HOST_UNREACHABLE
Definition: ndis.h:512
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define MID_TRACE
Definition: debug.h:15
_In_ NDIS_ERROR_CODE ErrorCode
Definition: ndis.h:4436
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
VOID NBSendPackets(PNEIGHBOR_CACHE_ENTRY NCE)
Definition: neighbor.c:28
#define ARP_RATE
Definition: neighbor.h:49
PNEIGHBOR_CACHE_ENTRY NBLocateNeighbor(PIP_ADDRESS Address, PIP_INTERFACE Interface)
Definition: neighbor.c:417
_In_ NDIS_HANDLE _In_ PNDIS_PACKET Packet
Definition: ndis.h:1548
VOID NBSendSolicit(PNEIGHBOR_CACHE_ENTRY NCE)
Definition: neighbor.c:221
Definition: fatfs.h:173
Definition: neighbor.h:28
#define NUD_STALE
Definition: neighbor.h:43
LONG NTSTATUS
Definition: precomp.h:26
_In_ BOOLEAN _In_ ULONG _Out_ PULONG HashValue
Definition: rtlfuncs.h:2039
VOID NBShutdown(VOID)
Definition: neighbor.c:184
struct _NEIGHBOR_PACKET * PNEIGHBOR_PACKET
#define InsertTailList(ListHead, Entry)
#define NUD_PERMANENT
Definition: neighbor.h:42
VOID TcpipReleaseSpinLock(PKSPIN_LOCK SpinLock, KIRQL Irql)
Definition: lock.c:26
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
VOID TcpipAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL Irql)
Definition: lock.c:18
UINT LinkAddressLength
Definition: neighbor.h:34
int NDIS_STATUS
Definition: ntddndis.h:471
Definition: ip.h:23
UCHAR KIRQL
Definition: env_spec_w32.h:591
PNEIGHBOR_CACHE_ENTRY NBFindOrCreateNeighbor(PIP_INTERFACE Interface, PIP_ADDRESS Address, BOOLEAN NoTimeout)
Definition: neighbor.c:501
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID NBCompleteSend(PVOID Context, PNDIS_PACKET NdisPacket, NDIS_STATUS Status)
Definition: neighbor.c:15
VOID NBFlushPacketQueue(PNEIGHBOR_CACHE_ENTRY NCE, NTSTATUS ErrorCode)
Definition: neighbor.c:65
#define ARP_ENTRY_DYNAMIC
Definition: info.h:31
VOID NBRemoveNeighbor(PNEIGHBOR_CACHE_ENTRY NCE)
Definition: neighbor.c:590
LIST_ENTRY PacketQueue
Definition: neighbor.h:37
BOOLEAN ARPTransmit(PIP_ADDRESS Address, PVOID LinkAddress, PIP_INTERFACE Interface)
Definition: arp.c:111
KSPIN_LOCK Lock
Definition: neighbor.h:24
PLIST_ENTRY NTAPI ExInterlockedRemoveHeadList(IN OUT PLIST_ENTRY ListHead, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:166
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
static WCHAR Address[46]
Definition: ping.c:68
IP_ADDRESS Unicast
Definition: ip.h:159
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
ULONG Index
Definition: info.h:36
UCHAR State
Definition: neighbor.h:30
#define PC(Packet)
Definition: ip.h:106
void * PVOID
Definition: retypes.h:9
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
VOID NBTimeout(VOID)
Definition: neighbor.c:91
#define NDIS_STATUS_REQUEST_ABORTED
Definition: ndis.h:476
PVOID LinkAddress
Definition: neighbor.h:35
VOID(* PNEIGHBOR_PACKET_COMPLETE)(PVOID Context, PNDIS_PACKET Packet, NDIS_STATUS Status)
Definition: neighbor.h:13
ULONG NBCopyNeighbors(PIP_INTERFACE Interface, PIPARP_ENTRY ArpTable)
Definition: neighbor.c:636
IN PVOID IN PVOID IN USHORT IN USHORT IN PINTERFACE Interface
Definition: pci.h:359
#define LAN_PROTO_IPv4
Definition: lan.h:126
LL_TRANSMIT_ROUTINE Transmit
Definition: ip.h:168
#define NDIS_STATUS_NOT_ACCEPTED
Definition: ndis.h:350
#define ARP_COMPLETE_TIMEOUT
Definition: neighbor.h:52
BOOLEAN NBQueuePacket(PNEIGHBOR_CACHE_ENTRY NCE, PNDIS_PACKET NdisPacket, PNEIGHBOR_PACKET_COMPLETE PacketComplete, PVOID PacketContext)
Definition: neighbor.c:541
struct NEIGHBOR_CACHE_ENTRY * Next
Definition: neighbor.h:29
#define ARP_ENTRY_STATIC
Definition: info.h:30
#define NUD_INCOMPLETE
Definition: neighbor.h:41
#define ARP_ENTRY_INVALID
Definition: info.h:32
#define ASSERT_KM_POINTER(_x)
Definition: debug.h:74
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
unsigned char UCHAR
Definition: xmlstorage.h:181
VOID TcpipReleaseSpinLockFromDpcLevel(PKSPIN_LOCK SpinLock)
Definition: lock.c:30
BOOLEAN AddrIsEqual(PIP_ADDRESS Address1, PIP_ADDRESS Address2)
Definition: address.c:221
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
VOID NBDestroyNeighborsForInterface(PIP_INTERFACE Interface)
Definition: neighbor.c:237
Definition: typedefs.h:117
IN OUT PLONG IN OUT PLONG Addend IN OUT PLONG IN LONG IN OUT PLONG IN LONG Increment IN PNDIS_RW_LOCK Lock
Definition: CrNtStubs.h:75
NEIGHBOR_CACHE_TABLE NeighborCache[NB_HASHMASK+1]
Definition: neighbor.c:13
UINT EventCount
Definition: neighbor.h:32
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define NEIGHBOR_PACKET_TAG
Definition: tags.h:24
#define NB_HASHMASK
Definition: neighbor.h:10
PVOID Context
Definition: ip.h:154
ULONG LogAddr
Definition: info.h:39
Status
Definition: gdiplustypes.h:24
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
PIP_INTERFACE Interface
Definition: neighbor.h:33
enum State_ State
Definition: pofuncs.h:54
#define MAX_TRACE
Definition: debug.h:16
ULONG Type
Definition: info.h:40
Definition: info.h:35
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
VOID NBResetNeighborTimeout(PIP_ADDRESS Address)
Definition: neighbor.c:387
UINT EventTimer
Definition: neighbor.h:31
PNEIGHBOR_CACHE_ENTRY NBAddNeighbor(PIP_INTERFACE Interface, PIP_ADDRESS Address, PVOID LinkAddress, UINT LinkAddressLength, UCHAR State, UINT EventTimer)
Definition: neighbor.c:273
VOID TcpipInitializeSpinLock(PKSPIN_LOCK SpinLock)
Definition: lock.c:14
VOID NBStartup(VOID)
Definition: neighbor.c:169
unsigned int * PULONG
Definition: retypes.h:1
unsigned int UINT
Definition: ndis.h:50
IP_ADDRESS Address
Definition: neighbor.h:36
VOID TcpipAcquireSpinLockAtDpcLevel(PKSPIN_LOCK SpinLock)
Definition: lock.c:22
PIP_INTERFACE GetDefaultInterface(VOID)
Definition: interface.c:156
ULONG AddrSize
Definition: info.h:37
unsigned int ULONG
Definition: retypes.h:1
#define NDIS_STATUS_NETWORK_UNREACHABLE
Definition: ndis.h:511
#define MIN_TRACE
Definition: debug.h:14
#define DEBUG_NCACHE
Definition: debug.h:32
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define NCE_TAG
Definition: tags.h:25
#define memset(x, y, z)
Definition: compat.h:39
union IP_ADDRESS::@990 Address
struct NEIGHBOR_CACHE_ENTRY * Cache
Definition: neighbor.h:23
VOID NBUpdateNeighbor(PNEIGHBOR_CACHE_ENTRY NCE, PVOID LinkAddress, UCHAR State)
Definition: neighbor.c:346
PCHAR A2S(PIP_ADDRESS Address)
Definition: address.c:17