Annotation of sys/netatalk/at_control.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: at_control.c,v 1.10 2007/04/10 17:47:55 miod 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 <netatalk/at.h>
! 75: #include <netatalk/at_var.h>
! 76: #include <netatalk/aarp.h>
! 77: #include <netatalk/phase2.h>
! 78: #include <netatalk/at_extern.h>
! 79:
! 80: #include <dev/rndvar.h>
! 81:
! 82: int at_control( u_long, caddr_t, struct ifnet *, struct proc * );
! 83: static int at_scrub( struct ifnet *, struct at_ifaddr * );
! 84: static int at_ifinit( struct ifnet *, struct at_ifaddr *,
! 85: struct sockaddr_at * );
! 86: int at_broadcast( struct sockaddr_at * );
! 87:
! 88: static int aa_dorangeroute(struct ifaddr *, u_int, u_int, int);
! 89: static int aa_addsingleroute(struct ifaddr *, struct at_addr *,
! 90: struct at_addr *);
! 91: static int aa_delsingleroute(struct ifaddr *, struct at_addr *,
! 92: struct at_addr *);
! 93: static int aa_dosingleroute(struct ifaddr *, struct at_addr *,
! 94: struct at_addr *, int, int );
! 95:
! 96: # define sateqaddr(a,b) ((a)->sat_len == (b)->sat_len && \
! 97: (a)->sat_family == (b)->sat_family && \
! 98: (a)->sat_addr.s_net == (b)->sat_addr.s_net && \
! 99: (a)->sat_addr.s_node == (b)->sat_addr.s_node )
! 100:
! 101: extern struct timeout aarpprobe_timeout;
! 102:
! 103: int
! 104: at_control( cmd, data, ifp, p )
! 105: u_long cmd;
! 106: caddr_t data;
! 107: struct ifnet *ifp;
! 108: struct proc *p;
! 109: {
! 110: struct ifreq *ifr = (struct ifreq *)data;
! 111: struct sockaddr_at *sat;
! 112: struct netrange *nr;
! 113: struct at_aliasreq *ifra = (struct at_aliasreq *)data;
! 114: struct at_ifaddr *aa0;
! 115: struct at_ifaddr *aa = 0;
! 116: struct ifaddr *ifa, *ifa0;
! 117:
! 118: if ( ifp ) {
! 119: for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
! 120: if ( aa->aa_ifp == ifp ) break;
! 121: }
! 122: }
! 123:
! 124: switch ( cmd ) {
! 125: case SIOCAIFADDR:
! 126: case SIOCDIFADDR:
! 127: if ( ifra->ifra_addr.sat_family == AF_APPLETALK ) {
! 128: for ( ; aa; aa = aa->aa_next ) {
! 129: if ( aa->aa_ifp == ifp &&
! 130: sateqaddr( &aa->aa_addr, &ifra->ifra_addr )) {
! 131: break;
! 132: }
! 133: }
! 134: }
! 135: if ( cmd == SIOCDIFADDR && aa == 0 ) {
! 136: return( EADDRNOTAVAIL );
! 137: }
! 138: /*FALLTHROUGH*/
! 139:
! 140: case SIOCSIFADDR:
! 141: /*
! 142: * What a great idea this is: Let's reverse the meaning of
! 143: * the return...
! 144: */
! 145: if ( suser( p, 0 )) {
! 146: return( EPERM );
! 147: }
! 148:
! 149: sat = satosat( &ifr->ifr_addr );
! 150: nr = (struct netrange *)sat->sat_zero;
! 151: if ( nr->nr_phase == 1 ) {
! 152: for ( ; aa; aa = aa->aa_next ) {
! 153: if ( aa->aa_ifp == ifp &&
! 154: ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
! 155: break;
! 156: }
! 157: }
! 158: } else { /* default to phase 2 */
! 159: for ( ; aa; aa = aa->aa_next ) {
! 160: if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
! 161: break;
! 162: }
! 163: }
! 164: }
! 165:
! 166: if ( ifp == 0 )
! 167: panic( "at_control" );
! 168:
! 169: if ( aa == (struct at_ifaddr *) 0 ) {
! 170: aa0 = malloc(sizeof(struct at_ifaddr), M_IFADDR, M_WAITOK);
! 171: bzero(aa0, sizeof(struct at_ifaddr));
! 172:
! 173: if (( aa = at_ifaddr ) != NULL ) {
! 174: /*
! 175: * Don't let the loopback be first, since the first
! 176: * address is the machine's default address for
! 177: * binding.
! 178: */
! 179: if ( at_ifaddr->aa_ifp->if_flags & IFF_LOOPBACK ) {
! 180: aa = aa0;
! 181: aa->aa_next = at_ifaddr;
! 182: at_ifaddr = aa;
! 183: } else {
! 184: for ( ; aa->aa_next; aa = aa->aa_next )
! 185: ;
! 186: aa->aa_next = aa0;
! 187: }
! 188: } else {
! 189: at_ifaddr = aa0;
! 190: }
! 191:
! 192: aa = aa0;
! 193:
! 194: if (( ifa = ifp->if_addrlist.tqh_first ) != NULL ) {
! 195: for ( ; ifa->ifa_list.tqe_next; ifa = ifa->ifa_list.tqe_next )
! 196: ;
! 197: ifa->ifa_list.tqe_next = (struct ifaddr *)aa;
! 198: } else {
! 199: ifp->if_addrlist.tqh_first = (struct ifaddr *)aa;
! 200: }
! 201:
! 202: /* FreeBSD found this. Whew */
! 203: aa->aa_ifa.ifa_refcnt++;
! 204:
! 205: aa->aa_ifa.ifa_addr = (struct sockaddr *)&aa->aa_addr;
! 206: aa->aa_ifa.ifa_dstaddr = (struct sockaddr *)&aa->aa_addr;
! 207: aa->aa_ifa.ifa_netmask = (struct sockaddr *)&aa->aa_netmask;
! 208:
! 209: /*
! 210: * Set/clear the phase 2 bit.
! 211: */
! 212: if ( nr->nr_phase == 1 ) {
! 213: aa->aa_flags &= ~AFA_PHASE2;
! 214: } else {
! 215: aa->aa_flags |= AFA_PHASE2;
! 216: }
! 217: aa->aa_ifp = ifp;
! 218: } else {
! 219: at_scrub( ifp, aa );
! 220: }
! 221: break;
! 222:
! 223: case SIOCGIFADDR :
! 224: sat = satosat( &ifr->ifr_addr );
! 225: nr = (struct netrange *)sat->sat_zero;
! 226: if ( nr->nr_phase == 1 ) {
! 227: for ( ; aa; aa = aa->aa_next ) {
! 228: if ( aa->aa_ifp == ifp &&
! 229: ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
! 230: break;
! 231: }
! 232: }
! 233: } else { /* default to phase 2 */
! 234: for ( ; aa; aa = aa->aa_next ) {
! 235: if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
! 236: break;
! 237: }
! 238: }
! 239: }
! 240:
! 241: if ( aa == (struct at_ifaddr *) 0 )
! 242: return( EADDRNOTAVAIL );
! 243: break;
! 244: }
! 245:
! 246: switch ( cmd ) {
! 247: case SIOCGIFADDR:
! 248: *(struct sockaddr_at *)&ifr->ifr_addr = aa->aa_addr;
! 249:
! 250: /* from FreeBSD : some cleanups about netranges */
! 251: ((struct netrange *)&sat->sat_zero)->nr_phase
! 252: = (aa->aa_flags & AFA_PHASE2) ? 2 : 1;
! 253: ((struct netrange *)&sat->sat_zero)->nr_firstnet = aa->aa_firstnet;
! 254: ((struct netrange *)&sat->sat_zero)->nr_lastnet = aa->aa_lastnet;
! 255: break;
! 256:
! 257: case SIOCSIFADDR:
! 258: return( at_ifinit( ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr ));
! 259:
! 260: case SIOCAIFADDR:
! 261: if ( sateqaddr( &ifra->ifra_addr, &aa->aa_addr )) {
! 262: return( 0 );
! 263: }
! 264: return( at_ifinit( ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr ));
! 265:
! 266: case SIOCDIFADDR:
! 267: at_scrub( ifp, aa );
! 268: ifa0 = (struct ifaddr *)aa;
! 269: if (( ifa = ifp->if_addrlist.tqh_first ) == ifa0 ) {
! 270: ifp->if_addrlist.tqh_first = ifa->ifa_list.tqe_next;
! 271: } else {
! 272: while ( ifa->ifa_list.tqe_next &&
! 273: ( ifa->ifa_list.tqe_next != ifa0 )) {
! 274: ifa = ifa->ifa_list.tqe_next;
! 275: }
! 276: if ( ifa->ifa_list.tqe_next ) {
! 277: ifa->ifa_list.tqe_next = ifa0->ifa_list.tqe_next;
! 278: } else {
! 279: panic( "at_control" );
! 280: }
! 281: }
! 282:
! 283: /* FreeBSD */
! 284: IFAFREE(ifa0);
! 285:
! 286: aa0 = aa;
! 287: if ( aa0 == ( aa = at_ifaddr )) {
! 288: at_ifaddr = aa->aa_next;
! 289: } else {
! 290: while ( aa->aa_next && ( aa->aa_next != aa0 )) {
! 291: aa = aa->aa_next;
! 292: }
! 293: if ( aa->aa_next ) {
! 294: aa->aa_next = aa0->aa_next;
! 295: } else {
! 296: panic( "at_control" );
! 297: }
! 298: }
! 299:
! 300: /* FreeBSD */
! 301: IFAFREE(ifa0);
! 302: break;
! 303:
! 304: default:
! 305: if ( ifp == 0 || ifp->if_ioctl == 0 )
! 306: return( EOPNOTSUPP );
! 307: return( (*ifp->if_ioctl)( ifp, cmd, data ));
! 308: }
! 309: return( 0 );
! 310: }
! 311:
! 312: /* replaced this routine with the one from FreeBSD */
! 313: static int
! 314: at_scrub( ifp, aa )
! 315: struct ifnet *ifp;
! 316: struct at_ifaddr *aa;
! 317: {
! 318: int error;
! 319:
! 320: if ( aa->aa_flags & AFA_ROUTE ) {
! 321: if (ifp->if_flags & IFF_LOOPBACK) {
! 322: if ((error = aa_delsingleroute(&aa->aa_ifa,
! 323: &aa->aa_addr.sat_addr,
! 324: &aa->aa_netmask.sat_addr))) {
! 325: return( error );
! 326: }
! 327: } else if (ifp->if_flags & IFF_POINTOPOINT) {
! 328: if ((error = rtinit( &aa->aa_ifa, RTM_DELETE, RTF_HOST)) != 0)
! 329: return( error );
! 330: } else if (ifp->if_flags & IFF_BROADCAST) {
! 331: error = aa_dorangeroute(&aa->aa_ifa,
! 332: ntohs(aa->aa_firstnet),
! 333: ntohs(aa->aa_lastnet),
! 334: RTM_DELETE );
! 335: }
! 336: aa->aa_ifa.ifa_flags &= ~IFA_ROUTE;
! 337: aa->aa_flags &= ~AFA_ROUTE;
! 338: }
! 339: return( 0 );
! 340: }
! 341:
! 342: static int
! 343: at_ifinit( ifp, aa, sat )
! 344: struct ifnet *ifp;
! 345: struct at_ifaddr *aa;
! 346: struct sockaddr_at *sat;
! 347: {
! 348: struct netrange nr, onr;
! 349: struct sockaddr_at oldaddr;
! 350: int s = splnet(), error = 0, i, j, netinc, nodeinc, nnets;
! 351: u_int16_t net;
! 352:
! 353: oldaddr = aa->aa_addr;
! 354: bzero( AA_SAT( aa ), sizeof( struct sockaddr_at ));
! 355: bcopy( sat->sat_zero, &nr, sizeof( struct netrange ));
! 356: bcopy( sat->sat_zero, AA_SAT( aa )->sat_zero, sizeof( struct netrange ));
! 357: nnets = ntohs( nr.nr_lastnet ) - ntohs( nr.nr_firstnet ) + 1;
! 358:
! 359: onr.nr_firstnet = aa->aa_firstnet;
! 360: onr.nr_lastnet = aa->aa_lastnet;
! 361: aa->aa_firstnet = nr.nr_firstnet;
! 362: aa->aa_lastnet = nr.nr_lastnet;
! 363:
! 364: /*
! 365: * We could eliminate the need for a second phase 1 probe (post
! 366: * autoconf) if we check whether we're resetting the node. Note
! 367: * that phase 1 probes use only nodes, not net.node pairs. Under
! 368: * phase 2, both the net and node must be the same.
! 369: */
! 370: if ( ifp->if_flags & IFF_LOOPBACK ) {
! 371: AA_SAT( aa )->sat_len = sat->sat_len;
! 372: AA_SAT( aa )->sat_family = AF_APPLETALK;
! 373: AA_SAT( aa )->sat_addr.s_net = sat->sat_addr.s_net;
! 374: AA_SAT( aa )->sat_addr.s_node = sat->sat_addr.s_node;
! 375: } else {
! 376: aa->aa_flags |= AFA_PROBING;
! 377: AA_SAT( aa )->sat_len = sizeof(struct sockaddr_at);
! 378: AA_SAT( aa )->sat_family = AF_APPLETALK;
! 379: if ( aa->aa_flags & AFA_PHASE2 ) {
! 380: if ( sat->sat_addr.s_net == ATADDR_ANYNET ) {
! 381: if ( nnets != 1 ) {
! 382: net = ntohs( nr.nr_firstnet ) +
! 383: arc4random() % ( nnets - 1 );
! 384: } else {
! 385: net = ntohs( nr.nr_firstnet );
! 386: }
! 387: } else {
! 388: if ( ntohs( sat->sat_addr.s_net ) < ntohs( nr.nr_firstnet ) ||
! 389: ntohs( sat->sat_addr.s_net ) > ntohs( nr.nr_lastnet )) {
! 390: aa->aa_addr = oldaddr;
! 391: aa->aa_firstnet = onr.nr_firstnet;
! 392: aa->aa_lastnet = onr.nr_lastnet;
! 393: splx(s);
! 394: return( EINVAL );
! 395: }
! 396: net = ntohs( sat->sat_addr.s_net );
! 397: }
! 398: } else {
! 399: net = ntohs( sat->sat_addr.s_net );
! 400: }
! 401:
! 402: if ( sat->sat_addr.s_node == ATADDR_ANYNODE ) {
! 403: AA_SAT( aa )->sat_addr.s_node = arc4random();
! 404: } else {
! 405: AA_SAT( aa )->sat_addr.s_node = sat->sat_addr.s_node;
! 406: }
! 407:
! 408: for ( i = nnets, netinc = 1; i > 0; net = ntohs( nr.nr_firstnet ) +
! 409: (( net - ntohs( nr.nr_firstnet ) + netinc ) % nnets ), i-- ) {
! 410: AA_SAT( aa )->sat_addr.s_net = htons( net );
! 411:
! 412: for ( j = 0, nodeinc = arc4random() | 1; j < 256;
! 413: j++, AA_SAT( aa )->sat_addr.s_node += nodeinc ) {
! 414: if ( AA_SAT( aa )->sat_addr.s_node > 253 ||
! 415: AA_SAT( aa )->sat_addr.s_node < 1 ) {
! 416: continue;
! 417: }
! 418: aa->aa_probcnt = 10;
! 419: timeout_set(&aarpprobe_timeout, aarpprobe, ifp);
! 420: /* XXX don't use hz so badly */
! 421: timeout_add(&aarpprobe_timeout, hz / 5);
! 422: if ( tsleep( aa, PPAUSE|PCATCH, "at_ifinit", 0 )) {
! 423: printf( "at_ifinit why did this happen?!\n" );
! 424: aa->aa_addr = oldaddr;
! 425: aa->aa_firstnet = onr.nr_firstnet;
! 426: aa->aa_lastnet = onr.nr_lastnet;
! 427: splx( s );
! 428: return( EINTR );
! 429: }
! 430: if (( aa->aa_flags & AFA_PROBING ) == 0 ) {
! 431: break;
! 432: }
! 433: }
! 434: if (( aa->aa_flags & AFA_PROBING ) == 0 ) {
! 435: break;
! 436: }
! 437: /* reset node for next network */
! 438: AA_SAT( aa )->sat_addr.s_node = arc4random();
! 439: }
! 440:
! 441: if ( aa->aa_flags & AFA_PROBING ) {
! 442: aa->aa_addr = oldaddr;
! 443: aa->aa_firstnet = onr.nr_firstnet;
! 444: aa->aa_lastnet = onr.nr_lastnet;
! 445: splx( s );
! 446: return( EADDRINUSE );
! 447: }
! 448: }
! 449:
! 450: if ( ifp->if_ioctl &&
! 451: ( error = (*ifp->if_ioctl)( ifp, SIOCSIFADDR, (caddr_t) aa ))) {
! 452: aa->aa_addr = oldaddr;
! 453: aa->aa_firstnet = onr.nr_firstnet;
! 454: aa->aa_lastnet = onr.nr_lastnet;
! 455: splx( s );
! 456: return( error );
! 457: }
! 458:
! 459: bzero(&aa->aa_netmask, sizeof(aa->aa_netmask));
! 460: aa->aa_netmask.sat_len = sizeof(struct sockaddr_at);
! 461: aa->aa_netmask.sat_family = AF_APPLETALK;
! 462: aa->aa_netmask.sat_addr.s_net = 0xffff;
! 463: aa->aa_netmask.sat_addr.s_node = 0;
! 464: /* XXX From FreeBSD. Why does it do this? */
! 465: aa->aa_ifa.ifa_netmask =(struct sockaddr *) &(aa->aa_netmask);
! 466:
! 467: /* This block came from FreeBSD too */
! 468: /*
! 469: * Initialize broadcast (or remote p2p) address
! 470: */
! 471: bzero(&aa->aa_broadaddr, sizeof(aa->aa_broadaddr));
! 472: aa->aa_broadaddr.sat_len = sizeof(struct sockaddr_at);
! 473: aa->aa_broadaddr.sat_family = AF_APPLETALK;
! 474:
! 475: aa->aa_ifa.ifa_metric = ifp->if_metric;
! 476: if (ifp->if_flags & IFF_BROADCAST) {
! 477: aa->aa_broadaddr.sat_addr.s_net = htons(0);
! 478: aa->aa_broadaddr.sat_addr.s_node = 0xff;
! 479: aa->aa_ifa.ifa_broadaddr = (struct sockaddr *) &aa->aa_broadaddr;
! 480: /* add the range of routes needed */
! 481: error = aa_dorangeroute(&aa->aa_ifa,
! 482: ntohs(aa->aa_firstnet), ntohs(aa->aa_lastnet), RTM_ADD );
! 483: }
! 484: else if (ifp->if_flags & IFF_POINTOPOINT) {
! 485: struct at_addr rtaddr, rtmask;
! 486:
! 487: bzero(&rtaddr, sizeof(rtaddr));
! 488: bzero(&rtmask, sizeof(rtmask));
! 489: /* fill in the far end if we know it here XXX */
! 490: aa->aa_ifa.ifa_dstaddr = (struct sockaddr *) &aa->aa_broadaddr;
! 491: error = aa_addsingleroute(&aa->aa_ifa, &rtaddr, &rtmask);
! 492: }
! 493: else if ( ifp->if_flags & IFF_LOOPBACK ) {
! 494: struct at_addr rtaddr, rtmask;
! 495:
! 496: bzero(&rtaddr, sizeof(rtaddr));
! 497: bzero(&rtmask, sizeof(rtmask));
! 498: rtaddr.s_net = AA_SAT( aa )->sat_addr.s_net;
! 499: rtaddr.s_node = AA_SAT( aa )->sat_addr.s_node;
! 500: rtmask.s_net = 0xffff;
! 501: rtmask.s_node = 0x0; /* XXX should not be so.. should be HOST route */
! 502: error = aa_addsingleroute(&aa->aa_ifa, &rtaddr, &rtmask);
! 503: }
! 504:
! 505: if ( error ) {
! 506: at_scrub( ifp, aa );
! 507: aa->aa_addr = oldaddr;
! 508: aa->aa_firstnet = onr.nr_firstnet;
! 509: aa->aa_lastnet = onr.nr_lastnet;
! 510: splx( s );
! 511: return( error );
! 512: }
! 513:
! 514: aa->aa_ifa.ifa_flags |= IFA_ROUTE;
! 515: aa->aa_flags |= AFA_ROUTE;
! 516: splx( s );
! 517: return( 0 );
! 518: }
! 519:
! 520: int
! 521: at_broadcast( sat )
! 522: struct sockaddr_at *sat;
! 523: {
! 524: struct at_ifaddr *aa;
! 525:
! 526: if ( sat->sat_addr.s_node != ATADDR_BCAST ) {
! 527: return( 0 );
! 528: }
! 529: if ( sat->sat_addr.s_net == ATADDR_ANYNET ) {
! 530: return( 1 );
! 531: } else {
! 532: for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
! 533: if (( aa->aa_ifp->if_flags & IFF_BROADCAST ) &&
! 534: ( ntohs( sat->sat_addr.s_net ) >= ntohs( aa->aa_firstnet ) &&
! 535: ntohs( sat->sat_addr.s_net ) <= ntohs( aa->aa_lastnet ))) {
! 536: return( 1 );
! 537: }
! 538: }
! 539: }
! 540: return( 0 );
! 541: }
! 542:
! 543: /* Yet another bunch of routines from FreeBSD. Those guys are good */
! 544: /*
! 545: * aa_dorangeroute()
! 546: *
! 547: * Add a route for a range of networks from bot to top - 1.
! 548: * Algorithm:
! 549: *
! 550: * Split the range into two subranges such that the middle
! 551: * of the two ranges is the point where the highest bit of difference
! 552: * between the two addresses, makes its transition
! 553: * Each of the upper and lower ranges might not exist, or might be
! 554: * representable by 1 or more netmasks. In addition, if both
! 555: * ranges can be represented by the same netmask, then they can be merged
! 556: * by using the next higher netmask..
! 557: */
! 558:
! 559: static int
! 560: aa_dorangeroute(struct ifaddr *ifa, u_int bot, u_int top, int cmd)
! 561: {
! 562: u_int mask1;
! 563: struct at_addr addr;
! 564: struct at_addr mask;
! 565: int error;
! 566:
! 567: /*
! 568: * slight sanity check
! 569: */
! 570: if (bot > top) return (EINVAL);
! 571:
! 572: addr.s_node = 0;
! 573: mask.s_node = 0;
! 574: /*
! 575: * just start out with the lowest boundary
! 576: * and keep extending the mask till it's too big.
! 577: */
! 578:
! 579: while (bot <= top) {
! 580: mask1 = 1;
! 581: while ((( bot & ~mask1) >= bot)
! 582: && (( bot | mask1) <= top)) {
! 583: mask1 <<= 1;
! 584: mask1 |= 1;
! 585: }
! 586: mask1 >>= 1;
! 587: mask.s_net = htons(~mask1);
! 588: addr.s_net = htons(bot);
! 589: if(cmd == RTM_ADD) {
! 590: error = aa_addsingleroute(ifa,&addr,&mask);
! 591: if (error) {
! 592: /* XXX clean up? */
! 593: return (error);
! 594: }
! 595: } else {
! 596: error = aa_delsingleroute(ifa,&addr,&mask);
! 597: }
! 598: bot = (bot | mask1) + 1;
! 599: }
! 600: return 0;
! 601: }
! 602:
! 603: static int
! 604: aa_addsingleroute(struct ifaddr *ifa,
! 605: struct at_addr *addr, struct at_addr *mask)
! 606: {
! 607: int error;
! 608:
! 609: #if 0
! 610: printf("aa_addsingleroute: %x.%x mask %x.%x ...\n",
! 611: ntohs(addr->s_net), addr->s_node,
! 612: ntohs(mask->s_net), mask->s_node);
! 613: #endif
! 614:
! 615: error = aa_dosingleroute(ifa, addr, mask, RTM_ADD, RTF_UP);
! 616: if (error)
! 617: printf("aa_addsingleroute: error %d\n", error);
! 618: return(error);
! 619: }
! 620:
! 621: static int
! 622: aa_delsingleroute(struct ifaddr *ifa,
! 623: struct at_addr *addr, struct at_addr *mask)
! 624: {
! 625: int error;
! 626:
! 627: error = aa_dosingleroute(ifa, addr, mask, RTM_DELETE, 0);
! 628: if (error)
! 629: printf("aa_delsingleroute: error %d\n", error);
! 630: return(error);
! 631: }
! 632:
! 633: static int
! 634: aa_dosingleroute(struct ifaddr *ifa,
! 635: struct at_addr *at_addr, struct at_addr *at_mask, int cmd, int flags)
! 636: {
! 637: struct sockaddr_at addr, mask;
! 638:
! 639: bzero(&addr, sizeof(addr));
! 640: bzero(&mask, sizeof(mask));
! 641: addr.sat_family = AF_APPLETALK;
! 642: addr.sat_len = sizeof(struct sockaddr_at);
! 643: addr.sat_addr.s_net = at_addr->s_net;
! 644: addr.sat_addr.s_node = at_addr->s_node;
! 645: mask.sat_family = AF_APPLETALK;
! 646: mask.sat_len = sizeof(struct sockaddr_at);
! 647: mask.sat_addr.s_net = at_mask->s_net;
! 648: mask.sat_addr.s_node = at_mask->s_node;
! 649: if (at_mask->s_node)
! 650: flags |= RTF_HOST;
! 651: return(rtrequest(cmd, (struct sockaddr *) &addr,
! 652: (flags & RTF_HOST)?(ifa->ifa_dstaddr):(ifa->ifa_addr),
! 653: (struct sockaddr *) &mask, flags, NULL, 0));
! 654: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to at_control.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netatalk