Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / uts / common / io / ppp / sppp / sppp_dlpi.c

/*
 * sppp_dlpi.c - Solaris STREAMS PPP multiplexing pseudo-driver DLPI handlers
 *
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation is hereby granted, provided that the above copyright
 * notice appears in all copies.
 *
 * SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF
 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT.  SUN SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES
 *
 * Copyright (c) 1994 The Australian National University.
 * All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation is hereby granted, provided that the above copyright
 * notice appears in all copies.  This software is provided without any
 * warranty, express or implied. The Australian National University
 * makes no representations about the suitability of this software for
 * any purpose.
 *
 * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
 * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
 * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
 * OR MODIFICATIONS.
 *
 * This driver is derived from the original SVR4 STREAMS PPP driver
 * originally written by Paul Mackerras <paul.mackerras@cs.anu.edu.au>.
 *
 * Adi Masputra <adi.masputra@sun.com> rewrote and restructured the code
 * for improved performance and scalability.
 */

#define RCSID   "$Id: sppp_dlpi.c,v 1.0 2000/05/08 01:10:12 masputra Exp $"

#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/cmn_err.h>
#include <sys/conf.h>
#include <sys/dlpi.h>
#include <sys/ddi.h>
#include <sys/kstat.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/ethernet.h>
#include <net/ppp_defs.h>
#include <netinet/in.h>
#include <net/pppio.h>
#include "s_common.h"
#include "sppp.h"

static int      sppp_dlattachreq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dldetachreq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dlbindreq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dlunbindreq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dlinforeq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dlunitdatareq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dlpromisconreq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dlpromiscoffreq(queue_t *, mblk_t *, spppstr_t *);
static int      sppp_dlphyreq(queue_t *, mblk_t *, spppstr_t *);
static void     sppp_dl_attach_upper(queue_t *, mblk_t *);
static void     sppp_dl_detach_upper(queue_t *, mblk_t *);
static void     sppp_dl_bind(queue_t *, mblk_t *);
static void     sppp_dl_unbind(queue_t *, mblk_t *);
static void     sppp_dl_promiscon(queue_t *, mblk_t *);
static void     sppp_dl_promiscoff(queue_t *, mblk_t *);
static mblk_t   *sppp_dladdether(spppstr_t *, mblk_t *, t_scalar_t);

static struct sppp_dlpi_pinfo_t dl_pinfo[DL_MAXPRIM + 1];

#if 0
#define DBGERROR(x)     cmn_err x
#else
#define DBGERROR(x)     ((void)0)
#endif

/* #define      DBG_DLPI        1 */

#ifdef DBG_DLPI
struct sppp_dlpi_entry {
        uint32_t sde_val;
        const char *sde_name;
};

static const struct sppp_dlpi_entry sppp_dlpi_list[] = {
        { DL_INFO_REQ, "DL_INFO_REQ" },
        { DL_INFO_ACK, "DL_INFO_ACK" },
        { DL_ATTACH_REQ, "DL_ATTACH_REQ" },
        { DL_DETACH_REQ, "DL_DETACH_REQ" },
        { DL_BIND_REQ, "DL_BIND_REQ" },
        { DL_BIND_ACK, "DL_BIND_ACK" },
        { DL_UNBIND_REQ, "DL_UNBIND_REQ" },
        { DL_OK_ACK, "DL_OK_ACK" },
        { DL_ERROR_ACK, "DL_ERROR_ACK" },
        { DL_SUBS_BIND_REQ, "DL_SUBS_BIND_REQ" },
        { DL_SUBS_BIND_ACK, "DL_SUBS_BIND_ACK" },
        { DL_SUBS_UNBIND_REQ, "DL_SUBS_UNBIND_REQ" },
        { DL_ENABMULTI_REQ, "DL_ENABMULTI_REQ" },
        { DL_DISABMULTI_REQ, "DL_DISABMULTI_REQ" },
        { DL_PROMISCON_REQ, "DL_PROMISCON_REQ" },
        { DL_PROMISCOFF_REQ, "DL_PROMISCOFF_REQ" },
        { DL_UNITDATA_REQ, "DL_UNITDATA_REQ" },
        { DL_UNITDATA_IND, "DL_UNITDATA_IND" },
        { DL_UDERROR_IND, "DL_UDERROR_IND" },
        { DL_UDQOS_REQ, "DL_UDQOS_REQ" },
        { DL_CONNECT_REQ, "DL_CONNECT_REQ" },
        { DL_CONNECT_IND, "DL_CONNECT_IND" },
        { DL_CONNECT_RES, "DL_CONNECT_RES" },
        { DL_CONNECT_CON, "DL_CONNECT_CON" },
        { DL_TOKEN_REQ, "DL_TOKEN_REQ" },
        { DL_TOKEN_ACK, "DL_TOKEN_ACK" },
        { DL_DISCONNECT_REQ, "DL_DISCONNECT_REQ" },
        { DL_DISCONNECT_IND, "DL_DISCONNECT_IND" },
        { DL_RESET_REQ, "DL_RESET_REQ" },
        { DL_RESET_IND, "DL_RESET_IND" },
        { DL_RESET_RES, "DL_RESET_RES" },
        { DL_RESET_CON, "DL_RESET_CON" },
        { DL_DATA_ACK_REQ, "DL_DATA_ACK_REQ" },
        { DL_DATA_ACK_IND, "DL_DATA_ACK_IND" },
        { DL_DATA_ACK_STATUS_IND, "DL_DATA_ACK_STATUS_IND" },
        { DL_REPLY_REQ, "DL_REPLY_REQ" },
        { DL_REPLY_IND, "DL_REPLY_IND" },
        { DL_REPLY_STATUS_IND, "DL_REPLY_STATUS_IND" },
        { DL_REPLY_UPDATE_REQ, "DL_REPLY_UPDATE_REQ" },
        { DL_REPLY_UPDATE_STATUS_IND, "DL_REPLY_UPDATE_STATUS_IND" },
        { DL_XID_REQ, "DL_XID_REQ" },
        { DL_XID_IND, "DL_XID_IND" },
        { DL_XID_RES, "DL_XID_RES" },
        { DL_XID_CON, "DL_XID_CON" },
        { DL_TEST_REQ, "DL_TEST_REQ" },
        { DL_TEST_IND, "DL_TEST_IND" },
        { DL_TEST_RES, "DL_TEST_RES" },
        { DL_TEST_CON, "DL_TEST_CON" },
        { DL_PHYS_ADDR_REQ, "DL_PHYS_ADDR_REQ" },
        { DL_PHYS_ADDR_ACK, "DL_PHYS_ADDR_ACK" },
        { DL_SET_PHYS_ADDR_REQ, "DL_SET_PHYS_ADDR_REQ" },
        { DL_GET_STATISTICS_REQ, "DL_GET_STATISTICS_REQ" },
        { DL_GET_STATISTICS_ACK, "DL_GET_STATISTICS_ACK" },
        { 0, NULL }
};

static const struct sppp_dlpi_entry sppp_state_list[] = {
        { DL_UNBOUND, "DL_UNBOUND" },
        { DL_BIND_PENDING, "DL_BIND_PENDING" },
        { DL_UNBIND_PENDING, "DL_UNBIND_PENDING" },
        { DL_IDLE, "DL_IDLE" },
        { DL_UNATTACHED, "DL_UNATTACHED" },
        { DL_ATTACH_PENDING, "DL_ATTACH_PENDING" },
        { DL_DETACH_PENDING, "DL_DETACH_PENDING" },
        { DL_UDQOS_PENDING, "DL_UDQOS_PENDING" },
        { DL_OUTCON_PENDING, "DL_OUTCON_PENDING" },
        { DL_INCON_PENDING, "DL_INCON_PENDING" },
        { DL_CONN_RES_PENDING, "DL_CONN_RES_PENDING" },
        { DL_DATAXFER, "DL_DATAXFER" },
        { DL_USER_RESET_PENDING, "DL_USER_RESET_PENDING" },
        { DL_PROV_RESET_PENDING, "DL_PROV_RESET_PENDING" },
        { DL_RESET_RES_PENDING, "DL_RESET_RES_PENDING" },
        { DL_DISCON8_PENDING, "DL_DISCON8_PENDING" },
        { DL_DISCON9_PENDING, "DL_DISCON9_PENDING" },
        { DL_DISCON11_PENDING, "DL_DISCON11_PENDING" },
        { DL_DISCON12_PENDING, "DL_DISCON12_PENDING" },
        { DL_DISCON13_PENDING, "DL_DISCON13_PENDING" },
        { DL_SUBS_BIND_PND, "DL_SUBS_BIND_PND" },
        { DL_SUBS_UNBIND_PND, "DL_SUBS_UNBIND_PND" },
        { 0, NULL }
};

static const char *
prim2name(uint32_t prim)
{
        const struct sppp_dlpi_entry *sde;

        for (sde = sppp_dlpi_list; sde->sde_name != NULL; sde++)
                if (sde->sde_val == prim)
                        break;
        return (sde->sde_name);
}

static const char *
state2name(uint32_t state)
{
        const struct sppp_dlpi_entry *sde;

        for (sde = sppp_state_list; sde->sde_name != NULL; sde++)
                if (sde->sde_val == state)
                        break;
        return (sde->sde_name);
}

#define DBGDLPI(x)      cmn_err x
#else
#define DBGDLPI(x)      ((void)0)
#endif /* DBG_DLPI */

/*
 * DL_INFO_ACK template for point-to-point interface.
 */
static dl_info_ack_t    sppp_infoack = {
        DL_INFO_ACK,                    /* dl_primitive */
        PPP_MAXMTU,                     /* dl_max_sdu */
        0,                              /* dl_min_sdu */
        SPPP_ADDRL,                     /* dl_addr_length */
        /*
         * snoop et. al. don't know about DL_OTHER so this entry
         * was changed to DL_ETHER so ethernet tracing/snooping
         * facilities will work with PPP interfaces.
         */
        DL_ETHER,                       /* dl_mac_type */
        0,                              /* dl_reserved */
        0,                              /* dl_current_state */
        SPPP_SAPL,                      /* dl_sap_length */
        DL_CLDLS,                       /* dl_service_mode */
        0,                              /* dl_qos_length */
        0,                              /* dl_qos_offset */
        0,                              /* dl_range_length */
        0,                              /* dl_range_offset */
        DL_STYLE2,                      /* dl_provider_style */
        sizeof (dl_info_ack_t),         /* dl_addr_offset */
        DL_VERSION_2,                   /* dl_version */
        0,                              /* dl_brdcst_addr_length */
        0,                              /* dl_brdcst_addr_offset */
        0                               /* dl_growth */
};

/*
 * sppp_dlpi_pinfoinit()
 *
 * Description:
 *    Initialize dl_pinfo[], called from sppp_attach.
 */
void
sppp_dlpi_pinfoinit(void)
{
        bzero(dl_pinfo, sizeof (dl_pinfo));     /* Just to be safe */

        dl_pinfo[DL_ATTACH_REQ].pi_minlen = sizeof (dl_attach_req_t);
        dl_pinfo[DL_ATTACH_REQ].pi_state = DL_UNATTACHED;
        dl_pinfo[DL_ATTACH_REQ].pi_funcp = sppp_dlattachreq;

        dl_pinfo[DL_DETACH_REQ].pi_minlen = sizeof (dl_detach_req_t);
        dl_pinfo[DL_DETACH_REQ].pi_state = DL_UNBOUND;
        dl_pinfo[DL_DETACH_REQ].pi_funcp = sppp_dldetachreq;

        dl_pinfo[DL_BIND_REQ].pi_minlen = sizeof (dl_bind_req_t);
        dl_pinfo[DL_BIND_REQ].pi_state = DL_UNBOUND;
        dl_pinfo[DL_BIND_REQ].pi_funcp = sppp_dlbindreq;

        dl_pinfo[DL_UNBIND_REQ].pi_minlen = sizeof (dl_unbind_req_t);
        dl_pinfo[DL_UNBIND_REQ].pi_state = DL_IDLE;
        dl_pinfo[DL_UNBIND_REQ].pi_funcp = sppp_dlunbindreq;

        dl_pinfo[DL_INFO_REQ].pi_minlen = sizeof (dl_info_req_t);
        dl_pinfo[DL_INFO_REQ].pi_state = -1;    /* special handling */
        dl_pinfo[DL_INFO_REQ].pi_funcp = sppp_dlinforeq;

        dl_pinfo[DL_UNITDATA_REQ].pi_minlen = sizeof (dl_unitdata_req_t);
        dl_pinfo[DL_UNITDATA_REQ].pi_state = DL_IDLE;
        dl_pinfo[DL_UNITDATA_REQ].pi_funcp = sppp_dlunitdatareq;

        dl_pinfo[DL_PROMISCON_REQ].pi_minlen = sizeof (dl_promiscon_req_t);
        dl_pinfo[DL_PROMISCON_REQ].pi_state = -1; /* special handling */
        dl_pinfo[DL_PROMISCON_REQ].pi_funcp = sppp_dlpromisconreq;

        dl_pinfo[DL_PROMISCOFF_REQ].pi_minlen = sizeof (dl_promiscoff_req_t);
        dl_pinfo[DL_PROMISCOFF_REQ].pi_state = -1; /* special handling */
        dl_pinfo[DL_PROMISCOFF_REQ].pi_funcp = sppp_dlpromiscoffreq;

        dl_pinfo[DL_PHYS_ADDR_REQ].pi_minlen = sizeof (dl_phys_addr_req_t);
        dl_pinfo[DL_PHYS_ADDR_REQ].pi_state = -1; /* special handling */
        dl_pinfo[DL_PHYS_ADDR_REQ].pi_funcp = sppp_dlphyreq;
}

/*
 * sppp_mproto()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Handle M_PCPROTO/M_PROTO messages, called by sppp_uwput.
 */
int
sppp_mproto(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        union DL_primitives *dlp;
        struct sppp_dlpi_pinfo_t *dpi;
        t_uscalar_t     prim;
        int             len;
        int             error = 0;

        ASSERT(!IS_SPS_CONTROL(sps));
        if ((len = MBLKL(mp)) < sizeof (t_uscalar_t)) {
                DBGERROR((CE_CONT, "bad mproto: block length %d\n", len));
                merror(q, mp, EPROTO);
                return (0);
        }
        dlp = (union DL_primitives *)mp->b_rptr;
        prim = dlp->dl_primitive;
        if (prim > DL_MAXPRIM) {
                DBGERROR((CE_CONT, "bad mproto: primitive %d > %d\n", prim,
                    DL_MAXPRIM));
                error = DL_BADPRIM;
        } else {
                dpi = &dl_pinfo[prim];
                if (dpi->pi_funcp == NULL) {
                        DBGERROR((CE_CONT,
                            "bad mproto: primitive %d not supported\n", prim));
                        error = DL_NOTSUPPORTED;
                } else if (len < dpi->pi_minlen) {
                        DBGERROR((CE_CONT,
                            "bad mproto: primitive len %d < %d\n", len,
                            dpi->pi_minlen));
                        error = DL_BADPRIM;
                } else if (dpi->pi_state != -1 &&
                    sps->sps_dlstate != dpi->pi_state) {
                        DBGERROR((CE_CONT,
                            "bad state %d != %d for primitive %d\n",
                            sps->sps_dlstate, dpi->pi_state, prim));
                        error = DL_OUTSTATE;
                }
        }
        if (error != 0) {
                dlerrorack(q, mp, dlp->dl_primitive, error, 0);
                return (0);
        }
#ifdef DBG_DLPI
        {
                const char *cp = prim2name(prim);
                if (cp != NULL)
                        cmn_err(CE_CONT, "/%d: Dispatching %s\n",
                            sps->sps_mn_id, cp);
                else
                        cmn_err(CE_CONT,
                            "/%d: Dispatching unknown primitive %d\n",
                            sps->sps_mn_id, prim);
        }
#endif
        return ((*dpi->pi_funcp)(q, mp, sps));
}

/*
 * sppp_dlattachreq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_ATTACH_REQ request, called by sppp_mproto.
 */
static int
sppp_dlattachreq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        int     error = 0;
        union DL_primitives *dlp;

        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        dlp = (union DL_primitives *)mp->b_rptr;
        ASSERT(sps != NULL);
        ASSERT(sps->sps_dlstate == DL_UNATTACHED);

        if (IS_SPS_PIOATTACH(sps)) {
                DBGERROR((CE_CONT, "DLPI attach: already attached\n"));
                error = EINVAL;
        }
        if (error != 0) {
                dlerrorack(q, mp, dlp->dl_primitive, DL_OUTSTATE, error);
        } else {
                qwriter(q, mp, sppp_dl_attach_upper, PERIM_OUTER);
        }
        return (0);
}

/*
 * sppp_dl_attach_upper()
 *
 * MT-Perimeters:
 *    exclusive inner, exclusive outer.
 *
 * Description:
 *    Called by qwriter (INNER) from sppp_dlattachreq as the result of
 *    receiving a DL_ATTACH_REQ message.
 */
static void
sppp_dl_attach_upper(queue_t *q, mblk_t *mp)
{
        sppa_t          *ppa;
        spppstr_t       *sps = q->q_ptr;
        union DL_primitives *dlp;
        int             err = ENOMEM;
        cred_t          *cr;
        zoneid_t        zoneid;

        ASSERT(!IS_SPS_PIOATTACH(sps));
        dlp = (union DL_primitives *)mp->b_rptr;

        /* If there's something here, it's detached. */
        if (sps->sps_ppa != NULL) {
                sppp_remove_ppa(sps);
        }

        if ((cr = msg_getcred(mp, NULL)) == NULL)
                zoneid = sps->sps_zoneid;
        else
                zoneid = crgetzoneid(cr);

        ppa = sppp_find_ppa(dlp->attach_req.dl_ppa);
        if (ppa == NULL) {
                ppa = sppp_create_ppa(dlp->attach_req.dl_ppa, zoneid);
        } else if (ppa->ppa_zoneid != zoneid) {
                ppa = NULL;
                err = EPERM;
        }

        /*
         * If we can't find or create it, then it's either because we're out of
         * memory or because the requested PPA is owned by a different zone.
         */
        if (ppa == NULL) {
                DBGERROR((CE_CONT, "DLPI attach: cannot create ppa %u\n",
                    dlp->attach_req.dl_ppa));
                dlerrorack(q, mp, dlp->dl_primitive, DL_SYSERR, err);
                return;
        }
        /*
         * Preallocate the hangup message so that we're always able to
         * send this upstream in the event of a catastrophic failure.
         */
        if ((sps->sps_hangup = allocb(1, BPRI_MED)) == NULL) {
                DBGERROR((CE_CONT, "DLPI attach: cannot allocate hangup\n"));
                dlerrorack(q, mp, dlp->dl_primitive, DL_SYSERR, ENOSR);
                return;
        }
        sps->sps_dlstate = DL_UNBOUND;
        sps->sps_ppa = ppa;
        /*
         * Add this stream to the head of the list of sibling streams
         * which belong to the specified ppa.
         */
        rw_enter(&ppa->ppa_sib_lock, RW_WRITER);
        ppa->ppa_refcnt++;
        sps->sps_nextsib = ppa->ppa_streams;
        ppa->ppa_streams = sps;
        /*
         * And if this stream was marked as promiscuous (SPS_PROMISC), then we
         * need to update the promiscuous streams count. This should only
         * happen when DL_PROMISCON_REQ was issued prior to attachment.
         */
        if (IS_SPS_PROMISC(sps)) {
                ppa->ppa_promicnt++;
        }
        rw_exit(&ppa->ppa_sib_lock);
        DBGDLPI((CE_CONT, "/%d: attached to ppa %d\n", sps->sps_mn_id,
            ppa->ppa_ppa_id));
        dlokack(q, mp, DL_ATTACH_REQ);
}

/*
 * sppp_dldetachreq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_DETACH_REQ request, called by sppp_mproto.
 */
/* ARGSUSED */
static int
sppp_dldetachreq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        ASSERT(sps != NULL);
        ASSERT(sps->sps_dlstate == DL_UNBOUND);
        ASSERT(!IS_SPS_PIOATTACH(sps));

        qwriter(q, mp, sppp_dl_detach_upper, PERIM_INNER);
        return (0);
}

/*
 * sppp_dl_detach_upper()
 *
 * MT-Perimeters:
 *    exclusive inner, shared outer.
 *
 * Description:
 *    Called by qwriter (INNER) from sppp_dldetachreq as the result of
 *    receiving a DL_DETACH_REQ message.
 */
/* ARGSUSED */
static void
sppp_dl_detach_upper(queue_t *q, mblk_t *mp)
{
        spppstr_t       *sps;

        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        sps = (spppstr_t *)q->q_ptr;
        /*
         * We don't actually detach from the PPA until closed or
         * reattached.
         */
        sps->sps_flags &= ~SPS_PROMISC; /* clear flag anyway */
        sps->sps_dlstate = DL_UNATTACHED;
        dlokack(q, mp, DL_DETACH_REQ);
}

/*
 * sppp_dlbindreq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_BIND_REQ request, called by sppp_mproto.
 */
static int
sppp_dlbindreq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        sppa_t                  *ppa;
        union DL_primitives     *dlp;
        spppreqsap_t            req_sap;
        int                     error = 0;

        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        dlp = (union DL_primitives *)mp->b_rptr;
        req_sap = dlp->bind_req.dl_sap;
        ASSERT(sps != NULL);
        ASSERT(!IS_SPS_PIOATTACH(sps));
        ASSERT(sps->sps_dlstate == DL_UNBOUND);

        ppa = sps->sps_ppa;
        if (ppa == NULL) {
                DBGERROR((CE_CONT, "DLPI bind: no attached ppa\n"));
                error = DL_OUTSTATE;
        } else if ((req_sap != ETHERTYPE_IP) && (req_sap != ETHERTYPE_IPV6) &&
            (req_sap != ETHERTYPE_ALLSAP)) {
                DBGERROR((CE_CONT, "DLPI bind: unknown SAP %x\n", req_sap));
                error = DL_BADADDR;
        }
        if (error != 0) {
                dlerrorack(q, mp, dlp->dl_primitive, error, 0);
        } else {
                qwriter(q, mp, sppp_dl_bind, PERIM_INNER);
        }
        return (0);
}

/*
 * sppp_dl_bind()
 *
 * MT-Perimeters:
 *    exclusive inner, shared outer.
 *
 * Description:
 *    Called by qwriter (INNER) from sppp_dlbindreq as the result of
 *    receiving a DL_BIND_REQ message.
 */
static void
sppp_dl_bind(queue_t *q, mblk_t *mp)
{
        spppstr_t               *sps;
        sppa_t                  *ppa;
        union DL_primitives     *dlp;
        t_scalar_t              sap;
        spppreqsap_t            req_sap;
        mblk_t                  *lsmp;

        ASSERT(q != NULL && q->q_ptr != NULL);
        sps = (spppstr_t *)q->q_ptr;
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        dlp = (union DL_primitives *)mp->b_rptr;
        ppa = sps->sps_ppa;
        ASSERT(ppa != NULL);
        req_sap = dlp->bind_req.dl_sap;
        ASSERT((req_sap == ETHERTYPE_IP) || (req_sap == ETHERTYPE_IPV6) ||
            (req_sap == ETHERTYPE_ALLSAP));

        if (req_sap == ETHERTYPE_IP) {
                sap = PPP_IP;
        } else if (req_sap == ETHERTYPE_IPV6) {
                sap = PPP_IPV6;
        } else if (req_sap == ETHERTYPE_ALLSAP) {
                sap = PPP_ALLSAP;
        }
        /*
         * If there's another stream with the same sap has already been bound
         * to the same ppa, then return with DL_NOADDR. However, we do make an
         * exception for snoop (req_sap=0x00, sap=0xff) since multiple
         * instances of snoop may execute an a given device.
         */
        lsmp = NULL;
        if (sap != PPP_ALLSAP) {
                if ((sap == PPP_IP) && (ppa->ppa_ip_cache == NULL)) {
                        ppa->ppa_ip_cache = sps;
                        if (ppa->ppa_ctl != NULL) {
                                lsmp = create_lsmsg(PPP_LINKSTAT_IPV4_BOUND);
                        }
                } else if ((sap == PPP_IPV6) && (ppa->ppa_ip6_cache == NULL)) {
                        ppa->ppa_ip6_cache = sps;
                        if (ppa->ppa_ctl != NULL) {
                                lsmp = create_lsmsg(PPP_LINKSTAT_IPV6_BOUND);
                        }
                } else {
                        DBGERROR((CE_CONT, "DLPI bind: bad SAP %x\n", sap));
                        dlerrorack(q, mp, dlp->dl_primitive, DL_NOADDR,
                            EEXIST);
                        return;
                }
                sps->sps_flags |= SPS_CACHED;
        }
        /*
         * Tell the daemon that a DLPI bind has happened on this stream,
         * and we'll only do this for PPP_IP or PPP_IPV6 sap (not snoop).
         */
        if (lsmp != NULL && ppa->ppa_ctl != NULL) {
#ifdef DBG_DLPI
                cmn_err(CE_CONT, "sending up %s\n",
                    ((sap == PPP_IP) ? "PPP_LINKSTAT_IPV4_BOUND" :
                    "PPP_LINKSTAT_IPV6_BOUND"));
#endif
                putnext(ppa->ppa_ctl->sps_rq, lsmp);
        }
        DBGDLPI((CE_CONT, "/%d: bound to sap %X (req %X)\n", sps->sps_mn_id,
            sap, req_sap));
        sps->sps_req_sap = req_sap;
        sps->sps_sap = sap;
        sps->sps_dlstate = DL_IDLE;
        dlbindack(q, mp, req_sap, &sap, sizeof (int32_t), 0, 0);
}

/*
 * sppp_dlunbindreq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_UNBIND_REQ request, called by sppp_mproto.
 */
/* ARGSUSED */
static int
sppp_dlunbindreq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        ASSERT(sps != NULL);
        ASSERT(!IS_SPS_PIOATTACH(sps));
        ASSERT(sps->sps_dlstate == DL_IDLE);

        qwriter(q, mp, sppp_dl_unbind, PERIM_INNER);
        return (0);
}

/*
 * sppp_dl_unbind()
 *
 * MT-Perimeters:
 *    exclusive inner, shared outer.
 *
 * Description:
 *    Called by qwriter (INNER) from sppp_dlunbindreq as the result of
 *    receiving a DL_UNBIND_REQ message.
 */
static void
sppp_dl_unbind(queue_t *q, mblk_t *mp)
{
        spppstr_t       *sps;
        sppa_t          *ppa;
        t_scalar_t      sap;
        mblk_t          *msg;
        boolean_t       saydown;

        ASSERT(q != NULL && q->q_ptr != NULL);
        sps = (spppstr_t *)q->q_ptr;
        ppa = sps->sps_ppa;
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        sap = sps->sps_sap;
        ASSERT((sap == PPP_IP) || (sap == PPP_IPV6) || (sap == PPP_ALLSAP));

        /* Flush messages on unbind, per DLPI specification. */
        flushq(WR(q), FLUSHALL);
        flushq(RD(q), FLUSHALL);

        if ((ppa != NULL) && IS_SPS_CACHED(sps)) {
                sps->sps_flags &= ~SPS_CACHED;
                msg = NULL;
                saydown = (ppa->ppa_ctl != NULL &&
                    (sps->sps_npmode == NPMODE_PASS ||
                    sps->sps_npmode == NPMODE_QUEUE));
                if (sap == PPP_IP) {
                        ppa->ppa_ip_cache = NULL;
                        if (saydown)
                                msg = create_lsmsg(PPP_LINKSTAT_IPV4_UNBOUND);
                } else if (sap == PPP_IPV6) {
                        ppa->ppa_ip6_cache = NULL;
                        if (saydown)
                                msg = create_lsmsg(PPP_LINKSTAT_IPV6_UNBOUND);
                }
                if (msg != NULL) {
#ifdef DBG_DLPI
                        cmn_err(CE_CONT, "sending up %s\n",
                            ((sap == PPP_IP) ? "PPP_LINKSTAT_IPV4_UNBOUND" :
                            "PPP_LINKSTAT_IPV6_UNBOUND"));
#endif
                        putnext(ppa->ppa_ctl->sps_rq, msg);
                }
        }
        DBGDLPI((CE_CONT, "/%d: unbound from sap %X (req %X)\n", sps->sps_mn_id,
            sps->sps_sap, sps->sps_req_sap));
        sps->sps_req_sap = 0;
        sps->sps_sap = -1;
        sps->sps_dlstate = DL_UNBOUND;

        dlokack(q, mp, DL_UNBIND_REQ);
}

/*
 * sppp_dlinforeq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_INFO_REQ request, called by sppp_mproto.
 */
static int
sppp_dlinforeq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        dl_info_ack_t   *dlip;
        uint32_t        size;
        uint32_t        addr_size;
        sppa_t          *ppa;

        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        ASSERT(sps != NULL);
        ppa = sps->sps_ppa;

        /* Exchange current msg for a DL_INFO_ACK. */
        addr_size = SPPP_ADDRL;
        size = sizeof (dl_info_ack_t) + addr_size;
        if ((mp = mexchange(q, mp, size, M_PCPROTO, DL_INFO_ACK)) == NULL) {
                DBGERROR((CE_CONT, "DLPI info: mexchange failed\n"));
                /* mexchange already sent up an merror ENOSR */
                return (0);
        }
        /* Fill in DL_INFO_ACK fields and reply */
        dlip = (dl_info_ack_t *)mp->b_rptr;
        *dlip = sppp_infoack;
        dlip->dl_current_state = sps->sps_dlstate;
        dlip->dl_max_sdu = ppa != NULL ? ppa->ppa_mtu : PPP_MAXMTU;
#ifdef DBG_DLPI
        {
                const char *cp = state2name(dlip->dl_current_state);
                if (cp != NULL)
                        cmn_err(CE_CONT, "info returns state %s, max sdu %d\n",
                            cp, dlip->dl_max_sdu);
                else
                        cmn_err(CE_CONT, "info returns state %d, max sdu %d\n",
                            dlip->dl_current_state, dlip->dl_max_sdu);
        }
#endif
        qreply(q, mp);
        return (0);
}

/*
 * sppp_dlunitdatareq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Handle DL_UNITDATA_REQ request, called by sppp_mproto. This procedure
 *    gets called for M_PROTO (DLPI) style of transmission. The fact that we
 *    have acknowledged IP's fastpath probing (DL_IOC_HDR_INFO) does not
 *    guarantee that IP will always transmit via M_DATA, and it merely implies
 *    that such situation _may_ happen. In other words, IP may decide to use
 *    M_PROTO (DLPI) for data transmission should it decide to do so.
 *    Therefore, we should never place any restrictions or checks against
 *    streams marked with SPS_FASTPATH, since it is legal for this procedure
 *    to be entered with or without the bit set.
 */
static int
sppp_dlunitdatareq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        sppa_t          *ppa;
        mblk_t          *hdrmp;
        mblk_t          *pktmp;
        dl_unitdata_req_t *dludp;
        int             dladdroff;
        int             dladdrlen;
        int             msize;
        int             error = 0;
        boolean_t       is_promisc;

        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        ASSERT((MTYPE(mp) == M_PCPROTO) || (MTYPE(mp) == M_PROTO));
        dludp = (dl_unitdata_req_t *)mp->b_rptr;
        dladdroff = dludp->dl_dest_addr_offset;
        dladdrlen = dludp->dl_dest_addr_length;
        ASSERT(sps != NULL);
        ASSERT(!IS_SPS_PIOATTACH(sps));
        ASSERT(sps->sps_dlstate == DL_IDLE);
        ASSERT(q->q_ptr == sps);
        /*
         * If this stream is not attached to any ppas, then discard data
         * coming down through this stream.
         */
        ppa = sps->sps_ppa;
        if (ppa == NULL) {
                DBGERROR((CE_CONT, "DLPI unitdata: no attached ppa\n"));
                error = ENOLINK;
        } else if (mp->b_cont == NULL) {
                DBGERROR((CE_CONT, "DLPI unitdata: missing data\n"));
                error = EPROTO;
        }
        if (error != 0) {
                dluderrorind(q, mp, mp->b_rptr + dladdroff, dladdrlen,
                    DL_BADDATA, error);
                return (0);
        }
        ASSERT(mp->b_cont->b_rptr != NULL);
        /*
         * Check if outgoing packet size is larger than allowed. We use
         * msgdsize to count all of M_DATA blocks in the message.
         */
        msize = msgdsize(mp);
        if (msize > ppa->ppa_mtu) {
                /* Log, and send it anyway */
                mutex_enter(&ppa->ppa_sta_lock);
                ppa->ppa_otoolongs++;
                mutex_exit(&ppa->ppa_sta_lock);
        }
        if (IS_SPS_KDEBUG(sps)) {
                SPDEBUG(PPP_DRV_NAME
                    "/%d: DL_UNITDATA_REQ (%d bytes) sps=0x%p flags=0x%b "
                    "ppa=0x%p flags=0x%b\n", sps->sps_mn_id, msize,
                    (void *)sps, sps->sps_flags, SPS_FLAGS_STR,
                    (void *)ppa, ppa->ppa_flags, PPA_FLAGS_STR);
        }
        /* Allocate a message (M_DATA) to contain PPP header bytes. */
        if ((hdrmp = allocb(PPP_HDRLEN, BPRI_MED)) == NULL) {
                mutex_enter(&ppa->ppa_sta_lock);
                ppa->ppa_allocbfail++;
                mutex_exit(&ppa->ppa_sta_lock);
                DBGERROR((CE_CONT,
                    "DLPI unitdata: can't allocate header buffer\n"));
                dluderrorind(q, mp, mp->b_rptr + dladdroff, dladdrlen,
                    DL_SYSERR, ENOSR);
                return (0);
        }
        /*
         * Should there be any promiscuous stream(s), send the data up
         * for each promiscuous stream that we recognize.
         */
        rw_enter(&ppa->ppa_sib_lock, RW_READER);
        is_promisc = ppa->ppa_promicnt;
        if (is_promisc) {
                ASSERT(ppa->ppa_streams != NULL);
                sppp_dlprsendup(ppa->ppa_streams, mp->b_cont, sps->sps_sap,
                    B_FALSE);
        }
        rw_exit(&ppa->ppa_sib_lock);
        /* Discard DLPI header and keep only IP payload (mp->b_cont). */
        pktmp = mp->b_cont;
        mp->b_cont = NULL;
        freemsg(mp);
        mp = hdrmp;

        *(uchar_t *)mp->b_wptr++ = PPP_ALLSTATIONS;
        *(uchar_t *)mp->b_wptr++ = PPP_UI;
        *(uchar_t *)mp->b_wptr++ = ((uint16_t)sps->sps_sap >> 8) & 0xff;
        *(uchar_t *)mp->b_wptr++ = ((uint16_t)sps->sps_sap) & 0xff;
        ASSERT(MBLKL(mp) == PPP_HDRLEN);

        linkb(mp, pktmp);
        /*
         * Only time-stamp the packet with hrtime if the upper stream
         * is configured to do so.
         */
        if (IS_PPA_TIMESTAMP(ppa)) {
                ppa->ppa_lasttx = gethrtime();
        }
        /*
         * Just put this back on the queue and allow the write service
         * routine to handle it.  We're nested too deeply here to
         * rewind the stack sufficiently to prevent overflow.  This is
         * the slow path anyway.
         */
        if (putq(q, mp) == 0) {
                mutex_enter(&ppa->ppa_sta_lock);
                ppa->ppa_oqdropped++;
                mutex_exit(&ppa->ppa_sta_lock);
                freemsg(mp);
        } else {
                qenable(q);
        }
        return (0);
}

/*
 * sppp_dlpromisconreq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_PROMISCON_REQ request, called by sppp_mproto.
 */
static int
sppp_dlpromisconreq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        t_uscalar_t     level;

        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        level = ((dl_promiscon_req_t *)mp->b_rptr)->dl_level;
        ASSERT(sps != NULL);

        /* snoop issues DL_PROMISCON_REQ more than once. */
        if (IS_SPS_PROMISC(sps)) {
                dlokack(q, mp, DL_PROMISCON_REQ);
        } else if ((level != DL_PROMISC_PHYS) && (level != DL_PROMISC_SAP) &&
            (level != DL_PROMISC_MULTI)) {
                DBGERROR((CE_CONT, "DLPI promiscon: bad level %d\n", level));
                dlerrorack(q, mp, DL_PROMISCON_REQ, DL_NOTSUPPORTED, 0);
        } else {
                qwriter(q, mp, sppp_dl_promiscon, PERIM_INNER);
        }
        return (0);
}

/*
 * sppp_dl_promiscon()
 *
 * MT-Perimeters:
 *    exclusive inner, shared outer.
 *
 * Description:
 *    Called by qwriter (INNER) from sppp_dlpromisconreq as the result of
 *    receiving a DL_PROMISCON_REQ message.
 */
static void
sppp_dl_promiscon(queue_t *q, mblk_t *mp)
{
        spppstr_t       *sps;
        sppa_t          *ppa;

        ASSERT(q != NULL && q->q_ptr != NULL);
        sps = (spppstr_t *)q->q_ptr;
        ASSERT(!IS_SPS_PROMISC(sps));
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        ppa = sps->sps_ppa;

        sps->sps_flags |= SPS_PROMISC;
        /*
         * We can't be sure that the sps_ppa field is valid, since the DLPI
         * spec says that DL_PROMISCON_REQ can be issued at any state, i.e.,
         * the request can be issued even before DL_ATTACH_REQ or PPPIO_ATTACH
         * be issued to associate this stream with a ppa.
         */
        if (ppa != NULL) {
                rw_enter(&ppa->ppa_sib_lock, RW_WRITER);
                ppa->ppa_promicnt++;
                rw_exit(&ppa->ppa_sib_lock);
        }
        DBGDLPI((CE_CONT, "/%d: promiscuous mode on\n", sps->sps_mn_id));
        dlokack(q, mp, DL_PROMISCON_REQ);
}

/*
 * sppp_dlpromiscoffreq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_PROMISCOFF_REQ request, called by sppp_mproto.
 */
static int
sppp_dlpromiscoffreq(queue_t *q, mblk_t *mp, spppstr_t *sps)
{
        t_uscalar_t     level;

        ASSERT(q != NULL && q->q_ptr != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        level = ((dl_promiscoff_req_t *)mp->b_rptr)->dl_level;
        ASSERT(sps != NULL);

        if (!IS_SPS_PROMISC(sps)) {
                DBGERROR((CE_CONT, "DLPI promiscoff: not promiscuous\n"));
                dlerrorack(q, mp, DL_PROMISCOFF_REQ, DL_NOTENAB, 0);
        } else if ((level != DL_PROMISC_PHYS) && (level != DL_PROMISC_SAP) &&
            (level != DL_PROMISC_MULTI)) {
                dlerrorack(q, mp, DL_PROMISCOFF_REQ, DL_NOTSUPPORTED, 0);
                DBGERROR((CE_CONT, "DLPI promiscoff: bad level %d\n", level));
        } else {
                qwriter(q, mp, sppp_dl_promiscoff, PERIM_INNER);
        }
        return (0);

}

/*
 * sppp_dl_promiscoff()
 *
 * MT-Perimeters:
 *    exclusive inner, shared outer.
 *
 * Description:
 *    Called by qwriter (INNER) from sppp_dlpromiscoffreq as the result of
 *    receiving a DL_PROMISCOFF_REQ message.
 */
static void
sppp_dl_promiscoff(queue_t *q, mblk_t *mp)
{
        spppstr_t       *sps;
        sppa_t          *ppa;

        ASSERT(q != NULL && q->q_ptr != NULL);
        sps = (spppstr_t *)q->q_ptr;
        ASSERT(IS_SPS_PROMISC(sps));
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        ppa = sps->sps_ppa;

        sps->sps_flags &= ~SPS_PROMISC;
        /*
         * We can't be guaranteed that the sps_ppa field is still valid, since
         * the control stream might have been closed earlier, in which case
         * the close procedure would have NULL'd out the sps_ppa.
         */
        if (ppa != NULL) {
                rw_enter(&ppa->ppa_sib_lock, RW_WRITER);
                ASSERT(ppa->ppa_promicnt > 0);
                ppa->ppa_promicnt--;
                rw_exit(&ppa->ppa_sib_lock);
        }
        DBGDLPI((CE_CONT, "/%d: promiscuous mode off\n", sps->sps_mn_id));
        dlokack(q, mp, DL_PROMISCOFF_REQ);
}

/*
 * sppp_dlphyreq()
 *
 * MT-Perimeters:
 *    shared inner, shared outer.
 *
 * Description:
 *    Perform DL_PHYS_ADDR_REQ request, called by sppp_mproto. This doesn't
 *    return anything useful, but it keeps ifconfig happy.
 */
/* ARGSUSED */
static int
sppp_dlphyreq(queue_t *q, mblk_t *mp, spppstr_t *us)
{
        static struct ether_addr addr = { 0 };

        dlphysaddrack(q, mp, (char *)&addr, ETHERADDRL);
        return (0);
}

/*
 * sppp_dladdether()
 *
 * Description:
 *    Prepend an empty Ethernet header to msg for snoop, et al. Free
 *    the original mblk if alloc fails. Only called for the purpose of sending
 *    packets up the promiscous stream.
 */
/* ARGSUSED */
static mblk_t *
sppp_dladdether(spppstr_t *sps, mblk_t *mp, t_scalar_t proto)
{
        mblk_t          *eh;
        t_scalar_t      type;

        if ((eh = allocb(sizeof (struct ether_header), BPRI_MED)) == NULL) {
                freemsg(mp);
                return (NULL);
        }
        if (proto == PPP_IP) {
                type = ETHERTYPE_IP;
        } else if (proto == PPP_IPV6) {
                type = ETHERTYPE_IPV6;
        } else {
                /*
                 * For all other protocols, end this up as an ETHERTYPE_PPP
                 * type of packet. Since we've skipped the PPP headers in the
                 * caller, make sure that we restore it. We know for sure that
                 * the PPP header still exists in the message (only skipped),
                 * since the sender of this message is pppd and it must have
                 * included the PPP header in front.
                 */
                type = ETHERTYPE_PPP;
                mp->b_rptr -= PPP_HDRLEN;
                ASSERT(mp->b_rptr >= mp->b_datap->db_base);
        }
        eh->b_wptr += sizeof (struct ether_header);
        bzero((caddr_t)eh->b_rptr, sizeof (struct ether_header));
        ((struct ether_header *)eh->b_rptr)->ether_type = htons((int16_t)type);

        linkb(eh, mp);
        return (eh);
}

/*
 * sppp_dladdud()
 *
 * Description:
 *    Prepend DL_UNITDATA_IND mblk to msg, free original alloc fails.
 */
/* ARGSUSED */
mblk_t *
sppp_dladdud(spppstr_t *sps, mblk_t *mp, t_scalar_t proto, boolean_t promisc)
{
        dl_unitdata_ind_t *dlu;
        mblk_t          *dh;
        size_t          size;
        t_scalar_t      type;

        size = sizeof (dl_unitdata_ind_t) + (2 * SPPP_ADDRL);
        if ((dh = allocb(size, BPRI_MED)) == NULL) {
                freemsg(mp);
                return (NULL);
        }

        dh->b_datap->db_type = M_PROTO;
        dh->b_wptr = dh->b_datap->db_lim;
        dh->b_rptr = dh->b_wptr - size;

        dlu = (dl_unitdata_ind_t *)dh->b_rptr;
        dlu->dl_primitive = DL_UNITDATA_IND;
        dlu->dl_dest_addr_length = SPPP_ADDRL;
        dlu->dl_dest_addr_offset = sizeof (dl_unitdata_ind_t);
        dlu->dl_src_addr_length = SPPP_ADDRL;
        dlu->dl_src_addr_offset = sizeof (dl_unitdata_ind_t) + SPPP_ADDRL;
        dlu->dl_group_address = 0;

        if (promisc) {
                if (proto == PPP_IP) {
                        type = ETHERTYPE_IP;
                } else if (proto == PPP_IPV6) {
                        type = ETHERTYPE_IPV6;
                } else {
                        /*
                         * For all other protocols, send this up as an
                         * ETHERTYPE_PPP type of packet. Since we've skipped
                         * the PPP headers in the caller, make sure that we
                         * restore it. We know for sure that the PPP header
                         * still exists in the message (only skipped), since
                         * the sender of this message is pppd and it must
                         * have included the PPP header in front.
                         */
                        type = ETHERTYPE_PPP;
                        mp->b_rptr -= PPP_HDRLEN;
                        ASSERT(mp->b_rptr >= mp->b_datap->db_base);
                }
        } else {
                type = sps->sps_req_sap;
        }
        /*
         * Send the DLPI client the data with the SAP they requested,
         * (e.g. ETHERTYPE_IP) rather than the PPP protocol (e.g. PPP_IP).
         */
        ((spppreqsap_t *)(dlu + 1))[0] = type;
        ((spppreqsap_t *)(dlu + 1))[1] = type;

        linkb(dh, mp);
        return (dh);
}

/*
 * sppp_dlprsendup()
 *
 * Description:
 *    For any valid promiscuous streams (marked with SPS_PROMISC and its
 *    sps_dlstate is DL_IDLE), send data upstream. The caller is expected
 *    to hold ppa_sib_lock when calling this procedure.
 */
void
sppp_dlprsendup(spppstr_t *sps, mblk_t *mp, t_scalar_t proto, boolean_t header)
{
        sppa_t  *ppa;
        mblk_t  *dmp;

        ASSERT(sps != NULL);
        ASSERT(mp != NULL && mp->b_rptr != NULL);
        ppa = sps->sps_ppa;
        ASSERT(ppa != NULL);

        /* NOTE: caller must hold ppa_sib_lock in RW_READER mode */
        ASSERT(RW_READ_HELD(&ppa->ppa_sib_lock));

        for (; sps != NULL; sps = sps->sps_nextsib) {
                /*
                 * We specifically test to ensure that the DLPI state for the
                 * promiscous stream is IDLE (DL_IDLE), since such state tells
                 * us that the promiscous stream has been bound to PPP_ALLSAP.
                 */
                if (IS_SPS_PROMISC(sps) && (sps->sps_dlstate == DL_IDLE) &&
                    canputnext(sps->sps_rq)) {
                        if ((dmp = dupmsg(mp)) == NULL) {
                                mutex_enter(&ppa->ppa_sta_lock);
                                ppa->ppa_allocbfail++;
                                mutex_exit(&ppa->ppa_sta_lock);
                                continue;
                        }
                        if (header) {
                                dmp->b_rptr += PPP_HDRLEN;
                        }
                        if (IS_SPS_RAWDATA(sps)) {
                                /* function frees original message if fails */
                                dmp = sppp_dladdether(sps, dmp, proto);
                        } else {
                                /* function frees original message if fails */
                                dmp = sppp_dladdud(sps, dmp, proto, B_TRUE);
                        }
                        if (dmp != NULL) {
                                putnext(sps->sps_rq, dmp);
                        } else {
                                mutex_enter(&ppa->ppa_sta_lock);
                                ppa->ppa_allocbfail++;
                                mutex_exit(&ppa->ppa_sta_lock);
                        }
                }
        }
}