Deleted Added
sdiff udiff text old ( 15885 ) new ( 17254 )
full compact
1/*
2 * Copyright (c) 1990,1991 Regents of The University of Michigan.
3 * All Rights Reserved.
4 */
5
6#include <sys/types.h>
7#include <sys/cdefs.h>
8#include <sys/socket.h>
9#include <sys/syslog.h>
10#include <sys/param.h>
11#if defined( __FreeBSD__ )
11#include <machine/endian.h>
12#include <sys/systm.h>
13#include <sys/proc.h>
15#endif
14#include <sys/mbuf.h>
15#include <sys/time.h>
18#ifndef _IBMR2
16#include <sys/kernel.h>
20#endif _IBMR2
17#include <net/if.h>
18#include <net/route.h>
23#if !defined( __FreeBSD__ )
24#include <net/af.h>
25#endif
19#include <netinet/in.h>
20#undef s_net
21#include <netinet/if_ether.h>
29#ifdef _IBMR2
30#include <netinet/in_netarp.h>
31#include <net/spl.h>
32#include <sys/errno.h>
33#include <sys/err_rec.h>
34#endif _IBMR2
22
23#include <netatalk/at.h>
24#include <netatalk/at_var.h>
25#include <netatalk/aarp.h>
26#include <netatalk/ddp_var.h>
27#include <netatalk/phase2.h>
28#include <netatalk/at_extern.h>
29
30static void aarptfree( struct aarptab *aat);
31static void at_aarpinput( struct arpcom *ac, struct mbuf *m);
32
46#ifdef GATEWAY
47#define AARPTAB_BSIZ 16
48#define AARPTAB_NB 37
49#else
33#define AARPTAB_BSIZ 9
34#define AARPTAB_NB 19
52#endif GATEWAY
35#define AARPTAB_SIZE (AARPTAB_BSIZ * AARPTAB_NB)
36struct aarptab aarptab[AARPTAB_SIZE];
37int aarptab_size = AARPTAB_SIZE;
38
39#define AARPTAB_HASH(a) \
40 ((((a).s_net << 8 ) + (a).s_node ) % AARPTAB_NB )
41
42#define AARPTAB_LOOK(aat,addr) { \

--- 6 unchanged lines hidden (view full) ---

49 if ( n >= AARPTAB_BSIZ ) \
50 aat = 0; \
51}
52
53#define AARPT_AGE (60 * 1)
54#define AARPT_KILLC 20
55#define AARPT_KILLI 3
56
75#ifdef sun
76extern struct ether_addr etherbroadcastaddr;
77#else sun
57# if !defined( __FreeBSD__ )
58extern u_char etherbroadcastaddr[6];
59# endif __FreeBSD__
81#endif sun
60
61u_char atmulticastaddr[ 6 ] = {
62 0x09, 0x00, 0x07, 0xff, 0xff, 0xff,
63};
64
65u_char at_org_code[ 3 ] = {
66 0x08, 0x00, 0x07,
67};

--- 21 unchanged lines hidden (view full) ---

89 }
90}
91
92struct ifaddr *
93at_ifawithnet( sat, ifa )
94 struct sockaddr_at *sat;
95 struct ifaddr *ifa;
96{
119 struct at_ifaddr *aa;
97
98 for (; ifa; ifa = ifa->ifa_next ) {
122#ifdef BSD4_4
99 if ( ifa->ifa_addr->sa_family != AF_APPLETALK ) {
100 continue;
101 }
102 if ( satosat( ifa->ifa_addr )->sat_addr.s_net ==
103 sat->sat_addr.s_net ) {
104 break;
105 }
130#else BSD4_4
131 if ( ifa->ifa_addr.sa_family != AF_APPLETALK ) {
132 continue;
133 }
134 aa = (struct at_ifaddr *)ifa;
135 if ( ntohs( sat->sat_addr.s_net ) >= ntohs( aa->aa_firstnet ) &&
136 ntohs( sat->sat_addr.s_net ) <= ntohs( aa->aa_lastnet )) {
137 break;
138 }
139#endif BSD4_4
106 }
107 return( ifa );
108}
109
110static void
111aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat )
112{
113 struct mbuf *m;
114 struct ether_header *eh;
115 struct ether_aarp *ea;
116 struct at_ifaddr *aa;
117 struct llc *llc;
118 struct sockaddr sa;
119
154#ifdef BSD4_4
120 if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
121 return;
122 }
123 m->m_len = sizeof( *ea );
124 m->m_pkthdr.len = sizeof( *ea );
125 MH_ALIGN( m, sizeof( *ea ));
161#else BSD4_4
162 if (( m = m_get( M_DONTWAIT, MT_DATA )) == NULL ) {
163 return;
164 }
165 m->m_len = sizeof( *ea );
166 m->m_off = MMAXOFF - sizeof( *ea );
167#endif BSD4_4
126
127 ea = mtod( m, struct ether_aarp *);
128 bzero((caddr_t)ea, sizeof( *ea ));
129
130 ea->aarp_hrd = htons( AARPHRD_ETHER );
131 ea->aarp_pro = htons( ETHERTYPE_AT );
132 ea->aarp_hln = sizeof( ea->aarp_sha );
133 ea->aarp_pln = sizeof( ea->aarp_spu );
134 ea->aarp_op = htons( AARPOP_REQUEST );
177#ifdef sun
178 bcopy((caddr_t)&ac->ac_enaddr, (caddr_t)ea->aarp_sha,
179 sizeof( ea->aarp_sha ));
180#else sun
135 bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
136 sizeof( ea->aarp_sha ));
183#endif sun
137
138 /*
139 * We need to check whether the output ethernet type should
140 * be phase 1 or 2. We have the interface that we'll be sending
141 * the aarp out. We need to find an AppleTalk network on that
142 * interface with the same address as we're looking for. If the
143 * net is phase 2, generate an 802.2 and SNAP header.
144 */
145 if (( aa = (struct at_ifaddr *)at_ifawithnet( sat, ac->ac_if.if_addrlist ))
146 == NULL ) {
147 m_freem( m );
148 return;
149 }
150
151 eh = (struct ether_header *)sa.sa_data;
152
153 if ( aa->aa_flags & AFA_PHASE2 ) {
201#ifdef sun
202 bcopy((caddr_t)atmulticastaddr, (caddr_t)&eh->ether_dhost,
203 sizeof( eh->ether_dhost ));
204#else sun
154 bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
155 sizeof( eh->ether_dhost ));
207#endif sun
208#if defined(sun) && defined(i386)
156 eh->ether_type = htons(sizeof(struct llc) + sizeof(struct ether_aarp));
210#else
211 eh->ether_type = sizeof(struct llc) + sizeof(struct ether_aarp);
212#endif
213#ifdef BSD4_4
157 M_PREPEND( m, sizeof( struct llc ), M_WAIT );
215#else BSD4_4
216 m->m_len += sizeof( struct llc );
217 m->m_off -= sizeof( struct llc );
218#endif BSD4_4
158 llc = mtod( m, struct llc *);
159 llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
160 llc->llc_control = LLC_UI;
161 bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
162 llc->llc_ether_type = htons( ETHERTYPE_AARP );
163
164 bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
165 sizeof( ea->aarp_spnet ));
166 bcopy( &sat->sat_addr.s_net, ea->aarp_tpnet,
167 sizeof( ea->aarp_tpnet ));
168 ea->aarp_spnode = AA_SAT( aa )->sat_addr.s_node;
169 ea->aarp_tpnode = sat->sat_addr.s_node;
170 } else {
232#ifdef sun
233 bcopy((caddr_t)&etherbroadcastaddr, (caddr_t)&eh->ether_dhost,
234 sizeof( eh->ether_dhost ));
235#else sun
171 bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
172 sizeof( eh->ether_dhost ));
238#endif sun
239#if defined(sun) && defined(i386)
173 eh->ether_type = htons( ETHERTYPE_AARP );
241#else
242 eh->ether_type = ETHERTYPE_AARP;
243#endif
174
175 ea->aarp_spa = AA_SAT( aa )->sat_addr.s_node;
176 ea->aarp_tpa = sat->sat_addr.s_node;
177 }
178
179#ifdef NETATALKDEBUG
180 printf("aarp: sending request for %u.%u\n",
181 ntohs(AA_SAT( aa )->sat_addr.s_net),
182 AA_SAT( aa )->sat_addr.s_node);
183#endif NETATALKDEBUG
184
255#ifdef BSD4_4
185 sa.sa_len = sizeof( struct sockaddr );
257#endif BSD4_4
186 sa.sa_family = AF_UNSPEC;
259 (*ac->ac_if.if_output)(&ac->ac_if, m, &sa
260#if defined( __FreeBSD__ )
261 , NULL /* XXX should be routing information */
262#endif __FreeBSD__
263 );
187 (*ac->ac_if.if_output)(&ac->ac_if,
188 m, &sa, NULL); /* XXX NULL should be routing information */
189}
190
191int
192aarpresolve( ac, m, destsat, desten )
193 struct arpcom *ac;
194 struct mbuf *m;
195 struct sockaddr_at *destsat;
271#ifdef sun
272 struct ether_addr *desten;
273#else sun
196 u_char *desten;
275#endif sun
197{
198 struct at_ifaddr *aa;
278 struct ifaddr ifa;
199 struct aarptab *aat;
200 int s;
201
202 if ( at_broadcast( destsat )) {
203 if (( aa = (struct at_ifaddr *)at_ifawithnet( destsat,
204 ((struct ifnet *)ac)->if_addrlist )) == NULL ) {
205 m_freem( m );
206 return( 0 );
207 }
208 if ( aa->aa_flags & AFA_PHASE2 ) {
209 bcopy( (caddr_t)atmulticastaddr, (caddr_t)desten,
210 sizeof( atmulticastaddr ));
211 } else {
292#ifdef sun
293 bcopy( (caddr_t)&etherbroadcastaddr, (caddr_t)desten,
294 sizeof( etherbroadcastaddr ));
295#else sun
212 bcopy( (caddr_t)etherbroadcastaddr, (caddr_t)desten,
213 sizeof( etherbroadcastaddr ));
298#endif sun
214 }
215 return( 1 );
216 }
217
218 s = splimp();
219 AARPTAB_LOOK( aat, destsat->sat_addr );
220 if ( aat == 0 ) { /* No entry */
221 aat = aarptnew( &destsat->sat_addr );

--- 28 unchanged lines hidden (view full) ---

250 struct arpcom *ac;
251 struct mbuf *m;
252{
253 struct arphdr *ar;
254
255 if ( ac->ac_if.if_flags & IFF_NOARP )
256 goto out;
257
343#ifndef BSD4_4
344 IF_ADJ( m );
345#endif BSD4_4
346
258 if ( m->m_len < sizeof( struct arphdr )) {
259 goto out;
260 }
261
262 ar = mtod( m, struct arphdr *);
263 if ( ntohs( ar->ar_hrd ) != AARPHRD_ETHER ) {
264 goto out;
265 }

--- 14 unchanged lines hidden (view full) ---

280
281out:
282 m_freem( m );
283}
284
285static void
286at_aarpinput( struct arpcom *ac, struct mbuf *m)
287{
377 struct mbuf *m0;
288 struct ether_aarp *ea;
289 struct at_ifaddr *aa;
290 struct aarptab *aat;
291 struct ether_header *eh;
292 struct llc *llc;
293 struct sockaddr_at sat;
294 struct sockaddr sa;
295 struct at_addr spa, tpa, ma;
386 int op, s;
296 int op;
297 u_short net;
298
299 ea = mtod( m, struct ether_aarp *);
300
301 /* Check to see if from my hardware address */
392#ifdef sun
393 if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )&ac->ac_enaddr,
394 sizeof( ac->ac_enaddr ))) {
395 m_freem( m );
396 return;
397 }
398#else sun
302 if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )ac->ac_enaddr,
303 sizeof( ac->ac_enaddr ))) {
304 m_freem( m );
305 return;
306 }
404#endif sun
307
308 op = ntohs( ea->aarp_op );
309 bcopy( ea->aarp_tpnet, &net, sizeof( net ));
310
311 if ( net != 0 ) { /* should be ATADDR_ANYNET? */
410#ifdef BSD4_4
312 sat.sat_len = sizeof(struct sockaddr_at);
412#endif BSD4_4
313 sat.sat_family = AF_APPLETALK;
314 sat.sat_addr.s_net = net;
315 if (( aa = (struct at_ifaddr *)at_ifawithnet( &sat,
316 ac->ac_if.if_addrlist )) == NULL ) {
317 m_freem( m );
318 return;
319 }
320 bcopy( ea->aarp_spnet, &spa.s_net, sizeof( spa.s_net ));

--- 37 unchanged lines hidden (view full) ---

358 m_freem( m );
359 return;
360 } else if ( op != AARPOP_PROBE ) {
361 /*
362 * This is not a probe, and we're not probing. This means
363 * that someone's saying they have the same source address
364 * as the one we're using. Get upset...
365 */
466#ifndef _IBMR2
467#ifdef ultrix
468 mprintf( LOG_ERR,
469#else ultrix
366 log( LOG_ERR,
471#endif ultrix
367 "aarp: duplicate AT address!! %x:%x:%x:%x:%x:%x\n",
368 ea->aarp_sha[ 0 ], ea->aarp_sha[ 1 ], ea->aarp_sha[ 2 ],
369 ea->aarp_sha[ 3 ], ea->aarp_sha[ 4 ], ea->aarp_sha[ 5 ]);
475#endif _IBMR2
370 m_freem( m );
371 return;
372 }
373 }
374
375 AARPTAB_LOOK( aat, spa );
376 if ( aat ) {
377 if ( op == AARPOP_PROBE ) {

--- 6 unchanged lines hidden (view full) ---

384 m_freem( m );
385 return;
386 }
387
388 bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
389 sizeof( ea->aarp_sha ));
390 aat->aat_flags |= ATF_COM;
391 if ( aat->aat_hold ) {
498#ifdef _IBMR2
499 /*
500 * Like in ddp_output(), we can't rely on the if_output
501 * routine to resolve AF_APPLETALK addresses, on the rs6k.
502 * So, we fill the destination ethernet address here.
503 *
504 * This should really be replaced with something like
505 * rsif_output(). XXX Will have to be for phase 2.
506 */
507 /* XXX maybe fill in the rest of the frame header */
508 sat.sat_family = AF_UNSPEC;
509 bcopy( aat->aat_enaddr, (*(struct sockaddr *)&sat).sa_data,
510 sizeof( aat->aat_enaddr ));
511#else _IBMR2
512#ifdef BSD4_4
392 sat.sat_len = sizeof(struct sockaddr_at);
514#endif BSD4_4
393 sat.sat_family = AF_APPLETALK;
394 sat.sat_addr = spa;
517#endif _IBMR2
395 (*ac->ac_if.if_output)( &ac->ac_if, aat->aat_hold,
519 (struct sockaddr *)&sat
520#if defined( __FreeBSD__ )
521 , NULL /* XXX */
522#endif __FreeBSD__
523 );
396 (struct sockaddr *)&sat, NULL); /* XXX */
397 aat->aat_hold = 0;
398 }
399 }
400
401 if ( aat == 0 && tpa.s_net == ma.s_net && tpa.s_node == ma.s_node
402 && op != AARPOP_PROBE ) {
403 if ( aat = aarptnew( &spa )) {
404 bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,

--- 9 unchanged lines hidden (view full) ---

414 if ( tpa.s_net != ma.s_net || tpa.s_node != ma.s_node ||
415 op == AARPOP_RESPONSE || ( aa->aa_flags & AFA_PROBING )) {
416 m_freem( m );
417 return;
418 }
419
420 bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )ea->aarp_tha,
421 sizeof( ea->aarp_sha ));
549#ifdef sun
550 bcopy(( caddr_t )&ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
551 sizeof( ea->aarp_sha ));
552#else sun
422 bcopy(( caddr_t )ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
423 sizeof( ea->aarp_sha ));
555#endif sun
424
425 /* XXX */
426 eh = (struct ether_header *)sa.sa_data;
559#ifdef sun
560 bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )&eh->ether_dhost,
561 sizeof( eh->ether_dhost ));
562#else sun
427 bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )eh->ether_dhost,
428 sizeof( eh->ether_dhost ));
565#endif sun
429
430 if ( aa->aa_flags & AFA_PHASE2 ) {
568#if defined(sun) && defined(i386)
431 eh->ether_type = htons( sizeof( struct llc ) +
432 sizeof( struct ether_aarp ));
571#else
572 eh->ether_type = sizeof( struct llc ) + sizeof( struct ether_aarp );
573#endif
574#ifdef BSD4_4
433 M_PREPEND( m, sizeof( struct llc ), M_DONTWAIT );
434 if ( m == NULL ) {
435 return;
436 }
579#else BSD4_4
580 MGET( m0, M_DONTWAIT, MT_HEADER );
581 if ( m0 == NULL ) {
582 m_freem( m );
583 return;
584 }
585 m0->m_next = m;
586 m = m0;
587 m->m_off = MMAXOFF - sizeof( struct llc );
588 m->m_len = sizeof ( struct llc );
589#endif BSD4_4
437 llc = mtod( m, struct llc *);
438 llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
439 llc->llc_control = LLC_UI;
440 bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
441 llc->llc_ether_type = htons( ETHERTYPE_AARP );
442
443 bcopy( ea->aarp_spnet, ea->aarp_tpnet, sizeof( ea->aarp_tpnet ));
444 bcopy( &ma.s_net, ea->aarp_spnet, sizeof( ea->aarp_spnet ));
445 } else {
599#if defined(sun) && defined(i386)
446 eh->ether_type = htons( ETHERTYPE_AARP );
601#else
602 eh->ether_type = ETHERTYPE_AARP;
603#endif
447 }
448
449 ea->aarp_tpnode = ea->aarp_spnode;
450 ea->aarp_spnode = ma.s_node;
451 ea->aarp_op = htons( AARPOP_RESPONSE );
452
610#ifdef BSD4_4
453 sa.sa_len = sizeof( struct sockaddr );
612#endif BSD4_4
454 sa.sa_family = AF_UNSPEC;
614 (*ac->ac_if.if_output)( &ac->ac_if, m, &sa
615#if defined( __FreeBSD__ )
616 , NULL /* XXX */
617#endif
618 );
455 (*ac->ac_if.if_output)( &ac->ac_if, m, &sa, NULL); /* XXX */
456 return;
457}
458
459static void
460aarptfree( struct aarptab *aat)
461{
462
463 if ( aat->aat_hold )

--- 71 unchanged lines hidden (view full) ---

535 if ( aa->aa_probcnt <= 0 ) {
536 aa->aa_flags &= ~AFA_PROBING;
537 wakeup( aa );
538 return;
539 } else {
540 timeout( (timeout_func_t)aarpprobe, (caddr_t)ac, hz / 5 );
541 }
542
706#ifdef BSD4_4
543 if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
544 return;
545 }
546 m->m_len = sizeof( *ea );
547 m->m_pkthdr.len = sizeof( *ea );
548 MH_ALIGN( m, sizeof( *ea ));
713#else BSD4_4
714 if (( m = m_get( M_DONTWAIT, MT_DATA )) == NULL ) {
715 return;
716 }
717 m->m_len = sizeof( *ea );
718 m->m_off = MMAXOFF - sizeof( *ea );
719#endif BSD4_4
549
550 ea = mtod( m, struct ether_aarp *);
551 bzero((caddr_t)ea, sizeof( *ea ));
552
553 ea->aarp_hrd = htons( AARPHRD_ETHER );
554 ea->aarp_pro = htons( ETHERTYPE_AT );
555 ea->aarp_hln = sizeof( ea->aarp_sha );
556 ea->aarp_pln = sizeof( ea->aarp_spu );
557 ea->aarp_op = htons( AARPOP_PROBE );
729#ifdef sun
730 bcopy((caddr_t)&ac->ac_enaddr, (caddr_t)ea->aarp_sha,
731 sizeof( ea->aarp_sha ));
732#else sun
558 bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
559 sizeof( ea->aarp_sha ));
735#endif sun
560
561 eh = (struct ether_header *)sa.sa_data;
562
563 if ( aa->aa_flags & AFA_PHASE2 ) {
740#ifdef sun
741 bcopy((caddr_t)atmulticastaddr, (caddr_t)&eh->ether_dhost,
742 sizeof( eh->ether_dhost ));
743#else sun
564 bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
565 sizeof( eh->ether_dhost ));
746#endif sun
747#if defined(sun) && defined(i386)
566 eh->ether_type = htons( sizeof( struct llc ) +
567 sizeof( struct ether_aarp ));
750#else
751 eh->ether_type = sizeof( struct llc ) + sizeof( struct ether_aarp );
752#endif
753#ifdef BSD4_4
568 M_PREPEND( m, sizeof( struct llc ), M_WAIT );
755#else BSD4_4
756 m->m_len += sizeof( struct llc );
757 m->m_off -= sizeof( struct llc );
758#endif BSD4_4
569 llc = mtod( m, struct llc *);
570 llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
571 llc->llc_control = LLC_UI;
572 bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
573 llc->llc_ether_type = htons( ETHERTYPE_AARP );
574
575 bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
576 sizeof( ea->aarp_spnet ));
577 bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_tpnet,
578 sizeof( ea->aarp_tpnet ));
579 ea->aarp_spnode = ea->aarp_tpnode = AA_SAT( aa )->sat_addr.s_node;
580 } else {
771#ifdef sun
772 bcopy((caddr_t)&etherbroadcastaddr, (caddr_t)&eh->ether_dhost,
773 sizeof( eh->ether_dhost ));
774#else sun
581 bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
582 sizeof( eh->ether_dhost ));
777#endif sun
778#if defined(sun) && defined(i386)
583 eh->ether_type = htons( ETHERTYPE_AARP );
780#else
781 eh->ether_type = ETHERTYPE_AARP;
782#endif
584 ea->aarp_spa = ea->aarp_tpa = AA_SAT( aa )->sat_addr.s_node;
585 }
586
587#ifdef NETATALKDEBUG
588 printf("aarp: sending probe for %u.%u\n",
589 ntohs(AA_SAT( aa )->sat_addr.s_net),
590 AA_SAT( aa )->sat_addr.s_node);
591#endif NETATALKDEBUG
592
792#ifdef BSD4_4
593 sa.sa_len = sizeof( struct sockaddr );
794#endif BSD4_4
594 sa.sa_family = AF_UNSPEC;
796 (*ac->ac_if.if_output)(&ac->ac_if, m, &sa
797#if defined( __FreeBSD__ )
798 , NULL /* XXX */
799#endif __FreeBSD__
800 );
595 (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, NULL); /* XXX */
596 aa->aa_probcnt--;
597}
598
599void
600aarp_clean(void)
601{
602 struct aarptab *aat;
603 int i;
604
605 untimeout( aarptimer, 0 );
606 for ( i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++ ) {
607 if ( aat->aat_hold ) {
608 m_freem( aat->aat_hold );
609 }
610 }
611}