system/freebsd-src
system/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src synced 2024-10-17 05:43:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Since I have my hands all over netatalk adding locking and restructuring

Browse source 
it, cinch the file's style closer to style(9) with regard to parenthesis:

  s/( /(/g
  s/ )/)/g
  s/return(/return (/g
  s/return 0/return (0)/
  s/return 1/return (1)/
This commit is contained in:
Robert Watson 2004-03-22 03:24:10 +00:00
parent 2edbecc6db
commit b8e3da4a83
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=127288
5 changed files with 576 additions and 576 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

422
sys/netatalk/aarp.c
View file

@ -28,8 +28,8 @@
#include <netatalk/phase2.h>
#include <netatalk/at_extern.h>
static void aarptfree( struct aarptab *aat);
static void at_aarpinput( struct arpcom *ac, struct mbuf *m);
static void aarptfree(struct aarptab *aat);
static void at_aarpinput(struct arpcom *ac, struct mbuf *m);
#define AARPTAB_BSIZ 9
#define AARPTAB_NB 19
@ -37,16 +37,16 @@ static void at_aarpinput( struct arpcom *ac, struct mbuf *m);
static struct aarptab aarptab[AARPTAB_SIZE];
#define AARPTAB_HASH(a) \
((((a).s_net << 8 ) + (a).s_node ) % AARPTAB_NB )
((((a).s_net << 8) + (a).s_node) % AARPTAB_NB)
#define AARPTAB_LOOK(aat,addr) { \
int n; \
aat = &aarptab[ AARPTAB_HASH(addr) * AARPTAB_BSIZ ]; \
for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) \
if ( aat->aat_ataddr.s_net == (addr).s_net && \
aat->aat_ataddr.s_node == (addr).s_node ) \
for (n = 0; n < AARPTAB_BSIZ; n++, aat++) \
if (aat->aat_ataddr.s_net == (addr).s_net && \
aat->aat_ataddr.s_node == (addr).s_node) \
break; \
if ( n >= AARPTAB_BSIZ ) \
if (n >= AARPTAB_BSIZ) \
aat = 0; \
}
@ -54,7 +54,7 @@ static struct aarptab aarptab[AARPTAB_SIZE];
#define AARPT_KILLC 20
#define AARPT_KILLI 3
# if !defined( __FreeBSD__ )
# if !defined(__FreeBSD__)
extern u_char etherbroadcastaddr[6];
# endif /* __FreeBSD__ */
@ -81,17 +81,17 @@ aarptimer(void *ignored)
struct aarptab *aat;
int i, s;
aarptimer_ch = timeout( aarptimer, (caddr_t)0, AARPT_AGE * hz );
aarptimer_ch = timeout(aarptimer, (caddr_t)0, AARPT_AGE * hz);
aat = aarptab;
for ( i = 0; i < AARPTAB_SIZE; i++, aat++ ) {
if ( aat->aat_flags == 0 || ( aat->aat_flags & ATF_PERM ))
for (i = 0; i < AARPTAB_SIZE; i++, aat++) {
if (aat->aat_flags == 0 || (aat->aat_flags & ATF_PERM))
continue;
if ( ++aat->aat_timer < (( aat->aat_flags & ATF_COM ) ?
AARPT_KILLC : AARPT_KILLI ))
if (++aat->aat_timer < ((aat->aat_flags & ATF_COM) ?
AARPT_KILLC : AARPT_KILLI))
continue;
s = splimp();
aarptfree( aat );
splx( s );
aarptfree(aat);
splx(s);
}
}
@ -101,27 +101,27 @@ aarptimer(void *ignored)
* consideration.
*/
struct at_ifaddr *
at_ifawithnet(struct sockaddr_at *sat )
at_ifawithnet(struct sockaddr_at *sat)
{
struct at_ifaddr *aa;
struct sockaddr_at *sat2;
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
for (aa = at_ifaddr; aa; aa = aa->aa_next) {
sat2 = &(aa->aa_addr);
if ( sat2->sat_addr.s_net == sat->sat_addr.s_net ) {
if (sat2->sat_addr.s_net == sat->sat_addr.s_net) {
break;
}
if( (aa->aa_flags & AFA_PHASE2 )
if((aa->aa_flags & AFA_PHASE2)
&& (ntohs(aa->aa_firstnet) <= ntohs(sat->sat_addr.s_net))
&& (ntohs(aa->aa_lastnet) >= ntohs(sat->sat_addr.s_net))) {
break;
}
}
return( aa );
return (aa);
}
static void
aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat )
aarpwhohas(struct arpcom *ac, struct sockaddr_at *sat)
{
struct mbuf *m;
struct ether_header *eh;
@ -130,26 +130,26 @@ aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat )
struct llc *llc;
struct sockaddr sa;
if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL) {
return;
}
#ifdef MAC
mac_create_mbuf_linklayer(&ac->ac_if, m);
#endif
m->m_len = sizeof( *ea );
m->m_pkthdr.len = sizeof( *ea );
MH_ALIGN( m, sizeof( *ea ));
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 = 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 );
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,
sizeof( ea->aarp_sha ));
sizeof(ea->aarp_sha));
/*
* We need to check whether the output ethernet type should
@ -158,55 +158,55 @@ aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat )
* interface with the same address as we're looking for. If the
* net is phase 2, generate an 802.2 and SNAP header.
*/
if ((aa = at_ifawithnet( sat )) == NULL) {
m_freem( m );
if ((aa = at_ifawithnet(sat)) == NULL) {
m_freem(m);
return;
}
eh = (struct ether_header *)sa.sa_data;
if ( aa->aa_flags & AFA_PHASE2 ) {
bcopy(atmulticastaddr, eh->ether_dhost, sizeof( eh->ether_dhost ));
if (aa->aa_flags & AFA_PHASE2) {
bcopy(atmulticastaddr, eh->ether_dhost, sizeof(eh->ether_dhost));
eh->ether_type = htons(sizeof(struct llc) + sizeof(struct ether_aarp));
M_PREPEND( m, sizeof( struct llc ), M_TRYWAIT );
if ( m == NULL ) {
M_PREPEND(m, sizeof(struct llc), M_TRYWAIT);
if (m == NULL) {
return;
}
llc = mtod( m, struct llc *);
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 );
llc->llc_ether_type = htons(ETHERTYPE_AARP);
bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_spnet,
sizeof( ea->aarp_spnet ));
bcopy( &sat->sat_addr.s_net, ea->aarp_tpnet,
sizeof( ea->aarp_tpnet ));
ea->aarp_spnode = AA_SAT( aa )->sat_addr.s_node;
bcopy(&AA_SAT(aa)->sat_addr.s_net, ea->aarp_spnet,
sizeof(ea->aarp_spnet));
bcopy(&sat->sat_addr.s_net, ea->aarp_tpnet,
sizeof(ea->aarp_tpnet));
ea->aarp_spnode = AA_SAT(aa)->sat_addr.s_node;
ea->aarp_tpnode = sat->sat_addr.s_node;
} else {
bcopy(ac->ac_if.if_broadcastaddr, (caddr_t)eh->ether_dhost,
sizeof( eh->ether_dhost ));
eh->ether_type = htons( ETHERTYPE_AARP );
sizeof(eh->ether_dhost));
eh->ether_type = htons(ETHERTYPE_AARP);
ea->aarp_spa = AA_SAT( aa )->sat_addr.s_node;
ea->aarp_spa = AA_SAT(aa)->sat_addr.s_node;
ea->aarp_tpa = sat->sat_addr.s_node;
}
#ifdef NETATALKDEBUG
printf("aarp: sending request for %u.%u\n",
ntohs(AA_SAT( aa )->sat_addr.s_net),
AA_SAT( aa )->sat_addr.s_node);
ntohs(AA_SAT(aa)->sat_addr.s_net),
AA_SAT(aa)->sat_addr.s_node);
#endif /* NETATALKDEBUG */
sa.sa_len = sizeof( struct sockaddr );
sa.sa_len = sizeof(struct sockaddr);
sa.sa_family = AF_UNSPEC;
(*ac->ac_if.if_output)(&ac->ac_if,
m, &sa, NULL); /* XXX NULL should be routing information */
}
int
aarpresolve( ac, m, destsat, desten )
aarpresolve(ac, m, destsat, desten)
struct arpcom *ac;
struct mbuf *m;
struct sockaddr_at *destsat;
@ -216,79 +216,79 @@ aarpresolve( ac, m, destsat, desten )
struct aarptab *aat;
int s;
if ( at_broadcast( destsat )) {
if (at_broadcast(destsat)) {
m->m_flags |= M_BCAST;
if ((aa = at_ifawithnet( destsat )) == NULL) {
m_freem( m );
return( 0 );
if ((aa = at_ifawithnet(destsat)) == NULL) {
m_freem(m);
return (0);
}
if ( aa->aa_flags & AFA_PHASE2 ) {
if (aa->aa_flags & AFA_PHASE2) {
bcopy(atmulticastaddr, (caddr_t)desten, sizeof(atmulticastaddr));
} else {
bcopy( ac->ac_if.if_broadcastaddr, (caddr_t)desten,
sizeof( ac->ac_if.if_addrlen ));
bcopy(ac->ac_if.if_broadcastaddr, (caddr_t)desten,
sizeof(ac->ac_if.if_addrlen));
}
return( 1 );
return (1);
}
s = splimp();
AARPTAB_LOOK( aat, destsat->sat_addr );
if ( aat == 0 ) { /* No entry */
aat = aarptnew( &destsat->sat_addr );
if ( aat == 0 ) {
panic( "aarpresolve: no free entry" );
AARPTAB_LOOK(aat, destsat->sat_addr);
if (aat == 0) { /* No entry */
aat = aarptnew(&destsat->sat_addr);
if (aat == 0) {
panic("aarpresolve: no free entry");
}
aat->aat_hold = m;
aarpwhohas( ac, destsat );
splx( s );
return( 0 );
aarpwhohas(ac, destsat);
splx(s);
return (0);
}
/* found an entry */
aat->aat_timer = 0;
if ( aat->aat_flags & ATF_COM ) { /* entry is COMplete */
bcopy( (caddr_t)aat->aat_enaddr, (caddr_t)desten,
sizeof( aat->aat_enaddr ));
splx( s );
return( 1 );
if (aat->aat_flags & ATF_COM) { /* entry is COMplete */
bcopy((caddr_t)aat->aat_enaddr, (caddr_t)desten,
sizeof(aat->aat_enaddr));
splx(s);
return (1);
}
/* entry has not completed */
if ( aat->aat_hold ) {
m_freem( aat->aat_hold );
if (aat->aat_hold) {
m_freem(aat->aat_hold);
}
aat->aat_hold = m;
aarpwhohas( ac, destsat );
splx( s );
return( 0 );
aarpwhohas(ac, destsat);
splx(s);
return (0);
}
void
aarpintr( m )
aarpintr(m)
struct mbuf *m;
{
struct arphdr *ar;
struct arpcom *ac;
ac = (struct arpcom *)m->m_pkthdr.rcvif;
if ( ac->ac_if.if_flags & IFF_NOARP )
if (ac->ac_if.if_flags & IFF_NOARP)
goto out;
if ( m->m_len < sizeof( struct arphdr )) {
if (m->m_len < sizeof(struct arphdr)) {
goto out;
}
ar = mtod( m, struct arphdr *);
if ( ntohs( ar->ar_hrd ) != AARPHRD_ETHER ) {
ar = mtod(m, struct arphdr *);
if (ntohs(ar->ar_hrd) != AARPHRD_ETHER) {
goto out;
}
if ( m->m_len < sizeof( struct arphdr ) + 2 * ar->ar_hln +
2 * ar->ar_pln ) {
if (m->m_len < sizeof(struct arphdr) + 2 * ar->ar_hln +
2 * ar->ar_pln) {
goto out;
}
switch( ntohs( ar->ar_pro )) {
switch(ntohs(ar->ar_pro)) {
case ETHERTYPE_AT :
at_aarpinput( ac, m );
at_aarpinput(ac, m);
return;
default:
@ -296,11 +296,11 @@ aarpintr( m )
}
out:
m_freem( m );
m_freem(m);
}
static void
at_aarpinput( struct arpcom *ac, struct mbuf *m)
at_aarpinput(struct arpcom *ac, struct mbuf *m)
{
struct ether_aarp *ea;
struct at_ifaddr *aa;
@ -315,28 +315,28 @@ at_aarpinput( struct arpcom *ac, struct mbuf *m)
GIANT_REQUIRED;
ea = mtod( m, struct ether_aarp *);
ea = mtod(m, struct ether_aarp *);
/* Check to see if from my hardware address */
if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )ac->ac_enaddr,
sizeof( ac->ac_enaddr ))) {
m_freem( m );
if (!bcmp((caddr_t)ea->aarp_sha, (caddr_t)ac->ac_enaddr,
sizeof(ac->ac_enaddr))) {
m_freem(m);
return;
}
op = ntohs( ea->aarp_op );
bcopy( ea->aarp_tpnet, &net, sizeof( net ));
op = ntohs(ea->aarp_op);
bcopy(ea->aarp_tpnet, &net, sizeof(net));
if ( net != 0 ) { /* should be ATADDR_ANYNET? */
if (net != 0) { /* should be ATADDR_ANYNET? */
sat.sat_len = sizeof(struct sockaddr_at);
sat.sat_family = AF_APPLETALK;
sat.sat_addr.s_net = net;
if ((aa = at_ifawithnet( &sat )) == NULL) {
m_freem( m );
if ((aa = at_ifawithnet(&sat)) == NULL) {
m_freem(m);
return;
}
bcopy( ea->aarp_spnet, &spa.s_net, sizeof( spa.s_net ));
bcopy( ea->aarp_tpnet, &tpa.s_net, sizeof( tpa.s_net ));
bcopy(ea->aarp_spnet, &spa.s_net, sizeof(spa.s_net));
bcopy(ea->aarp_tpnet, &tpa.s_net, sizeof(tpa.s_net));
} else {
/*
* Since we don't know the net, we just look for the first
@ -344,141 +344,141 @@ at_aarpinput( struct arpcom *ac, struct mbuf *m)
*/
for (aa = (struct at_ifaddr *)TAILQ_FIRST(&ac->ac_if.if_addrhead); aa;
aa = (struct at_ifaddr *)aa->aa_ifa.ifa_link.tqe_next) {
if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
if (AA_SAT(aa)->sat_family == AF_APPLETALK &&
(aa->aa_flags & AFA_PHASE2) == 0) {
break;
}
}
if ( aa == NULL ) {
m_freem( m );
if (aa == NULL) {
m_freem(m);
return;
}
tpa.s_net = spa.s_net = AA_SAT( aa )->sat_addr.s_net;
tpa.s_net = spa.s_net = AA_SAT(aa)->sat_addr.s_net;
}
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;
ma.s_net = AA_SAT(aa)->sat_addr.s_net;
ma.s_node = AA_SAT(aa)->sat_addr.s_node;
/*
* This looks like it's from us.
*/
if ( spa.s_net == ma.s_net && spa.s_node == ma.s_node ) {
if ( aa->aa_flags & AFA_PROBING ) {
if (spa.s_net == ma.s_net && spa.s_node == ma.s_node) {
if (aa->aa_flags & AFA_PROBING) {
/*
* We're probing, someone either responded to our probe, or
* probed for the same address we'd like to use. Change the
* address we're probing for.
*/
untimeout( aarpprobe, ac, aa->aa_ch );
wakeup( aa );
m_freem( m );
untimeout(aarpprobe, ac, aa->aa_ch);
wakeup(aa);
m_freem(m);
return;
} else if ( op != AARPOP_PROBE ) {
} else if (op != AARPOP_PROBE) {
/*
* This is not a probe, and we're not probing. This means
* that someone's saying they have the same source address
* as the one we're using. Get upset...
*/
log( LOG_ERR,
log(LOG_ERR,
"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 );
m_freem(m);
return;
}
}
AARPTAB_LOOK( aat, spa );
if ( aat ) {
if ( op == AARPOP_PROBE ) {
AARPTAB_LOOK(aat, spa);
if (aat) {
if (op == AARPOP_PROBE) {
/*
* Someone's probing for spa, dealocate the one we've got,
* so that if the prober keeps the address, we'll be able
* to arp for him.
*/
aarptfree( aat );
m_freem( m );
aarptfree(aat);
m_freem(m);
return;
}
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
sizeof( ea->aarp_sha ));
bcopy((caddr_t)ea->aarp_sha, (caddr_t)aat->aat_enaddr,
sizeof(ea->aarp_sha));
aat->aat_flags |= ATF_COM;
if ( aat->aat_hold ) {
if (aat->aat_hold) {
struct mbuf *mhold = aat->aat_hold;
aat->aat_hold = NULL;
sat.sat_len = sizeof(struct sockaddr_at);
sat.sat_family = AF_APPLETALK;
sat.sat_addr = spa;
(*ac->ac_if.if_output)( &ac->ac_if, mhold,
(*ac->ac_if.if_output)(&ac->ac_if, mhold,
(struct sockaddr *)&sat, NULL); /* XXX */
}
} else if ((tpa.s_net == ma.s_net)
&& (tpa.s_node == ma.s_node)
&& (op != AARPOP_PROBE)
&& ((aat = aarptnew( &spa )) != NULL)) {
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
sizeof( ea->aarp_sha ));
aat->aat_flags |= ATF_COM;
&& ((aat = aarptnew(&spa)) != NULL)) {
bcopy((caddr_t)ea->aarp_sha, (caddr_t)aat->aat_enaddr,
sizeof(ea->aarp_sha));
aat->aat_flags |= ATF_COM;
}
/*
* Don't respond to responses, and never respond if we're
* still probing.
*/
if ( tpa.s_net != ma.s_net || tpa.s_node != ma.s_node ||
op == AARPOP_RESPONSE || ( aa->aa_flags & AFA_PROBING )) {
m_freem( m );
if (tpa.s_net != ma.s_net || tpa.s_node != ma.s_node ||
op == AARPOP_RESPONSE || (aa->aa_flags & AFA_PROBING)) {
m_freem(m);
return;
}
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )ea->aarp_tha,
sizeof( ea->aarp_sha ));
bcopy(( caddr_t )ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
sizeof( ea->aarp_sha ));
bcopy((caddr_t)ea->aarp_sha, (caddr_t)ea->aarp_tha,
sizeof(ea->aarp_sha));
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
sizeof(ea->aarp_sha));
/* XXX */
eh = (struct ether_header *)sa.sa_data;
bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )eh->ether_dhost,
sizeof( eh->ether_dhost ));
bcopy((caddr_t)ea->aarp_tha, (caddr_t)eh->ether_dhost,
sizeof(eh->ether_dhost));
if ( aa->aa_flags & AFA_PHASE2 ) {
eh->ether_type = htons( sizeof( struct llc ) +
sizeof( struct ether_aarp ));
M_PREPEND( m, sizeof( struct llc ), M_DONTWAIT );
if ( m == NULL ) {
if (aa->aa_flags & AFA_PHASE2) {
eh->ether_type = htons(sizeof(struct llc) +
sizeof(struct ether_aarp));
M_PREPEND(m, sizeof(struct llc), M_DONTWAIT);
if (m == NULL) {
return;
}
llc = mtod( m, struct llc *);
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(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 ));
bcopy(ea->aarp_spnet, ea->aarp_tpnet, sizeof(ea->aarp_tpnet));
bcopy(&ma.s_net, ea->aarp_spnet, sizeof(ea->aarp_spnet));
} else {
eh->ether_type = htons( ETHERTYPE_AARP );
eh->ether_type = htons(ETHERTYPE_AARP);
}
ea->aarp_tpnode = ea->aarp_spnode;
ea->aarp_spnode = ma.s_node;
ea->aarp_op = htons( AARPOP_RESPONSE );
ea->aarp_op = htons(AARPOP_RESPONSE);
sa.sa_len = sizeof( struct sockaddr );
sa.sa_len = sizeof(struct sockaddr);
sa.sa_family = AF_UNSPEC;
(*ac->ac_if.if_output)( &ac->ac_if, m, &sa, NULL); /* XXX */
(*ac->ac_if.if_output)(&ac->ac_if, m, &sa, NULL); /* XXX */
return;
}
static void
aarptfree( struct aarptab *aat)
aarptfree(struct aarptab *aat)
{
if ( aat->aat_hold )
m_freem( aat->aat_hold );
if (aat->aat_hold)
m_freem(aat->aat_hold);
aat->aat_hold = NULL;
aat->aat_timer = aat->aat_flags = 0;
aat->aat_ataddr.s_net = 0;
@ -486,7 +486,7 @@ aarptfree( struct aarptab *aat)
}
struct aarptab *
aarptnew( addr )
aarptnew(addr)
struct at_addr *addr;
{
int n;
@ -494,34 +494,34 @@ aarptnew( addr )
struct aarptab *aat, *aato = NULL;
static int first = 1;
if ( first ) {
if (first) {
first = 0;
aarptimer_ch = timeout( aarptimer, (caddr_t)0, hz );
aarptimer_ch = timeout(aarptimer, (caddr_t)0, hz);
}
aat = &aarptab[ AARPTAB_HASH( *addr ) * AARPTAB_BSIZ ];
for ( n = 0; n < AARPTAB_BSIZ; n++, aat++ ) {
if ( aat->aat_flags == 0 )
aat = &aarptab[ AARPTAB_HASH(*addr) * AARPTAB_BSIZ ];
for (n = 0; n < AARPTAB_BSIZ; n++, aat++) {
if (aat->aat_flags == 0)
goto out;
if ( aat->aat_flags & ATF_PERM )
if (aat->aat_flags & ATF_PERM)
continue;
if ((int) aat->aat_timer > oldest ) {
if ((int) aat->aat_timer > oldest) {
oldest = aat->aat_timer;
aato = aat;
}
}
if ( aato == NULL )
return( NULL );
if (aato == NULL)
return (NULL);
aat = aato;
aarptfree( aat );
aarptfree(aat);
out:
aat->aat_ataddr = *addr;
aat->aat_flags = ATF_INUSE;
return( aat );
return (aat);
}
void
aarpprobe( void *arg )
aarpprobe(void *arg)
{
struct arpcom *ac = arg;
struct mbuf *m;
@ -540,80 +540,80 @@ aarpprobe( void *arg )
*/
for (aa = (struct at_ifaddr *)TAILQ_FIRST(&ac->ac_if.if_addrhead); aa;
aa = (struct at_ifaddr *)aa->aa_ifa.ifa_link.tqe_next) {
if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
( aa->aa_flags & AFA_PROBING )) {
if (AA_SAT(aa)->sat_family == AF_APPLETALK &&
(aa->aa_flags & AFA_PROBING)) {
break;
}
}
if ( aa == NULL ) { /* serious error XXX */
printf( "aarpprobe why did this happen?!\n" );
if (aa == NULL) { /* serious error XXX */
printf("aarpprobe why did this happen?!\n");
return;
}
if ( aa->aa_probcnt <= 0 ) {
if (aa->aa_probcnt <= 0) {
aa->aa_flags &= ~AFA_PROBING;
wakeup( aa );
wakeup(aa);
return;
} else {
aa->aa_ch = timeout( aarpprobe, (caddr_t)ac, hz / 5 );
aa->aa_ch = timeout(aarpprobe, (caddr_t)ac, hz / 5);
}
if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL) {
return;
}
#ifdef MAC
mac_create_mbuf_linklayer(&ac->ac_if, m);
#endif
m->m_len = sizeof( *ea );
m->m_pkthdr.len = sizeof( *ea );
MH_ALIGN( m, sizeof( *ea ));
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 = 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 );
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,
sizeof( ea->aarp_sha ));
sizeof(ea->aarp_sha));
eh = (struct ether_header *)sa.sa_data;
if ( aa->aa_flags & AFA_PHASE2 ) {
bcopy(atmulticastaddr, eh->ether_dhost, sizeof( eh->ether_dhost ));
eh->ether_type = htons( sizeof( struct llc ) +
sizeof( struct ether_aarp ));
M_PREPEND( m, sizeof( struct llc ), M_TRYWAIT );
if ( m == NULL ) {
if (aa->aa_flags & AFA_PHASE2) {
bcopy(atmulticastaddr, eh->ether_dhost, sizeof(eh->ether_dhost));
eh->ether_type = htons(sizeof(struct llc) +
sizeof(struct ether_aarp));
M_PREPEND(m, sizeof(struct llc), M_TRYWAIT);
if (m == NULL) {
return;
}
llc = mtod( m, struct llc *);
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(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,
sizeof( ea->aarp_spnet ));
bcopy( &AA_SAT( aa )->sat_addr.s_net, ea->aarp_tpnet,
sizeof( ea->aarp_tpnet ));
ea->aarp_spnode = ea->aarp_tpnode = AA_SAT( aa )->sat_addr.s_node;
bcopy(&AA_SAT(aa)->sat_addr.s_net, ea->aarp_spnet,
sizeof(ea->aarp_spnet));
bcopy(&AA_SAT(aa)->sat_addr.s_net, ea->aarp_tpnet,
sizeof(ea->aarp_tpnet));
ea->aarp_spnode = ea->aarp_tpnode = AA_SAT(aa)->sat_addr.s_node;
} else {
bcopy(ac->ac_if.if_broadcastaddr, (caddr_t)eh->ether_dhost,
sizeof( eh->ether_dhost ));
eh->ether_type = htons( ETHERTYPE_AARP );
ea->aarp_spa = ea->aarp_tpa = AA_SAT( aa )->sat_addr.s_node;
sizeof(eh->ether_dhost));
eh->ether_type = htons(ETHERTYPE_AARP);
ea->aarp_spa = ea->aarp_tpa = AA_SAT(aa)->sat_addr.s_node;
}
#ifdef NETATALKDEBUG
printf("aarp: sending probe for %u.%u\n",
ntohs(AA_SAT( aa )->sat_addr.s_net),
AA_SAT( aa )->sat_addr.s_node);
ntohs(AA_SAT(aa)->sat_addr.s_net),
AA_SAT(aa)->sat_addr.s_node);
#endif /* NETATALKDEBUG */
sa.sa_len = sizeof( struct sockaddr );
sa.sa_len = sizeof(struct sockaddr);
sa.sa_family = AF_UNSPEC;
(*ac->ac_if.if_output)(&ac->ac_if, m, &sa, NULL); /* XXX */
aa->aa_probcnt--;
@ -625,10 +625,10 @@ aarp_clean(void)
struct aarptab *aat;
int i;
untimeout( aarptimer, 0, aarptimer_ch );
for ( i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++ ) {
if ( aat->aat_hold ) {
m_freem( aat->aat_hold );
untimeout(aarptimer, 0, aarptimer_ch);
for (i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++) {
if (aat->aat_hold) {
m_freem(aat->aat_hold);
aat->aat_hold = NULL;
}
}

304
sys/netatalk/at_control.c
View file

@ -31,19 +31,19 @@ static int aa_delsingleroute(struct ifaddr *ifa,
struct at_addr *addr, struct at_addr *mask);
static int aa_dosingleroute(struct ifaddr *ifa, struct at_addr *addr,
struct at_addr *mask, int cmd, int flags);
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 );
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);
static int aa_claim_addr(struct ifaddr *ifa, struct sockaddr *gw);
# 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 )
(a)->sat_addr.s_node == (b)->sat_addr.s_node)
int
at_control(struct socket *so, u_long cmd, caddr_t data,
struct ifnet *ifp, struct thread *td )
struct ifnet *ifp, struct thread *td)
{
struct ifreq *ifr = (struct ifreq *)data;
struct sockaddr_at *sat;
@ -56,9 +56,9 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
/*
* If we have an ifp, then find the matching at_ifaddr if it exists
*/
if ( ifp ) {
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp ) break;
if (ifp) {
for (aa = at_ifaddr; aa; aa = aa->aa_next) {
if (aa->aa_ifp == ifp) break;
}
}
@ -68,7 +68,7 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* so that they start to look more similar to other protocols etc.
*/
switch ( cmd ) {
switch (cmd) {
case SIOCAIFADDR:
case SIOCDIFADDR:
/*
@ -78,10 +78,10 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* This may leave aa pointing to the first address on the
* NEXT interface!
*/
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 )) {
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;
}
}
@ -90,8 +90,8 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* If we a retrying to delete an addres but didn't find such,
* then rewurn with an error
*/
if ( cmd == SIOCDIFADDR && aa == NULL ) {
return( EADDRNOTAVAIL );
if (cmd == SIOCDIFADDR && aa == NULL) {
return (EADDRNOTAVAIL);
}
/*FALLTHROUGH*/
@ -99,21 +99,21 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
/*
* If we are not superuser, then we don't get to do these ops.
*/
if ( suser(td) ) {
return( EPERM );
if (suser(td)) {
return (EPERM);
}
sat = satosat( &ifr->ifr_addr );
sat = satosat(&ifr->ifr_addr);
nr = (struct netrange *)sat->sat_zero;
if ( nr->nr_phase == 1 ) {
if (nr->nr_phase == 1) {
/*
* Look for a phase 1 address on this interface.
* This may leave aa pointing to the first address on the
* NEXT interface!
*/
for ( ; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp &&
( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
for (; aa; aa = aa->aa_next) {
if (aa->aa_ifp == ifp &&
(aa->aa_flags & AFA_PHASE2) == 0) {
break;
}
}
@ -123,23 +123,23 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* This may leave aa pointing to the first address on the
* NEXT interface!
*/
for ( ; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
for (; aa; aa = aa->aa_next) {
if (aa->aa_ifp == ifp && (aa->aa_flags & AFA_PHASE2)) {
break;
}
}
}
if ( ifp == NULL )
panic( "at_control" );
if (ifp == NULL)
panic("at_control");
/*
* If we failed to find an existing at_ifaddr entry, then we
* allocate a fresh one.
*/
if ( aa == NULL ) {
if (aa == NULL) {
aa0 = malloc(sizeof(struct at_ifaddr), M_IFADDR, M_WAITOK | M_ZERO);
if (( aa = at_ifaddr ) != NULL ) {
if ((aa = at_ifaddr) != NULL) {
/*
* Don't let the loopback be first, since the first
* address is the machine's default address for
@ -147,12 +147,12 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* If it is, stick ourself in front, otherwise
* go to the back of the list.
*/
if ( at_ifaddr->aa_ifp->if_flags & IFF_LOOPBACK ) {
if (at_ifaddr->aa_ifp->if_flags & IFF_LOOPBACK) {
aa = aa0;
aa->aa_next = at_ifaddr;
at_ifaddr = aa;
} else {
for ( ; aa->aa_next; aa = aa->aa_next )
for (; aa->aa_next; aa = aa->aa_next)
;
aa->aa_next = aa0;
}
@ -181,7 +181,7 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
/*
* Set/clear the phase 2 bit.
*/
if ( nr->nr_phase == 1 ) {
if (nr->nr_phase == 1) {
aa->aa_flags &= ~AFA_PHASE2;
} else {
aa->aa_flags |= AFA_PHASE2;
@ -195,21 +195,21 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
/*
* If we DID find one then we clobber any routes dependent on it..
*/
at_scrub( ifp, aa );
at_scrub(ifp, aa);
}
break;
case SIOCGIFADDR :
sat = satosat( &ifr->ifr_addr );
sat = satosat(&ifr->ifr_addr);
nr = (struct netrange *)sat->sat_zero;
if ( nr->nr_phase == 1 ) {
if (nr->nr_phase == 1) {
/*
* If the request is specifying phase 1, then
* only look at a phase one address
*/
for ( ; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp &&
( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
for (; aa; aa = aa->aa_next) {
if (aa->aa_ifp == ifp &&
(aa->aa_flags & AFA_PHASE2) == 0) {
break;
}
}
@ -217,15 +217,15 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
/*
* default to phase 2
*/
for ( ; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
for (; aa; aa = aa->aa_next) {
if (aa->aa_ifp == ifp && (aa->aa_flags & AFA_PHASE2)) {
break;
}
}
}
if ( aa == NULL )
return( EADDRNOTAVAIL );
if (aa == NULL)
return (EADDRNOTAVAIL);
break;
}
@ -233,7 +233,7 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* By the time this switch is run we should be able to assume that
* the "aa" pointer is valid when needed.
*/
switch ( cmd ) {
switch (cmd) {
case SIOCGIFADDR:
/*
@ -252,19 +252,19 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
break;
case SIOCSIFADDR:
return( at_ifinit( ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr ));
return (at_ifinit(ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr));
case SIOCAIFADDR:
if ( sateqaddr( &ifra->ifra_addr, &aa->aa_addr )) {
return( 0 );
if (sateqaddr(&ifra->ifra_addr, &aa->aa_addr)) {
return (0);
}
return( at_ifinit( ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr ));
return (at_ifinit(ifp, aa, (struct sockaddr_at *)&ifr->ifr_addr));
case SIOCDIFADDR:
/*
* scrub all routes.. didn't we just DO this? XXX yes, del it
*/
at_scrub( ifp, aa );
at_scrub(ifp, aa);
/*
* remove the ifaddr from the interface
@ -277,20 +277,20 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* as well, or we'd be in deep trouble
*/
aa0 = aa;
if ( aa0 == ( aa = at_ifaddr )) {
if (aa0 == (aa = at_ifaddr)) {
at_ifaddr = aa->aa_next;
} else {
while ( aa->aa_next && ( aa->aa_next != aa0 )) {
while (aa->aa_next && (aa->aa_next != aa0)) {
aa = aa->aa_next;
}
/*
* if we found it, remove it, otherwise we screwed up.
*/
if ( aa->aa_next ) {
if (aa->aa_next) {
aa->aa_next = aa0->aa_next;
} else {
panic( "at_control" );
panic("at_control");
}
}
@ -301,11 +301,11 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
break;
default:
if ( ifp == NULL || ifp->if_ioctl == NULL )
return( EOPNOTSUPP );
return( (*ifp->if_ioctl)( ifp, cmd, data ));
if (ifp == NULL || ifp->if_ioctl == NULL)
return (EOPNOTSUPP);
return ((*ifp->if_ioctl)(ifp, cmd, data));
}
return( 0 );
return (0);
}
/*
@ -315,32 +315,32 @@ at_control(struct socket *so, u_long cmd, caddr_t data,
* as aa->at_ifaddr.ifa_ifp should be the same.
*/
static int
at_scrub( ifp, aa )
at_scrub(ifp, aa)
struct ifnet *ifp;
struct at_ifaddr *aa;
{
int error;
if ( aa->aa_flags & AFA_ROUTE ) {
if (aa->aa_flags & AFA_ROUTE) {
if (ifp->if_flags & IFF_LOOPBACK) {
if ((error = aa_delsingleroute(&aa->aa_ifa,
&aa->aa_addr.sat_addr,
&aa->aa_netmask.sat_addr)) != 0) {
return( error );
return (error);
}
} else if (ifp->if_flags & IFF_POINTOPOINT) {
if ((error = rtinit( &aa->aa_ifa, RTM_DELETE, RTF_HOST)) != 0)
return( error );
if ((error = rtinit(&aa->aa_ifa, RTM_DELETE, RTF_HOST)) != 0)
return (error);
} else if (ifp->if_flags & IFF_BROADCAST) {
error = aa_dorangeroute(&aa->aa_ifa,
ntohs(aa->aa_firstnet),
ntohs(aa->aa_lastnet),
RTM_DELETE );
RTM_DELETE);
}
aa->aa_ifa.ifa_flags &= ~IFA_ROUTE;
aa->aa_flags &= ~AFA_ROUTE;
}
return( 0 );
return (0);
}
/*
@ -348,7 +348,7 @@ at_scrub( ifp, aa )
* bang them all together at high speed and see what happens
*/
static int
at_ifinit( ifp, aa, sat )
at_ifinit(ifp, aa, sat)
struct ifnet *ifp;
struct at_ifaddr *aa;
struct sockaddr_at *sat;
@ -371,10 +371,10 @@ at_ifinit( ifp, aa, sat )
* at_ifnet (also given). Remember ing to update
* those parts of the at_ifaddr that need special processing
*/
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;
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;
aa->aa_firstnet = nr.nr_firstnet;
aa->aa_lastnet = nr.nr_lastnet;
@ -393,13 +393,13 @@ at_ifinit( ifp, aa, sat )
* 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 ) {
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;
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;
#if 0
} else if ( fp->if_flags & IFF_POINTOPOINT) {
} else if (fp->if_flags & IFF_POINTOPOINT) {
/* unimplemented */
/*
* we'd have to copy the dstaddr field over from the sat
@ -417,19 +417,19 @@ at_ifinit( ifp, aa, sat )
* we find an unused address.
*/
aa->aa_flags |= AFA_PROBING; /* if not loopback we Must probe? */
AA_SAT( aa )->sat_len = sizeof(struct sockaddr_at);
AA_SAT( aa )->sat_family = AF_APPLETALK;
if ( aa->aa_flags & AFA_PHASE2 ) {
if ( sat->sat_addr.s_net == ATADDR_ANYNET ) {
AA_SAT(aa)->sat_len = sizeof(struct sockaddr_at);
AA_SAT(aa)->sat_family = AF_APPLETALK;
if (aa->aa_flags & AFA_PHASE2) {
if (sat->sat_addr.s_net == ATADDR_ANYNET) {
/*
* If we are phase 2, and the net was not specified
* then we select a random net within the supplied netrange.
* XXX use /dev/random?
*/
if ( nnets != 1 ) {
net = ntohs( nr.nr_firstnet ) + time_second % ( nnets - 1 );
if (nnets != 1) {
net = ntohs(nr.nr_firstnet) + time_second % (nnets - 1);
} else {
net = ntohs( nr.nr_firstnet );
net = ntohs(nr.nr_firstnet);
}
} else {
/*
@ -437,25 +437,25 @@ at_ifinit( ifp, aa, sat )
* the netrange. If it is not then replace the old values
* and return an error
*/
if ( ntohs( sat->sat_addr.s_net ) < ntohs( nr.nr_firstnet ) ||
ntohs( sat->sat_addr.s_net ) > ntohs( nr.nr_lastnet )) {
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);
return( EINVAL );
return (EINVAL);
}
/*
* otherwise just use the new net number..
*/
net = ntohs( sat->sat_addr.s_net );
net = ntohs(sat->sat_addr.s_net);
}
} else {
/*
* we must be phase one, so just use whatever we were given.
* I guess it really isn't going to be used... RIGHT?
*/
net = ntohs( sat->sat_addr.s_net );
net = ntohs(sat->sat_addr.s_net);
}
/*
@ -463,25 +463,25 @@ at_ifinit( ifp, aa, sat )
* If it's not specified, be random about it...
* XXX use /dev/random?
*/
if ( sat->sat_addr.s_node == ATADDR_ANYNODE ) {
AA_SAT( aa )->sat_addr.s_node = time_second;
if (sat->sat_addr.s_node == ATADDR_ANYNODE) {
AA_SAT(aa)->sat_addr.s_node = time_second;
} else {
AA_SAT( aa )->sat_addr.s_node = sat->sat_addr.s_node;
AA_SAT(aa)->sat_addr.s_node = sat->sat_addr.s_node;
}
/*
* Copy the phase.
*/
AA_SAT( aa )->sat_range.r_netrange.nr_phase
AA_SAT(aa)->sat_range.r_netrange.nr_phase
= ((aa->aa_flags & AFA_PHASE2) ? 2:1);
/*
* step through the nets in the range
* starting at the (possibly random) start point.
*/
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 (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);
/*
* using a rather strange stepping method,
@ -489,10 +489,10 @@ at_ifinit( ifp, aa, sat )
* Once again, starting at the (possibly random)
* initial node address.
*/
for ( j = 0, nodeinc = time_second | 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 ) {
for (j = 0, nodeinc = time_second | 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;
@ -501,18 +501,18 @@ at_ifinit( ifp, aa, sat )
* start off the probes as an asynchronous activity.
* though why wait 200mSec?
*/
aa->aa_ch = timeout( aarpprobe, (caddr_t)ifp, hz / 5 );
if ( tsleep( aa, PPAUSE|PCATCH, "at_ifinit", 0 )) {
aa->aa_ch = timeout(aarpprobe, (caddr_t)ifp, hz / 5);
if (tsleep(aa, PPAUSE|PCATCH, "at_ifinit", 0)) {
/*
* theoretically we shouldn't time out here
* so if we returned with an error..
*/
printf( "at_ifinit: why did this happen?!\n" );
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 );
return( EINTR );
splx(s);
return (EINTR);
}
/*
@ -521,7 +521,7 @@ at_ifinit( ifp, aa, sat )
* a free spot, or if we need to iterate to the next
* address to try.
*/
if (( aa->aa_flags & AFA_PROBING ) == 0 ) {
if ((aa->aa_flags & AFA_PROBING) == 0) {
break;
}
}
@ -529,11 +529,11 @@ at_ifinit( ifp, aa, sat )
/*
* of course we need to break out through two loops...
*/
if (( aa->aa_flags & AFA_PROBING ) == 0 ) {
if ((aa->aa_flags & AFA_PROBING) == 0) {
break;
}
/* reset node for next network */
AA_SAT( aa )->sat_addr.s_node = time_second;
AA_SAT(aa)->sat_addr.s_node = time_second;
}
/*
@ -541,12 +541,12 @@ at_ifinit( ifp, aa, sat )
* the possible addresses, so we need to give up
*/
if ( aa->aa_flags & AFA_PROBING ) {
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 );
splx(s);
return (EADDRINUSE);
}
}
@ -554,8 +554,8 @@ at_ifinit( ifp, aa, sat )
* Now that we have selected an address, we need to tell the interface
* about it, just in case it needs to adjust something.
*/
if ( ifp->if_ioctl &&
( error = (*ifp->if_ioctl)( ifp, SIOCSIFADDR, (caddr_t)aa ))) {
if (ifp->if_ioctl &&
(error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)aa))) {
/*
* of course this could mean that it objects violently
* so if it does, we back out again..
@ -563,8 +563,8 @@ at_ifinit( ifp, aa, sat )
aa->aa_addr = oldaddr;
aa->aa_firstnet = onr.nr_firstnet;
aa->aa_lastnet = onr.nr_lastnet;
splx( s );
return( error );
splx(s);
return (error);
}
/*
@ -590,10 +590,10 @@ at_ifinit( ifp, aa, sat )
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;
aa->aa_ifa.ifa_broadaddr = (struct sockaddr *) &aa->aa_broadaddr;
/* add the range of routes needed */
error = aa_dorangeroute(&aa->aa_ifa,
ntohs(aa->aa_firstnet), ntohs(aa->aa_lastnet), RTM_ADD );
ntohs(aa->aa_firstnet), ntohs(aa->aa_lastnet), RTM_ADD);
}
else if (ifp->if_flags & IFF_POINTOPOINT) {
struct at_addr rtaddr, rtmask;
@ -601,16 +601,16 @@ at_ifinit( ifp, aa, sat )
bzero(&rtaddr, sizeof(rtaddr));
bzero(&rtmask, sizeof(rtmask));
/* fill in the far end if we know it here XXX */
aa->aa_ifa.ifa_dstaddr = (struct sockaddr *) &aa->aa_dstaddr;
aa->aa_ifa.ifa_dstaddr = (struct sockaddr *) &aa->aa_dstaddr;
error = aa_addsingleroute(&aa->aa_ifa, &rtaddr, &rtmask);
}
else if ( ifp->if_flags & IFF_LOOPBACK ) {
else if (ifp->if_flags & IFF_LOOPBACK) {
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;
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);
@ -626,13 +626,13 @@ at_ifinit( ifp, aa, sat )
* of course if we can't add these routes we back out, but it's getting
* risky by now XXX
*/
if ( error ) {
at_scrub( ifp, aa );
if (error) {
at_scrub(ifp, aa);
aa->aa_addr = oldaddr;
aa->aa_firstnet = onr.nr_firstnet;
aa->aa_lastnet = onr.nr_lastnet;
splx( s );
return( error );
splx(s);
return (error);
}
/*
@ -640,15 +640,15 @@ at_ifinit( ifp, aa, sat )
*/
aa->aa_ifa.ifa_flags |= IFA_ROUTE;
aa->aa_flags |= AFA_ROUTE;
splx( s );
return( 0 );
splx(s);
return (0);
}
/*
* check whether a given address is a broadcast address for us..
*/
int
at_broadcast( sat )
at_broadcast(sat)
struct sockaddr_at *sat;
{
struct at_ifaddr *aa;
@ -656,28 +656,28 @@ at_broadcast( sat )
/*
* If the node is not right, it can't be a broadcast
*/
if ( sat->sat_addr.s_node != ATADDR_BCAST ) {
return( 0 );
if (sat->sat_addr.s_node != ATADDR_BCAST) {
return (0);
}
/*
* If the node was right then if the net is right, it's a broadcast
*/
if ( sat->sat_addr.s_net == ATADDR_ANYNET ) {
return( 1 );
if (sat->sat_addr.s_net == ATADDR_ANYNET) {
return (1);
}
/*
* failing that, if the net is one we have, it's a broadcast as well.
*/
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 );
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 );
return (0);
}
/*
@ -717,8 +717,8 @@ aa_dorangeroute(struct ifaddr *ifa, u_int bot, u_int top, int cmd)
while (bot <= top) {
mask1 = 1;
while ((( bot & ~mask1) >= bot)
&& (( bot | mask1) <= top)) {
while (((bot & ~mask1) >= bot)
&& ((bot | mask1) <= top)) {
mask1 <<= 1;
mask1 |= 1;
}
@ -736,7 +736,7 @@ aa_dorangeroute(struct ifaddr *ifa, u_int bot, u_int top, int cmd)
}
bot = (bot | mask1) + 1;
}
return 0;
return (0);
}
static int
@ -754,7 +754,7 @@ aa_addsingleroute(struct ifaddr *ifa,
error = aa_dosingleroute(ifa, addr, mask, RTM_ADD, RTF_UP);
if (error)
printf("aa_addsingleroute: error %d\n", error);
return(error);
return (error);
}
static int
@ -766,7 +766,7 @@ aa_delsingleroute(struct ifaddr *ifa,
error = aa_dosingleroute(ifa, addr, mask, RTM_DELETE, 0);
if (error)
printf("aa_delsingleroute: error %d\n", error);
return(error);
return (error);
}
static int
@ -787,7 +787,7 @@ aa_dosingleroute(struct ifaddr *ifa,
mask.sat_addr.s_node = at_mask->s_node;
if (at_mask->s_node)
flags |= RTF_HOST;
return(rtrequest(cmd, (struct sockaddr *) &addr,
return (rtrequest(cmd, (struct sockaddr *) &addr,
(flags & RTF_HOST)?(ifa->ifa_dstaddr):(ifa->ifa_addr),
(struct sockaddr *) &mask, flags, NULL));
}
@ -801,21 +801,21 @@ aa_clean(void)
struct ifaddr *ifa;
struct ifnet *ifp;
while ( aa = at_ifaddr ) {
while (aa = at_ifaddr) {
ifp = aa->aa_ifp;
at_scrub( ifp, aa );
at_scrub(ifp, aa);
at_ifaddr = aa->aa_next;
if (( ifa = ifp->if_addrlist ) == (struct ifaddr *)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 )) {
while (ifa->ifa_next &&
(ifa->ifa_next != (struct ifaddr *)aa)) {
ifa = ifa->ifa_next;
}
if ( ifa->ifa_next ) {
if (ifa->ifa_next) {
ifa->ifa_next = ((struct ifaddr *)aa)->ifa_next;
} else {
panic( "at_entry" );
panic("at_entry");
}
}
}
@ -832,7 +832,7 @@ aa_claim_addr(struct ifaddr *ifa, struct sockaddr *gw0)
switch (gw->sat_range.r_netrange.nr_phase) {
case 1:
if(addr->sat_range.r_netrange.nr_phase == 1)
return 1;
return (1);
case 0:
case 2:
/*
@ -843,14 +843,14 @@ aa_claim_addr(struct ifaddr *ifa, struct sockaddr *gw0)
if ((addr->sat_addr.s_net == gw->sat_addr.s_net)
|| ((addr->sat_range.r_netrange.nr_lastnet)
&& (ntohs(gw->sat_addr.s_net)
>= ntohs(addr->sat_range.r_netrange.nr_firstnet ))
>= ntohs(addr->sat_range.r_netrange.nr_firstnet))
&& (ntohs(gw->sat_addr.s_net)
<= ntohs(addr->sat_range.r_netrange.nr_lastnet )))) {
return 1;
<= ntohs(addr->sat_range.r_netrange.nr_lastnet)))) {
return (1);
}
break;
default:
printf("atalk: bad phase\n");
}
return 0;
return (0);
}

98
sys/netatalk/ddp_output.c
View file

@ -46,20 +46,20 @@
int ddp_cksum = 1;
int
ddp_output( struct mbuf *m, struct socket *so)
ddp_output(struct mbuf *m, struct socket *so)
{
struct ddpehdr *deh;
struct ddpcb *ddp = sotoddpcb( so );
struct ddpcb *ddp = sotoddpcb(so);
#ifdef MAC
mac_create_mbuf_from_socket(so, m);
#endif
M_PREPEND( m, sizeof( struct ddpehdr ), M_TRYWAIT );
if ( m == NULL )
return( ENOBUFS );
M_PREPEND(m, sizeof(struct ddpehdr), M_TRYWAIT);
if (m == NULL)
return (ENOBUFS);
deh = mtod( m, struct ddpehdr *);
deh = mtod(m, struct ddpehdr *);
deh->deh_pad = 0;
deh->deh_hops = 0;
@ -76,50 +76,50 @@ ddp_output( struct mbuf *m, struct socket *so)
* The checksum calculation is done after all of the other bytes have
* been filled in.
*/
if ( ddp_cksum ) {
deh->deh_sum = at_cksum( m, sizeof( int ));
if (ddp_cksum) {
deh->deh_sum = at_cksum(m, sizeof(int));
} else {
deh->deh_sum = 0;
}
deh->deh_bytes = htonl( deh->deh_bytes );
deh->deh_bytes = htonl(deh->deh_bytes);
#ifdef NETATALK_DEBUG
printf ("ddp_output: from %d.%d:%d to %d.%d:%d\n",
ntohs(deh->deh_snet), deh->deh_snode, deh->deh_sport,
ntohs(deh->deh_dnet), deh->deh_dnode, deh->deh_dport);
#endif
return( ddp_route( m, &ddp->ddp_route ));
return (ddp_route(m, &ddp->ddp_route));
}
u_short
at_cksum( struct mbuf *m, int skip)
at_cksum(struct mbuf *m, int skip)
{
u_char *data, *end;
u_long cksum = 0;
for (; m; m = m->m_next ) {
for ( data = mtod( m, u_char * ), end = data + m->m_len; data < end;
data++ ) {
if ( skip ) {
for (; m; m = m->m_next) {
for (data = mtod(m, u_char *), end = data + m->m_len; data < end;
data++) {
if (skip) {
skip--;
continue;
}
cksum = ( cksum + *data ) << 1;
if ( cksum & 0x00010000 ) {
cksum = (cksum + *data) << 1;
if (cksum & 0x00010000) {
cksum++;
}
cksum &= 0x0000ffff;
}
}
if ( cksum == 0 ) {
if (cksum == 0) {
cksum = 0x0000ffff;
}
return( (u_short)cksum );
return ((u_short)cksum);
}
int
ddp_route( struct mbuf *m, struct route *ro)
ddp_route(struct mbuf *m, struct route *ro)
{
struct sockaddr_at gate;
struct elaphdr *elh;
@ -140,24 +140,24 @@ ddp_route( struct mbuf *m, struct route *ro)
* if we have a route, find the ifa that refers to this route.
* I.e The ifa used to get to the gateway.
*/
if ( (ro->ro_rt == NULL)
|| ( ro->ro_rt->rt_ifa == NULL )
|| ( (ifp = ro->ro_rt->rt_ifa->ifa_ifp) == NULL )) {
if ((ro->ro_rt == NULL)
|| (ro->ro_rt->rt_ifa == NULL)
|| ((ifp = ro->ro_rt->rt_ifa->ifa_ifp) == NULL)) {
rtalloc(ro);
}
if ( (ro->ro_rt != NULL)
&& ( ro->ro_rt->rt_ifa )
&& ( ifp = ro->ro_rt->rt_ifa->ifa_ifp )) {
if ((ro->ro_rt != NULL)
&& (ro->ro_rt->rt_ifa)
&& (ifp = ro->ro_rt->rt_ifa->ifa_ifp)) {
net = ntohs(satosat(ro->ro_rt->rt_gateway)->sat_addr.s_net);
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
for (aa = at_ifaddr; aa; aa = aa->aa_next) {
if (((net == 0) || (aa->aa_ifp == ifp)) &&
net >= ntohs( aa->aa_firstnet ) &&
net <= ntohs( aa->aa_lastnet )) {
net >= ntohs(aa->aa_firstnet) &&
net <= ntohs(aa->aa_lastnet)) {
break;
}
}
} else {
m_freem( m );
m_freem(m);
#ifdef NETATALK_DEBUG
if (ro->ro_rt == NULL)
printf ("ddp_route: no ro_rt.\n");
@ -166,29 +166,29 @@ ddp_route( struct mbuf *m, struct route *ro)
else
printf ("ddp_route: no ro_rt->rt_ifa->ifa_ifp\n");
#endif
return( ENETUNREACH );
return (ENETUNREACH);
}
if ( aa == NULL ) {
if (aa == NULL) {
#ifdef NETATALK_DEBUG
printf( "ddp_route: no atalk address found for %s\n",
printf("ddp_route: no atalk address found for %s\n",
ifp->if_xname);
#endif
m_freem( m );
return( ENETUNREACH );
m_freem(m);
return (ENETUNREACH);
}
/*
* if the destination address is on a directly attached node use that,
* else use the official gateway.
*/
if ( ntohs( satosat( &ro->ro_dst )->sat_addr.s_net ) >=
ntohs( aa->aa_firstnet ) &&
ntohs( satosat( &ro->ro_dst )->sat_addr.s_net ) <=
ntohs( aa->aa_lastnet )) {
gate = *satosat( &ro->ro_dst );
if (ntohs(satosat(&ro->ro_dst)->sat_addr.s_net) >=
ntohs(aa->aa_firstnet) &&
ntohs(satosat(&ro->ro_dst)->sat_addr.s_net) <=
ntohs(aa->aa_lastnet)) {
gate = *satosat(&ro->ro_dst);
} else {
gate = *satosat( ro->ro_rt->rt_gateway );
gate = *satosat(ro->ro_rt->rt_gateway);
}
/*
@ -197,12 +197,12 @@ ddp_route( struct mbuf *m, struct route *ro)
* This is bad for transition routing, since phase 1 and phase 2
* packets end up poorly aligned due to the three byte elap header.
*/
if ( !(aa->aa_flags & AFA_PHASE2) ) {
MGET( m0, M_TRYWAIT, MT_HEADER );
if ( m0 == NULL ) {
m_freem( m );
if (!(aa->aa_flags & AFA_PHASE2)) {
MGET(m0, M_TRYWAIT, MT_HEADER);
if (m0 == NULL) {
m_freem(m);
printf("ddp_route: no buffers\n");
return( ENOBUFS );
return (ENOBUFS);
}
#ifdef MAC
mac_create_mbuf_from_mbuf(m, m0);
@ -212,8 +212,8 @@ ddp_route( struct mbuf *m, struct route *ro)
m0->m_len = SZ_ELAPHDR;
m = m0;
elh = mtod( m, struct elaphdr *);
elh->el_snode = satosat( &aa->aa_addr )->sat_addr.s_node;
elh = mtod(m, struct elaphdr *);
elh->el_snode = satosat(&aa->aa_addr)->sat_addr.s_node;
elh->el_type = ELAP_DDPEXTEND;
elh->el_dnode = gate.sat_addr.s_node;
}
@ -237,6 +237,6 @@ ddp_route( struct mbuf *m, struct route *ro)
return (if_simloop(ifp, m, gate.sat_family, 0));
}
return((*ifp->if_output)( ifp,
return ((*ifp->if_output)(ifp,
m, (struct sockaddr *)&gate, NULL)); /* XXX */
}

192
sys/netatalk/ddp_pcb.c
View file

@ -38,41 +38,41 @@ at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
struct at_ifaddr *aa;
struct ddpcb *ddpp;
if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
return( EINVAL );
if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT) { /* shouldn't be bound */
return (EINVAL);
}
if (addr != NULL) { /* validate passed address */
sat = (struct sockaddr_at *)addr;
if (sat->sat_family != AF_APPLETALK) {
return(EAFNOSUPPORT);
return (EAFNOSUPPORT);
}
if ( sat->sat_addr.s_node != ATADDR_ANYNODE ||
sat->sat_addr.s_net != ATADDR_ANYNET ) {
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if (( sat->sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) &&
( sat->sat_addr.s_node == AA_SAT( aa )->sat_addr.s_node )) {
if (sat->sat_addr.s_node != ATADDR_ANYNODE ||
sat->sat_addr.s_net != ATADDR_ANYNET) {
for (aa = at_ifaddr; aa; aa = aa->aa_next) {
if ((sat->sat_addr.s_net == AA_SAT(aa)->sat_addr.s_net) &&
(sat->sat_addr.s_node == AA_SAT(aa)->sat_addr.s_node)) {
break;
}
}
if ( !aa ) {
return( EADDRNOTAVAIL );
if (!aa) {
return (EADDRNOTAVAIL);
}
}
if ( sat->sat_port != ATADDR_ANYPORT ) {
if ( sat->sat_port < ATPORT_FIRST ||
sat->sat_port >= ATPORT_LAST ) {
return( EINVAL );
if (sat->sat_port != ATADDR_ANYPORT) {
if (sat->sat_port < ATPORT_FIRST ||
sat->sat_port >= ATPORT_LAST) {
return (EINVAL);
}
if ( sat->sat_port < ATPORT_RESERVED &&
suser(td) ) {
return( EACCES );
if (sat->sat_port < ATPORT_RESERVED &&
suser(td)) {
return (EACCES);
}
}
} else {
bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
bzero((caddr_t)&lsat, sizeof(struct sockaddr_at));
lsat.sat_len = sizeof(struct sockaddr_at);
lsat.sat_addr.s_node = ATADDR_ANYNODE;
lsat.sat_addr.s_net = ATADDR_ANYNET;
@ -80,49 +80,49 @@ at_pcbsetaddr(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
sat = &lsat;
}
if ( sat->sat_addr.s_node == ATADDR_ANYNODE &&
sat->sat_addr.s_net == ATADDR_ANYNET ) {
if ( at_ifaddr == NULL ) {
return( EADDRNOTAVAIL );
if (sat->sat_addr.s_node == ATADDR_ANYNODE &&
sat->sat_addr.s_net == ATADDR_ANYNET) {
if (at_ifaddr == NULL) {
return (EADDRNOTAVAIL);
}
sat->sat_addr = AA_SAT( at_ifaddr )->sat_addr;
sat->sat_addr = AA_SAT(at_ifaddr)->sat_addr;
}
ddp->ddp_lsat = *sat;
/*
* Choose port.
*/
if ( sat->sat_port == ATADDR_ANYPORT ) {
for ( sat->sat_port = ATPORT_RESERVED;
sat->sat_port < ATPORT_LAST; sat->sat_port++ ) {
if ( ddp_ports[ sat->sat_port - 1 ] == NULL ) {
if (sat->sat_port == ATADDR_ANYPORT) {
for (sat->sat_port = ATPORT_RESERVED;
sat->sat_port < ATPORT_LAST; sat->sat_port++) {
if (ddp_ports[ sat->sat_port - 1 ] == NULL) {
break;
}
}
if ( sat->sat_port == ATPORT_LAST ) {
return( EADDRNOTAVAIL );
if (sat->sat_port == ATPORT_LAST) {
return (EADDRNOTAVAIL);
}
ddp->ddp_lsat.sat_port = sat->sat_port;
ddp_ports[ sat->sat_port - 1 ] = ddp;
} else {
for ( ddpp = ddp_ports[ sat->sat_port - 1 ]; ddpp;
ddpp = ddpp->ddp_pnext ) {
if ( ddpp->ddp_lsat.sat_addr.s_net == sat->sat_addr.s_net &&
ddpp->ddp_lsat.sat_addr.s_node == sat->sat_addr.s_node ) {
for (ddpp = ddp_ports[ sat->sat_port - 1 ]; ddpp;
ddpp = ddpp->ddp_pnext) {
if (ddpp->ddp_lsat.sat_addr.s_net == sat->sat_addr.s_net &&
ddpp->ddp_lsat.sat_addr.s_node == sat->sat_addr.s_node) {
break;
}
}
if ( ddpp != NULL ) {
return( EADDRINUSE );
if (ddpp != NULL) {
return (EADDRINUSE);
}
ddp->ddp_pnext = ddp_ports[ sat->sat_port - 1 ];
ddp_ports[ sat->sat_port - 1 ] = ddp;
if ( ddp->ddp_pnext ) {
if (ddp->ddp_pnext) {
ddp->ddp_pnext->ddp_pprev = ddp;
}
}
return( 0 );
return (0);
}
int
@ -135,7 +135,7 @@ at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
u_short hintnet = 0, net;
if (sat->sat_family != AF_APPLETALK) {
return(EAFNOSUPPORT);
return (EAFNOSUPPORT);
}
/*
@ -143,10 +143,10 @@ at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
* network" to mean the network the control block is bound to.
* If the control block is not bound, there is an error.
*/
if ( sat->sat_addr.s_net == ATADDR_ANYNET
&& sat->sat_addr.s_node != ATADDR_ANYNODE ) {
if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
return( EADDRNOTAVAIL );
if (sat->sat_addr.s_net == ATADDR_ANYNET
&& sat->sat_addr.s_node != ATADDR_ANYNODE) {
if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT) {
return (EADDRNOTAVAIL);
}
hintnet = ddp->ddp_lsat.sat_addr.s_net;
}
@ -157,27 +157,27 @@ at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
* If we've changed our address, we may have an old "good looking"
* route here. Attempt to detect it.
*/
if ( ro->ro_rt ) {
if ( hintnet ) {
if (ro->ro_rt) {
if (hintnet) {
net = hintnet;
} else {
net = sat->sat_addr.s_net;
}
aa = NULL;
if ((ifp = ro->ro_rt->rt_ifp) != NULL) {
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp &&
ntohs( net ) >= ntohs( aa->aa_firstnet ) &&
ntohs( net ) <= ntohs( aa->aa_lastnet )) {
for (aa = at_ifaddr; aa; aa = aa->aa_next) {
if (aa->aa_ifp == ifp &&
ntohs(net) >= ntohs(aa->aa_firstnet) &&
ntohs(net) <= ntohs(aa->aa_lastnet)) {
break;
}
}
}
if ( aa == NULL || ( satosat( &ro->ro_dst )->sat_addr.s_net !=
( hintnet ? hintnet : sat->sat_addr.s_net ) ||
satosat( &ro->ro_dst )->sat_addr.s_node !=
sat->sat_addr.s_node )) {
RTFREE( ro->ro_rt );
if (aa == NULL || (satosat(&ro->ro_dst)->sat_addr.s_net !=
(hintnet ? hintnet : sat->sat_addr.s_net) ||
satosat(&ro->ro_dst)->sat_addr.s_node !=
sat->sat_addr.s_node)) {
RTFREE(ro->ro_rt);
ro->ro_rt = NULL;
}
}
@ -185,42 +185,42 @@ at_pcbconnect(struct ddpcb *ddp, struct sockaddr *addr, struct thread *td)
/*
* If we've got no route for this interface, try to find one.
*/
if ( ro->ro_rt == NULL || ro->ro_rt->rt_ifp == NULL ) {
ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
if (ro->ro_rt == NULL || ro->ro_rt->rt_ifp == NULL) {
ro->ro_dst.sa_len = sizeof(struct sockaddr_at);
ro->ro_dst.sa_family = AF_APPLETALK;
if ( hintnet ) {
satosat( &ro->ro_dst )->sat_addr.s_net = hintnet;
if (hintnet) {
satosat(&ro->ro_dst)->sat_addr.s_net = hintnet;
} else {
satosat( &ro->ro_dst )->sat_addr.s_net = sat->sat_addr.s_net;
satosat(&ro->ro_dst)->sat_addr.s_net = sat->sat_addr.s_net;
}
satosat( &ro->ro_dst )->sat_addr.s_node = sat->sat_addr.s_node;
rtalloc( ro );
satosat(&ro->ro_dst)->sat_addr.s_node = sat->sat_addr.s_node;
rtalloc(ro);
}
/*
* Make sure any route that we have has a valid interface.
*/
aa = NULL;
if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp ) {
if (ro->ro_rt && (ifp = ro->ro_rt->rt_ifp)) {
for (aa = at_ifaddr; aa; aa = aa->aa_next) {
if (aa->aa_ifp == ifp) {
break;
}
}
}
if ( aa == NULL ) {
return( ENETUNREACH );
if (aa == NULL) {
return (ENETUNREACH);
}
ddp->ddp_fsat = *sat;
if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
return(at_pcbsetaddr(ddp, NULL, td));
if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT) {
return (at_pcbsetaddr(ddp, NULL, td));
}
return( 0 );
return (0);
}
void
at_pcbdisconnect( struct ddpcb *ddp )
at_pcbdisconnect(struct ddpcb *ddp)
{
ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
@ -228,7 +228,7 @@ at_pcbdisconnect( struct ddpcb *ddp )
}
int
at_pcballoc( struct socket *so )
at_pcballoc(struct socket *so)
{
struct ddpcb *ddp;
@ -246,39 +246,39 @@ at_pcballoc( struct socket *so )
ddp->ddp_socket = so;
so->so_pcb = (caddr_t)ddp;
return(0);
return (0);
}
void
at_pcbdetach( struct socket *so, struct ddpcb *ddp)
at_pcbdetach(struct socket *so, struct ddpcb *ddp)
{
soisdisconnected( so );
soisdisconnected(so);
so->so_pcb = NULL;
sotryfree(so);
/* remove ddp from ddp_ports list */
if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] != NULL ) {
if ( ddp->ddp_pprev != NULL ) {
if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] != NULL) {
if (ddp->ddp_pprev != NULL) {
ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
} else {
ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] = ddp->ddp_pnext;
}
if ( ddp->ddp_pnext != NULL ) {
if (ddp->ddp_pnext != NULL) {
ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
}
}
if ( ddp->ddp_route.ro_rt ) {
RTFREE( ddp->ddp_route.ro_rt );
if (ddp->ddp_route.ro_rt) {
RTFREE(ddp->ddp_route.ro_rt);
}
if ( ddp->ddp_prev ) {
if (ddp->ddp_prev) {
ddp->ddp_prev->ddp_next = ddp->ddp_next;
} else {
ddpcb = ddp->ddp_next;
}
if ( ddp->ddp_next ) {
if (ddp->ddp_next) {
ddp->ddp_next->ddp_prev = ddp->ddp_prev;
}
FREE(ddp, M_PCB);
@ -291,7 +291,7 @@ at_pcbdetach( struct socket *so, struct ddpcb *ddp)
* sockets (pcbs).
*/
struct ddpcb *
ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
ddp_search(struct sockaddr_at *from, struct sockaddr_at *to,
struct at_ifaddr *aa)
{
struct ddpcb *ddp;
@ -299,39 +299,39 @@ ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
/*
* Check for bad ports.
*/
if ( to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST ) {
return( NULL );
if (to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST) {
return (NULL);
}
/*
* Make sure the local address matches the sent address. What about
* the interface?
*/
for ( ddp = ddp_ports[ to->sat_port - 1 ]; ddp; ddp = ddp->ddp_pnext ) {
for (ddp = ddp_ports[ to->sat_port - 1 ]; ddp; ddp = ddp->ddp_pnext) {
/* XXX should we handle 0.YY? */
/* XXXX.YY to socket on destination interface */
if ( to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node ) {
if (to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node) {
break;
}
/* 0.255 to socket on receiving interface */
if ( to->sat_addr.s_node == ATADDR_BCAST && ( to->sat_addr.s_net == 0 ||
to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net ) &&
ddp->ddp_lsat.sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) {
if (to->sat_addr.s_node == ATADDR_BCAST && (to->sat_addr.s_net == 0 ||
to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net) &&
ddp->ddp_lsat.sat_addr.s_net == AA_SAT(aa)->sat_addr.s_net) {
break;
}
/* XXXX.0 to socket on destination interface */
if ( to->sat_addr.s_net == aa->aa_firstnet &&
if (to->sat_addr.s_net == aa->aa_firstnet &&
to->sat_addr.s_node == 0 &&
ntohs( ddp->ddp_lsat.sat_addr.s_net ) >=
ntohs( aa->aa_firstnet ) &&
ntohs( ddp->ddp_lsat.sat_addr.s_net ) <=
ntohs( aa->aa_lastnet )) {
ntohs(ddp->ddp_lsat.sat_addr.s_net) >=
ntohs(aa->aa_firstnet) &&
ntohs(ddp->ddp_lsat.sat_addr.s_net) <=
ntohs(aa->aa_lastnet)) {
break;
}
}
return( ddp );
return (ddp);
}

136
sys/netatalk/ddp_usrreq.c
View file

@ -23,7 +23,7 @@
#include <netatalk/at_extern.h>
static u_long ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
static u_long ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
static u_long ddp_recvspace = 10 * (587 + sizeof(struct sockaddr_at));
static struct ifqueue atintrq1, atintrq2, aarpintrq;
@ -35,18 +35,18 @@ ddp_attach(struct socket *so, int proto, struct thread *td)
int s;
ddp = sotoddpcb( so );
if ( ddp != NULL ) {
return( EINVAL);
ddp = sotoddpcb(so);
if (ddp != NULL) {
return (EINVAL);
}
s = splnet();
error = at_pcballoc( so );
error = at_pcballoc(so);
splx(s);
if (error) {
return (error);
}
return (soreserve( so, ddp_sendspace, ddp_recvspace ));
return (soreserve(so, ddp_sendspace, ddp_recvspace));
}
static int
@ -55,14 +55,14 @@ ddp_detach(struct socket *so)
struct ddpcb *ddp;
int s;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return( EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
s = splnet();
at_pcbdetach( so, ddp );
at_pcbdetach(so, ddp);
splx(s);
return(0);
return (0);
}
static int
@ -72,9 +72,9 @@ ddp_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
int error = 0;
int s;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return( EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
s = splnet();
error = at_pcbsetaddr(ddp, nam, td);
@ -89,21 +89,21 @@ ddp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
int error = 0;
int s;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return( EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
return(EISCONN);
if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
return (EISCONN);
}
s = splnet();
error = at_pcbconnect( ddp, nam, td );
error = at_pcbconnect(ddp, nam, td);
splx(s);
if ( error == 0 )
soisconnected( so );
return(error);
if (error == 0)
soisconnected(so);
return (error);
}
static int
@ -113,20 +113,20 @@ ddp_disconnect(struct socket *so)
struct ddpcb *ddp;
int s;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return( EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
return(ENOTCONN);
if (ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE) {
return (ENOTCONN);
}
s = splnet();
at_pcbdisconnect( ddp );
at_pcbdisconnect(ddp);
ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
splx(s);
soisdisconnected( so );
return(0);
soisdisconnected(so);
return (0);
}
static int
@ -134,12 +134,12 @@ ddp_shutdown(struct socket *so)
{
struct ddpcb *ddp;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return( EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
socantsendmore( so );
return(0);
socantsendmore(so);
return (0);
}
static int
@ -150,39 +150,39 @@ ddp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
int error = 0;
int s;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return(EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
if ( control && control->m_len ) {
return(EINVAL);
if (control && control->m_len) {
return (EINVAL);
}
if ( addr ) {
if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
return(EISCONN);
if (addr) {
if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
return (EISCONN);
}
s = splnet();
error = at_pcbconnect(ddp, addr, td);
splx( s );
if ( error ) {
return(error);
splx(s);
if (error) {
return (error);
}
} else {
if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
return(ENOTCONN);
if (ddp->ddp_fsat.sat_port == ATADDR_ANYPORT) {
return (ENOTCONN);
}
}
s = splnet();
error = ddp_output( m, so );
if ( addr ) {
at_pcbdisconnect( ddp );
error = ddp_output(m, so);
if (addr) {
at_pcbdisconnect(ddp);
}
splx(s);
return(error);
return (error);
}
static int
@ -191,15 +191,15 @@ ddp_abort(struct socket *so)
struct ddpcb *ddp;
int s;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return(EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
soisdisconnected( so );
soisdisconnected(so);
s = splnet();
at_pcbdetach( so, ddp );
at_pcbdetach(so, ddp);
splx(s);
return(0);
return (0);
}
void
@ -219,12 +219,12 @@ ddp_init(void)
#if 0
static void
ddp_clean(void )
ddp_clean(void)
{
struct ddpcb *ddp;
for ( ddp = ddpcb; ddp; ddp = ddp->ddp_next ) {
at_pcbdetach( ddp->ddp_socket, ddp );
for (ddp = ddpcb; ddp; ddp = ddp->ddp_next) {
at_pcbdetach(ddp->ddp_socket, ddp);
}
}
#endif
@ -232,7 +232,7 @@ ddp_clean(void )
static int
at_setpeeraddr(struct socket *so, struct sockaddr **nam)
{
return(EOPNOTSUPP);
return (EOPNOTSUPP);
}
static int
@ -240,12 +240,12 @@ at_setsockaddr(struct socket *so, struct sockaddr **nam)
{
struct ddpcb *ddp;
ddp = sotoddpcb( so );
if ( ddp == NULL ) {
return( EINVAL);
ddp = sotoddpcb(so);
if (ddp == NULL) {
return (EINVAL);
}
at_sockaddr( ddp, nam );
return(0);
at_sockaddr(ddp, nam);
return (0);
}
struct pr_usrreqs ddp_usrreqs = {