/*
 * 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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/types.h>
#include <sys/t_lock.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/debug.h>
#include <sys/errno.h>
#include <sys/strsubr.h>
#include <sys/cmn_err.h>
#include <sys/sysmacros.h>

#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/strsun.h>
#include <sys/signal.h>

#include <netinet/sctp.h>
#include <inet/sctp_itf.h>
#include <fs/sockfs/sockcommon.h>
#include "socksctp.h"

extern kmem_cache_t *sosctp_assoccache;
/*
 * Find a free association id. See os/fio.c file descriptor allocator
 * for description of the algorithm.
 */
sctp_assoc_t
sosctp_aid_get(struct sctp_sonode *ss)
{
        sctp_assoc_t id, size, ralloc;
        struct sctp_sa_id *assocs = ss->ss_assocs;

        ASSERT((ss->ss_maxassoc & (ss->ss_maxassoc + 1)) == 0);

        for (id = 1; (uint32_t)id < ss->ss_maxassoc; id |= id + 1) {
                size = id + 1;
                if (assocs[id].ssi_alloc == size)
                        continue;
                for (ralloc = 0, size >>= 1; size != 0; size >>= 1) {
                        ralloc += assocs[id + size].ssi_alloc;
                        if (assocs[id].ssi_alloc == ralloc + size) {
                                id += size;
                                ralloc = 0;
                        }
                }
                return (id);
        }
        return (-1);
}

/*
 * Allocate or free ID, depending on whether incr is 1 or -1
 */
void
sosctp_aid_reserve(struct sctp_sonode *ss, sctp_assoc_t id, int incr)
{
        struct sctp_sa_id *assocs = ss->ss_assocs;
        sctp_assoc_t pid;

        ASSERT((assocs[id].ssi_assoc == NULL && incr == 1) ||
            (assocs[id].ssi_assoc != NULL && incr == -1));

        for (pid = id; pid >= 0; pid = (pid & (pid + 1)) - 1) {
                assocs[pid].ssi_alloc += incr;
        }
}

/*
 * Increase size of the ss_assocs array to accommodate at least maxid.
 * We keep the size of the form 2^n - 1 for benefit of sosctp_aid_get().
 */
int
sosctp_aid_grow(struct sctp_sonode *ss, sctp_assoc_t maxid, int kmflags)
{
        sctp_assoc_t newcnt, oldcnt;
        struct sctp_sa_id *newlist, *oldlist;

        ASSERT(MUTEX_HELD(&ss->ss_so.so_lock));
        for (newcnt = 1; newcnt <= maxid; newcnt = (newcnt << 1) | 1) {
                continue;
        }

        mutex_exit(&ss->ss_so.so_lock);
        newlist = kmem_alloc(newcnt * sizeof (struct sctp_sa_id), kmflags);
        mutex_enter(&ss->ss_so.so_lock);
        if (newlist == NULL) {
                return (-1);
        }
        oldcnt = ss->ss_maxassoc;
        if (newcnt <= oldcnt) {
                kmem_free(newlist, newcnt * sizeof (struct sctp_sa_id));
                return (0);
        }
        ASSERT((newcnt & (newcnt + 1)) == 0);
        oldlist = ss->ss_assocs;
        ss->ss_assocs = newlist;
        ss->ss_maxassoc = newcnt;

        bcopy(oldlist, newlist, oldcnt * sizeof (struct sctp_sa_id));
        bzero(newlist + oldcnt,
            (newcnt - oldcnt) * sizeof (struct sctp_sa_id));
        if (oldlist != NULL) {
                kmem_free(oldlist, oldcnt * sizeof (struct sctp_sa_id));
        }
        return (0);
}

/*
 * Convert a id into a pointer to sctp_sockassoc structure.
 * Increments refcnt.
 */
int
sosctp_assoc(struct sctp_sonode *ss, sctp_assoc_t id, struct sctp_soassoc **ssa)
{
        ASSERT(ssa != NULL);
        ASSERT(MUTEX_HELD(&ss->ss_so.so_lock));
        if ((uint32_t)id >= ss->ss_maxassoc) {
                *ssa = NULL;
                return (EINVAL);
        }

        if ((*ssa = ss->ss_assocs[id].ssi_assoc) == NULL) {
                return (EINVAL);
        }
        if (((*ssa)->ssa_state & (SS_CANTSENDMORE|SS_CANTRCVMORE)) ==
            (SS_CANTSENDMORE|SS_CANTRCVMORE)) {
                /*
                 * Disconnected connection, shouldn't be found anymore
                 */
                *ssa = NULL;
                return (ESHUTDOWN);
        }
        SSA_REFHOLD(*ssa)

        return (0);
}

/*
 * Can be called from upcall, or through system call.
 */
struct sctp_soassoc *
sosctp_assoc_create(struct sctp_sonode *ss, int kmflag)
{
        struct sctp_soassoc *ssa;

        ssa = kmem_cache_alloc(sosctp_assoccache, kmflag);
        if (ssa != NULL) {
                ssa->ssa_type = SOSCTP_ASSOC;
                ssa->ssa_refcnt = 1;
                ssa->ssa_sonode = ss;
                ssa->ssa_state = 0;
                ssa->ssa_error = 0;
                ssa->ssa_snd_qfull = 0;
                ssa->ssa_rcv_queued = 0;
                ssa->ssa_flowctrld = B_FALSE;
        }
        dprint(2, ("sosctp_assoc_create %p %p\n", (void *)ss, (void *)ssa));
        return (ssa);
}

void
sosctp_assoc_free(struct sctp_sonode *ss, struct sctp_soassoc *ssa)
{
        struct sonode *so = &ss->ss_so;

        dprint(2, ("sosctp_assoc_free %p %p (%d)\n", (void *)ss, (void *)ssa,
            ssa->ssa_id));
        ASSERT(MUTEX_HELD(&so->so_lock));
        if (ssa->ssa_conn != NULL) {
                mutex_exit(&so->so_lock);

                sctp_recvd(ssa->ssa_conn, so->so_rcvbuf);
                (void) sctp_disconnect(ssa->ssa_conn);
                sctp_close(ssa->ssa_conn);

                mutex_enter(&so->so_lock);
                ssa->ssa_conn = NULL;
        }
        sosctp_aid_reserve(ss, ssa->ssa_id, -1);
        ss->ss_assocs[ssa->ssa_id].ssi_assoc = NULL;
        --ss->ss_assoccnt;
        kmem_cache_free(sosctp_assoccache, ssa);
}

/*
 * Pack the ancillary stuff taking care of alignment issues.
 * sctp_input_add_ancillary() packs the information as:
 * struct cmsghdr -> ancillary data + struct cmsghdr -> ancillary data + ...
 * In the next version of SCTP, sctp_input_add_ancillary() should
 * pack the information taking alignment into account, then we would
 * not need this routine.
 */
void
sosctp_pack_cmsg(const uchar_t *opt, struct nmsghdr *msg, int len)
{
        struct cmsghdr  *ocmsg;
        struct cmsghdr  *cmsg;
        int             optlen = 0;
        char            *cend;
        boolean_t       isaligned = B_TRUE;

        ocmsg = (struct cmsghdr *)opt;
        cend = (char *)opt + len;
        /* Figure out the length incl. alignment et. al. */
        for (;;) {
                if ((char *)(ocmsg + 1) > cend ||
                    ((char *)ocmsg + ocmsg->cmsg_len) > cend) {
                        break;
                }
                if (isaligned && !ISALIGNED_cmsghdr(ocmsg))
                        isaligned = B_FALSE;
                optlen += ROUNDUP_cmsglen(ocmsg->cmsg_len);
                if (ocmsg->cmsg_len > 0) {
                        ocmsg = (struct cmsghdr *)
                            ((uchar_t *)ocmsg + ocmsg->cmsg_len);
                } else {
                        break;
                }
        }
        /* Now allocate and copy */
        msg->msg_control = kmem_zalloc(optlen, KM_SLEEP);
        msg->msg_controllen = optlen;
        if (isaligned) {
                ASSERT(optlen == len);
                bcopy(opt, msg->msg_control, len);
                return;
        }
        cmsg = (struct cmsghdr *)msg->msg_control;
        ASSERT(ISALIGNED_cmsghdr(cmsg));
        ocmsg = (struct cmsghdr *)opt;
        cend = (char *)opt + len;
        for (;;) {
                if ((char *)(ocmsg + 1) > cend ||
                    ((char *)ocmsg + ocmsg->cmsg_len) > cend) {
                        break;
                }
                bcopy(ocmsg, cmsg, ocmsg->cmsg_len);
                if (ocmsg->cmsg_len > 0) {
                        cmsg = (struct cmsghdr *)((uchar_t *)cmsg +
                            ROUNDUP_cmsglen(ocmsg->cmsg_len));
                        ASSERT(ISALIGNED_cmsghdr(cmsg));
                        ocmsg = (struct cmsghdr *)
                            ((uchar_t *)ocmsg + ocmsg->cmsg_len);
                } else {
                        break;
                }
        }
}

/*
 * Find cmsghdr of specified type
 */
struct cmsghdr *
sosctp_find_cmsg(const uchar_t *control, socklen_t clen, int type)
{
        struct cmsghdr *cmsg;
        char *cend;

        cmsg = (struct cmsghdr *)control;
        cend = (char *)control + clen;

        for (;;) {
                if ((char *)(cmsg + 1) > cend ||
                    ((char *)cmsg + cmsg->cmsg_len) > cend) {
                        break;
                }
                if ((cmsg->cmsg_level == IPPROTO_SCTP) &&
                    (cmsg->cmsg_type == type)) {
                        return (cmsg);
                }
                if (cmsg->cmsg_len > 0) {
                        cmsg = CMSG_NEXT(cmsg);
                } else {
                        break;
                }
        }
        return (NULL);
}

/*
 * Wait until the association is connected or there is an error.
 * fmode should contain any nonblocking flags.
 */
static int
sosctp_assoc_waitconnected(struct sctp_soassoc *ssa, int fmode)
{
        struct sonode *so = &ssa->ssa_sonode->ss_so;
        int error = 0;

        ASSERT((ssa->ssa_state & (SS_ISCONNECTED|SS_ISCONNECTING)) ||
            ssa->ssa_error != 0);

        while ((ssa->ssa_state & (SS_ISCONNECTED|SS_ISCONNECTING)) ==
            SS_ISCONNECTING && ssa->ssa_error == 0) {

                dprint(3, ("waiting for SS_ISCONNECTED on %p\n", (void *)so));
                if (fmode & (FNDELAY|FNONBLOCK))
                        return (EINPROGRESS);

                if (so->so_state & SS_CLOSING)
                        return (EINTR);
                if (!cv_wait_sig_swap(&so->so_state_cv, &so->so_lock)) {
                        /*
                         * Return EINTR and let the application use
                         * nonblocking techniques for detecting when
                         * the connection has been established.
                         */
                        return (EINTR);
                }
                dprint(3, ("awoken on %p\n", (void *)so));
        }
        if (ssa->ssa_error != 0) {
                error = ssa->ssa_error;
                ssa->ssa_error = 0;
                dprint(3, ("sosctp_assoc_waitconnected: error %d\n", error));
                return (error);
        }

        if (!(ssa->ssa_state & SS_ISCONNECTED)) {
                /*
                 * Another thread could have consumed so_error
                 * e.g. by calling read. - take from sowaitconnected()
                 */
                error = ECONNREFUSED;
                dprint(3, ("sosctp_waitconnected: error %d\n", error));
                return (error);
        }
        return (0);
}

/*
 * Called from connect(), sendmsg() when we need to create a new association.
 */
int
sosctp_assoc_createconn(struct sctp_sonode *ss, const struct sockaddr *name,
    socklen_t namelen, const uchar_t *control, socklen_t controllen, int fflag,
    struct cred *cr, struct sctp_soassoc **ssap)
{
        struct sonode *so = &ss->ss_so;
        struct sctp_soassoc *ssa;
        struct sockaddr_storage laddr;
        sctp_sockbuf_limits_t sbl;
        sctp_assoc_t id;
        int error;
        struct cmsghdr *cmsg;
        pid_t pid = curproc->p_pid;

        ASSERT(MUTEX_HELD(&so->so_lock));

        /*
         * System needs to pick local endpoint
         */
        if (!(so->so_state & SS_ISBOUND)) {
                bzero(&laddr, sizeof (laddr));
                laddr.ss_family = so->so_family;

                error = SOP_BIND(so, (struct sockaddr *)&laddr,
                    sizeof (laddr), _SOBIND_LOCK_HELD, cr);
                if (error) {
                        *ssap = NULL;
                        return (error);
                }
        }

        /*
         * Create a new association, and call connect on that.
         */
        for (;;) {
                id = sosctp_aid_get(ss);
                if (id != -1) {
                        break;
                }
                /*
                 * Array not large enough; increase size.
                 */
                (void) sosctp_aid_grow(ss, ss->ss_maxassoc, KM_SLEEP);
        }
        ++ss->ss_assoccnt;
        sosctp_aid_reserve(ss, id, 1);

        mutex_exit(&so->so_lock);

        ssa = sosctp_assoc_create(ss, KM_SLEEP);
        ssa->ssa_wroff = ss->ss_wroff;
        ssa->ssa_wrsize = ss->ss_wrsize;
        ssa->ssa_conn = sctp_create(ssa, (struct sctp_s *)so->so_proto_handle,
            so->so_family, so->so_type, SCTP_CAN_BLOCK, &sosctp_assoc_upcalls,
            &sbl, cr);

        mutex_enter(&so->so_lock);
        ss->ss_assocs[id].ssi_assoc = ssa;
        ssa->ssa_id = id;
        if (ssa->ssa_conn == NULL) {
                ASSERT(ssa->ssa_refcnt == 1);
                sosctp_assoc_free(ss, ssa);
                *ssap = NULL;
                return (ENOMEM);
        }
        ssa->ssa_state |= SS_ISBOUND;

        sosctp_assoc_isconnecting(ssa);
        SSA_REFHOLD(ssa);
        mutex_exit(&so->so_lock);

        /*
         * Can specify special init params
         */
        cmsg = sosctp_find_cmsg(control, controllen, SCTP_INIT);
        if (cmsg != NULL) {
                error = sctp_set_opt(ssa->ssa_conn, IPPROTO_SCTP, SCTP_INITMSG,
                    cmsg + 1, cmsg->cmsg_len - sizeof (*cmsg));
                if (error != 0)
                        goto ret_err;
        }

        if ((error = sctp_connect(ssa->ssa_conn, name, namelen, cr, pid)) != 0)
                goto ret_err;

        mutex_enter(&so->so_lock);
        /*
         * Allow other threads to access the socket
         */
        error = sosctp_assoc_waitconnected(ssa, fflag);

        switch (error) {
        case 0:
        case EINPROGRESS:
        case EALREADY:
        case EINTR:
                /* Non-fatal errors */
                break;
        default:
                /*
                 * Fatal errors.  It means that sctp_assoc_disconnected()
                 * must have been called.  So we only need to do a
                 * SSA_REFRELE() here to release our hold done above.
                 */
                ASSERT(ssa->ssa_state & (SS_CANTSENDMORE | SS_CANTRCVMORE));
                SSA_REFRELE(ss, ssa);
                ssa = NULL;
                break;
        }

        *ssap = ssa;
        return (error);

ret_err:
        mutex_enter(&so->so_lock);
        /*
         * There should not be any upcall done by SCTP.  So normally the
         * ssa_refcnt should be 2.  And we can call sosctp_assoc_free()
         * directly.  But since the ssa is inserted to the ss_soassocs
         * array above, some thread can actually put a hold on it.  In
         * this special case, we "manually" decrease the ssa_refcnt by 2.
         */
        if (ssa->ssa_refcnt > 2)
                ssa->ssa_refcnt -= 2;
        else
                sosctp_assoc_free(ss, ssa);
        *ssap = NULL;
        return (error);
}

/*
 * Inherit socket properties
 */
void
sosctp_so_inherit(struct sctp_sonode *lss, struct sctp_sonode *nss)
{
        struct sonode *nso = &nss->ss_so;
        struct sonode *lso = &lss->ss_so;

        nso->so_options = lso->so_options & (SO_DEBUG|SO_REUSEADDR|
            SO_KEEPALIVE|SO_DONTROUTE|SO_BROADCAST|SO_USELOOPBACK|
            SO_OOBINLINE|SO_DGRAM_ERRIND|SO_LINGER);
        nso->so_sndbuf = lso->so_sndbuf;
        nso->so_rcvbuf = lso->so_rcvbuf;
        nso->so_pgrp = lso->so_pgrp;

        nso->so_rcvlowat = lso->so_rcvlowat;
        nso->so_sndlowat = lso->so_sndlowat;
}

/*
 * Branching association to it's own socket. Inherit properties from
 * the parent, and move data for the association to the new socket.
 */
void
sosctp_assoc_move(struct sctp_sonode *ss, struct sctp_sonode *nss,
    struct sctp_soassoc *ssa)
{
        mblk_t *mp, **nmp, *last_mp;
        struct sctp_soassoc *tmp;
        struct sonode *nso, *sso;

        sosctp_so_inherit(ss, nss);

        sso = &ss->ss_so;
        nso = &nss->ss_so;

        nso->so_state |= (sso->so_state & (SS_NDELAY|SS_NONBLOCK));
        nso->so_state |=
            (ssa->ssa_state & (SS_ISCONNECTED|SS_ISCONNECTING|
            SS_ISDISCONNECTING|SS_CANTSENDMORE|SS_CANTRCVMORE|SS_ISBOUND));
        nso->so_error = ssa->ssa_error;
        nso->so_snd_qfull = ssa->ssa_snd_qfull;
        nso->so_proto_props.sopp_wroff = ssa->ssa_wroff;
        nso->so_proto_props.sopp_maxblk = ssa->ssa_wrsize;
        nso->so_rcv_queued = ssa->ssa_rcv_queued;
        nso->so_flowctrld = ssa->ssa_flowctrld;
        nso->so_proto_handle = (sock_lower_handle_t)ssa->ssa_conn;
        /* The peeled off socket is connection oriented */
        nso->so_mode |= SM_CONNREQUIRED;

        /* Consolidate all data on a single rcv list */
        if (sso->so_rcv_head != NULL) {
                so_process_new_message(&ss->ss_so, sso->so_rcv_head,
                    sso->so_rcv_last_head);
                sso->so_rcv_head = NULL;
                sso->so_rcv_last_head = NULL;
        }

        if (nso->so_rcv_queued > 0) {
                nmp = &sso->so_rcv_q_head;
                last_mp = NULL;
                while ((mp = *nmp) != NULL) {
                        tmp = *(struct sctp_soassoc **)DB_BASE(mp);
#ifdef DEBUG
                        {
                                /*
                                 * Verify that b_prev points to the last
                                 * mblk in the b_cont chain (as mandated
                                 * by so_dequeue_msg().)
                                 */
                                mblk_t *mp1 = mp;
                                while (mp1->b_cont != NULL)
                                        mp1 = mp1->b_cont;
                                VERIFY(mp->b_prev == mp1);
                        }
#endif /* DEBUG */
                        if (tmp == ssa) {
                                *nmp = mp->b_next;
                                ASSERT(DB_TYPE(mp) != M_DATA);
                                if (nso->so_rcv_q_last_head == NULL) {
                                        nso->so_rcv_q_head = mp;
                                } else {
                                        nso->so_rcv_q_last_head->b_next = mp;
                                }
                                nso->so_rcv_q_last_head = mp;
                                mp->b_next = NULL;
                        } else {
                                nmp = &mp->b_next;
                                last_mp = mp;
                        }
                }

                sso->so_rcv_q_last_head = last_mp;
        }
}

void
sosctp_assoc_isconnecting(struct sctp_soassoc *ssa)
{
        struct sonode *so = &ssa->ssa_sonode->ss_so;

        ASSERT(MUTEX_HELD(&so->so_lock));

        ssa->ssa_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
        ssa->ssa_state |= SS_ISCONNECTING;
        cv_broadcast(&so->so_state_cv);
}

void
sosctp_assoc_isconnected(struct sctp_soassoc *ssa)
{
        struct sonode *so = &ssa->ssa_sonode->ss_so;

        ASSERT(MUTEX_HELD(&so->so_lock));

        ssa->ssa_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING);
        ssa->ssa_state |= SS_ISCONNECTED;
        cv_broadcast(&so->so_state_cv);
}

void
sosctp_assoc_isdisconnecting(struct sctp_soassoc *ssa)
{
        struct sonode *so = &ssa->ssa_sonode->ss_so;

        ASSERT(MUTEX_HELD(&so->so_lock));

        ssa->ssa_state &= ~SS_ISCONNECTING;
        ssa->ssa_state |= SS_CANTSENDMORE;
        cv_broadcast(&so->so_state_cv);
}

void
sosctp_assoc_isdisconnected(struct sctp_soassoc *ssa, int error)
{
        struct sonode *so = &ssa->ssa_sonode->ss_so;

        ASSERT(MUTEX_HELD(&so->so_lock));

        ssa->ssa_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
        ssa->ssa_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
        if (error != 0)
                ssa->ssa_error = (ushort_t)error;
        cv_broadcast(&so->so_state_cv);
}