/*
 * 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 = 0;
                        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);
                if (rmp == NULL) {
                        freemsg(nmp);
                        return (LLCE_NOBUFFER);
                }
                ud = (dl_unitdata_req_t *)rmp->b_rptr;
                DB_TYPE(rmp) = M_PROTO;
                ud->dl_primitive = DL_UNITDATA_REQ;
                ud->dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
                ud->dl_dest_addr_length = xid->dl_dest_addr_length;
                rmp->b_wptr += sizeof (dl_unitdata_req_t);
                bcopy(LLCADDR(xid, xid->dl_dest_addr_offset)->llca_addr,
                    LLCADDR(ud, ud->dl_dest_addr_offset),
                    xid->dl_dest_addr_length);
                LLCSADDR(ud, ud->dl_dest_addr_offset)->llca_ssap =
                    msgdsize(mp);
                rmp->b_wptr += xid->dl_dest_addr_length;
                rmp->b_cont = nmp;
                llchdr = (struct llchdr *)nmp->b_rptr;
                nmp->b_wptr += sizeof (struct llchdr);
        }

        llchdr->llc_dsap = LLCADDR(xid, xid->dl_dest_addr_offset)->llca_sap;
        llchdr->llc_ssap = llc->llc_sap | (req_or_res ? LLC_RESPONSE : 0);
        llchdr->llc_ctl =
            LLC_XID | ((xid->dl_flag & DL_POLL_FINAL) ? LLC_P : 0);

        nmp->b_cont = mp->b_cont;
        mp->b_cont = NULL;
        freeb(mp);
        macinfo->llcp_stats.llcs_xidxmt++;
        putnext(WR(macinfo->llcp_queue), rmp);
        return (LLCE_OK);
}

/*
 * llc1_test_reply(macinfo, mp)
 * automatic reply to a TEST message
 */
static mblk_t *
llc1_test_reply(llc_mac_info_t *macinfo, mblk_t *mp, int sap)
{
        mblk_t *nmp;
        struct ether_header *hdr, *msgether;
        struct llchdr *llchdr;
        struct llchdr *msgllc;
        int poll_final;

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

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

        nmp = copymsg(mp);      /* so info field is duplicated */
        if (nmp == NULL) {
                nmp = mp;
                mp = NULL;
        }
        /*
         * now construct the TEST reply frame
         */


        poll_final = llchdr->llc_ctl & LLC_P;

        if (DB_TYPE(nmp) == M_PROTO) {
                dl_unitdata_req_t *udr = (dl_unitdata_req_t *)nmp->b_rptr;
                dl_unitdata_ind_t *udi = (dl_unitdata_ind_t *)nmp->b_rptr;

                /* make into a request */
                udr->dl_primitive = DL_UNITDATA_REQ;
                udr->dl_dest_addr_offset = udi->dl_src_addr_offset;
                udr->dl_dest_addr_length = udi->dl_src_addr_length;
                udr->dl_priority.dl_min = udr->dl_priority.dl_max = 0;
                msgllc = (struct llchdr *)nmp->b_cont->b_rptr;
        } else {
                msgether = (struct ether_header *)nmp->b_rptr;
                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);
                msgllc = (struct llchdr *)(msgether+1);
        }

        msgllc->llc_dsap = llchdr->llc_ssap;

        /* mark it as a response */
        msgllc->llc_ssap = sap |  LLC_RESPONSE;
        msgllc->llc_ctl = LLC_TEST | poll_final;

        macinfo->llcp_stats.llcs_testxmt++;
        putnext(WR(macinfo->llcp_queue), nmp);
        return (mp);
}

/*
 * llc1_test_ind_con(lld, macinfo, mp) form a DL_TEST_IND or DL_TEST_CON
 * message to send to the user since it was requested that the user process
 * these messages
 */
static mblk_t *
llc1_test_ind_con(llc1_t *lld, llc_mac_info_t *macinfo, mblk_t *mp)
{
        mblk_t *nmp;
        dl_test_ind_t *test;
        struct ether_header *hdr;
        struct llchdr *llchdr;
        int raw;

        nmp = allocb(sizeof (dl_test_ind_t) + 2 * (ETHERADDRL + 1), BPRI_MED);
        if (nmp == NULL)
                return (NULL);

        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;
        }

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

        if (raw) {
                bcopy(hdr->ether_dhost.ether_addr_octet,
                    LLCADDR(nmp->b_rptr, test->dl_dest_addr_offset)->llca_addr,
                    test->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 + test->dl_dest_addr_offset),
                    test->dl_dest_addr_length);
        }

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

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

        if (raw) {
                bcopy(hdr->ether_shost.ether_addr_octet,
                    LLCADDR(nmp->b_rptr, test->dl_src_addr_offset)->llca_addr,
                    test->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 + test->dl_src_addr_offset),
                    ind->dl_src_addr_length);
        }
        LLCADDR(nmp->b_rptr, test->dl_src_addr_offset)->llca_sap =
            llchdr->llc_ssap & ~LLC_RESPONSE;

        nmp->b_wptr = nmp->b_rptr + sizeof (dl_test_ind_t) +
            2 * test->dl_dest_addr_length;

        if (!(llchdr->llc_ssap & LLC_RESPONSE)) {
                test->dl_primitive = DL_TEST_IND;
        } else {
                test->dl_primitive = DL_TEST_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_test_req_res(q, mp, req_or_res) the user wants to send a TEST
 * message or response construct a proper message and put on the net
 */
static int
llc1_test_req_res(queue_t *q, mblk_t *mp, int req_or_res)
{
        dl_test_req_t *test = (dl_test_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_TEST)
                return (DL_TESTAUTO);

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

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

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

        if (macinfo->llcp_flags & LLC1_USING_RAW) {
                hdr = (struct ether_header *)nmp->b_rptr;
                bcopy(LLCADDR(test, test->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);
                if (rmp == NULL) {
                        freemsg(nmp);
                        return (LLCE_NOBUFFER);

                }
                ud = (dl_unitdata_req_t *)rmp->b_rptr;
                DB_TYPE(rmp) = M_PROTO;
                ud->dl_primitive = DL_UNITDATA_REQ;
                ud->dl_dest_addr_offset = sizeof (dl_unitdata_req_t);
                ud->dl_dest_addr_length = test->dl_dest_addr_length;
                rmp->b_wptr += sizeof (dl_unitdata_req_t);
                bcopy(LLCADDR(test, test->dl_dest_addr_offset)->llca_addr,
                    LLCADDR(ud, ud->dl_dest_addr_offset),
                    test->dl_dest_addr_length);
                LLCSADDR(ud, ud->dl_dest_addr_offset)->llca_ssap =
                    msgdsize(mp);
                rmp->b_wptr += test->dl_dest_addr_length;
                rmp->b_cont = nmp;
                llchdr = (struct llchdr *)nmp->b_rptr;
                nmp->b_wptr += sizeof (struct llchdr);
        }

        llchdr->llc_dsap = LLCADDR(test, test->dl_dest_addr_offset)->llca_sap;
        llchdr->llc_ssap = llc->llc_sap | (req_or_res ? LLC_RESPONSE : 0);
        llchdr->llc_ctl =
            LLC_TEST | ((test->dl_flag & DL_POLL_FINAL) ? LLC_P : 0);

        nmp->b_cont = mp->b_cont;
        mp->b_cont = NULL;
        freeb(mp);
        macinfo->llcp_stats.llcs_testxmt++;
        putnext(WR(macinfo->llcp_queue), rmp);
        return (LLCE_OK);
}

/*
 * llc1_find_waiting(macinfo, mp, prim) look for a stream waiting for a
 * response to a message identified by prim and send it to the user.
 */
static void
llc1_find_waiting(llc_mac_info_t *macinfo, mblk_t *mp, long prim)
{
        llc1_t *llc;

        for (llc = llc1_device_list.llc1_str_next;
            llc != (llc1_t *)&llc1_device_list.llc1_str_next;
            llc = llc->llc_next)
                if (llc->llc_mac_info == macinfo &&
                    prim == llc->llc_waiting_for) {
                        putnext(RD(llc->llc_qptr), mp);
                        llc->llc_waiting_for = -1;
                        return;
                }
        freemsg(mp);
}

static void
llc1insque(void *elem, void *pred)
{
        struct qelem *pelem = elem;
        struct qelem *ppred = pred;
        struct qelem *pnext = ppred->q_forw;

        pelem->q_forw = pnext;
        pelem->q_back = ppred;
        ppred->q_forw = pelem;
        pnext->q_back = pelem;
}

static void
llc1remque(void *arg)
{
        struct qelem *pelem = arg;
        struct qelem *elem = arg;

        ASSERT(pelem->q_forw != NULL);
        pelem->q_forw->q_back = pelem->q_back;
        pelem->q_back->q_forw = pelem->q_forw;
        elem->q_back = elem->q_forw = NULL;
}

/* VARARGS */
static void
llc1error(dev_info_t *dip, char *fmt, char *a1, char *a2, char *a3,
    char *a4, char *a5, char *a6)
{
        static long last;
        static char *lastfmt;
        time_t now;

        /*
         * Don't print same error message too often.
         */
        now = gethrestime_sec();
        if ((last == (now & ~1)) && (lastfmt == fmt))
                return;
        last = now & ~1;
        lastfmt = fmt;

        cmn_err(CE_CONT, "%s%d:  ",
            ddi_get_name(dip), ddi_get_instance(dip));
        cmn_err(CE_CONT, fmt, a1, a2, a3, a4, a5, a6);
        cmn_err(CE_CONT, "\n");
}

/*ARGSUSED1*/
static int
llc1_update_kstat(kstat_t *ksp, int rw)
{
        llc_mac_info_t *macinfo;
        kstat_named_t *kstat;
        struct llc_stats *stats;

        if (ksp == NULL)
                return (0);

        kstat = (kstat_named_t *)(ksp->ks_data);
        macinfo = (llc_mac_info_t *)(ksp->ks_private);
        stats = &macinfo->llcp_stats;

        kstat[LLCS_NOBUFFER].value.ul = stats->llcs_nobuffer;
        kstat[LLCS_MULTIXMT].value.ul = stats->llcs_multixmt;
        kstat[LLCS_MULTIRCV].value.ul = stats->llcs_multircv;
        kstat[LLCS_BRDCSTXMT].value.ul = stats->llcs_brdcstxmt;
        kstat[LLCS_BRDCSTRCV].value.ul = stats->llcs_brdcstrcv;
        kstat[LLCS_BLOCKED].value.ul = stats->llcs_blocked;
        kstat[LLCS_PKTXMT].value.ul = stats->llcs_pktxmt;
        kstat[LLCS_PKTRCV].value.ul = stats->llcs_pktrcv;
        kstat[LLCS_BYTEXMT].value.ul = stats->llcs_bytexmt;
        kstat[LLCS_BYTERCV].value.ul = stats->llcs_bytercv;
        kstat[LLCS_XIDXMT].value.ul = stats->llcs_xidxmt;
        kstat[LLCS_XIDRCV].value.ul = stats->llcs_xidrcv;
        kstat[LLCS_TESTXMT].value.ul = stats->llcs_testxmt;
        kstat[LLCS_TESTRCV].value.ul = stats->llcs_testrcv;
        kstat[LLCS_IERRORS].value.ul = stats->llcs_ierrors;
        kstat[LLCS_OERRORS].value.ul = stats->llcs_oerrors;
        return (0);
}

static void
llc1_init_kstat(llc_mac_info_t *macinfo)
{
        kstat_named_t *ksp;

        /*
         * Note that the temporary macinfo->llcp_ppa number is negative.
         */
        macinfo->llcp_kstatp = kstat_create("llc", (-macinfo->llcp_ppa - 1),
            NULL, "net", KSTAT_TYPE_NAMED,
            sizeof (struct llc_stats) / sizeof (long), 0);
        if (macinfo->llcp_kstatp == NULL)
                return;

        macinfo->llcp_kstatp->ks_update = llc1_update_kstat;
        macinfo->llcp_kstatp->ks_private = (void *)macinfo;

        ksp = (kstat_named_t *)(macinfo->llcp_kstatp->ks_data);

        kstat_named_init(&ksp[LLCS_NOBUFFER], "nobuffer", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_MULTIXMT], "multixmt", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_MULTIRCV], "multircv", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_BRDCSTXMT], "brdcstxmt", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_BRDCSTRCV], "brdcstrcv", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_BLOCKED], "blocked", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_PKTXMT], "pktxmt", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_PKTRCV], "pktrcv", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_BYTEXMT], "bytexmt", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_BYTERCV], "bytercv", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_XIDXMT], "xidxmt", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_XIDRCV], "xidrcv", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_TESTXMT], "testxmt", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_TESTRCV], "testrcv", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_IERRORS], "ierrors", KSTAT_DATA_ULONG);
        kstat_named_init(&ksp[LLCS_OERRORS], "oerrors", KSTAT_DATA_ULONG);
        kstat_install(macinfo->llcp_kstatp);
}

static void
llc1_uninit_kstat(llc_mac_info_t *macinfo)
{
        if (macinfo->llcp_kstatp) {
                kstat_delete(macinfo->llcp_kstatp);
                macinfo->llcp_kstatp = NULL;
        }
}

/*
 * llc1_subs_bind(q, mp)
 *      implements the DL_SUBS_BIND_REQ primitive
 *      this only works for a STREAM bound to LLC_SNAP_SAP
 *      or one bound to the automatic SNAP mode.
 *      If bound to LLC_SNAP_SAP, the subs bind can be:
 *      - 2 octets treated as a native byte order short (ethertype)
 *      - 3 octets treated as a network order byte string (OID part)
 *      - 5 octets treated as a network order byte string (full SNAP header)
 *      If bound to an automatic SNAP mode sap, then only the 3 octet
 *      form is allowed
 */
static int
llc1_subs_bind(queue_t *q, mblk_t *mp)
{
        llc1_t *lld = (llc1_t *)q->q_ptr;
        dl_subs_bind_req_t *subs = (dl_subs_bind_req_t *)mp->b_rptr;
        ushort_t subssap;
        uchar_t *sapstr;
        int result;


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

        if (lld == NULL || lld->llc_state != DL_IDLE) {
                result = DL_OUTSTATE;
        } else if (lld->llc_sap != LLC_SNAP_SAP ||
            subs->dl_subs_bind_class != DL_HIERARCHICAL_BIND) {
                /* we only want to support this for SNAP at present */
                result = DL_UNSUPPORTED;
        } else {

                lld->llc_state = DL_SUBS_BIND_PND;

                sapstr = (uchar_t *)(mp->b_rptr + subs->dl_subs_sap_offset);

                result = LLCE_OK;
                switch (subs->dl_subs_sap_length) {
                case 2:         /* just the ethertype part */
                        if (lld->llc_flags & LLC_SNAP) {
                                result = DL_BADADDR;
                                break;
                        }
                        ((uchar_t *)&subssap)[0] = sapstr[0];
                        ((uchar_t *)&subssap)[1] = sapstr[1];
                        subssap = htons(subssap);
                        lld->llc_snap[3] = ((uchar_t *)&subssap)[0];
                        lld->llc_snap[4] = ((uchar_t *)&subssap)[1];
                        lld->llc_flags |= LLC_SNAP;
                        break;

                case 3:         /* just the OID part */
                        if ((lld->llc_flags & (LLC_SNAP|LLC_SNAP_OID)) ==
                            (LLC_SNAP|LLC_SNAP_OID)) {
                                result = DL_BADADDR;
                                break;
                        }
                        bcopy(sapstr, lld->llc_snap, 3);
                        lld->llc_flags |= LLC_SNAP_OID;
                        break;

                case 5:         /* full SNAP header */
                        if (lld->llc_flags & (LLC_SNAP|LLC_SNAP_OID)) {
                                result = DL_BADADDR;
                                break;
                        }
                        bcopy(sapstr, lld->llc_snap, 5);
                        lld->llc_flags |= LLC_SNAP|LLC_SNAP_OID;
                        break;
                }
                /* if successful, acknowledge and enter the proper state */
                if (result == LLCE_OK) {
                        mblk_t *nmp = mp;
                        dl_subs_bind_ack_t *ack;

                        if (DB_REF(mp) != 1 ||
                            MBLKL(mp) < (sizeof (dl_subs_bind_ack_t) + 5)) {
                                freemsg(mp);
                                nmp = allocb(sizeof (dl_subs_bind_ack_t) + 5,
                                    BPRI_MED);
                        }
                        ack = (dl_subs_bind_ack_t *)nmp->b_rptr;
                        nmp->b_wptr = nmp->b_rptr +
                            sizeof (dl_subs_bind_ack_t) + 5;
                        ack->dl_primitive = DL_SUBS_BIND_ACK;
                        ack->dl_subs_sap_offset = sizeof (dl_subs_bind_ack_t);
                        ack->dl_subs_sap_length = 5;
                        bcopy(lld->llc_snap,
                            (caddr_t)nmp->b_rptr + ack->dl_subs_sap_offset + 5,
                            5);
                        DB_TYPE(nmp) = M_PCPROTO;
                        qreply(q, nmp);

                }
                lld->llc_state = DL_IDLE;
        }
        return (result);
}

/*
 *
 */
static int
llc1_subs_unbind(void)
{
        return (DL_UNSUPPORTED);
}

char *
snapdmp(uchar_t *bstr)
{
        static char buff[32];

        (void) sprintf(buff, "%x.%x.%x.%x.%x",
            bstr[0],
            bstr[1],
            bstr[2],
            bstr[3],
            bstr[4]);
        return (buff);
}

static int
llc1_snap_match(llc1_t *lld, struct snaphdr *snap)
{
        return (bcmp(snap->snap_oid, lld->llc_snap, 5) == 0);
}