usr/src/uts/common/io/llc1.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * llc1 - an LLC Class 1 MUX compatible with SunConnect LLC2 uses DLPI
 * interface.  Its primary use is to support RPL for network boot but can be
 * used by other protocols.
 */

#include <sys/types.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <sys/mkdev.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/devops.h>
#include <sys/sunddi.h>
#include <sys/ksynch.h>
#include <sys/dlpi.h>
#include <sys/ethernet.h>
#include <sys/strsun.h>
#include <sys/stat.h>
#include <netinet/in.h> /* for byteorder macros on machines that define them */
#include <sys/llc1.h>
#include <sys/kstat.h>
#include <sys/debug.h>

/*
 * function prototypes, etc.
 */
static int llc1_open(queue_t *q, dev_t *dev, int flag, int sflag,
	cred_t *cred);
static int llc1_close(queue_t *q, int flag, cred_t *cred);
static int llc1_uwput(queue_t *q, mblk_t *mp);
static int llc1_uwsrv(queue_t *q);
static int llc1_lrsrv(queue_t *q);
static int llc1_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int llc1_detach(dev_info_t *dev, ddi_detach_cmd_t cmd);
static int llc1_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd);

static mblk_t *llc1_form_udata(llc1_t *lld, llc_mac_info_t *macinfo,
	mblk_t *mp);
static mblk_t *llc1_xid_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap);
static mblk_t *llc1_xid_ind_con(llc1_t *lld, llc_mac_info_t *macinfo,
	mblk_t *mp);
static mblk_t *llc1_test_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap);
static mblk_t *llc1_test_ind_con(llc1_t *lld, llc_mac_info_t *macinfo,
	mblk_t *mp);

static void llc1_ioctl(queue_t *q, mblk_t *mp);
static void llc1_recv(llc_mac_info_t *macinfo, mblk_t *mp);
static void llc1_req_raw(llc_mac_info_t *macinfo);
static void llc1_find_waiting(llc_mac_info_t *macinfo, mblk_t *mp, long prim);

static minor_t llc1_findminor(llc1dev_t *device);
static void llc1_send_disable_multi(llc_mac_info_t *, llc_mcast_t *);

static void llc1insque(void *elem, void *pred);
static void llc1remque(void *arg);
static void llc1error();
static int llc1_subs_unbind(void);
static void llc1_init_kstat(llc_mac_info_t *macinfo);
static void llc1_uninit_kstat(llc_mac_info_t *macinfo);
static int llc1_update_kstat(kstat_t *ksp, int rw);
static int llc1_broadcast(struct ether_addr *addr, llc_mac_info_t *macinfo);
static int llc1_unbind(queue_t *q, mblk_t *mp);
static int llc1_subs_bind(queue_t *q, mblk_t *mp);
static int llc1_unitdata(queue_t *q, mblk_t *mp);
static int llc1_inforeq(queue_t *q, mblk_t *mp);
static int llc1attach(queue_t *q, mblk_t *mp);
static void llc1_send_bindreq(llc_mac_info_t *macinfo);
static int llc1_req_info(queue_t *q);
static int llc1_cmds(queue_t *q, mblk_t *mp);
static int llc1_setppa(struct ll_snioc *snioc);
static int llc1_getppa(llc_mac_info_t *macinfo, struct ll_snioc *snioc);
static int llc1_bind(queue_t *q, mblk_t *mp);
static int llc1unattach(queue_t *q, mblk_t *mp);
static int llc1_enable_multi(queue_t *q, mblk_t *mp);
static int llc1_disable_multi(queue_t *q, mblk_t *mp);
static int llc1_xid_req_res(queue_t *q, mblk_t *mp, int req_or_res);
static int llc1_test_req_res(queue_t *q, mblk_t *mp, int req_or_res);
static int llc1_local(struct ether_addr *addr, llc_mac_info_t *macinfo);
static int llc1_snap_match(llc1_t *lld, struct snaphdr *snap);

/*
 * the standard streams glue for defining the type of streams entity and the
 * operational parameters.
 */

static struct module_info llc1_minfo = {
	LLC1IDNUM,
	"llc1",
	0,
	LLC1_DEFMAX,
	LLC1_HIWATER,		/* high water mark */
	LLC1_LOWATER,		/* low water mark */
};

static struct qinit llc1_rint = {
	NULL,
	NULL,
	llc1_open,
	llc1_close,
	NULL,
	&llc1_minfo,
	NULL
};

static struct qinit llc1_wint = {
	llc1_uwput,
	llc1_uwsrv,
	NULL,
	NULL,
	NULL,
	&llc1_minfo,
	NULL
};

static struct qinit llc1_muxrint = {
	putq,
	llc1_lrsrv,
	NULL,
	NULL,
	NULL,
	&llc1_minfo,
	NULL
};

static struct qinit llc1_muxwint = {
	NULL,
	NULL,
	NULL,
	NULL,
	NULL,
	&llc1_minfo,
	NULL
};

struct streamtab llc1_info = {
	&llc1_rint,
	&llc1_wint,
	&llc1_muxrint,
	&llc1_muxwint
};

/*
 * loadable module/driver wrapper this allows llc1 to be unloaded later
 */

#if !defined(BUILD_STATIC)
#include <sys/modctl.h>

/* define the "ops" structure for a STREAMS driver */
DDI_DEFINE_STREAM_OPS(llc1_ops, nulldev, nulldev, llc1_attach,
    llc1_detach, nodev, llc1_getinfo, D_MP | D_MTPERMOD, &llc1_info,
    ddi_quiesce_not_supported);

/*
 * Module linkage information for the kernel.
 */
static struct modldrv modldrv = {
	&mod_driverops,		/* Type of module.  This one is a driver */
	"LLC Class 1 Driver",
	&llc1_ops,		/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modldrv, NULL
};

int
_init(void)
{
	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

#endif

#ifdef LLC1_DEBUG
extern int llc1_debug = 0x0;

#endif

/*
 * Allocate and zero-out "number" structures each of type "structure" in
 * kernel memory.
 */
#define	GETSTRUCT(structure, number)   \
	(kmem_zalloc(sizeof (structure) * (number), KM_NOSLEEP))
#define	GETBUF(structure, size) \
	(kmem_zalloc(size, KM_NOSLEEP))

static struct llc1device llc1_device_list;

/*
 * llc1_attach - init time attach support When the hardware specific attach
 * is called, it must call this procedure with the device class structure
 */

static int
llc1_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd)
{
	if (cmd != DDI_ATTACH)
		return (DDI_FAILURE);

	/*
	 * there isn't any hardware but we do need to initialize things
	 */
	if (!(llc1_device_list.llc1_status & LLC1_ATTACHED)) {
		llc1_device_list.llc1_status |= LLC1_ATTACHED;
		rw_init(&llc1_device_list.llc1_rwlock, NULL, RW_DRIVER, NULL);

		/* make sure minor device lists are initialized */
		llc1_device_list.llc1_str_next =
		    llc1_device_list.llc1_str_prev =
		    (llc1_t *)&llc1_device_list.llc1_str_next;

		/* make sure device list is initialized */
		llc1_device_list.llc1_mac_next =
		    llc1_device_list.llc1_mac_prev =
		    (llc_mac_info_t *)&llc1_device_list.llc1_mac_next;
	}

	/*
	 * now do all the DDI stuff necessary
	 */

	ddi_set_driver_private(devinfo, &llc1_device_list);

	/*
	 * create the file system device node
	 */
	if (ddi_create_minor_node(devinfo, "llc1", S_IFCHR,
	    0, DDI_PSEUDO, CLONE_DEV) == DDI_FAILURE) {
		llc1error(devinfo, "ddi_create_minor_node failed");
		ddi_remove_minor_node(devinfo, NULL);
		return (DDI_FAILURE);
	}
	llc1_device_list.llc1_multisize = ddi_getprop(DDI_DEV_T_NONE,
	    devinfo, 0, "multisize", 0);
	if (llc1_device_list.llc1_multisize == 0)
		llc1_device_list.llc1_multisize = LLC1_MAX_MULTICAST;

	ddi_report_dev(devinfo);
	return (DDI_SUCCESS);
}

/*
 * llc1_detach standard kernel interface routine
 */

static int
llc1_detach(dev_info_t *dev, ddi_detach_cmd_t cmd)
{
	if (cmd != DDI_DETACH) {
		return (DDI_FAILURE);
	}
	if (llc1_device_list.llc1_ndevice > 0)
		return (DDI_FAILURE);
	/* remove all mutex and locks */
	rw_destroy(&llc1_device_list.llc1_rwlock);
	llc1_device_list.llc1_status = 0;	/* no longer attached */
	ddi_remove_minor_node(dev, NULL);
	return (DDI_SUCCESS);
}

/*
 * llc1_devinfo(dev, cmd, arg, result) standard kernel devinfo lookup
 * function
 */
/*ARGSUSED2*/
static int
llc1_getinfo(dev_info_t *dev, ddi_info_cmd_t cmd, void *arg, void **result)
{
	int error;

	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		if (dev == NULL) {
			error = DDI_FAILURE;
		} else {
			*result = (void *)dev;
			error = DDI_SUCCESS;
		}
		break;
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)0;
		error = DDI_SUCCESS;
		break;
	default:
		error = DDI_FAILURE;
	}
	return (error);
}

/*
 * llc1_open()
 * LLC1 open routine, called when device is opened by the user
 */

/*ARGSUSED2*/
static int
llc1_open(queue_t *q, dev_t *dev, int flag, int sflag, cred_t *cred)
{
	llc1_t *llc1;
	minor_t	minordev;
	int	status = 0;

	ASSERT(q);

	/*
	 * Stream already open, sucess.
	 */
	if (q->q_ptr)
		return (0);
	/*
	 * Serialize access through open/close this will serialize across all
	 * llc1 devices, but open and close are not frequent so should not
	 * induce much, if any delay.
	 */
	rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);

	if (sflag == CLONEOPEN) {
		/* need to find a minor dev */
		minordev = llc1_findminor(&llc1_device_list);
		if (minordev == 0) {
			rw_exit(&llc1_device_list.llc1_rwlock);
			return (ENXIO);
		}
		*dev = makedevice(getmajor(*dev), minordev);
	} else {
		minordev = getminor (*dev);
		if ((minordev > MAXMIN32) || (minordev == 0)) {
			rw_exit(&llc1_device_list.llc1_rwlock);
			return (ENXIO);
		}
	}

	/*
	 * get a per-stream structure and link things together so we
	 * can easily find them later.
	 */

	llc1 = kmem_zalloc(sizeof (llc1_t), KM_SLEEP);
	llc1->llc_qptr = q;
	WR(q)->q_ptr = q->q_ptr = (caddr_t)llc1;
	/*
	 * fill in the structure and state info
	 */
	llc1->llc_state = DL_UNATTACHED;
	llc1->llc_style = DL_STYLE2;
	llc1->llc_minor = minordev;

	mutex_init(&llc1->llc_lock, NULL, MUTEX_DRIVER, NULL);
	llc1insque(llc1, llc1_device_list.llc1_str_prev);
	rw_exit(&llc1_device_list.llc1_rwlock);
	qprocson(q);		/* start the queues running */
	return (status);
}

/*
 * llc1_close(q)
 * normal stream close call checks current status and cleans up
 * data structures that were dynamically allocated
 */
/*ARGSUSED1*/
static int
llc1_close(queue_t *q, int flag, cred_t *cred)
{
	llc1_t *llc1;

	ASSERT(q);
	ASSERT(q->q_ptr);

	qprocsoff(q);
	llc1 = (llc1_t *)q->q_ptr;
	rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
	/* completely disassociate the stream from the device */
	q->q_ptr = WR(q)->q_ptr = NULL;

	(void) llc1remque(llc1); /* remove from active list */
	rw_exit(&llc1_device_list.llc1_rwlock);

	mutex_enter(&llc1->llc_lock);
	if (llc1->llc_state == DL_IDLE || llc1->llc_state == DL_UNBOUND) {
		llc1->llc_state = DL_UNBOUND;	/* force the issue */
	}

	if (llc1->llc_mcast != NULL) {
		int	i;

		for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
			llc_mcast_t *mcast;

			if ((mcast = llc1->llc_mcast[i]) != NULL) {
				/*
				 * disable from stream and possibly
				 * lower stream
				 */
				if (llc1->llc_mac_info &&
				    llc1->llc_mac_info->llcp_flags &
				    LLC1_AVAILABLE)
					llc1_send_disable_multi(
					    llc1->llc_mac_info,
					    mcast);
				llc1->llc_mcast[i] = NULL;
			}
		}
		kmem_free(llc1->llc_mcast,
		    sizeof (llc_mcast_t *) * llc1->llc_multicnt);
		llc1->llc_mcast = NULL;
	}
	llc1->llc_state = DL_UNATTACHED;

	mutex_exit(&llc1->llc_lock);

	mutex_destroy(&llc1->llc_lock);

	kmem_free(llc1, sizeof (llc1_t));

	return (0);
}

/*
 * llc1_uwput()
 * general llc stream write put routine. Receives ioctl's from
 * user level and data from upper modules and processes them immediately.
 * M_PROTO/M_PCPROTO are queued for later processing by the service
 * procedure.
 */

static int
llc1_uwput(queue_t *q, mblk_t *mp)
{
	llc1_t *ld = (llc1_t *)(q->q_ptr);

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_wput(%x %x): type %d\n", q, mp, DB_TYPE(mp));
#endif
	switch (DB_TYPE(mp)) {

	case M_IOCTL:		/* no waiting in ioctl's */
		(void) llc1_ioctl(q, mp);
		break;

	case M_FLUSH:		/* canonical flush handling */
		if (*mp->b_rptr & FLUSHW)
			flushq(q, 0);

		if (*mp->b_rptr & FLUSHR) {
			flushq(RD(q), 0);
			*mp->b_rptr &= ~FLUSHW;
			qreply(q, mp);
		} else
			freemsg(mp);
		break;

		/* for now, we will always queue */
	case M_PROTO:
	case M_PCPROTO:
		(void) putq(q, mp);
		break;

	case M_DATA:
		/* fast data / raw support */
		if ((ld->llc_flags & (LLC_RAW | LLC_FAST)) == 0 ||
		    ld->llc_state != DL_IDLE) {
			(void) merror(q, mp, EPROTO);
			break;
		}
		/* need to do further checking */
		(void) putq(q, mp);
		break;

	default:
#ifdef LLC1_DEBUG
		if (llc1_debug & LLCERRS)
			printf("llc1: Unexpected packet type from queue: %d\n",
			    mp->b_datap->db_type);
#endif
		freemsg(mp);
	}
	return (0);
}

/*
 * llc1_lrsrv()
 * called when data is put into the service queue from below.
 * Determines additional processing that might be needed and sends the data
 * upstream in the form of a Data Indication packet.
 */
static int
llc1_lrsrv(queue_t *q)
{
	mblk_t *mp;
	union DL_primitives *prim;
	llc_mac_info_t *macinfo = (llc_mac_info_t *)q->q_ptr;
	struct iocblk *iocp;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_rsrv(%x)\n", q);
	if (llc1_debug & LLCRECV) {
		printf("llc1_lrsrv: q=%x macinfo=%x", q, macinfo);
		if (macinfo == NULL) {
			printf("NULL macinfo");
			panic("null macinfo in lrsrv");
			/*NOTREACHED*/
		}
		printf("\n");
	}
#endif

	/*
	 * determine where message goes, then call the proper handler
	 */

	while ((mp = getq(q)) != NULL) {
		switch (DB_TYPE(mp)) {
		case M_PROTO:
		case M_PCPROTO:
			prim = (union DL_primitives *)mp->b_rptr;
			/* only some primitives ever get passed through */
			switch (prim->dl_primitive) {
			case DL_INFO_ACK:
				if (macinfo->llcp_flags & LLC1_LINKED) {
					/*
					 * we are in the midst of completing
					 * the I_LINK/I_PLINK and needed this
					 * info
					 */
					macinfo->llcp_flags &= ~LLC1_LINKED;
					macinfo->llcp_flags |= LLC1_AVAILABLE;
					macinfo->llcp_maxpkt =
					    prim->info_ack.dl_max_sdu;
					macinfo->llcp_minpkt =
					    prim->info_ack.dl_min_sdu;
					macinfo->llcp_type =
					    prim->info_ack.dl_mac_type;
					if (macinfo->llcp_type == DL_ETHER) {
						macinfo->llcp_type = DL_CSMACD;
						/*
						 * size of max header
						 * (including SNAP)
						 */
						macinfo->llcp_maxpkt -= 8;
					}
					macinfo->llcp_addrlen =
					    prim->info_ack.dl_addr_length -
					    ABS(prim->info_ack.dl_sap_length);

					bcopy(mp->b_rptr +
					    prim->info_ack.dl_addr_offset,
					    macinfo->llcp_macaddr,
					    macinfo->llcp_addrlen);
					bcopy(mp->b_rptr +
					    prim->info_ack.
					    dl_brdcst_addr_offset,
					    macinfo->llcp_broadcast,
					    prim->info_ack.
					    dl_brdcst_addr_length);

					if (prim->info_ack.dl_current_state ==
					    DL_UNBOUND)
						llc1_send_bindreq(macinfo);
					freemsg(mp);
					/*
					 * need to put the lower stream into
					 * DLRAW mode.  Currently only DL_ETHER
					 * or DL_CSMACD
					 */
					switch (macinfo->llcp_type) {
					case DL_ETHER:
					case DL_CSMACD:
						/*
						 * raw mode is optimal so ask
						 * for it * we might not get
						 * it but that's OK
						 */
						llc1_req_raw(macinfo);
						break;
					default:
						/*
						 * don't want raw mode so don't
						 * ask for it
						 */
						break;
					}
				} else {
					if (prim->info_ack.dl_current_state ==
					    DL_IDLE)
					/* address was wrong before */
					bcopy(mp->b_rptr +
					    prim->info_ack.dl_addr_offset,
					    macinfo->llcp_macaddr,
					    macinfo->llcp_addrlen);
					freemsg(mp);
				}
				break;
			case DL_BIND_ACK:
				/*
				 * if we had to bind, the macaddr is wrong
				 * so get it again
				 */
				freemsg(mp);
				(void) llc1_req_info(q);
				break;
			case DL_UNITDATA_IND:
				/* when not using raw mode we get these */
				(void) llc1_recv(macinfo, mp);
				break;
			case DL_ERROR_ACK:
				/* binding is a special case */
				if (prim->error_ack.dl_error_primitive ==
				    DL_BIND_REQ) {
					freemsg(mp);
					if (macinfo->llcp_flags & LLC1_BINDING)
						llc1_send_bindreq(macinfo);
				} else
					llc1_find_waiting(macinfo, mp,
					    prim->error_ack.dl_error_primitive);
				break;
			case DL_PHYS_ADDR_ACK:
				llc1_find_waiting(macinfo, mp,
				    DL_PHYS_ADDR_REQ);
				break;
			case DL_OK_ACK:
				if (prim->ok_ack.dl_correct_primitive ==
				    DL_BIND_REQ)
					macinfo->llcp_flags &= ~LLC1_BINDING;
				/* FALLTHROUGH */
			default:
				freemsg(mp);
			}
			break;

		case M_IOCACK:
			/* probably our DLIOCRAW completing */
			iocp = (struct iocblk *)mp->b_rptr;
			if ((macinfo->llcp_flags & LLC1_RAW_WAIT) &&
			    macinfo->llcp_iocid == iocp->ioc_id) {
				macinfo->llcp_flags &= ~LLC1_RAW_WAIT;
				/* we can use this form */
				macinfo->llcp_flags |= LLC1_USING_RAW;
				freemsg(mp);
				break;
			}
			/* need to find the correct queue */
			freemsg(mp);
			break;
		case M_IOCNAK:
			iocp = (struct iocblk *)mp->b_rptr;
			if ((macinfo->llcp_flags & LLC1_RAW_WAIT) &&
			    macinfo->llcp_iocid == iocp->ioc_id) {
				macinfo->llcp_flags &= ~LLC1_RAW_WAIT;
				freemsg(mp);
				break;
			}
			/* need to find the correct queue */
			freemsg(mp);
			break;
		case M_DATA:
			llc1_recv(macinfo, mp);
			break;
		}
	}
	return (0);
}

/*
 * llc1_uwsrv - Incoming messages are processed according to the DLPI
 * protocol specification
 */

static int
llc1_uwsrv(queue_t *q)
{
	mblk_t *mp;
	llc1_t *lld = (llc1_t *)q->q_ptr;
	union DL_primitives *prim;
	int	err;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_wsrv(%x)\n", q);
#endif


	while ((mp = getq(q)) != NULL) {
		switch (mp->b_datap->db_type) {
		case M_PROTO:	/* Will be an DLPI message of some type */
		case M_PCPROTO:
			if ((err = llc1_cmds(q, mp)) != LLCE_OK) {
				prim = (union DL_primitives *)mp->b_rptr;
				if (err == LLCE_NOBUFFER || err == DL_SYSERR) {
					/* quit while we're ahead */
					lld->llc_stats->llcs_nobuffer++;
#ifdef LLC1_DEBUG
					if (llc1_debug & LLCERRS)
						printf(
"llc1_cmds: nonfatal err=%d\n",
						    err);
#endif
					(void) putbq(q, mp);
					return (0);

				} else {
					dlerrorack(q, mp,
					    prim->dl_primitive,
					    err, 0);
				}
			}
			break;
		case M_DATA:
			/*
			 * retry of a previously processed
			 * UNITDATA_REQ or is a RAW message from
			 * above
			 */

			mutex_enter(&lld->llc_lock);
			putnext(lld->llc_mac_info->llcp_queue, mp);
			mutex_exit(&lld->llc_lock);
			freemsg(mp);	/* free on success */
			break;

			/* This should never happen */
		default:
#ifdef LLC1_DEBUG
			if (llc1_debug & LLCERRS)
				printf("llc1_wsrv: type(%x) not supported\n",
				    mp->b_datap->db_type);
#endif
			freemsg(mp);	/* unknown types are discarded */
			break;
		}
	}
	return (0);
}

/*
 * llc1_multicast used to determine if the address is a multicast address for
 * this user.
 */
int
llc1_multicast(struct ether_addr *addr, llc1_t *lld)
{
	int i;

	if (lld->llc_mcast)
		for (i = 0; i < lld->llc_multicnt; i++)
			if (lld->llc_mcast[i] &&
			    lld->llc_mcast[i]->llcm_refcnt &&
			    bcmp(lld->llc_mcast[i]->llcm_addr,
			    addr->ether_addr_octet, ETHERADDRL) == 0)
				return (1);
	return (0);
}

/*
 * llc1_ioctl handles all ioctl requests passed downstream. This routine is
 * passed a pointer to the message block with the ioctl request in it, and a
 * pointer to the queue so it can respond to the ioctl request with an ack.
 */

int	llc1_doreqinfo;

static void
llc1_ioctl(queue_t *q, mblk_t *mp)
{
	struct iocblk *iocp;
	llc1_t *lld;
	struct linkblk *link;
	llc_mac_info_t *macinfo;
	mblk_t *tmp;
	int error;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_ioctl(%x %x)\n", q, mp);
#endif
	lld = (llc1_t *)q->q_ptr;
	iocp = (struct iocblk *)mp->b_rptr;
	switch (iocp->ioc_cmd) {
		/* XXX need to lock the data structures */
	case I_PLINK:
	case I_LINK:
		link = (struct linkblk *)mp->b_cont->b_rptr;
		tmp = allocb(sizeof (llc_mac_info_t), BPRI_MED);
		if (tmp == NULL) {
			(void) miocnak(q, mp, 0, ENOSR);
			return;
		}
		bzero(tmp->b_rptr, sizeof (llc_mac_info_t));
		macinfo = (llc_mac_info_t *)tmp->b_rptr;
		macinfo->llcp_mb = tmp;
		macinfo->llcp_next = macinfo->llcp_prev = macinfo;
		macinfo->llcp_queue = link->l_qbot;
		macinfo->llcp_lindex = link->l_index;
		/* tentative */
		macinfo->llcp_ppa = --llc1_device_list.llc1_nextppa;
		llc1_device_list.llc1_ndevice++;
		macinfo->llcp_flags |= LLC1_LINKED | LLC1_DEF_PPA;
		macinfo->llcp_lqtop = q;
		macinfo->llcp_data = NULL;

		/* need to do an info_req before an info_req or attach */

		rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
		llc1insque(macinfo, llc1_device_list.llc1_mac_prev);
		macinfo->llcp_queue->q_ptr = RD(macinfo->llcp_queue)->q_ptr =
		    (caddr_t)macinfo;
		llc1_init_kstat(macinfo);
		rw_exit(&llc1_device_list.llc1_rwlock);

		/* initiate getting the info */
		(void) llc1_req_info(macinfo->llcp_queue);

		miocack(q, mp, 0, 0);
		return;

	case I_PUNLINK:
	case I_UNLINK:
		link = (struct linkblk *)mp->b_cont->b_rptr;
		rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
		for (macinfo = llc1_device_list.llc1_mac_next;
		    macinfo != NULL &&
		    macinfo !=
		    (llc_mac_info_t *)&llc1_device_list.llc1_mac_next;
		    macinfo = macinfo->llcp_next) {
			if (macinfo->llcp_lindex == link->l_index &&
			    macinfo->llcp_queue == link->l_qbot) {
				/* found it */

				ASSERT(macinfo->llcp_next);

			    /* remove from device list */
				llc1_device_list.llc1_ndevice--;
				llc1remque(macinfo);

			    /* remove any mcast structs */
				if (macinfo->llcp_mcast != NULL) {
				kmem_free(macinfo->llcp_mcast,
				    sizeof (llc_mcast_t) *
				    llc1_device_list.llc1_multisize);
				macinfo->llcp_mcast = NULL;
				}

			    /* remove any kstat counters */
				if (macinfo->llcp_kstatp != NULL)
				llc1_uninit_kstat(macinfo);
				if (macinfo->llcp_mb != NULL)
				freeb(macinfo->llcp_mb);

				lld->llc_mac_info = NULL;

				miocack(q, mp, 0, 0);

			    /* finish any necessary setup */
				if (llc1_device_list.llc1_ndevice == 0)
				llc1_device_list.llc1_nextppa = 0;

				rw_exit(&llc1_device_list.llc1_rwlock);
				return;
			}
		}
		rw_exit(&llc1_device_list.llc1_rwlock);
		/*
		 * what should really be done here -- force errors on all
		 * streams?
		 */
		miocnak(q, mp, 0, EINVAL);
		return;

	case L_SETPPA:
		error = miocpullup(mp, sizeof (struct ll_snioc));
		if (error != 0) {
			miocnak(q, mp, 0, error);
			return;
		}

		if (llc1_setppa((struct ll_snioc *)mp->b_cont->b_rptr) >= 0) {
			miocack(q, mp, 0, 0);
			return;
		}
		miocnak(q, mp, 0, EINVAL);
		return;

	case L_GETPPA:
		if (mp->b_cont == NULL) {
			mp->b_cont = allocb(sizeof (struct ll_snioc), BPRI_MED);
			if (mp->b_cont == NULL) {
				miocnak(q, mp, 0, ENOSR);
				return;
			}
			mp->b_cont->b_wptr =
			    mp->b_cont->b_rptr + sizeof (struct ll_snioc);
		} else {
			error = miocpullup(mp, sizeof (struct ll_snioc));
			if (error != 0) {
				miocnak(q, mp, 0, error);
				return;
			}
		}

		lld = (llc1_t *)q->q_ptr;
		if (llc1_getppa(lld->llc_mac_info,
		    (struct ll_snioc *)mp->b_cont->b_rptr) >= 0)
			miocack(q, mp, 0, 0);
		else
			miocnak(q, mp, 0, EINVAL);
		return;
	default:
		miocnak(q, mp, 0, EINVAL);
	}
}

/*
 * llc1_setppa(snioc) this function sets the real PPA number for a previously
 * I_LINKED stream. Be careful to select the macinfo struct associated
 * with our llc struct, to avoid erroneous references.
 */

static int
llc1_setppa(struct ll_snioc *snioc)
{
	llc_mac_info_t *macinfo;

	for (macinfo = llc1_device_list.llc1_mac_next;
	    macinfo != (llc_mac_info_t *)&llc1_device_list.llc1_mac_next;
	    macinfo = macinfo->llcp_next)
		if (macinfo->llcp_lindex == snioc->lli_index &&
		    (macinfo->llcp_flags & LLC1_DEF_PPA)) {
			macinfo->llcp_flags &= ~LLC1_DEF_PPA;
			macinfo->llcp_ppa = snioc->lli_ppa;
			return (0);
		}
	return (-1);
}

/*
 * llc1_getppa(macinfo, snioc) returns the PPA for this stream
 */
static int
llc1_getppa(llc_mac_info_t *macinfo, struct ll_snioc *snioc)
{
	if (macinfo == NULL)
		return (-1);
	snioc->lli_ppa = macinfo->llcp_ppa;
	snioc->lli_index = macinfo->llcp_lindex;
	return (0);
}

/*
 * llc1_cmds - process the DL commands as defined in dlpi.h
 */
static int
llc1_cmds(queue_t *q, mblk_t *mp)
{
	union DL_primitives *dlp;
	llc1_t *llc = (llc1_t *)q->q_ptr;
	int	result = 0;
	llc_mac_info_t *macinfo = llc->llc_mac_info;

	dlp = (union DL_primitives *)mp->b_rptr;
#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_cmds(%x, %x):dlp=%x, dlp->dl_primitive=%d\n",
		    q, mp, dlp, dlp->dl_primitive);
#endif
	mutex_enter(&llc->llc_lock);
	rw_enter(&llc1_device_list.llc1_rwlock, RW_READER);

	switch (dlp->dl_primitive) {
	case DL_BIND_REQ:
		result = llc1_bind(q, mp);
		break;

	case DL_UNBIND_REQ:
		result = llc1_unbind(q, mp);
		break;

	case DL_SUBS_BIND_REQ:
		result = llc1_subs_bind(q, mp);
		break;

	case DL_SUBS_UNBIND_REQ:
		result = llc1_subs_unbind();
		break;

	case DL_UNITDATA_REQ:
		result = llc1_unitdata(q, mp);
		break;

	case DL_INFO_REQ:
		result = llc1_inforeq(q, mp);
		break;

	case DL_ATTACH_REQ:
		result = llc1attach(q, mp);
		break;

	case DL_DETACH_REQ:
		result = llc1unattach(q, mp);
		break;

	case DL_ENABMULTI_REQ:
		result = llc1_enable_multi(q, mp);
		break;

	case DL_DISABMULTI_REQ:
		result = llc1_disable_multi(q, mp);
		break;

	case DL_XID_REQ:
		result = llc1_xid_req_res(q, mp, 0);
		break;

	case DL_XID_RES:
		result = llc1_xid_req_res(q, mp, 1);
		break;

	case DL_TEST_REQ:
		result = llc1_test_req_res(q, mp, 0);
		break;

	case DL_TEST_RES:
		result = llc1_test_req_res(q, mp, 1);
		break;

	case DL_SET_PHYS_ADDR_REQ:
		result = DL_NOTSUPPORTED;
		break;

	case DL_PHYS_ADDR_REQ:
		if (llc->llc_state != DL_UNATTACHED && macinfo) {
			llc->llc_waiting_for = dlp->dl_primitive;
			putnext(WR(macinfo->llcp_queue), mp);
			result = LLCE_OK;
		} else {
			result = DL_OUTSTATE;
		}
		break;

	case DL_PROMISCON_REQ:
	case DL_PROMISCOFF_REQ:
		result = DL_NOTSUPPORTED;
		break;

	default:
#ifdef LLC1_DEBUG
		if (llc1_debug & LLCERRS)
			printf("llc1_cmds: Received unknown primitive: %d\n",
			    dlp->dl_primitive);
#endif
		result = DL_BADPRIM;
		break;
	}
	rw_exit(&llc1_device_list.llc1_rwlock);
	mutex_exit(&llc->llc_lock);
	return (result);
}

/*
 * llc1_bind - determine if a SAP is already allocated and whether it is
 * legal to do the bind at this time
 */
static int
llc1_bind(queue_t *q, mblk_t *mp)
{
	int	sap;
	dl_bind_req_t *dlp;
	llc1_t *lld = (llc1_t *)q->q_ptr;

	ASSERT(lld);

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_bind(%x %x)\n", q, mp);
#endif

	dlp = (dl_bind_req_t *)mp->b_rptr;
	sap = dlp->dl_sap;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCPROT)
		printf("llc1_bind: lsap=%x\n", sap);
#endif

	if (lld->llc_mac_info == NULL)
		return (DL_OUTSTATE);

	if (lld->llc_qptr && lld->llc_state != DL_UNBOUND) {
#ifdef LLC1_DEBUG
		if (llc1_debug & LLCERRS)
			printf("llc1_bind: stream bound/not attached (%d)\n",
			    lld->llc_state);
#endif
		return (DL_OUTSTATE);
	}

	if (dlp->dl_service_mode != DL_CLDLS || dlp->dl_max_conind != 0) {
		return (DL_UNSUPPORTED);
	}
	/*
	 * prohibit group saps.	An exception is the broadcast sap which is,
	 * unfortunately, used by SUNSelect to indicate Novell Netware in
	 * 802.3 mode.	Really should use a very non-802.2 SAP like 0xFFFF
	 * or -2.
	 */

	if (sap == 0 || (sap <= 0xFF && (sap & 1 && sap != 0xFF)) ||
	    sap > 0xFFFF) {
		return (DL_BADSAP);
	}
	lld->llc_state = DL_BIND_PENDING;

	/* if we fall through, then the SAP is legal */
	if (sap == 0xFF) {
		if (lld->llc_mac_info->llcp_type == DL_CSMACD)
			sap = LLC_NOVELL_SAP;
		else
			return (DL_BADSAP);
	}
	lld->llc_sap = sap;

	if (sap > 0xFF) {
		ushort_t snapsap = htons(sap);
		/* this is SNAP, so set things up */
		lld->llc_snap[3] = ((uchar_t *)&snapsap)[0];
		lld->llc_snap[4] = ((uchar_t *)&snapsap)[1];
		/* mark as SNAP but allow OID to be added later */
		lld->llc_flags |= LLC_SNAP;
		lld->llc_sap = LLC_SNAP_SAP;
	}

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCPROT)
		printf("llc1_bind: ok - type = %d\n", lld->llc_type);
#endif

	if (dlp->dl_xidtest_flg & DL_AUTO_XID)
		lld->llc_flags |= LLC1_AUTO_XID;
	if (dlp->dl_xidtest_flg & DL_AUTO_TEST)
		lld->llc_flags |= LLC1_AUTO_TEST;

	/* ACK the BIND, if possible */

	dlbindack(q, mp, sap, lld->llc_mac_info->llcp_macaddr, 6, 0, 0);

	lld->llc_state = DL_IDLE;	/* bound and ready */

	return (LLCE_OK);
}

/*
 * llc1_unbind - perform an unbind of an LSAP or ether type on the stream.
 * The stream is still open and can be re-bound.
 */
static int
llc1_unbind(queue_t *q, mblk_t *mp)
{
	llc1_t *lld;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_unbind(%x %x)\n", q, mp);
#endif
	lld = (llc1_t *)q->q_ptr;

	if (lld->llc_mac_info == NULL)
		return (DL_OUTSTATE);

	if (lld->llc_state != DL_IDLE) {
#ifdef LLC1_DEBUG
		if (llc1_debug & LLCERRS)
			printf("llc1_unbind: wrong state (%d)\n",
			    lld->llc_state);
#endif
		return (DL_OUTSTATE);
	}
	lld->llc_state = DL_UNBIND_PENDING;
	lld->llc_flags &= ~(LLC_SNAP|LLC_SNAP_OID); /* just in case */
	dlokack(q, mp, DL_UNBIND_REQ);
	lld->llc_state = DL_UNBOUND;
	return (LLCE_OK);
}

/*
 * llc1_inforeq - generate the response to an info request
 */
static int
llc1_inforeq(queue_t *q, mblk_t *mp)
{
	llc1_t *lld;
	mblk_t *nmp;
	dl_info_ack_t *dlp;
	int	bufsize;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_inforeq(%x %x)\n", q, mp);
#endif
	lld = (llc1_t *)q->q_ptr;
	ASSERT(lld);
	if (lld->llc_mac_info == NULL)
		bufsize = sizeof (dl_info_ack_t) + ETHERADDRL;
	else
		bufsize = sizeof (dl_info_ack_t) +
		    2 * lld->llc_mac_info->llcp_addrlen + 2;

	nmp = mexchange(q, mp, bufsize, M_PCPROTO, DL_INFO_ACK);

	if (nmp) {
		nmp->b_wptr = nmp->b_rptr + sizeof (dl_info_ack_t);
		dlp = (dl_info_ack_t *)nmp->b_rptr;
		bzero(dlp, DL_INFO_ACK_SIZE);
		dlp->dl_primitive = DL_INFO_ACK;
		if (lld->llc_mac_info)
			dlp->dl_max_sdu = lld->llc_mac_info->llcp_maxpkt;
		dlp->dl_min_sdu = 0;
		dlp->dl_mac_type = lld->llc_type;
		dlp->dl_service_mode = DL_CLDLS;
		dlp->dl_current_state = lld->llc_state;
		dlp->dl_provider_style =
		    (lld->llc_style == 0) ? lld->llc_style : DL_STYLE2;

		/* now append physical address */
		if (lld->llc_mac_info) {
			dlp->dl_addr_length = lld->llc_mac_info->llcp_addrlen;
			dlp->dl_addr_offset = DL_INFO_ACK_SIZE;
			nmp->b_wptr += dlp->dl_addr_length + 1;
			bcopy(lld->llc_mac_info->llcp_macaddr,
			    ((caddr_t)dlp) + dlp->dl_addr_offset,
			    lld->llc_mac_info->llcp_addrlen);
			if (lld->llc_state == DL_IDLE) {
				dlp->dl_sap_length = -1; /* 1 byte on end */
				*(((caddr_t)dlp) + dlp->dl_addr_offset +
				    dlp->dl_addr_length) = lld->llc_sap;
				dlp->dl_addr_length += 1;
			}
			/* and the broadcast address */
			dlp->dl_brdcst_addr_length =
			    lld->llc_mac_info->llcp_addrlen;
			dlp->dl_brdcst_addr_offset =
			    dlp->dl_addr_offset + dlp->dl_addr_length;
			nmp->b_wptr += dlp->dl_brdcst_addr_length;
			bcopy(lld->llc_mac_info->llcp_broadcast,
			    ((caddr_t)dlp) + dlp->dl_brdcst_addr_offset,
			    lld->llc_mac_info->llcp_addrlen);
		} else {
			dlp->dl_addr_length = 0; /* not attached yet */
			dlp->dl_addr_offset = NULL;
			dlp->dl_sap_length = 0; /* 1 bytes on end */
		}
		dlp->dl_version = DL_VERSION_2;
		qreply(q, nmp);
	}
	return (LLCE_OK);
}

/*
 * llc1_unitdata
 * send a datagram.  Destination address/lsap is in M_PROTO
 * message (first mblock), data is in remainder of message.
 *
 * NOTE: We are reusing the DL_unitdata_req mblock; if llc header gets any
 * bigger, recheck to make sure it still fits!	We assume that we have a
 * 64-byte dblock for this, since a DL_unitdata_req is 20 bytes and the next
 * larger dblock size is 64.
 */
static int
llc1_unitdata(queue_t *q, mblk_t *mp)
{
	llc1_t *lld = (llc1_t *)q->q_ptr;
	dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr;
	struct ether_header *hdr;
	struct llcaddr *llcp;
	mblk_t *nmp;
	long	msglen;
	struct llchdr *llchdr;
	llc_mac_info_t *macinfo;
	int xmt_type = 0;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_unitdata(%x %x)\n", q, mp);
#endif

	if ((macinfo = lld->llc_mac_info) == NULL)
		return (DL_OUTSTATE);

	if (lld->llc_state != DL_IDLE) {
#ifdef LLC1_DEBUG
		if (llc1_debug & LLCERRS)
			printf("llc1_unitdata: wrong state (%d)\n",
			    lld->llc_state);
#endif
		return (DL_OUTSTATE);
	}

	/* need the destination address in all cases */
	llcp = (struct llcaddr *)((caddr_t)dlp + dlp->dl_dest_addr_offset);

	if (macinfo->llcp_flags & LLC1_USING_RAW) {
		/*
		 * make a valid header for transmission
		 */

	    /* need a buffer big enough for the headers */
		nmp = allocb(macinfo->llcp_addrlen * 2 + 2 + 8, BPRI_MED);
		hdr = (struct ether_header *)nmp->b_rptr;
		msglen = msgdsize(mp);

	    /* fill in type dependent fields */
		switch (lld->llc_type) {
		case DL_CSMACD: /* 802.3 CSMA/CD */
		nmp->b_wptr = nmp->b_rptr + LLC1_CSMACD_HDR_SIZE;
		llchdr = (struct llchdr *)nmp->b_wptr;
		bcopy(llcp->llca_addr,
		    hdr->ether_dhost.ether_addr_octet,
		    ETHERADDRL);
		bcopy(macinfo->llcp_macaddr,
		    hdr->ether_shost.ether_addr_octet,
		    ETHERADDRL);

		if (lld->llc_sap != LLC_NOVELL_SAP) {
			/* set length with llc header size */
			hdr->ether_type = ntohs(msglen +
			    sizeof (struct llchdr));

			/* need an LLC header, otherwise is Novell */
			/* bound sap is always source */
			llchdr->llc_ssap = lld->llc_sap;

			/* destination sap */
			llchdr->llc_dsap = llcp->llca_sap;

			/* always Unnumbered Information */
			llchdr->llc_ctl = LLC_UI;

			nmp->b_wptr += sizeof (struct llchdr);

			if (lld->llc_flags & LLC_SNAP) {
				bcopy(lld->llc_snap, nmp->b_wptr, 5);
				llchdr->llc_dsap = LLC_SNAP_SAP;
				nmp->b_wptr += 5;
			}
		} else {
			/* set length without llc header size */
			hdr->ether_type = ntohs(msglen);

			/* we don't do anything else for Netware */
		}

		if (ismulticast(hdr->ether_dhost.ether_addr_octet)) {
			if (bcmp(hdr->ether_dhost.ether_addr_octet,
			    macinfo->llcp_broadcast, ETHERADDRL) == 0)
				xmt_type = 2;
			else
				xmt_type = 1;
		}

		break;

		default:		/* either RAW or unknown, send as is */
		break;
		}
		DB_TYPE(nmp) = M_DATA; /* ether/llc header is data */
		nmp->b_cont = mp->b_cont;	/* use the data given */
		freeb(mp);
		mp = nmp;
	} else {
	    /* need to format a DL_UNITDATA_REQ with LLC1 header inserted */
		nmp = allocb(sizeof (struct llchdr)+sizeof (struct snaphdr),
		    BPRI_MED);
		if (nmp == NULL)
		return (DL_UNDELIVERABLE);
		llchdr = (struct llchdr *)(nmp->b_rptr);
		nmp->b_wptr += sizeof (struct llchdr);
		llchdr->llc_dsap = llcp->llca_sap;
		llchdr->llc_ssap = lld->llc_sap;
		llchdr->llc_ctl = LLC_UI;

		/*
		 * if we are using SNAP, insert the header here
		 */
		if (lld->llc_flags & LLC_SNAP) {
			bcopy(lld->llc_snap, nmp->b_wptr, 5);
			nmp->b_wptr += 5;
		}
		nmp->b_cont = mp->b_cont;
		mp->b_cont = nmp;
		nmp = mp;
		if (ismulticast(llcp->llca_addr)) {
			if (bcmp(llcp->llca_addr,
			    macinfo->llcp_broadcast, ETHERADDRL) == 0)
				xmt_type = 2;
			else
				xmt_type = 1;
		}
	}
	if (canput(macinfo->llcp_queue)) {
		lld->llc_stats->llcs_bytexmt += msgdsize(mp);
		lld->llc_stats->llcs_pktxmt++;
		switch (xmt_type) {
		case 1:
			macinfo->llcp_stats.llcs_multixmt++;
			break;
		case 2:
			macinfo->llcp_stats.llcs_brdcstxmt++;
			break;
		}

		putnext(macinfo->llcp_queue, mp);
		return (LLCE_OK);	/* this is almost correct, the result */
	} else {
		lld->llc_stats->llcs_nobuffer++;
	}
	if (nmp != NULL)
		freemsg(nmp);	/* free on failure */
	return (LLCE_OK);
}

/*
 * llc1_recv(macinfo, mp)
 * called with an ethernet packet in a mblock; must decide
 * whether packet is for us and which streams to queue it to. This routine is
 * called with locally originated packets for loopback.
 */
static void
llc1_recv(llc_mac_info_t *macinfo, mblk_t *mp)
{
	struct ether_addr *addr;
	llc1_t *lld;
	mblk_t *nmp, *udmp;
	int	i, nmcast = 0, statcnt_normal = 0, statcnt_brdcst = 0;
	int valid, msgsap;
	struct llchdr *llchdr;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCTRACE)
		printf("llc1_recv(%x, %x)\n", mp, macinfo);
#endif

	if (DB_TYPE(mp) == M_PROTO) {
		dl_unitdata_ind_t *udata;

		/* check to see if really LLC1 XXX */
		/* also need to make sure to keep address info */
		nmp = mp;
		udata = (dl_unitdata_ind_t *)(nmp->b_rptr);
		addr = (struct ether_addr *)(nmp->b_rptr +
		    udata->dl_dest_addr_offset);
		llchdr = (struct llchdr *)(nmp->b_cont->b_rptr);
		if (macinfo->llcp_type == DL_CSMACD) {
			i = ((struct llcsaddr *)addr)->llca_ssap;
			if (i < 60) {
				valid = adjmsg(mp->b_cont, i - msgdsize(mp));
			}
		}
	} else {
		struct ether_header *hdr;

		/* Note that raw mode currently assumes Ethernet */
		nmp = NULL;
		hdr = (struct ether_header *)mp->b_rptr;
		addr = &hdr->ether_dhost;
		llchdr = (struct llchdr *)(mp->b_rptr +
		    sizeof (struct ether_header));
		i = (ushort_t)ntohs(hdr->ether_type);
		if (i < 60) {
			(void) adjmsg(mp, i + sizeof (struct ether_header) -
			    msgdsize(mp));
		}
	}
	udmp = NULL;

	msgsap = llchdr->llc_dsap;

#ifdef LLC1_DEBUG
	if (llc1_debug & LLCRECV) {
		printf("llc1_recv: machdr=<%s>\n", ether_sprintf(addr));
	}
#endif

	if (llc1_broadcast(addr, macinfo)) {
		valid = 2;	/* 2 means valid but multicast */
		statcnt_brdcst = 1;
	} else {
		valid = llc1_local(addr, macinfo);
		statcnt_normal = msgdsize(mp);
	}

	/*
	 * Note that the NULL SAP is a special case.  It is associated with
	 * the MAC layer and not the LLC layer so should be handled
	 * independently of any STREAM.
	 */
	if (msgsap == LLC_NULL_SAP) {
		/* only XID and TEST ever processed, UI is dropped */
		if ((llchdr->llc_ctl & ~LLC_P) == LLC_XID)
			mp = llc1_xid_reply(macinfo, mp, 0);
		else if ((llchdr->llc_ctl & ~LLC_P) == LLC_TEST)
			mp = llc1_test_reply(macinfo, mp, 0);
	} else
		for (lld = llc1_device_list.llc1_str_next;
		    lld != (llc1_t *)&llc1_device_list.llc1_str_next;
		    lld = lld->llc_next) {

			/*
			 * is this a potentially usable SAP on the
			 * right MAC layer?
			 */
			if (lld->llc_qptr == NULL ||
			    lld->llc_state != DL_IDLE ||
			    lld->llc_mac_info != macinfo) {
				continue;
			}
#ifdef LLC1_DEBUG
			if (llc1_debug & LLCRECV)
				printf(
"llc1_recv: type=%d, sap=%x, pkt-dsap=%x\n",
				    lld->llc_type, lld->llc_sap,
				    msgsap);
#endif
			if (!valid && ismulticast(addr->ether_addr_octet) &&
			    lld->llc_multicnt > 0 &&
			    llc1_multicast(addr, lld)) {
				valid |= 4;
			} else if (lld->llc_flags & LLC_PROM)
				/* promiscuous mode */
				valid = 1;

			if ((lld->llc_flags & LLC_PROM) ||
				/* promiscuous streams */
			    (valid &&
			    (lld->llc_sap == msgsap ||
			    msgsap == LLC_GLOBAL_SAP))) {
				/* sap matches */
				if (msgsap == LLC_SNAP_SAP &&
				    (lld->llc_flags & (LLC_SNAP|LLC_PROM)) ==
				    LLC_SNAP) {
					if (!llc1_snap_match(lld,
					    (struct snaphdr *)(llchdr+1)))
						continue;
				}
				if (!canputnext(RD(lld->llc_qptr))) {
#ifdef LLC1_DEBUG
					if (llc1_debug & LLCRECV)
						printf(
"llc1_recv: canput failed\n");
#endif
					lld->llc_stats->llcs_blocked++;
					continue;
				}
				/* check for Novell special handling */
				if (msgsap == LLC_GLOBAL_SAP &&
				    lld->llc_sap == LLC_NOVELL_SAP &&
				    llchdr->llc_ssap == LLC_GLOBAL_SAP) {

					/* A Novell packet */
					nmp = llc1_form_udata(lld, macinfo, mp);
					continue;
				}
				switch (llchdr->llc_ctl) {
				case LLC_UI:
					/*
					 * this is an Unnumbered Information
					 * packet so form a DL_UNITDATA_IND and
					 * send to user
					 */
					nmp = llc1_form_udata(lld, macinfo, mp);
					break;

				case LLC_XID:
				case LLC_XID | LLC_P:
					/*
					 * this is either an XID request or
					 * response. We either handle directly
					 * (if user hasn't requested to handle
					 * itself) or send to user. We also
					 * must check if a response if user
					 * handled so that we can send correct
					 * message form
					 */
					if (lld->llc_flags & LLC1_AUTO_XID) {
						nmp = llc1_xid_reply(macinfo,
						    mp, lld->llc_sap);
					} else {
						/*
						 * hand to the user for
						 * handling. if this is a
						 * "request", generate a
						 * DL_XID_IND.	If it is a
						 * "response" to one of our
						 * requests, generate a
						 * DL_XID_CON.
						 */
						nmp = llc1_xid_ind_con(lld,
						    macinfo, mp);
					}
					macinfo->llcp_stats.llcs_xidrcv++;
					break;

				case LLC_TEST:
				case LLC_TEST | LLC_P:
					/*
					 * this is either a TEST request or
					 * response.  We either handle
					 * directly (if user hasn't
					 * requested to handle itself)
					 * or send to user.  We also
					 * must check if a response if
					 * user handled so that we can
					 * send correct message form
					 */
					if (lld->llc_flags & LLC1_AUTO_TEST) {
						nmp = llc1_test_reply(macinfo,
						    mp, lld->llc_sap);
					} else {
						/*
						 * hand to the user for
						 * handling. if this is
						 * a "request",
						 * generate a
						 * DL_TEST_IND. If it
						 * is a "response" to
						 * one of our requests,
						 * generate a
						 * DL_TEST_CON.
						 */
						nmp = llc1_test_ind_con(lld,
						    macinfo, mp);
					}
					macinfo->llcp_stats.llcs_testrcv++;
					break;
				default:
					nmp = mp;
					break;
				}
				mp = nmp;
			}
		}
	if (mp != NULL)
		freemsg(mp);
	if (udmp != NULL)
		freeb(udmp);
	if (nmcast > 0)
		macinfo->llcp_stats.llcs_multircv++;
	if (statcnt_brdcst) {
		macinfo->llcp_stats.llcs_brdcstrcv++;
	}
	if (statcnt_normal) {
		macinfo->llcp_stats.llcs_bytercv += statcnt_normal;
		macinfo->llcp_stats.llcs_pktrcv++;
	}
}

/*
 * llc1_local - check to see if the message is addressed to this system by
 * comparing with the board's address.
 */
static int
llc1_local(struct ether_addr *addr, llc_mac_info_t *macinfo)
{
	return (bcmp(addr->ether_addr_octet, macinfo->llcp_macaddr,
	    macinfo->llcp_addrlen) == 0);
}

/*
 * llc1_broadcast - check to see if a broadcast address is the destination of
 * this received packet
 */
static int
llc1_broadcast(struct ether_addr *addr, llc_mac_info_t *macinfo)
{
	return (bcmp(addr->ether_addr_octet, macinfo->llcp_broadcast,
	    macinfo->llcp_addrlen) == 0);
}

/*
 * llc1attach(q, mp) DLPI DL_ATTACH_REQ this attaches the stream to a PPA
 */
static int
llc1attach(queue_t *q, mblk_t *mp)
{
	dl_attach_req_t *at;
	llc_mac_info_t *mac;
	llc1_t *llc = (llc1_t *)q->q_ptr;

	at = (dl_attach_req_t *)mp->b_rptr;

	if (llc->llc_state != DL_UNATTACHED) {
		return (DL_OUTSTATE);
	}
	llc->llc_state = DL_ATTACH_PENDING;

	if (rw_tryupgrade(&llc1_device_list.llc1_rwlock) == 0) {
		/*
		 * someone else has a lock held.  To avoid deadlock,
		 * release the READER lock and block on a WRITER
		 * lock.  This will let things continue safely.
		 */
		rw_exit(&llc1_device_list.llc1_rwlock);
		rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
	}

	for (mac = llc1_device_list.llc1_mac_next;
	    mac != (llc_mac_info_t *)(&llc1_device_list.llc1_mac_next);
	    mac = mac->llcp_next) {
		ASSERT(mac);
		if (mac->llcp_ppa == at->dl_ppa && mac->llcp_lqtop == q) {
			/*
			 * We may have found the correct PPA
			 * check to see if linking has finished.
			 * Use explicit flag checks for incorrect
			 * state, and use negative values for "tenative"
			 * llcp_ppas, to avoid erroneous attaches.
			 */
			if (mac->llcp_flags &
			    (LLC1_LINKED|LLC1_DEF_PPA)) {
				return (DL_INITFAILED);
			} else if (!(mac->llcp_flags & LLC1_AVAILABLE)) {
				return (DL_BADPPA);
			}

			/* this links us to the PPA */
			mac->llcp_nstreams++;
			llc->llc_mac_info = mac;

			llc->llc_state = DL_UNBOUND; /* now ready for action */
			llc->llc_stats = &mac->llcp_stats;
			dlokack(q, mp, DL_ATTACH_REQ);

			return (LLCE_OK);
		}
	}
	llc->llc_state = DL_UNATTACHED;
	return (DL_BADPPA);
}

/*
 * llc1unattach(q, mp) DLPI DL_DETACH_REQ detaches the mac layer from the
 * stream
 */
static int
llc1unattach(queue_t *q, mblk_t *mp)
{
	llc1_t *llc = (llc1_t *)q->q_ptr;
	int	state;
	int	i;

	state = llc->llc_state;
	if (state != DL_UNBOUND)
		return (DL_OUTSTATE);

	/* can now detach from the PPA */
	llc->llc_state = DL_DETACH_PENDING;

	if (rw_tryupgrade(&llc1_device_list.llc1_rwlock) == 0) {
		/*
		 * someone else has a lock held.  To avoid deadlock,
		 * release the READER lock and block on a WRITER
		 * lock.  This will let things continue safely.
		 */
		rw_exit(&llc1_device_list.llc1_rwlock);
		rw_enter(&llc1_device_list.llc1_rwlock, RW_WRITER);
	}

	if (llc->llc_mcast) {
		for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
			llc_mcast_t *mcast;

			if ((mcast = llc->llc_mcast[i]) != NULL) {
				/* disable from stream and possibly lower */
				llc1_send_disable_multi(llc->llc_mac_info,
				    mcast);
				llc->llc_mcast[i] = NULL;
			}
		}
		kmem_free(llc->llc_mcast,
		    sizeof (llc_mcast_t *) * llc->llc_multicnt);
		llc->llc_mcast = NULL;
	}
	if (llc->llc_mac_info)
		llc->llc_mac_info->llcp_nstreams--;
	llc->llc_sap = 0;
	llc->llc_state = DL_UNATTACHED;
	if (mp) {
		dlokack(q, mp, DL_DETACH_REQ);
	}
	return (LLCE_OK);
}

/*
 * llc1_enable_multi enables multicast address on the stream if the mac layer
 * isn't enabled for this address, enable at that level as well.
 */
static int
llc1_enable_multi(queue_t *q, mblk_t *mp)
{
	llc1_t *llc;
	llc_mac_info_t *macinfo;
	struct ether_addr *maddr;
	dl_enabmulti_req_t *multi;
	llc_mcast_t *mcast;
	int	status = DL_BADADDR;
	int	i;

#if defined(LLC1_DEBUG)
	if (llc1_debug & LLCPROT) {
		printf("llc1_enable_multi(%x, %x)\n", q, mp);
	}
#endif

	llc = (llc1_t *)q->q_ptr;

	if (llc->llc_state == DL_UNATTACHED)
		return (DL_OUTSTATE);

	macinfo = llc->llc_mac_info;
	multi = (dl_enabmulti_req_t *)mp->b_rptr;
	maddr = (struct ether_addr *)(mp->b_rptr + multi->dl_addr_offset);

	/*
	 * check to see if this multicast address is valid if it is, then
	 * check to see if it is already in the per stream table and the per
	 * device table if it is already in the per stream table, if it isn't
	 * in the per device, add it.  If it is, just set a pointer.  If it
	 * isn't, allocate what's necessary.
	 */

	if (MBLKL(mp) >= sizeof (dl_enabmulti_req_t) &&
	    MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length) &&
	    multi->dl_addr_length == macinfo->llcp_addrlen &&
	    ismulticast(maddr->ether_addr_octet)) {
		/* request appears to be valid */
		/* does this address appear in current table? */
		if (llc->llc_mcast == NULL) {
			/* no mcast addresses -- allocate table */
			llc->llc_mcast =
			    GETSTRUCT(llc_mcast_t *,
			    llc1_device_list.llc1_multisize);
			if (llc->llc_mcast == NULL)
				return (DL_SYSERR);
			llc->llc_multicnt = llc1_device_list.llc1_multisize;
		} else {
			for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
				if (llc->llc_mcast[i] &&
				    bcmp(llc->llc_mcast[i]->llcm_addr,
				    maddr->ether_addr_octet, ETHERADDRL)) {
					/* this is a match -- just succeed */
					dlokack(q, mp, DL_ENABMULTI_REQ);
					return (LLCE_OK);
				}
			}
		}
		/*
		 * there wasn't one so check to see if the mac layer has one
		 */
		if (macinfo->llcp_mcast == NULL) {
			macinfo->llcp_mcast =
			    GETSTRUCT(llc_mcast_t,
			    llc1_device_list.llc1_multisize);
			if (macinfo->llcp_mcast == NULL)
				return (DL_SYSERR);
		}
		for (mcast = NULL, i = 0;
		    i < llc1_device_list.llc1_multisize; i++) {
			if (macinfo->llcp_mcast[i].llcm_refcnt &&
			    bcmp(macinfo->llcp_mcast[i].llcm_addr,
			    maddr->ether_addr_octet, ETHERADDRL) == 0) {
				mcast = &macinfo->llcp_mcast[i];
				break;
			}
		}
		if (mcast == NULL) {
			mblk_t *nmp;

			nmp = dupmsg(mp);
			if (nmp) {
				nmp->b_cont = NULL;
				DB_TYPE(nmp) = M_PROTO;
				putnext(WR(macinfo->llcp_queue), nmp);
			}
			/* find an empty slot to fill in */
			for (mcast = macinfo->llcp_mcast, i = 0;
			    i < llc1_device_list.llc1_multisize; i++, mcast++) {
				if (mcast->llcm_refcnt == 0) {
					bcopy(maddr->ether_addr_octet,
					    mcast->llcm_addr, ETHERADDRL);
					break;
				}
			}
		}
		if (mcast != NULL) {
			for (i = 0; i < llc1_device_list.llc1_multisize; i++) {
				if (llc->llc_mcast[i] == NULL) {
					llc->llc_mcast[i] = mcast;
					mcast->llcm_refcnt++;
					dlokack(q, mp, DL_ENABMULTI_REQ);
					return (LLCE_OK);
				}
			}
		}
		status = DL_TOOMANY;
	}
	return (status);
}

/*
 * llc1_disable_multi disable the multicast address on the stream if last
 * reference for the mac layer, disable there as well
 */
static int
llc1_disable_multi(queue_t *q, mblk_t *mp)
{
	llc1_t *llc;
	llc_mac_info_t *macinfo;
	struct ether_addr *maddr;
	dl_enabmulti_req_t *multi;
	int	status = DL_BADADDR, i;
	llc_mcast_t *mcast;

#if defined(LLC1_DEBUG)
	if (llc1_debug & LLCPROT) {
		printf("llc1_enable_multi(%x, %x)\n", q, mp);
	}
#endif

	llc = (llc1_t *)q->q_ptr;

	if (llc->llc_state == DL_UNATTACHED)
		return (DL_OUTSTATE);

	macinfo = llc->llc_mac_info;
	multi = (dl_enabmulti_req_t *)mp->b_rptr;
	maddr = (struct ether_addr *)(multi + 1);

	if (MBLKL(mp) >= sizeof (dl_enabmulti_req_t) &&
	    MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length)) {
		/* request appears to be valid */
		/* does this address appear in current table? */
		if (llc->llc_mcast != NULL) {
			for (i = 0; i < llc->llc_multicnt; i++)
				if (((mcast = llc->llc_mcast[i]) != NULL) &&
				    mcast->llcm_refcnt &&
				    bcmp(mcast->llcm_addr,
				    maddr->ether_addr_octet, ETHERADDRL) == 0) {
					llc1_send_disable_multi(macinfo,
					    mcast);
					llc->llc_mcast[i] = NULL;
					dlokack(q, mp, DL_DISABMULTI_REQ);
					return (LLCE_OK);
				}
			status = DL_NOTENAB;
		}
	}
	return (status);
}

/*
 * llc1_send_disable_multi(llc, macinfo, mcast) this function is used to
 * disable a multicast address if the reference count goes to zero. The
 * disable request will then be forwarded to the lower stream.
 */
static void
llc1_send_disable_multi(llc_mac_info_t *macinfo, llc_mcast_t *mcast)
{
	mblk_t *mp;
	dl_disabmulti_req_t *dis;

	if (mcast == NULL) {
		return;
	}
	if (macinfo == NULL || macinfo->llcp_queue == NULL) {
		return;
	}
	if (--mcast->llcm_refcnt > 0)
		return;

	mp = allocb(sizeof (dl_disabmulti_req_t) + ETHERADDRL, BPRI_MED);
	if (mp) {
		dis = (dl_disabmulti_req_t *)mp->b_rptr;
		mp->b_wptr =
		    mp->b_rptr + sizeof (dl_disabmulti_req_t) + ETHERADDRL;
		dis->dl_primitive = DL_DISABMULTI_REQ;
		dis->dl_addr_offset = sizeof (dl_disabmulti_req_t);
		dis->dl_addr_length = ETHERADDRL;
		bcopy(mcast->llcm_addr,
		    (mp->b_rptr + sizeof (dl_disabmulti_req_t)), ETHERADDRL);
		DB_TYPE(mp) = M_PROTO;
		putnext(WR(macinfo->llcp_queue), mp);
	}
}

/*
 * llc1_findminor(device) searches the per device class list of STREAMS for
 * the first minor number not used.  Note that we currently don't allocate
 * minor 0.
 */

static minor_t
llc1_findminor(llc1dev_t *device)
{
	llc1_t *next;
	minor_t	minor;

	ASSERT(device != NULL);
	for (minor = 1; minor <= MAXMIN32; minor++) {
		for (next = device->llc1_str_next;
		    next != NULL && next != (llc1_t *)&device->llc1_str_next;
		    next = next->llc_next) {
			if (minor == next->llc_minor)
				goto nextminor;
		}
		return (minor);
nextminor:
		/* don't need to do anything */
		;
	}
	/*NOTREACHED*/
	return (0);
}

/*
 * llc1_req_info(q) simply construct a DL_INFO_REQ to be sent to the lower
 * stream this is used to populate the macinfo structure.
 */
static int
llc1_req_info(queue_t *q)
{
	dl_info_req_t *info;
	mblk_t *mp;

	mp = allocb(DL_INFO_REQ_SIZE, BPRI_MED);
	if (mp == NULL)
		return (-1);
	DB_TYPE(mp) = M_PCPROTO;
	info = (dl_info_req_t *)mp->b_rptr;
	mp->b_wptr = mp->b_rptr + DL_INFO_REQ_SIZE;
	info->dl_primitive = DL_INFO_REQ;
	putnext(q, mp);
	return (0);
}

/*
 * llc1_req_raw(macinfo) request that the lower stream enter DLIOCRAW mode
 */
static void
llc1_req_raw(llc_mac_info_t *macinfo)
{
	mblk_t *mp;

	mp = mkiocb(DLIOCRAW);
	if (mp == NULL)
		return;

	macinfo->llcp_iocid = ((struct iocblk *)mp->b_rptr)->ioc_id;

	putnext(macinfo->llcp_queue, mp);
	macinfo->llcp_flags |= LLC1_RAW_WAIT;
}

/*
 * llc1_send_bindreq
 * if lower stream isn't bound, bind it to something appropriate
 */
static void
llc1_send_bindreq(llc_mac_info_t *macinfo)
{
	mblk_t *mp;
	dl_bind_req_t *bind;

	if (macinfo->llcp_sap >= 0xFF) {
		/* have to quite sometime if the world is failing */
		macinfo->llcp_sap &= ~(LLC1_BINDING|LLC1_AVAILABLE);
		return;
	}

	mp = allocb(sizeof (dl_bind_req_t), BPRI_MED);
	if (mp == NULL)
		return;

	bind = (dl_bind_req_t *)mp->b_rptr;
	mp->b_wptr = mp->b_rptr + sizeof (dl_bind_req_t);

	bind->dl_primitive = DL_BIND_REQ;
	bind->dl_sap = macinfo->llcp_sap += 2; /* starts at 2, inc by 2  */
	macinfo->llcp_flags |= LLC1_BINDING;
	bind->dl_max_conind = 0;
	bind->dl_service_mode = DL_CLDLS;
	bind->dl_conn_mgmt = 0;
	bind->dl_xidtest_flg = 0;
	putnext(macinfo->llcp_queue, mp);
}

/*
 * llc1_form_udata(lld, macinfo, mp) format a DL_UNITDATA_IND message to be
 * sent to the user
 */
static mblk_t *
llc1_form_udata(llc1_t *lld, llc_mac_info_t *macinfo, mblk_t *mp)
{
	mblk_t *udmp, *nmp;
	dl_unitdata_ind_t *udata;
	struct ether_header *hdr;
	struct llchdr *llchdr;
	struct snaphdr *snap;

	if (macinfo->llcp_flags & LLC1_USING_RAW) {
		hdr = (struct ether_header *)mp->b_rptr;
		llchdr = (struct llchdr *)(hdr + 1);

	    /* allocate the DL_UNITDATA_IND M_PROTO header */
		udmp = allocb(sizeof (dl_unitdata_ind_t) +
		    2 * (macinfo->llcp_addrlen + 5), BPRI_MED);
		if (udmp == NULL) {
		/* might as well discard since we can't go further */
		freemsg(mp);
		return (NULL);
		}
		udata = (dl_unitdata_ind_t *)udmp->b_rptr;
		udmp->b_wptr += sizeof (dl_unitdata_ind_t);

		nmp = dupmsg(mp);	/* make a copy for future streams */
		if (lld->llc_sap != LLC_NOVELL_SAP)
			mp->b_rptr += sizeof (struct ether_header) +
			    sizeof (struct llchdr);
		else
			mp->b_rptr += sizeof (struct ether_header);

		if (lld->llc_flags & LLC_SNAP) {
			mp->b_rptr += sizeof (struct snaphdr);
			snap = (struct snaphdr *)(llchdr + 1);
		}

		/*
		 * now setup the DL_UNITDATA_IND header
		 */
		DB_TYPE(udmp) = M_PROTO;
		udata->dl_primitive = DL_UNITDATA_IND;
		udata->dl_dest_addr_offset = sizeof (dl_unitdata_ind_t);
		bcopy(hdr->ether_dhost.ether_addr_octet,
		    LLCADDR(udata, udata->dl_dest_addr_offset)->llca_addr,
		    macinfo->llcp_addrlen);

		if (lld->llc_flags & LLC_SNAP) {
			udata->dl_dest_addr_length = macinfo->llcp_addrlen + 2;
			LLCSADDR(udata, udata->dl_dest_addr_offset)->llca_ssap =
			    ntohs(*(ushort_t *)snap->snap_type);
		} else {
			udata->dl_dest_addr_length = macinfo->llcp_addrlen + 1;
			LLCADDR(udata, udata->dl_dest_addr_offset)->llca_sap =
			    llchdr->llc_dsap;
		}
		udmp->b_wptr += udata->dl_dest_addr_length;
		udata->dl_src_addr_offset = udata->dl_dest_addr_length +
		    udata->dl_dest_addr_offset;
		bcopy(hdr->ether_shost.ether_addr_octet,
		    LLCADDR(udata, udata->dl_src_addr_offset)->llca_addr,
		    macinfo->llcp_addrlen);
		if (lld->llc_flags & LLC_SNAP) {
			udata->dl_src_addr_length = macinfo->llcp_addrlen + 2;
			LLCSADDR(udata, udata->dl_src_addr_offset)->llca_ssap =
			    ntohs(*(ushort_t *)snap->snap_type);
		} else {
			udata->dl_src_addr_length = macinfo->llcp_addrlen + 1;
			LLCADDR(udata, udata->dl_src_addr_offset)->llca_sap =
			    llchdr->llc_ssap;
		}
		udata->dl_group_address = hdr->ether_dhost.ether_addr_octet[0] &
		    0x1;
		udmp->b_wptr += udata->dl_src_addr_length;
		udmp->b_cont = mp;
	} else {
		dl_unitdata_ind_t *ud2;
		if (mp->b_cont == NULL) {
		return (mp);	/* we can't do anything */
		}
	    /* if we end up here, we only want to patch the existing M_PROTO */
		nmp = dupmsg(mp);	/* make a copy for future streams */
		udata = (dl_unitdata_ind_t *)(mp->b_rptr);
		udmp = allocb(MBLKL(mp) + 4, BPRI_MED);
		bcopy(mp->b_rptr, udmp->b_rptr, sizeof (dl_unitdata_ind_t));
		ud2 = (dl_unitdata_ind_t *)(udmp->b_rptr);
		udmp->b_wptr += sizeof (dl_unitdata_ind_t);
		bcopy((caddr_t)mp->b_rptr + udata->dl_dest_addr_offset,
		    udmp->b_wptr, macinfo->llcp_addrlen);
		ud2->dl_dest_addr_offset = sizeof (dl_unitdata_ind_t);
		ud2->dl_dest_addr_length = macinfo->llcp_addrlen + 1;
		udmp->b_wptr += ud2->dl_dest_addr_length;
		bcopy((caddr_t)udmp->b_rptr + udata->dl_src_addr_offset,
		    udmp->b_wptr, macinfo->llcp_addrlen);
		ud2->dl_src_addr_length = ud2->dl_dest_addr_length;
		udmp->b_wptr += ud2->dl_src_addr_length;
		udmp->b_cont = mp->b_cont;
		if (lld->llc_sap != LLC_NOVELL_SAP)
			mp->b_cont->b_rptr += sizeof (struct llchdr);
		freeb(mp);

		DB_TYPE(udmp) = M_PROTO;
		udata = (dl_unitdata_ind_t *)(mp->b_rptr);
		llchdr = (struct llchdr *)(mp->b_cont->b_rptr);
		LLCADDR(udata, udata->dl_dest_addr_offset)->llca_sap =
		    llchdr->llc_dsap;
		LLCADDR(udata, udata->dl_src_addr_offset)->llca_sap =
		    llchdr->llc_ssap;
	}
#ifdef LLC1_DEBUG
		if (llc1_debug & LLCRECV)
		printf("llc1_recv: queued message to %x (%d)\n",
		    lld->llc_qptr, lld->llc_minor);
#endif
	/* enqueue for the service routine to process */
	putnext(RD(lld->llc_qptr), udmp);
	mp = nmp;
	return (mp);
}

/*
 * llc1_xid_reply(macinfo, mp) automatic reply to an XID command
 */
static mblk_t *
llc1_xid_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap)
{
	mblk_t *nmp, *rmp;
	struct ether_header *hdr, *msgether;
	struct llchdr *llchdr;
	struct llchdr *msgllc;
	struct llchdr_xid *xid;

	if (DB_TYPE(mp) == M_DATA) {
		hdr = (struct ether_header *)mp->b_rptr;
		llchdr = (struct llchdr *)(hdr + 1);
	} else {
		if (mp->b_cont == NULL)
			return (mp);
		llchdr = (struct llchdr *)(mp->b_cont->b_rptr);
	}

	/* we only want to respond to commands to avoid response loops */
	if (llchdr->llc_ssap & LLC_RESPONSE)
		return (mp);

	nmp = allocb(msgdsize(mp) + LLC_XID_INFO_SIZE, BPRI_MED);
	if (nmp == NULL) {
		return (mp);
	}

	/*
	 * now construct the XID reply frame
	 */
	if (DB_TYPE(mp) == M_DATA) {
		msgether = (struct ether_header *)nmp->b_rptr;
		nmp->b_wptr += sizeof (struct ether_header);
		bcopy(hdr->ether_shost.ether_addr_octet,
		    msgether->ether_dhost.ether_addr_octet,
		    macinfo->llcp_addrlen);
		bcopy(macinfo->llcp_macaddr,
		    msgether->ether_shost.ether_addr_octet,
		    macinfo->llcp_addrlen);
		msgether->ether_type = htons(sizeof (struct llchdr_xid) +
		    sizeof (struct llchdr));
		rmp = nmp;
	} else {
		dl_unitdata_req_t *ud;
		dl_unitdata_ind_t *rud;
		rud = (dl_unitdata_ind_t *)mp->b_rptr;

		rmp = allocb(sizeof (dl_unitdata_req_t) +
		    macinfo->llcp_addrlen + 5, BPRI_MED);
		if (rmp == NULL)
			return (mp);

		DB_TYPE(rmp) = M_PROTO;
		bzero(rmp->b_rptr, sizeof (dl_unitdata_req_t));
		ud = (dl_unitdata_req_t *)rmp->b_rptr;
		ud->dl_primitive = DL_UNITDATA_REQ;
		ud->dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
		ud->dl_dest_addr_length = macinfo->llcp_addrlen + 1;

		rmp->b_wptr += sizeof (dl_unitdata_req_t);
		bcopy(LLCADDR(mp->b_rptr, rud->dl_src_addr_offset),
		    LLCADDR(rmp->b_rptr, ud->dl_dest_addr_offset),
		    macinfo->llcp_addrlen);
		LLCADDR(rmp->b_rptr, ud->dl_dest_addr_offset)->llca_sap =
		    LLCADDR(mp->b_rptr, rud->dl_src_addr_offset)->llca_sap;
		rmp->b_wptr += sizeof (struct llcaddr);
		rmp->b_cont = nmp;
	}

	msgllc = (struct llchdr *)nmp->b_wptr;
	xid = (struct llchdr_xid *)(msgllc + 1);
	nmp->b_wptr += sizeof (struct llchdr);

	msgllc->llc_dsap = llchdr->llc_ssap;

	/* mark it a response */
	msgllc->llc_ssap = sap | LLC_RESPONSE;

	msgllc->llc_ctl = llchdr->llc_ctl;
	xid->llcx_format = LLC_XID_FMTID;
	xid->llcx_class = LLC_XID_TYPE_1;
	xid->llcx_window = 0;	/* we don't have connections yet */

	nmp->b_wptr += sizeof (struct llchdr_xid);
	macinfo->llcp_stats.llcs_xidxmt++;
	putnext(WR(macinfo->llcp_queue), rmp);
	return (mp);
}

/*
 * llc1_xid_ind_con(lld, macinfo, mp) form a DL_XID_IND or DL_XID_CON message
 * to send to the user since it was requested that the user process these
 * messages
 */
static mblk_t *
llc1_xid_ind_con(llc1_t *lld, llc_mac_info_t *macinfo, mblk_t *mp)
{
	mblk_t *nmp;
	dl_xid_ind_t *xid;
	struct ether_header *hdr;
	struct llchdr *llchdr;
	int raw;

	nmp = allocb(sizeof (dl_xid_ind_t) + 2 * (macinfo->llcp_addrlen + 1),
	    BPRI_MED);
	if (nmp == NULL)
		return (mp);

	if ((raw = (DB_TYPE(mp) == M_DATA)) != 0) {
		hdr = (struct ether_header *)mp->b_rptr;
		llchdr = (struct llchdr *)(hdr + 1);
	} else {
		if (mp->b_rptr == NULL)
			return (mp);
		llchdr = (struct llchdr *)mp->b_cont->b_rptr;
	}

	xid = (dl_xid_ind_t *)nmp->b_rptr;
	xid->dl_flag = (llchdr->llc_ctl & LLC_P) ? DL_POLL_FINAL : 0;
	xid->dl_dest_addr_offset = sizeof (dl_xid_ind_t);
	xid->dl_dest_addr_length = macinfo->llcp_addrlen + 1;

	if (raw) {
		bcopy(hdr->ether_dhost.ether_addr_octet,
		    (nmp->b_rptr + xid->dl_dest_addr_offset),
		    xid->dl_dest_addr_length);
	} else {
		dl_unitdata_ind_t *ind;
		ind = (dl_unitdata_ind_t *)mp->b_rptr;
		bcopy(LLCADDR(ind, ind->dl_dest_addr_offset),
		    (nmp->b_rptr + xid->dl_dest_addr_offset),
		    xid->dl_dest_addr_length);
	}

	LLCADDR(xid, xid->dl_dest_addr_offset)->llca_sap =
	    llchdr->llc_dsap;

	xid->dl_src_addr_offset =
	    xid->dl_dest_addr_offset + xid->dl_dest_addr_length;
	xid->dl_src_addr_length = xid->dl_dest_addr_length;

	if (raw) {
		bcopy(hdr->ether_shost.ether_addr_octet,
		    (nmp->b_rptr + xid->dl_src_addr_offset),
		    xid->dl_src_addr_length);
	} else {
		dl_unitdata_ind_t *ind;
		ind = (dl_unitdata_ind_t *)mp->b_rptr;
		bcopy(LLCADDR(mp->b_rptr, ind->dl_src_addr_offset),
		    (nmp->b_rptr + xid->dl_src_addr_offset),
		    ind->dl_src_addr_length);
	}
	LLCADDR(nmp->b_rptr, xid->dl_src_addr_offset)->llca_sap =
	    llchdr->llc_ssap & ~LLC_RESPONSE;

	nmp->b_wptr = nmp->b_rptr + sizeof (dl_xid_ind_t) +
	    2 * xid->dl_dest_addr_length;

	if (!(llchdr->llc_ssap & LLC_RESPONSE)) {
		xid->dl_primitive = DL_XID_IND;
	} else {
		xid->dl_primitive = DL_XID_CON;
	}

	DB_TYPE(nmp) = M_PROTO;
	if (raw) {
		if (MBLKL(mp) >
		    (sizeof (struct ether_header) + sizeof (struct llchdr))) {
			nmp->b_cont = dupmsg(mp);
			if (nmp->b_cont) {
				nmp->b_cont->b_rptr +=
					sizeof (struct ether_header) +
					sizeof (struct llchdr);
			}
		}
	} else if (mp->b_cont != NULL && MBLKL(mp->b_cont) >
						sizeof (struct llchdr)) {
		nmp->b_cont = dupmsg(mp->b_cont);
		(void) adjmsg(nmp->b_cont, sizeof (struct llchdr));
	}
	putnext(RD(lld->llc_qptr), nmp);
	return (mp);
}

/*
 * llc1_xid_req_res(q, mp, req_or_res) the user wants to send an XID message
 * or response construct a proper message and put on the net
 */
static int
llc1_xid_req_res(queue_t *q, mblk_t *mp, int req_or_res)
{
	dl_xid_req_t *xid = (dl_xid_req_t *)mp->b_rptr;
	llc1_t *llc = (llc1_t *)q->q_ptr;
	llc_mac_info_t *macinfo;
	mblk_t *nmp, *rmp;
	struct ether_header *hdr;
	struct llchdr *llchdr;

	if (llc == NULL || llc->llc_state == DL_UNATTACHED)
		return (DL_OUTSTATE);

	if (llc->llc_sap == LLC_NOVELL_SAP)
		return (DL_NOTSUPPORTED);

	if (llc->llc_flags & DL_AUTO_XID)
		return (DL_XIDAUTO);

	macinfo = llc->llc_mac_info;
	if (MBLKL(mp) < sizeof (dl_xid_req_t) ||
	    !MBLKIN(mp, xid->dl_dest_addr_offset, xid->dl_dest_addr_length)) {
		return (DL_BADPRIM);
	}

	nmp = allocb(sizeof (struct ether_header) + sizeof (struct llchdr) +
	    sizeof (struct llchdr_xid), BPRI_MED);

	if (nmp == NULL)
		return (LLCE_NOBUFFER);

	if (macinfo->llcp_flags & LLC1_USING_RAW) {
		hdr = (struct ether_header *)nmp->b_rptr;
		bcopy(LLCADDR(xid, xid->dl_dest_addr_offset)->llca_addr,
		    hdr->ether_dhost.ether_addr_octet, ETHERADDRL);
		bcopy(macinfo->llcp_macaddr,
		    hdr->ether_shost.ether_addr_octet, ETHERADDRL);
		hdr->ether_type = htons(sizeof (struct llchdr) + msgdsize(mp));
		nmp->b_wptr = nmp->b_rptr +
		    sizeof (struct ether_header) + sizeof (struct llchdr);
		llchdr = (struct llchdr *)(hdr + 1);
		rmp = nmp;
	} else {
		dl_unitdata_req_t *ud;
		rmp = allocb(sizeof (dl_unitdata_req_t) +
		    (macinfo->llcp_addrlen + 2), BPRI_MED);