1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 #include <sys/types.h>
  27 #include <sys/t_lock.h>
  28 #include <sys/param.h>
  29 #include <sys/systm.h>
  30 #include <sys/buf.h>
  31 #include <sys/vfs.h>
  32 #include <sys/vnode.h>
  33 #include <sys/debug.h>
  34 #include <sys/errno.h>
  35 #include <sys/stropts.h>
  36 #include <sys/cmn_err.h>
  37 #include <sys/sysmacros.h>
  38 #include <sys/filio.h>
  39 #include <sys/policy.h>
  40 
  41 #include <sys/project.h>
  42 #include <sys/tihdr.h>
  43 #include <sys/strsubr.h>
  44 #include <sys/esunddi.h>
  45 #include <sys/ddi.h>
  46 
  47 #include <sys/sockio.h>
  48 #include <sys/socket.h>
  49 #include <sys/socketvar.h>
  50 #include <sys/strsun.h>
  51 
  52 #include <netinet/sctp.h>
  53 #include <inet/sctp_itf.h>
  54 #include <fs/sockfs/sockcommon.h>
  55 #include "socksctp.h"
  56 
  57 /*
  58  * SCTP sockfs sonode operations, 1-1 socket
  59  */
  60 static int sosctp_init(struct sonode *, struct sonode *, struct cred *, int);
  61 static int sosctp_accept(struct sonode *, int, struct cred *, struct sonode **);
  62 static int sosctp_bind(struct sonode *, struct sockaddr *, socklen_t, int,
  63     struct cred *);
  64 static int sosctp_listen(struct sonode *, int, struct cred *);
  65 static int sosctp_connect(struct sonode *, struct sockaddr *, socklen_t,
  66     int, int, struct cred *);
  67 static int sosctp_recvmsg(struct sonode *, struct nmsghdr *, struct uio *,
  68     struct cred *);
  69 static int sosctp_sendmsg(struct sonode *, struct nmsghdr *, struct uio *,
  70     struct cred *);
  71 static int sosctp_getpeername(struct sonode *, struct sockaddr *, socklen_t *,
  72     boolean_t, struct cred *);
  73 static int sosctp_getsockname(struct sonode *, struct sockaddr *, socklen_t *,
  74     struct cred *);
  75 static int sosctp_shutdown(struct sonode *, int, struct cred *);
  76 static int sosctp_getsockopt(struct sonode *, int, int, void *, socklen_t *,
  77     int, struct cred *);
  78 static int sosctp_setsockopt(struct sonode *, int, int, const void *,
  79     socklen_t, struct cred *);
  80 static int sosctp_ioctl(struct sonode *, int, intptr_t, int, struct cred *,
  81     int32_t *);
  82 static int sosctp_close(struct sonode *, int, struct cred *);
  83 void sosctp_fini(struct sonode *, struct cred *);
  84 
  85 /*
  86  * SCTP sockfs sonode operations, 1-N socket
  87  */
  88 static int sosctp_seq_connect(struct sonode *, struct sockaddr *,
  89     socklen_t, int, int, struct cred *);
  90 static int sosctp_seq_sendmsg(struct sonode *, struct nmsghdr *, struct uio *,
  91     struct cred *);
  92 
  93 /*
  94  * Socket association upcalls, 1-N socket connection
  95  */
  96 sock_upper_handle_t sctp_assoc_newconn(sock_upper_handle_t,
  97     sock_lower_handle_t, sock_downcalls_t *, struct cred *, pid_t,
  98     sock_upcalls_t **);
  99 static void sctp_assoc_connected(sock_upper_handle_t, sock_connid_t,
 100     struct cred *, pid_t);
 101 static int sctp_assoc_disconnected(sock_upper_handle_t, sock_connid_t, int);
 102 static void sctp_assoc_disconnecting(sock_upper_handle_t, sock_opctl_action_t,
 103     uintptr_t arg);
 104 static ssize_t sctp_assoc_recv(sock_upper_handle_t, mblk_t *, size_t, int,
 105     int *, boolean_t *);
 106 static void sctp_assoc_xmitted(sock_upper_handle_t, boolean_t);
 107 static void sctp_assoc_properties(sock_upper_handle_t,
 108     struct sock_proto_props *);
 109 
 110 sonodeops_t sosctp_sonodeops = {
 111         sosctp_init,                    /* sop_init     */
 112         sosctp_accept,                  /* sop_accept   */
 113         sosctp_bind,                    /* sop_bind     */
 114         sosctp_listen,                  /* sop_listen   */
 115         sosctp_connect,                 /* sop_connect  */
 116         sosctp_recvmsg,                 /* sop_recvmsg  */
 117         sosctp_sendmsg,                 /* sop_sendmsg  */
 118         so_sendmblk_notsupp,            /* sop_sendmblk */
 119         sosctp_getpeername,             /* sop_getpeername */
 120         sosctp_getsockname,             /* sop_getsockname */
 121         sosctp_shutdown,                /* sop_shutdown */
 122         sosctp_getsockopt,              /* sop_getsockopt */
 123         sosctp_setsockopt,              /* sop_setsockopt */
 124         sosctp_ioctl,                   /* sop_ioctl    */
 125         so_poll,                        /* sop_poll     */
 126         sosctp_close,                   /* sop_close    */
 127 };
 128 
 129 sonodeops_t sosctp_seq_sonodeops = {
 130         sosctp_init,                    /* sop_init     */
 131         so_accept_notsupp,              /* sop_accept   */
 132         sosctp_bind,                    /* sop_bind     */
 133         sosctp_listen,                  /* sop_listen   */
 134         sosctp_seq_connect,             /* sop_connect  */
 135         sosctp_recvmsg,                 /* sop_recvmsg  */
 136         sosctp_seq_sendmsg,             /* sop_sendmsg  */
 137         so_sendmblk_notsupp,            /* sop_sendmblk */
 138         so_getpeername_notsupp,         /* sop_getpeername */
 139         sosctp_getsockname,             /* sop_getsockname */
 140         so_shutdown_notsupp,            /* sop_shutdown */
 141         sosctp_getsockopt,              /* sop_getsockopt */
 142         sosctp_setsockopt,              /* sop_setsockopt */
 143         sosctp_ioctl,                   /* sop_ioctl    */
 144         so_poll,                        /* sop_poll     */
 145         sosctp_close,                   /* sop_close    */
 146 };
 147 
 148 /* All the upcalls expect the upper handle to be sonode. */
 149 sock_upcalls_t sosctp_sock_upcalls = {
 150         so_newconn,
 151         so_connected,
 152         so_disconnected,
 153         so_opctl,
 154         so_queue_msg,
 155         so_set_prop,
 156         so_txq_full,
 157         NULL,                   /* su_signal_oob */
 158 };
 159 
 160 /* All the upcalls expect the upper handle to be sctp_sonode/sctp_soassoc. */
 161 sock_upcalls_t sosctp_assoc_upcalls = {
 162         sctp_assoc_newconn,
 163         sctp_assoc_connected,
 164         sctp_assoc_disconnected,
 165         sctp_assoc_disconnecting,
 166         sctp_assoc_recv,
 167         sctp_assoc_properties,
 168         sctp_assoc_xmitted,
 169         NULL,                   /* su_recv_space */
 170         NULL,                   /* su_signal_oob */
 171 };
 172 
 173 /* ARGSUSED */
 174 static int
 175 sosctp_init(struct sonode *so, struct sonode *pso, struct cred *cr, int flags)
 176 {
 177         struct sctp_sonode *ss;
 178         struct sctp_sonode *pss;
 179         sctp_sockbuf_limits_t sbl;
 180         int err;
 181 
 182         ss = SOTOSSO(so);
 183 
 184         if (pso != NULL) {
 185                 /*
 186                  * Passive open, just inherit settings from parent. We should
 187                  * not end up here for SOCK_SEQPACKET type sockets, since no
 188                  * new sonode is created in that case.
 189                  */
 190                 ASSERT(so->so_type == SOCK_STREAM);
 191                 pss = SOTOSSO(pso);
 192 
 193                 mutex_enter(&pso->so_lock);
 194                 so->so_state |= (SS_ISBOUND | SS_ISCONNECTED |
 195                     (pso->so_state & SS_ASYNC));
 196                 sosctp_so_inherit(pss, ss);
 197                 so->so_proto_props = pso->so_proto_props;
 198                 so->so_mode = pso->so_mode;
 199                 mutex_exit(&pso->so_lock);
 200 
 201                 return (0);
 202         }
 203 
 204         if ((err = secpolicy_basic_net_access(cr)) != 0)
 205                 return (err);
 206 
 207         if (so->so_type == SOCK_STREAM) {
 208                 so->so_proto_handle = (sock_lower_handle_t)sctp_create(so,
 209                     NULL, so->so_family, so->so_type, SCTP_CAN_BLOCK,
 210                     &sosctp_sock_upcalls, &sbl, cr);
 211                 so->so_mode = SM_CONNREQUIRED;
 212         } else {
 213                 ASSERT(so->so_type == SOCK_SEQPACKET);
 214                 so->so_proto_handle = (sock_lower_handle_t)sctp_create(ss,
 215                     NULL, so->so_family, so->so_type, SCTP_CAN_BLOCK,
 216                     &sosctp_assoc_upcalls, &sbl, cr);
 217         }
 218 
 219         if (so->so_proto_handle == NULL)
 220                 return (ENOMEM);
 221 
 222         so->so_rcvbuf = sbl.sbl_rxbuf;
 223         so->so_rcvlowat = sbl.sbl_rxlowat;
 224         so->so_sndbuf = sbl.sbl_txbuf;
 225         so->so_sndlowat = sbl.sbl_txlowat;
 226 
 227         return (0);
 228 }
 229 
 230 /*
 231  * Accept incoming connection.
 232  */
 233 /*ARGSUSED*/
 234 static int
 235 sosctp_accept(struct sonode *so, int fflag, struct cred *cr,
 236     struct sonode **nsop)
 237 {
 238         int error = 0;
 239 
 240         if ((so->so_state & SS_ACCEPTCONN) == 0)
 241                 return (EINVAL);
 242 
 243         error = so_acceptq_dequeue(so, (fflag & (FNONBLOCK|FNDELAY)), nsop);
 244 
 245         return (error);
 246 }
 247 
 248 /*
 249  * Bind local endpoint.
 250  */
 251 /*ARGSUSED*/
 252 static int
 253 sosctp_bind(struct sonode *so, struct sockaddr *name, socklen_t namelen,
 254     int flags, struct cred *cr)
 255 {
 256         int error;
 257 
 258         if (!(flags & _SOBIND_LOCK_HELD)) {
 259                 mutex_enter(&so->so_lock);
 260                 so_lock_single(so);     /* Set SOLOCKED */
 261         } else {
 262                 ASSERT(MUTEX_HELD(&so->so_lock));
 263         }
 264 
 265         /*
 266          * X/Open requires this check
 267          */
 268         if (so->so_state & SS_CANTSENDMORE) {
 269                 error = EINVAL;
 270                 goto done;
 271         }
 272 
 273 
 274         /*
 275          * Protocol module does address family checks.
 276          */
 277         mutex_exit(&so->so_lock);
 278 
 279         error = sctp_bind((struct sctp_s *)so->so_proto_handle, name, namelen);
 280 
 281         mutex_enter(&so->so_lock);
 282         if (error == 0) {
 283                 so->so_state |= SS_ISBOUND;
 284         } else {
 285                 eprintsoline(so, error);
 286         }
 287 done:
 288         if (!(flags & _SOBIND_LOCK_HELD)) {
 289                 so_unlock_single(so, SOLOCKED);
 290                 mutex_exit(&so->so_lock);
 291         } else {
 292                 /* If the caller held the lock don't release it here */
 293                 ASSERT(MUTEX_HELD(&so->so_lock));
 294                 ASSERT(so->so_flag & SOLOCKED);
 295         }
 296 
 297         return (error);
 298 }
 299 
 300 /*
 301  * Turn socket into a listen socket.
 302  */
 303 /* ARGSUSED */
 304 static int
 305 sosctp_listen(struct sonode *so, int backlog, struct cred *cr)
 306 {
 307         int error = 0;
 308 
 309         mutex_enter(&so->so_lock);
 310         so_lock_single(so);
 311 
 312         /*
 313          * If this socket is trying to do connect, or if it has
 314          * been connected, disallow.
 315          */
 316         if (so->so_state & (SS_ISCONNECTING | SS_ISCONNECTED |
 317             SS_ISDISCONNECTING | SS_CANTRCVMORE | SS_CANTSENDMORE)) {
 318                 error = EINVAL;
 319                 eprintsoline(so, error);
 320                 goto done;
 321         }
 322 
 323         if (backlog < 0) {
 324                 backlog = 0;
 325         }
 326 
 327         /*
 328          * If listen() is only called to change backlog, we don't
 329          * need to notify protocol module.
 330          */
 331         if (so->so_state & SS_ACCEPTCONN) {
 332                 so->so_backlog = backlog;
 333                 goto done;
 334         }
 335 
 336         mutex_exit(&so->so_lock);
 337         error = sctp_listen((struct sctp_s *)so->so_proto_handle);
 338         mutex_enter(&so->so_lock);
 339         if (error == 0) {
 340                 so->so_state |= (SS_ACCEPTCONN|SS_ISBOUND);
 341                 so->so_backlog = backlog;
 342         } else {
 343                 eprintsoline(so, error);
 344         }
 345 done:
 346         so_unlock_single(so, SOLOCKED);
 347         mutex_exit(&so->so_lock);
 348 
 349         return (error);
 350 }
 351 
 352 /*
 353  * Active open.
 354  */
 355 /*ARGSUSED*/
 356 static int
 357 sosctp_connect(struct sonode *so, struct sockaddr *name,
 358     socklen_t namelen, int fflag, int flags, struct cred *cr)
 359 {
 360         int error = 0;
 361         pid_t pid = curproc->p_pid;
 362 
 363         ASSERT(so->so_type == SOCK_STREAM);
 364 
 365         mutex_enter(&so->so_lock);
 366         so_lock_single(so);
 367 
 368         /*
 369          * Can't connect() after listen(), or if the socket is already
 370          * connected.
 371          */
 372         if (so->so_state & (SS_ACCEPTCONN|SS_ISCONNECTED|SS_ISCONNECTING)) {
 373                 if (so->so_state & SS_ISCONNECTED) {
 374                         error = EISCONN;
 375                 } else if (so->so_state & SS_ISCONNECTING) {
 376                         error = EALREADY;
 377                 } else {
 378                         error = EOPNOTSUPP;
 379                 }
 380                 eprintsoline(so, error);
 381                 goto done;
 382         }
 383 
 384         /*
 385          * Check for failure of an earlier call
 386          */
 387         if (so->so_error != 0) {
 388                 error = sogeterr(so, B_TRUE);
 389                 eprintsoline(so, error);
 390                 goto done;
 391         }
 392 
 393         /*
 394          * Connection is closing, or closed, don't allow reconnect.
 395          * TCP allows this to proceed, but the socket remains unwriteable.
 396          * BSD returns EINVAL.
 397          */
 398         if (so->so_state & (SS_ISDISCONNECTING|SS_CANTRCVMORE|
 399             SS_CANTSENDMORE)) {
 400                 error = EINVAL;
 401                 eprintsoline(so, error);
 402                 goto done;
 403         }
 404 
 405         if (name == NULL || namelen == 0) {
 406                 mutex_exit(&so->so_lock);
 407                 error = EINVAL;
 408                 eprintsoline(so, error);
 409                 goto done;
 410         }
 411 
 412         soisconnecting(so);
 413         mutex_exit(&so->so_lock);
 414 
 415         error = sctp_connect((struct sctp_s *)so->so_proto_handle,
 416             name, namelen, cr, pid);
 417 
 418         mutex_enter(&so->so_lock);
 419         if (error == 0) {
 420                 /*
 421                  * Allow other threads to access the socket
 422                  */
 423                 error = sowaitconnected(so, fflag, 0);
 424         }
 425 done:
 426         so_unlock_single(so, SOLOCKED);
 427         mutex_exit(&so->so_lock);
 428         return (error);
 429 }
 430 
 431 /*
 432  * Active open for 1-N sockets, create a new association and
 433  * call connect on that.
 434  * If there parent hasn't been bound yet (this is the first association),
 435  * make it so.
 436  */
 437 static int
 438 sosctp_seq_connect(struct sonode *so, struct sockaddr *name,
 439     socklen_t namelen, int fflag, int flags, struct cred *cr)
 440 {
 441         struct sctp_soassoc *ssa;
 442         struct sctp_sonode *ss;
 443         int error;
 444 
 445         ASSERT(so->so_type == SOCK_SEQPACKET);
 446 
 447         mutex_enter(&so->so_lock);
 448         so_lock_single(so);
 449 
 450         if (name == NULL || namelen == 0) {
 451                 error = EINVAL;
 452                 eprintsoline(so, error);
 453                 goto done;
 454         }
 455 
 456         ss = SOTOSSO(so);
 457 
 458         error = sosctp_assoc_createconn(ss, name, namelen, NULL, 0, fflag,
 459             cr, &ssa);
 460         if (error != 0) {
 461                 if ((error == EHOSTUNREACH) && (flags & _SOCONNECT_XPG4_2)) {
 462                         error = ENETUNREACH;
 463                 }
 464         }
 465         if (ssa != NULL) {
 466                 SSA_REFRELE(ss, ssa);
 467         }
 468 
 469 done:
 470         so_unlock_single(so, SOLOCKED);
 471         mutex_exit(&so->so_lock);
 472         return (error);
 473 }
 474 
 475 /*
 476  * Receive data.
 477  */
 478 /* ARGSUSED */
 479 static int
 480 sosctp_recvmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop,
 481     struct cred *cr)
 482 {
 483         struct sctp_sonode *ss = SOTOSSO(so);
 484         struct sctp_soassoc *ssa = NULL;
 485         int flags, error = 0;
 486         struct T_unitdata_ind *tind;
 487         ssize_t orig_resid = uiop->uio_resid;
 488         int len, count, readcnt = 0;
 489         socklen_t controllen, namelen;
 490         void *opt;
 491         mblk_t *mp;
 492         rval_t  rval;
 493 
 494         controllen = msg->msg_controllen;
 495         namelen = msg->msg_namelen;
 496         flags = msg->msg_flags;
 497         msg->msg_flags = 0;
 498         msg->msg_controllen = 0;
 499         msg->msg_namelen = 0;
 500 
 501         if (so->so_type == SOCK_STREAM) {
 502                 if (!(so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING|
 503                     SS_CANTRCVMORE))) {
 504                         return (ENOTCONN);
 505                 }
 506         } else {
 507                 /* NOTE: Will come here from vop_read() as well */
 508                 /* For 1-N socket, recv() cannot be used. */
 509                 if (namelen == 0)
 510                         return (EOPNOTSUPP);
 511                 /*
 512                  * If there are no associations, and no new connections are
 513                  * coming in, there's not going to be new messages coming
 514                  * in either.
 515                  */
 516                 if (so->so_rcv_q_head == NULL && so->so_rcv_head == NULL &&
 517                     ss->ss_assoccnt == 0 && !(so->so_state & SS_ACCEPTCONN)) {
 518                         return (ENOTCONN);
 519                 }
 520         }
 521 
 522         /*
 523          * out-of-band data not supported.
 524          */
 525         if (flags & MSG_OOB) {
 526                 return (EOPNOTSUPP);
 527         }
 528 
 529         /*
 530          * flag possibilities:
 531          *
 532          * MSG_PEEK     Don't consume data
 533          * MSG_WAITALL  Wait for full quantity of data (ignored if MSG_PEEK)
 534          * MSG_DONTWAIT Non-blocking (same as FNDELAY | FNONBLOCK)
 535          *
 536          * MSG_WAITALL can return less than the full buffer if either
 537          *
 538          * 1. we would block and we are non-blocking
 539          * 2. a full message cannot be delivered
 540          *
 541          * Given that we always get a full message from proto below,
 542          * MSG_WAITALL is not meaningful.
 543          */
 544 
 545         mutex_enter(&so->so_lock);
 546 
 547         /*
 548          * Allow just one reader at a time.
 549          */
 550         error = so_lock_read_intr(so,
 551             uiop->uio_fmode | ((flags & MSG_DONTWAIT) ? FNONBLOCK : 0));
 552         if (error) {
 553                 mutex_exit(&so->so_lock);
 554                 return (error);
 555         }
 556         mutex_exit(&so->so_lock);
 557 again:
 558         error = so_dequeue_msg(so, &mp, uiop, &rval, flags | MSG_DUPCTRL);
 559         if (mp != NULL) {
 560                 if (so->so_type == SOCK_SEQPACKET) {
 561                         ssa = *(struct sctp_soassoc **)DB_BASE(mp);
 562                 }
 563 
 564                 tind = (struct T_unitdata_ind *)mp->b_rptr;
 565 
 566                 len = tind->SRC_length;
 567 
 568                 if (namelen > 0 && len > 0) {
 569 
 570                         opt = sogetoff(mp, tind->SRC_offset, len, 1);
 571 
 572                         ASSERT(opt != NULL);
 573 
 574                         msg->msg_name = kmem_alloc(len, KM_SLEEP);
 575                         msg->msg_namelen = len;
 576 
 577                         bcopy(opt, msg->msg_name, len);
 578                 }
 579 
 580                 len = tind->OPT_length;
 581                 if (controllen == 0) {
 582                         if (len > 0) {
 583                                 msg->msg_flags |= MSG_CTRUNC;
 584                         }
 585                 } else if (len > 0) {
 586                         opt = sogetoff(mp, tind->OPT_offset, len,
 587                             __TPI_ALIGN_SIZE);
 588 
 589                         ASSERT(opt != NULL);
 590                         sosctp_pack_cmsg(opt, msg, len);
 591                 }
 592 
 593                 if (mp->b_flag & SCTP_NOTIFICATION) {
 594                         msg->msg_flags |= MSG_NOTIFICATION;
 595                 }
 596 
 597                 if (!(mp->b_flag & SCTP_PARTIAL_DATA) &&
 598                     !(rval.r_val1 & MOREDATA)) {
 599                         msg->msg_flags |= MSG_EOR;
 600                 }
 601                 freemsg(mp);
 602         }
 603 done:
 604         if (!(flags & MSG_PEEK))
 605                 readcnt = orig_resid - uiop->uio_resid;
 606         /*
 607          * Determine if we need to update SCTP about the buffer
 608          * space.  For performance reason, we cannot update SCTP
 609          * every time a message is read.  The socket buffer low
 610          * watermark is used as the threshold.
 611          */
 612         if (ssa == NULL) {
 613                 mutex_enter(&so->so_lock);
 614                 count = so->so_rcvbuf - so->so_rcv_queued;
 615 
 616                 ASSERT(so->so_rcv_q_head != NULL ||
 617                     so->so_rcv_head != NULL ||
 618                     so->so_rcv_queued == 0);
 619 
 620                 so_unlock_read(so);
 621 
 622                 /*
 623                  * so_dequeue_msg() sets r_val2 to true if flow control was
 624                  * cleared and we need to update SCTP.  so_flowctrld was
 625                  * cleared in so_dequeue_msg() via so_check_flow_control().
 626                  */
 627                 if (rval.r_val2) {
 628                         mutex_exit(&so->so_lock);
 629                         sctp_recvd((struct sctp_s *)so->so_proto_handle, count);
 630                 } else {
 631                         mutex_exit(&so->so_lock);
 632                 }
 633         } else {
 634                 /*
 635                  * Each association keeps track of how much data it has
 636                  * queued; we need to update the value here. Note that this
 637                  * is slightly different from SOCK_STREAM type sockets, which
 638                  * does not need to update the byte count, as it is already
 639                  * done in so_dequeue_msg().
 640                  */
 641                 mutex_enter(&so->so_lock);
 642                 ssa->ssa_rcv_queued -= readcnt;
 643                 count = so->so_rcvbuf - ssa->ssa_rcv_queued;
 644 
 645                 so_unlock_read(so);
 646 
 647                 if (readcnt > 0 && ssa->ssa_flowctrld &&
 648                     ssa->ssa_rcv_queued < so->so_rcvlowat) {
 649                         /*
 650                          * Need to clear ssa_flowctrld, different from 1-1
 651                          * style.
 652                          */
 653                         ssa->ssa_flowctrld = B_FALSE;
 654                         mutex_exit(&so->so_lock);
 655                         sctp_recvd(ssa->ssa_conn, count);
 656                         mutex_enter(&so->so_lock);
 657                 }
 658 
 659                 /*
 660                  * MOREDATA flag is set if all data could not be copied
 661                  */
 662                 if (!(flags & MSG_PEEK) && !(rval.r_val1 & MOREDATA)) {
 663                         SSA_REFRELE(ss, ssa);
 664                 }
 665                 mutex_exit(&so->so_lock);
 666         }
 667 
 668         return (error);
 669 }
 670 
 671 int
 672 sosctp_uiomove(mblk_t *hdr_mp, ssize_t count, ssize_t blk_size, int wroff,
 673     struct uio *uiop, int flags)
 674 {
 675         ssize_t size;
 676         int error;
 677         mblk_t *mp;
 678         dblk_t *dp;
 679 
 680         if (blk_size == INFPSZ)
 681                 blk_size = count;
 682 
 683         /*
 684          * Loop until we have all data copied into mblk's.
 685          */
 686         while (count > 0) {
 687                 size = MIN(count, blk_size);
 688 
 689                 /*
 690                  * As a message can be splitted up and sent in different
 691                  * packets, each mblk will have the extra space before
 692                  * data to accommodate what SCTP wants to put in there.
 693                  */
 694                 while ((mp = allocb(size + wroff, BPRI_MED)) == NULL) {
 695                         if ((uiop->uio_fmode & (FNDELAY|FNONBLOCK)) ||
 696                             (flags & MSG_DONTWAIT)) {
 697                                 return (EAGAIN);
 698                         }
 699                         if ((error = strwaitbuf(size + wroff, BPRI_MED))) {
 700                                 return (error);
 701                         }
 702                 }
 703 
 704                 dp = mp->b_datap;
 705                 dp->db_cpid = curproc->p_pid;
 706                 ASSERT(wroff <= dp->db_lim - mp->b_wptr);
 707                 mp->b_rptr += wroff;
 708                 error = uiomove(mp->b_rptr, size, UIO_WRITE, uiop);
 709                 if (error != 0) {
 710                         freeb(mp);
 711                         return (error);
 712                 }
 713                 mp->b_wptr = mp->b_rptr + size;
 714                 count -= size;
 715                 hdr_mp->b_cont = mp;
 716                 hdr_mp = mp;
 717         }
 718         return (0);
 719 }
 720 
 721 /*
 722  * Send message.
 723  */
 724 static int
 725 sosctp_sendmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop,
 726     struct cred *cr)
 727 {
 728         mblk_t *mctl;
 729         struct cmsghdr *cmsg;
 730         struct sctp_sndrcvinfo *sinfo;
 731         int optlen, flags, fflag;
 732         ssize_t count, msglen;
 733         int error;
 734 
 735         ASSERT(so->so_type == SOCK_STREAM);
 736 
 737         flags = msg->msg_flags;
 738         if (flags & MSG_OOB) {
 739                 /*
 740                  * No out-of-band data support.
 741                  */
 742                 return (EOPNOTSUPP);
 743         }
 744 
 745         if (msg->msg_controllen != 0) {
 746                 optlen = msg->msg_controllen;
 747                 cmsg = sosctp_find_cmsg(msg->msg_control, optlen, SCTP_SNDRCV);
 748                 if (cmsg != NULL) {
 749                         if (cmsg->cmsg_len <
 750                             (sizeof (*sinfo) + sizeof (*cmsg))) {
 751                                 eprintsoline(so, EINVAL);
 752                                 return (EINVAL);
 753                         }
 754                         sinfo = (struct sctp_sndrcvinfo *)(cmsg + 1);
 755 
 756                         /* Both flags should not be set together. */
 757                         if ((sinfo->sinfo_flags & MSG_EOF) &&
 758                             (sinfo->sinfo_flags & MSG_ABORT)) {
 759                                 eprintsoline(so, EINVAL);
 760                                 return (EINVAL);
 761                         }
 762 
 763                         /* Initiate a graceful shutdown. */
 764                         if (sinfo->sinfo_flags & MSG_EOF) {
 765                                 /* Can't include data in MSG_EOF message. */
 766                                 if (uiop->uio_resid != 0) {
 767                                         eprintsoline(so, EINVAL);
 768                                         return (EINVAL);
 769                                 }
 770 
 771                                 /*
 772                                  * This is the same sequence as done in
 773                                  * shutdown(SHUT_WR).
 774                                  */
 775                                 mutex_enter(&so->so_lock);
 776                                 so_lock_single(so);
 777                                 socantsendmore(so);
 778                                 cv_broadcast(&so->so_snd_cv);
 779                                 so->so_state |= SS_ISDISCONNECTING;
 780                                 mutex_exit(&so->so_lock);
 781 
 782                                 pollwakeup(&so->so_poll_list, POLLOUT);
 783                                 sctp_recvd((struct sctp_s *)so->so_proto_handle,
 784                                     so->so_rcvbuf);
 785                                 error = sctp_disconnect(
 786                                     (struct sctp_s *)so->so_proto_handle);
 787 
 788                                 mutex_enter(&so->so_lock);
 789                                 so_unlock_single(so, SOLOCKED);
 790                                 mutex_exit(&so->so_lock);
 791                                 return (error);
 792                         }
 793                 }
 794         } else {
 795                 optlen = 0;
 796         }
 797 
 798         mutex_enter(&so->so_lock);
 799         for (;;) {
 800                 if (so->so_state & SS_CANTSENDMORE) {
 801                         mutex_exit(&so->so_lock);
 802                         return (EPIPE);
 803                 }
 804 
 805                 if (so->so_error != 0) {
 806                         error = sogeterr(so, B_TRUE);
 807                         mutex_exit(&so->so_lock);
 808                         return (error);
 809                 }
 810 
 811                 if (!so->so_snd_qfull)
 812                         break;
 813 
 814                 if (so->so_state & SS_CLOSING) {
 815                         mutex_exit(&so->so_lock);
 816                         return (EINTR);
 817                 }
 818                 /*
 819                  * Xmit window full in a blocking socket.
 820                  */
 821                 if ((uiop->uio_fmode & (FNDELAY|FNONBLOCK)) ||
 822                     (flags & MSG_DONTWAIT)) {
 823                         mutex_exit(&so->so_lock);
 824                         return (EAGAIN);
 825                 } else {
 826                         /*
 827                          * Wait for space to become available and try again.
 828                          */
 829                         error = cv_wait_sig(&so->so_snd_cv, &so->so_lock);
 830                         if (!error) { /* signal */
 831                                 mutex_exit(&so->so_lock);
 832                                 return (EINTR);
 833                         }
 834                 }
 835         }
 836         msglen = count = uiop->uio_resid;
 837 
 838         /* Don't allow sending a message larger than the send buffer size. */
 839         /* XXX Transport module need to enforce this */
 840         if (msglen > so->so_sndbuf) {
 841                 mutex_exit(&so->so_lock);
 842                 return (EMSGSIZE);
 843         }
 844 
 845         /*
 846          * Allow piggybacking data on handshake messages (SS_ISCONNECTING).
 847          */
 848         if (!(so->so_state & (SS_ISCONNECTING | SS_ISCONNECTED))) {
 849                 /*
 850                  * We need to check here for listener so that the
 851                  * same error will be returned as with a TCP socket.
 852                  * In this case, sosctp_connect() returns EOPNOTSUPP
 853                  * while a TCP socket returns ENOTCONN instead.  Catch it
 854                  * here to have the same behavior as a TCP socket.
 855                  *
 856                  * We also need to make sure that the peer address is
 857                  * provided before we attempt to do the connect.
 858                  */
 859                 if ((so->so_state & SS_ACCEPTCONN) ||
 860                     msg->msg_name == NULL) {
 861                         mutex_exit(&so->so_lock);
 862                         error = ENOTCONN;
 863                         goto error_nofree;
 864                 }
 865                 mutex_exit(&so->so_lock);
 866                 fflag = uiop->uio_fmode;
 867                 if (flags & MSG_DONTWAIT) {
 868                         fflag |= FNDELAY;
 869                 }
 870                 error = sosctp_connect(so, msg->msg_name, msg->msg_namelen,
 871                     fflag, (so->so_version == SOV_XPG4_2) * _SOCONNECT_XPG4_2,
 872                     cr);
 873                 if (error) {
 874                         /*
 875                          * Check for non-fatal errors, socket connected
 876                          * while the lock had been lifted.
 877                          */
 878                         if (error != EISCONN && error != EALREADY) {
 879                                 goto error_nofree;
 880                         }
 881                         error = 0;
 882                 }
 883         } else {
 884                 mutex_exit(&so->so_lock);
 885         }
 886 
 887         mctl = sctp_alloc_hdr(msg->msg_name, msg->msg_namelen,
 888             msg->msg_control, optlen, SCTP_CAN_BLOCK);
 889         if (mctl == NULL) {
 890                 error = EINTR;
 891                 goto error_nofree;
 892         }
 893 
 894         /* Copy in the message. */
 895         if ((error = sosctp_uiomove(mctl, count, so->so_proto_props.sopp_maxblk,
 896             so->so_proto_props.sopp_wroff, uiop, flags)) != 0) {
 897                 goto error_ret;
 898         }
 899         error = sctp_sendmsg((struct sctp_s *)so->so_proto_handle, mctl, 0);
 900         if (error == 0)
 901                 return (0);
 902 
 903 error_ret:
 904         freemsg(mctl);
 905 error_nofree:
 906         mutex_enter(&so->so_lock);
 907         if ((error == EPIPE) && (so->so_state & SS_CANTSENDMORE)) {
 908                 /*
 909                  * We received shutdown between the time lock was
 910                  * lifted and call to sctp_sendmsg().
 911                  */
 912                 mutex_exit(&so->so_lock);
 913                 return (EPIPE);
 914         }
 915         mutex_exit(&so->so_lock);
 916         return (error);
 917 }
 918 
 919 /*
 920  * Send message on 1-N socket. Connects automatically if there is
 921  * no association.
 922  */
 923 static int
 924 sosctp_seq_sendmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop,
 925     struct cred *cr)
 926 {
 927         struct sctp_sonode *ss;
 928         struct sctp_soassoc *ssa;
 929         struct cmsghdr *cmsg;
 930         struct sctp_sndrcvinfo *sinfo;
 931         int aid = 0;
 932         mblk_t *mctl;
 933         int namelen, optlen, flags;
 934         ssize_t count, msglen;
 935         int error;
 936         uint16_t s_flags = 0;
 937 
 938         ASSERT(so->so_type == SOCK_SEQPACKET);
 939 
 940         /*
 941          * There shouldn't be problems with alignment, as the memory for
 942          * msg_control was alloced with kmem_alloc.
 943          */
 944         cmsg = sosctp_find_cmsg(msg->msg_control, msg->msg_controllen,
 945             SCTP_SNDRCV);
 946         if (cmsg != NULL) {
 947                 if (cmsg->cmsg_len < (sizeof (*sinfo) + sizeof (*cmsg))) {
 948                         eprintsoline(so, EINVAL);
 949                         return (EINVAL);
 950                 }
 951                 sinfo = (struct sctp_sndrcvinfo *)(cmsg + 1);
 952                 s_flags = sinfo->sinfo_flags;
 953                 aid = sinfo->sinfo_assoc_id;
 954         }
 955 
 956         ss = SOTOSSO(so);
 957         namelen = msg->msg_namelen;
 958 
 959         if (msg->msg_controllen > 0) {
 960                 optlen = msg->msg_controllen;
 961         } else {
 962                 optlen = 0;
 963         }
 964 
 965         mutex_enter(&so->so_lock);
 966 
 967         /*
 968          * If there is no association id, connect to address specified
 969          * in msg_name.  Otherwise look up the association using the id.
 970          */
 971         if (aid == 0) {
 972                 /*
 973                  * Connect and shutdown cannot be done together, so check for
 974                  * MSG_EOF.
 975                  */
 976                 if (msg->msg_name == NULL || namelen == 0 ||
 977                     (s_flags & MSG_EOF)) {
 978                         error = EINVAL;
 979                         eprintsoline(so, error);
 980                         goto done;
 981                 }
 982                 flags = uiop->uio_fmode;
 983                 if (msg->msg_flags & MSG_DONTWAIT) {
 984                         flags |= FNDELAY;
 985                 }
 986                 so_lock_single(so);
 987                 error = sosctp_assoc_createconn(ss, msg->msg_name, namelen,
 988                     msg->msg_control, optlen, flags, cr, &ssa);
 989                 if (error) {
 990                         if ((so->so_version == SOV_XPG4_2) &&
 991                             (error == EHOSTUNREACH)) {
 992                                 error = ENETUNREACH;
 993                         }
 994                         if (ssa == NULL) {
 995                                 /*
 996                                  * Fatal error during connect(). Bail out.
 997                                  * If ssa exists, it means that the handshake
 998                                  * is in progress.
 999                                  */
1000                                 eprintsoline(so, error);
1001                                 so_unlock_single(so, SOLOCKED);
1002                                 goto done;
1003                         }
1004                         /*
1005                          * All the errors are non-fatal ones, don't return
1006                          * e.g. EINPROGRESS from sendmsg().
1007                          */
1008                         error = 0;
1009                 }
1010                 so_unlock_single(so, SOLOCKED);
1011         } else {
1012                 if ((error = sosctp_assoc(ss, aid, &ssa)) != 0) {
1013                         eprintsoline(so, error);
1014                         goto done;
1015                 }
1016         }
1017 
1018         /*
1019          * Now we have an association.
1020          */
1021         flags = msg->msg_flags;
1022 
1023         /*
1024          * MSG_EOF initiates graceful shutdown.
1025          */
1026         if (s_flags & MSG_EOF) {
1027                 if (uiop->uio_resid) {
1028                         /*
1029                          * Can't include data in MSG_EOF message.
1030                          */
1031                         error = EINVAL;
1032                 } else {
1033                         mutex_exit(&so->so_lock);
1034                         ssa->ssa_state |= SS_ISDISCONNECTING;
1035                         sctp_recvd(ssa->ssa_conn, so->so_rcvbuf);
1036                         error = sctp_disconnect(ssa->ssa_conn);
1037                         mutex_enter(&so->so_lock);
1038                 }
1039                 goto refrele;
1040         }
1041 
1042         for (;;) {
1043                 if (ssa->ssa_state & SS_CANTSENDMORE) {
1044                         SSA_REFRELE(ss, ssa);
1045                         mutex_exit(&so->so_lock);
1046                         return (EPIPE);
1047                 }
1048                 if (ssa->ssa_error != 0) {
1049                         error = ssa->ssa_error;
1050                         ssa->ssa_error = 0;
1051                         goto refrele;
1052                 }
1053 
1054                 if (!ssa->ssa_snd_qfull)
1055                         break;
1056 
1057                 if (so->so_state & SS_CLOSING) {
1058                         error = EINTR;
1059                         goto refrele;
1060                 }
1061                 if ((uiop->uio_fmode & (FNDELAY|FNONBLOCK)) ||
1062                     (flags & MSG_DONTWAIT)) {
1063                         error = EAGAIN;
1064                         goto refrele;
1065                 } else {
1066                         /*
1067                          * Wait for space to become available and try again.
1068                          */
1069                         error = cv_wait_sig(&so->so_snd_cv, &so->so_lock);
1070                         if (!error) { /* signal */
1071                                 error = EINTR;
1072                                 goto refrele;
1073                         }
1074                 }
1075         }
1076 
1077         msglen = count = uiop->uio_resid;
1078 
1079         /* Don't allow sending a message larger than the send buffer size. */
1080         if (msglen > so->so_sndbuf) {
1081                 error = EMSGSIZE;
1082                 goto refrele;
1083         }
1084 
1085         /*
1086          * Update TX buffer usage here so that we can lift the socket lock.
1087          */
1088         mutex_exit(&so->so_lock);
1089 
1090         mctl = sctp_alloc_hdr(msg->msg_name, namelen, msg->msg_control,
1091             optlen, SCTP_CAN_BLOCK);
1092         if (mctl == NULL) {
1093                 error = EINTR;
1094                 goto lock_rele;
1095         }
1096 
1097         /* Copy in the message. */
1098         if ((error = sosctp_uiomove(mctl, count, ssa->ssa_wrsize,
1099             ssa->ssa_wroff, uiop, flags)) != 0) {
1100                 goto lock_rele;
1101         }
1102         error = sctp_sendmsg((struct sctp_s *)ssa->ssa_conn, mctl, 0);
1103 lock_rele:
1104         mutex_enter(&so->so_lock);
1105         if (error != 0) {
1106                 freemsg(mctl);
1107                 if ((error == EPIPE) && (ssa->ssa_state & SS_CANTSENDMORE)) {
1108                         /*
1109                          * We received shutdown between the time lock was
1110                          * lifted and call to sctp_sendmsg().
1111                          */
1112                         SSA_REFRELE(ss, ssa);
1113                         mutex_exit(&so->so_lock);
1114                         return (EPIPE);
1115                 }
1116         }
1117 
1118 refrele:
1119         SSA_REFRELE(ss, ssa);
1120 done:
1121         mutex_exit(&so->so_lock);
1122         return (error);
1123 }
1124 
1125 /*
1126  * Get address of remote node.
1127  */
1128 /* ARGSUSED */
1129 static int
1130 sosctp_getpeername(struct sonode *so, struct sockaddr *addr, socklen_t *addrlen,
1131     boolean_t accept, struct cred *cr)
1132 {
1133         return (sctp_getpeername((struct sctp_s *)so->so_proto_handle, addr,
1134             addrlen));
1135 }
1136 
1137 /*
1138  * Get local address.
1139  */
1140 /* ARGSUSED */
1141 static int
1142 sosctp_getsockname(struct sonode *so, struct sockaddr *addr, socklen_t *addrlen,
1143     struct cred *cr)
1144 {
1145         return (sctp_getsockname((struct sctp_s *)so->so_proto_handle, addr,
1146             addrlen));
1147 }
1148 
1149 /*
1150  * Called from shutdown().
1151  */
1152 /* ARGSUSED */
1153 static int
1154 sosctp_shutdown(struct sonode *so, int how, struct cred *cr)
1155 {
1156         uint_t state_change;
1157         int wakesig = 0;
1158         int error = 0;
1159 
1160         mutex_enter(&so->so_lock);
1161         /*
1162          * Record the current state and then perform any state changes.
1163          * Then use the difference between the old and new states to
1164          * determine which needs to be done.
1165          */
1166         state_change = so->so_state;
1167 
1168         switch (how) {
1169         case SHUT_RD:
1170                 socantrcvmore(so);
1171                 break;
1172         case SHUT_WR:
1173                 socantsendmore(so);
1174                 break;
1175         case SHUT_RDWR:
1176                 socantsendmore(so);
1177                 socantrcvmore(so);
1178                 break;
1179         default:
1180                 mutex_exit(&so->so_lock);
1181                 return (EINVAL);
1182         }
1183 
1184         state_change = so->so_state & ~state_change;
1185 
1186         if (state_change & SS_CANTRCVMORE) {
1187                 if (so->so_rcv_q_head == NULL) {
1188                         cv_signal(&so->so_rcv_cv);
1189                 }
1190                 wakesig = POLLIN|POLLRDNORM;
1191 
1192                 socket_sendsig(so, SOCKETSIG_READ);
1193         }
1194         if (state_change & SS_CANTSENDMORE) {
1195                 cv_broadcast(&so->so_snd_cv);
1196                 wakesig |= POLLOUT;
1197 
1198                 so->so_state |= SS_ISDISCONNECTING;
1199         }
1200         mutex_exit(&so->so_lock);
1201 
1202         pollwakeup(&so->so_poll_list, wakesig);
1203 
1204         if (state_change & SS_CANTSENDMORE) {
1205                 sctp_recvd((struct sctp_s *)so->so_proto_handle, so->so_rcvbuf);
1206                 error = sctp_disconnect((struct sctp_s *)so->so_proto_handle);
1207         }
1208 
1209         /*
1210          * HACK: sctp_disconnect() may return EWOULDBLOCK.  But this error is
1211          * not documented in standard socket API.  Catch it here.
1212          */
1213         if (error == EWOULDBLOCK)
1214                 error = 0;
1215         return (error);
1216 }
1217 
1218 /*
1219  * Get socket options.
1220  */
1221 /*ARGSUSED5*/
1222 static int
1223 sosctp_getsockopt(struct sonode *so, int level, int option_name,
1224     void *optval, socklen_t *optlenp, int flags, struct cred *cr)
1225 {
1226         socklen_t maxlen = *optlenp;
1227         socklen_t len;
1228         socklen_t optlen;
1229         uint8_t buffer[4];
1230         void    *optbuf = &buffer;
1231         int     error = 0;
1232 
1233         if (level == SOL_SOCKET) {
1234                 switch (option_name) {
1235                 /* Not supported options */
1236                 case SO_SNDTIMEO:
1237                 case SO_RCVTIMEO:
1238                 case SO_EXCLBIND:
1239                         eprintsoline(so, ENOPROTOOPT);
1240                         return (ENOPROTOOPT);
1241                 default:
1242                         error = socket_getopt_common(so, level, option_name,
1243                             optval, optlenp, flags);
1244                         if (error >= 0)
1245                                 return (error);
1246                         /* Pass the request to the protocol */
1247                         break;
1248                 }
1249         }
1250 
1251         if (level == IPPROTO_SCTP) {
1252                 /*
1253                  * Should go through ioctl().
1254                  */
1255                 return (EINVAL);
1256         }
1257 
1258         if (maxlen > sizeof (buffer)) {
1259                 optbuf = kmem_alloc(maxlen, KM_SLEEP);
1260         }
1261         optlen = maxlen;
1262 
1263         /*
1264          * If the resulting optlen is greater than the provided maxlen, then
1265          * we sliently trucate.
1266          */
1267         error = sctp_get_opt((struct sctp_s *)so->so_proto_handle, level,
1268             option_name, optbuf, &optlen);
1269 
1270         if (error != 0) {
1271                 eprintsoline(so, error);
1272                 goto free;
1273         }
1274         len = optlen;
1275 
1276 copyout:
1277 
1278         len = MIN(len, maxlen);
1279         bcopy(optbuf, optval, len);
1280         *optlenp = optlen;
1281 free:
1282         if (optbuf != &buffer) {
1283                 kmem_free(optbuf, maxlen);
1284         }
1285 
1286         return (error);
1287 }
1288 
1289 /*
1290  * Set socket options
1291  */
1292 /* ARGSUSED */
1293 static int
1294 sosctp_setsockopt(struct sonode *so, int level, int option_name,
1295     const void *optval, t_uscalar_t optlen, struct cred *cr)
1296 {
1297         struct sctp_sonode *ss = SOTOSSO(so);
1298         struct sctp_soassoc *ssa = NULL;
1299         sctp_assoc_t id;
1300         int error, rc;
1301         void *conn = NULL;
1302 
1303         mutex_enter(&so->so_lock);
1304 
1305         /*
1306          * For some SCTP level options, one can select the association this
1307          * applies to.
1308          */
1309         if (so->so_type == SOCK_STREAM) {
1310                 conn = so->so_proto_handle;
1311         } else {
1312                 /*
1313                  * SOCK_SEQPACKET only
1314                  */
1315                 id = 0;
1316                 if (level == IPPROTO_SCTP) {
1317                         switch (option_name) {
1318                         case SCTP_RTOINFO:
1319                         case SCTP_ASSOCINFO:
1320                         case SCTP_SET_PEER_PRIMARY_ADDR:
1321                         case SCTP_PRIMARY_ADDR:
1322                         case SCTP_PEER_ADDR_PARAMS:
1323                                 /*
1324                                  * Association ID is the first element
1325                                  * params struct
1326                                  */
1327                                 if (optlen < sizeof (sctp_assoc_t)) {
1328                                         error = EINVAL;
1329                                         eprintsoline(so, error);
1330                                         goto done;
1331                                 }
1332                                 id = *(sctp_assoc_t *)optval;
1333                                 break;
1334                         case SCTP_DEFAULT_SEND_PARAM:
1335                                 if (optlen != sizeof (struct sctp_sndrcvinfo)) {
1336                                         error = EINVAL;
1337                                         eprintsoline(so, error);
1338                                         goto done;
1339                                 }
1340                                 id = ((struct sctp_sndrcvinfo *)
1341                                     optval)->sinfo_assoc_id;
1342                                 break;
1343                         case SCTP_INITMSG:
1344                                 /*
1345                                  * Only applies to future associations
1346                                  */
1347                                 conn = so->so_proto_handle;
1348                                 break;
1349                         default:
1350                                 break;
1351                         }
1352                 } else if (level == SOL_SOCKET) {
1353                         if (option_name == SO_LINGER) {
1354                                 error = EOPNOTSUPP;
1355                                 eprintsoline(so, error);
1356                                 goto done;
1357                         }
1358                         /*
1359                          * These 2 options are applied to all associations.
1360                          * The other socket level options are only applied
1361                          * to the socket (not associations).
1362                          */
1363                         if ((option_name != SO_RCVBUF) &&
1364                             (option_name != SO_SNDBUF)) {
1365                                 conn = so->so_proto_handle;
1366                         }
1367                 } else {
1368                         conn = NULL;
1369                 }
1370 
1371                 /*
1372                  * If association ID was specified, do op on that assoc.
1373                  * Otherwise set the default setting of a socket.
1374                  */
1375                 if (id != 0) {
1376                         if ((error = sosctp_assoc(ss, id, &ssa)) != 0) {
1377                                 eprintsoline(so, error);
1378                                 goto done;
1379                         }
1380                         conn = ssa->ssa_conn;
1381                 }
1382         }
1383         dprint(2, ("sosctp_setsockopt %p (%d) - conn %p %d %d id:%d\n",
1384             (void *)ss, so->so_type, (void *)conn, level, option_name, id));
1385 
1386         ASSERT(ssa == NULL || (ssa != NULL && conn != NULL));
1387         if (conn != NULL) {
1388                 mutex_exit(&so->so_lock);
1389                 error = sctp_set_opt((struct sctp_s *)conn, level, option_name,
1390                     optval, optlen);
1391                 mutex_enter(&so->so_lock);
1392                 if (ssa != NULL)
1393                         SSA_REFRELE(ss, ssa);
1394         } else {
1395                 /*
1396                  * 1-N socket, and we have to apply the operation to ALL
1397                  * associations. Like with anything of this sort, the
1398                  * problem is what to do if the operation fails.
1399                  * Just try to apply the setting to everyone, but store
1400                  * error number if someone returns such.  And since we are
1401                  * looping through all possible aids, some of them can be
1402                  * invalid.  We just ignore this kind (sosctp_assoc()) of
1403                  * errors.
1404                  */
1405                 sctp_assoc_t aid;
1406 
1407                 mutex_exit(&so->so_lock);
1408                 error = sctp_set_opt((struct sctp_s *)so->so_proto_handle,
1409                     level, option_name, optval, optlen);
1410                 mutex_enter(&so->so_lock);
1411                 for (aid = 1; aid < ss->ss_maxassoc; aid++) {
1412                         if (sosctp_assoc(ss, aid, &ssa) != 0)
1413                                 continue;
1414                         mutex_exit(&so->so_lock);
1415                         rc = sctp_set_opt((struct sctp_s *)ssa->ssa_conn, level,
1416                             option_name, optval, optlen);
1417                         mutex_enter(&so->so_lock);
1418                         SSA_REFRELE(ss, ssa);
1419                         if (error == 0) {
1420                                 error = rc;
1421                         }
1422                 }
1423         }
1424 done:
1425         mutex_exit(&so->so_lock);
1426         return (error);
1427 }
1428 
1429 /*ARGSUSED*/
1430 static int
1431 sosctp_ioctl(struct sonode *so, int cmd, intptr_t arg, int mode,
1432     struct cred *cr, int32_t *rvalp)
1433 {
1434         struct sctp_sonode      *ss;
1435         int32_t                 value;
1436         int                     error;
1437         int                     intval;
1438         pid_t                   pid;
1439         struct sctp_soassoc     *ssa;
1440         void                    *conn;
1441         void                    *buf;
1442         STRUCT_DECL(sctpopt, opt);
1443         uint32_t                optlen;
1444         int                     buflen;
1445 
1446         ss = SOTOSSO(so);
1447 
1448         /* handle socket specific ioctls */
1449         switch (cmd) {
1450         case FIONBIO:
1451                 if (so_copyin((void *)arg, &value, sizeof (int32_t),
1452                     (mode & (int)FKIOCTL))) {
1453                         return (EFAULT);
1454                 }
1455                 mutex_enter(&so->so_lock);
1456                 if (value) {
1457                         so->so_state |= SS_NDELAY;
1458                 } else {
1459                         so->so_state &= ~SS_NDELAY;
1460                 }
1461                 mutex_exit(&so->so_lock);
1462                 return (0);
1463 
1464         case FIOASYNC:
1465                 if (so_copyin((void *)arg, &value, sizeof (int32_t),
1466                     (mode & (int)FKIOCTL))) {
1467                         return (EFAULT);
1468                 }
1469                 mutex_enter(&so->so_lock);
1470 
1471                 if (value) {
1472                         /* Turn on SIGIO */
1473                         so->so_state |= SS_ASYNC;
1474                 } else {
1475                         /* Turn off SIGIO */
1476                         so->so_state &= ~SS_ASYNC;
1477                 }
1478                 mutex_exit(&so->so_lock);
1479                 return (0);
1480 
1481         case SIOCSPGRP:
1482         case FIOSETOWN:
1483                 if (so_copyin((void *)arg, &pid, sizeof (pid_t),
1484                     (mode & (int)FKIOCTL))) {
1485                         return (EFAULT);
1486                 }
1487                 mutex_enter(&so->so_lock);
1488 
1489                 error = (pid != so->so_pgrp) ? socket_chgpgrp(so, pid) : 0;
1490                 mutex_exit(&so->so_lock);
1491                 return (error);
1492 
1493         case SIOCGPGRP:
1494         case FIOGETOWN:
1495                 if (so_copyout(&so->so_pgrp, (void *)arg,
1496                     sizeof (pid_t), (mode & (int)FKIOCTL)))
1497                         return (EFAULT);
1498                 return (0);
1499 
1500         case FIONREAD:
1501                 /* XXX: Cannot be used unless standard buffer is used */
1502                 /*
1503                  * Return number of bytes of data in all data messages
1504                  * in queue in "arg".
1505                  * For stream socket, amount of available data.
1506                  * For sock_dgram, # of available bytes + addresses.
1507                  */
1508                 intval = (so->so_state & SS_ACCEPTCONN) ? 0 :
1509                     MIN(so->so_rcv_queued, INT_MAX);
1510                 if (so_copyout(&intval, (void *)arg, sizeof (intval),
1511                     (mode & (int)FKIOCTL)))
1512                         return (EFAULT);
1513                 return (0);
1514         case SIOCATMARK:
1515                 /*
1516                  * No support for urgent data.
1517                  */
1518                 intval = 0;
1519 
1520                 if (so_copyout(&intval, (void *)arg, sizeof (int),
1521                     (mode & (int)FKIOCTL)))
1522                         return (EFAULT);
1523                 return (0);
1524         case _I_GETPEERCRED: {
1525                 int error = 0;
1526 
1527                 if ((mode & FKIOCTL) == 0)
1528                         return (EINVAL);
1529 
1530                 mutex_enter(&so->so_lock);
1531                 if ((so->so_mode & SM_CONNREQUIRED) == 0) {
1532                         error = ENOTSUP;
1533                 } else if ((so->so_state & SS_ISCONNECTED) == 0) {
1534                         error = ENOTCONN;
1535                 } else if (so->so_peercred != NULL) {
1536                         k_peercred_t *kp = (k_peercred_t *)arg;
1537                         kp->pc_cr = so->so_peercred;
1538                         kp->pc_cpid = so->so_cpid;
1539                         crhold(so->so_peercred);
1540                 } else {
1541                         error = EINVAL;
1542                 }
1543                 mutex_exit(&so->so_lock);
1544                 return (error);
1545         }
1546         case SIOCSCTPGOPT:
1547                 STRUCT_INIT(opt, mode);
1548 
1549                 if (so_copyin((void *)arg, STRUCT_BUF(opt), STRUCT_SIZE(opt),
1550                     (mode & (int)FKIOCTL))) {
1551                         return (EFAULT);
1552                 }
1553                 if ((optlen = STRUCT_FGET(opt, sopt_len)) > SO_MAXARGSIZE)
1554                         return (EINVAL);
1555 
1556                 /*
1557                  * Find the correct sctp_t based on whether it is 1-N socket
1558                  * or not.
1559                  */
1560                 intval = STRUCT_FGET(opt, sopt_aid);
1561                 mutex_enter(&so->so_lock);
1562                 if ((so->so_type == SOCK_SEQPACKET) && intval) {
1563                         if ((error = sosctp_assoc(ss, intval, &ssa)) != 0) {
1564                                 mutex_exit(&so->so_lock);
1565                                 return (error);
1566                         }
1567                         conn = ssa->ssa_conn;
1568                         ASSERT(conn != NULL);
1569                 } else {
1570                         conn = so->so_proto_handle;
1571                         ssa = NULL;
1572                 }
1573                 mutex_exit(&so->so_lock);
1574 
1575                 /* Copyin the option buffer and then call sctp_get_opt(). */
1576                 buflen = optlen;
1577                 /* Let's allocate a buffer enough to hold an int */
1578                 if (buflen < sizeof (uint32_t))
1579                         buflen = sizeof (uint32_t);
1580                 buf = kmem_alloc(buflen, KM_SLEEP);
1581                 if (so_copyin(STRUCT_FGETP(opt, sopt_val), buf, optlen,
1582                     (mode & (int)FKIOCTL))) {
1583                         if (ssa != NULL) {
1584                                 mutex_enter(&so->so_lock);
1585                                 SSA_REFRELE(ss, ssa);
1586                                 mutex_exit(&so->so_lock);
1587                         }
1588                         kmem_free(buf, buflen);
1589                         return (EFAULT);
1590                 }
1591                 /* The option level has to be IPPROTO_SCTP */
1592                 error = sctp_get_opt((struct sctp_s *)conn, IPPROTO_SCTP,
1593                     STRUCT_FGET(opt, sopt_name), buf, &optlen);
1594                 if (ssa != NULL) {
1595                         mutex_enter(&so->so_lock);
1596                         SSA_REFRELE(ss, ssa);
1597                         mutex_exit(&so->so_lock);
1598                 }
1599                 optlen = MIN(buflen, optlen);
1600                 /* No error, copyout the result with the correct buf len. */
1601                 if (error == 0) {
1602                         STRUCT_FSET(opt, sopt_len, optlen);
1603                         if (so_copyout(STRUCT_BUF(opt), (void *)arg,
1604                             STRUCT_SIZE(opt), (mode & (int)FKIOCTL))) {
1605                                 error = EFAULT;
1606                         } else if (so_copyout(buf, STRUCT_FGETP(opt, sopt_val),
1607                             optlen, (mode & (int)FKIOCTL))) {
1608                                 error = EFAULT;
1609                         }
1610                 }
1611                 kmem_free(buf, buflen);
1612                 return (error);
1613 
1614         case SIOCSCTPSOPT:
1615                 STRUCT_INIT(opt, mode);
1616 
1617                 if (so_copyin((void *)arg, STRUCT_BUF(opt), STRUCT_SIZE(opt),
1618                     (mode & (int)FKIOCTL))) {
1619                         return (EFAULT);
1620                 }
1621                 if ((optlen = STRUCT_FGET(opt, sopt_len)) > SO_MAXARGSIZE)
1622                         return (EINVAL);
1623 
1624                 /*
1625                  * Find the correct sctp_t based on whether it is 1-N socket
1626                  * or not.
1627                  */
1628                 intval = STRUCT_FGET(opt, sopt_aid);
1629                 mutex_enter(&so->so_lock);
1630                 if (intval != 0) {
1631                         if ((error = sosctp_assoc(ss, intval, &ssa)) != 0) {
1632                                 mutex_exit(&so->so_lock);
1633                                 return (error);
1634                         }
1635                         conn = ssa->ssa_conn;
1636                         ASSERT(conn != NULL);
1637                 } else {
1638                         conn = so->so_proto_handle;
1639                         ssa = NULL;
1640                 }
1641                 mutex_exit(&so->so_lock);
1642 
1643                 /* Copyin the option buffer and then call sctp_set_opt(). */
1644                 buf = kmem_alloc(optlen, KM_SLEEP);
1645                 if (so_copyin(STRUCT_FGETP(opt, sopt_val), buf, optlen,
1646                     (mode & (int)FKIOCTL))) {
1647                         if (ssa != NULL) {
1648                                 mutex_enter(&so->so_lock);
1649                                 SSA_REFRELE(ss, ssa);
1650                                 mutex_exit(&so->so_lock);
1651                         }
1652                         kmem_free(buf, intval);
1653                         return (EFAULT);
1654                 }
1655                 /* The option level has to be IPPROTO_SCTP */
1656                 error = sctp_set_opt((struct sctp_s *)conn, IPPROTO_SCTP,
1657                     STRUCT_FGET(opt, sopt_name), buf, optlen);
1658                 if (ssa) {
1659                         mutex_enter(&so->so_lock);
1660                         SSA_REFRELE(ss, ssa);
1661                         mutex_exit(&so->so_lock);
1662                 }
1663                 kmem_free(buf, optlen);
1664                 return (error);
1665 
1666         case SIOCSCTPPEELOFF: {
1667                 struct sonode *nso;
1668                 struct sctp_uc_swap us;
1669                 int nfd;
1670                 struct file *nfp;
1671                 struct vnode *nvp = NULL;
1672                 struct sockparams *sp;
1673 
1674                 dprint(2, ("sctppeeloff %p\n", (void *)ss));
1675 
1676                 if (so->so_type != SOCK_SEQPACKET) {
1677                         return (EOPNOTSUPP);
1678                 }
1679                 if (so_copyin((void *)arg, &intval, sizeof (intval),
1680                     (mode & (int)FKIOCTL))) {
1681                         return (EFAULT);
1682                 }
1683                 if (intval == 0) {
1684                         return (EINVAL);
1685                 }
1686 
1687                 /*
1688                  * Find sockparams. This is different from parent's entry,
1689                  * as the socket type is different.
1690                  */
1691                 error = solookup(so->so_family, SOCK_STREAM, so->so_protocol,
1692                     &sp);
1693                 if (error != 0)
1694                         return (error);
1695 
1696                 /*
1697                  * Allocate the user fd.
1698                  */
1699                 if ((nfd = ufalloc(0)) == -1) {
1700                         eprintsoline(so, EMFILE);
1701                         SOCKPARAMS_DEC_REF(sp);
1702                         return (EMFILE);
1703                 }
1704 
1705                 /*
1706                  * Copy the fd out.
1707                  */
1708                 if (so_copyout(&nfd, (void *)arg, sizeof (nfd),
1709                     (mode & (int)FKIOCTL))) {
1710                         error = EFAULT;
1711                         goto err;
1712                 }
1713                 mutex_enter(&so->so_lock);
1714 
1715                 /*
1716                  * Don't use sosctp_assoc() in order to peel off disconnected
1717                  * associations.
1718                  */
1719                 ssa = ((uint32_t)intval >= ss->ss_maxassoc) ? NULL :
1720                     ss->ss_assocs[intval].ssi_assoc;
1721                 if (ssa == NULL) {
1722                         mutex_exit(&so->so_lock);
1723                         error = EINVAL;
1724                         goto err;
1725                 }
1726                 SSA_REFHOLD(ssa);
1727 
1728                 nso = socksctp_create(sp, so->so_family, SOCK_STREAM,
1729                     so->so_protocol, so->so_version, SOCKET_NOSLEEP,
1730                     &error, cr);
1731                 if (nso == NULL) {
1732                         SSA_REFRELE(ss, ssa);
1733                         mutex_exit(&so->so_lock);
1734                         goto err;
1735                 }
1736                 nvp = SOTOV(nso);
1737                 so_lock_single(so);
1738                 mutex_exit(&so->so_lock);
1739 
1740                 /* cannot fail, only inheriting properties */
1741                 (void) sosctp_init(nso, so, CRED(), 0);
1742 
1743                 /*
1744                  * We have a single ref on the new socket. This is normally
1745                  * handled by socket_{create,newconn}, but since they are not
1746                  * used we have to do it here.
1747                  */
1748                 nso->so_count = 1;
1749 
1750                 us.sus_handle = nso;
1751                 us.sus_upcalls = &sosctp_sock_upcalls;
1752 
1753                 /*
1754                  * Upcalls to new socket are blocked for the duration of
1755                  * downcall.
1756                  */
1757                 mutex_enter(&nso->so_lock);
1758 
1759                 error = sctp_set_opt((struct sctp_s *)ssa->ssa_conn,
1760                     IPPROTO_SCTP, SCTP_UC_SWAP, &us, sizeof (us));
1761                 if (error) {
1762                         goto peelerr;
1763                 }
1764                 error = falloc(nvp, FWRITE|FREAD, &nfp, NULL);
1765                 if (error) {
1766                         goto peelerr;
1767                 }
1768 
1769                 /*
1770                  * fill in the entries that falloc reserved
1771                  */
1772                 nfp->f_vnode = nvp;
1773                 mutex_exit(&nfp->f_tlock);
1774                 setf(nfd, nfp);
1775 
1776                 mutex_enter(&so->so_lock);
1777 
1778                 sosctp_assoc_move(ss, SOTOSSO(nso), ssa);
1779 
1780                 mutex_exit(&nso->so_lock);
1781 
1782                 ssa->ssa_conn = NULL;
1783                 sosctp_assoc_free(ss, ssa);
1784 
1785                 so_unlock_single(so, SOLOCKED);
1786                 mutex_exit(&so->so_lock);
1787 
1788                 return (0);
1789 
1790 err:
1791                 SOCKPARAMS_DEC_REF(sp);
1792                 setf(nfd, NULL);
1793                 eprintsoline(so, error);
1794                 return (error);
1795 
1796 peelerr:
1797                 mutex_exit(&nso->so_lock);
1798                 mutex_enter(&so->so_lock);
1799                 ASSERT(nso->so_count == 1);
1800                 nso->so_count = 0;
1801                 so_unlock_single(so, SOLOCKED);
1802                 SSA_REFRELE(ss, ssa);
1803                 mutex_exit(&so->so_lock);
1804 
1805                 setf(nfd, NULL);
1806                 ASSERT(nvp->v_count == 1);
1807                 socket_destroy(nso);
1808                 eprintsoline(so, error);
1809                 return (error);
1810         }
1811         default:
1812                 return (EINVAL);
1813         }
1814 }
1815 
1816 /*ARGSUSED*/
1817 static int
1818 sosctp_close(struct sonode *so, int flag, struct cred *cr)
1819 {
1820         struct sctp_sonode *ss;
1821         struct sctp_sa_id *ssi;
1822         struct sctp_soassoc *ssa;
1823         int32_t i;
1824 
1825         ss = SOTOSSO(so);
1826 
1827         /*
1828          * Initiate connection shutdown.  Tell SCTP if there is any data
1829          * left unread.
1830          */
1831         sctp_recvd((struct sctp_s *)so->so_proto_handle,
1832             so->so_rcvbuf - so->so_rcv_queued);
1833         (void) sctp_disconnect((struct sctp_s *)so->so_proto_handle);
1834 
1835         /*
1836          * New associations can't come in, but old ones might get
1837          * closed in upcall. Protect against that by taking a reference
1838          * on the association.
1839          */
1840         mutex_enter(&so->so_lock);
1841         ssi = ss->ss_assocs;
1842         for (i = 0; i < ss->ss_maxassoc; i++, ssi++) {
1843                 if ((ssa = ssi->ssi_assoc) != NULL) {
1844                         SSA_REFHOLD(ssa);
1845                         sosctp_assoc_isdisconnected(ssa, 0);
1846                         mutex_exit(&so->so_lock);
1847 
1848                         sctp_recvd(ssa->ssa_conn, so->so_rcvbuf -
1849                             ssa->ssa_rcv_queued);
1850                         (void) sctp_disconnect(ssa->ssa_conn);
1851 
1852                         mutex_enter(&so->so_lock);
1853                         SSA_REFRELE(ss, ssa);
1854                 }
1855         }
1856         mutex_exit(&so->so_lock);
1857 
1858         return (0);
1859 }
1860 
1861 /*
1862  * Closes incoming connections which were never accepted, frees
1863  * resources.
1864  */
1865 /* ARGSUSED */
1866 void
1867 sosctp_fini(struct sonode *so, struct cred *cr)
1868 {
1869         struct sctp_sonode *ss;
1870         struct sctp_sa_id *ssi;
1871         struct sctp_soassoc *ssa;
1872         int32_t i;
1873 
1874         ss = SOTOSSO(so);
1875 
1876         ASSERT(so->so_ops == &sosctp_sonodeops ||
1877             so->so_ops == &sosctp_seq_sonodeops);
1878 
1879         /* We are the sole owner of so now */
1880         mutex_enter(&so->so_lock);
1881 
1882         /* Free all pending connections */
1883         so_acceptq_flush(so, B_TRUE);
1884 
1885         ssi = ss->ss_assocs;
1886         for (i = 0; i < ss->ss_maxassoc; i++, ssi++) {
1887                 if ((ssa = ssi->ssi_assoc) != NULL) {
1888                         SSA_REFHOLD(ssa);
1889                         mutex_exit(&so->so_lock);
1890 
1891                         sctp_close((struct sctp_s *)ssa->ssa_conn);
1892 
1893                         mutex_enter(&so->so_lock);
1894                         ssa->ssa_conn = NULL;
1895                         sosctp_assoc_free(ss, ssa);
1896                 }
1897         }
1898         if (ss->ss_assocs != NULL) {
1899                 ASSERT(ss->ss_assoccnt == 0);
1900                 kmem_free(ss->ss_assocs,
1901                     ss->ss_maxassoc * sizeof (struct sctp_sa_id));
1902         }
1903         mutex_exit(&so->so_lock);
1904 
1905         if (so->so_proto_handle)
1906                 sctp_close((struct sctp_s *)so->so_proto_handle);
1907         so->so_proto_handle = NULL;
1908 
1909         /*
1910          * Note until sctp_close() is called, SCTP can still send up
1911          * messages, such as event notifications.  So we should flush
1912          * the recevie buffer after calling sctp_close().
1913          */
1914         mutex_enter(&so->so_lock);
1915         so_rcv_flush(so);
1916         mutex_exit(&so->so_lock);
1917 
1918         sonode_fini(so);
1919 }
1920 
1921 /*
1922  * Upcalls from SCTP
1923  */
1924 
1925 /*
1926  * This is the upcall function for 1-N (SOCK_SEQPACKET) socket when a new
1927  * association is created.  Note that the first argument (handle) is of type
1928  * sctp_sonode *, which is the one changed to a listener for new
1929  * associations.  All the other upcalls for 1-N socket take sctp_soassoc *
1930  * as handle.  The only exception is the su_properties upcall, which
1931  * can take both types as handle.
1932  */
1933 /* ARGSUSED */
1934 sock_upper_handle_t
1935 sctp_assoc_newconn(sock_upper_handle_t parenthandle,
1936     sock_lower_handle_t connind, sock_downcalls_t *dc,
1937     struct cred *peer_cred, pid_t peer_cpid, sock_upcalls_t **ucp)
1938 {
1939         struct sctp_sonode *lss = (struct sctp_sonode *)parenthandle;
1940         struct sonode *lso = &lss->ss_so;
1941         struct sctp_soassoc *ssa;
1942         sctp_assoc_t id;
1943 
1944         ASSERT(lss->ss_type == SOSCTP_SOCKET);
1945         ASSERT(lso->so_state & SS_ACCEPTCONN);
1946         ASSERT(lso->so_proto_handle != NULL); /* closed conn */
1947         ASSERT(lso->so_type == SOCK_SEQPACKET);
1948 
1949         mutex_enter(&lso->so_lock);
1950 
1951         if ((id = sosctp_aid_get(lss)) == -1) {
1952                 /*
1953                  * Array not large enough; increase size.
1954                  */
1955                 if (sosctp_aid_grow(lss, lss->ss_maxassoc, KM_NOSLEEP) < 0) {
1956                         mutex_exit(&lso->so_lock);
1957                         return (NULL);
1958                 }
1959                 id = sosctp_aid_get(lss);
1960                 ASSERT(id != -1);
1961         }
1962 
1963         /*
1964          * Create soassoc for this connection
1965          */
1966         ssa = sosctp_assoc_create(lss, KM_NOSLEEP);
1967         if (ssa == NULL) {
1968                 mutex_exit(&lso->so_lock);
1969                 return (NULL);
1970         }
1971         sosctp_aid_reserve(lss, id, 1);
1972         lss->ss_assocs[id].ssi_assoc = ssa;
1973         ++lss->ss_assoccnt;
1974         ssa->ssa_id = id;
1975         ssa->ssa_conn = (struct sctp_s *)connind;
1976         ssa->ssa_state = (SS_ISBOUND | SS_ISCONNECTED);
1977         ssa->ssa_wroff = lss->ss_wroff;
1978         ssa->ssa_wrsize = lss->ss_wrsize;
1979 
1980         mutex_exit(&lso->so_lock);
1981 
1982         *ucp = &sosctp_assoc_upcalls;
1983 
1984         return ((sock_upper_handle_t)ssa);
1985 }
1986 
1987 /* ARGSUSED */
1988 static void
1989 sctp_assoc_connected(sock_upper_handle_t handle, sock_connid_t id,
1990     struct cred *peer_cred, pid_t peer_cpid)
1991 {
1992         struct sctp_soassoc *ssa = (struct sctp_soassoc *)handle;
1993         struct sonode *so = &ssa->ssa_sonode->ss_so;
1994 
1995         ASSERT(so->so_type == SOCK_SEQPACKET);
1996         ASSERT(ssa->ssa_conn);
1997 
1998         mutex_enter(&so->so_lock);
1999         sosctp_assoc_isconnected(ssa);
2000         mutex_exit(&so->so_lock);
2001 }
2002 
2003 /* ARGSUSED */
2004 static int
2005 sctp_assoc_disconnected(sock_upper_handle_t handle, sock_connid_t id, int error)
2006 {
2007         struct sctp_soassoc *ssa = (struct sctp_soassoc *)handle;
2008         struct sonode *so = &ssa->ssa_sonode->ss_so;
2009         int ret;
2010 
2011         ASSERT(so->so_type == SOCK_SEQPACKET);
2012         ASSERT(ssa->ssa_conn != NULL);
2013 
2014         mutex_enter(&so->so_lock);
2015         sosctp_assoc_isdisconnected(ssa, error);
2016         if (ssa->ssa_refcnt == 1) {
2017                 ret = 1;
2018                 ssa->ssa_conn = NULL;
2019         } else {
2020                 ret = 0;
2021         }
2022         SSA_REFRELE(SOTOSSO(so), ssa);
2023 
2024         cv_broadcast(&so->so_snd_cv);
2025 
2026         mutex_exit(&so->so_lock);
2027 
2028         return (ret);
2029 }
2030 
2031 /* ARGSUSED */
2032 static void
2033 sctp_assoc_disconnecting(sock_upper_handle_t handle, sock_opctl_action_t action,
2034     uintptr_t arg)
2035 {
2036         struct sctp_soassoc *ssa = (struct sctp_soassoc *)handle;
2037         struct sonode *so = &ssa->ssa_sonode->ss_so;
2038 
2039         ASSERT(so->so_type == SOCK_SEQPACKET);
2040         ASSERT(ssa->ssa_conn != NULL);
2041         ASSERT(action == SOCK_OPCTL_SHUT_SEND);
2042 
2043         mutex_enter(&so->so_lock);
2044         sosctp_assoc_isdisconnecting(ssa);
2045         mutex_exit(&so->so_lock);
2046 }
2047 
2048 /* ARGSUSED */
2049 static ssize_t
2050 sctp_assoc_recv(sock_upper_handle_t handle, mblk_t *mp, size_t len, int flags,
2051     int *errorp, boolean_t *forcepush)
2052 {
2053         struct sctp_soassoc *ssa = (struct sctp_soassoc *)handle;
2054         struct sctp_sonode *ss = ssa->ssa_sonode;
2055         struct sonode *so = &ss->ss_so;
2056         struct T_unitdata_ind *tind;
2057         mblk_t *mp2;
2058         union sctp_notification *sn;
2059         struct sctp_sndrcvinfo *sinfo;
2060         ssize_t space_available;
2061 
2062         ASSERT(ssa->ssa_type == SOSCTP_ASSOC);
2063         ASSERT(so->so_type == SOCK_SEQPACKET);
2064         ASSERT(ssa->ssa_conn != NULL); /* closed conn */
2065         ASSERT(mp != NULL);
2066 
2067         ASSERT(errorp != NULL);
2068         *errorp = 0;
2069 
2070         /*
2071          * Should be getting T_unitdata_req's only.
2072          * Must have address as part of packet.
2073          */
2074         tind = (struct T_unitdata_ind *)mp->b_rptr;
2075         ASSERT((DB_TYPE(mp) == M_PROTO) &&
2076             (tind->PRIM_type == T_UNITDATA_IND));
2077         ASSERT(tind->SRC_length);
2078 
2079         mutex_enter(&so->so_lock);
2080 
2081         /*
2082          * For notify messages, need to fill in association id.
2083          * For data messages, sndrcvinfo could be in ancillary data.
2084          */
2085         if (mp->b_flag & SCTP_NOTIFICATION) {
2086                 mp2 = mp->b_cont;
2087                 sn = (union sctp_notification *)mp2->b_rptr;
2088                 switch (sn->sn_header.sn_type) {
2089                 case SCTP_ASSOC_CHANGE:
2090                         sn->sn_assoc_change.sac_assoc_id = ssa->ssa_id;
2091                         break;
2092                 case SCTP_PEER_ADDR_CHANGE:
2093                         sn->sn_paddr_change.spc_assoc_id = ssa->ssa_id;
2094                         break;
2095                 case SCTP_REMOTE_ERROR:
2096                         sn->sn_remote_error.sre_assoc_id = ssa->ssa_id;
2097                         break;
2098                 case SCTP_SEND_FAILED:
2099                         sn->sn_send_failed.ssf_assoc_id = ssa->ssa_id;
2100                         break;
2101                 case SCTP_SHUTDOWN_EVENT:
2102                         sn->sn_shutdown_event.sse_assoc_id = ssa->ssa_id;
2103                         break;
2104                 case SCTP_ADAPTATION_INDICATION:
2105                         sn->sn_adaptation_event.sai_assoc_id = ssa->ssa_id;
2106                         break;
2107                 case SCTP_PARTIAL_DELIVERY_EVENT:
2108                         sn->sn_pdapi_event.pdapi_assoc_id = ssa->ssa_id;
2109                         break;
2110                 default:
2111                         ASSERT(0);
2112                         break;
2113                 }
2114         } else {
2115                 if (tind->OPT_length > 0) {
2116                         struct cmsghdr  *cmsg;
2117                         char            *cend;
2118 
2119                         cmsg = (struct cmsghdr *)
2120                             ((uchar_t *)mp->b_rptr + tind->OPT_offset);
2121                         cend = (char *)cmsg + tind->OPT_length;
2122                         for (;;) {
2123                                 if ((char *)(cmsg + 1) > cend ||
2124                                     ((char *)cmsg + cmsg->cmsg_len) > cend) {
2125                                         break;
2126                                 }
2127                                 if ((cmsg->cmsg_level == IPPROTO_SCTP) &&
2128                                     (cmsg->cmsg_type == SCTP_SNDRCV)) {
2129                                         sinfo = (struct sctp_sndrcvinfo *)
2130                                             (cmsg + 1);
2131                                         sinfo->sinfo_assoc_id = ssa->ssa_id;
2132                                         break;
2133                                 }
2134                                 if (cmsg->cmsg_len > 0) {
2135                                         cmsg = (struct cmsghdr *)
2136                                             ((uchar_t *)cmsg + cmsg->cmsg_len);
2137                                 } else {
2138                                         break;
2139                                 }
2140                         }
2141                 }
2142         }
2143 
2144         /*
2145          * SCTP has reserved space in the header for storing a pointer.
2146          * Put the pointer to assocation there, and queue the data.
2147          */
2148         SSA_REFHOLD(ssa);
2149         ASSERT((mp->b_rptr - DB_BASE(mp)) >= sizeof (ssa));
2150         *(struct sctp_soassoc **)DB_BASE(mp) = ssa;
2151 
2152         ssa->ssa_rcv_queued += len;
2153         space_available = so->so_rcvbuf - ssa->ssa_rcv_queued;
2154         if (space_available <= 0)
2155                 ssa->ssa_flowctrld = B_TRUE;
2156 
2157         so_enqueue_msg(so, mp, len);
2158 
2159         /* so_notify_data drops so_lock */
2160         so_notify_data(so, len);
2161 
2162         return (space_available);
2163 }
2164 
2165 static void
2166 sctp_assoc_xmitted(sock_upper_handle_t handle, boolean_t qfull)
2167 {
2168         struct sctp_soassoc *ssa = (struct sctp_soassoc *)handle;
2169         struct sctp_sonode *ss = ssa->ssa_sonode;
2170 
2171         ASSERT(ssa->ssa_type == SOSCTP_ASSOC);
2172         ASSERT(ss->ss_so.so_type == SOCK_SEQPACKET);
2173         ASSERT(ssa->ssa_conn != NULL);
2174 
2175         mutex_enter(&ss->ss_so.so_lock);
2176 
2177         ssa->ssa_snd_qfull = qfull;
2178 
2179         /*
2180          * Wake blocked writers.
2181          */
2182         cv_broadcast(&ss->ss_so.so_snd_cv);
2183 
2184         mutex_exit(&ss->ss_so.so_lock);
2185 }
2186 
2187 static void
2188 sctp_assoc_properties(sock_upper_handle_t handle,
2189     struct sock_proto_props *soppp)
2190 {
2191         struct sctp_soassoc *ssa = (struct sctp_soassoc *)handle;
2192         struct sonode *so;
2193 
2194         if (ssa->ssa_type == SOSCTP_ASSOC) {
2195                 so = &ssa->ssa_sonode->ss_so;
2196 
2197                 mutex_enter(&so->so_lock);
2198 
2199                 /* Per assoc_id properties. */
2200                 if (soppp->sopp_flags & SOCKOPT_WROFF)
2201                         ssa->ssa_wroff = soppp->sopp_wroff;
2202                 if (soppp->sopp_flags & SOCKOPT_MAXBLK)
2203                         ssa->ssa_wrsize = soppp->sopp_maxblk;
2204         } else {
2205                 so = &((struct sctp_sonode *)handle)->ss_so;
2206                 mutex_enter(&so->so_lock);
2207 
2208                 if (soppp->sopp_flags & SOCKOPT_WROFF)
2209                         so->so_proto_props.sopp_wroff = soppp->sopp_wroff;
2210                 if (soppp->sopp_flags & SOCKOPT_MAXBLK)
2211                         so->so_proto_props.sopp_maxblk = soppp->sopp_maxblk;
2212                 if (soppp->sopp_flags & SOCKOPT_RCVHIWAT) {
2213                         ssize_t lowat;
2214 
2215                         so->so_rcvbuf = soppp->sopp_rxhiwat;
2216                         /*
2217                          * The low water mark should be adjusted properly
2218                          * if the high water mark is changed.  It should
2219                          * not be bigger than 1/4 of high water mark.
2220                          */
2221                         lowat = soppp->sopp_rxhiwat >> 2;
2222                         if (so->so_rcvlowat > lowat) {
2223                                 /* Sanity check... */
2224                                 if (lowat == 0)
2225                                         so->so_rcvlowat = soppp->sopp_rxhiwat;
2226                                 else
2227                                         so->so_rcvlowat = lowat;
2228                         }
2229                 }
2230         }
2231         mutex_exit(&so->so_lock);
2232 }