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