root/netatalk/at_control.c

DEFINITIONS

1. at_control
2. at_scrub
3. at_ifinit
4. at_broadcast
5. aa_dorangeroute
6. aa_addsingleroute
7. aa_delsingleroute
8. aa_dosingleroute

    1 /*      $OpenBSD: at_control.c,v 1.10 2007/04/10 17:47:55 miod 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 <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>
   80 #include <dev/rndvar.h>
   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 * );
   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 );
   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 )
  101 extern struct timeout aarpprobe_timeout;
  103 int
at_control( cmd, data, ifp, p )
u_long              cmd;
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;
  118     if ( ifp ) {
  119         for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
  120             if ( aa->aa_ifp == ifp ) break;
  121         }
  122     }
  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 &&
sateqaddr( &aa->aa_addr, &ifra->ifra_addr )) {
  131                     break;
  132                 }
  133             }
  134         }
  135         if ( cmd == SIOCDIFADDR && aa == 0 ) {
  136             return( EADDRNOTAVAIL );
  137         }
  138         /*FALLTHROUGH*/
  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         }
sat = satosat( &ifr->ifr_addr );
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         }
  166         if ( ifp == 0 )
panic( "at_control" );
  169         if ( aa == (struct at_ifaddr *) 0 ) {
aa0 = malloc(sizeof(struct at_ifaddr), M_IFADDR, M_WAITOK);
bzero(aa0, sizeof(struct at_ifaddr));
  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 ) {
aa = aa0;
aa->aa_next = at_ifaddr;
at_ifaddr = aa;
  183                 } else {
  184                     for ( ; aa->aa_next; aa = aa->aa_next )
  185                         ;
aa->aa_next = aa0;
  187                 }
  188             } else {
at_ifaddr = aa0;
  190             }
aa = aa0;
  194             if (( ifa = ifp->if_addrlist.tqh_first ) != NULL ) {
  195                 for ( ; ifa->ifa_list.tqe_next; ifa = ifa->ifa_list.tqe_next )
  196                     ;
ifa->ifa_list.tqe_next = (struct ifaddr *)aa;
  198             } else {
ifp->if_addrlist.tqh_first = (struct ifaddr *)aa;
  200             }
  202             /* FreeBSD found this. Whew */
aa->aa_ifa.ifa_refcnt++;
aa->aa_ifa.ifa_addr = (struct sockaddr *)&aa->aa_addr;
aa->aa_ifa.ifa_dstaddr = (struct sockaddr *)&aa->aa_addr;
aa->aa_ifa.ifa_netmask = (struct sockaddr *)&aa->aa_netmask;
  209             /*
  210              * Set/clear the phase 2 bit.
  211              */
  212             if ( nr->nr_phase == 1 ) {
aa->aa_flags &= ~AFA_PHASE2;
  214             } else {
aa->aa_flags |= AFA_PHASE2;
  216             }
aa->aa_ifp = ifp;
  218         } else {
at_scrub( ifp, aa );
  220         }
  221         break;
  223     case SIOCGIFADDR :
sat = satosat( &ifr->ifr_addr );
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         }
  241         if ( aa == (struct at_ifaddr *) 0 )
  242             return( EADDRNOTAVAIL );
  243         break;
  244     }
  246     switch ( cmd ) {
  247     case SIOCGIFADDR:
  248         *(struct sockaddr_at *)&ifr->ifr_addr = aa->aa_addr;
  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;
  257     case SIOCSIFADDR:
  258         return( at_ifinit( ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr ));
  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 ));
  266     case SIOCDIFADDR:
at_scrub( ifp, aa );
ifa0 = (struct ifaddr *)aa;
  269         if (( ifa = ifp->if_addrlist.tqh_first ) == ifa0 ) {
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 )) {
ifa = ifa->ifa_list.tqe_next;
  275             }
  276             if ( ifa->ifa_list.tqe_next ) {
ifa->ifa_list.tqe_next = ifa0->ifa_list.tqe_next;
  278             } else {
panic( "at_control" );
  280             }
  281         }
  283         /* FreeBSD */
IFAFREE(ifa0);
aa0 = aa;
  287         if ( aa0 == ( aa = at_ifaddr )) {
at_ifaddr = aa->aa_next;
  289         } else {
  290             while ( aa->aa_next && ( aa->aa_next != aa0 )) {
aa = aa->aa_next;
  292             }
  293             if ( aa->aa_next ) {
aa->aa_next = aa0->aa_next;
  295             } else {
panic( "at_control" );
  297             }
  298         }
  300         /* FreeBSD */
IFAFREE(ifa0);
  302         break;
  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 }
  312 /* replaced this routine with the one from FreeBSD */
  313 static int
at_scrub( ifp, aa )
  315     struct ifnet        *ifp;
  316     struct at_ifaddr    *aa;
  317 {
  318     int                 error;
  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) {
error = aa_dorangeroute(&aa->aa_ifa,
ntohs(aa->aa_firstnet),
ntohs(aa->aa_lastnet),
RTM_DELETE );
  335         }
aa->aa_ifa.ifa_flags &= ~IFA_ROUTE;
aa->aa_flags &= ~AFA_ROUTE;
  338     }
  339     return( 0 );
  340 }
  342 static int
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;
u_int16_t           net;
oldaddr = aa->aa_addr;
bzero( AA_SAT( aa ), sizeof( struct sockaddr_at ));
bcopy( sat->sat_zero, &nr, sizeof( struct netrange ));
bcopy( sat->sat_zero, AA_SAT( aa )->sat_zero, sizeof( struct netrange ));
nnets = ntohs( nr.nr_lastnet ) - ntohs( nr.nr_firstnet ) + 1;
onr.nr_firstnet = aa->aa_firstnet;
onr.nr_lastnet = aa->aa_lastnet;
aa->aa_firstnet = nr.nr_firstnet;
aa->aa_lastnet = nr.nr_lastnet;
  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 ) {
AA_SAT( aa )->sat_len = sat->sat_len;
AA_SAT( aa )->sat_family = AF_APPLETALK;
AA_SAT( aa )->sat_addr.s_net = sat->sat_addr.s_net;
AA_SAT( aa )->sat_addr.s_node = sat->sat_addr.s_node;
  375     } else {
aa->aa_flags |= AFA_PROBING;
AA_SAT( aa )->sat_len = sizeof(struct sockaddr_at);
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 ) {
net = ntohs( nr.nr_firstnet ) +
arc4random() % ( nnets - 1 );
  384                 } else {
net = ntohs( nr.nr_firstnet );
  386                 }
  387             } else {
  388                 if ( ntohs( sat->sat_addr.s_net ) < ntohs( nr.nr_firstnet ) ||
ntohs( sat->sat_addr.s_net ) > ntohs( nr.nr_lastnet )) {
aa->aa_addr = oldaddr;
aa->aa_firstnet = onr.nr_firstnet;
aa->aa_lastnet = onr.nr_lastnet;
splx(s);
  394                     return( EINVAL );
  395                 }
net = ntohs( sat->sat_addr.s_net );
  397             }
  398         } else {
net = ntohs( sat->sat_addr.s_net );
  400         }
  402         if ( sat->sat_addr.s_node == ATADDR_ANYNODE ) {
AA_SAT( aa )->sat_addr.s_node = arc4random();
  404         } else {
AA_SAT( aa )->sat_addr.s_node = sat->sat_addr.s_node;
  406         }
  408         for ( i = nnets, netinc = 1; i > 0; net = ntohs( nr.nr_firstnet ) +
  409                 (( net - ntohs( nr.nr_firstnet ) + netinc ) % nnets ), i-- ) {
AA_SAT( aa )->sat_addr.s_net = htons( net );
  412             for ( j = 0, nodeinc = arc4random() | 1; j < 256;
j++, AA_SAT( aa )->sat_addr.s_node += nodeinc ) {
  414                 if ( AA_SAT( aa )->sat_addr.s_node > 253 ||
AA_SAT( aa )->sat_addr.s_node < 1 ) {
  416                     continue;
  417                 }
aa->aa_probcnt = 10;
timeout_set(&aarpprobe_timeout, aarpprobe, ifp);
  420                 /* XXX don't use hz so badly */
timeout_add(&aarpprobe_timeout, hz / 5);
  422                 if ( tsleep( aa, PPAUSE|PCATCH, "at_ifinit", 0 )) {
printf( "at_ifinit why did this happen?!\n" );
aa->aa_addr = oldaddr;
aa->aa_firstnet = onr.nr_firstnet;
aa->aa_lastnet = onr.nr_lastnet;
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 */
AA_SAT( aa )->sat_addr.s_node = arc4random();
  439         }
  441         if ( aa->aa_flags & AFA_PROBING ) {
aa->aa_addr = oldaddr;
aa->aa_firstnet = onr.nr_firstnet;
aa->aa_lastnet = onr.nr_lastnet;
splx( s );
  446             return( EADDRINUSE );
  447         }
  448     }
  450     if ( ifp->if_ioctl &&
  451             ( error = (*ifp->if_ioctl)( ifp, SIOCSIFADDR, (caddr_t) aa ))) {
aa->aa_addr = oldaddr;
aa->aa_firstnet = onr.nr_firstnet;
aa->aa_lastnet = onr.nr_lastnet;
splx( s );
  456         return( error );
  457     }
bzero(&aa->aa_netmask, sizeof(aa->aa_netmask));
aa->aa_netmask.sat_len = sizeof(struct sockaddr_at);
aa->aa_netmask.sat_family = AF_APPLETALK;
aa->aa_netmask.sat_addr.s_net = 0xffff;
aa->aa_netmask.sat_addr.s_node = 0;
  464     /* XXX From FreeBSD. Why does it do this? */
aa->aa_ifa.ifa_netmask =(struct sockaddr *) &(aa->aa_netmask);
  467     /* This block came from FreeBSD too */
  468     /*
  469      * Initialize broadcast (or remote p2p) address
  470      */
bzero(&aa->aa_broadaddr, sizeof(aa->aa_broadaddr));
aa->aa_broadaddr.sat_len = sizeof(struct sockaddr_at);
aa->aa_broadaddr.sat_family = AF_APPLETALK;
aa->aa_ifa.ifa_metric = ifp->if_metric;
  476     if (ifp->if_flags & IFF_BROADCAST) {
aa->aa_broadaddr.sat_addr.s_net = htons(0);
aa->aa_broadaddr.sat_addr.s_node = 0xff;
aa->aa_ifa.ifa_broadaddr = (struct sockaddr *) &aa->aa_broadaddr;
  480         /* add the range of routes needed */
error = aa_dorangeroute(&aa->aa_ifa,
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;
bzero(&rtaddr, sizeof(rtaddr));
bzero(&rtmask, sizeof(rtmask));
  489         /* fill in the far end if we know it here XXX */
aa->aa_ifa.ifa_dstaddr = (struct sockaddr *) &aa->aa_broadaddr;
error = aa_addsingleroute(&aa->aa_ifa, &rtaddr, &rtmask);
  492     }
  493     else if ( ifp->if_flags & IFF_LOOPBACK ) {
  494         struct at_addr  rtaddr, rtmask;
bzero(&rtaddr, sizeof(rtaddr));
bzero(&rtmask, sizeof(rtmask));
rtaddr.s_net = AA_SAT( aa )->sat_addr.s_net;
rtaddr.s_node = AA_SAT( aa )->sat_addr.s_node;
rtmask.s_net = 0xffff;
rtmask.s_node = 0x0; /* XXX should not be so.. should be HOST route */
error = aa_addsingleroute(&aa->aa_ifa, &rtaddr, &rtmask);
  503     }
  505     if ( error ) {
at_scrub( ifp, aa );
aa->aa_addr = oldaddr;
aa->aa_firstnet = onr.nr_firstnet;
aa->aa_lastnet = onr.nr_lastnet;
splx( s );
  511         return( error );
  512     }
aa->aa_ifa.ifa_flags |= IFA_ROUTE;
aa->aa_flags |= AFA_ROUTE;
splx( s );
  517     return( 0 );
  518 }
  520 int
at_broadcast( sat )
  522     struct sockaddr_at  *sat;
  523 {
  524     struct at_ifaddr    *aa;
  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 ) &&
ntohs( sat->sat_addr.s_net ) <= ntohs( aa->aa_lastnet ))) {
  536                 return( 1 );
  537             }
  538         }
  539     }
  540     return( 0 );
  541 }
  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  */
  559 static int
aa_dorangeroute(struct ifaddr *ifa, u_int bot, u_int top, int cmd)
  561 {
u_int mask1;
  563         struct at_addr addr;
  564         struct at_addr mask;
  565         int error;
  567         /*
  568          * slight sanity check
  569          */
  570         if (bot > top) return (EINVAL);
addr.s_node = 0;
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          */
  579          while (bot <= top) {
mask1 = 1;
  581                 while ((( bot & ~mask1) >= bot)
  582                    && (( bot | mask1) <= top)) {
mask1 <<= 1;
mask1 |= 1;
  585                 }
mask1 >>= 1;
mask.s_net = htons(~mask1);
addr.s_net = htons(bot);
  589                 if(cmd == RTM_ADD) {
error =  aa_addsingleroute(ifa,&addr,&mask);
  591                         if (error) {
  592                                 /* XXX clean up? */
  593                                 return (error);
  594                         }
  595                 } else {
error =  aa_delsingleroute(ifa,&addr,&mask);
  597                 }
bot = (bot | mask1) + 1;
  599         }
  600         return 0;
  601 }
  603 static int
aa_addsingleroute(struct ifaddr *ifa,
  605         struct at_addr *addr, struct at_addr *mask)
  606 {
  607   int   error;
  609 #if 0
printf("aa_addsingleroute: %x.%x mask %x.%x ...\n",
ntohs(addr->s_net), addr->s_node,
ntohs(mask->s_net), mask->s_node);
  613 #endif
error = aa_dosingleroute(ifa, addr, mask, RTM_ADD, RTF_UP);
  616   if (error)
printf("aa_addsingleroute: error %d\n", error);
  618   return(error);
  619 }
  621 static int
aa_delsingleroute(struct ifaddr *ifa,
  623         struct at_addr *addr, struct at_addr *mask)
  624 {
  625   int   error;
error = aa_dosingleroute(ifa, addr, mask, RTM_DELETE, 0);
  628   if (error)
printf("aa_delsingleroute: error %d\n", error);
  630   return(error);
  631 }
  633 static int
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;
bzero(&addr, sizeof(addr));
bzero(&mask, sizeof(mask));
addr.sat_family = AF_APPLETALK;
addr.sat_len = sizeof(struct sockaddr_at);
addr.sat_addr.s_net = at_addr->s_net;
addr.sat_addr.s_node = at_addr->s_node;
mask.sat_family = AF_APPLETALK;
mask.sat_len = sizeof(struct sockaddr_at);
mask.sat_addr.s_net = at_mask->s_net;
mask.sat_addr.s_node = at_mask->s_node;
  649   if (at_mask->s_node)
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 }