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