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