Annotation of sys/netatalk/aarp.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: aarp.c,v 1.7 2006/04/25 05:52:43 tedu Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 1990,1991 Regents of The University of Michigan.
! 5: * All Rights Reserved.
! 6: */
! 7:
! 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: */
! 53:
! 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>
! 66:
! 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>
! 73:
! 74: #include <machine/endian.h>
! 75:
! 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>
! 82:
! 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);
! 94:
! 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 */
! 102:
! 103: #define AARPTAB_SIZE (AARPTAB_BSIZ * AARPTAB_NB)
! 104: struct aarptab aarptab[AARPTAB_SIZE];
! 105: int aarptab_size = AARPTAB_SIZE;
! 106:
! 107: struct timeout aarpprobe_timeout;
! 108: struct timeout aarptimer_timeout;
! 109:
! 110: #define AARPTAB_HASH(a) \
! 111: ((((a).s_net << 8 ) + (a).s_node ) % AARPTAB_NB )
! 112:
! 113: #define AARPTAB_LOOK(aat,addr) { \
! 114: int n; \
! 115: 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 && \
! 118: aat->aat_ataddr.s_node == (addr).s_node ) \
! 119: break; \
! 120: if ( n >= AARPTAB_BSIZ ) \
! 121: aat = 0; \
! 122: }
! 123:
! 124: #define AARPT_AGE (60 * 1)
! 125: #define AARPT_KILLC 20
! 126: #define AARPT_KILLI 3
! 127:
! 128: u_int8_t atmulticastaddr[ 6 ] = {
! 129: 0x09, 0x00, 0x07, 0xff, 0xff, 0xff,
! 130: };
! 131:
! 132: u_int8_t at_org_code[ 3 ] = {
! 133: 0x08, 0x00, 0x07,
! 134: };
! 135: u_int8_t aarp_org_code[ 3 ] = {
! 136: 0x00, 0x00, 0x00,
! 137: };
! 138:
! 139: /*ARGSUSED*/
! 140: static void
! 141: aarptimer(v)
! 142: void *v;
! 143: {
! 144: struct aarptab *aat;
! 145: int i, s;
! 146:
! 147: timeout_add(&aarptimer_timeout, AARPT_AGE * hz);
! 148: 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 ) ?
! 153: AARPT_KILLC : AARPT_KILLI ))
! 154: continue;
! 155: s = splnet();
! 156: aarptfree( aat );
! 157: splx( s );
! 158: }
! 159: }
! 160:
! 161: struct ifaddr *
! 162: at_ifawithnet( sat, ifa )
! 163: struct sockaddr_at *sat;
! 164: struct ifaddr *ifa;
! 165: {
! 166: struct sockaddr_at *sat2;
! 167: struct netrange *nr;
! 168:
! 169: for (; ifa; ifa = ifa->ifa_list.tqe_next ) {
! 170: if ( ifa->ifa_addr->sa_family != AF_APPLETALK ) {
! 171: continue;
! 172: }
! 173: sat2 = satosat( ifa->ifa_addr );
! 174: if ( sat2->sat_addr.s_net == sat->sat_addr.s_net ) {
! 175: break;
! 176: }
! 177: 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: }
! 186:
! 187: static void
! 188: 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;
! 198:
! 199: if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
! 200: return;
! 201: }
! 202: m->m_len = sizeof( *ea );
! 203: m->m_pkthdr.len = sizeof( *ea );
! 204: MH_ALIGN( m, sizeof( *ea ));
! 205:
! 206: ea = mtod( m, struct ether_aarp *);
! 207: bzero((caddr_t)ea, sizeof( *ea ));
! 208:
! 209: ea->aarp_hrd = htons( AARPHRD_ETHER );
! 210: ea->aarp_pro = htons( ETHERTYPE_AT );
! 211: ea->aarp_hln = sizeof( ea->aarp_sha );
! 212: ea->aarp_pln = sizeof( ea->aarp_spu );
! 213: ea->aarp_op = htons( AARPOP_REQUEST );
! 214: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
! 215: sizeof( ea->aarp_sha ));
! 216:
! 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 *)
! 225: at_ifawithnet( sat, ac->ac_if.if_addrlist.tqh_first )) == NULL ) {
! 226: m_freem( m );
! 227: return;
! 228: }
! 229:
! 230: eh = (struct ether_header *)sa.sa_data;
! 231:
! 232: if ( aa->aa_flags & AFA_PHASE2 ) {
! 233: bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
! 234: sizeof( eh->ether_dhost ));
! 235: eh->ether_type = htons(AT_LLC_SIZE + sizeof(struct ether_aarp));
! 236: M_PREPEND( m, AT_LLC_SIZE, M_DONTWAIT );
! 237: if (!m)
! 238: return;
! 239:
! 240: llc = mtod( m, struct llc *);
! 241: llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
! 242: llc->llc_control = LLC_UI;
! 243: bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
! 244: llc->llc_ether_type = htons( ETHERTYPE_AARP );
! 245:
! 246: bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
! 247: sizeof( ea->aarp_spnet ));
! 248: ea->aarp_spnode = AA_SAT( aa )->sat_addr.s_node;
! 249: bcopy( &sat->sat_addr.s_net, ea->aarp_tpnet,
! 250: sizeof( ea->aarp_tpnet ));
! 251: ea->aarp_tpnode = sat->sat_addr.s_node;
! 252: } else {
! 253: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
! 254: sizeof( eh->ether_dhost ));
! 255: eh->ether_type = htons( ETHERTYPE_AARP );
! 256:
! 257: ea->aarp_spa = AA_SAT( aa )->sat_addr.s_node;
! 258: ea->aarp_tpa = sat->sat_addr.s_node;
! 259: }
! 260:
! 261: sa.sa_len = sizeof( struct sockaddr );
! 262: 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: }
! 266:
! 267: int
! 268: aarpresolve( ac, m, destsat, desten )
! 269: struct arpcom *ac;
! 270: struct mbuf *m;
! 271: struct sockaddr_at *destsat;
! 272: u_int8_t *desten;
! 273: {
! 274: struct at_ifaddr *aa;
! 275: struct aarptab *aat;
! 276: int s;
! 277:
! 278: if ( at_broadcast( destsat )) {
! 279: if (( aa = (struct at_ifaddr *)at_ifawithnet( destsat,
! 280: ((struct ifnet *)ac)->if_addrlist.tqh_first )) == NULL ) {
! 281: m_freem( m );
! 282: return( 0 );
! 283: }
! 284: if ( aa->aa_flags & AFA_PHASE2 ) {
! 285: bcopy( (caddr_t)atmulticastaddr, (caddr_t)desten,
! 286: sizeof( atmulticastaddr ));
! 287: } else {
! 288: bcopy( (caddr_t)etherbroadcastaddr, (caddr_t)desten,
! 289: sizeof( etherbroadcastaddr ));
! 290: }
! 291: return( 1 );
! 292: }
! 293:
! 294: s = splnet();
! 295: AARPTAB_LOOK( aat, destsat->sat_addr );
! 296: if ( aat == 0 ) { /* No entry */
! 297: aat = aarptnew( &destsat->sat_addr );
! 298: if ( aat == 0 ) { /* XXX allocate more */
! 299: panic( "aarpresolve: no free entry" );
! 300: }
! 301: aat->aat_hold = m;
! 302: aarpwhohas( ac, destsat );
! 303: splx( s );
! 304: return( 0 );
! 305: }
! 306: /* found an entry */
! 307: aat->aat_timer = 0;
! 308: if ( aat->aat_flags & ATF_COM ) { /* entry is COMplete */
! 309: bcopy( (caddr_t)aat->aat_enaddr, (caddr_t)desten,
! 310: sizeof( aat->aat_enaddr ));
! 311: splx( s );
! 312: return( 1 );
! 313: }
! 314: /* entry has not completed */
! 315: if ( aat->aat_hold ) {
! 316: m_freem( aat->aat_hold );
! 317: }
! 318: aat->aat_hold = m;
! 319: aarpwhohas( ac, destsat );
! 320: splx( s );
! 321: return( 0 );
! 322: }
! 323:
! 324: void
! 325: aarpinput( ac, m )
! 326: struct arpcom *ac;
! 327: struct mbuf *m;
! 328: {
! 329: struct arphdr *ar;
! 330:
! 331: if ( ac->ac_if.if_flags & IFF_NOARP )
! 332: goto out;
! 333:
! 334: if ( m->m_len < sizeof( struct arphdr )) {
! 335: goto out;
! 336: }
! 337:
! 338: ar = mtod( m, struct arphdr *);
! 339: if ( ntohs( ar->ar_hrd ) != AARPHRD_ETHER ) {
! 340: goto out;
! 341: }
! 342:
! 343: if ( m->m_len < sizeof( struct arphdr ) + 2 * ar->ar_hln +
! 344: 2 * ar->ar_pln ) {
! 345: goto out;
! 346: }
! 347:
! 348: switch( ntohs( ar->ar_pro )) {
! 349: case ETHERTYPE_AT :
! 350: at_aarpinput( ac, m );
! 351: return;
! 352:
! 353: default:
! 354: break;
! 355: }
! 356:
! 357: out:
! 358: m_freem( m );
! 359: }
! 360:
! 361:
! 362: static void
! 363: 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;
! 376: u_int16_t net;
! 377:
! 378: ea = mtod( m, struct ether_aarp *);
! 379:
! 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 ))) {
! 383: m_freem( m );
! 384: return;
! 385: }
! 386:
! 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 ))) {
! 393: log( LOG_ERR,
! 394: "aarp: source is broadcast!\n" );
! 395: m_freem( m );
! 396: return;
! 397: }
! 398:
! 399: op = ntohs( ea->aarp_op );
! 400: bcopy( ea->aarp_tpnet, &net, sizeof( net ));
! 401:
! 402: if ( net != 0 ) {
! 403: sat.sat_len = sizeof(struct sockaddr_at);
! 404: sat.sat_family = AF_APPLETALK;
! 405: sat.sat_addr.s_net = net;
! 406: if (( aa = (struct at_ifaddr *)at_ifawithnet( &sat,
! 407: ac->ac_if.if_addrlist.tqh_first )) == NULL ) {
! 408: m_freem( m );
! 409: return;
! 410: }
! 411: bcopy( ea->aarp_spnet, &spa.s_net, sizeof( spa.s_net ));
! 412: 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;
! 419: 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 ) {
! 426: m_freem( m );
! 427: return;
! 428: }
! 429: tpa.s_net = spa.s_net = AA_SAT( aa )->sat_addr.s_net;
! 430: }
! 431:
! 432: spa.s_node = ea->aarp_spnode;
! 433: tpa.s_node = ea->aarp_tpnode;
! 434: ma.s_net = AA_SAT( aa )->sat_addr.s_net;
! 435: ma.s_node = AA_SAT( aa )->sat_addr.s_node;
! 436:
! 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: */
! 447: timeout_del(&aarpprobe_timeout);
! 448: wakeup( aa );
! 449: 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 */
! 458: log( LOG_ERR,
! 459: "aarp: duplicate AT address!! %x:%x:%x:%x:%x:%x\n",
! 460: ea->aarp_sha[ 0 ], ea->aarp_sha[ 1 ], ea->aarp_sha[ 2 ],
! 461: ea->aarp_sha[ 3 ], ea->aarp_sha[ 4 ], ea->aarp_sha[ 5 ]);
! 462: m_freem( m );
! 463: return;
! 464: }
! 465: }
! 466:
! 467: 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: */
! 475: aarptfree( aat );
! 476: m_freem( m );
! 477: return;
! 478: }
! 479:
! 480: bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
! 481: sizeof( ea->aarp_sha ));
! 482: aat->aat_flags |= ATF_COM;
! 483: if ( aat->aat_hold ) {
! 484: sat.sat_len = sizeof(struct sockaddr_at);
! 485: sat.sat_family = AF_APPLETALK;
! 486: 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 );
! 490: aat->aat_hold = 0;
! 491: }
! 492: }
! 493:
! 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 ))) {
! 497: bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
! 498: sizeof( ea->aarp_sha ));
! 499: aat->aat_flags |= ATF_COM;
! 500: }
! 501: }
! 502:
! 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 ||
! 508: op == AARPOP_RESPONSE || ( aa->aa_flags & AFA_PROBING )) {
! 509: m_freem( m );
! 510: return;
! 511: }
! 512:
! 513: bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )ea->aarp_tha,
! 514: sizeof( ea->aarp_sha ));
! 515: bcopy(( caddr_t )ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
! 516: sizeof( ea->aarp_sha ));
! 517:
! 518: /* XXX FreeBSD has an 'XXX' here but no comment as to why. */
! 519: eh = (struct ether_header *)sa.sa_data;
! 520: bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )eh->ether_dhost,
! 521: sizeof( eh->ether_dhost ));
! 522:
! 523: if ( aa->aa_flags & AFA_PHASE2 ) {
! 524: eh->ether_type = htons( AT_LLC_SIZE +
! 525: sizeof( struct ether_aarp ));
! 526: M_PREPEND( m, AT_LLC_SIZE, M_DONTWAIT );
! 527: if ( m == NULL ) {
! 528: return;
! 529: }
! 530: llc = mtod( m, struct llc *);
! 531: llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
! 532: llc->llc_control = LLC_UI;
! 533: bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
! 534: llc->llc_ether_type = htons( ETHERTYPE_AARP );
! 535:
! 536: bcopy( ea->aarp_spnet, ea->aarp_tpnet, sizeof( ea->aarp_tpnet ));
! 537: bcopy( &ma.s_net, ea->aarp_spnet, sizeof( ea->aarp_spnet ));
! 538: } else {
! 539: eh->ether_type = htons( ETHERTYPE_AARP );
! 540: }
! 541:
! 542: ea->aarp_tpnode = ea->aarp_spnode;
! 543: ea->aarp_spnode = ma.s_node;
! 544: ea->aarp_op = htons( AARPOP_RESPONSE );
! 545:
! 546: sa.sa_len = sizeof( struct sockaddr );
! 547: 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: }
! 552:
! 553: static void
! 554: aarptfree( aat )
! 555: struct aarptab *aat;
! 556: {
! 557:
! 558: if ( aat->aat_hold )
! 559: m_freem( aat->aat_hold );
! 560: aat->aat_hold = 0;
! 561: aat->aat_timer = aat->aat_flags = 0;
! 562: aat->aat_ataddr.s_net = 0;
! 563: aat->aat_ataddr.s_node = 0;
! 564: }
! 565:
! 566: struct aarptab *
! 567: 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;
! 574:
! 575: if ( first ) {
! 576: first = 0;
! 577: timeout_set(&aarptimer_timeout, aarptimer, NULL);
! 578: timeout_add(&aarptimer_timeout, hz);
! 579: }
! 580: 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 ) {
! 587: oldest = aat->aat_timer;
! 588: aato = aat;
! 589: }
! 590: }
! 591: if ( aato == NULL )
! 592: return( NULL );
! 593: aat = aato;
! 594: aarptfree( aat );
! 595: out:
! 596: aat->aat_ataddr = *addr;
! 597: aat->aat_flags = ATF_INUSE;
! 598: return( aat );
! 599: }
! 600:
! 601: void
! 602: 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;
! 612:
! 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;
! 621: 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 */
! 628: printf( "aarpprobe why did this happen?!\n" );
! 629: return;
! 630: }
! 631:
! 632: if ( aa->aa_probcnt <= 0 ) {
! 633: aa->aa_flags &= ~AFA_PROBING;
! 634: wakeup( aa );
! 635: return;
! 636: } else {
! 637: timeout_set(&aarpprobe_timeout, aarpprobe, ac);
! 638: timeout_add(&aarpprobe_timeout, hz / 5);
! 639: }
! 640:
! 641: if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
! 642: return;
! 643: }
! 644: m->m_len = sizeof( *ea );
! 645: m->m_pkthdr.len = sizeof( *ea );
! 646: MH_ALIGN( m, sizeof( *ea ));
! 647:
! 648: ea = mtod( m, struct ether_aarp *);
! 649: bzero((caddr_t)ea, sizeof( *ea ));
! 650:
! 651: ea->aarp_hrd = htons( AARPHRD_ETHER );
! 652: ea->aarp_pro = htons( ETHERTYPE_AT );
! 653: ea->aarp_hln = sizeof( ea->aarp_sha );
! 654: ea->aarp_pln = sizeof( ea->aarp_spu );
! 655: ea->aarp_op = htons( AARPOP_PROBE );
! 656: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
! 657: sizeof( ea->aarp_sha ));
! 658:
! 659: eh = (struct ether_header *)sa.sa_data;
! 660:
! 661: if ( aa->aa_flags & AFA_PHASE2 ) {
! 662: bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
! 663: sizeof( eh->ether_dhost ));
! 664: eh->ether_type = htons( AT_LLC_SIZE +
! 665: sizeof( struct ether_aarp ));
! 666: M_PREPEND( m, AT_LLC_SIZE, M_DONTWAIT );
! 667: if (!m)
! 668: return;
! 669:
! 670: llc = mtod( m, struct llc *);
! 671: llc->llc_dsap = llc->llc_ssap = LLC_SNAP_LSAP;
! 672: llc->llc_control = LLC_UI;
! 673: bcopy( aarp_org_code, llc->llc_org_code, sizeof( aarp_org_code ));
! 674: llc->llc_ether_type = htons( ETHERTYPE_AARP );
! 675:
! 676: bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
! 677: sizeof( ea->aarp_spnet ));
! 678: bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_tpnet,
! 679: sizeof( ea->aarp_tpnet ));
! 680: ea->aarp_spnode = ea->aarp_tpnode = AA_SAT( aa )->sat_addr.s_node;
! 681: } else {
! 682: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
! 683: sizeof( eh->ether_dhost ));
! 684: eh->ether_type = htons( ETHERTYPE_AARP );
! 685: ea->aarp_spa = ea->aarp_tpa = AA_SAT( aa )->sat_addr.s_node;
! 686: }
! 687:
! 688: sa.sa_len = sizeof( struct sockaddr );
! 689: 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 );
! 692: aa->aa_probcnt--;
! 693: }
! 694:
! 695: void
! 696: aarp_clean(void)
! 697: {
! 698: struct aarptab *aat;
! 699: int i;
! 700:
! 701: timeout_del(&aarptimer_timeout);
! 702: for ( i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++ ) {
! 703: if ( aat->aat_hold ) {
! 704: m_freem( aat->aat_hold );
! 705: }
! 706: }
! 707: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to aarp.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netatalk