/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
 * Copyright 2024 RackTop Systems, Inc.
 */

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

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 * Kernel TLI-like functions
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/proc.h>
#include <sys/file.h>
#include <sys/filio.h>
#include <sys/user.h>
#include <sys/vnode.h>
#include <sys/cmn_err.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/stream.h>
#include <sys/strsubr.h>
#include <sys/strsun.h>
#include <sys/tihdr.h>
#include <sys/timod.h>
#include <sys/tiuser.h>
#include <sys/t_kuser.h>

#include <errno.h>
#include <stropts.h>
#include <unistd.h>

/*
 * While <xti.h> is the perferred interface, we're simulating the
 * (in-kernel) kTLI here, which forces sys/tiuser.h on us, so just
 * use the older <tiuser.h> for the simulation.
 */
#include <tiuser.h>

#include "fake_fio.h"

/* Size of mblks for tli_recv */
#define FKTLI_RCV_SZ    4096

/*
 * Translate a TLI error into a system error as best we can.
 */
static const int tli_errs[] = {
        0,              /* no error     */
        EADDRNOTAVAIL,  /* TBADADDR     */
        ENOPROTOOPT,    /* TBADOPT      */
        EACCES,         /* TACCES       */
        EBADF,          /* TBADF        */
        EADDRNOTAVAIL,  /* TNOADDR      */
        EPROTO,         /* TOUTSTATE    */
        EPROTO,         /* TBADSEQ      */
        ENOSYS,         /* TSYSERR      */
        EPROTO,         /* TLOOK        */
        EMSGSIZE,       /* TBADDATA     */
        EMSGSIZE,       /* TBUFOVFLW    */
        EPROTO,         /* TFLOW        */
        EWOULDBLOCK,    /* TNODATA      */
        EPROTO,         /* TNODIS       */
        EPROTO,         /* TNOUDERR     */
        EINVAL,         /* TBADFLAG     */
        EPROTO,         /* TNOREL       */
        EOPNOTSUPP,     /* TNOTSUPPORT  */
        EPROTO,         /* TSTATECHNG   */
};

static int
tlitosyserr(int terr)
{
        if (terr < 0 || (terr >= (sizeof (tli_errs) / sizeof (tli_errs[0]))))
                return (EPROTO);
        else
                return (tli_errs[terr]);
}

/*
 * Note: This implementation is specific to the needs of the callers in
 * uts/common/fs/smbclnt/netsmb/smb_trantcp.c
 */
/* ARGSUSED */
int
t_kopen(file_t *fp, dev_t rdev, int flags, TIUSER **tiptr, cred_t *cr)
{
        boolean_t madefp = B_FALSE;
        TIUSER *tiu;
        int fd;
        int rc;

        *tiptr = NULL;

        if (fp == NULL) {
                /*
                 * create a socket endpoint
                 * dev is actualy AF
                 */
                char *devnm;
                switch (rdev) {
                case AF_INET:
                        devnm = "/dev/tcp";
                        break;
                case AF_INET6:
                        devnm = "/dev/tcp6";
                        break;
                default:
                        cmn_err(CE_NOTE, "t_kopen: bad device");
                        return (EINVAL);
                }

                fd = t_open(devnm, O_RDWR, NULL);
                if (fd < 0) {
                        rc = t_errno;
                        cmn_err(CE_NOTE, "t_kopen: t_open terr=%d", rc);
                        return (tlitosyserr(rc));
                }

                /*
                 * allocate a file pointer...
                 */
                fp = file_getf(fd);
                madefp = B_TRUE;
        }
        fd = file_getfd(fp);

        tiu = kmem_zalloc(sizeof (*tiu), KM_SLEEP);
        rc = t_getinfo(fd, &tiu->tp_info);
        if (rc < 0) {
                rc = t_errno;
                cmn_err(CE_NOTE, "t_kopen: t_getinfo terr=%d", rc);
                kmem_free(tiu, sizeof (*tiu));
                if (madefp) {
                        file_releasef(fd);
                        (void) t_close(fd);
                }
                return (tlitosyserr(rc));
        }

        tiu->fp = fp;
        tiu->flags = madefp ? MADE_FP : 0;
        *tiptr = tiu;

        return (0);
}

/* ARGSUSED */
int
t_kclose(TIUSER *tiptr, int callclosef)
{
        file_t  *fp;

        fp = (tiptr->flags & MADE_FP) ? tiptr->fp : NULL;

        kmem_free(tiptr, TIUSERSZ);

        if (fp != NULL) {
                int fd = file_getfd(fp);
                file_releasef(fd);
                (void) t_close(fd);
        }

        return (0);
}

int
t_kbind(TIUSER *tiptr, struct t_bind *req, struct t_bind *ret)
{
        file_t          *fp = tiptr->fp;
        int             fd = file_getfd(fp);
        int             rc;

        if (t_bind(fd, req, ret) < 0) {
                rc = t_errno;
                cmn_err(CE_NOTE, "t_kbind: t_bind terr=%d", rc);
                return (tlitosyserr(rc));
        }
        return (0);
}

int
t_kunbind(TIUSER *tiptr)
{
        file_t          *fp = tiptr->fp;
        int             fd = file_getfd(fp);
        int             rc;

        if (t_unbind(fd) < 0) {
                rc = t_errno;
                cmn_err(CE_NOTE, "t_kunbind: t_unbind terr=%d", rc);
                return (tlitosyserr(rc));
        }
        return (0);
}

int
t_kconnect(TIUSER *tiptr, struct t_call *sndcall, struct t_call *rcvcall)
{
        file_t          *fp = tiptr->fp;
        int             fd = file_getfd(fp);
        int             rc;

        if (t_connect(fd, sndcall, rcvcall) < 0) {
                rc = t_errno;
                cmn_err(CE_NOTE, "t_kconnect: t_connect terr=%d", rc);
                if (rc == TLOOK) {
                        /* Probably got a RST. */
                        rc = ECONNREFUSED;
                } else {
                        rc = tlitosyserr(rc);
                }
                return (rc);
        }
        return (0);
}

int
t_koptmgmt(TIUSER *tiptr, struct t_optmgmt *req, struct t_optmgmt *ret)
{
        file_t          *fp = tiptr->fp;
        int             fd = file_getfd(fp);
        int             rc;

        if (t_optmgmt(fd, req, ret) < 0) {
                rc = t_errno;
                cmn_err(CE_NOTE, "t_koptmgmt: t_optmgmt terr=%d", rc);
                return (tlitosyserr(rc));
        }
        return (0);
}

/*
 * Poll for an input event.
 *
 * timo is measured in ticks
 */
int
t_kspoll(TIUSER *tiptr, int timo, int waitflg, int *events)
{
        struct pollfd   pfds[1];
        file_t          *fp = tiptr->fp;
        int             fd = file_getfd(fp);
        clock_t         timout; /* milliseconds */
        int             n;

        if (events == NULL || ((waitflg & READWAIT) == 0))
                return (EINVAL);

        /* Convert from ticks to milliseconds */
        if (timo < 0)
                timout = -1;
        else
                timout = TICK_TO_MSEC(timo);

        pfds[0].fd = fd;
        pfds[0].events = POLLIN;
        pfds[0].revents = 0;

        errno = 0;
        n = poll(pfds, 1, timout);
        if (n < 0)
                return (errno);
        if (n == 0)
                return (ETIME);
        *events = pfds[0].revents;
        return (0);
}

/*
 * Send the message, return zero or errno.
 * Always free's the message, even on error.
 */
int
tli_send(TIUSER *tiptr, mblk_t *bp, int fmode)
{
        struct strbuf ctlbuf;
        struct strbuf databuf;
        mblk_t  *m;
        int     flg, n, rc;
        file_t  *fp = tiptr->fp;
        int     fd = file_getfd(fp);

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

        switch (bp->b_datap->db_type) {
        case M_DATA:
                for (m = bp; m != NULL; m = m->b_cont) {
                        n = MBLKL(m);
                        flg = (m->b_cont != NULL) ? T_MORE : 0;
                        rc = t_snd(fd, (void *) m->b_rptr, n, flg);
                        if (rc != n) {
                                rc = EIO;
                                goto out;
                        }
                }
                rc = 0;
                break;

        /*
         * May get M_PROTO/T_DISCON_REQ from nb_snddis()
         */
        case M_PROTO:
        case M_PCPROTO:
                ctlbuf.len = MBLKL(bp);
                ctlbuf.maxlen = MBLKL(bp);
                ctlbuf.buf = (char *)bp->b_rptr;
                if (bp->b_cont == NULL) {
                        bzero(&databuf, sizeof (databuf));
                } else {
                        m = bp->b_cont;
                        databuf.len = MBLKL(m);
                        databuf.maxlen = MBLKL(m);
                        databuf.buf = (char *)m->b_rptr;
                }
                if (putmsg(fd, &ctlbuf, &databuf, 0) < 0) {
                        rc = errno;
                        cmn_err(CE_NOTE, "tli_send: putmsg err=%d", rc);
                } else {
                        rc = 0;
                }
                break;

        default:
                rc = EIO;
                break;
        }

out:
        freemsg(bp);
        return (rc);
}

int
tli_recv(TIUSER *tiptr, mblk_t **bp, int fmode)
{
        mblk_t          *mtop = NULL;
        mblk_t          *m;
        file_t          *fp = tiptr->fp;
        int             fd = file_getfd(fp);
        int             error;
        int             flags;
        int             nread;
        int             n;

        /*
         * Get an mblk for the data
         */
        nread = FKTLI_RCV_SZ;
        m = allocb_wait(nread, 0, 0, &error);
        ASSERT(m != NULL);

        if (mtop == NULL)
                mtop = m;

again:
        flags = 0;
        n = t_rcv(fd, (void *) m->b_rptr, nread, &flags);
        if (n < 0) {
                n = t_errno;
                cmn_err(CE_NOTE, "tli_recv: t_rcv terr=%d", n);
                error = tlitosyserr(n);
                goto errout;
        }
        if (n == 0) {
                error = ENOTCONN;
                goto errout;
        }
        ASSERT(n > 0 && n <= nread);
        m->b_wptr = m->b_rptr + n;

        if (flags & T_MORE) {
                mblk_t  *mtail = m;
                m = allocb_wait(nread, 0, 0, &error);
                ASSERT(m != NULL);
                mtail->b_cont = m;
                goto again;
        }

        *bp = mtop;
        return (0);

errout:
        if (m == mtop) {
                freemsg(mtop);
                return (error);
        }

        /* got some data, so return it. */
        return (0);
}