d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Obtained from: netatalk distribution netatalk@itd.umich.edu

Browse Source 
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.
This commit is contained in:
Julian Elischer 1996-05-24 01:35:45 +00:00
parent f66e235a13
commit 655929bfba
20 changed files with 4312 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
sys/conf/files
View File

@ -156,6 +156,13 @@ net/rtsock.c standard
net/slcompress.c optional ppp
net/slcompress.c optional sl
net/if_tun.c optional tun
netatalk/aarp.c optional netatalk
netatalk/at_control.c optional netatalk
netatalk/at_proto.c optional netatalk
netatalk/at_rmx.c optional netatalkdebug
netatalk/ddp_input.c optional netatalk
netatalk/ddp_output.c optional netatalk
netatalk/ddp_usrreq.c optional netatalk
#netccitt/ccitt_proto.c optional ccitt
#netccitt/hd_debug.c optional hdlc
#netccitt/hd_input.c optional hdlc

104
sys/net/if_ethersubr.c
View File

@ -31,7 +31,7 @@
* SUCH DAMAGE.
*
* @(#)if_ethersubr.c 8.1 (Berkeley) 6/10/93
* $Id: if_ethersubr.c,v 1.14 1996/01/24 21:09:06 phk Exp $
* $Id: if_ethersubr.c,v 1.15 1996/04/07 17:39:03 bde Exp $
*/
#include <sys/param.h>
@ -76,15 +76,27 @@
#include <netiso/iso_snpac.h>
#endif
#ifdef LLC
/*#ifdef LLC
#include <netccitt/dll.h>
#include <netccitt/llc_var.h>
#endif
#endif*/
#if defined(LLC) && defined(CCITT)
extern struct ifqueue pkintrq;
#endif
#ifdef NETATALK
#include <netatalk/at.h>
#include <netatalk/at_var.h>
#include <netatalk/at_extern.h>
#define llc_snap_org_code llc_un.type_snap.org_code
#define llc_snap_ether_type llc_un.type_snap.ether_type
extern u_char at_org_code[ 3 ];
extern u_char aarp_org_code[ 3 ];
#endif NETATALK
u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
#define senderr(e) { error = (e); goto bad;}
@ -111,6 +123,9 @@ ether_output(ifp, m0, dst, rt0)
register struct ether_header *eh;
int off, len = m->m_pkthdr.len;
struct arpcom *ac = (struct arpcom *)ifp;
#ifdef NETATALK
struct at_ifaddr *aa;
#endif NETATALK
if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
senderr(ENETDOWN);
@ -165,6 +180,44 @@ ether_output(ifp, m0, dst, rt0)
mcopy = m_copy(m, 0, (int)M_COPYALL);
break;
#endif
#ifdef NETATALK
case AF_APPLETALK:
if (!aarpresolve(ac, m, (struct sockaddr_at *)dst, edst)) {
#ifdef NETATALKDEBUG
extern char *prsockaddr(struct sockaddr *);
printf("aarpresolv: failed for %s\n", prsockaddr(dst));
#endif NETATALKDEBUG
return (0);
}
/*
* ifaddr is the first thing in at_ifaddr
*/
if ((aa = (struct at_ifaddr *)at_ifawithnet(
(struct sockaddr_at *)dst, ifp->if_addrlist))
== 0)
goto bad;
/*
* In the phase 2 case, we need to prepend an mbuf for the llc header.
* Since we must preserve the value of m, which is passed to us by
* value, we m_copy() the first mbuf, and use it for our llc header.
*/
if ( aa->aa_flags & AFA_PHASE2 ) {
struct llc llc;
M_PREPEND(m, sizeof(struct llc), M_WAIT);
len += sizeof(struct llc);
llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
llc.llc_control = LLC_UI;
bcopy(at_org_code, llc.llc_snap_org_code, sizeof(at_org_code));
llc.llc_snap_ether_type = htons( ETHERTYPE_AT );
bcopy(&llc, mtod(m, caddr_t), sizeof(struct llc));
type = m->m_pkthdr.len;
} else {
type = ETHERTYPE_AT;
}
break;
#endif NETATALK
#ifdef NS
case AF_NS:
type = ETHERTYPE_NS;
@ -371,12 +424,51 @@ ether_input(ifp, eh, m)
inq = &nsintrq;
break;
#endif
#ifdef NETATALK
case ETHERTYPE_AT:
schednetisr(NETISR_ATALK);
inq = &atintrq1;
break;
case ETHERTYPE_AARP:
/* probably this should be done with a NETISR as well */
aarpinput((struct arpcom *)ifp, m); /* XXX */
return;
#endif NETATALK
default:
#if defined (ISO) || defined (LLC)
#if defined (ISO) || defined (LLC) || defined(NETATALK)
if (ether_type > ETHERMTU)
goto dropanyway;
l = mtod(m, struct llc *);
switch (l->llc_dsap) {
#ifdef NETATALK
case LLC_SNAP_LSAP:
switch (l->llc_control) {
case LLC_UI:
if (l->llc_ssap != LLC_SNAP_LSAP)
goto dropanyway;
if (Bcmp(&(l->llc_snap_org_code)[0], at_org_code,
sizeof(at_org_code)) == 0 &&
ntohs(l->llc_snap_ether_type) == ETHERTYPE_AT) {
inq = &atintrq2;
m_adj( m, sizeof( struct llc ));
schednetisr(NETISR_ATALK);
break;
}
if (Bcmp(&(l->llc_snap_org_code)[0], aarp_org_code,
sizeof(aarp_org_code)) == 0 &&
ntohs(l->llc_snap_ether_type) == ETHERTYPE_AARP) {
m_adj( m, sizeof( struct llc ));
aarpinput((struct arpcom *)ifp, m); /* XXX */
return;
}
default:
goto dropanyway;
}
break;
#endif NETATALK
#ifdef ISO
case LLC_ISO_LSAP:
switch (l->llc_control) {
@ -469,10 +561,10 @@ ether_input(ifp, eh, m)
m_freem(m);
return;
}
#else /* ISO || LLC */
#else /* ISO || LLC || NETATALK */
m_freem(m);
return;
#endif /* ISO || LLC */
#endif /* ISO || LLC || NETATALK */
}
s = splimp();

14
sys/net/if_loop.c
View File

@ -31,7 +31,7 @@
* SUCH DAMAGE.
*
* @(#)if_loop.c 8.1 (Berkeley) 6/10/93
* $Id: if_loop.c,v 1.18 1996/02/06 18:51:11 wollman Exp $
* $Id: if_loop.c,v 1.19 1996/04/07 17:39:06 bde Exp $
*/
/*
@ -77,6 +77,12 @@
#include <netiso/iso_var.h>
#endif
#ifdef NETATALK
#include <netinet/if_ether.h>
#include <netatalk/at.h>
#include <netatalk/at_var.h>
#endif NETATALK
#include "bpfilter.h"
static int loioctl __P((struct ifnet *, int, caddr_t));
@ -194,6 +200,12 @@ looutput(ifp, m, dst, rt)
isr = NETISR_ISO;
break;
#endif
#ifdef NETATALK
case AF_APPLETALK:
ifq = &atintrq2;
isr = NETISR_ATALK;
break;
#endif NETATALK
default:
printf("lo%d: can't handle af%d\n", ifp->if_unit,
dst->sa_family);

3
sys/net/netisr.h
View File

@ -31,7 +31,7 @@
* SUCH DAMAGE.
*
* @(#)netisr.h 8.1 (Berkeley) 6/10/93
* $Id: netisr.h,v 1.7 1995/10/26 20:30:22 julian Exp $
* $Id: netisr.h,v 1.8 1995/10/31 19:07:49 peter Exp $
*/
#ifndef _NET_NETISR_H_
@ -61,6 +61,7 @@
#define NETISR_NS 6 /* same as AF_NS */
#define NETISR_ISO 7 /* same as AF_ISO */
#define NETISR_CCITT 10 /* same as AF_CCITT */
#define NETISR_ATALK 16 /* same as AF_APPLETALK */
#define NETISR_ARP 18 /* same as AF_LINK */
#define NETISR_IPX 23 /* same as AF_IPX */
#define NETISR_ISDN 26 /* same as AF_E164 */

816
sys/netatalk/aarp.c Normal file
View File

@ -0,0 +1,816 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*/
#include <sys/types.h>
#include <sys/cdefs.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/param.h>
#if defined( __FreeBSD__ )
#include <machine/endian.h>
#include <sys/systm.h>
#include <sys/proc.h>
#endif
#include <sys/mbuf.h>
#include <sys/time.h>
#ifndef _IBMR2
#include <sys/kernel.h>
#endif _IBMR2
#include <net/if.h>
#include <net/route.h>
#if !defined( __FreeBSD__ )
#include <net/af.h>
#endif
#include <netinet/in.h>
#undef s_net
#include <netinet/if_ether.h>
#ifdef _IBMR2
#include <netinet/in_netarp.h>
#include <net/spl.h>
#include <sys/errno.h>
#include <sys/err_rec.h>
#endif _IBMR2
#include <netatalk/at.h>
#include <netatalk/at_var.h>
#include <netatalk/aarp.h>
#include <netatalk/ddp_var.h>
#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);
#ifdef GATEWAY
#define AARPTAB_BSIZ 16
#define AARPTAB_NB 37
#else
#define AARPTAB_BSIZ 9
#define AARPTAB_NB 19
#endif GATEWAY
#define AARPTAB_SIZE (AARPTAB_BSIZ * AARPTAB_NB)
struct aarptab aarptab[AARPTAB_SIZE];
int aarptab_size = AARPTAB_SIZE;
#define AARPTAB_HASH(a) \
((((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 ) \
break; \
if ( n >= AARPTAB_BSIZ ) \
aat = 0; \
}
#define AARPT_AGE (60 * 1)
#define AARPT_KILLC 20
#define AARPT_KILLI 3
#ifdef sun
extern struct ether_addr etherbroadcastaddr;
#else sun
# if !defined( __FreeBSD__ )
extern u_char etherbroadcastaddr[6];
# endif __FreeBSD__
#endif sun
u_char atmulticastaddr[ 6 ] = {
0x09, 0x00, 0x07, 0xff, 0xff, 0xff,
};
u_char at_org_code[ 3 ] = {
0x08, 0x00, 0x07,
};
u_char aarp_org_code[ 3 ] = {
0x00, 0x00, 0x00,
};
static void
aarptimer(void *ignored)
{
struct aarptab *aat;
int i, s;
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 ))
continue;
if ( ++aat->aat_timer < (( aat->aat_flags & ATF_COM ) ?
AARPT_KILLC : AARPT_KILLI ))
continue;
s = splimp();
aarptfree( aat );
splx( s );
}
}
struct ifaddr *
at_ifawithnet( sat, ifa )
struct sockaddr_at *sat;
struct ifaddr *ifa;
{
struct at_ifaddr *aa;
for (; ifa; ifa = ifa->ifa_next ) {
#ifdef BSD4_4
if ( ifa->ifa_addr->sa_family != AF_APPLETALK ) {
continue;
}
if ( satosat( ifa->ifa_addr )->sat_addr.s_net ==
sat->sat_addr.s_net ) {
break;
}
#else BSD4_4
if ( ifa->ifa_addr.sa_family != AF_APPLETALK ) {
continue;
}
aa = (struct at_ifaddr *)ifa;
if ( ntohs( sat->sat_addr.s_net ) >= ntohs( aa->aa_firstnet ) &&
ntohs( sat->sat_addr.s_net ) <= ntohs( aa->aa_lastnet )) {
break;
}
#endif BSD4_4
}
return( ifa );
}
static void
aarpwhohas( struct arpcom *ac, struct sockaddr_at *sat )
{
struct mbuf *m;
struct ether_header *eh;
struct ether_aarp *ea;
struct at_ifaddr *aa;
struct llc *llc;
struct sockaddr sa;
#ifdef BSD4_4
if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
return;
}
m->m_len = sizeof( *ea );
m->m_pkthdr.len = sizeof( *ea );
MH_ALIGN( m, sizeof( *ea ));
#else BSD4_4
if (( m = m_get( M_DONTWAIT, MT_DATA )) == NULL ) {
return;
}
m->m_len = sizeof( *ea );
m->m_off = MMAXOFF - sizeof( *ea );
#endif BSD4_4
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 );
#ifdef sun
bcopy((caddr_t)&ac->ac_enaddr, (caddr_t)ea->aarp_sha,
sizeof( ea->aarp_sha ));
#else sun
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
sizeof( ea->aarp_sha ));
#endif sun
/*
* We need to check whether the output ethernet type should
* be phase 1 or 2. We have the interface that we'll be sending
* the aarp out. We need to find an AppleTalk network on that
* 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 = (struct at_ifaddr *)at_ifawithnet( sat, ac->ac_if.if_addrlist ))
== NULL ) {
m_freem( m );
return;
}
eh = (struct ether_header *)sa.sa_data;
if ( aa->aa_flags & AFA_PHASE2 ) {
#ifdef sun
bcopy((caddr_t)atmulticastaddr, (caddr_t)&eh->ether_dhost,
sizeof( eh->ether_dhost ));
#else sun
bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
sizeof( eh->ether_dhost ));
#endif sun
#if defined(sun) && defined(i386)
eh->ether_type = htons(sizeof(struct llc) + sizeof(struct ether_aarp));
#else
eh->ether_type = sizeof(struct llc) + sizeof(struct ether_aarp);
#endif
#ifdef BSD4_4
M_PREPEND( m, sizeof( struct llc ), M_WAIT );
#else BSD4_4
m->m_len += sizeof( struct llc );
m->m_off -= sizeof( struct llc );
#endif BSD4_4
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( &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 {
#ifdef sun
bcopy((caddr_t)&etherbroadcastaddr, (caddr_t)&eh->ether_dhost,
sizeof( eh->ether_dhost ));
#else sun
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
sizeof( eh->ether_dhost ));
#endif sun
#if defined(sun) && defined(i386)
eh->ether_type = htons( ETHERTYPE_AARP );
#else
eh->ether_type = ETHERTYPE_AARP;
#endif
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);
#endif NETATALKDEBUG
#ifdef BSD4_4
sa.sa_len = sizeof( struct sockaddr );
#endif BSD4_4
sa.sa_family = AF_UNSPEC;
(*ac->ac_if.if_output)(&ac->ac_if, m, &sa
#if defined( __FreeBSD__ )
, NULL /* XXX should be routing information */
#endif __FreeBSD__
);
}
int
aarpresolve( ac, m, destsat, desten )
struct arpcom *ac;
struct mbuf *m;
struct sockaddr_at *destsat;
#ifdef sun
struct ether_addr *desten;
#else sun
u_char *desten;
#endif sun
{
struct at_ifaddr *aa;
struct ifaddr ifa;
struct aarptab *aat;
int s;
if ( at_broadcast( destsat )) {
if (( aa = (struct at_ifaddr *)at_ifawithnet( destsat,
((struct ifnet *)ac)->if_addrlist )) == NULL ) {
m_freem( m );
return( 0 );
}
if ( aa->aa_flags & AFA_PHASE2 ) {
bcopy( (caddr_t)atmulticastaddr, (caddr_t)desten,
sizeof( atmulticastaddr ));
} else {
#ifdef sun
bcopy( (caddr_t)&etherbroadcastaddr, (caddr_t)desten,
sizeof( etherbroadcastaddr ));
#else sun
bcopy( (caddr_t)etherbroadcastaddr, (caddr_t)desten,
sizeof( etherbroadcastaddr ));
#endif sun
}
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" );
}
aat->aat_hold = m;
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 );
}
/* entry has not completed */
if ( aat->aat_hold ) {
m_freem( aat->aat_hold );
}
aat->aat_hold = m;
aarpwhohas( ac, destsat );
splx( s );
return( 0 );
}
void
aarpinput( ac, m )
struct arpcom *ac;
struct mbuf *m;
{
struct arphdr *ar;
if ( ac->ac_if.if_flags & IFF_NOARP )
goto out;
#ifndef BSD4_4
IF_ADJ( m );
#endif BSD4_4
if ( m->m_len < sizeof( struct arphdr )) {
goto out;
}
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 ) {
goto out;
}
switch( ntohs( ar->ar_pro )) {
case ETHERTYPE_AT :
at_aarpinput( ac, m );
return;
default:
break;
}
out:
m_freem( m );
}
static void
at_aarpinput( struct arpcom *ac, struct mbuf *m)
{
struct mbuf *m0;
struct ether_aarp *ea;
struct at_ifaddr *aa;
struct aarptab *aat;
struct ether_header *eh;
struct llc *llc;
struct sockaddr_at sat;
struct sockaddr sa;
struct at_addr spa, tpa, ma;
int op, s;
u_short net;
ea = mtod( m, struct ether_aarp *);
/* Check to see if from my hardware address */
#ifdef sun
if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )&ac->ac_enaddr,
sizeof( ac->ac_enaddr ))) {
m_freem( m );
return;
}
#else sun
if ( !bcmp(( caddr_t )ea->aarp_sha, ( caddr_t )ac->ac_enaddr,
sizeof( ac->ac_enaddr ))) {
m_freem( m );
return;
}
#endif sun
op = ntohs( ea->aarp_op );
bcopy( ea->aarp_tpnet, &net, sizeof( net ));
if ( net != 0 ) { /* should be ATADDR_ANYNET? */
#ifdef BSD4_4
sat.sat_len = sizeof(struct sockaddr_at);
#endif BSD4_4
sat.sat_family = AF_APPLETALK;
sat.sat_addr.s_net = net;
if (( aa = (struct at_ifaddr *)at_ifawithnet( &sat,
ac->ac_if.if_addrlist )) == 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 ));
} else {
/*
* Since we don't know the net, we just look for the first
* phase 1 address on the interface.
*/
for ( aa = (struct at_ifaddr *)ac->ac_if.if_addrlist; aa;
aa = (struct at_ifaddr *)aa->aa_ifa.ifa_next ) {
if ( AA_SAT( aa )->sat_family == AF_APPLETALK &&
( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
break;
}
}
if ( aa == NULL ) {
m_freem( m );
return;
}
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;
/*
* 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 ) {
/*
* 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((timeout_func_t) aarpprobe, ac );
wakeup( aa );
m_freem( m );
return;
} 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...
*/
#ifndef _IBMR2
#ifdef ultrix
mprintf( LOG_ERR,
#else ultrix
log( LOG_ERR,
#endif ultrix
"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 ]);
#endif _IBMR2
m_freem( m );
return;
}
}
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 );
return;
}
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )aat->aat_enaddr,
sizeof( ea->aarp_sha ));
aat->aat_flags |= ATF_COM;
if ( aat->aat_hold ) {
#ifdef _IBMR2
/*
* Like in ddp_output(), we can't rely on the if_output
* routine to resolve AF_APPLETALK addresses, on the rs6k.
* So, we fill the destination ethernet address here.
*
* This should really be replaced with something like
* rsif_output(). XXX Will have to be for phase 2.
*/
/* XXX maybe fill in the rest of the frame header */
sat.sat_family = AF_UNSPEC;
bcopy( aat->aat_enaddr, (*(struct sockaddr *)&sat).sa_data,
sizeof( aat->aat_enaddr ));
#else _IBMR2
#ifdef BSD4_4
sat.sat_len = sizeof(struct sockaddr_at);
#endif BSD4_4
sat.sat_family = AF_APPLETALK;
sat.sat_addr = spa;
#endif _IBMR2
(*ac->ac_if.if_output)( &ac->ac_if, aat->aat_hold,
(struct sockaddr *)&sat
#if defined( __FreeBSD__ )
, NULL /* XXX */
#endif __FreeBSD__
);
aat->aat_hold = 0;
}
}
if ( aat == 0 && tpa.s_net == ma.s_net && tpa.s_node == ma.s_node
&& op != AARPOP_PROBE ) {
if ( aat = aarptnew( &spa )) {
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 );
return;
}
bcopy(( caddr_t )ea->aarp_sha, ( caddr_t )ea->aarp_tha,
sizeof( ea->aarp_sha ));
#ifdef sun
bcopy(( caddr_t )&ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
sizeof( ea->aarp_sha ));
#else sun
bcopy(( caddr_t )ac->ac_enaddr, ( caddr_t )ea->aarp_sha,
sizeof( ea->aarp_sha ));
#endif sun
/* XXX */
eh = (struct ether_header *)sa.sa_data;
#ifdef sun
bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )&eh->ether_dhost,
sizeof( eh->ether_dhost ));
#else sun
bcopy(( caddr_t )ea->aarp_tha, ( caddr_t )eh->ether_dhost,
sizeof( eh->ether_dhost ));
#endif sun
if ( aa->aa_flags & AFA_PHASE2 ) {
#if defined(sun) && defined(i386)
eh->ether_type = htons( sizeof( struct llc ) +
sizeof( struct ether_aarp ));
#else
eh->ether_type = sizeof( struct llc ) + sizeof( struct ether_aarp );
#endif
#ifdef BSD4_4
M_PREPEND( m, sizeof( struct llc ), M_DONTWAIT );
if ( m == NULL ) {
return;
}
#else BSD4_4
MGET( m0, M_DONTWAIT, MT_HEADER );
if ( m0 == NULL ) {
m_freem( m );
return;
}
m0->m_next = m;
m = m0;
m->m_off = MMAXOFF - sizeof( struct llc );
m->m_len = sizeof ( struct llc );
#endif BSD4_4
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( ea->aarp_spnet, ea->aarp_tpnet, sizeof( ea->aarp_tpnet ));
bcopy( &ma.s_net, ea->aarp_spnet, sizeof( ea->aarp_spnet ));
} else {
#if defined(sun) && defined(i386)
eh->ether_type = htons( ETHERTYPE_AARP );
#else
eh->ether_type = ETHERTYPE_AARP;
#endif
}
ea->aarp_tpnode = ea->aarp_spnode;
ea->aarp_spnode = ma.s_node;
ea->aarp_op = htons( AARPOP_RESPONSE );
#ifdef BSD4_4
sa.sa_len = sizeof( struct sockaddr );
#endif BSD4_4
sa.sa_family = AF_UNSPEC;
(*ac->ac_if.if_output)( &ac->ac_if, m, &sa
#if defined( __FreeBSD__ )
, NULL /* XXX */
#endif
);
return;
}
static void
aarptfree( struct aarptab *aat)
{
if ( aat->aat_hold )
m_freem( aat->aat_hold );
aat->aat_hold = 0;
aat->aat_timer = aat->aat_flags = 0;
aat->aat_ataddr.s_net = 0;
aat->aat_ataddr.s_node = 0;
}
struct aarptab *
aarptnew( addr )
struct at_addr *addr;
{
int n;
int oldest = -1;
struct aarptab *aat, *aato = NULL;
static int first = 1;
if ( first ) {
first = 0;
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 )
goto out;
if ( aat->aat_flags & ATF_PERM )
continue;
if ((int) aat->aat_timer > oldest ) {
oldest = aat->aat_timer;
aato = aat;
}
}
if ( aato == NULL )
return( NULL );
aat = aato;
aarptfree( aat );
out:
aat->aat_ataddr = *addr;
aat->aat_flags = ATF_INUSE;
return( aat );
}
void
aarpprobe( struct arpcom *ac )
{
struct mbuf *m;
struct ether_header *eh;
struct ether_aarp *ea;
struct at_ifaddr *aa;
struct llc *llc;
struct sockaddr sa;
/*
* We need to check whether the output ethernet type should
* be phase 1 or 2. We have the interface that we'll be sending
* the aarp out. We need to find an AppleTalk network on that
* interface with the same address as we're looking for. If the
* net is phase 2, generate an 802.2 and SNAP header.
*/
for ( aa = (struct at_ifaddr *)ac->ac_if.if_addrlist; aa;
aa = (struct at_ifaddr *)aa->aa_ifa.ifa_next ) {
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" );
return;
}
if ( aa->aa_probcnt <= 0 ) {
aa->aa_flags &= ~AFA_PROBING;
wakeup( aa );
return;
} else {
timeout( (timeout_func_t)aarpprobe, (caddr_t)ac, hz / 5 );
}
#ifdef BSD4_4
if (( m = m_gethdr( M_DONTWAIT, MT_DATA )) == NULL ) {
return;
}
m->m_len = sizeof( *ea );
m->m_pkthdr.len = sizeof( *ea );
MH_ALIGN( m, sizeof( *ea ));
#else BSD4_4
if (( m = m_get( M_DONTWAIT, MT_DATA )) == NULL ) {
return;
}
m->m_len = sizeof( *ea );
m->m_off = MMAXOFF - sizeof( *ea );
#endif BSD4_4
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 );
#ifdef sun
bcopy((caddr_t)&ac->ac_enaddr, (caddr_t)ea->aarp_sha,
sizeof( ea->aarp_sha ));
#else sun
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->aarp_sha,
sizeof( ea->aarp_sha ));
#endif sun
eh = (struct ether_header *)sa.sa_data;
if ( aa->aa_flags & AFA_PHASE2 ) {
#ifdef sun
bcopy((caddr_t)atmulticastaddr, (caddr_t)&eh->ether_dhost,
sizeof( eh->ether_dhost ));
#else sun
bcopy((caddr_t)atmulticastaddr, (caddr_t)eh->ether_dhost,
sizeof( eh->ether_dhost ));
#endif sun
#if defined(sun) && defined(i386)
eh->ether_type = htons( sizeof( struct llc ) +
sizeof( struct ether_aarp ));
#else
eh->ether_type = sizeof( struct llc ) + sizeof( struct ether_aarp );
#endif
#ifdef BSD4_4
M_PREPEND( m, sizeof( struct llc ), M_WAIT );
#else BSD4_4
m->m_len += sizeof( struct llc );
m->m_off -= sizeof( struct llc );
#endif BSD4_4
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( &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 {
#ifdef sun
bcopy((caddr_t)&etherbroadcastaddr, (caddr_t)&eh->ether_dhost,
sizeof( eh->ether_dhost ));
#else sun
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
sizeof( eh->ether_dhost ));
#endif sun
#if defined(sun) && defined(i386)
eh->ether_type = htons( ETHERTYPE_AARP );
#else
eh->ether_type = ETHERTYPE_AARP;
#endif
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);
#endif NETATALKDEBUG
#ifdef BSD4_4
sa.sa_len = sizeof( struct sockaddr );
#endif BSD4_4
sa.sa_family = AF_UNSPEC;
(*ac->ac_if.if_output)(&ac->ac_if, m, &sa
#if defined( __FreeBSD__ )
, NULL /* XXX */
#endif __FreeBSD__
);
aa->aa_probcnt--;
}
void
aarp_clean(void)
{
struct aarptab *aat;
int i;
untimeout( aarptimer, 0 );
for ( i = 0, aat = aarptab; i < AARPTAB_SIZE; i++, aat++ ) {
if ( aat->aat_hold ) {
m_freem( aat->aat_hold );
}
}
}

62
sys/netatalk/aarp.h Normal file
View File

@ -0,0 +1,62 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*/
#ifndef _NETATALK_AARP_H_
/*
* This structure is used for both phase 1 and 2. Under phase 1
* the net is not filled in. It is in phase 2. In both cases, the
* hardware address length is (for some unknown reason) 4. If
* anyone at Apple could program their way out of paper bag, it
* would be 1 and 3 respectively for phase 1 and 2.
*/
union aapa {
u_char ap_pa[4];
struct ap_node {
u_char an_zero;
u_char an_net[2];
u_char an_node;
} ap_node;
};
struct ether_aarp {
struct arphdr eaa_hdr;
u_char aarp_sha[6];
union aapa aarp_spu;
u_char aarp_tha[6];
union aapa aarp_tpu;
};
#define aarp_hrd eaa_hdr.ar_hrd
#define aarp_pro eaa_hdr.ar_pro
#define aarp_hln eaa_hdr.ar_hln
#define aarp_pln eaa_hdr.ar_pln
#define aarp_op eaa_hdr.ar_op
#define aarp_spa aarp_spu.ap_node.an_node
#define aarp_tpa aarp_tpu.ap_node.an_node
#define aarp_spnet aarp_spu.ap_node.an_net
#define aarp_tpnet aarp_tpu.ap_node.an_net
#define aarp_spnode aarp_spu.ap_node.an_node
#define aarp_tpnode aarp_tpu.ap_node.an_node
struct aarptab {
struct at_addr aat_ataddr;
u_char aat_enaddr[ 6 ];
u_char aat_timer;
u_char aat_flags;
struct mbuf *aat_hold;
};
#define AARPHRD_ETHER 0x0001
#define AARPOP_REQUEST 0x01
#define AARPOP_RESPONSE 0x02
#define AARPOP_PROBE 0x03
#ifdef KERNEL
struct aarptab *aarptnew(struct at_addr *);
#if !defined( __FreeBSD__ )
int aarpprobe();
#endif
#endif
#endif /* _NETATALK_AARP_H_ */

117
sys/netatalk/at.h Normal file
View File

@ -0,0 +1,117 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of The University
* of Michigan not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. This software is supplied as is without expressed or
* implied warranties of any kind.
*
* Research Systems Unix Group
* The University of Michigan
* c/o Mike Clark
* 535 W. William Street
* Ann Arbor, Michigan
* +1-313-763-0525
* netatalk@itd.umich.edu
*/
#ifndef __AT_HEADER__
#define __AT_HEADER__
/*
* Supported protocols
*/
#define ATPROTO_DDP 0
#define ATPROTO_AARP 254
/*
* Ethernet types, for DIX.
* These should really be in some global header file, but we can't
* count on them being there, and it's annoying to patch system files.
*/
#define ETHERTYPE_AT 0x809B /* AppleTalk protocol */
#define ETHERTYPE_AARP 0x80F3 /* AppleTalk ARP */
#define DDP_MAXSZ 587
/*
* If ATPORT_FIRST <= Port < ATPORT_RESERVED,
* Port was created by a privileged process.
* If ATPORT_RESERVED <= Port < ATPORT_LAST,
* Port was not necessarily created by a
* privileged process.
*/
#define ATPORT_FIRST 1
#define ATPORT_RESERVED 128
#define ATPORT_LAST 255
/*
* AppleTalk address.
*/
struct at_addr {
u_short s_net;
u_char s_node;
};
#if defined( BSD4_4 ) && !defined( __FreeBSD__ )
#define ATADDR_ANYNET (u_short)0xffff
#else
#define ATADDR_ANYNET (u_short)0x0000
#endif
#define ATADDR_ANYNODE (u_char)0x00
#define ATADDR_ANYPORT (u_char)0x00
#define ATADDR_BCAST (u_char)0xff /* There is no BCAST for NET */
/*
* Socket address, AppleTalk style. We keep magic information in the
* zero bytes. There are three types, NONE, CONFIG which has the phase
* and a net range, and IFACE which has the network address of an
* interface. IFACE may be filled in by the client, and is filled in
* by the kernel.
*/
struct sockaddr_at {
#ifdef BSD4_4
u_char sat_len;
u_char sat_family;
#else BSD4_4
short sat_family;
#endif BSD4_4
u_char sat_port;
struct at_addr sat_addr;
#ifdef notdef
struct {
u_char sh_type;
# define SATHINT_NONE 0
# define SATHINT_CONFIG 1
# define SATHINT_IFACE 2
union {
char su_zero[ 7 ]; /* XXX check size */
struct {
u_char sr_phase;
u_short sr_firstnet, sr_lastnet;
} su_range;
u_short su_interface;
} sh_un;
} sat_hints;
#else notdef
char sat_zero[ 8 ];
#endif notdef
};
struct netrange {
u_char nr_phase;
u_short nr_firstnet;
u_short nr_lastnet;
};
#ifdef KERNEL
extern struct domain atalkdomain;
extern struct protosw atalksw[];
#endif
#endif __AT_HEADER__

614
sys/netatalk/at_control.c Normal file
View File

@ -0,0 +1,614 @@
/*
* 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" );
}
}
}
}

41
sys/netatalk/at_extern.h Normal file
View File

@ -0,0 +1,41 @@
#ifdef _NETINET_IF_ETHER_H_
extern void aarpprobe __P((struct arpcom *));
extern int aarpresolve __P((struct arpcom *,
struct mbuf *,
struct sockaddr_at *,
u_char *));
extern void aarpinput __P(( struct arpcom *, struct mbuf *));
extern int at_broadcast __P((struct sockaddr_at *));
#endif
#ifdef _NETATALK_AARP_H_
extern void aarptfree __P((struct aarptab *));
#endif
extern void aarp_clean __P((void));
extern int at_control __P(( int cmd,
caddr_t data,
struct ifnet *ifp,
struct proc *p ));
extern u_short at_cksum __P(( struct mbuf *m, int skip));
extern int ddp_usrreq __P(( struct socket *so, int req,
struct mbuf *m,
struct mbuf *addr,
struct mbuf *rights));
extern void ddp_init __P((void ));
extern struct ifaddr *at_ifawithnet __P((struct sockaddr_at *,
struct ifaddr *));
#ifdef _NETATALK_DDP_VAR_H_
extern int ddp_output __P(( struct ddpcb *ddp, struct mbuf *m));
#endif
#if defined (_NETATALK_DDP_VAR_H_) && defined(_NETATALK_AT_VAR_H_)
extern struct ddpcb *ddp_search __P((struct sockaddr_at *,
struct sockaddr_at *,
struct at_ifaddr *));
#endif
#ifdef _NET_ROUTE_H_
int ddp_route( struct mbuf *m, struct route *ro);
#endif

95
sys/netatalk/at_proto.c Normal file
View File

@ -0,0 +1,95 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of The University
* of Michigan not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. This software is supplied as is without expressed or
* implied warranties of any kind.
*
* Research Systems Unix Group
* The University of Michigan
* c/o Mike Clark
* 535 W. William Street
* Ann Arbor, Michigan
* +1-313-763-0525
* netatalk@itd.umich.edu
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/protosw.h>
#include <sys/domain.h>
#include <sys/types.h>
#include <sys/socket.h>
#if defined( __FreeBSD__ )
#include <sys/kernel.h>
#include <net/if.h>
#include <net/radix.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <net/route.h>
#endif
#include "at.h"
#include "ddp.h"
#include "at_var.h"
#include "ddp_var.h"
#include <netatalk/at_extern.h>
#ifdef ultrix
extern int ddp_ifoutput();
extern int ddp_ifinput();
extern int ddp_ifioctl();
#endif ultrix
struct protosw atalksw[] = {
{
/* Identifiers */
SOCK_DGRAM, &atalkdomain, ATPROTO_DDP, PR_ATOMIC|PR_ADDR,
/*
* protocol-protocol interface.
* fields are pr_input, pr_output, pr_ctlinput, and pr_ctloutput.
* pr_input can be called from the udp protocol stack for iptalk
* packets bound for a local socket.
* pr_output can be used by higher level appletalk protocols, should
* they be included in the kernel.
*/
0, ddp_output, 0, 0,
/* socket-protocol interface. */
ddp_usrreq,
/* utility routines. */
ddp_init, 0, 0, 0,
#ifdef ultrix
/* interface hooks */
ddp_ifoutput, ddp_ifinput, ddp_ifioctl, 0,
#endif ultrix
},
};
#if defined( __FreeBSD__ ) && defined ( NETATALKDEBUG )
extern int at_inithead();
#endif
struct domain atalkdomain = {
AF_APPLETALK, "appletalk", 0, 0, 0,
atalksw, &atalksw[sizeof(atalksw)/sizeof(atalksw[0])]
#if defined( __FreeBSD__ )
#ifdef NETATALKDEBUG
, 0, at_inithead, 32, sizeof(struct sockaddr_at)
#else
, 0, rn_inithead, 32, sizeof(struct sockaddr_at)
#endif
#endif
};
#if defined( __FreeBSD__ )
DOMAIN_SET(atalk);
#endif

160
sys/netatalk/at_rmx.c Normal file
View File

@ -0,0 +1,160 @@
/*
* Copyright 1994, 1995 Massachusetts Institute of Technology
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby
* granted, provided that both the above copyright notice and this
* permission notice appear in all copies, that both the above
* copyright notice and this permission notice appear in all
* supporting documentation, and that the name of M.I.T. not be used
* in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission. M.I.T. makes
* no representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied
* warranty.
*
* THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS
* ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
* SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* at_rmx.c,v 1.13 1995/05/30 08:09:31 rgrimes Exp
*/
/* This code generates debugging traces to the radix code */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/queue.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/mbuf.h>
#include <sys/syslog.h>
#include <net/if.h>
#include <net/route.h>
#include <netatalk/at.h>
#include <netatalk/at_extern.h>
static char hexbuf[256];
char *
prsockaddr(void *v)
{
char *bp = &hexbuf[0];
u_char *cp = v;
if (v) {
int len = *cp;
u_char *cplim = cp + len;
/* return: "(len) hexdump" */
bp += sprintf(bp, "(%d)", len);
for (cp++; cp < cplim && bp < hexbuf+252; cp++) {
*bp++ = "0123456789abcdef"[*cp / 16];
*bp++ = "0123456789abcdef"[*cp % 16];
}
} else {
bp+= sprintf(bp, "null");
}
*bp = '\0';
return &hexbuf[0];
}
static struct radix_node *
at_addroute(void *v_arg, void *n_arg, struct radix_node_head *head,
struct radix_node *treenodes)
{
struct radix_node *rn;
struct sockaddr_at *dst = v_arg, *mask = n_arg;
printf("at_addroute: v=%s\n", prsockaddr(v_arg));
printf("at_addroute: n=%s\n", prsockaddr(n_arg));
printf("at_addroute: head=%x treenodes=%x\n", head, treenodes);
rn = rn_addroute(v_arg, n_arg, head, treenodes);
printf("at_addroute: returns rn=%x\n", rn);
return rn;
}
static struct radix_node *
at_matroute(void *v_arg, struct radix_node_head *head)
{
struct radix_node *rn;
struct sockaddr_at *dst = v_arg;
printf("at_matroute: v=%s\n", prsockaddr(v_arg));
printf("at_matroute: head=%x\n", head);
rn = rn_match(v_arg, head);
printf("at_matroute: returns rn=%x\n", rn);
return rn;
}
static struct radix_node *
at_lookup(void *v_arg, void *m_arg, struct radix_node_head *head)
{
struct radix_node *rn;
printf("at_lookup: v=%s\n", prsockaddr(v_arg));
printf("at_lookup: n=%s\n", prsockaddr(m_arg));
printf("at_lookup: head=%x\n", head);
rn = rn_lookup(v_arg, m_arg, head);
printf("at_lookup: returns rn=%x\n", rn);
return rn;
}
static struct radix_node *
at_delroute(void *v_arg, void *netmask_arg, struct radix_node_head *head)
{
struct radix_node *rn;
printf("at_delroute: v=%s\n", prsockaddr(v_arg));
printf("at_delroute: n=%s\n", prsockaddr(netmask_arg));
printf("at_delroute: head=%x\n", head);
rn = rn_delete(v_arg, netmask_arg, head);
printf("at_delroute: returns rn=%x\n", rn);
return rn;
}
/*
* Initialize our routing tree with debugging hooks.
*/
int
at_inithead(void **head, int off)
{
struct radix_node_head *rnh;
if(!rn_inithead(head, off))
return 0;
rnh = *head;
rnh->rnh_addaddr = at_addroute;
rnh->rnh_deladdr = at_delroute;
rnh->rnh_matchaddr = at_matroute;
rnh->rnh_lookup = at_lookup;
return 1;
}

71
sys/netatalk/at_var.h Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of The University
* of Michigan not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. This software is supplied as is without expressed or
* implied warranties of any kind.
*
* Research Systems Unix Group
* The University of Michigan
* c/o Mike Clark
* 535 W. William Street
* Ann Arbor, Michigan
* +1-313-763-0525
* netatalk@itd.umich.edu
*/
#ifndef _NETATALK_AT_VAR_H_
#define _NETATALK_AT_VAR_H_ 1
/*
* For phase2, we need to keep not only our address on an interface,
* but also the legal networks on the interface.
*/
struct at_ifaddr {
struct ifaddr aa_ifa;
# define aa_ifp aa_ifa.ifa_ifp
#ifdef BSD4_4
struct sockaddr_at aa_addr;
struct sockaddr_at aa_broadaddr;
struct sockaddr_at aa_netmask;
#else BSD4_4
# define aa_addr aa_ifa.ifa_addr
# define aa_broadaddr aa_ifa.ifa_broadaddr
# define aa_dstaddr aa_ifa.ifa_dstaddr
#endif BSD4_4
int aa_flags;
u_short aa_firstnet, aa_lastnet;
int aa_probcnt;
struct at_ifaddr *aa_next;
};
#ifdef BSD4_4
struct at_aliasreq {
char ifra_name[IFNAMSIZ]; /* if name, e.g. "en0" */
struct sockaddr_at ifra_addr;
struct sockaddr_at ifra_broadaddr;
#define ifra_dstaddr ifra_broadaddr
struct sockaddr_at ifra_mask;
};
#endif BSD4_4
#define AA_SAT(aa) \
((struct sockaddr_at *)&((struct at_ifaddr *)(aa))->aa_addr)
#define satosat(sa) ((struct sockaddr_at *)(sa))
#define AFA_ROUTE 0x0001
#define AFA_PROBING 0x0002
#define AFA_PHASE2 0x0004
#ifdef KERNEL
struct at_ifaddr *at_ifaddr;
struct ifqueue atintrq1, atintrq2;
int atdebug;
#endif
#endif /* _NETATALK_AT_VAR_H_ */

133
sys/netatalk/ddp.h Normal file
View File

@ -0,0 +1,133 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of The University
* of Michigan not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. This software is supplied as is without expressed or
* implied warranties of any kind.
*
* Research Systems Unix Group
* The University of Michigan
* c/o Mike Clark
* 535 W. William Street
* Ann Arbor, Michigan
* +1-313-763-0525
* netatalk@itd.umich.edu
*/
#ifndef _NETATALK_DDP_H_
#define _NETATALK_DDP_H_ 1
/*
* <-1byte(8bits) ->
* +---------------+
* | 0 | hopc |len|
* +---------------+
* | len (cont) |
* +---------------+
* | |
* +- DDP csum -+
* | |
* +---------------+
* | |
* +- Dest NET -+
* | |
* +---------------+
* | |
* +- Src NET -+
* | |
* +---------------+
* | Dest NODE |
* +---------------+
* | Src NODE |
* +---------------+
* | Dest PORT |
* +---------------+
* | Src PORT |
* +---------------+
*
* On Apples, there is also a ddp_type field, after src_port. However,
* under this unix implementation, user level processes need to be able
* to set the ddp_type. In later revisions, the ddp_type may only be
* available in a raw_appletalk interface.
*/
struct elaphdr {
u_char el_dnode;
u_char el_snode;
u_char el_type;
};
#define SZ_ELAPHDR 3
#define ELAP_DDPSHORT 0x01
#define ELAP_DDPEXTEND 0x02
/*
* Extended DDP header. Includes sickness for dealing with arbitrary
* bitfields on a little-endian arch.
*/
struct ddpehdr {
union {
struct {
#if BYTE_ORDER == BIG_ENDIAN
unsigned dub_pad:2;
unsigned dub_hops:4;
unsigned dub_len:10;
unsigned dub_sum:16;
#endif
#if BYTE_ORDER == LITTLE_ENDIAN
unsigned dub_sum:16;
unsigned dub_len:10;
unsigned dub_hops:4;
unsigned dub_pad:2;
#endif
} du_bits;
unsigned du_bytes;
} deh_u;
#define deh_pad deh_u.du_bits.dub_pad
#define deh_hops deh_u.du_bits.dub_hops
#define deh_len deh_u.du_bits.dub_len
#define deh_sum deh_u.du_bits.dub_sum
#define deh_bytes deh_u.du_bytes
u_short deh_dnet;
u_short deh_snet;
u_char deh_dnode;
u_char deh_snode;
u_char deh_dport;
u_char deh_sport;
};
#define DDP_MAXHOPS 15
struct ddpshdr {
union {
struct {
#if BYTE_ORDER == BIG_ENDIAN
unsigned dub_pad:6;
unsigned dub_len:10;
unsigned dub_dport:8;
unsigned dub_sport:8;
#endif
#if BYTE_ORDER == LITTLE_ENDIAN
unsigned dub_sport:8;
unsigned dub_dport:8;
unsigned dub_len:10;
unsigned dub_pad:6;
#endif
} du_bits;
unsigned du_bytes;
} dsh_u;
#define dsh_pad dsh_u.du_bits.dub_pad
#define dsh_len dsh_u.du_bits.dub_len
#define dsh_dport dsh_u.du_bits.dub_dport
#define dsh_sport dsh_u.du_bits.dub_sport
#define dsh_bytes dsh_u.du_bytes
};
#endif /* _NETATALK_DDP_H_ */

413
sys/netatalk/ddp_input.c Normal file
View File

@ -0,0 +1,413 @@
/*
* Copyright (c) 1990,1994 Regents of The University of Michigan.
* All Rights Reserved. See COPYRIGHT.
*/
#include <sys/types.h>
#include <sys/param.h>
#if defined( __FreeBSD__ )
#include <sys/systm.h>
#include <sys/kernel.h>
#include <net/netisr.h>
#endif __FreeBSD__
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/syslog.h>
#include <net/if.h>
#include <net/route.h>
#ifdef _IBMR2
#include <net/spl.h>
#endif _IBMR2
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include "at.h"
#include "at_var.h"
#include "endian.h"
#include "ddp.h"
#include "ddp_var.h"
#include <netatalk/at_extern.h>
int ddp_forward = 1;
int ddp_firewall = 0;
extern int ddp_cksum;
void ddp_input( struct mbuf *, struct ifnet *, struct elaphdr *, int );
/*
* Could probably merge these two code segments a little better...
*/
static void
atintr( void )
{
struct elaphdr *elhp, elh;
struct ifnet *ifp;
struct mbuf *m;
struct at_ifaddr *aa;
int s;
for (;;) {
#ifndef _IBMR2
s = splimp();
#endif _IBMR2
#ifdef BSD4_4
IF_DEQUEUE( &atintrq2, m );
#else BSD4_4
IF_DEQUEUEIF( &atintrq2, m, ifp );
#endif BSD4_4
#ifndef _IBMR2
splx( s );
#endif _IBMR2
if ( m == 0 ) { /* no more queued packets */
break;
}
#ifdef BSD4_4
ifp = m->m_pkthdr.rcvif;
#endif BSD4_4
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 )) {
break;
}
}
if ( aa == NULL ) { /* ifp not an appletalk interface */
m_freem( m );
continue;
}
ddp_input( m, ifp, (struct elaphdr *)NULL, 2 );
}
for (;;) {
#ifndef _IBMR2
s = splimp();
#endif _IBMR2
#ifdef BSD4_4
IF_DEQUEUE( &atintrq1, m );
#else BSD4_4
IF_DEQUEUEIF( &atintrq1, m, ifp );
#endif BSD4_4
#ifndef _IBMR2
splx( s );
#endif _IBMR2
if ( m == 0 ) { /* no more queued packets */
break;
}
#ifdef BSD4_4
ifp = m->m_pkthdr.rcvif;
#endif BSD4_4
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
break;
}
}
if ( aa == NULL ) { /* ifp not an appletalk interface */
m_freem( m );
continue;
}
if ( m->m_len < SZ_ELAPHDR &&
(( m = m_pullup( m, SZ_ELAPHDR )) == 0 )) {
ddpstat.ddps_tooshort++;
continue;
}
elhp = mtod( m, struct elaphdr *);
m_adj( m, SZ_ELAPHDR );
if ( elhp->el_type == ELAP_DDPEXTEND ) {
ddp_input( m, ifp, (struct elaphdr *)NULL, 1 );
} else {
bcopy((caddr_t)elhp, (caddr_t)&elh, SZ_ELAPHDR );
ddp_input( m, ifp, &elh, 1 );
}
}
return;
}
#if defined( __FreeBSD__ )
NETISR_SET(NETISR_ATALK, atintr);
#endif __FreeBSD__
struct route forwro;
void
ddp_input( m, ifp, elh, phase )
struct mbuf *m;
struct ifnet *ifp;
struct elaphdr *elh;
int phase;
{
struct sockaddr_at from, to;
struct ddpshdr *dsh, ddps;
struct at_ifaddr *aa;
struct ddpehdr *deh, ddpe;
#ifndef BSD4_4
struct mbuf *mp;
#endif BSD4_4
struct ddpcb *ddp;
int dlen, mlen;
u_short cksum;
bzero( (caddr_t)&from, sizeof( struct sockaddr_at ));
if ( elh ) {
ddpstat.ddps_short++;
if ( m->m_len < sizeof( struct ddpshdr ) &&
(( m = m_pullup( m, sizeof( struct ddpshdr ))) == 0 )) {
ddpstat.ddps_tooshort++;
return;
}
dsh = mtod( m, struct ddpshdr *);
bcopy( (caddr_t)dsh, (caddr_t)&ddps, sizeof( struct ddpshdr ));
ddps.dsh_bytes = ntohl( ddps.dsh_bytes );
dlen = ddps.dsh_len;
to.sat_addr.s_net = ATADDR_ANYNET;
to.sat_addr.s_node = elh->el_dnode;
to.sat_port = ddps.dsh_dport;
from.sat_addr.s_net = ATADDR_ANYNET;
from.sat_addr.s_node = elh->el_snode;
from.sat_port = ddps.dsh_sport;
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( aa->aa_ifp == ifp && ( aa->aa_flags & AFA_PHASE2 ) == 0 &&
( AA_SAT( aa )->sat_addr.s_node == to.sat_addr.s_node ||
to.sat_addr.s_node == ATADDR_BCAST )) {
break;
}
}
if ( aa == NULL ) {
m_freem( m );
return;
}
} else {
ddpstat.ddps_long++;
if ( m->m_len < sizeof( struct ddpehdr ) &&
(( m = m_pullup( m, sizeof( struct ddpehdr ))) == 0 )) {
ddpstat.ddps_tooshort++;
return;
}
deh = mtod( m, struct ddpehdr *);
bcopy( (caddr_t)deh, (caddr_t)&ddpe, sizeof( struct ddpehdr ));
ddpe.deh_bytes = ntohl( ddpe.deh_bytes );
dlen = ddpe.deh_len;
if (( cksum = ddpe.deh_sum ) == 0 ) {
ddpstat.ddps_nosum++;
}
from.sat_addr.s_net = ddpe.deh_snet;
from.sat_addr.s_node = ddpe.deh_snode;
from.sat_port = ddpe.deh_sport;
to.sat_addr.s_net = ddpe.deh_dnet;
to.sat_addr.s_node = ddpe.deh_dnode;
to.sat_port = ddpe.deh_dport;
if ( to.sat_addr.s_net == ATADDR_ANYNET ) {
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( phase == 1 && ( aa->aa_flags & AFA_PHASE2 )) {
continue;
}
if ( phase == 2 && ( aa->aa_flags & AFA_PHASE2 ) == 0 ) {
continue;
}
if ( aa->aa_ifp == ifp &&
( AA_SAT( aa )->sat_addr.s_node == to.sat_addr.s_node ||
to.sat_addr.s_node == ATADDR_BCAST ||
( ifp->if_flags & IFF_LOOPBACK ))) {
break;
}
}
} else {
for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
if ( to.sat_addr.s_net == aa->aa_firstnet &&
to.sat_addr.s_node == 0 ) {
break;
}
if (( ntohs( to.sat_addr.s_net ) < ntohs( aa->aa_firstnet ) ||
ntohs( to.sat_addr.s_net ) > ntohs( aa->aa_lastnet )) &&
( ntohs( to.sat_addr.s_net ) < ntohs( 0xff00 ) ||
ntohs( to.sat_addr.s_net ) > ntohs( 0xfffe ))) {
continue;
}
if ( to.sat_addr.s_node != AA_SAT( aa )->sat_addr.s_node &&
to.sat_addr.s_node != ATADDR_BCAST ) {
continue;
}
break;
}
}
}
/*
* Adjust the length, removing any padding that may have been added
* at a link layer. We do this before we attempt to forward a packet,
* possibly on a different media.
*/
#ifdef BSD4_4
mlen = m->m_pkthdr.len;
#else BSD4_4
for ( mlen = 0, mp = m; mp; mp = mp->m_next ) {
mlen += mp->m_len;
}
#endif BSD4_4
if ( mlen < dlen ) {
ddpstat.ddps_toosmall++;
m_freem( m );
return;
}
if ( mlen > dlen ) {
m_adj( m, dlen - mlen );
}
/*
* XXX Should we deliver broadcasts locally, also, or rely on the
* link layer to give us a copy? For the moment, the latter.
*/
if ( aa == NULL || ( to.sat_addr.s_node == ATADDR_BCAST &&
aa->aa_ifp != ifp && ( ifp->if_flags & IFF_LOOPBACK ) == 0 )) {
if ( ddp_forward == 0 ) {
m_freem( m );
return;
}
if ( forwro.ro_rt && ( satosat( &forwro.ro_dst )->sat_addr.s_net !=
to.sat_addr.s_net ||
satosat( &forwro.ro_dst )->sat_addr.s_node !=
to.sat_addr.s_node )) {
#ifdef ultrix
rtfree( forwro.ro_rt );
#else ultrix
RTFREE( forwro.ro_rt );
#endif ultrix
forwro.ro_rt = (struct rtentry *)0;
}
if ( forwro.ro_rt == (struct rtentry *)0 ||
forwro.ro_rt->rt_ifp == (struct ifnet *)0 ) {
#ifdef BSD4_4
forwro.ro_dst.sa_len = sizeof( struct sockaddr_at );
#endif BSD4_4
forwro.ro_dst.sa_family = AF_APPLETALK;
satosat( &forwro.ro_dst )->sat_addr.s_net = to.sat_addr.s_net;
satosat( &forwro.ro_dst )->sat_addr.s_node = to.sat_addr.s_node;
rtalloc( &forwro );
}
if ( to.sat_addr.s_net != satosat( &forwro.ro_dst )->sat_addr.s_net &&
ddpe.deh_hops == DDP_MAXHOPS ) {
m_freem( m );
return;
}
if ( ddp_firewall &&
( forwro.ro_rt == NULL || forwro.ro_rt->rt_ifp != ifp )) {
m_freem( m );
return;
}
ddpe.deh_hops++;
ddpe.deh_bytes = htonl( ddpe.deh_bytes );
bcopy( (caddr_t)&ddpe, (caddr_t)deh, sizeof( u_short )); /* XXX deh? */
if ( ddp_route( m, &forwro )) {
ddpstat.ddps_cantforward++;
} else {
ddpstat.ddps_forward++;
}
return;
}
#ifdef BSD4_4
from.sat_len = sizeof( struct sockaddr_at );
#endif BSD4_4
from.sat_family = AF_APPLETALK;
if ( elh ) {
m_adj( m, sizeof( struct ddpshdr ));
} else {
if ( ddp_cksum && cksum && cksum != at_cksum( m, sizeof( int ))) {
ddpstat.ddps_badsum++;
m_freem( m );
return;
}
m_adj( m, sizeof( struct ddpehdr ));
}
if (( ddp = ddp_search( &from, &to, aa )) == NULL ) {
m_freem( m );
return;
}
if ( sbappendaddr( &ddp->ddp_socket->so_rcv, (struct sockaddr *)&from,
m, (struct mbuf *)0 ) == 0 ) {
ddpstat.ddps_nosockspace++;
m_freem( m );
return;
}
sorwakeup( ddp->ddp_socket );
}
#define BPXLEN 48
#define BPALEN 16
#include <ctype.h>
char hexdig[] = "0123456789ABCDEF";
static void
bprint( char *data, int len )
{
char xout[ BPXLEN ], aout[ BPALEN ];
int i = 0;
bzero( xout, BPXLEN );
bzero( aout, BPALEN );
for ( ;; ) {
if ( len < 1 ) {
if ( i != 0 ) {
printf( "%s\t%s\n", xout, aout );
}
printf( "%s\n", "(end)" );
break;
}
xout[ (i*3) ] = hexdig[ ( *data & 0xf0 ) >> 4 ];
xout[ (i*3) + 1 ] = hexdig[ *data & 0x0f ];
if ( (u_char)*data < 0x7f && (u_char)*data > 0x20 ) {
aout[ i ] = *data;
} else {
aout[ i ] = '.';
}
xout[ (i*3) + 2 ] = ' ';
i++;
len--;
data++;
if ( i > BPALEN - 2 ) {
printf( "%s\t%s\n", xout, aout );
bzero( xout, BPXLEN );
bzero( aout, BPALEN );
i = 0;
continue;
}
}
}
static void
m_printm( struct mbuf *m )
{
for (; m; m = m->m_next ) {
bprint( mtod( m, char * ), m->m_len );
}
}

298
sys/netatalk/ddp_output.c Normal file
View File

@ -0,0 +1,298 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of The University
* of Michigan not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. This software is supplied as is without expressed or
* implied warranties of any kind.
*
* Research Systems Unix Group
* The University of Michigan
* c/o Mike Clark
* 535 W. William Street
* Ann Arbor, Michigan
* +1-313-763-0525
* netatalk@itd.umich.edu
*/
#include <sys/types.h>
#include <sys/param.h>
#if defined( __FreeBSD__ )
#include <sys/systm.h>
#endif __FreeBSD__
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/errno.h>
#include <sys/syslog.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#undef s_net
#include <netinet/if_ether.h>
#include "at.h"
#include "at_var.h"
#include "endian.h"
#include "ddp.h"
#include "ddp_var.h"
#include <netatalk/at_extern.h>
int ddp_cksum = 1;
int
ddp_output( struct ddpcb *ddp, struct mbuf *m)
{
#ifndef BSD4_4
struct mbuf *m0;
int len;
#endif BSD4_4
struct ifnet *ifp;
struct at_ifaddr *aa = NULL;
struct ddpehdr *deh;
u_short net;
#ifdef BSD4_4
M_PREPEND( m, sizeof( struct ddpehdr ), M_WAIT );
#else BSD4_4
for ( len = 0, m0 = m; m; m = m->m_next ) {
len += m->m_len;
}
MGET( m, M_WAIT, MT_HEADER );
if ( m == 0 ) {
m_freem( m0 );
return( ENOBUFS );
}
m->m_next = m0;
#endif BSD4_4
#ifndef BSD4_4
# define align(a) (((a)+3)&0xfc)
m->m_off = MMINOFF + align( SZ_ELAPHDR );
m->m_len = sizeof( struct ddpehdr );
#endif BSD4_4
deh = mtod( m, struct ddpehdr *);
deh->deh_pad = 0;
deh->deh_hops = 0;
#ifdef BSD4_4
deh->deh_len = m->m_pkthdr.len;
#else BSD4_4
deh->deh_len = len + sizeof( struct ddpehdr );
#endif BSD4_4
deh->deh_dnet = ddp->ddp_fsat.sat_addr.s_net;
deh->deh_dnode = ddp->ddp_fsat.sat_addr.s_node;
deh->deh_dport = ddp->ddp_fsat.sat_port;
deh->deh_snet = ddp->ddp_lsat.sat_addr.s_net;
deh->deh_snode = ddp->ddp_lsat.sat_addr.s_node;
deh->deh_sport = ddp->ddp_lsat.sat_port;
/*
* 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 ));
} else {
deh->deh_sum = 0;
}
deh->deh_bytes = htonl( deh->deh_bytes );
return( ddp_route( m, &ddp->ddp_route ));
}
u_short
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 ) {
skip--;
continue;
}
cksum = ( cksum + *data ) << 1;
if ( cksum & 0x00010000 ) {
cksum++;
}
cksum &= 0x0000ffff;
}
}
if ( cksum == 0 ) {
cksum = 0x0000ffff;
}
return( (u_short)cksum );
}
int
ddp_route( struct mbuf *m, struct route *ro)
{
struct sockaddr_at gate;
struct elaphdr *elh;
struct mbuf *m0;
struct at_ifaddr *aa = NULL;
struct ifnet *ifp = NULL;
int mlen;
u_short net;
if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
#ifdef BSD4_4
net = satosat( ro->ro_rt->rt_gateway )->sat_addr.s_net;
#else BSD4_4
net = satosat( &ro->ro_rt->rt_gateway )->sat_addr.s_net;
#endif BSD4_4
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 ) {
printf( "ddp_route: oops\n" );
m_freem( m );
return( EINVAL );
}
/*
* There are several places in the kernel where data is added to
* an mbuf without ensuring that the mbuf pointer is aligned.
* 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 ) {
#if defined( __FreeBSD__ )
/* XXX don't need this because we can change if_ethersubr.c */
#else
for ( mlen = 0, m0 = m; m0; m0 = m0->m_next ) {
mlen += m0->m_len;
}
#ifndef MIN
#define MIN(x,y) ((x)<(y)?(x):(y))
#endif
if (( m = m_pullup( m, MIN( MLEN, mlen ))) == 0 ) {
printf("ddp_route: m_pullup of %d (mlen=%d) failed\n",
MIN( MLEN, mlen ), mlen);
return( ENOBUFS );
}
#endif __FreeBSD__
} else {
# ifdef notdef
#ifdef BSD4_4
M_PREPEND( m, SZ_ELAPHDR, M_DONTWAIT );
if ( m == NULL ) {
return( ENOBUFS );
}
#else BSD4_4
m->m_off -= SZ_ELAPHDR;
m->m_len += SZ_ELAPHDR;
#endif BSD4_4
# endif notdef
MGET( m0, M_WAIT, MT_HEADER );
if ( m0 == 0 ) {
m_freem( m );
printf("ddp_route: no buffers\n");
return( ENOBUFS );
}
m0->m_next = m;
#ifndef BSD4_4
m0->m_off = MMINOFF + align( sizeof( struct ether_header ));
#else
/* XXX perhaps we ought to align the header? */
#endif BSD4_4
m0->m_len = SZ_ELAPHDR;
m = m0;
elh = mtod( m, struct elaphdr *);
elh->el_snode = satosat( &aa->aa_addr )->sat_addr.s_node;
elh->el_type = ELAP_DDPEXTEND;
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 )) {
elh->el_dnode = satosat( &ro->ro_dst )->sat_addr.s_node;
} else {
#ifdef BSD4_4
elh->el_dnode = satosat( ro->ro_rt->rt_gateway )->sat_addr.s_node;
#else BSD4_4
elh->el_dnode = satosat( &ro->ro_rt->rt_gateway )->sat_addr.s_node;
#endif BSD4_4
}
}
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 {
#ifdef BSD4_4
gate = *satosat( ro->ro_rt->rt_gateway );
#else BSD4_4
gate = *satosat( &ro->ro_rt->rt_gateway );
#endif BSD4_4
}
ro->ro_rt->rt_use++;
#ifdef ultrix
/*
* SAIEW: We can't make changes to net/if_loop.c, so we don't route
* further than this: if it's going to go through the lookback,
* short-circuit to ddp_input(). Who needs queuing?
*
* Note: Passing NULL for the elaphdr is cool, since we'll only ever
* try to send long form ddp throught the loopback.
*/
if ( ifp->if_flags & IFF_LOOPBACK ) {
#ifdef notdef
m->m_off += SZ_ELAPHDR;
m->m_len -= SZ_ELAPHDR;
#endif notdef
ddp_input( m, ifp, (struct elaphdr *)NULL, 2 );
return( 0 );
}
#endif ultrix
#ifdef _IBMR2
/*
* We can't make changes to the interface routines on RS6ks, and
* they don't provide hooks for if_output, so we just resolve
* our address here, and pass the packet as a raw ethernet packet.
* This doesn't work particularly well, if we aren't *on* ethernet,
* but it's ok for the moment.
*/
if ( ! ( ifp->if_flags & IFF_LOOPBACK )) {
struct ether_header eh;
if ( !aarpresolve(( struct arpcom *)ifp, m,
&gate, eh.ether_dhost )) {
return( 0 );
}
eh.ether_type = htons( ETHERTYPE_AT );
gate.sat_family = AF_UNSPEC;
bcopy( &eh, (*(struct sockaddr *)&gate).sa_data,
sizeof( (*(struct sockaddr *)&gate).sa_data ));
}
#endif _IBMR2
return((*ifp->if_output)( ifp, m, &gate
#if defined( __FreeBSD__ )
, NULL /* XXX */
#endif __FreeBSD__
));
}

582
sys/netatalk/ddp_pcb.c Normal file
View File

@ -0,0 +1,582 @@
/*
* Copyright (c) 1990,1994 Regents of The University of Michigan.
* All Rights Reserved. See COPYRIGHT.
*/
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#if defined( __FreeBSD__ )
#include <sys/proc.h>
#endif __FreeBSD__
#ifdef ibm032
#include <sys/dir.h>
#endif ibm032
#ifndef __FreeBSD__
#include <sys/user.h>
#endif
#include <sys/mbuf.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#ifdef _IBMR2
#include <net/spl.h>
#endif _IBMR2
#include "at.h"
#include "at_var.h"
#include "ddp_var.h"
#include "aarp.h"
#include "endian.h"
#include <netatalk/at_extern.h>
static void at_pcbdisconnect( struct ddpcb *ddp );
static void at_sockaddr( struct ddpcb *ddp, struct mbuf *addr );
static int at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
static int at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
static void at_pcbdetach( struct socket *so, struct ddpcb *ddp);
static int at_pcballoc( struct socket *so );
struct ddpcb *ddp_ports[ ATPORT_LAST ];
struct ddpcb *ddpcb = NULL;
u_long ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
u_long ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
/*ARGSUSED*/
int
ddp_usrreq( struct socket *so, int req, struct mbuf *m,
struct mbuf *addr, struct mbuf *rights)
{
#if defined( __FreeBSD__ )
struct proc *p = curproc; /* XXX */
#endif __FreeBSD__
struct ddpcb *ddp;
int error = 0;
ddp = sotoddpcb( so );
if ( req == PRU_CONTROL ) {
return( at_control( (int) m, (caddr_t) addr,
(struct ifnet *) rights
#if defined( __FreeBSD__ )
, (struct proc *)p
#endif __FreeBSD__
));
}
if ( rights && rights->m_len ) {
error = EINVAL;
goto release;
}
if ( ddp == NULL && req != PRU_ATTACH ) {
error = EINVAL;
goto release;
}
switch ( req ) {
case PRU_ATTACH :
if ( ddp != NULL ) {
error = EINVAL;
break;
}
if (( error = at_pcballoc( so )) != 0 ) {
break;
}
error = soreserve( so, ddp_sendspace, ddp_recvspace );
break;
case PRU_DETACH :
at_pcbdetach( so, ddp );
break;
case PRU_BIND :
error = at_pcbsetaddr( ddp, addr
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
);
break;
case PRU_SOCKADDR :
at_sockaddr( ddp, addr );
break;
case PRU_CONNECT:
if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
error = EISCONN;
break;
}
error = at_pcbconnect( ddp, addr
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
);
if ( error == 0 )
soisconnected( so );
break;
case PRU_DISCONNECT:
if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
error = ENOTCONN;
break;
}
at_pcbdisconnect( ddp );
soisdisconnected( so );
break;
case PRU_SHUTDOWN:
socantsendmore( so );
break;
case PRU_SEND: {
int s = 0;
if ( addr ) {
if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
error = EISCONN;
break;
}
s = splnet();
error = at_pcbconnect( ddp, addr
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
);
if ( error ) {
splx( s );
break;
}
} else {
if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
error = ENOTCONN;
break;
}
}
error = ddp_output( ddp, m );
m = NULL;
if ( addr ) {
at_pcbdisconnect( ddp );
splx( s );
}
}
break;
case PRU_ABORT:
soisdisconnected( so );
at_pcbdetach( so, ddp );
break;
case PRU_LISTEN:
case PRU_CONNECT2:
case PRU_ACCEPT:
case PRU_SENDOOB:
case PRU_FASTTIMO:
case PRU_SLOWTIMO:
case PRU_PROTORCV:
case PRU_PROTOSEND:
error = EOPNOTSUPP;
break;
case PRU_RCVD:
case PRU_RCVOOB:
/*
* Don't mfree. Good architecture...
*/
return( EOPNOTSUPP );
case PRU_SENSE:
/*
* 1. Don't return block size.
* 2. Don't mfree.
*/
return( 0 );
default:
error = EOPNOTSUPP;
}
release:
if ( m != NULL ) {
m_freem( m );
}
return( error );
}
static void
at_sockaddr( struct ddpcb *ddp, struct mbuf *addr)
{
struct sockaddr_at *sat;
addr->m_len = sizeof( struct sockaddr_at );
sat = mtod( addr, struct sockaddr_at *);
*sat = ddp->ddp_lsat;
}
static int
at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p )
{
struct sockaddr_at lsat, *sat;
struct at_ifaddr *aa;
struct ddpcb *ddpp;
if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
return( EINVAL );
}
if ( addr != 0 ) { /* validate passed address */
sat = mtod( addr, struct sockaddr_at *);
if ( addr->m_len != sizeof( *sat )) {
return( EINVAL );
}
if ( sat->sat_family != AF_APPLETALK ) {
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 )) {
break;
}
}
if ( !aa ) {
return( EADDRNOTAVAIL );
}
}
if ( sat->sat_port != ATADDR_ANYPORT ) {
if ( sat->sat_port < ATPORT_FIRST ||
sat->sat_port >= ATPORT_LAST ) {
return( EINVAL );
}
#ifdef BSD4_4
if ( sat->sat_port < ATPORT_RESERVED &&
#if defined( __FreeBSD__ )
suser( p->p_ucred, &p->p_acflag )
#else
suser( u.u_cred, &u.u_acflag )
#endif __FreeBSD__
) {
return( EACCES );
}
#else BSD4_4
if ( sat->sat_port < ATPORT_RESERVED && ( !suser())) {
return( EACCES );
}
#endif BSD4_4
}
} else {
bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
#ifdef BSD4_4
lsat.sat_len = sizeof(struct sockaddr_at);
lsat.sat_addr.s_node = ATADDR_ANYNODE;
lsat.sat_addr.s_net = ATADDR_ANYNET;
#endif BSD4_4
lsat.sat_family = AF_APPLETALK;
sat = &lsat;
}
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;
}
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 ] == 0 ) {
break;
}
}
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 ) {
break;
}
}
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 ) {
ddp->ddp_pnext->ddp_pprev = ddp;
}
}
return( 0 );
}
static int
at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p)
{
struct sockaddr_at *sat = mtod( addr, struct sockaddr_at *);
struct route *ro;
struct at_ifaddr *aa = 0;
struct ifnet *ifp;
u_short hintnet = 0, net;
if ( addr->m_len != sizeof( *sat ))
return( EINVAL );
if ( sat->sat_family != AF_APPLETALK ) {
return( EAFNOSUPPORT );
}
/*
* Under phase 2, network 0 means "the network". We take "the
* 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 );
}
hintnet = ddp->ddp_lsat.sat_addr.s_net;
}
ro = &ddp->ddp_route;
/*
* If we've got an old route for this pcb, check that it is valid.
* 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 ) {
net = hintnet;
} else {
net = sat->sat_addr.s_net;
}
aa = 0;
if ( ifp = ro->ro_rt->rt_ifp ) {
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 )) {
printf("at_pcbconnect: found ifp net=%u\n", ntohs(net));
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 )) {
printf("at_pcbconnect: freeing ro->ro_rt=0x%x\n", ro->ro_rt);
#ifdef ultrix
rtfree( ro->ro_rt );
#else ultrix
RTFREE( ro->ro_rt );
#endif ultrix
ro->ro_rt = (struct rtentry *)0;
}
}
/*
* If we've got no route for this interface, try to find one.
*/
if ( ro->ro_rt == (struct rtentry *)0 ||
ro->ro_rt->rt_ifp == (struct ifnet *)0 ) {
#ifdef BSD4_4
ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
#endif BSD4_4
ro->ro_dst.sa_family = AF_APPLETALK;
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_node = sat->sat_addr.s_node;
rtalloc( ro );
}
/*
* Make sure any route that we have has a valid interface.
*/
aa = 0;
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 == 0 ) {
printf("at_pcbconnect: ro->ro_rt=0x%x\n", ro->ro_rt);
if (ro->ro_rt)
printf("at_pcbconnect: ro->ro_rt->rt_ifp=0x%x", ro->ro_rt->rt_ifp);
return( ENETUNREACH );
}
ddp->ddp_fsat = *sat;
if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
return( at_pcbsetaddr( ddp, (struct mbuf *)0
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
));
}
return( 0 );
}
static void
at_pcbdisconnect( struct ddpcb *ddp )
{
ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
}
static int
at_pcballoc( struct socket *so )
{
struct ddpcb *ddp;
struct mbuf *m;
m = m_getclr( M_WAIT, MT_PCB );
ddp = mtod( m, struct ddpcb * );
ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
ddp->ddp_next = ddpcb;
ddp->ddp_prev = NULL;
ddp->ddp_pprev = NULL;
ddp->ddp_pnext = NULL;
if ( ddpcb ) {
ddpcb->ddp_prev = ddp;
}
ddpcb = ddp;
ddp->ddp_socket = so;
so->so_pcb = (caddr_t)ddp;
return( 0 );
}
static void
at_pcbdetach( struct socket *so, struct ddpcb *ddp)
{
soisdisconnected( so );
so->so_pcb = 0;
sofree( 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 ) {
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 ) {
ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
}
}
if ( ddp->ddp_route.ro_rt ) {
rtfree( ddp->ddp_route.ro_rt );
}
if ( ddp->ddp_prev ) {
ddp->ddp_prev->ddp_next = ddp->ddp_next;
} else {
ddpcb = ddp->ddp_next;
}
if ( ddp->ddp_next ) {
ddp->ddp_next->ddp_prev = ddp->ddp_prev;
}
(void) m_free( dtom( ddp ));
}
/*
* For the moment, this just find the pcb with the correct local address.
* In the future, this will actually do some real searching, so we can use
* the sender's address to do de-multiplexing on a single port to many
* sockets (pcbs).
*/
struct ddpcb *
ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
struct at_ifaddr *aa)
{
struct ddpcb *ddp;
/*
* Check for bad ports.
*/
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 ) {
/* 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 ) {
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 ) {
break;
}
/* XXXX.0 to socket on destination interface */
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 )) {
break;
}
}
return( ddp );
}
void
ddp_init(void )
{
atintrq1.ifq_maxlen = IFQ_MAXLEN;
atintrq2.ifq_maxlen = IFQ_MAXLEN;
}
static void
ddp_clean(void )
{
struct ddpcb *ddp;
for ( ddp = ddpcb; ddp; ddp = ddp->ddp_next ) {
at_pcbdetach( ddp->ddp_socket, ddp );
}
}

582
sys/netatalk/ddp_usrreq.c Normal file
View File

@ -0,0 +1,582 @@
/*
* Copyright (c) 1990,1994 Regents of The University of Michigan.
* All Rights Reserved. See COPYRIGHT.
*/
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#if defined( __FreeBSD__ )
#include <sys/proc.h>
#endif __FreeBSD__
#ifdef ibm032
#include <sys/dir.h>
#endif ibm032
#ifndef __FreeBSD__
#include <sys/user.h>
#endif
#include <sys/mbuf.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <net/if.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#ifdef _IBMR2
#include <net/spl.h>
#endif _IBMR2
#include "at.h"
#include "at_var.h"
#include "ddp_var.h"
#include "aarp.h"
#include "endian.h"
#include <netatalk/at_extern.h>
static void at_pcbdisconnect( struct ddpcb *ddp );
static void at_sockaddr( struct ddpcb *ddp, struct mbuf *addr );
static int at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
static int at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
static void at_pcbdetach( struct socket *so, struct ddpcb *ddp);
static int at_pcballoc( struct socket *so );
struct ddpcb *ddp_ports[ ATPORT_LAST ];
struct ddpcb *ddpcb = NULL;
u_long ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
u_long ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
/*ARGSUSED*/
int
ddp_usrreq( struct socket *so, int req, struct mbuf *m,
struct mbuf *addr, struct mbuf *rights)
{
#if defined( __FreeBSD__ )
struct proc *p = curproc; /* XXX */
#endif __FreeBSD__
struct ddpcb *ddp;
int error = 0;
ddp = sotoddpcb( so );
if ( req == PRU_CONTROL ) {
return( at_control( (int) m, (caddr_t) addr,
(struct ifnet *) rights
#if defined( __FreeBSD__ )
, (struct proc *)p
#endif __FreeBSD__
));
}
if ( rights && rights->m_len ) {
error = EINVAL;
goto release;
}
if ( ddp == NULL && req != PRU_ATTACH ) {
error = EINVAL;
goto release;
}
switch ( req ) {
case PRU_ATTACH :
if ( ddp != NULL ) {
error = EINVAL;
break;
}
if (( error = at_pcballoc( so )) != 0 ) {
break;
}
error = soreserve( so, ddp_sendspace, ddp_recvspace );
break;
case PRU_DETACH :
at_pcbdetach( so, ddp );
break;
case PRU_BIND :
error = at_pcbsetaddr( ddp, addr
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
);
break;
case PRU_SOCKADDR :
at_sockaddr( ddp, addr );
break;
case PRU_CONNECT:
if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
error = EISCONN;
break;
}
error = at_pcbconnect( ddp, addr
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
);
if ( error == 0 )
soisconnected( so );
break;
case PRU_DISCONNECT:
if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
error = ENOTCONN;
break;
}
at_pcbdisconnect( ddp );
soisdisconnected( so );
break;
case PRU_SHUTDOWN:
socantsendmore( so );
break;
case PRU_SEND: {
int s = 0;
if ( addr ) {
if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
error = EISCONN;
break;
}
s = splnet();
error = at_pcbconnect( ddp, addr
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
);
if ( error ) {
splx( s );
break;
}
} else {
if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
error = ENOTCONN;
break;
}
}
error = ddp_output( ddp, m );
m = NULL;
if ( addr ) {
at_pcbdisconnect( ddp );
splx( s );
}
}
break;
case PRU_ABORT:
soisdisconnected( so );
at_pcbdetach( so, ddp );
break;
case PRU_LISTEN:
case PRU_CONNECT2:
case PRU_ACCEPT:
case PRU_SENDOOB:
case PRU_FASTTIMO:
case PRU_SLOWTIMO:
case PRU_PROTORCV:
case PRU_PROTOSEND:
error = EOPNOTSUPP;
break;
case PRU_RCVD:
case PRU_RCVOOB:
/*
* Don't mfree. Good architecture...
*/
return( EOPNOTSUPP );
case PRU_SENSE:
/*
* 1. Don't return block size.
* 2. Don't mfree.
*/
return( 0 );
default:
error = EOPNOTSUPP;
}
release:
if ( m != NULL ) {
m_freem( m );
}
return( error );
}
static void
at_sockaddr( struct ddpcb *ddp, struct mbuf *addr)
{
struct sockaddr_at *sat;
addr->m_len = sizeof( struct sockaddr_at );
sat = mtod( addr, struct sockaddr_at *);
*sat = ddp->ddp_lsat;
}
static int
at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p )
{
struct sockaddr_at lsat, *sat;
struct at_ifaddr *aa;
struct ddpcb *ddpp;
if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
return( EINVAL );
}
if ( addr != 0 ) { /* validate passed address */
sat = mtod( addr, struct sockaddr_at *);
if ( addr->m_len != sizeof( *sat )) {
return( EINVAL );
}
if ( sat->sat_family != AF_APPLETALK ) {
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 )) {
break;
}
}
if ( !aa ) {
return( EADDRNOTAVAIL );
}
}
if ( sat->sat_port != ATADDR_ANYPORT ) {
if ( sat->sat_port < ATPORT_FIRST ||
sat->sat_port >= ATPORT_LAST ) {
return( EINVAL );
}
#ifdef BSD4_4
if ( sat->sat_port < ATPORT_RESERVED &&
#if defined( __FreeBSD__ )
suser( p->p_ucred, &p->p_acflag )
#else
suser( u.u_cred, &u.u_acflag )
#endif __FreeBSD__
) {
return( EACCES );
}
#else BSD4_4
if ( sat->sat_port < ATPORT_RESERVED && ( !suser())) {
return( EACCES );
}
#endif BSD4_4
}
} else {
bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
#ifdef BSD4_4
lsat.sat_len = sizeof(struct sockaddr_at);
lsat.sat_addr.s_node = ATADDR_ANYNODE;
lsat.sat_addr.s_net = ATADDR_ANYNET;
#endif BSD4_4
lsat.sat_family = AF_APPLETALK;
sat = &lsat;
}
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;
}
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 ] == 0 ) {
break;
}
}
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 ) {
break;
}
}
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 ) {
ddp->ddp_pnext->ddp_pprev = ddp;
}
}
return( 0 );
}
static int
at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p)
{
struct sockaddr_at *sat = mtod( addr, struct sockaddr_at *);
struct route *ro;
struct at_ifaddr *aa = 0;
struct ifnet *ifp;
u_short hintnet = 0, net;
if ( addr->m_len != sizeof( *sat ))
return( EINVAL );
if ( sat->sat_family != AF_APPLETALK ) {
return( EAFNOSUPPORT );
}
/*
* Under phase 2, network 0 means "the network". We take "the
* 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 );
}
hintnet = ddp->ddp_lsat.sat_addr.s_net;
}
ro = &ddp->ddp_route;
/*
* If we've got an old route for this pcb, check that it is valid.
* 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 ) {
net = hintnet;
} else {
net = sat->sat_addr.s_net;
}
aa = 0;
if ( ifp = ro->ro_rt->rt_ifp ) {
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 )) {
printf("at_pcbconnect: found ifp net=%u\n", ntohs(net));
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 )) {
printf("at_pcbconnect: freeing ro->ro_rt=0x%x\n", ro->ro_rt);
#ifdef ultrix
rtfree( ro->ro_rt );
#else ultrix
RTFREE( ro->ro_rt );
#endif ultrix
ro->ro_rt = (struct rtentry *)0;
}
}
/*
* If we've got no route for this interface, try to find one.
*/
if ( ro->ro_rt == (struct rtentry *)0 ||
ro->ro_rt->rt_ifp == (struct ifnet *)0 ) {
#ifdef BSD4_4
ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
#endif BSD4_4
ro->ro_dst.sa_family = AF_APPLETALK;
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_node = sat->sat_addr.s_node;
rtalloc( ro );
}
/*
* Make sure any route that we have has a valid interface.
*/
aa = 0;
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 == 0 ) {
printf("at_pcbconnect: ro->ro_rt=0x%x\n", ro->ro_rt);
if (ro->ro_rt)
printf("at_pcbconnect: ro->ro_rt->rt_ifp=0x%x", ro->ro_rt->rt_ifp);
return( ENETUNREACH );
}
ddp->ddp_fsat = *sat;
if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
return( at_pcbsetaddr( ddp, (struct mbuf *)0
#if defined( __FreeBSD__ )
, p
#endif __FreeBSD__
));
}
return( 0 );
}
static void
at_pcbdisconnect( struct ddpcb *ddp )
{
ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
}
static int
at_pcballoc( struct socket *so )
{
struct ddpcb *ddp;
struct mbuf *m;
m = m_getclr( M_WAIT, MT_PCB );
ddp = mtod( m, struct ddpcb * );
ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
ddp->ddp_next = ddpcb;
ddp->ddp_prev = NULL;
ddp->ddp_pprev = NULL;
ddp->ddp_pnext = NULL;
if ( ddpcb ) {
ddpcb->ddp_prev = ddp;
}
ddpcb = ddp;
ddp->ddp_socket = so;
so->so_pcb = (caddr_t)ddp;
return( 0 );
}
static void
at_pcbdetach( struct socket *so, struct ddpcb *ddp)
{
soisdisconnected( so );
so->so_pcb = 0;
sofree( 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 ) {
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 ) {
ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
}
}
if ( ddp->ddp_route.ro_rt ) {
rtfree( ddp->ddp_route.ro_rt );
}
if ( ddp->ddp_prev ) {
ddp->ddp_prev->ddp_next = ddp->ddp_next;
} else {
ddpcb = ddp->ddp_next;
}
if ( ddp->ddp_next ) {
ddp->ddp_next->ddp_prev = ddp->ddp_prev;
}
(void) m_free( dtom( ddp ));
}
/*
* For the moment, this just find the pcb with the correct local address.
* In the future, this will actually do some real searching, so we can use
* the sender's address to do de-multiplexing on a single port to many
* sockets (pcbs).
*/
struct ddpcb *
ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
struct at_ifaddr *aa)
{
struct ddpcb *ddp;
/*
* Check for bad ports.
*/
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 ) {
/* 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 ) {
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 ) {
break;
}
/* XXXX.0 to socket on destination interface */
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 )) {
break;
}
}
return( ddp );
}
void
ddp_init(void )
{
atintrq1.ifq_maxlen = IFQ_MAXLEN;
atintrq2.ifq_maxlen = IFQ_MAXLEN;
}
static void
ddp_clean(void )
{
struct ddpcb *ddp;
for ( ddp = ddpcb; ddp; ddp = ddp->ddp_next ) {
at_pcbdetach( ddp->ddp_socket, ddp );
}
}

36
sys/netatalk/ddp_var.h Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (c) 1990,1994 Regents of The University of Michigan.
* All Rights Reserved. See COPYRIGHT.
*/
#ifndef _NETATALK_DDP_VAR_H_
#define _NETATALK_DDP_VAR_H_ 1
struct ddpcb {
struct sockaddr_at ddp_fsat, ddp_lsat;
struct route ddp_route;
struct socket *ddp_socket;
struct ddpcb *ddp_prev, *ddp_next;
struct ddpcb *ddp_pprev, *ddp_pnext;
};
#define sotoddpcb(so) ((struct ddpcb *)(so)->so_pcb)
struct ddpstat {
long ddps_short; /* short header packets received */
long ddps_long; /* long header packets received */
long ddps_nosum; /* no checksum */
long ddps_badsum; /* bad checksum */
long ddps_tooshort; /* packet too short */
long ddps_toosmall; /* not enough data */
long ddps_forward; /* packets forwarded */
long ddps_encap; /* packets encapsulated */
long ddps_cantforward; /* packets rcvd for unreachable dest */
long ddps_nosockspace; /* no space in sockbuf for packet */
};
#ifdef KERNEL
extern struct ddpcb *ddp_ports[ ];
extern struct ddpcb *ddpcb;
struct ddpstat ddpstat;
#endif
#endif /* _NETATALK_DDP_VAR_H_ */

87
sys/netatalk/endian.h Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appears in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation, and that the name of The University
* of Michigan not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. This software is supplied as is without expressed or
* implied warranties of any kind.
*
* Research Systems Unix Group
* The University of Michigan
* c/o Mike Clark
* 535 W. William Street
* Ann Arbor, Michigan
* +1-313-763-0525
* netatalk@itd.umich.edu
*/
# ifndef _ATALK_ENDIAN_H_
#define _ATALK_ENDIAN_H_
#ifdef _IBMR2
#include <sys/machine.h>
#endif _IBMR2
#ifdef linux
#include <bytesex.h>
#define BYTE_ORDER __BYTE_ORDER
#endif linux
#ifdef __FreeBSD__
#include <machine/endian.h>
#endif __FreeBSD__
# ifndef BYTE_ORDER
#define LITTLE_ENDIAN 1234
#define BIG_ENDIAN 4321
#define PDP_ENDIAN 3412
#ifdef sun
#ifdef i386
#define BYTE_ORDER LITTLE_ENDIAN
#else i386
#define BYTE_ORDER BIG_ENDIAN
#endif i386
#else
#ifdef MIPSEB
#define BYTE_ORDER BIG_ENDIAN
#else
#ifdef MIPSEL
#define BYTE_ORDER LITTLE_ENDIAN
#else
Like, what is your byte order, man?
#endif MIPSEL
#endif MIPSEB
#endif sun
# endif BYTE_ORDER
# ifndef ntohl
# if defined( sun ) || defined( ultrix ) || defined( _IBMR2 )
#if BYTE_ORDER == BIG_ENDIAN
#define ntohl(x) (x)
#define ntohs(x) (x)
#define htonl(x) (x)
#define htons(x) (x)
#else
#if defined( mips ) && defined( KERNEL )
#define ntohl(x) nuxi_l(x)
#define ntohs(x) nuxi_s(x)
#define htonl(x) nuxi_l(x)
#define htons(x) nuxi_s(x)
#else mips KERNEL
unsigned short ntohs(), htons();
unsigned long ntohl(), htonl();
#endif mips KERNEL
#endif BYTE_ORDER
# endif sun ultrix _IBMR2
# endif ntohl
# endif _ATALK_ENDIAN_H_

85
sys/netatalk/phase2.h Normal file
View File

@ -0,0 +1,85 @@
/*
* Copyright (c) 1990,1991 Regents of The University of Michigan.
* All Rights Reserved.
*/
# if defined( ultrix ) || defined( BSD4_4 )
#include <net/if_llc.h>
# if defined( __FreeBSD__ )
#define llc_org_code llc_un.type_snap.org_code
#define llc_ether_type llc_un.type_snap.ether_type
# endif __FreeBSD__
# else ultrix BSD4_4
#ifdef sun
#include <net/if_ieee802.h>
#endif sun
/*
* Copyright (c) 1988 Regents of the University of California.
* All rights reserved.
*
* @(#)if_llc.h 7.2 (Berkeley) 6/28/90
*/
/*
* IEEE 802.2 Link Level Control headers, for use in conjunction with
* 802.{3,4,5} media access control methods.
*
* Headers here do not use bit fields due to shortcommings in many
* compilers.
*/
struct llc {
u_char llc_dsap;
u_char llc_ssap;
union {
struct {
u_char control;
u_char format_id;
u_char class;
u_char window_x2;
} type_u;
struct {
u_char num_snd_x2;
u_char num_rcv_x2;
} type_i;
struct {
u_char control;
u_char num_rcv_x2;
} type_s;
struct {
u_char control;
u_char org_code[3];
u_short ether_type;
} type_snap;
} llc_un;
};
#define llc_control llc_un.type_u.control
#define llc_fid llc_un.type_u.format_id
#define llc_class llc_un.type_u.class
#define llc_window llc_un.type_u.window_x2
#define llc_org_code llc_un.type_snap.org_code
#define llc_ether_type llc_un.type_snap.ether_type
#define LLC_UI 0x3
#define LLC_UI_P 0x13
#define LLC_XID 0xaf
#define LLC_XID_P 0xbf
#define LLC_TEST 0xe3
#define LLC_TEST_P 0xf3
#define LLC_ISO_LSAP 0xfe
#define LLC_SNAP_LSAP 0xaa
# endif ultrix BSD4_4
#if defined( sun ) || defined( ibm032 )
#define SIOCPHASE1 _IOW(i, 100, struct ifreq) /* AppleTalk phase 1 */
#define SIOCPHASE2 _IOW(i, 101, struct ifreq) /* AppleTalk phase 2 */
#endif sun ibm032
#if defined( ultrix ) || defined( BSD4_4 ) || defined( _IBMR2 )
#define SIOCPHASE1 _IOW('i', 100, struct ifreq) /* AppleTalk phase 1 */
#define SIOCPHASE2 _IOW('i', 101, struct ifreq) /* AppleTalk phase 2 */
#endif ultrix BSD4_4 _IBMR2