Silence compiler warning by adding include files.
[dragonfly.git] / sys / netproto / atalk / aarp.c
1 /*
2  * Copyright (c) 1990,1991 Regents of The University of Michigan.
3  * All Rights Reserved.
4  *
5  * $FreeBSD: src/sys/netatalk/aarp.c,v 1.12.2.2 2001/06/23 20:43:09 iedowse Exp $
6  * $DragonFly: src/sys/netproto/atalk/aarp.c,v 1.9 2004/04/11 07:41:52 hsu Exp $
7  */
8
9 #include "opt_atalk.h"
10
11 #include <sys/param.h>
12 #include <sys/systm.h>
13 #include <sys/mbuf.h>
14 #include <sys/kernel.h>
15 #include <sys/socket.h>
16 #include <sys/syslog.h>
17
18 #include <sys/thread2.h>
19 #include <sys/msgport2.h>
20
21 #include <net/if.h>
22 #include <net/netisr.h>
23
24 #include <netinet/in.h>
25 #undef s_net
26 #include <netinet/if_ether.h>
27
28 #include "at.h"
29 #include "at_var.h"
30 #include "aarp.h"
31 #include "phase2.h"
32 #include "at_extern.h"
33
34 static void aarptfree( struct aarptab *aat);
35 static void at_aarpinput( struct arpcom *ac, struct mbuf *m);
36
37 #define AARPTAB_BSIZ    9
38 #define AARPTAB_NB      19
39 #define AARPTAB_SIZE    (AARPTAB_BSIZ * AARPTAB_NB)
40 static struct aarptab   aarptab[AARPTAB_SIZE];
41
42 #define AARPTAB_HASH(a) \
43     ((((a).s_net << 8 ) + (a).s_node ) % AARPTAB_NB )
44
45 #define AARPTAB_LOOK(aat,addr) { \
46     int         n; \
47     aat = &aarptab[ AARPTAB_HASH(addr) * AARPTAB_BSIZ ]; \
48     for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) \
49         if ( aat->aat_ataddr.s_net == (addr).s_net && \
50              aat->aat_ataddr.s_node == (addr).s_node ) \
51             break; \
52         if ( n >= AARPTAB_BSIZ ) \
53             aat = 0; \
54 }
55
56 #define AARPT_AGE       (60 * 1)
57 #define AARPT_KILLC     20
58 #define AARPT_KILLI     3
59
60 # if !defined( __DragonFly__ )
61 extern u_char                   etherbroadcastaddr[6];
62 # endif __DragonFly__
63
64 static u_char atmulticastaddr[ 6 ] = {
65     0x09, 0x00, 0x07, 0xff, 0xff, 0xff,
66 };
67
68 u_char  at_org_code[ 3 ] = {
69     0x08, 0x00, 0x07,
70 };
71 u_char  aarp_org_code[ 3 ] = {
72     0x00, 0x00, 0x00,
73 };
74
75 static struct callout_handle aarptimer_ch =
76     CALLOUT_HANDLE_INITIALIZER(&aarptimer_ch);
77
78 static void
79 aarptimer(void *ignored)
80 {
81     struct aarptab      *aat;
82     int                 i, s;
83
84     aarptimer_ch = timeout( aarptimer, (caddr_t)0, AARPT_AGE * hz );
85     aat = aarptab;
86     for ( i = 0; i < AARPTAB_SIZE; i++, aat++ ) {
87         if ( aat->aat_flags == 0 || ( aat->aat_flags & ATF_PERM ))
88             continue;
89         if ( ++aat->aat_timer < (( aat->aat_flags & ATF_COM ) ?
90                 AARPT_KILLC : AARPT_KILLI ))
91             continue;
92         s = splimp();
93         aarptfree( aat );
94         splx( s );
95     }
96 }
97
98 /* 
99  * search through the network addresses to find one that includes
100  * the given network.. remember to take netranges into
101  * consideration.
102  */
103 struct at_ifaddr *
104 at_ifawithnet(struct sockaddr_at  *sat )
105 {
106     struct at_ifaddr    *aa;
107     struct sockaddr_at  *sat2;
108
109         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
110                 sat2 = &(aa->aa_addr);
111                 if ( sat2->sat_addr.s_net == sat->sat_addr.s_net ) {
112                         break;
113                 }
114                 if( (aa->aa_flags & AFA_PHASE2 )
115                 && (ntohs(aa->aa_firstnet) <= ntohs(sat->sat_addr.s_net))
116                 && (ntohs(aa->aa_lastnet) >= ntohs(sat->sat_addr.s_net))) {
117                         break;
118                 }
119         }
120         return( aa );
121 }
122
123 static void
124 aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat )
125 {
126     struct mbuf         *m;
127     struct ether_header *eh;
128     struct ether_aarp   *ea;
129     struct at_ifaddr    *aa;
130     struct llc          *llc;
131     struct sockaddr     sa;
132
133     if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
134         return;
135     }
136     m->m_len = sizeof( *ea );
137     m->m_pkthdr.len = sizeof( *ea );
138     MH_ALIGN( m, sizeof( *ea ));
139
140     ea = mtod( m, struct ether_aarp *);
141     bzero((caddr_t)ea, sizeof( *ea ));
142
143     ea->aarp_hrd = htons( AARPHRD_ETHER );
144     ea->aarp_pro = htons( ETHERTYPE_AT );
145     ea->aarp_hln = sizeof( ea->aarp_sha );
146     ea->aarp_pln = sizeof( ea->aarp_spu );
147     ea->aarp_op = htons( AARPOP_REQUEST );
148     bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
149             sizeof( ea->aarp_sha ));
150
151     /*
152      * We need to check whether the output ethernet type should
153      * be phase 1 or 2. We have the interface that we'll be sending
154      * the aarp out. We need to find an AppleTalk network on that
155      * interface with the same address as we're looking for. If the
156      * net is phase 2, generate an 802.2 and SNAP header.
157      */
158     if ((aa = at_ifawithnet( sat )) == NULL) {
159         m_freem( m );
160         return;
161     }
162
163     eh = (struct ether_header *)sa.sa_data;
164
165     if ( aa->aa_flags & AFA_PHASE2 ) {
166         bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
167                 sizeof( eh->ether_dhost ));
168         eh->ether_type = htons(sizeof(struct llc) + sizeof(struct ether_aarp));
169         M_PREPEND( m, sizeof( struct llc ), M_WAIT );
170         llc = mtod( m, struct llc *);
171         llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
172         llc->llc_control = LLC_UI;
173         bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
174         llc->llc_ether_type = htons( ETHERTYPE_AARP );
175
176         bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
177                sizeof( ea->aarp_spnet ));
178         bcopy( &sat->sat_addr.s_net, ea->aarp_tpnet,
179                sizeof( ea->aarp_tpnet ));
180         ea->aarp_spnode = AA_SAT( aa )->sat_addr.s_node;
181         ea->aarp_tpnode = sat->sat_addr.s_node;
182     } else {
183         bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
184                 sizeof( eh->ether_dhost ));
185         eh->ether_type = htons( ETHERTYPE_AARP );
186
187         ea->aarp_spa = AA_SAT( aa )->sat_addr.s_node;
188         ea->aarp_tpa = sat->sat_addr.s_node;
189     }
190
191 #ifdef NETATALKDEBUG
192     printf("aarp: sending request for %u.%u\n",
193            ntohs(AA_SAT( aa )->sat_addr.s_net),
194            AA_SAT( aa )->sat_addr.s_node);
195 #endif /* NETATALKDEBUG */
196
197     sa.sa_len = sizeof( struct sockaddr );
198     sa.sa_family = AF_UNSPEC;
199     (*ac->ac_if.if_output)(&ac->ac_if,
200         m, &sa, NULL);  /* XXX NULL should be routing information */
201 }
202
203 int
204 aarpresolve( ac, m, destsat, desten )
205     struct arpcom       *ac;
206     struct mbuf         *m;
207     struct sockaddr_at  *destsat;
208     u_char              *desten;
209 {
210     struct at_ifaddr    *aa;
211     struct aarptab      *aat;
212     int                 s;
213
214     if ( at_broadcast( destsat )) {
215         m->m_flags |= M_BCAST;
216         if ((aa = at_ifawithnet( destsat )) == NULL)  {
217             m_freem( m );
218             return( 0 );
219         }
220         if ( aa->aa_flags & AFA_PHASE2 ) {
221             bcopy( (caddr_t)atmulticastaddr, (caddr_t)desten,
222                     sizeof( atmulticastaddr ));
223         } else {
224             bcopy( (caddr_t)etherbroadcastaddr, (caddr_t)desten,
225                     sizeof( etherbroadcastaddr ));
226         }
227         return( 1 );
228     }
229
230     s = splimp();
231     AARPTAB_LOOK( aat, destsat->sat_addr );
232     if ( aat == 0 ) {                   /* No entry */
233         aat = aarptnew( &destsat->sat_addr );
234         if ( aat == 0 ) {
235             panic( "aarpresolve: no free entry" );
236         }
237         aat->aat_hold = m;
238         aarpwhohas( ac, destsat );
239         splx( s );
240         return( 0 );
241     }
242     /* found an entry */
243     aat->aat_timer = 0;
244     if ( aat->aat_flags & ATF_COM ) {   /* entry is COMplete */
245         bcopy( (caddr_t)aat->aat_enaddr, (caddr_t)desten,
246                 sizeof( aat->aat_enaddr ));
247         splx( s );
248         return( 1 );
249     }
250     /* entry has not completed */
251     if ( aat->aat_hold ) {
252         m_freem( aat->aat_hold );
253     }
254     aat->aat_hold = m;
255     aarpwhohas( ac, destsat );
256     splx( s );
257     return( 0 );
258 }
259
260 void
261 aarpintr(struct netmsg *msg)
262 {
263     struct mbuf *m = ((struct netmsg_packet *)msg)->nm_packet;   
264     struct arphdr       *ar;
265     struct arpcom       *ac;
266
267     ac = (struct arpcom *)m->m_pkthdr.rcvif;
268     if ( ac->ac_if.if_flags & IFF_NOARP )
269         goto out;
270
271     if ( m->m_len < sizeof( struct arphdr )) {
272         goto out;
273     }
274
275     ar = mtod( m, struct arphdr *);
276     if ( ntohs( ar->ar_hrd ) != AARPHRD_ETHER ) {
277         goto out;
278     }
279     
280     if ( m->m_len < sizeof( struct arphdr ) + 2 * ar->ar_hln +
281             2 * ar->ar_pln ) {
282         goto out;
283     }
284     
285     switch( ntohs( ar->ar_pro )) {
286     case ETHERTYPE_AT :
287         at_aarpinput( ac, m );
288         goto out2;
289
290     default:
291         break;
292     }
293
294 out:
295     m_freem( m );
296 out2:
297     lwkt_replymsg(&msg->nm_lmsg, 0);
298 }
299
300 static void
301 at_aarpinput( struct arpcom *ac, struct mbuf *m)
302 {
303     struct ether_aarp   *ea;
304     struct at_ifaddr    *aa;
305     struct aarptab      *aat;
306     struct ether_header *eh;
307     struct llc          *llc;
308     struct sockaddr_at  sat;
309     struct sockaddr     sa;
310     struct at_addr      spa, tpa, ma;
311     int                 op;
312     u_short             net;
313
314     ea = mtod( m, struct ether_aarp *);
315
316     /* Check to see if from my hardware address */
317     if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )ac->ac_enaddr,
318             sizeof( ac->ac_enaddr ))) {
319         m_freem( m );
320         return;
321     }
322
323     op = ntohs( ea->aarp_op );
324     bcopy( ea->aarp_tpnet, &net, sizeof( net ));
325
326     if ( net != 0 ) { /* should be ATADDR_ANYNET? */
327         sat.sat_len = sizeof(struct sockaddr_at);
328         sat.sat_family = AF_APPLETALK;
329         sat.sat_addr.s_net = net;
330         if ((aa = at_ifawithnet( &sat )) == NULL) {
331             m_freem( m );
332             return;
333         }
334         bcopy( ea->aarp_spnet, &spa.s_net, sizeof( spa.s_net ));
335         bcopy( ea->aarp_tpnet, &tpa.s_net, sizeof( tpa.s_net ));
336     } else {
337         /*
338          * Since we don't know the net, we just look for the first
339          * phase 1 address on the interface.
340          */
341         for (aa = (struct at_ifaddr *)ac->ac_if.if_addrhead.tqh_first; aa;
342                 aa = (struct at_ifaddr *)aa->aa_ifa.ifa_link.tqe_next) {
343             if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
344                     ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
345                 break;
346             }
347         }
348         if ( aa == NULL ) {
349             m_freem( m );
350             return;
351         }
352         tpa.s_net = spa.s_net = AA_SAT( aa )->sat_addr.s_net;
353     }
354
355     spa.s_node = ea->aarp_spnode;
356     tpa.s_node = ea->aarp_tpnode;
357     ma.s_net = AA_SAT( aa )->sat_addr.s_net;
358     ma.s_node = AA_SAT( aa )->sat_addr.s_node;
359
360     /*
361      * This looks like it's from us.
362      */
363     if ( spa.s_net == ma.s_net && spa.s_node == ma.s_node ) {
364         if ( aa->aa_flags & AFA_PROBING ) {
365             /*
366              * We're probing, someone either responded to our probe, or
367              * probed for the same address we'd like to use. Change the
368              * address we're probing for.
369              */
370             untimeout( aarpprobe, ac, aa->aa_ch );
371             wakeup( aa );
372             m_freem( m );
373             return;
374         } else if ( op != AARPOP_PROBE ) {
375             /*
376              * This is not a probe, and we're not probing. This means
377              * that someone's saying they have the same source address
378              * as the one we're using. Get upset...
379              */
380             log( LOG_ERR,
381                     "aarp: duplicate AT address!! %x:%x:%x:%x:%x:%x\n",
382                     ea->aarp_sha[ 0 ], ea->aarp_sha[ 1 ], ea->aarp_sha[ 2 ],
383                     ea->aarp_sha[ 3 ], ea->aarp_sha[ 4 ], ea->aarp_sha[ 5 ]);
384             m_freem( m );
385             return;
386         }
387     }
388
389     AARPTAB_LOOK( aat, spa );
390     if ( aat ) {
391         if ( op == AARPOP_PROBE ) {
392             /*
393              * Someone's probing for spa, dealocate the one we've got,
394              * so that if the prober keeps the address, we'll be able
395              * to arp for him.
396              */
397             aarptfree( aat );
398             m_freem( m );
399             return;
400         }
401
402         bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
403                 sizeof( ea->aarp_sha ));
404         aat->aat_flags |= ATF_COM;
405         if ( aat->aat_hold ) {
406             struct mbuf *mhold = aat->aat_hold;
407             aat->aat_hold = NULL;
408             sat.sat_len = sizeof(struct sockaddr_at);
409             sat.sat_family = AF_APPLETALK;
410             sat.sat_addr = spa;
411             (*ac->ac_if.if_output)( &ac->ac_if, mhold,
412                     (struct sockaddr *)&sat, NULL); /* XXX */
413         }
414     } else if ((tpa.s_net == ma.s_net)
415            && (tpa.s_node == ma.s_node)
416            && (op != AARPOP_PROBE)
417            && ((aat = aarptnew( &spa )) != NULL)) {
418                 bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
419                     sizeof( ea->aarp_sha ));
420                 aat->aat_flags |= ATF_COM;
421     }
422
423     /*
424      * Don't respond to responses, and never respond if we're
425      * still probing.
426      */
427     if ( tpa.s_net != ma.s_net || tpa.s_node != ma.s_node ||
428             op == AARPOP_RESPONSE || ( aa->aa_flags & AFA_PROBING )) {
429         m_freem( m );
430         return;
431     }
432
433     bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )ea->aarp_tha,
434             sizeof( ea->aarp_sha ));
435     bcopy(( caddr_t )ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
436             sizeof( ea->aarp_sha ));
437
438     /* XXX */
439     eh = (struct ether_header *)sa.sa_data;
440     bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )eh->ether_dhost,
441             sizeof( eh->ether_dhost ));
442
443     if ( aa->aa_flags & AFA_PHASE2 ) {
444         eh->ether_type = htons( sizeof( struct llc ) +
445                 sizeof( struct ether_aarp ));
446         M_PREPEND( m, sizeof( struct llc ), M_DONTWAIT );
447         if ( m == NULL ) {
448             return;
449         }
450         llc = mtod( m, struct llc *);
451         llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
452         llc->llc_control = LLC_UI;
453         bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
454         llc->llc_ether_type = htons( ETHERTYPE_AARP );
455
456         bcopy( ea->aarp_spnet, ea->aarp_tpnet, sizeof( ea->aarp_tpnet ));
457         bcopy( &ma.s_net, ea->aarp_spnet, sizeof( ea->aarp_spnet ));
458     } else {
459         eh->ether_type = htons( ETHERTYPE_AARP );
460     }
461
462     ea->aarp_tpnode = ea->aarp_spnode;
463     ea->aarp_spnode = ma.s_node;
464     ea->aarp_op = htons( AARPOP_RESPONSE );
465
466     sa.sa_len = sizeof( struct sockaddr );
467     sa.sa_family = AF_UNSPEC;
468     (*ac->ac_if.if_output)( &ac->ac_if, m, &sa, NULL); /* XXX */
469     return;
470 }
471
472 static void
473 aarptfree( struct aarptab *aat)
474 {
475
476     if ( aat->aat_hold )
477         m_freem( aat->aat_hold );
478     aat->aat_hold = NULL;
479     aat->aat_timer = aat->aat_flags = 0;
480     aat->aat_ataddr.s_net = 0;
481     aat->aat_ataddr.s_node = 0;
482 }
483
484     struct aarptab *
485 aarptnew( addr )
486     struct at_addr      *addr;
487 {
488     int                 n;
489     int                 oldest = -1;
490     struct aarptab      *aat, *aato = NULL;
491     static int          first = 1;
492
493     if ( first ) {
494         first = 0;
495         aarptimer_ch = timeout( aarptimer, (caddr_t)0, hz );
496     }
497     aat = &aarptab[ AARPTAB_HASH( *addr ) * AARPTAB_BSIZ ];
498     for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) {
499         if ( aat->aat_flags == 0 )
500             goto out;
501         if ( aat->aat_flags & ATF_PERM )
502             continue;
503         if ((int) aat->aat_timer > oldest ) {
504             oldest = aat->aat_timer;
505             aato = aat;
506         }
507     }
508     if ( aato == NULL )
509         return( NULL );
510     aat = aato;
511     aarptfree( aat );
512 out:
513     aat->aat_ataddr = *addr;
514     aat->aat_flags = ATF_INUSE;
515     return( aat );
516 }
517
518
519 void
520 aarpprobe( void *arg )
521 {
522     struct arpcom       *ac = arg;
523     struct mbuf         *m;
524     struct ether_header *eh;
525     struct ether_aarp   *ea;
526     struct at_ifaddr    *aa;
527     struct llc          *llc;
528     struct sockaddr     sa;
529
530     /*
531      * We need to check whether the output ethernet type should
532      * be phase 1 or 2. We have the interface that we'll be sending
533      * the aarp out. We need to find an AppleTalk network on that
534      * interface with the same address as we're looking for. If the
535      * net is phase 2, generate an 802.2 and SNAP header.
536      */
537     for (aa = (struct at_ifaddr *)ac->ac_if.if_addrhead.tqh_first; aa;
538             aa = (struct at_ifaddr *)aa->aa_ifa.ifa_link.tqe_next) {
539         if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
540                 ( aa->aa_flags & AFA_PROBING )) {
541             break;
542         }
543     }
544     if ( aa == NULL ) {         /* serious error XXX */
545         printf( "aarpprobe why did this happen?!\n" );
546         return;
547     }
548
549     if ( aa->aa_probcnt <= 0 ) {
550         aa->aa_flags &= ~AFA_PROBING;
551         wakeup( aa );
552         return;
553     } else {
554         aa->aa_ch = timeout( aarpprobe, (caddr_t)ac, hz / 5 );
555     }
556
557     if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
558         return;
559     }
560     m->m_len = sizeof( *ea );
561     m->m_pkthdr.len = sizeof( *ea );
562     MH_ALIGN( m, sizeof( *ea ));
563
564     ea = mtod( m, struct ether_aarp *);
565     bzero((caddr_t)ea, sizeof( *ea ));
566
567     ea->aarp_hrd = htons( AARPHRD_ETHER );
568     ea->aarp_pro = htons( ETHERTYPE_AT );
569     ea->aarp_hln = sizeof( ea->aarp_sha );
570     ea->aarp_pln = sizeof( ea->aarp_spu );
571     ea->aarp_op = htons( AARPOP_PROBE );
572     bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
573             sizeof( ea->aarp_sha ));
574
575     eh = (struct ether_header *)sa.sa_data;
576
577     if ( aa->aa_flags & AFA_PHASE2 ) {
578         bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
579                 sizeof( eh->ether_dhost ));
580         eh->ether_type = htons( sizeof( struct llc ) +
581                 sizeof( struct ether_aarp ));
582         M_PREPEND( m, sizeof( struct llc ), M_WAIT );
583         /* XXX-MBUF */
584         llc = mtod( m, struct llc *);
585         llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
586         llc->llc_control = LLC_UI;
587         bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
588         llc->llc_ether_type = htons( ETHERTYPE_AARP );
589
590         bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
591                 sizeof( ea->aarp_spnet ));
592         bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_tpnet,
593                 sizeof( ea->aarp_tpnet ));
594         ea->aarp_spnode = ea->aarp_tpnode = AA_SAT( aa )->sat_addr.s_node;
595     } else {
596         bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
597                 sizeof( eh->ether_dhost ));
598         eh->ether_type = htons( ETHERTYPE_AARP );
599         ea->aarp_spa = ea->aarp_tpa = AA_SAT( aa )->sat_addr.s_node;
600     }
601
602 #ifdef NETATALKDEBUG
603     printf("aarp: sending probe for %u.%u\n",
604            ntohs(AA_SAT( aa )->sat_addr.s_net),
605            AA_SAT( aa )->sat_addr.s_node);
606 #endif /* NETATALKDEBUG */
607
608     sa.sa_len = sizeof( struct sockaddr );
609     sa.sa_family = AF_UNSPEC;
610     (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, NULL); /* XXX */
611     aa->aa_probcnt--;
612 }
613
614 void
615 aarp_clean(void)
616 {
617     struct aarptab      *aat;
618     int                 i;
619
620     untimeout( aarptimer, 0, aarptimer_ch );
621     for ( i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++ ) {
622         if ( aat->aat_hold ) {
623             m_freem( aat->aat_hold );
624             aat->aat_hold = NULL;
625         }
626     }
627 }