/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*
 * Transport Interface Library read/write module - issue 1
 */

#include        <sys/types.h>
#include        <sys/param.h>
#include        <sys/stream.h>
#include        <sys/stropts.h>
#include        <sys/tihdr.h>
#include        <sys/debug.h>
#include        <sys/errno.h>
#include        <sys/kmem.h>
#include        <sys/tirdwr.h>
#include        <sys/conf.h>
#include        <sys/modctl.h>
#include        <sys/ddi.h>
#include        <sys/sunddi.h>

#define ORDREL          002
#define DISCON          004
#define FATAL           010
#define WAITACK         020
#define TIRDWR_ID       4

/*
 * Per-Stream private data structure.
 */
struct trw_trw {
        queue_t *trw_rdq;
        uint_t  trw_flags;
};

/*
 * stream data structure definitions
 */
static  int tirdwropen(queue_t *q, dev_t *dev,
    int flag, int sflag, cred_t *cr);

static  int tirdwrclose(queue_t *q, int flag, cred_t *cr);

static  int check_strhead(queue_t *q);

/*
 * To save instructions, since STREAMS ignores the return value
 * from these functions, they are defined as void here. Kind of icky, but...
 */
static int tirdwrrput(queue_t *q, mblk_t *mp);
static int tirdwrwput(queue_t *q, mblk_t *mp);

static struct module_info tirdwr_info = {
        TIRDWR_ID,
        "tirdwr",
        0,
        INFPSZ,
        4096,
        1024
};

static struct qinit tirdwrrinit = {
        tirdwrrput,
        NULL,
        tirdwropen,
        tirdwrclose,
        nulldev,
        &tirdwr_info,
        NULL
};

static struct qinit tirdwrwinit = {
        tirdwrwput,
        NULL,
        tirdwropen,
        tirdwrclose,
        nulldev,
        &tirdwr_info,
        NULL
};

static struct streamtab trwinfo = {
        &tirdwrrinit,
        &tirdwrwinit,
        NULL,
        NULL
};

static struct fmodsw fsw = {
        "tirdwr",
        &trwinfo,
        D_NEW|D_MTQPAIR|D_MP
};

static struct modlstrmod modlstrmod = {
        &mod_strmodops, "xport interface rd/wr str mod", &fsw
};

static struct modlinkage modlinkage = {
        MODREV_1, &modlstrmod, 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));
}

static void send_fatal(queue_t *q, mblk_t *mp);
static void strip_strhead(queue_t *q);


/*
 * tirdwropen - open routine gets called when the
 *              module gets pushed onto the stream.
 */
/*ARGSUSED*/
static int
tirdwropen(
        queue_t *q,
        dev_t   *dev,
        int flag,
        int sflag,
        cred_t  *cr)
{
        struct trw_trw *trwptr;

        /* check if already open */
        if (q->q_ptr) {
                return (0);
        }

        /*
         * Allocate a new trw_trw struct.
         */
        trwptr = kmem_alloc(sizeof (struct trw_trw), KM_SLEEP);

        /* initialize data structure */
        trwptr->trw_flags = 0;
        trwptr->trw_rdq = q;
        q->q_ptr = (caddr_t)trwptr;
        WR(q)->q_ptr = (caddr_t)trwptr;
        qprocson(q);

        freezestr(q);

        (void) strqset(WR(q), QMAXPSZ, 0, (uintptr_t)WR(q)->q_next->q_maxpsz);
        (void) strqset(q, QMAXPSZ, 0, (uintptr_t)q->q_next->q_maxpsz);

        if (!check_strhead(q)) {
                unfreezestr(q);
                qprocsoff(q);
                kmem_free(trwptr, sizeof (struct trw_trw));
                return (EPROTO);
        }
        strip_strhead(q);
        unfreezestr(q);

        return (0);
}

/*
 * tirdwrclose - This routine gets called when the module
 *              gets popped off of the stream.
 */

/*ARGSUSED1*/
static int
tirdwrclose(queue_t *q, int flag, cred_t *cr)
{
        struct trw_trw *trwptr;
        mblk_t *mp;
        union T_primitives *pptr;

        qprocsoff(q);
        trwptr = (struct trw_trw *)q->q_ptr;

        ASSERT(trwptr != NULL);

        /*
         * Send up a T_DISCON_IND if necessary.
         */
        if ((trwptr->trw_flags & ORDREL) && !(trwptr->trw_flags & FATAL))
                if (mp = allocb(sizeof (struct T_discon_req), BPRI_LO)) {
                        pptr = (union T_primitives *)mp->b_rptr;
                        mp->b_wptr = mp->b_rptr + sizeof (struct T_ordrel_req);
                        pptr->type = T_ORDREL_REQ;
                        mp->b_datap->db_type = M_PROTO;
                        putnext(WR(q), mp);
                }

        kmem_free(trwptr, sizeof (struct trw_trw));

        return (0);
}

/*
 * tirdwrrput - Module read queue put procedure.
 *              This is called from the module or
 *              driver downstream.
 */

static int
tirdwrrput(queue_t *q, mblk_t *mp)
{
        union T_primitives *pptr;
        struct trw_trw *trwptr;
        mblk_t *tmp;

        trwptr = (struct trw_trw *)q->q_ptr;

        ASSERT(trwptr != NULL);

        if ((trwptr->trw_flags & FATAL) && !(trwptr->trw_flags & WAITACK)) {
                freemsg(mp);
                return (0);
        }

        switch (mp->b_datap->db_type) {

        default:
                putnext(q, mp);
                break;

        case M_DATA:
                putnext(q, mp);
                break;

        case M_PCPROTO:
        case M_PROTO:
                /* is there enough data to check type */
                if ((mp->b_wptr - mp->b_rptr) < sizeof (t_scalar_t)) {
                        /* malformed message */
                        freemsg(mp);
                        break;
                }
                pptr = (union T_primitives *)mp->b_rptr;

                switch (pptr->type) {

                case T_EXDATA_IND:
                        send_fatal(q, mp);
                        break;
                case T_DATA_IND:
                        if (msgdsize(mp) == 0) {
                                freemsg(mp);
                                break;
                        }

                        tmp = (mblk_t *)unlinkb(mp);
                        freemsg(mp);
                        putnext(q, tmp);
                        break;

                case T_ORDREL_IND:
                        trwptr->trw_flags |= ORDREL;
                        mp->b_datap->db_type = M_DATA;
                        mp->b_wptr = mp->b_rptr;
                        putnext(q, mp);
                        break;

                case T_DISCON_IND:
                        trwptr->trw_flags |= DISCON;
                        trwptr->trw_flags &= ~ORDREL;
                        if (msgdsize(mp) != 0) {
                                tmp = (mblk_t *)unlinkb(mp);
                                putnext(q, tmp);
                        }
                        mp->b_datap->db_type = M_HANGUP;
                        mp->b_wptr = mp->b_rptr;
                        putnext(q, mp);
                        break;

                default:
                        send_fatal(q, mp);
                        break;
                }
        }
        return (0);
}


/*
 * tirdwrwput - Module write queue put procedure.
 *              This is called from the module or
 *              stream head upstream.
 */
static int
tirdwrwput(queue_t *q, mblk_t *mp)
{
        struct trw_trw *trwptr;

        trwptr = (struct trw_trw *)q->q_ptr;

        ASSERT(trwptr != NULL);

        if (trwptr->trw_flags & FATAL) {
                freemsg(mp);
                return (0);
        }

        switch (mp->b_datap->db_type) {
        default:
                putnext(q, mp);
                break;

        case M_DATA:
                putnext(q, mp);
                break;

        case M_PROTO:
        case M_PCPROTO:
                send_fatal(q, mp);
                break;
        }
        return (0);
}


static void
send_fatal(queue_t *q, mblk_t *mp)
{
        struct trw_trw *trwptr;

        trwptr = (struct trw_trw *)q->q_ptr;

        trwptr->trw_flags |= FATAL;
        mp->b_datap->db_type = M_ERROR;
        *mp->b_datap->db_base = EPROTO;
        mp->b_rptr = mp->b_datap->db_base;
        mp->b_wptr = mp->b_datap->db_base + sizeof (char);
        freemsg(unlinkb(mp));
        if (q->q_flag&QREADR)
                putnext(q, mp);
        else
                qreply(q, mp);
}

static int
check_strhead(queue_t *q)
{
        mblk_t *mp;
        union T_primitives *pptr;

        for (mp = q->q_next->q_first; mp != NULL; mp = mp->b_next) {

                switch (mp->b_datap->db_type) {
                case M_PROTO:
                        pptr = (union T_primitives *)mp->b_rptr;
                        if ((mp->b_wptr - mp->b_rptr) < sizeof (t_scalar_t))
                                return (0);
                        switch (pptr->type) {

                        case T_EXDATA_IND:
                                return (0);
                        case T_DATA_IND:
                                if (mp->b_cont &&
                                    (mp->b_cont->b_datap->db_type != M_DATA))
                                        return (0);
                                break;
                        default:
                                return (0);
                        }
                        break;

                case M_PCPROTO:
                        return (0);

                case M_DATA:
                case M_SIG:
                        break;
                default:
                        return (0);
                }
        }
        return (1);
}

static void
strip_strhead(queue_t *q)
{
        mblk_t *mp;
        mblk_t *emp;
        mblk_t *tmp;
        union T_primitives *pptr;

        q = q->q_next;
        /*CSTYLED*/
        for (mp = q->q_first; mp != NULL; ) {

                switch (mp->b_datap->db_type) {
                case M_PROTO:
                        pptr = (union T_primitives *)mp->b_rptr;
                        switch (pptr->type) {

                        case T_DATA_IND:
                                if (msgdsize(mp) == 0) {
strip0:
                                        tmp = mp->b_next;
                                        rmvq(q, mp);
                                        freemsg(mp);
                                        mp = tmp;
                                        break;
                                }
                                emp = mp->b_next;
                                rmvq(q, mp);
                                tmp = (mblk_t *)unlinkb(mp);
                                freeb(mp);
                                (void) insq(q, emp, tmp);
                                mp = emp;
                                break;
                        }
                        break;

                case M_DATA:
                        if (msgdsize(mp) == 0)
                                goto strip0;
                        mp = mp->b_next;
                        break;

                case M_SIG:
                        mp = mp->b_next;
                        break;
                }
        }
}