root/netatalk/aarp.c

DEFINITIONS

1. aarptimer
2. at_ifawithnet
3. aarpwhohas
4. aarpresolve
5. aarpinput
6. at_aarpinput
7. aarptfree
8. aarptnew
9. aarpprobe
10. aarp_clean

    1 /*      $OpenBSD: aarp.c,v 1.7 2006/04/25 05:52:43 tedu Exp $   */
    3 /*
    4  * Copyright (c) 1990,1991 Regents of The University of Michigan.
    5  * All Rights Reserved.
    6  */
    8 /*
    9  * The following is the contents of the COPYRIGHT file from the
   10  * netatalk-1.4a2 distribution, from which this file is derived.
   11  */
   12 /*
   13  * Copyright (c) 1990,1996 Regents of The University of Michigan.
   14  *
   15  * All Rights Reserved.
   16  *
   17  *    Permission to use, copy, modify, and distribute this software and
   18  *    its documentation for any purpose and without fee is hereby granted,
   19  *    provided that the above copyright notice appears in all copies and
   20  *    that both that copyright notice and this permission notice appear
   21  *    in supporting documentation, and that the name of The University
   22  *    of Michigan not be used in advertising or publicity pertaining to
   23  *    distribution of the software without specific, written prior
   24  *    permission. This software is supplied as is without expressed or
   25  *    implied warranties of any kind.
   26  *
   27  * This product includes software developed by the University of
   28  * California, Berkeley and its contributors.
   29  *
   30  * Solaris code is encumbered by the following:
   31  *
   32  *     Copyright (C) 1996 by Sun Microsystems Computer Co.
   33  *
   34  *     Permission to use, copy, modify, and distribute this software and
   35  *     its documentation for any purpose and without fee is hereby
   36  *     granted, provided that the above copyright notice appear in all
   37  *     copies and that both that copyright notice and this permission
   38  *     notice appear in supporting documentation.  This software is
   39  *     provided "as is" without express or implied warranty.
   40  *
   41  * Research Systems Unix Group
   42  * The University of Michigan
   43  * c/o Wesley Craig
   44  * 535 W. William Street
   45  * Ann Arbor, Michigan
   46  * +1-313-764-2278
   47  * netatalk@umich.edu
   48  */
   49 /*
   50  * None of the Solaris code mentioned is included in OpenBSD.
   51  * This code also relies heavily on previous effort in FreeBSD and NetBSD.
   52  */
   54 #include <sys/param.h>
   55 #include <sys/systm.h>
   56 #include <sys/kernel.h>
   57 #include <sys/malloc.h>
   58 #include <sys/mbuf.h>
   59 #include <sys/protosw.h>
   60 #include <sys/socket.h>
   61 #include <sys/ioctl.h>
   62 #include <sys/errno.h>
   63 #include <sys/syslog.h>
   64 #include <sys/proc.h>
   65 #include <sys/timeout.h>
   67 #include <net/if.h>
   68 #include <net/route.h>
   69 #include <netinet/in.h>
   70 #undef s_net
   71 #include <netinet/if_ether.h>
   72 #include <net/if_llc.h>
   74 #include <machine/endian.h>
   76 #include <netatalk/at.h>
   77 #include <netatalk/at_var.h>
   78 #include <netatalk/aarp.h>
   79 #include <netatalk/ddp_var.h>
   80 #include <netatalk/phase2.h>
   81 #include <netatalk/at_extern.h>
   83 static void aarptimer(void *);
   84 struct ifaddr *at_ifawithnet(struct sockaddr_at *, struct ifaddr *);
   85 static void aarpwhohas(struct arpcom *, struct sockaddr_at *);
   86 int aarpresolve(struct arpcom *, struct mbuf *,
   87                                         struct sockaddr_at *, u_int8_t *);
   88 void aarpinput(struct arpcom *, struct mbuf *);
   89 static void at_aarpinput(struct arpcom *, struct mbuf *);
   90 static void aarptfree(struct aarptab *);
   91 struct aarptab *aarptnew(struct at_addr *);
   92 void aarpprobe(void *);
   93 void aarp_clean(void);
   95 #ifdef GATEWAY
   96 #define AARPTAB_BSIZ    16
   97 #define AARPTAB_NB      37
   98 #else
   99 #define AARPTAB_BSIZ    9
  100 #define AARPTAB_NB      19
  101 #endif /* GATEWAY */
  103 #define AARPTAB_SIZE    (AARPTAB_BSIZ * AARPTAB_NB)
  104 struct aarptab          aarptab[AARPTAB_SIZE];
  105 int                     aarptab_size = AARPTAB_SIZE;
  107 struct timeout  aarpprobe_timeout;
  108 struct timeout  aarptimer_timeout;
  110 #define AARPTAB_HASH(a) \
  111     ((((a).s_net << 8 ) + (a).s_node ) % AARPTAB_NB )
  113 #define AARPTAB_LOOK(aat,addr) { \
  114     int         n; \
aat = &aarptab[ AARPTAB_HASH(addr) * AARPTAB_BSIZ ]; \
  116     for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) \
  117         if ( aat->aat_ataddr.s_net == (addr).s_net && \
aat->aat_ataddr.s_node == (addr).s_node ) \
  119             break; \
  120         if ( n >= AARPTAB_BSIZ ) \
aat = 0; \
  122 }
  124 #define AARPT_AGE       (60 * 1)
  125 #define AARPT_KILLC     20
  126 #define AARPT_KILLI     3
u_int8_t        atmulticastaddr[ 6 ] = {
  129     0x09, 0x00, 0x07, 0xff, 0xff, 0xff,
  130 };
u_int8_t        at_org_code[ 3 ] = {
  133     0x08, 0x00, 0x07,
  134 };
u_int8_t        aarp_org_code[ 3 ] = {
  136     0x00, 0x00, 0x00,
  137 };
  139 /*ARGSUSED*/
  140 static void
aarptimer(v)
  142         void *v;
  143 {
  144     struct aarptab      *aat;
  145     int                 i, s;
timeout_add(&aarptimer_timeout, AARPT_AGE * hz);
aat = aarptab;
  149     for ( i = 0; i < AARPTAB_SIZE; i++, aat++ ) {
  150         if ( aat->aat_flags == 0 || ( aat->aat_flags & ATF_PERM ))
  151             continue;
  152         if ( ++aat->aat_timer < (( aat->aat_flags & ATF_COM ) ?
AARPT_KILLC : AARPT_KILLI ))
  154             continue;
s = splnet();
aarptfree( aat );
splx( s );
  158     }
  159 }
  161 struct ifaddr *
at_ifawithnet( sat, ifa )
  163     struct sockaddr_at  *sat;
  164     struct ifaddr       *ifa;
  165 {
  166     struct sockaddr_at  *sat2;
  167     struct netrange     *nr;
  169     for (; ifa; ifa = ifa->ifa_list.tqe_next ) {
  170         if ( ifa->ifa_addr->sa_family != AF_APPLETALK ) {
  171             continue;
  172         }
sat2 = satosat( ifa->ifa_addr );
  174         if ( sat2->sat_addr.s_net == sat->sat_addr.s_net ) {
  175             break;
  176         }
nr = (struct netrange *)(sat2->sat_zero);
  178         if( (nr->nr_phase == 2 )
  179          && (ntohs(nr->nr_firstnet) <= ntohs(sat->sat_addr.s_net))
  180          && (ntohs(nr->nr_lastnet) >= ntohs(sat->sat_addr.s_net))) {
  181             break;
  182         }
  183     }
  184     return( ifa );
  185 }
  187 static void
aarpwhohas( ac, sat )
  189     struct arpcom       *ac;
  190     struct sockaddr_at  *sat;
  191 {
  192     struct mbuf         *m;
  193     struct ether_header *eh;
  194     struct ether_aarp   *ea;
  195     struct at_ifaddr    *aa;
  196     struct llc          *llc;
  197     struct sockaddr     sa;
  199     if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
  200         return;
  201     }
m->m_len = sizeof( *ea );
m->m_pkthdr.len = sizeof( *ea );
MH_ALIGN( m, sizeof( *ea ));
ea = mtod( m, struct ether_aarp *);
bzero((caddr_t)ea, sizeof( *ea ));
ea->aarp_hrd = htons( AARPHRD_ETHER );
ea->aarp_pro = htons( ETHERTYPE_AT );
ea->aarp_hln = sizeof( ea->aarp_sha );
ea->aarp_pln = sizeof( ea->aarp_spu );
ea->aarp_op = htons( AARPOP_REQUEST );
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
  215             sizeof( ea->aarp_sha ));
  217     /*
  218      * We need to check whether the output ethernet type should
  219      * be phase 1 or 2. We have the interface that we'll be sending
  220      * the aarp out. We need to find an AppleTalk network on that
  221      * interface with the same address as we're looking for. If the
  222      * net is phase 2, generate an 802.2 and SNAP header.
  223      */
  224     if (( aa = (struct at_ifaddr *)
at_ifawithnet( sat, ac->ac_if.if_addrlist.tqh_first )) == NULL ) {
m_freem( m );
  227         return;
  228     }
eh = (struct ether_header *)sa.sa_data;
  232     if ( aa->aa_flags & AFA_PHASE2 ) {
bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
  234                 sizeof( eh->ether_dhost ));
eh->ether_type = htons(AT_LLC_SIZE + sizeof(struct ether_aarp));
M_PREPEND( m, AT_LLC_SIZE, M_DONTWAIT );
  237         if (!m)
  238             return;
llc = mtod( m, struct llc *);
llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
llc->llc_control = LLC_UI;
bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
llc->llc_ether_type = htons( ETHERTYPE_AARP );
bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
  247                 sizeof( ea->aarp_spnet ));
ea->aarp_spnode = AA_SAT( aa )->sat_addr.s_node;
bcopy( &sat->sat_addr.s_net, ea->aarp_tpnet,
  250                 sizeof( ea->aarp_tpnet ));
ea->aarp_tpnode = sat->sat_addr.s_node;
  252     } else {
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
  254                 sizeof( eh->ether_dhost ));
eh->ether_type = htons( ETHERTYPE_AARP );
ea->aarp_spa = AA_SAT( aa )->sat_addr.s_node;
ea->aarp_tpa = sat->sat_addr.s_node;
  259     }
sa.sa_len = sizeof( struct sockaddr );
sa.sa_family = AF_UNSPEC;
  263     /* XXX The NULL should be a struct rtentry. TBD */
  264     (*ac->ac_if.if_output)(&ac->ac_if, m, &sa , NULL);
  265 }
  267 int
aarpresolve( ac, m, destsat, desten )
  269     struct arpcom       *ac;
  270     struct mbuf         *m;
  271     struct sockaddr_at  *destsat;
u_int8_t            *desten;
  273 {
  274     struct at_ifaddr    *aa;
  275     struct aarptab      *aat;
  276     int                 s;
  278     if ( at_broadcast( destsat )) {
  279         if (( aa = (struct at_ifaddr *)at_ifawithnet( destsat,
  280                 ((struct ifnet *)ac)->if_addrlist.tqh_first )) == NULL ) {
m_freem( m );
  282             return( 0 );
  283         }
  284         if ( aa->aa_flags & AFA_PHASE2 ) {
bcopy( (caddr_t)atmulticastaddr, (caddr_t)desten,
  286                     sizeof( atmulticastaddr ));
  287         } else {
bcopy( (caddr_t)etherbroadcastaddr, (caddr_t)desten,
  289                     sizeof( etherbroadcastaddr ));
  290         }
  291         return( 1 );
  292     }
s = splnet();
AARPTAB_LOOK( aat, destsat->sat_addr );
  296     if ( aat == 0 ) {                   /* No entry */
aat = aarptnew( &destsat->sat_addr );
  298         if ( aat == 0 ) { /* XXX allocate more */
panic( "aarpresolve: no free entry" );
  300         }
aat->aat_hold = m;
aarpwhohas( ac, destsat );
splx( s );
  304         return( 0 );
  305     }
  306     /* found an entry */
aat->aat_timer = 0;
  308     if ( aat->aat_flags & ATF_COM ) {   /* entry is COMplete */
bcopy( (caddr_t)aat->aat_enaddr, (caddr_t)desten,
  310                 sizeof( aat->aat_enaddr ));
splx( s );
  312         return( 1 );
  313     }
  314     /* entry has not completed */
  315     if ( aat->aat_hold ) {
m_freem( aat->aat_hold );
  317     }
aat->aat_hold = m;
aarpwhohas( ac, destsat );
splx( s );
  321     return( 0 );
  322 }
  324 void
aarpinput( ac, m )
  326     struct arpcom       *ac;
  327     struct mbuf         *m;
  328 {
  329     struct arphdr       *ar;
  331     if ( ac->ac_if.if_flags & IFF_NOARP )
  332         goto out;
  334     if ( m->m_len < sizeof( struct arphdr )) {
  335         goto out;
  336     }
ar = mtod( m, struct arphdr *);
  339     if ( ntohs( ar->ar_hrd ) != AARPHRD_ETHER ) {
  340         goto out;
  341     }
  343     if ( m->m_len < sizeof( struct arphdr ) + 2 * ar->ar_hln +
  344             2 * ar->ar_pln ) {
  345         goto out;
  346     }
  348     switch( ntohs( ar->ar_pro )) {
  349     case ETHERTYPE_AT :
at_aarpinput( ac, m );
  351         return;
  353     default:
  354         break;
  355     }
out:
m_freem( m );
  359 }
  362 static void
at_aarpinput( ac, m )
  364     struct arpcom       *ac;
  365     struct mbuf         *m;
  366 {
  367     struct ether_aarp   *ea;
  368     struct at_ifaddr    *aa;
  369     struct aarptab      *aat;
  370     struct ether_header *eh;
  371     struct llc          *llc;
  372     struct sockaddr_at  sat;
  373     struct sockaddr     sa;
  374     struct at_addr      spa, tpa, ma;
  375     int                 op;
u_int16_t           net;
ea = mtod( m, struct ether_aarp *);
  380     /* Check to see if from my hardware address */
  381     if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )ac->ac_enaddr,
  382             sizeof( ac->ac_enaddr ))) {
m_freem( m );
  384         return;
  385     }
  387     /*
  388      * Check if from broadcast address.  This could be a more robust
  389      * check, since we could look for multicasts. XXX
  390      */
  391     if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )etherbroadcastaddr,
  392             sizeof( etherbroadcastaddr ))) {
log( LOG_ERR,
  394                 "aarp: source is broadcast!\n" );
m_freem( m );
  396         return;
  397     }
op = ntohs( ea->aarp_op );
bcopy( ea->aarp_tpnet, &net, sizeof( net ));
  402     if ( net != 0 ) {
sat.sat_len = sizeof(struct sockaddr_at);
sat.sat_family = AF_APPLETALK;
sat.sat_addr.s_net = net;
  406         if (( aa = (struct at_ifaddr *)at_ifawithnet( &sat,
ac->ac_if.if_addrlist.tqh_first )) == NULL ) {
m_freem( m );
  409             return;
  410         }
bcopy( ea->aarp_spnet, &spa.s_net, sizeof( spa.s_net ));
bcopy( ea->aarp_tpnet, &tpa.s_net, sizeof( tpa.s_net ));
  413     } else {
  414         /*
  415          * Since we don't know the net, we just look for the first
  416          * phase 1 address on the interface.
  417          */
  418         for ( aa = (struct at_ifaddr *)ac->ac_if.if_addrlist.tqh_first; aa;
aa = (struct at_ifaddr *)aa->aa_ifa.ifa_list.tqe_next ) {
  420             if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
  421                     ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
  422                 break;
  423             }
  424         }
  425         if ( aa == NULL ) {
m_freem( m );
  427             return;
  428         }
tpa.s_net = spa.s_net = AA_SAT( aa )->sat_addr.s_net;
  430     }
spa.s_node = ea->aarp_spnode;
tpa.s_node = ea->aarp_tpnode;
ma.s_net = AA_SAT( aa )->sat_addr.s_net;
ma.s_node = AA_SAT( aa )->sat_addr.s_node;
  437     /*
  438      * This looks like it's from us.
  439      */
  440     if ( spa.s_net == ma.s_net && spa.s_node == ma.s_node ) {
  441         if ( aa->aa_flags & AFA_PROBING ) {
  442             /*
  443              * We're probing, someone either responded to our probe, or
  444              * probed for the same address we'd like to use. Change the
  445              * address we're probing for.
  446              */
timeout_del(&aarpprobe_timeout);
wakeup( aa );
m_freem( m );
  450             return;
  451         } else if ( op != AARPOP_PROBE ) {
  452             /*
  453              * This is not a probe, and we're not probing. This means
  454              * that someone's saying they have the same source address
  455              * as the one we're using. Get upset...
  456              */
  457             /* XXX use ether_ntoa */
log( LOG_ERR,
  459                     "aarp: duplicate AT address!! %x:%x:%x:%x:%x:%x\n",
ea->aarp_sha[ 0 ], ea->aarp_sha[ 1 ], ea->aarp_sha[ 2 ],
ea->aarp_sha[ 3 ], ea->aarp_sha[ 4 ], ea->aarp_sha[ 5 ]);
m_freem( m );
  463             return;
  464         }
  465     }
AARPTAB_LOOK( aat, spa );
  468     if ( aat ) {
  469         if ( op == AARPOP_PROBE ) {
  470             /*
  471              * Someone's probing for spa, dealocate the one we've got,
  472              * so that if the prober keeps the address, we'll be able
  473              * to arp for him.
  474              */
aarptfree( aat );
m_freem( m );
  477             return;
  478         }
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
  481                 sizeof( ea->aarp_sha ));
aat->aat_flags |= ATF_COM;
  483         if ( aat->aat_hold ) {
sat.sat_len = sizeof(struct sockaddr_at);
sat.sat_family = AF_APPLETALK;
sat.sat_addr = spa;
  487             /* XXX the NULL should be a struct rtentry */
  488             (*ac->ac_if.if_output)( &ac->ac_if, aat->aat_hold,
  489                     (struct sockaddr *)&sat, NULL );
aat->aat_hold = 0;
  491         }
  492     }
  494     if ( aat == 0 && tpa.s_net == ma.s_net && tpa.s_node == ma.s_node
  495             && op != AARPOP_PROBE ) {
  496         if ( (aat = aarptnew( &spa ))) {
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
  498                     sizeof( ea->aarp_sha ));
aat->aat_flags |= ATF_COM;
  500         }
  501     }
  503     /*
  504      * Don't respond to responses, and never respond if we're
  505      * still probing.
  506      */
  507     if ( tpa.s_net != ma.s_net || tpa.s_node != ma.s_node ||
op == AARPOP_RESPONSE || ( aa->aa_flags & AFA_PROBING )) {
m_freem( m );
  510         return;
  511     }
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )ea->aarp_tha,
  514             sizeof( ea->aarp_sha ));
bcopy(( caddr_t )ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
  516             sizeof( ea->aarp_sha ));
  518     /* XXX FreeBSD has an 'XXX' here but no comment as to why. */
eh = (struct ether_header *)sa.sa_data;
bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )eh->ether_dhost,
  521             sizeof( eh->ether_dhost ));
  523     if ( aa->aa_flags & AFA_PHASE2 ) {
eh->ether_type = htons( AT_LLC_SIZE +
  525                 sizeof( struct ether_aarp ));
M_PREPEND( m, AT_LLC_SIZE, M_DONTWAIT );
  527         if ( m == NULL ) {
  528             return;
  529         }
llc = mtod( m, struct llc *);
llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
llc->llc_control = LLC_UI;
bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
llc->llc_ether_type = htons( ETHERTYPE_AARP );
bcopy( ea->aarp_spnet, ea->aarp_tpnet, sizeof( ea->aarp_tpnet ));
bcopy( &ma.s_net, ea->aarp_spnet, sizeof( ea->aarp_spnet ));
  538     } else {
eh->ether_type = htons( ETHERTYPE_AARP );
  540     }
ea->aarp_tpnode = ea->aarp_spnode;
ea->aarp_spnode = ma.s_node;
ea->aarp_op = htons( AARPOP_RESPONSE );
sa.sa_len = sizeof( struct sockaddr );
sa.sa_family = AF_UNSPEC;
  548     /* XXX the NULL should be a struct rtentry */
  549     (*ac->ac_if.if_output)( &ac->ac_if, m, &sa, NULL );
  550     return;
  551 }
  553 static void
aarptfree( aat )
  555     struct aarptab      *aat;
  556 {
  558     if ( aat->aat_hold )
m_freem( aat->aat_hold );
aat->aat_hold = 0;
aat->aat_timer = aat->aat_flags = 0;
aat->aat_ataddr.s_net = 0;
aat->aat_ataddr.s_node = 0;
  564 }
  566 struct aarptab *
aarptnew( addr )
  568     struct at_addr      *addr;
  569 {
  570     int                 n;
  571     int                 oldest = -1;
  572     struct aarptab      *aat, *aato = NULL;
  573     static int          first = 1;
  575     if ( first ) {
first = 0;
timeout_set(&aarptimer_timeout, aarptimer, NULL);
timeout_add(&aarptimer_timeout, hz);
  579     }
aat = &aarptab[ AARPTAB_HASH( *addr ) * AARPTAB_BSIZ ];
  581     for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) {
  582         if ( aat->aat_flags == 0 )
  583             goto out;
  584         if ( aat->aat_flags & ATF_PERM )
  585             continue;
  586         if ((int) aat->aat_timer > oldest ) {
oldest = aat->aat_timer;
aato = aat;
  589         }
  590     }
  591     if ( aato == NULL )
  592         return( NULL );
aat = aato;
aarptfree( aat );
out:
aat->aat_ataddr = *addr;
aat->aat_flags = ATF_INUSE;
  598     return( aat );
  599 }
  601 void
aarpprobe( arg )
  603     void        *arg;
  604 {
  605     struct arpcom       *ac = (struct arpcom *) arg;
  606     struct mbuf         *m;
  607     struct ether_header *eh;
  608     struct ether_aarp   *ea;
  609     struct at_ifaddr    *aa;
  610     struct llc          *llc;
  611     struct sockaddr     sa;
  613     /*
  614      * We need to check whether the output ethernet type should
  615      * be phase 1 or 2. We have the interface that we'll be sending
  616      * the aarp out. We need to find an AppleTalk network on that
  617      * interface with the same address as we're looking for. If the
  618      * net is phase 2, generate an 802.2 and SNAP header.
  619      */
  620     for ( aa = (struct at_ifaddr *)ac->ac_if.if_addrlist.tqh_first; aa;
aa = (struct at_ifaddr *)aa->aa_ifa.ifa_list.tqe_next) {
  622         if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
  623                 ( aa->aa_flags & AFA_PROBING )) {
  624             break;
  625         }
  626     }
  627     if ( aa == NULL ) {         /* serious error XXX */
printf( "aarpprobe why did this happen?!\n" );
  629         return;
  630     }
  632     if ( aa->aa_probcnt <= 0 ) {
aa->aa_flags &= ~AFA_PROBING;
wakeup( aa );
  635         return;
  636     } else {
timeout_set(&aarpprobe_timeout, aarpprobe, ac);
timeout_add(&aarpprobe_timeout, hz / 5);
  639     }
  641     if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
  642         return;
  643     }
m->m_len = sizeof( *ea );
m->m_pkthdr.len = sizeof( *ea );
MH_ALIGN( m, sizeof( *ea ));
ea = mtod( m, struct ether_aarp *);
bzero((caddr_t)ea, sizeof( *ea ));
ea->aarp_hrd = htons( AARPHRD_ETHER );
ea->aarp_pro = htons( ETHERTYPE_AT );
ea->aarp_hln = sizeof( ea->aarp_sha );
ea->aarp_pln = sizeof( ea->aarp_spu );
ea->aarp_op = htons( AARPOP_PROBE );
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
  657             sizeof( ea->aarp_sha ));
eh = (struct ether_header *)sa.sa_data;
  661     if ( aa->aa_flags & AFA_PHASE2 ) {
bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
  663                 sizeof( eh->ether_dhost ));
eh->ether_type = htons( AT_LLC_SIZE +
  665                 sizeof( struct ether_aarp ));
M_PREPEND( m, AT_LLC_SIZE, M_DONTWAIT );
  667         if (!m)
  668             return;
llc = mtod( m, struct llc *);
llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
llc->llc_control = LLC_UI;
bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
llc->llc_ether_type = htons( ETHERTYPE_AARP );
bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
  677                 sizeof( ea->aarp_spnet ));
bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_tpnet,
  679                 sizeof( ea->aarp_tpnet ));
ea->aarp_spnode = ea->aarp_tpnode = AA_SAT( aa )->sat_addr.s_node;
  681     } else {
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
  683                 sizeof( eh->ether_dhost ));
eh->ether_type = htons( ETHERTYPE_AARP );
ea->aarp_spa = ea->aarp_tpa = AA_SAT( aa )->sat_addr.s_node;
  686     }
sa.sa_len = sizeof( struct sockaddr );
sa.sa_family = AF_UNSPEC;
  690     /* XXX the NULL should be a struct rtentry */
  691     (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, NULL );
aa->aa_probcnt--;
  693 }
  695 void
aarp_clean(void)
  697 {
  698     struct aarptab      *aat;
  699     int                 i;
timeout_del(&aarptimer_timeout);
  702     for ( i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++ ) {
  703         if ( aat->aat_hold ) {
m_freem( aat->aat_hold );
  705         }
  706     }
  707 }