655929bfba
Kernel Appletalk protocol support both CAP and netatalk can make use of this.. still needs some owrk but it seemd the right tiime to commit it so other can experiment.
615 lines
15 KiB
C
615 lines
15 KiB
C
/*
|
|
* Copyright (c) 1990,1991 Regents of The University of Michigan.
|
|
* All Rights Reserved.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#ifdef ibm032
|
|
#include <sys/dir.h>
|
|
#endif ibm032
|
|
#include <sys/proc.h>
|
|
#ifndef BSD4_4
|
|
#include <sys/user.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mbuf.h>
|
|
#ifndef _IBMR2
|
|
#include <sys/kernel.h>
|
|
#endif _IBMR2
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
#include <net/if.h>
|
|
/* #include <net/af.h> */
|
|
#include <net/route.h>
|
|
#include <netinet/in.h>
|
|
#undef s_net
|
|
#include <netinet/if_ether.h>
|
|
#ifdef _IBMR2
|
|
#include <net/spl.h>
|
|
#endif _IBMR2
|
|
|
|
#include "at.h"
|
|
#include "at_var.h"
|
|
#include "aarp.h"
|
|
#include "phase2.h"
|
|
#include <netatalk/at_extern.h>
|
|
|
|
static int at_scrub( struct ifnet *ifp, struct at_ifaddr *aa );
|
|
static int at_ifinit( struct ifnet *ifp, struct at_ifaddr *aa,
|
|
struct sockaddr_at *sat );
|
|
|
|
#ifdef BSD4_4
|
|
# define sateqaddr(a,b) ((a)->sat_len == (b)->sat_len && \
|
|
(a)->sat_family == (b)->sat_family && \
|
|
(a)->sat_addr.s_net == (b)->sat_addr.s_net && \
|
|
(a)->sat_addr.s_node == (b)->sat_addr.s_node )
|
|
#else BSD4_4
|
|
atalk_hash( sat, hp )
|
|
struct sockaddr_at *sat;
|
|
struct afhash *hp;
|
|
{
|
|
hp->afh_nethash = sat->sat_addr.s_net;
|
|
hp->afh_hosthash = ( sat->sat_addr.s_net << 8 ) +
|
|
sat->sat_addr.s_node;
|
|
}
|
|
|
|
/*
|
|
* Note the magic to get ifa_ifwithnet() to work without adding an
|
|
* ifaddr entry for each net in our local range.
|
|
*/
|
|
int
|
|
atalk_netmatch( sat1, sat2 )
|
|
struct sockaddr_at *sat1, *sat2;
|
|
{
|
|
struct at_ifaddr *aa;
|
|
|
|
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
|
|
if ( AA_SAT( aa ) == sat1 ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( aa ) {
|
|
return( ntohs( aa->aa_firstnet ) <= ntohs( sat2->sat_addr.s_net ) &&
|
|
ntohs( aa->aa_lastnet ) >= ntohs( sat2->sat_addr.s_net ));
|
|
}
|
|
return( sat1->sat_addr.s_net == sat2->sat_addr.s_net );
|
|
}
|
|
#endif BSD4_4
|
|
|
|
int
|
|
at_control( int cmd, caddr_t data, struct ifnet *ifp, struct proc *p )
|
|
{
|
|
struct ifreq *ifr = (struct ifreq *)data;
|
|
struct sockaddr_at *sat;
|
|
struct netrange *nr;
|
|
#ifdef BSD4_4
|
|
struct at_aliasreq *ifra = (struct at_aliasreq *)data;
|
|
struct at_ifaddr *aa0;
|
|
#endif BSD4_4
|
|
struct at_ifaddr *aa = 0;
|
|
struct mbuf *m;
|
|
struct ifaddr *ifa;
|
|
|
|
if ( ifp ) {
|
|
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
|
|
if ( aa->aa_ifp == ifp ) break;
|
|
}
|
|
}
|
|
|
|
switch ( cmd ) {
|
|
#ifdef BSD4_4
|
|
case SIOCAIFADDR:
|
|
case SIOCDIFADDR:
|
|
if ( ifra->ifra_addr.sat_family == AF_APPLETALK ) {
|
|
for ( ; aa; aa = aa->aa_next ) {
|
|
if ( aa->aa_ifp == ifp &&
|
|
sateqaddr( &aa->aa_addr, &ifra->ifra_addr )) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ( cmd == SIOCDIFADDR && aa == 0 ) {
|
|
return( EADDRNOTAVAIL );
|
|
}
|
|
/*FALLTHROUGH*/
|
|
#endif BSD4_4
|
|
|
|
case SIOCSIFADDR:
|
|
#ifdef BSD4_4
|
|
/*
|
|
* What a great idea this is: Let's reverse the meaning of
|
|
* the return...
|
|
*/
|
|
#if defined( __FreeBSD__ )
|
|
if ( suser(p->p_ucred, &p->p_acflag) ) {
|
|
#else
|
|
if ( suser( u.u_cred, &u.u_acflag )) {
|
|
#endif
|
|
return( EPERM );
|
|
}
|
|
#else BSD4_4
|
|
if ( !suser()) {
|
|
return( EPERM );
|
|
}
|
|
#endif BSD4_4
|
|
|
|
sat = satosat( &ifr->ifr_addr );
|
|
nr = (struct netrange *)sat->sat_zero;
|
|
if ( nr->nr_phase == 1 ) {
|
|
for ( ; aa; aa = aa->aa_next ) {
|
|
if ( aa->aa_ifp == ifp &&
|
|
( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
|
|
break;
|
|
}
|
|
}
|
|
} else { /* default to phase 2 */
|
|
for ( ; aa; aa = aa->aa_next ) {
|
|
if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ifp == 0 )
|
|
panic( "at_control" );
|
|
|
|
if ( aa == (struct at_ifaddr *) 0 ) {
|
|
m = m_getclr( M_WAIT, MT_IFADDR );
|
|
if ( m == (struct mbuf *)NULL ) {
|
|
return( ENOBUFS );
|
|
}
|
|
|
|
if (( aa = at_ifaddr ) != NULL ) {
|
|
/*
|
|
* Don't let the loopback be first, since the first
|
|
* address is the machine's default address for
|
|
* binding.
|
|
*/
|
|
if ( at_ifaddr->aa_ifp->if_flags & IFF_LOOPBACK ) {
|
|
aa = mtod( m, struct at_ifaddr *);
|
|
aa->aa_next = at_ifaddr;
|
|
at_ifaddr = aa;
|
|
} else {
|
|
for ( ; aa->aa_next; aa = aa->aa_next )
|
|
;
|
|
aa->aa_next = mtod( m, struct at_ifaddr *);
|
|
}
|
|
} else {
|
|
at_ifaddr = mtod( m, struct at_ifaddr *);
|
|
}
|
|
|
|
aa = mtod( m, struct at_ifaddr *);
|
|
|
|
if (( ifa = ifp->if_addrlist ) != NULL ) {
|
|
for ( ; ifa->ifa_next; ifa = ifa->ifa_next )
|
|
;
|
|
ifa->ifa_next = (struct ifaddr *)aa;
|
|
} else {
|
|
ifp->if_addrlist = (struct ifaddr *)aa;
|
|
}
|
|
|
|
#ifdef BSD4_4
|
|
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;
|
|
#endif BSD4_4
|
|
|
|
/*
|
|
* Set/clear the phase 2 bit.
|
|
*/
|
|
if ( nr->nr_phase == 1 ) {
|
|
aa->aa_flags &= ~AFA_PHASE2;
|
|
} else {
|
|
aa->aa_flags |= AFA_PHASE2;
|
|
}
|
|
aa->aa_ifp = ifp;
|
|
} else {
|
|
at_scrub( ifp, aa );
|
|
}
|
|
break;
|
|
|
|
case SIOCGIFADDR :
|
|
sat = satosat( &ifr->ifr_addr );
|
|
nr = (struct netrange *)sat->sat_zero;
|
|
if ( nr->nr_phase == 1 ) {
|
|
for ( ; aa; aa = aa->aa_next ) {
|
|
if ( aa->aa_ifp == ifp &&
|
|
( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
|
|
break;
|
|
}
|
|
}
|
|
} else { /* default to phase 2 */
|
|
for ( ; aa; aa = aa->aa_next ) {
|
|
if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( aa == (struct at_ifaddr *) 0 )
|
|
return( EADDRNOTAVAIL );
|
|
break;
|
|
}
|
|
|
|
switch ( cmd ) {
|
|
case SIOCGIFADDR:
|
|
#ifdef BSD4_4
|
|
*(struct sockaddr_at *)&ifr->ifr_addr = aa->aa_addr;
|
|
#else BSD4_4
|
|
ifr->ifr_addr = aa->aa_addr;
|
|
#endif BSD4_4
|
|
break;
|
|
|
|
case SIOCSIFADDR:
|
|
return( at_ifinit( ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr ));
|
|
|
|
#ifdef BSD4_4
|
|
case SIOCAIFADDR:
|
|
if ( sateqaddr( &ifra->ifra_addr, &aa->aa_addr )) {
|
|
return( 0 );
|
|
}
|
|
return( at_ifinit( ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr ));
|
|
|
|
case SIOCDIFADDR:
|
|
at_scrub( ifp, aa );
|
|
if (( ifa = ifp->if_addrlist ) == (struct ifaddr *)aa ) {
|
|
ifp->if_addrlist = ifa->ifa_next;
|
|
} else {
|
|
while ( ifa->ifa_next && ( ifa->ifa_next != (struct ifaddr *)aa )) {
|
|
ifa = ifa->ifa_next;
|
|
}
|
|
if ( ifa->ifa_next ) {
|
|
ifa->ifa_next = ((struct ifaddr *)aa)->ifa_next;
|
|
} else {
|
|
panic( "at_control" );
|
|
}
|
|
}
|
|
|
|
aa0 = aa;
|
|
if ( aa0 == ( aa = at_ifaddr )) {
|
|
at_ifaddr = aa->aa_next;
|
|
} else {
|
|
while ( aa->aa_next && ( aa->aa_next != aa0 )) {
|
|
aa = aa->aa_next;
|
|
}
|
|
if ( aa->aa_next ) {
|
|
aa->aa_next = aa0->aa_next;
|
|
} else {
|
|
panic( "at_control" );
|
|
}
|
|
}
|
|
m_free( dtom( aa0 ));
|
|
break;
|
|
#endif BSD4_4
|
|
|
|
default:
|
|
if ( ifp == 0 || ifp->if_ioctl == 0 )
|
|
return( EOPNOTSUPP );
|
|
return( (*ifp->if_ioctl)( ifp, cmd, data ));
|
|
}
|
|
return( 0 );
|
|
}
|
|
static int
|
|
at_scrub( ifp, aa )
|
|
struct ifnet *ifp;
|
|
struct at_ifaddr *aa;
|
|
{
|
|
#ifndef BSD4_4
|
|
struct sockaddr_at netsat;
|
|
u_short net;
|
|
#endif BSD4_4
|
|
int error;
|
|
|
|
if ( aa->aa_flags & AFA_ROUTE ) {
|
|
#ifdef BSD4_4
|
|
if (( error = rtinit( &(aa->aa_ifa), RTM_DELETE,
|
|
( ifp->if_flags & IFF_LOOPBACK ) ? RTF_HOST : 0 )) != 0 ) {
|
|
return( error );
|
|
}
|
|
aa->aa_ifa.ifa_flags &= ~IFA_ROUTE;
|
|
#else BSD4_4
|
|
if ( ifp->if_flags & IFF_LOOPBACK ) {
|
|
rtinit( &aa->aa_addr, &aa->aa_addr, SIOCDELRT, RTF_HOST );
|
|
} else {
|
|
bzero( &netsat, sizeof( struct sockaddr_at ));
|
|
netsat.sat_family = AF_APPLETALK;
|
|
netsat.sat_addr.s_node = ATADDR_ANYNODE;
|
|
|
|
/*
|
|
* If the range is the full 0-fffe range, just use
|
|
* the default route.
|
|
*/
|
|
if ( aa->aa_firstnet == htons( 0x0000 ) &&
|
|
aa->aa_lastnet == htons( 0xfffe )) {
|
|
netsat.sat_addr.s_net = 0;
|
|
rtinit((struct sockaddr *)&netsat, &aa->aa_addr,
|
|
(int)SIOCDELRT, 0 );
|
|
} else {
|
|
for ( net = ntohs( aa->aa_firstnet );
|
|
net <= ntohs( aa->aa_lastnet ); net++ ) {
|
|
netsat.sat_addr.s_net = htons( net );
|
|
rtinit((struct sockaddr *)&netsat, &aa->aa_addr,
|
|
(int)SIOCDELRT, 0 );
|
|
}
|
|
}
|
|
}
|
|
#endif BSD4_4
|
|
aa->aa_flags &= ~AFA_ROUTE;
|
|
}
|
|
return( 0 );
|
|
}
|
|
|
|
#if !defined( __FreeBSD__ )
|
|
extern struct timeval time;
|
|
#endif __FreeBSD__
|
|
|
|
static int
|
|
at_ifinit( ifp, aa, sat )
|
|
struct ifnet *ifp;
|
|
struct at_ifaddr *aa;
|
|
struct sockaddr_at *sat;
|
|
{
|
|
struct netrange nr, onr;
|
|
#ifdef BSD4_4
|
|
struct sockaddr_at oldaddr;
|
|
#else BSD4_4
|
|
struct sockaddr oldaddr;
|
|
#endif BSD4_4
|
|
struct sockaddr_at netaddr;
|
|
int s = splimp(), error = 0, i, j, netinc, nodeinc, nnets;
|
|
u_short net;
|
|
|
|
oldaddr = aa->aa_addr;
|
|
bzero( AA_SAT( aa ), sizeof( struct sockaddr_at ));
|
|
bcopy( sat->sat_zero, &nr, 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;
|
|
|
|
/*
|
|
* We could eliminate the need for a second phase 1 probe (post
|
|
* autoconf) if we check whether we're resetting the node. Note
|
|
* that phase 1 probes use only nodes, not net.node pairs. Under
|
|
* phase 2, both the net and node must be the same.
|
|
*/
|
|
if ( ifp->if_flags & IFF_LOOPBACK ) {
|
|
#ifdef BSD4_4
|
|
AA_SAT( aa )->sat_len = sat->sat_len;
|
|
#endif BSD4_4
|
|
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;
|
|
} else {
|
|
aa->aa_flags |= AFA_PROBING;
|
|
#ifdef BSD4_4
|
|
AA_SAT( aa )->sat_len = sizeof(struct sockaddr_at);
|
|
#endif BSD4_4
|
|
AA_SAT( aa )->sat_family = AF_APPLETALK;
|
|
if ( aa->aa_flags & AFA_PHASE2 ) {
|
|
if ( sat->sat_addr.s_net == ATADDR_ANYNET ) {
|
|
if ( nnets != 1 ) {
|
|
net = ntohs( nr.nr_firstnet ) + time.tv_sec % ( nnets - 1 );
|
|
} else {
|
|
net = ntohs( nr.nr_firstnet );
|
|
}
|
|
} else {
|
|
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;
|
|
return( EINVAL );
|
|
}
|
|
net = ntohs( sat->sat_addr.s_net );
|
|
}
|
|
} else {
|
|
net = ntohs( sat->sat_addr.s_net );
|
|
}
|
|
|
|
if ( sat->sat_addr.s_node == ATADDR_ANYNODE ) {
|
|
AA_SAT( aa )->sat_addr.s_node = time.tv_sec;
|
|
} else {
|
|
AA_SAT( aa )->sat_addr.s_node = sat->sat_addr.s_node;
|
|
}
|
|
|
|
for ( i = nnets, netinc = 1; i > 0; net = ntohs( nr.nr_firstnet ) +
|
|
(( net - ntohs( nr.nr_firstnet ) + netinc ) % nnets ), i-- ) {
|
|
AA_SAT( aa )->sat_addr.s_net = htons( net );
|
|
|
|
for ( j = 0, nodeinc = time.tv_sec | 1; j < 256;
|
|
j++, AA_SAT( aa )->sat_addr.s_node += nodeinc ) {
|
|
if ( AA_SAT( aa )->sat_addr.s_node > 253 ||
|
|
AA_SAT( aa )->sat_addr.s_node < 1 ) {
|
|
continue;
|
|
}
|
|
aa->aa_probcnt = 10;
|
|
timeout( (timeout_func_t)aarpprobe, (caddr_t)ifp, hz / 5 );
|
|
splx( s );
|
|
if (
|
|
#if defined( __FreeBSD__ )
|
|
tsleep( aa, PPAUSE|PCATCH, "at_ifinit", 0 )
|
|
#else
|
|
sleep( aa, PSLEP|PCATCH )
|
|
#endif
|
|
) {
|
|
printf( "at_ifinit why did this happen?!\n" );
|
|
aa->aa_addr = oldaddr;
|
|
aa->aa_firstnet = onr.nr_firstnet;
|
|
aa->aa_lastnet = onr.nr_lastnet;
|
|
return( EINTR );
|
|
}
|
|
s = splimp();
|
|
if (( aa->aa_flags & AFA_PROBING ) == 0 ) {
|
|
break;
|
|
}
|
|
}
|
|
if (( aa->aa_flags & AFA_PROBING ) == 0 ) {
|
|
break;
|
|
}
|
|
/* reset node for next network */
|
|
AA_SAT( aa )->sat_addr.s_node = time.tv_sec;
|
|
}
|
|
|
|
if ( aa->aa_flags & AFA_PROBING ) {
|
|
aa->aa_addr = oldaddr;
|
|
aa->aa_firstnet = onr.nr_firstnet;
|
|
aa->aa_lastnet = onr.nr_lastnet;
|
|
splx( s );
|
|
return( EADDRINUSE );
|
|
}
|
|
}
|
|
|
|
if ( ifp->if_ioctl &&
|
|
( error = (*ifp->if_ioctl)( ifp, SIOCSIFADDR, (caddr_t)aa ))) {
|
|
splx( s );
|
|
aa->aa_addr = oldaddr;
|
|
aa->aa_firstnet = onr.nr_firstnet;
|
|
aa->aa_lastnet = onr.nr_lastnet;
|
|
return( error );
|
|
}
|
|
|
|
#ifdef BSD4_4
|
|
aa->aa_netmask.sat_len = 6/*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;
|
|
#if defined( __FreeBSD__ )
|
|
aa->aa_ifa.ifa_netmask =(struct sockaddr *) &(aa->aa_netmask); /* XXX */
|
|
#endif __FreeBSD__
|
|
#endif BSD4_4
|
|
|
|
if ( ifp->if_flags & IFF_LOOPBACK ) {
|
|
#ifndef BSD4_4
|
|
rtinit( &aa->aa_addr, &aa->aa_addr, (int)SIOCADDRT,
|
|
RTF_HOST|RTF_UP );
|
|
#else BSD4_4
|
|
error = rtinit( &(aa->aa_ifa), (int)RTM_ADD,
|
|
#if !defined( __FreeBSD__ )
|
|
RTF_HOST |
|
|
#else
|
|
/* XXX not a host route? */
|
|
#endif __FreeBSD__
|
|
RTF_UP );
|
|
#endif BSD4_4
|
|
} else {
|
|
#ifndef BSD4_4
|
|
/*
|
|
* rtrequest looks for point-to-point links first. The
|
|
* broadaddr is in the same spot as the destaddr. So, if
|
|
* ATADDR_ANYNET is 0, and we don't fill in the broadaddr, we
|
|
* get 0.0 routed out the ether interface. So, initialize the
|
|
* broadaddr, even tho we don't use it.
|
|
*
|
|
* We *could* use the broadaddr field to reduce some of the
|
|
* sockaddr_at overloading that we've done. E.g. Just send
|
|
* to INTERFACE-NET.255, and have the kernel reroute that
|
|
* to broadaddr, which would be 0.255 for phase 2 interfaces,
|
|
* and IFACE-NET.255 for phase 1 interfaces.
|
|
*/
|
|
((struct sockaddr_at *)&aa->aa_broadaddr)->sat_addr.s_net =
|
|
sat->sat_addr.s_net;
|
|
((struct sockaddr_at *)&aa->aa_broadaddr)->sat_addr.s_node =
|
|
ATADDR_BCAST;
|
|
|
|
bzero( &netaddr, sizeof( struct sockaddr_at ));
|
|
netaddr.sat_family = AF_APPLETALK;
|
|
netaddr.sat_addr.s_node = ATADDR_ANYNODE;
|
|
if (( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
|
|
netaddr.sat_addr.s_net = AA_SAT( aa )->sat_addr.s_net;
|
|
rtinit((struct sockaddr *)&netaddr, &aa->aa_addr,
|
|
(int)SIOCADDRT, RTF_UP );
|
|
} else {
|
|
/*
|
|
* If the range is the full 0-fffe range, just use
|
|
* the default route.
|
|
*/
|
|
if ( aa->aa_firstnet == htons( 0x0000 ) &&
|
|
aa->aa_lastnet == htons( 0xfffe )) {
|
|
netaddr.sat_addr.s_net = 0;
|
|
rtinit((struct sockaddr *)&netaddr, &aa->aa_addr,
|
|
(int)SIOCADDRT, RTF_UP );
|
|
} else {
|
|
for ( net = ntohs( aa->aa_firstnet );
|
|
net <= ntohs( aa->aa_lastnet ); net++ ) {
|
|
netaddr.sat_addr.s_net = htons( net );
|
|
rtinit((struct sockaddr *)&netaddr, &aa->aa_addr,
|
|
(int)SIOCADDRT, RTF_UP );
|
|
}
|
|
}
|
|
}
|
|
#else BSD4_4
|
|
error = rtinit( &(aa->aa_ifa), (int)RTM_ADD, RTF_UP );
|
|
#endif BSD4_4
|
|
}
|
|
if ( error ) {
|
|
aa->aa_addr = oldaddr;
|
|
aa->aa_firstnet = onr.nr_firstnet;
|
|
aa->aa_lastnet = onr.nr_lastnet;
|
|
splx( s );
|
|
return( error );
|
|
}
|
|
|
|
#ifdef BSD4_4
|
|
aa->aa_ifa.ifa_flags |= IFA_ROUTE;
|
|
#endif BSD4_4
|
|
aa->aa_flags |= AFA_ROUTE;
|
|
splx( s );
|
|
return( 0 );
|
|
}
|
|
|
|
int
|
|
at_broadcast( sat )
|
|
struct sockaddr_at *sat;
|
|
{
|
|
struct at_ifaddr *aa;
|
|
|
|
if ( sat->sat_addr.s_node != ATADDR_BCAST ) {
|
|
return( 0 );
|
|
}
|
|
if ( sat->sat_addr.s_net == ATADDR_ANYNET ) {
|
|
return( 1 );
|
|
} else {
|
|
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
|
|
if (( aa->aa_ifp->if_flags & IFF_BROADCAST ) &&
|
|
( ntohs( sat->sat_addr.s_net ) >= ntohs( aa->aa_firstnet ) &&
|
|
ntohs( sat->sat_addr.s_net ) <= ntohs( aa->aa_lastnet ))) {
|
|
return( 1 );
|
|
}
|
|
}
|
|
}
|
|
return( 0 );
|
|
}
|
|
|
|
static void
|
|
aa_clean(void)
|
|
{
|
|
struct at_ifaddr *aa;
|
|
struct ifaddr *ifa;
|
|
struct ifnet *ifp;
|
|
|
|
while ( aa = at_ifaddr ) {
|
|
ifp = aa->aa_ifp;
|
|
at_scrub( ifp, aa );
|
|
at_ifaddr = aa->aa_next;
|
|
if (( ifa = ifp->if_addrlist ) == (struct ifaddr *)aa ) {
|
|
ifp->if_addrlist = ifa->ifa_next;
|
|
} else {
|
|
while ( ifa->ifa_next &&
|
|
( ifa->ifa_next != (struct ifaddr *)aa )) {
|
|
ifa = ifa->ifa_next;
|
|
}
|
|
if ( ifa->ifa_next ) {
|
|
ifa->ifa_next = ((struct ifaddr *)aa)->ifa_next;
|
|
} else {
|
|
panic( "at_entry" );
|
|
}
|
|
}
|
|
}
|
|
}
|