[unix-history] / usr / src / sys / net / if_ethersubr.c

/*
 * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *	@(#)if_ethersubr.c	7.4 (Berkeley) %G%
 */

#include "param.h"
#include "systm.h"
#include "malloc.h"
#include "mbuf.h"
#include "protosw.h"
#include "socket.h"
#include "ioctl.h"
#include "errno.h"
#include "syslog.h"

#include "if.h"
#include "netisr.h"
#include "route.h"
#include "if_llc.h"

#include "machine/mtpr.h"

#ifdef INET
#include "../netinet/in.h"
#include "../netinet/in_var.h"
#include "../netinet/if_ether.h"
#endif

#ifdef NS
#include "../netns/ns.h"
#include "../netns/ns_if.h"
#endif

#ifdef ISO
#include "../netiso/argo_debug.h"
#include "../netiso/iso.h"
#include "../netiso/iso_var.h"
#endif

u_char	etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
extern	struct ifnet loif;

/*
 * Ethernet 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.
 */
ether_output(ifp, m0, dst)
	register struct ifnet *ifp;
	struct mbuf *m0;
	struct sockaddr *dst;
{
	short type;
	int s, error = 0;
 	u_char edst[6];
	struct in_addr idst;
	register struct mbuf *m = m0;
	struct mbuf *mcopy = (struct mbuf *)0;
	register struct ether_header *eh;
	int usetrailers, off;
#define	ac ((struct arpcom *)ifp)

	if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
		error = ENETDOWN;
		goto bad;
	}
	if (ifp->if_flags & IFF_SIMPLEX && dst->sa_family != AF_UNSPEC &&
	    !bcmp((caddr_t)edst, (caddr_t)etherbroadcastaddr, sizeof (edst)))
		mcopy = m_copy(m, 0, (int)M_COPYALL);
	switch (dst->sa_family) {

#ifdef INET
	case AF_INET:
		idst = ((struct sockaddr_in *)dst)->sin_addr;
 		if (!arpresolve(ac, m, &idst, edst, &usetrailers))
			return (0);	/* if not yet resolved */
		if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1))
		    mcopy = m_copy(m, 0, (int)M_COPYALL);
		off = m->m_pkthdr.len - m->m_len;
		if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
		    (m->m_flags & M_EXT) == 0 &&
		    m->m_data >= m->m_pktdat + 2 * sizeof (u_short)) {
			type = ETHERTYPE_TRAIL + (off>>9);
			m->m_data -= 2 * sizeof (u_short);
			m->m_len += 2 * sizeof (u_short);
			*mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
			*(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
			goto gottrailertype;
		}
		type = ETHERTYPE_IP;
		goto gottype;
#endif
#ifdef NS
	case AF_NS:
		type = ETHERTYPE_NS;
		if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst)))
			return(looutput(&loif, m, dst));
 		bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
		    (caddr_t)edst, sizeof (edst));
		if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1))
		    mcopy = m_copy(m, 0, (int)M_COPYALL);
		goto gottype;
#endif
#ifdef	ISO
	case AF_ISO: {
		int	len;
		int	ret;
		struct	llc *l;

		if ((ret = iso_tryloopback(m, (struct sockaddr_iso *)dst)) >= 0)
			return (ret);
		ret = iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
					(char *)edst, &len);
		if (ret > 0) {
			m_freem(m); /* Not Resolved */
			return(ret);
		}
		M_PREPEND(m, 3, M_DONTWAIT);
		if (m == NULL)
			return(0);
		type = m->m_pkthdr.len;
		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
		} goto gottype;
#endif	ISO
	case AF_UNSPEC:
		eh = (struct ether_header *)dst->sa_data;
 		bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
		type = eh->ether_type;
		goto gottype;

	default:
		printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
			dst->sa_family);
		error = EAFNOSUPPORT;
		goto bad;
	}

gottrailertype:
	/*
	 * Packet to be sent as trailer: move first packet
	 * (control information) to end of chain.
	 */
	while (m->m_next)
		m = m->m_next;
	m->m_next = m0;
	m = m0->m_next;
	m0->m_next = 0;

gottype:
	/*
	 * Add local net header.  If no space in first mbuf,
	 * allocate another.
	 */
	M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
	if (m == 0) {
		error = ENOBUFS;
		goto bad;
	}
	eh = mtod(m, struct ether_header *);
	type = htons((u_short)type);
	bcopy((caddr_t)&type,(caddr_t)&eh->ether_type,
		sizeof(eh->ether_type));
 	bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
 	bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
	    sizeof(eh->ether_shost));
	/*
	 * Queue message on interface, and start output if interface
	 * not yet active.
	 */
	s = splimp();
	if (IF_QFULL(&ifp->if_snd)) {
		IF_DROP(&ifp->if_snd);
		splx(s);
		error = ENOBUFS;
		goto bad;
	}
	IF_ENQUEUE(&ifp->if_snd, m);
	if ((ifp->if_flags & IFF_OACTIVE) == 0)
		(*ifp->if_start)(ifp);
	splx(s);
	if (mcopy)
		(void) looutput(&loif, mcopy, dst);
	return (error);

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

/*
 * Process a received Ethernet packet;
 * the packet is in the mbuf chain m without
 * the ether header, which is provided separately.
 */
ether_input(ifp, eh, m)
	struct ifnet *ifp;
	register struct ether_header *eh;
	struct mbuf *m;
{
	register struct ifqueue *inq;
	register struct llc *l;
	int s;

	if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
	    sizeof(etherbroadcastaddr)) == 0)
		m->m_flags |= M_BCAST;
	else if (eh->ether_dhost[0] & 1)
		m->m_flags |= M_MCAST;

	switch (eh->ether_type) {
#ifdef INET
	case ETHERTYPE_IP:
		schednetisr(NETISR_IP);
		inq = &ipintrq;
		break;

	case ETHERTYPE_ARP:
		arpinput((struct arpcom *)ifp, m);
		return;
#endif
#ifdef NS
	case ETHERTYPE_NS:
		schednetisr(NETISR_NS);
		inq = &nsintrq;
		break;

#endif
	default:
#ifdef	ISO
		if (eh->ether_type > ETHERMTU)
			goto dropanyway;
		l = mtod(m, struct llc *);
		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 *eh, M_DONTWAIT);
			if (m == 0)
				return;
			*mtod(m, struct ether_header *) = *eh;
			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 *eh2;
		    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);
		    eh2 = (struct ether_header *)sa.sa_data;
		    for (i = 0; i < 6; i++) {
			eh2->ether_shost[i] = c = eh->ether_dhost[i];
			eh2->ether_dhost[i] = 
				eh->ether_dhost[i] = eh->ether_shost[i];
			eh->ether_shost[i] = c;
		    }
		    ifp->if_output(ifp, m, &sa);
		    return;
		}
		dropanyway:
		default:
		    m_freem(m);
		    return;
	    }
#else
	    m_freem(m);
	    return;
#endif	ISO
	}

	s = splimp();
	if (IF_QFULL(inq)) {
		IF_DROP(inq);
		m_freem(m);
	} else
		IF_ENQUEUE(inq, m);
	splx(s);
}

/*
 * Convert Ethernet address to printable (loggable) representation.
 */
static char digits[] = "0123456789abcdef";
char *
ether_sprintf(ap)
	register u_char *ap;
{
	register i;
	static char etherbuf[18];
	register char *cp = etherbuf;

	for (i = 0; i < 6; i++) {
		*cp++ = digits[*ap >> 4];
		*cp++ = digits[*ap++ & 0xf];
		*cp++ = ':';
	}
	*--cp = 0;
	return (etherbuf);
}
Commit	Line	Data
132c65ba KF	1	/*
	2	* Copyright (c) 1982, 1986, 1988 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms are permitted
	6	* provided that the above copyright notice and this paragraph are
	7	* duplicated in all such forms and that any documentation,
	8	* advertising materials, and other materials related to such
	9	* distribution and use acknowledge that the software was developed
	10	* by the University of California, Berkeley. The name of the
	11	* University may not be used to endorse or promote products derived
	12	* from this software without specific prior written permission.
	13	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	14	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	15	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	16	*
ae4c8bc9	17	* @(#)if_ethersubr.c 7.4 (Berkeley) %G%
132c65ba KF	18	*/
	19
	20	#include "param.h"
	21	#include "systm.h"
	22	#include "malloc.h"
	23	#include "mbuf.h"
	24	#include "protosw.h"
	25	#include "socket.h"
	26	#include "ioctl.h"
	27	#include "errno.h"
	28	#include "syslog.h"
	29
	30	#include "if.h"
	31	#include "netisr.h"
	32	#include "route.h"
38a81509	33	#include "if_llc.h"
132c65ba	34
d301d150	35	#include "machine/mtpr.h"
132c65ba KF	36
	37	#ifdef INET
	38	#include "../netinet/in.h"
	39	#include "../netinet/in_var.h"
	40	#include "../netinet/if_ether.h"
	41	#endif
	42
	43	#ifdef NS
	44	#include "../netns/ns.h"
	45	#include "../netns/ns_if.h"
	46	#endif
	47
b72a6efb KS	48	#ifdef ISO
	49	#include "../netiso/argo_debug.h"
	50	#include "../netiso/iso.h"
	51	#include "../netiso/iso_var.h"
	52	#endif
	53
132c65ba	54	u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
38a81509	55	extern struct ifnet loif;
132c65ba KF	56
	57	/*
	58	* Ethernet output routine.
	59	* Encapsulate a packet of type family for the local net.
	60	* Use trailer local net encapsulation if enough data in first
	61	* packet leaves a multiple of 512 bytes of data in remainder.
	62	* Assumes that ifp is actually pointer to arpcom structure.
	63	*/
b72a6efb	64	ether_output(ifp, m0, dst)
132c65ba KF	65	register struct ifnet *ifp;
	66	struct mbuf *m0;
	67	struct sockaddr *dst;
	68	{
38a81509 MK	69	short type;
38a81509 MK	70	int s, error = 0;
132c65ba KF	71	u_char edst[6];
	72	struct in_addr idst;
	73	register struct mbuf *m = m0;
38a81509	74	struct mbuf mcopy = (struct mbuf )0;
132c65ba	75	register struct ether_header *eh;
38a81509	76	int usetrailers, off;
132c65ba KF	77	#define ac ((struct arpcom *)ifp)
	78
	79	if ((ifp->if_flags & (IFF_UP\|IFF_RUNNING)) != (IFF_UP\|IFF_RUNNING)) {
	80	error = ENETDOWN;
	81	goto bad;
	82	}
b72a6efb KS	83	if (ifp->if_flags & IFF_SIMPLEX && dst->sa_family != AF_UNSPEC &&
	84	!bcmp((caddr_t)edst, (caddr_t)etherbroadcastaddr, sizeof (edst)))
	85	mcopy = m_copy(m, 0, (int)M_COPYALL);
132c65ba KF	86	switch (dst->sa_family) {
	87
	88	#ifdef INET
	89	case AF_INET:
	90	idst = ((struct sockaddr_in *)dst)->sin_addr;
	91	if (!arpresolve(ac, m, &idst, edst, &usetrailers))
	92	return (0); /* if not yet resolved */
b72a6efb KS	93	if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1))
b72a6efb KS	94	mcopy = m_copy(m, 0, (int)M_COPYALL);
132c65ba KF	95	off = m->m_pkthdr.len - m->m_len;
	96	if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
	97	(m->m_flags & M_EXT) == 0 &&
	98	m->m_data >= m->m_pktdat + 2 * sizeof (u_short)) {
	99	type = ETHERTYPE_TRAIL + (off>>9);
	100	m->m_data -= 2 * sizeof (u_short);
	101	m->m_len += 2 * sizeof (u_short);
	102	mtod(m, u_short ) = htons((u_short)ETHERTYPE_IP);
	103	(mtod(m, u_short ) + 1) = htons((u_short)m->m_len);
	104	goto gottrailertype;
	105	}
	106	type = ETHERTYPE_IP;
132c65ba KF	107	goto gottype;
	108	#endif
	109	#ifdef NS
	110	case AF_NS:
	111	type = ETHERTYPE_NS;
38a81509 MK	112	if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst)))
38a81509 MK	113	return(looutput(&loif, m, dst));
132c65ba	114	bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
38a81509	115	(caddr_t)edst, sizeof (edst));
b72a6efb KS	116	if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1))
b72a6efb KS	117	mcopy = m_copy(m, 0, (int)M_COPYALL);
132c65ba KF	118	goto gottype;
132c65ba KF	119	#endif
38a81509 MK	120	#ifdef ISO
38a81509 MK	121	case AF_ISO: {
b72a6efb	122	int len;
38a81509	123	int ret;
b72a6efb KS	124	struct llc *l;
	125
	126	if ((ret = iso_tryloopback(m, (struct sockaddr_iso *)dst)) >= 0)
	127	return (ret);
	128	ret = iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
	129	(char *)edst, &len);
	130	if (ret > 0) {
	131	m_freem(m); /* Not Resolved */
	132	return(ret);
38a81509 MK	133	}
38a81509 MK	134	M_PREPEND(m, 3, M_DONTWAIT);
b72a6efb	135	if (m == NULL)
38a81509	136	return(0);
38a81509 MK	137	type = m->m_pkthdr.len;
	138	l = mtod(m, struct llc *);
	139	l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
	140	l->llc_control = LLC_UI;
	141	IFDEBUG(D_ETHER)
	142	int i;
	143	printf("unoutput: sending pkt to: ");
	144	for (i=0; i<6; i++)
	145	printf("%x ", edst[i] & 0xff);
	146	printf("\n");
	147	ENDDEBUG
	148	} goto gottype;
	149	#endif ISO
132c65ba KF	150	case AF_UNSPEC:
	151	eh = (struct ether_header *)dst->sa_data;
	152	bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
	153	type = eh->ether_type;
	154	goto gottype;
	155
	156	default:
	157	printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
	158	dst->sa_family);
	159	error = EAFNOSUPPORT;
	160	goto bad;
	161	}
	162
	163	gottrailertype:
	164	/*
	165	* Packet to be sent as trailer: move first packet
	166	* (control information) to end of chain.
	167	*/
	168	while (m->m_next)
	169	m = m->m_next;
	170	m->m_next = m0;
	171	m = m0->m_next;
	172	m0->m_next = 0;
132c65ba KF	173
	174	gottype:
	175	/*
	176	* Add local net header. If no space in first mbuf,
	177	* allocate another.
	178	*/
	179	M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
	180	if (m == 0) {
	181	error = ENOBUFS;
	182	goto bad;
	183	}
	184	eh = mtod(m, struct ether_header *);
38a81509 MK	185	type = htons((u_short)type);
	186	bcopy((caddr_t)&type,(caddr_t)&eh->ether_type,
	187	sizeof(eh->ether_type));
132c65ba KF	188	bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
	189	bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
	190	sizeof(eh->ether_shost));
132c65ba KF	191	/*
	192	* Queue message on interface, and start output if interface
	193	* not yet active.
	194	*/
	195	s = splimp();
	196	if (IF_QFULL(&ifp->if_snd)) {
	197	IF_DROP(&ifp->if_snd);
	198	splx(s);
38a81509 MK	199	error = ENOBUFS;
38a81509 MK	200	goto bad;
132c65ba KF	201	}
	202	IF_ENQUEUE(&ifp->if_snd, m);
	203	if ((ifp->if_flags & IFF_OACTIVE) == 0)
ae4c8bc9	204	(*ifp->if_start)(ifp);
132c65ba	205	splx(s);
38a81509 MK	206	if (mcopy)
	207	(void) looutput(&loif, mcopy, dst);
	208	return (error);
132c65ba KF	209
132c65ba KF	210	bad:
38a81509 MK	211	if (mcopy)
	212	m_freem(mcopy);
	213	if (m)
	214	m_freem(m);
132c65ba KF	215	return (error);
	216	}
	217
	218	/*
ae4c8bc9 BJ	219	* Process a received Ethernet packet;
	220	* the packet is in the mbuf chain m without
	221	* the ether header, which is provided separately.
132c65ba	222	*/
b72a6efb	223	ether_input(ifp, eh, m)
132c65ba KF	224	struct ifnet *ifp;
	225	register struct ether_header *eh;
	226	struct mbuf *m;
	227	{
	228	register struct ifqueue *inq;
38a81509	229	register struct llc *l;
132c65ba KF	230	int s;
132c65ba KF	231
38a81509	232	if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
132c65ba KF	233	sizeof(etherbroadcastaddr)) == 0)
132c65ba KF	234	m->m_flags \|= M_BCAST;
38a81509 MK	235	else if (eh->ether_dhost[0] & 1)
38a81509 MK	236	m->m_flags \|= M_MCAST;
132c65ba KF	237
	238	switch (eh->ether_type) {
	239	#ifdef INET
	240	case ETHERTYPE_IP:
	241	schednetisr(NETISR_IP);
	242	inq = &ipintrq;
	243	break;
	244
	245	case ETHERTYPE_ARP:
	246	arpinput((struct arpcom *)ifp, m);
	247	return;
	248	#endif
	249	#ifdef NS
	250	case ETHERTYPE_NS:
	251	schednetisr(NETISR_NS);
	252	inq = &nsintrq;
	253	break;
	254
	255	#endif
	256	default:
ae4c8bc9	257	#ifdef ISO
b72a6efb	258	if (eh->ether_type > ETHERMTU)
38a81509 MK	259	goto dropanyway;
	260	l = mtod(m, struct llc *);
	261	switch (l->llc_control) {
	262	case LLC_UI:
	263	/* LLC_UI_P forbidden in class 1 service */
	264	if ((l->llc_dsap == LLC_ISO_LSAP) &&
	265	(l->llc_ssap == LLC_ISO_LSAP)) {
38a81509	266	/* LSAP for ISO */
ae4c8bc9 BJ	267	m->m_data += 3; /* XXX */
	268	m->m_len -= 3; /* XXX */
	269	m->m_pkthdr.len -= 3; /* XXX */
b72a6efb KS	270	M_PREPEND(m, sizeof *eh, M_DONTWAIT);
	271	if (m == 0)
	272	return;
	273	mtod(m, struct ether_header ) = *eh;
	274	IFDEBUG(D_ETHER)
	275	printf("clnp packet");
	276	ENDDEBUG
	277	schednetisr(NETISR_ISO);
38a81509	278	inq = &clnlintrq;
ae4c8bc9	279	break;
38a81509	280	}
ae4c8bc9 BJ	281	goto dropanyway;
ae4c8bc9 BJ	282
38a81509 MK	283	case LLC_XID:
	284	case LLC_XID_P:
	285	if(m->m_len < 6)
	286	goto dropanyway;
	287	l->llc_window = 0;
	288	l->llc_fid = 9;
	289	l->llc_class = 1;
	290	l->llc_dsap = l->llc_ssap = 0;
	291	/* Fall through to */
	292	case LLC_TEST:
	293	case LLC_TEST_P:
	294	{
	295	struct sockaddr sa;
	296	register struct ether_header *eh2;
	297	int i;
	298	u_char c = l->llc_dsap;
	299	l->llc_dsap = l->llc_ssap;
	300	l->llc_ssap = c;
b72a6efb KS	301	if (m->m_flags & (M_BCAST \| M_MCAST))
	302	bcopy((caddr_t)ac->ac_enaddr,
	303	(caddr_t)eh->ether_dhost, 6);
38a81509	304	sa.sa_family = AF_UNSPEC;
b72a6efb	305	sa.sa_len = sizeof(sa);
38a81509 MK	306	eh2 = (struct ether_header *)sa.sa_data;
	307	for (i = 0; i < 6; i++) {
	308	eh2->ether_shost[i] = c = eh->ether_dhost[i];
	309	eh2->ether_dhost[i] =
	310	eh->ether_dhost[i] = eh->ether_shost[i];
	311	eh->ether_shost[i] = c;
	312	}
	313	ifp->if_output(ifp, m, &sa);
	314	return;
	315	}
	316	dropanyway:
	317	default:
	318	m_freem(m);
	319	return;
	320	}
ae4c8bc9 BJ	321	#else
	322	m_freem(m);
	323	return;
	324	#endif ISO
132c65ba KF	325	}
	326
	327	s = splimp();
	328	if (IF_QFULL(inq)) {
	329	IF_DROP(inq);
	330	m_freem(m);
	331	} else
	332	IF_ENQUEUE(inq, m);
	333	splx(s);
	334	}
	335
	336	/*
	337	* Convert Ethernet address to printable (loggable) representation.
	338	*/
b72a6efb	339	static char digits[] = "0123456789abcdef";
132c65ba KF	340	char *
	341	ether_sprintf(ap)
	342	register u_char *ap;
	343	{
	344	register i;
	345	static char etherbuf[18];
	346	register char *cp = etherbuf;
132c65ba KF	347
	348	for (i = 0; i < 6; i++) {
	349	cp++ = digits[ap >> 4];
	350	cp++ = digits[ap++ & 0xf];
	351	*cp++ = ':';
	352	}
	353	*--cp = 0;
	354	return (etherbuf);
	355	}