[apple/xnu.git] / bsd / net / if_fddisubr.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1995, 1996
 *	Matt Thomas <matt@3am-software.com>.  All rights reserved.
 * Copyright (c) 1982, 1989, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS 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.
 *
 *	from: if_ethersubr.c,v 1.5 1994/12/13 22:31:45 wollman Exp
 */

#include "opt_atalk.h"
#include "opt_inet.h"
#include "opt_ipx.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/socket.h>

#include <net/if.h>
#include <net/netisr.h>
#include <net/route.h>
#include <net/if_llc.h>
#include <net/if_dl.h>
#include <net/if_types.h>

#if INET
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet/if_ether.h>
#endif
#if defined(__FreeBSD__)
#include <netinet/if_fddi.h>
#else
#include <net/if_fddi.h>
#endif

#if IPX
#include <netipx/ipx.h> 
#include <netipx/ipx_if.h>
#endif

#if DECNET
#include <netdnet/dn.h>
#endif

#include "bpfilter.h"

#define senderr(e) { error = (e); goto bad;}

/*
 * This really should be defined in if_llc.h but in case it isn't.
 */
#ifndef llc_snap
#define	llc_snap	llc_un.type_snap
#endif

#if defined(__bsdi__) || defined(__NetBSD__)
#define	RTALLOC1(a, b)			rtalloc1(a, b)
#define	ARPRESOLVE(a, b, c, d, e, f)	arpresolve(a, b, c, d, e)
#elif defined(__FreeBSD__)
#define	RTALLOC1(a, b)			rtalloc1(a, b, 0UL)
#define	ARPRESOLVE(a, b, c, d, e, f)	arpresolve(a, b, c, d, e, f)
#endif
/*
 * FDDI output routine.
 * Encapsulate a packet of type family for the local net.
 * Use trailer local net encapsulation if enough data in first
 * packet leaves a multiple of 512 bytes of data in remainder.
 * Assumes that ifp is actually pointer to arpcom structure.
 */
int
fddi_output(ifp, m0, dst, rt0)
	register struct ifnet *ifp;
	struct mbuf *m0;
	struct sockaddr *dst;
	struct rtentry *rt0;
{
	u_int16_t type;
	int s, loop_copy = 0, error = 0;
 	u_char edst[6];
	register struct mbuf *m = m0;
	register struct rtentry *rt;
	register struct fddi_header *fh;
	struct arpcom *ac = (struct arpcom *)ifp;

	if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
		senderr(ENETDOWN);
	getmicrotime(&ifp->if_lastchange);
#if !defined(__bsdi__) || _BSDI_VERSION >= 199401
	if (rt = rt0) {
		if ((rt->rt_flags & RTF_UP) == 0) {
			if (rt0 = rt = RTALLOC1(dst, 1))
				rtunref(rt);
			else 
				senderr(EHOSTUNREACH);
		}
		if (rt->rt_flags & RTF_GATEWAY) {
			if (rt->rt_gwroute == 0)
				goto lookup;
			if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
				rtfree(rt); rt = rt0;
			lookup: rt->rt_gwroute = RTALLOC1(rt->rt_gateway, 1);
				if ((rt = rt->rt_gwroute) == 0)
					senderr(EHOSTUNREACH);
			}
		}
		if (rt->rt_flags & RTF_REJECT)
			if (rt->rt_rmx.rmx_expire == 0 ||
			    time_second < rt->rt_rmx.rmx_expire)
				senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
	}
#endif
	switch (dst->sa_family) {

#if INET
	case AF_INET: {
#if !defined(__bsdi__) || _BSDI_VERSION >= 199401
		if (!ARPRESOLVE(ac, rt, m, dst, edst, rt0))
			return (0);	/* if not yet resolved */
#else
		int usetrailers;
		if (!arpresolve(ac, m, &((struct sockaddr_in *)dst)->sin_addr, edst, &usetrailers))
			return (0);	/* if not yet resolved */
#endif
		type = htons(ETHERTYPE_IP);
		break;
	}
#endif
#if IPX
	case AF_IPX:
		type = htons(ETHERTYPE_IPX);
 		bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
		    (caddr_t)edst, sizeof (edst));
		break;
#endif

#if NS
	case AF_NS:
		type = htons(ETHERTYPE_NS);
 		bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
		    (caddr_t)edst, sizeof (edst));
		break;
#endif
#if	ISO
	case AF_ISO: {
		int	snpalen;
		struct	llc *l;
		register struct sockaddr_dl *sdl;

		if (rt && (sdl = (struct sockaddr_dl *)rt->rt_gateway) &&
		    sdl->sdl_family == AF_LINK && sdl->sdl_alen > 0) {
			bcopy(LLADDR(sdl), (caddr_t)edst, sizeof(edst));
		} else if (error =
			    iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
					    (char *)edst, &snpalen))
			goto bad; /* Not Resolved */
		/* If broadcasting on a simplex interface, loopback a copy */
		if (*edst & 1)
			m->m_flags |= (M_BCAST|M_MCAST);
		M_PREPEND(m, 3, M_DONTWAIT);
		if (m == NULL)
			return (0);
		type = 0;
		l = mtod(m, struct llc *);
		l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
		l->llc_control = LLC_UI;
		IFDEBUG(D_ETHER)
			int i;
			printf("unoutput: sending pkt to: ");
			for (i=0; i<6; i++)
				printf("%x ", edst[i] & 0xff);
			printf("\n");
		ENDDEBUG
		} break;
#endif /* ISO */
#if	LLC
/*	case AF_NSAP: */
	case AF_CCITT: {
		register struct sockaddr_dl *sdl = 
			(struct sockaddr_dl *) rt -> rt_gateway;

		if (sdl && sdl->sdl_family != AF_LINK && sdl->sdl_alen <= 0)
			goto bad; /* Not a link interface ? Funny ... */
		bcopy(LLADDR(sdl), (char *)edst, sizeof(edst));
		if (*edst & 1)
			loop_copy = 1;
		type = 0;
#if LLC_DEBUG
		{
			int i;
			register struct llc *l = mtod(m, struct llc *);

			printf("fddi_output: sending LLC2 pkt to: ");
			for (i=0; i<6; i++)
				printf("%x ", edst[i] & 0xff);
			printf(" len 0x%x dsap 0x%x ssap 0x%x control 0x%x\n", 
			       type & 0xff, l->llc_dsap & 0xff, l->llc_ssap &0xff,
			       l->llc_control & 0xff);

		}
#endif /* LLC_DEBUG */
		} break;
#endif /* LLC */	

	case AF_UNSPEC:
	{
		struct ether_header *eh;
		loop_copy = -1;
		eh = (struct ether_header *)dst->sa_data;
 		(void)memcpy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
		if (*edst & 1)
			m->m_flags |= (M_BCAST|M_MCAST);
		type = eh->ether_type;
		break;
	}

#if NBPFILTER > 0
	case AF_IMPLINK:
	{
		fh = mtod(m, struct fddi_header *);
		error = EPROTONOSUPPORT;
		switch (fh->fddi_fc & (FDDIFC_C|FDDIFC_L|FDDIFC_F)) {
			case FDDIFC_LLC_ASYNC: {
				/* legal priorities are 0 through 7 */
				if ((fh->fddi_fc & FDDIFC_Z) > 7)
			        	goto bad;
				break;
			}
			case FDDIFC_LLC_SYNC: {
				/* FDDIFC_Z bits reserved, must be zero */
				if (fh->fddi_fc & FDDIFC_Z)
					goto bad;
				break;
			}
			case FDDIFC_SMT: {
				/* FDDIFC_Z bits must be non zero */
				if ((fh->fddi_fc & FDDIFC_Z) == 0)
					goto bad;
				break;
			}
			default: {
				/* anything else is too dangerous */
               	 		goto bad;
			}
		}
		error = 0;
		if (fh->fddi_dhost[0] & 1)
			m->m_flags |= (M_BCAST|M_MCAST);
		goto queue_it;
	}
#endif
	default:
		printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
			dst->sa_family);
		senderr(EAFNOSUPPORT);
	}

	if (type != 0) {
		register struct llc *l;
		M_PREPEND(m, sizeof (struct llc), M_DONTWAIT);
		if (m == 0)
			senderr(ENOBUFS);
		l = mtod(m, struct llc *);
		l->llc_control = LLC_UI;
		l->llc_dsap = l->llc_ssap = LLC_SNAP_LSAP;
		l->llc_snap.org_code[0] = l->llc_snap.org_code[1] = l->llc_snap.org_code[2] = 0;
		(void)memcpy((caddr_t) &l->llc_snap.ether_type, (caddr_t) &type,
			sizeof(u_int16_t));
	}

	/*
	 * Add local net header.  If no space in first mbuf,
	 * allocate another.
	 */
	M_PREPEND(m, sizeof (struct fddi_header), M_DONTWAIT);
	if (m == 0)
		senderr(ENOBUFS);
	fh = mtod(m, struct fddi_header *);
	fh->fddi_fc = FDDIFC_LLC_ASYNC|FDDIFC_LLC_PRIO4;
 	(void)memcpy((caddr_t)fh->fddi_dhost, (caddr_t)edst, sizeof (edst));
  queue_it:
 	(void)memcpy((caddr_t)fh->fddi_shost, (caddr_t)ac->ac_enaddr,
	    sizeof(fh->fddi_shost));

	/*
	 * If a simplex interface, and the packet is being sent to our
	 * Ethernet address or a broadcast address, loopback a copy.
	 * XXX To make a simplex device behave exactly like a duplex
	 * device, we should copy in the case of sending to our own
	 * ethernet address (thus letting the original actually appear
	 * on the wire). However, we don't do that here for security
	 * reasons and compatibility with the original behavior.
	 */
	if ((ifp->if_flags & IFF_SIMPLEX) &&
	   (loop_copy != -1)) {
		if ((m->m_flags & M_BCAST) || loop_copy) {
			struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);

			(void) if_simloop(ifp,
				n, dst, sizeof(struct fddi_header));
	     	} else if (bcmp(fh->fddi_dhost,
		    fh->fddi_shost, sizeof(fh->fddi_shost)) == 0) {
			(void) if_simloop(ifp,
				m, dst, sizeof(struct fddi_header));
			return(0);	/* XXX */
		}
	}

	s = splimp();
	/*
	 * Queue message on interface, and start output if interface
	 * not yet active.
	 */
	if (IF_QFULL(&ifp->if_snd)) {
		IF_DROP(&ifp->if_snd);
		splx(s);
		senderr(ENOBUFS);
	}
	ifp->if_obytes += m->m_pkthdr.len;
	IF_ENQUEUE(&ifp->if_snd, m);
	if ((ifp->if_flags & IFF_OACTIVE) == 0)
		(*ifp->if_start)(ifp);
	splx(s);
	if (m->m_flags & M_MCAST)
		ifp->if_omcasts++;
	return (error);

bad:
	if (m)
		m_freem(m);
	return (error);
}

/*
 * Process a received FDDI packet;
 * the packet is in the mbuf chain m without
 * the fddi header, which is provided separately.
 */
void
fddi_input(ifp, fh, m)
	struct ifnet *ifp;
	register struct fddi_header *fh;
	struct mbuf *m;
{
	register struct ifqueue *inq;
	register struct llc *l;
	int s;

	if ((ifp->if_flags & IFF_UP) == 0) {
		m_freem(m);
		return;
	}
	getmicrotime(&ifp->if_lastchange);
	ifp->if_ibytes += m->m_pkthdr.len + sizeof (*fh);
	if (fh->fddi_dhost[0] & 1) {
		if (bcmp((caddr_t)fddibroadcastaddr, (caddr_t)fh->fddi_dhost,
		    sizeof(fddibroadcastaddr)) == 0)
			m->m_flags |= M_BCAST;
		else
			m->m_flags |= M_MCAST;
		ifp->if_imcasts++;
	} else if ((ifp->if_flags & IFF_PROMISC)
	    && bcmp(((struct arpcom *)ifp)->ac_enaddr, (caddr_t)fh->fddi_dhost,
		    sizeof(fh->fddi_dhost)) != 0) {
		m_freem(m);
		return;
	}

#ifdef M_LINK0
	/*
	 * If this has a LLC priority of 0, then mark it so upper
	 * layers have a hint that it really came via a FDDI/Ethernet
	 * bridge.
	 */
	if ((fh->fddi_fc & FDDIFC_LLC_PRIO7) == FDDIFC_LLC_PRIO0)
		m->m_flags |= M_LINK0;
#endif

	l = mtod(m, struct llc *);
	switch (l->llc_dsap) {
#if defined(INET) || NS || IPX || defined(NETATALK)
	case LLC_SNAP_LSAP:
	{
		u_int16_t type;
		if (l->llc_control != LLC_UI || l->llc_ssap != LLC_SNAP_LSAP)
			goto dropanyway;

		if (l->llc_snap.org_code[0] != 0 || l->llc_snap.org_code[1] != 0|| l->llc_snap.org_code[2] != 0)
			goto dropanyway;
		type = ntohs(l->llc_snap.ether_type);
		m_adj(m, 8);
		switch (type) {
#if INET
		case ETHERTYPE_IP:
			if (ipflow_fastforward(m))
				return;
			schednetisr(NETISR_IP);
			inq = &ipintrq;
			break;

		case ETHERTYPE_ARP:
#if !defined(__bsdi__) || _BSDI_VERSION >= 199401
			schednetisr(NETISR_ARP);
			inq = &arpintrq;
			break;
#else
			arpinput((struct arpcom *)ifp, m);
			return;
#endif
#endif
#if IPX      
		case ETHERTYPE_IPX: 
			schednetisr(NETISR_IPX);
			inq = &ipxintrq;
			break;  
#endif   
#if NS
		case ETHERTYPE_NS:
			schednetisr(NETISR_NS);
			inq = &nsintrq;
			break;
#endif
#if DECNET
		case ETHERTYPE_DECNET:
			schednetisr(NETISR_DECNET);
			inq = &decnetintrq;
			break;
#endif

		default:
			/* printf("fddi_input: unknown protocol 0x%x\n", type); */
			ifp->if_noproto++;
			goto dropanyway;
		}
		break;
	}
#endif /* INET || NS */
#if	ISO
	case LLC_ISO_LSAP: 
		switch (l->llc_control) {
		case LLC_UI:
			/* LLC_UI_P forbidden in class 1 service */
			if ((l->llc_dsap == LLC_ISO_LSAP) &&
			    (l->llc_ssap == LLC_ISO_LSAP)) {
				/* LSAP for ISO */
				m->m_data += 3;		/* XXX */
				m->m_len -= 3;		/* XXX */
				m->m_pkthdr.len -= 3;	/* XXX */
				M_PREPEND(m, sizeof *fh, M_DONTWAIT);
				if (m == 0)
					return;
				*mtod(m, struct fddi_header *) = *fh;
				IFDEBUG(D_ETHER)
					printf("clnp packet");
				ENDDEBUG
				schednetisr(NETISR_ISO);
				inq = &clnlintrq;
				break;
			}
			goto dropanyway;
			
		case LLC_XID:
		case LLC_XID_P:
			if(m->m_len < 6)
				goto dropanyway;
			l->llc_window = 0;
			l->llc_fid = 9;
			l->llc_class = 1;
			l->llc_dsap = l->llc_ssap = 0;
			/* Fall through to */
		case LLC_TEST:
		case LLC_TEST_P:
		{
			struct sockaddr sa;
			register struct ether_header *eh;
			struct arpcom *ac = (struct arpcom *) ifp;
			int i;
			u_char c = l->llc_dsap;

			l->llc_dsap = l->llc_ssap;
			l->llc_ssap = c;
			if (m->m_flags & (M_BCAST | M_MCAST))
				bcopy((caddr_t)ac->ac_enaddr,
				      (caddr_t)eh->ether_dhost, 6);
			sa.sa_family = AF_UNSPEC;
			sa.sa_len = sizeof(sa);
			eh = (struct ether_header *)sa.sa_data;
			for (i = 0; i < 6; i++) {
				eh->ether_shost[i] = fh->fddi_dhost[i];
				eh->ether_dhost[i] = fh->fddi_shost[i];
			}
			eh->ether_type = 0;
			ifp->if_output(ifp, m, &sa, NULL);
			return;
		}
		default:
			m_freem(m);
			return;
		}
		break;
#endif /* ISO */
#if LLC
	case LLC_X25_LSAP:
	{
		M_PREPEND(m, sizeof(struct sdl_hdr) , M_DONTWAIT);
		if (m == 0)
			return;
		if ( !sdl_sethdrif(ifp, fh->fddi_shost, LLC_X25_LSAP,
				    fh->fddi_dhost, LLC_X25_LSAP, 6, 
				    mtod(m, struct sdl_hdr *)))
			panic("ETHER cons addr failure");
		mtod(m, struct sdl_hdr *)->sdlhdr_len = m->m_pkthdr.len - sizeof(struct sdl_hdr);
#if LLC_DEBUG
		printf("llc packet\n");
#endif /* LLC_DEBUG */
		schednetisr(NETISR_CCITT);
		inq = &llcintrq;
		break;
	}
#endif /* LLC */
		
	default:
		/* printf("fddi_input: unknown dsap 0x%x\n", l->llc_dsap); */
		ifp->if_noproto++;
	dropanyway:
		m_freem(m);
		return;
	}

	s = splimp();
	if (IF_QFULL(inq)) {
		IF_DROP(inq);
		m_freem(m);
	} else
		IF_ENQUEUE(inq, m);
	splx(s);
}
/*
 * Perform common duties while attaching to interface list
 */
#ifdef __NetBSD__
#define	ifa_next	ifa_list.tqe_next
#endif

void
fddi_ifattach(ifp)
	register struct ifnet *ifp;
{
	register struct ifaddr *ifa;
	register struct sockaddr_dl *sdl;

	ifp->if_type = IFT_FDDI;
	ifp->if_addrlen = 6;
	ifp->if_hdrlen = 21;
	ifp->if_mtu = FDDIMTU;
	ifp->if_baudrate = 100000000;
#if IFF_NOTRAILERS
	ifp->if_flags |= IFF_NOTRAILERS;
#endif
#if defined(__FreeBSD__)
	ifa = ifnet_addrs[ifp->if_index - 1];
	sdl = (struct sockaddr_dl *)ifa->ifa_addr;
	sdl->sdl_type = IFT_FDDI;
	sdl->sdl_alen = ifp->if_addrlen;
	bcopy(((struct arpcom *)ifp)->ac_enaddr, LLADDR(sdl), ifp->if_addrlen);
#elif defined(__NetBSD__)
	LIST_INIT(&((struct arpcom *)ifp)->ac_multiaddrs);
	for (ifa = ifp->if_addrlist.tqh_first; ifa != NULL; ifa = ifa->ifa_list.tqe_next)
#else
	for (ifa = ifp->if_addrlist; ifa != NULL; ifa = ifa->ifa_next)
#endif
#if !defined(__FreeBSD__)
		if ((sdl = (struct sockaddr_dl *)ifa->ifa_addr) &&
		    sdl->sdl_family == AF_LINK) {
			sdl->sdl_type = IFT_FDDI;
			sdl->sdl_alen = ifp->if_addrlen;
			bcopy((caddr_t)((struct arpcom *)ifp)->ac_enaddr,
			      LLADDR(sdl), ifp->if_addrlen);
			break;
		}
#endif
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* Copyright (c) 1995, 1996
	24	* Matt Thomas <matt@3am-software.com>. All rights reserved.
	25	* Copyright (c) 1982, 1989, 1993
	26	* The Regents of the University of California. All rights reserved.
	27	*
	28	* Redistribution and use in source and binary forms, with or without
	29	* modification, are permitted provided that the following conditions
	30	* are met:
	31	* 1. Redistributions of source code must retain the above copyright
	32	* notice, this list of conditions and the following disclaimer.
	33	* 2. Redistributions in binary form must reproduce the above copyright
	34	* notice, this list of conditions and the following disclaimer in the
	35	* documentation and/or other materials provided with the distribution.
	36	* 3. All advertising materials mentioning features or use of this software
	37	* must display the following acknowledgement:
	38	* This product includes software developed by the University of
	39	* California, Berkeley and its contributors.
	40	* 4. Neither the name of the University nor the names of its contributors
	41	* may be used to endorse or promote products derived from this software
	42	* without specific prior written permission.
	43	*
	44	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	45	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	46	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	47	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	48	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	49	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	50	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	51	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	52	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	53	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	54	* SUCH DAMAGE.
	55	*
	56	* from: if_ethersubr.c,v 1.5 1994/12/13 22:31:45 wollman Exp
	57	*/
	58
	59	#include "opt_atalk.h"
	60	#include "opt_inet.h"
	61	#include "opt_ipx.h"
	62
	63	#include <sys/param.h>
	64	#include <sys/systm.h>
65	#include <sys/mbuf.h>
66	#include <sys/socket.h>
67
68	#include <net/if.h>
69	#include <net/netisr.h>
70	#include <net/route.h>
71	#include <net/if_llc.h>
72	#include <net/if_dl.h>
73	#include <net/if_types.h>
74
75	#if INET
76	#include <netinet/in.h>
77	#include <netinet/in_var.h>
78	#include <netinet/if_ether.h>
79	#endif
80	#if defined(__FreeBSD__)
81	#include <netinet/if_fddi.h>
82	#else
83	#include <net/if_fddi.h>
84	#endif
85
86	#if IPX
87	#include <netipx/ipx.h>
88	#include <netipx/ipx_if.h>
89	#endif
90
1c79356b A	91	#if DECNET
	92	#include <netdnet/dn.h>
	93	#endif
	94
1c79356b A	95	#include "bpfilter.h"
	96
	97	#define senderr(e) { error = (e); goto bad;}
	98
	99	/*
	100	* This really should be defined in if_llc.h but in case it isn't.
	101	*/
	102	#ifndef llc_snap
	103	#define llc_snap llc_un.type_snap
	104	#endif
	105
	106	#if defined(__bsdi__) \|\| defined(__NetBSD__)
	107	#define RTALLOC1(a, b) rtalloc1(a, b)
	108	#define ARPRESOLVE(a, b, c, d, e, f) arpresolve(a, b, c, d, e)
	109	#elif defined(__FreeBSD__)
	110	#define RTALLOC1(a, b) rtalloc1(a, b, 0UL)
	111	#define ARPRESOLVE(a, b, c, d, e, f) arpresolve(a, b, c, d, e, f)
	112	#endif
	113	/*
	114	* FDDI output routine.
	115	* Encapsulate a packet of type family for the local net.
	116	* Use trailer local net encapsulation if enough data in first
	117	* packet leaves a multiple of 512 bytes of data in remainder.
	118	* Assumes that ifp is actually pointer to arpcom structure.
	119	*/
	120	int
	121	fddi_output(ifp, m0, dst, rt0)
	122	register struct ifnet *ifp;
	123	struct mbuf *m0;
	124	struct sockaddr *dst;
	125	struct rtentry *rt0;
	126	{
	127	u_int16_t type;
	128	int s, loop_copy = 0, error = 0;
	129	u_char edst[6];
	130	register struct mbuf *m = m0;
	131	register struct rtentry *rt;
	132	register struct fddi_header *fh;
	133	struct arpcom ac = (struct arpcom )ifp;
	134
	135	if ((ifp->if_flags & (IFF_UP\|IFF_RUNNING)) != (IFF_UP\|IFF_RUNNING))
	136	senderr(ENETDOWN);
	137	getmicrotime(&ifp->if_lastchange);
	138	#if !defined(__bsdi__) \|\| _BSDI_VERSION >= 199401
	139	if (rt = rt0) {
	140	if ((rt->rt_flags & RTF_UP) == 0) {
	141	if (rt0 = rt = RTALLOC1(dst, 1))
9bccf70c	142	rtunref(rt);
1c79356b A	143	else
	144	senderr(EHOSTUNREACH);
	145	}
	146	if (rt->rt_flags & RTF_GATEWAY) {
	147	if (rt->rt_gwroute == 0)
	148	goto lookup;
	149	if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
	150	rtfree(rt); rt = rt0;
	151	lookup: rt->rt_gwroute = RTALLOC1(rt->rt_gateway, 1);
	152	if ((rt = rt->rt_gwroute) == 0)
	153	senderr(EHOSTUNREACH);
	154	}
	155	}
	156	if (rt->rt_flags & RTF_REJECT)
	157	if (rt->rt_rmx.rmx_expire == 0 \|\|
	158	time_second < rt->rt_rmx.rmx_expire)
	159	senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
	160	}
	161	#endif
	162	switch (dst->sa_family) {
	163
	164	#if INET
	165	case AF_INET: {
	166	#if !defined(__bsdi__) \|\| _BSDI_VERSION >= 199401
	167	if (!ARPRESOLVE(ac, rt, m, dst, edst, rt0))
	168	return (0); /* if not yet resolved */
	169	#else
	170	int usetrailers;
	171	if (!arpresolve(ac, m, &((struct sockaddr_in *)dst)->sin_addr, edst, &usetrailers))
	172	return (0); /* if not yet resolved */
	173	#endif
	174	type = htons(ETHERTYPE_IP);
	175	break;
	176	}
	177	#endif
	178	#if IPX
	179	case AF_IPX:
	180	type = htons(ETHERTYPE_IPX);
	181	bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
	182	(caddr_t)edst, sizeof (edst));
	183	break;
	184	#endif
	185
	186	#if NS
	187	case AF_NS:
	188	type = htons(ETHERTYPE_NS);
	189	bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
	190	(caddr_t)edst, sizeof (edst));
	191	break;
	192	#endif
	193	#if ISO
	194	case AF_ISO: {
	195	int snpalen;
	196	struct llc *l;
	197	register struct sockaddr_dl *sdl;
	198
	199	if (rt && (sdl = (struct sockaddr_dl *)rt->rt_gateway) &&
	200	sdl->sdl_family == AF_LINK && sdl->sdl_alen > 0) {
	201	bcopy(LLADDR(sdl), (caddr_t)edst, sizeof(edst));
	202	} else if (error =
	203	iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
	204	(char *)edst, &snpalen))
	205	goto bad; /* Not Resolved */
	206	/* If broadcasting on a simplex interface, loopback a copy */
207	if (*edst & 1)
208	m->m_flags \|= (M_BCAST\|M_MCAST);
209	M_PREPEND(m, 3, M_DONTWAIT);
210	if (m == NULL)
211	return (0);
212	type = 0;
213	l = mtod(m, struct llc *);
214	l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
215	l->llc_control = LLC_UI;
216	IFDEBUG(D_ETHER)
217	int i;
218	printf("unoutput: sending pkt to: ");
219	for (i=0; i<6; i++)
220	printf("%x ", edst[i] & 0xff);
221	printf("\n");
222	ENDDEBUG
223	} break;
224	#endif /* ISO */
225	#if LLC
226	/* case AF_NSAP: */
227	case AF_CCITT: {
228	register struct sockaddr_dl *sdl =
229	(struct sockaddr_dl *) rt -> rt_gateway;
230
231	if (sdl && sdl->sdl_family != AF_LINK && sdl->sdl_alen <= 0)
232	goto bad; /* Not a link interface ? Funny ... */
233	bcopy(LLADDR(sdl), (char *)edst, sizeof(edst));
234	if (*edst & 1)
235	loop_copy = 1;
236	type = 0;
237	#if LLC_DEBUG
238	{
239	int i;
240	register struct llc l = mtod(m, struct llc );
241
242	printf("fddi_output: sending LLC2 pkt to: ");
243	for (i=0; i<6; i++)
244	printf("%x ", edst[i] & 0xff);
245	printf(" len 0x%x dsap 0x%x ssap 0x%x control 0x%x\n",
246	type & 0xff, l->llc_dsap & 0xff, l->llc_ssap &0xff,
247	l->llc_control & 0xff);
248
249	}
250	#endif /* LLC_DEBUG */
251	} break;
252	#endif /* LLC */
253
254	case AF_UNSPEC:
255	{
256	struct ether_header *eh;
257	loop_copy = -1;
258	eh = (struct ether_header *)dst->sa_data;
259	(void)memcpy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
260	if (*edst & 1)
261	m->m_flags \|= (M_BCAST\|M_MCAST);
262	type = eh->ether_type;
263	break;
264	}
265
266	#if NBPFILTER > 0
267	case AF_IMPLINK:
268	{
269	fh = mtod(m, struct fddi_header *);
270	error = EPROTONOSUPPORT;
271	switch (fh->fddi_fc & (FDDIFC_C\|FDDIFC_L\|FDDIFC_F)) {
272	case FDDIFC_LLC_ASYNC: {
273	/* legal priorities are 0 through 7 */
274	if ((fh->fddi_fc & FDDIFC_Z) > 7)
275	goto bad;
276	break;
277	}
278	case FDDIFC_LLC_SYNC: {
279	/* FDDIFC_Z bits reserved, must be zero */
280	if (fh->fddi_fc & FDDIFC_Z)
281	goto bad;
282	break;
283	}
284	case FDDIFC_SMT: {
285	/* FDDIFC_Z bits must be non zero */
286	if ((fh->fddi_fc & FDDIFC_Z) == 0)
287	goto bad;
288	break;
289	}
290	default: {
291	/* anything else is too dangerous */
292	goto bad;
293	}
294	}
295	error = 0;
296	if (fh->fddi_dhost[0] & 1)
297	m->m_flags \|= (M_BCAST\|M_MCAST);
298	goto queue_it;
299	}
300	#endif
301	default:
302	printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
303	dst->sa_family);
304	senderr(EAFNOSUPPORT);
305	}
306
307	if (type != 0) {
308	register struct llc *l;
309	M_PREPEND(m, sizeof (struct llc), M_DONTWAIT);
310	if (m == 0)
311	senderr(ENOBUFS);
312	l = mtod(m, struct llc *);
313	l->llc_control = LLC_UI;
314	l->llc_dsap = l->llc_ssap = LLC_SNAP_LSAP;
315	l->llc_snap.org_code[0] = l->llc_snap.org_code[1] = l->llc_snap.org_code[2] = 0;
316	(void)memcpy((caddr_t) &l->llc_snap.ether_type, (caddr_t) &type,
317	sizeof(u_int16_t));
318	}
319
320	/*
321	* Add local net header. If no space in first mbuf,
322	* allocate another.
323	*/
324	M_PREPEND(m, sizeof (struct fddi_header), M_DONTWAIT);
325	if (m == 0)
326	senderr(ENOBUFS);
327	fh = mtod(m, struct fddi_header *);
328	fh->fddi_fc = FDDIFC_LLC_ASYNC\|FDDIFC_LLC_PRIO4;
329	(void)memcpy((caddr_t)fh->fddi_dhost, (caddr_t)edst, sizeof (edst));
330	queue_it:
331	(void)memcpy((caddr_t)fh->fddi_shost, (caddr_t)ac->ac_enaddr,
332	sizeof(fh->fddi_shost));
333
334	/*
335	* If a simplex interface, and the packet is being sent to our
336	* Ethernet address or a broadcast address, loopback a copy.
337	* XXX To make a simplex device behave exactly like a duplex
338	* device, we should copy in the case of sending to our own
339	* ethernet address (thus letting the original actually appear
340	* on the wire). However, we don't do that here for security
341	* reasons and compatibility with the original behavior.
342	*/
343	if ((ifp->if_flags & IFF_SIMPLEX) &&
344	(loop_copy != -1)) {
345	if ((m->m_flags & M_BCAST) \|\| loop_copy) {
346	struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
347
348	(void) if_simloop(ifp,
349	n, dst, sizeof(struct fddi_header));
350	} else if (bcmp(fh->fddi_dhost,
351	fh->fddi_shost, sizeof(fh->fddi_shost)) == 0) {
352	(void) if_simloop(ifp,
353	m, dst, sizeof(struct fddi_header));
354	return(0); /* XXX */
355	}
356	}
357
358	s = splimp();
359	/*
360	* Queue message on interface, and start output if interface
361	* not yet active.
362	*/
363	if (IF_QFULL(&ifp->if_snd)) {
364	IF_DROP(&ifp->if_snd);
365	splx(s);
366	senderr(ENOBUFS);
367	}
368	ifp->if_obytes += m->m_pkthdr.len;
369	IF_ENQUEUE(&ifp->if_snd, m);
370	if ((ifp->if_flags & IFF_OACTIVE) == 0)
371	(*ifp->if_start)(ifp);
372	splx(s);
373	if (m->m_flags & M_MCAST)
374	ifp->if_omcasts++;
375	return (error);
376
377	bad:
378	if (m)
379	m_freem(m);
380	return (error);
381	}
382
383	/*
384	* Process a received FDDI packet;
385	* the packet is in the mbuf chain m without
386	* the fddi header, which is provided separately.
387	*/
388	void
389	fddi_input(ifp, fh, m)
390	struct ifnet *ifp;
391	register struct fddi_header *fh;
392	struct mbuf *m;
393	{
394	register struct ifqueue *inq;
395	register struct llc *l;
396	int s;
397
398	if ((ifp->if_flags & IFF_UP) == 0) {
399	m_freem(m);
400	return;
401	}
402	getmicrotime(&ifp->if_lastchange);
403	ifp->if_ibytes += m->m_pkthdr.len + sizeof (*fh);
404	if (fh->fddi_dhost[0] & 1) {
405	if (bcmp((caddr_t)fddibroadcastaddr, (caddr_t)fh->fddi_dhost,
406	sizeof(fddibroadcastaddr)) == 0)
407	m->m_flags \|= M_BCAST;
408	else
409	m->m_flags \|= M_MCAST;
410	ifp->if_imcasts++;
411	} else if ((ifp->if_flags & IFF_PROMISC)
412	&& bcmp(((struct arpcom *)ifp)->ac_enaddr, (caddr_t)fh->fddi_dhost,
413	sizeof(fh->fddi_dhost)) != 0) {
414	m_freem(m);
415	return;
416	}
417
418	#ifdef M_LINK0
419	/*
420	* If this has a LLC priority of 0, then mark it so upper
421	* layers have a hint that it really came via a FDDI/Ethernet
422	* bridge.
423	*/
424	if ((fh->fddi_fc & FDDIFC_LLC_PRIO7) == FDDIFC_LLC_PRIO0)
425	m->m_flags \|= M_LINK0;
426	#endif
427
428	l = mtod(m, struct llc *);
429	switch (l->llc_dsap) {
430	#if defined(INET) \|\| NS \|\| IPX \|\| defined(NETATALK)
431	case LLC_SNAP_LSAP:
432	{
433	u_int16_t type;
434	if (l->llc_control != LLC_UI \|\| l->llc_ssap != LLC_SNAP_LSAP)
435	goto dropanyway;
436
437	if (l->llc_snap.org_code[0] != 0 \|\| l->llc_snap.org_code[1] != 0\|\| l->llc_snap.org_code[2] != 0)
438	goto dropanyway;
439	type = ntohs(l->llc_snap.ether_type);
440	m_adj(m, 8);
441	switch (type) {
442	#if INET
443	case ETHERTYPE_IP:
444	if (ipflow_fastforward(m))
445	return;
446	schednetisr(NETISR_IP);
447	inq = &ipintrq;
448	break;
449
450	case ETHERTYPE_ARP:
451	#if !defined(__bsdi__) \|\| _BSDI_VERSION >= 199401
452	schednetisr(NETISR_ARP);
453	inq = &arpintrq;
454	break;
455	#else
456	arpinput((struct arpcom *)ifp, m);
457	return;
458	#endif
459	#endif
460	#if IPX
461	case ETHERTYPE_IPX:
462	schednetisr(NETISR_IPX);
463	inq = &ipxintrq;
464	break;
465	#endif
466	#if NS
467	case ETHERTYPE_NS:
468	schednetisr(NETISR_NS);
469	inq = &nsintrq;
470	break;
471	#endif
472	#if DECNET
473	case ETHERTYPE_DECNET:
474	schednetisr(NETISR_DECNET);
475	inq = &decnetintrq;
476	break;
477	#endif
478
479	default:
480	/* printf("fddi_input: unknown protocol 0x%x\n", type); */
481	ifp->if_noproto++;
482	goto dropanyway;
483	}
484	break;
485	}
486	#endif /* INET \|\| NS */
487	#if ISO
488	case LLC_ISO_LSAP:
489	switch (l->llc_control) {
490	case LLC_UI:
491	/* LLC_UI_P forbidden in class 1 service */
492	if ((l->llc_dsap == LLC_ISO_LSAP) &&
493	(l->llc_ssap == LLC_ISO_LSAP)) {
494	/* LSAP for ISO */
495	m->m_data += 3; /* XXX */
496	m->m_len -= 3; /* XXX */
497	m->m_pkthdr.len -= 3; /* XXX */
498	M_PREPEND(m, sizeof *fh, M_DONTWAIT);
499	if (m == 0)
500	return;
501	mtod(m, struct fddi_header ) = *fh;
502	IFDEBUG(D_ETHER)
503	printf("clnp packet");
504	ENDDEBUG
505	schednetisr(NETISR_ISO);
506	inq = &clnlintrq;
507	break;
508	}
509	goto dropanyway;
510
511	case LLC_XID:
512	case LLC_XID_P:
513	if(m->m_len < 6)
514	goto dropanyway;
515	l->llc_window = 0;
516	l->llc_fid = 9;
517	l->llc_class = 1;
518	l->llc_dsap = l->llc_ssap = 0;
519	/* Fall through to */
520	case LLC_TEST:
521	case LLC_TEST_P:
522	{
523	struct sockaddr sa;
524	register struct ether_header *eh;
525	struct arpcom ac = (struct arpcom ) ifp;
526	int i;
527	u_char c = l->llc_dsap;
528
529	l->llc_dsap = l->llc_ssap;
530	l->llc_ssap = c;
531	if (m->m_flags & (M_BCAST \| M_MCAST))
532	bcopy((caddr_t)ac->ac_enaddr,
533	(caddr_t)eh->ether_dhost, 6);
534	sa.sa_family = AF_UNSPEC;
535	sa.sa_len = sizeof(sa);
536	eh = (struct ether_header *)sa.sa_data;
537	for (i = 0; i < 6; i++) {
538	eh->ether_shost[i] = fh->fddi_dhost[i];
539	eh->ether_dhost[i] = fh->fddi_shost[i];
540	}
541	eh->ether_type = 0;
542	ifp->if_output(ifp, m, &sa, NULL);
543	return;
544	}
545	default:
546	m_freem(m);
547	return;
548	}
549	break;
550	#endif /* ISO */
551	#if LLC
552	case LLC_X25_LSAP:
553	{
554	M_PREPEND(m, sizeof(struct sdl_hdr) , M_DONTWAIT);
555	if (m == 0)
556	return;
557	if ( !sdl_sethdrif(ifp, fh->fddi_shost, LLC_X25_LSAP,
558	fh->fddi_dhost, LLC_X25_LSAP, 6,
559	mtod(m, struct sdl_hdr *)))
560	panic("ETHER cons addr failure");
561	mtod(m, struct sdl_hdr *)->sdlhdr_len = m->m_pkthdr.len - sizeof(struct sdl_hdr);
562	#if LLC_DEBUG
563	printf("llc packet\n");
564	#endif /* LLC_DEBUG */
565	schednetisr(NETISR_CCITT);
566	inq = &llcintrq;
567	break;
568	}
569	#endif /* LLC */
570
571	default:
572	/* printf("fddi_input: unknown dsap 0x%x\n", l->llc_dsap); */
573	ifp->if_noproto++;
574	dropanyway:
575	m_freem(m);
576	return;
577	}
578
579	s = splimp();
580	if (IF_QFULL(inq)) {
581	IF_DROP(inq);
582	m_freem(m);
583	} else
584	IF_ENQUEUE(inq, m);
585	splx(s);
586	}
587	/*
588	* Perform common duties while attaching to interface list
589	*/
590	#ifdef __NetBSD__
591	#define ifa_next ifa_list.tqe_next
592	#endif
593
594	void
595	fddi_ifattach(ifp)
596	register struct ifnet *ifp;
597	{
598	register struct ifaddr *ifa;
599	register struct sockaddr_dl *sdl;
600
601	ifp->if_type = IFT_FDDI;
602	ifp->if_addrlen = 6;
603	ifp->if_hdrlen = 21;
604	ifp->if_mtu = FDDIMTU;
605	ifp->if_baudrate = 100000000;
606	#if IFF_NOTRAILERS
607	ifp->if_flags \|= IFF_NOTRAILERS;
608	#endif
609	#if defined(__FreeBSD__)
610	ifa = ifnet_addrs[ifp->if_index - 1];
611	sdl = (struct sockaddr_dl *)ifa->ifa_addr;
612	sdl->sdl_type = IFT_FDDI;
613	sdl->sdl_alen = ifp->if_addrlen;
614	bcopy(((struct arpcom *)ifp)->ac_enaddr, LLADDR(sdl), ifp->if_addrlen);
615	#elif defined(__NetBSD__)
616	LIST_INIT(&((struct arpcom *)ifp)->ac_multiaddrs);
617	for (ifa = ifp->if_addrlist.tqh_first; ifa != NULL; ifa = ifa->ifa_list.tqe_next)
618	#else
619	for (ifa = ifp->if_addrlist; ifa != NULL; ifa = ifa->ifa_next)
620	#endif
621	#if !defined(__FreeBSD__)
622	if ((sdl = (struct sockaddr_dl *)ifa->ifa_addr) &&
623	sdl->sdl_family == AF_LINK) {
624	sdl->sdl_type = IFT_FDDI;
625	sdl->sdl_alen = ifp->if_addrlen;
626	bcopy((caddr_t)((struct arpcom *)ifp)->ac_enaddr,
627	LLADDR(sdl), ifp->if_addrlen);
628	break;
629	}
630	#endif
631	}