?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MFC r1.27:
[dragonfly.git] / sys / netinet / sctp_usrreq.c
blob63b7516ac118b2bd1903a8062fc1499439d291d6
1 /* $KAME: sctp_usrreq.c,v 1.47 2005/03/06 16:04:18 itojun Exp $ */
2 /* $DragonFly: src/sys/netinet/sctp_usrreq.c,v 1.14 2008/04/20 13:44:25 swildner Exp $ */
3
4 /*
5 * Copyright (c) 2001, 2002, 2003, 2004 Cisco Systems, Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by Cisco Systems, Inc.
19 * 4. Neither the name of the project nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY CISCO SYSTEMS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL CISCO SYSTEMS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35 #if !(defined(__OpenBSD__) || defined(__APPLE__))
36 #include "opt_ipsec.h"
37 #endif
38 #if defined(__FreeBSD__) || defined(__DragonFly__)
39 #include "opt_inet6.h"
40 #include "opt_inet.h"
41 #endif
42 #if defined(__NetBSD__)
43 #include "opt_inet.h"
44 #endif
45
46 #ifdef __APPLE__
47 #include <sctp.h>
48 #elif !defined(__OpenBSD__)
49 #include "opt_sctp.h"
50 #endif
51
52 #include <sys/param.h>
53 #include <sys/systm.h>
54 #include <sys/kernel.h>
55 #include <sys/malloc.h>
56 #include <sys/mbuf.h>
57 #include <sys/domain.h>
58 #include <sys/proc.h>
59 #include <sys/protosw.h>
60 #include <sys/socket.h>
61 #include <sys/socketvar.h>
62 #include <sys/sysctl.h>
63 #include <sys/syslog.h>
64 #include <sys/thread2.h>
65 #include <net/if.h>
66 #include <net/if_types.h>
67 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
68 #include <net/if_var.h>
69 #endif
70 #include <net/route.h>
71 #include <netinet/in.h>
72 #include <netinet/in_systm.h>
73 #include <netinet/ip.h>
74 #include <netinet/ip6.h>
75 #include <netinet/in_pcb.h>
76 #include <netinet/in_var.h>
77 #include <netinet/ip_var.h>
78 #include <netinet6/ip6_var.h>
79 #include <netinet6/in6_var.h>
80
81 #include <netinet/ip_icmp.h>
82 #include <netinet/icmp_var.h>
83 #include <netinet/sctp_pcb.h>
84 #include <netinet/sctp_header.h>
85 #include <netinet/sctp_var.h>
86 #include <netinet/sctp_output.h>
87 #include <netinet/sctp_uio.h>
88 #include <netinet/sctp_asconf.h>
89 #include <netinet/sctputil.h>
90 #include <netinet/sctp_indata.h>
91 #include <netinet/sctp_asconf.h>
92 #ifdef IPSEC
93 #ifndef __OpenBSD__
94 #include <netinet6/ipsec.h>
95 #include <netproto/key/key.h>
96 #else
97 #undef IPSEC
98 #endif
99 #endif /* IPSEC */
100
101 #include <net/net_osdep.h>
102
103 #if defined(HAVE_NRL_INPCB) || defined(__FreeBSD__) || defined(__DragonFly__)
104 #ifndef in6pcb
105 #define in6pcb inpcb
106 #endif
107 #ifndef sotoin6pcb
108 #define sotoin6pcb sotoinpcb
109 #endif
110 #endif
111
112 #ifdef SCTP_DEBUG
113 extern u_int32_t sctp_debug_on;
114 #endif /* SCTP_DEBUG */
115
116 /*
117 * sysctl tunable variables
118 */
119 int sctp_auto_asconf = SCTP_DEFAULT_AUTO_ASCONF;
120 int sctp_max_burst_default = SCTP_DEF_MAX_BURST;
121 int sctp_peer_chunk_oh = sizeof(struct mbuf);
122 int sctp_strict_init = 1;
123 int sctp_no_csum_on_loopback = 1;
124 unsigned int sctp_max_chunks_on_queue = SCTP_ASOC_MAX_CHUNKS_ON_QUEUE;
125 int sctp_sendspace = (128 * 1024);
126 int sctp_recvspace = 128 * (1024 +
127 #ifdef INET6
128 sizeof(struct sockaddr_in6)
129 #else
130 sizeof(struct sockaddr_in)
131 #endif
132 );
133 int sctp_strict_sacks = 0;
134 int sctp_ecn = 1;
135 int sctp_ecn_nonce = 0;
136
137 unsigned int sctp_delayed_sack_time_default = SCTP_RECV_MSEC;
138 unsigned int sctp_heartbeat_interval_default = SCTP_HB_DEFAULT_MSEC;
139 unsigned int sctp_pmtu_raise_time_default = SCTP_DEF_PMTU_RAISE_SEC;
140 unsigned int sctp_shutdown_guard_time_default = SCTP_DEF_MAX_SHUTDOWN_SEC;
141 unsigned int sctp_secret_lifetime_default = SCTP_DEFAULT_SECRET_LIFE_SEC;
142 unsigned int sctp_rto_max_default = SCTP_RTO_UPPER_BOUND;
143 unsigned int sctp_rto_min_default = SCTP_RTO_LOWER_BOUND;
144 unsigned int sctp_rto_initial_default = SCTP_RTO_INITIAL;
145 unsigned int sctp_init_rto_max_default = SCTP_RTO_UPPER_BOUND;
146 unsigned int sctp_valid_cookie_life_default = SCTP_DEFAULT_COOKIE_LIFE;
147 unsigned int sctp_init_rtx_max_default = SCTP_DEF_MAX_INIT;
148 unsigned int sctp_assoc_rtx_max_default = SCTP_DEF_MAX_SEND;
149 unsigned int sctp_path_rtx_max_default = SCTP_DEF_MAX_SEND/2;
150 unsigned int sctp_nr_outgoing_streams_default = SCTP_OSTREAM_INITIAL;
151
152 void
153 sctp_init(void)
154 {
155 #ifdef __OpenBSD__
156 #define nmbclusters nmbclust
157 #endif
158 /* Init the SCTP pcb in sctp_pcb.c */
159 u_long sb_max_adj;
160
161 sctp_pcb_init();
162
163 #ifndef __OpenBSD__
164 if (nmbclusters > SCTP_ASOC_MAX_CHUNKS_ON_QUEUE)
165 sctp_max_chunks_on_queue = nmbclusters;
166 #else
167 /* if (nmbclust > SCTP_ASOC_MAX_CHUNKS_ON_QUEUE)
168 sctp_max_chunks_on_queue = nmbclust; FIX ME */
169 sctp_max_chunks_on_queue = nmbclust * 2;
170 #endif
171 /*
172 * Allow a user to take no more than 1/2 the number of clusters
173 * or the SB_MAX whichever is smaller for the send window.
174 */
175 sb_max_adj = (u_long)((u_quad_t)(SB_MAX) * MCLBYTES / (MSIZE + MCLBYTES));
176 sctp_sendspace = min((min(SB_MAX, sb_max_adj)),
177 #ifndef __OpenBSD__
178 ((nmbclusters/2) * SCTP_DEFAULT_MAXSEGMENT));
179 #else
180 ((nmbclust/2) * SCTP_DEFAULT_MAXSEGMENT));
181 #endif
182 /*
183 * Now for the recv window, should we take the same amount?
184 * or should I do 1/2 the SB_MAX instead in the SB_MAX min above.
185 * For now I will just copy.
186 */
187 sctp_recvspace = sctp_sendspace;
188 #ifdef __OpenBSD__
189 #undef nmbclusters
190 #endif
191 }
192
193 #ifdef INET6
194 void
195 ip_2_ip6_hdr(struct ip6_hdr *ip6, struct ip *ip)
196 {
197 bzero(ip6, sizeof(*ip6));
198
199 ip6->ip6_vfc = IPV6_VERSION;
200 ip6->ip6_plen = ip->ip_len;
201 ip6->ip6_nxt = ip->ip_p;
202 ip6->ip6_hlim = ip->ip_ttl;
203 ip6->ip6_src.s6_addr32[2] = ip6->ip6_dst.s6_addr32[2] =
204 IPV6_ADDR_INT32_SMP;
205 ip6->ip6_src.s6_addr32[3] = ip->ip_src.s_addr;
206 ip6->ip6_dst.s6_addr32[3] = ip->ip_dst.s_addr;
207 }
208 #endif /* INET6 */
209
210 static void
211 sctp_split_chunks(struct sctp_association *asoc,
212 struct sctp_stream_out *strm,
213 struct sctp_tmit_chunk *chk)
214 {
215 struct sctp_tmit_chunk *new_chk;
216
217 /* First we need a chunk */
218 new_chk = (struct sctp_tmit_chunk *)SCTP_ZONE_GET(sctppcbinfo.ipi_zone_chunk);
219 if (new_chk == NULL) {
220 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
221 return;
222 }
223 sctppcbinfo.ipi_count_chunk++;
224 sctppcbinfo.ipi_gencnt_chunk++;
225 /* Copy it all */
226 *new_chk = *chk;
227 /* split the data */
228 new_chk->data = m_split(chk->data, (chk->send_size>>1), MB_DONTWAIT);
229 if (new_chk->data == NULL) {
230 /* Can't split */
231 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
232 SCTP_ZONE_FREE(sctppcbinfo.ipi_zone_chunk, new_chk);
233 sctppcbinfo.ipi_count_chunk--;
234 if ((int)sctppcbinfo.ipi_count_chunk < 0) {
235 panic("Chunk count is negative");
236 }
237 sctppcbinfo.ipi_gencnt_chunk++;
238 return;
239
240 }
241 /* Data is now split adjust sizes */
242 chk->send_size >>= 1;
243 new_chk->send_size >>= 1;
244
245 chk->book_size >>= 1;
246 new_chk->book_size >>= 1;
247
248 /* now adjust the marks */
249 chk->rec.data.rcv_flags |= SCTP_DATA_FIRST_FRAG;
250 chk->rec.data.rcv_flags &= ~SCTP_DATA_LAST_FRAG;
251
252 new_chk->rec.data.rcv_flags &= ~SCTP_DATA_FIRST_FRAG;
253 new_chk->rec.data.rcv_flags |= SCTP_DATA_LAST_FRAG;
254
255 /* Increase ref count if dest is set */
256 if (chk->whoTo) {
257 new_chk->whoTo->ref_count++;
258 }
259 /* now drop it on the end of the list*/
260 asoc->stream_queue_cnt++;
261 TAILQ_INSERT_AFTER(&strm->outqueue, chk, new_chk, sctp_next);
262 }
263
264 static void
265 sctp_notify_mbuf(struct sctp_inpcb *inp,
266 struct sctp_tcb *stcb,
267 struct sctp_nets *net,
268 struct ip *ip,
269 struct sctphdr *sh)
270
271 {
272 struct icmp *icmph;
273 int totsz;
274 uint16_t nxtsz;
275
276 /* protection */
277 if ((inp == NULL) || (stcb == NULL) || (net == NULL) ||
278 (ip == NULL) || (sh == NULL)) {
279 if (stcb != NULL)
280 SCTP_TCB_UNLOCK(stcb);
281 return;
282 }
283 /* First job is to verify the vtag matches what I would send */
284 if (ntohl(sh->v_tag) != (stcb->asoc.peer_vtag)) {
285 SCTP_TCB_UNLOCK(stcb);
286 return;
287 }
288 icmph = (struct icmp *)((caddr_t)ip - (sizeof(struct icmp) -
289 sizeof(struct ip)));
290 if (icmph->icmp_type != ICMP_UNREACH) {
291 /* We only care about unreachable */
292 SCTP_TCB_UNLOCK(stcb);
293 return;
294 }
295 if (icmph->icmp_code != ICMP_UNREACH_NEEDFRAG) {
296 /* not a unreachable message due to frag. */
297 SCTP_TCB_UNLOCK(stcb);
298 return;
299 }
300 totsz = ip->ip_len;
301 nxtsz = ntohs(icmph->icmp_seq);
302 if (nxtsz == 0) {
303 /*
304 * old type router that does not tell us what the next size
305 * mtu is. Rats we will have to guess (in a educated fashion
306 * of course)
307 */
308 nxtsz = find_next_best_mtu(totsz);
309 }
310
311 /* Stop any PMTU timer */
312 sctp_timer_stop(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, NULL);
313
314 /* Adjust destination size limit */
315 if (net->mtu > nxtsz) {
316 net->mtu = nxtsz;
317 }
318 /* now what about the ep? */
319 if (stcb->asoc.smallest_mtu > nxtsz) {
320 struct sctp_tmit_chunk *chk, *nchk;
321 struct sctp_stream_out *strm;
322 /* Adjust that too */
323 stcb->asoc.smallest_mtu = nxtsz;
324 /* now off to subtract IP_DF flag if needed */
325
326 TAILQ_FOREACH(chk, &stcb->asoc.send_queue, sctp_next) {
327 if ((chk->send_size+IP_HDR_SIZE) > nxtsz) {
328 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
329 }
330 }
331 TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {
332 if ((chk->send_size+IP_HDR_SIZE) > nxtsz) {
333 /*
334 * For this guy we also mark for immediate
335 * resend since we sent to big of chunk
336 */
337 chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;
338 if (chk->sent != SCTP_DATAGRAM_RESEND) {
339 stcb->asoc.sent_queue_retran_cnt++;
340 }
341 chk->sent = SCTP_DATAGRAM_RESEND;
342 chk->rec.data.doing_fast_retransmit = 0;
343
344 /* Clear any time so NO RTT is being done */
345 chk->do_rtt = 0;
346 stcb->asoc.total_flight -= chk->book_size;
347 if (stcb->asoc.total_flight < 0) {
348 stcb->asoc.total_flight = 0;
349 }
350 stcb->asoc.total_flight_count--;
351 if (stcb->asoc.total_flight_count < 0) {
352 stcb->asoc.total_flight_count = 0;
353 }
354 net->flight_size -= chk->book_size;
355 if (net->flight_size < 0) {
356 net->flight_size = 0;
357 }
358 }
359 }
360 TAILQ_FOREACH(strm, &stcb->asoc.out_wheel, next_spoke) {
361 chk = TAILQ_FIRST(&strm->outqueue);
362 while (chk) {
363 nchk = TAILQ_NEXT(chk, sctp_next);
364 if ((chk->send_size+SCTP_MED_OVERHEAD) > nxtsz) {
365 sctp_split_chunks(&stcb->asoc, strm, chk);
366 }
367 chk = nchk;
368 }
369 }
370 }
371 sctp_timer_start(SCTP_TIMER_TYPE_PATHMTURAISE, inp, stcb, NULL);
372 SCTP_TCB_UNLOCK(stcb);
373 }
374
375
376 void
377 sctp_notify(struct sctp_inpcb *inp,
378 int error,
379 struct sctphdr *sh,
380 struct sockaddr *to,
381 struct sctp_tcb *stcb,
382 struct sctp_nets *net)
383 {
384 /* protection */
385 if ((inp == NULL) || (stcb == NULL) || (net == NULL) ||
386 (sh == NULL) || (to == NULL)) {
387 #ifdef SCTP_DEBUG
388 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
389 kprintf("sctp-notify, bad call\n");
390 }
391 #endif /* SCTP_DEBUG */
392 return;
393 }
394 /* First job is to verify the vtag matches what I would send */
395 if (ntohl(sh->v_tag) != (stcb->asoc.peer_vtag)) {
396 return;
397 }
398
399 /* FIX ME FIX ME PROTOPT i.e. no SCTP should ALWAYS be an ABORT */
400
401 if ((error == EHOSTUNREACH) || /* Host is not reachable */
402 (error == EHOSTDOWN) || /* Host is down */
403 (error == ECONNREFUSED) || /* Host refused the connection, (not an abort?) */
404 (error == ENOPROTOOPT) /* SCTP is not present on host */
405 ) {
406 /*
407 * Hmm reachablity problems we must examine closely.
408 * If its not reachable, we may have lost a network.
409 * Or if there is NO protocol at the other end named SCTP.
410 * well we consider it a OOTB abort.
411 */
412 if ((error == EHOSTUNREACH) || (error == EHOSTDOWN)) {
413 if (net->dest_state & SCTP_ADDR_REACHABLE) {
414 /* Ok that destination is NOT reachable */
415 net->dest_state &= ~SCTP_ADDR_REACHABLE;
416 net->dest_state |= SCTP_ADDR_NOT_REACHABLE;
417 net->error_count = net->failure_threshold + 1;
418 sctp_ulp_notify(SCTP_NOTIFY_INTERFACE_DOWN,
419 stcb, SCTP_FAILED_THRESHOLD,
420 (void *)net);
421 }
422 if (stcb)
423 SCTP_TCB_UNLOCK(stcb);
424 } else {
425 /*
426 * Here the peer is either playing tricks on us,
427 * including an address that belongs to someone who
428 * does not support SCTP OR was a userland
429 * implementation that shutdown and now is dead. In
430 * either case treat it like a OOTB abort with no TCB
431 */
432 sctp_abort_notification(stcb, SCTP_PEER_FAULTY);
433 sctp_free_assoc(inp, stcb);
434 /* no need to unlock here, since the TCB is gone */
435 }
436 } else {
437 /* Send all others to the app */
438 if (inp->sctp_socket) {
439 SOCK_LOCK(inp->sctp_socket);
440 inp->sctp_socket->so_error = error;
441 sctp_sowwakeup(inp, inp->sctp_socket);
442 SOCK_UNLOCK(inp->sctp_socket);
443 }
444 if (stcb)
445 SCTP_TCB_UNLOCK(stcb);
446 }
447 }
448
449 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
450 void
451 #else
452 void *
453 #endif
454 sctp_ctlinput(int cmd, struct sockaddr *sa, void *vip)
455 {
456 struct ip *ip = vip;
457 struct sctphdr *sh;
458
459
460 if (sa->sa_family != AF_INET ||
461 ((struct sockaddr_in *)sa)->sin_addr.s_addr == INADDR_ANY) {
462 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
463 return;
464 #else
465 return (NULL);
466 #endif
467 }
468
469 if (PRC_IS_REDIRECT(cmd)) {
470 ip = 0;
471 } else if ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0) {
472 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
473 return;
474 #else
475 return (NULL);
476 #endif
477 }
478 if (ip) {
479 struct sctp_inpcb *inp;
480 struct sctp_tcb *stcb;
481 struct sctp_nets *net;
482 struct sockaddr_in to, from;
483
484 sh = (struct sctphdr *)((caddr_t)ip + (ip->ip_hl << 2));
485 bzero(&to, sizeof(to));
486 bzero(&from, sizeof(from));
487 from.sin_family = to.sin_family = AF_INET;
488 from.sin_len = to.sin_len = sizeof(to);
489 from.sin_port = sh->src_port;
490 from.sin_addr = ip->ip_src;
491 to.sin_port = sh->dest_port;
492 to.sin_addr = ip->ip_dst;
493
494 /*
495 * 'to' holds the dest of the packet that failed to be sent.
496 * 'from' holds our local endpoint address.
497 * Thus we reverse the to and the from in the lookup.
498 */
499 crit_enter();
500 stcb = sctp_findassociation_addr_sa((struct sockaddr *)&from,
501 (struct sockaddr *)&to,
502 &inp, &net, 1);
503 if (stcb != NULL && inp && (inp->sctp_socket != NULL)) {
504 if (cmd != PRC_MSGSIZE) {
505 int cm;
506 if (cmd == PRC_HOSTDEAD) {
507 cm = EHOSTUNREACH;
508 } else {
509 cm = inetctlerrmap[cmd];
510 }
511 sctp_notify(inp, cm, sh,
512 (struct sockaddr *)&to, stcb,
513 net);
514 } else {
515 /* handle possible ICMP size messages */
516 sctp_notify_mbuf(inp, stcb, net, ip, sh);
517 }
518 } else {
519 #if (defined(__FreeBSD__) && __FreeBSD_version < 500000) || defined(__DragonFly__)
520 /* XXX must be fixed for 5.x and higher, leave for 4.x */
521 if (PRC_IS_REDIRECT(cmd) && inp) {
522 in_rtchange((struct inpcb *)inp,
523 inetctlerrmap[cmd]);
524 }
525 #endif
526 if ((stcb == NULL) && (inp != NULL)) {
527 /* reduce ref-count */
528 SCTP_INP_WLOCK(inp);
529 SCTP_INP_DECR_REF(inp);
530 SCTP_INP_WUNLOCK(inp);
531 }
532
533 }
534 crit_exit();
535 }
536 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
537 return;
538 #else
539 return (NULL);
540 #endif
541 }
542
543 #if defined(__FreeBSD__) || defined(__DragonFly__)
544 static int
545 sctp_getcred(SYSCTL_HANDLER_ARGS)
546 {
547 struct sockaddr_in addrs[2];
548 struct sctp_inpcb *inp;
549 struct sctp_nets *net;
550 struct sctp_tcb *stcb;
551 int error;
552
553 #if __FreeBSD_version >= 500000 || defined(__DragonFly__)
554 error = suser(req->td);
555 #else
556 error = suser(req->p);
557 #endif
558 if (error)
559 return (error);
560 error = SYSCTL_IN(req, addrs, sizeof(addrs));
561 if (error)
562 return (error);
563
564 crit_enter();
565 stcb = sctp_findassociation_addr_sa(sintosa(&addrs[0]),
566 sintosa(&addrs[1]),
567 &inp, &net, 1);
568 if (stcb == NULL || inp == NULL || inp->sctp_socket == NULL) {
569 if ((inp != NULL) && (stcb == NULL)) {
570 /* reduce ref-count */
571 SCTP_INP_WLOCK(inp);
572 SCTP_INP_DECR_REF(inp);
573 SCTP_INP_WUNLOCK(inp);
574 }
575 error = ENOENT;
576 goto out;
577 }
578 error = SYSCTL_OUT(req, inp->sctp_socket->so_cred, sizeof(struct ucred));
579 SCTP_TCB_UNLOCK(stcb);
580 out:
581 crit_exit();
582 return (error);
583 }
584
585 SYSCTL_PROC(_net_inet_sctp, OID_AUTO, getcred, CTLTYPE_OPAQUE|CTLFLAG_RW,
586 0, 0, sctp_getcred, "S,ucred", "Get the ucred of a SCTP connection");
587 #endif /* #if defined(__FreeBSD__) || defined(__DragonFly__) */
588
589 /*
590 * sysctl definitions
591 */
592 #if defined(__FreeBSD__) || defined (__APPLE__) || defined(__DragonFly__)
593
594 SYSCTL_DECL(_net_inet);
595
596 SYSCTL_NODE(_net_inet, OID_AUTO, sctp, CTLFLAG_RD, 0,
597 "sctp values");
598
599 SYSCTL_INT(_net_inet_sctp, OID_AUTO, maxdgram, CTLFLAG_RW,
600 &sctp_sendspace, 0, "Maximum outgoing SCTP buffer size");
601
602 SYSCTL_INT(_net_inet_sctp, OID_AUTO, recvspace, CTLFLAG_RW,
603 &sctp_recvspace, 0, "Maximum incoming SCTP buffer size");
604
605 SYSCTL_INT(_net_inet_sctp, OID_AUTO, auto_asconf, CTLFLAG_RW,
606 &sctp_auto_asconf, 0, "Enable SCTP Auto-ASCONF");
607
608 SYSCTL_INT(_net_inet_sctp, OID_AUTO, ecn_enable, CTLFLAG_RW,
609 &sctp_ecn, 0, "Enable SCTP ECN");
610
611 SYSCTL_INT(_net_inet_sctp, OID_AUTO, ecn_nonce, CTLFLAG_RW,
612 &sctp_ecn_nonce, 0, "Enable SCTP ECN Nonce");
613
614 SYSCTL_INT(_net_inet_sctp, OID_AUTO, strict_sacks, CTLFLAG_RW,
615 &sctp_strict_sacks, 0, "Enable SCTP Strict SACK checking");
616
617 SYSCTL_INT(_net_inet_sctp, OID_AUTO, loopback_nocsum, CTLFLAG_RW,
618 &sctp_no_csum_on_loopback, 0,
619 "Enable NO Csum on packets sent on loopback");
620
621 SYSCTL_INT(_net_inet_sctp, OID_AUTO, strict_init, CTLFLAG_RW,
622 &sctp_strict_init, 0,
623 "Enable strict INIT/INIT-ACK singleton enforcement");
624
625 SYSCTL_INT(_net_inet_sctp, OID_AUTO, peer_chkoh, CTLFLAG_RW,
626 &sctp_peer_chunk_oh, 0,
627 "Amount to debit peers rwnd per chunk sent");
628
629 SYSCTL_INT(_net_inet_sctp, OID_AUTO, maxburst, CTLFLAG_RW,
630 &sctp_max_burst_default, 0,
631 "Default max burst for sctp endpoints");
632
633 SYSCTL_INT(_net_inet_sctp, OID_AUTO, maxchunks, CTLFLAG_RW,
634 &sctp_max_chunks_on_queue, 0,
635 "Default max chunks on queue per asoc");
636
637 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, delayed_sack_time, CTLFLAG_RW,
638 &sctp_delayed_sack_time_default, 0,
639 "Default delayed SACK timer in msec");
640
641 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, heartbeat_interval, CTLFLAG_RW,
642 &sctp_heartbeat_interval_default, 0,
643 "Default heartbeat interval in msec");
644
645 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, pmtu_raise_time, CTLFLAG_RW,
646 &sctp_pmtu_raise_time_default, 0,
647 "Default PMTU raise timer in sec");
648
649 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, shutdown_guard_time, CTLFLAG_RW,
650 &sctp_shutdown_guard_time_default, 0,
651 "Default shutdown guard timer in sec");
652
653 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, secret_lifetime, CTLFLAG_RW,
654 &sctp_secret_lifetime_default, 0,
655 "Default secret lifetime in sec");
656
657 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, rto_max, CTLFLAG_RW,
658 &sctp_rto_max_default, 0,
659 "Default maximum retransmission timeout in msec");
660
661 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, rto_min, CTLFLAG_RW,
662 &sctp_rto_min_default, 0,
663 "Default minimum retransmission timeout in msec");
664
665 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, rto_initial, CTLFLAG_RW,
666 &sctp_rto_initial_default, 0,
667 "Default initial retransmission timeout in msec");
668
669 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, init_rto_max, CTLFLAG_RW,
670 &sctp_init_rto_max_default, 0,
671 "Default maximum retransmission timeout during association setup in msec");
672
673 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, valid_cookie_life, CTLFLAG_RW,
674 &sctp_valid_cookie_life_default, 0,
675 "Default cookie lifetime in sec");
676
677 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, init_rtx_max, CTLFLAG_RW,
678 &sctp_init_rtx_max_default, 0,
679 "Default maximum number of retransmission for INIT chunks");
680
681 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, assoc_rtx_max, CTLFLAG_RW,
682 &sctp_assoc_rtx_max_default, 0,
683 "Default maximum number of retransmissions per association");
684
685 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, path_rtx_max, CTLFLAG_RW,
686 &sctp_path_rtx_max_default, 0,
687 "Default maximum of retransmissions per path");
688
689 SYSCTL_UINT(_net_inet_sctp, OID_AUTO, nr_outgoing_streams, CTLFLAG_RW,
690 &sctp_nr_outgoing_streams_default, 0,
691 "Default number of outgoing streams");
692
693 #ifdef SCTP_DEBUG
694 SYSCTL_INT(_net_inet_sctp, OID_AUTO, debug, CTLFLAG_RW,
695 &sctp_debug_on, 0, "Configure debug output");
696 #endif /* SCTP_DEBUG */
697 #endif
698
699 static int
700 sctp_abort(struct socket *so)
701 {
702 struct sctp_inpcb *inp;
703
704 inp = (struct sctp_inpcb *)so->so_pcb;
705 if (inp == 0)
706 return EINVAL; /* ??? possible? panic instead? */
707
708 crit_enter();
709 sctp_inpcb_free(inp, 1);
710 crit_exit();
711 return 0;
712 }
713
714 static int
715 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
716 sctp_attach(struct socket *so, int proto, struct thread *p)
717 #elif defined(__DragonFly__)
718 sctp_attach(struct socket *so, int proto, struct pru_attach_info *ai)
719 #else
720 sctp_attach(struct socket *so, int proto, struct proc *p)
721 #endif
722 {
723 struct sctp_inpcb *inp;
724 struct inpcb *ip_inp;
725 int error;
726
727 crit_enter();
728 inp = (struct sctp_inpcb *)so->so_pcb;
729 if (inp != 0) {
730 crit_exit();
731 return EINVAL;
732 }
733 error = soreserve(so, sctp_sendspace, sctp_recvspace, NULL);
734 if (error) {
735 crit_exit();
736 return error;
737 }
738 error = sctp_inpcb_alloc(so);
739 if (error) {
740 crit_exit();
741 return error;
742 }
743 inp = (struct sctp_inpcb *)so->so_pcb;
744 SCTP_INP_WLOCK(inp);
745
746 inp->sctp_flags &= ~SCTP_PCB_FLAGS_BOUND_V6; /* I'm not v6! */
747 ip_inp = &inp->ip_inp.inp;
748 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
749 ip_inp->inp_vflag |= INP_IPV4;
750 ip_inp->inp_ip_ttl = ip_defttl;
751 #else
752 inp->inp_vflag |= INP_IPV4;
753 inp->inp_ip_ttl = ip_defttl;
754 #endif
755
756 #ifdef IPSEC
757 #if !(defined(__OpenBSD__) || defined(__APPLE__))
758 error = ipsec_init_policy(so, &ip_inp->inp_sp);
759 if (error != 0) {
760 sctp_inpcb_free(inp, 1);
761 return error;
762 }
763 #endif
764 #endif /*IPSEC*/
765 SCTP_INP_WUNLOCK(inp);
766 #if defined(__NetBSD__)
767 so->so_send = sctp_sosend;
768 #endif
769 crit_exit();
770 return 0;
771 }
772
773 static int
774 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
775 sctp_bind(struct socket *so, struct sockaddr *addr, struct thread *p)
776 {
777 #elif defined(__FreeBSD__) || defined(__APPLE__)
778 sctp_bind(struct socket *so, struct sockaddr *addr, struct proc *p)
779 {
780 #else
781 sctp_bind(struct socket *so, struct mbuf *nam, struct proc *p)
782 {
783 struct sockaddr *addr = nam ? mtod(nam, struct sockaddr *) : NULL;
784 #endif
785 struct sctp_inpcb *inp;
786 int error;
787
788 #ifdef INET6
789 if (addr && addr->sa_family != AF_INET)
790 /* must be a v4 address! */
791 return EINVAL;
792 #endif /* INET6 */
793
794 inp = (struct sctp_inpcb *)so->so_pcb;
795 if (inp == 0)
796 return EINVAL;
797
798 crit_enter();
799 error = sctp_inpcb_bind(so, addr, p);
800 crit_exit();
801 return error;
802 }
803
804
805 static int
806 sctp_detach(struct socket *so)
807 {
808 struct sctp_inpcb *inp;
809
810 inp = (struct sctp_inpcb *)so->so_pcb;
811 if (inp == 0)
812 return EINVAL;
813 crit_enter();
814 if (((so->so_options & SO_LINGER) && (so->so_linger == 0)) ||
815 (so->so_rcv.ssb_cc > 0)) {
816 sctp_inpcb_free(inp, 1);
817 } else {
818 sctp_inpcb_free(inp, 0);
819 }
820 crit_exit();
821 return 0;
822 }
823
824 int
825 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
826 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
827 struct mbuf *control, struct thread *p);
828 #else
829 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
830 struct mbuf *control, struct proc *p);
831 #endif
832
833 int
834 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
835 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
836 struct mbuf *control, struct thread *p)
837 {
838 #else
839 sctp_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *addr,
840 struct mbuf *control, struct proc *p)
841 {
842 #endif
843 struct sctp_inpcb *inp;
844 int error;
845 inp = (struct sctp_inpcb *)so->so_pcb;
846 if (inp == 0) {
847 if (control) {
848 sctp_m_freem(control);
849 control = NULL;
850 }
851 sctp_m_freem(m);
852 return EINVAL;
853 }
854 /* Got to have an to address if we are NOT a connected socket */
855 if ((addr == NULL) &&
856 ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) ||
857 (inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE))
858 ) {
859 goto connected_type;
860 } else if (addr == NULL) {
861 error = EDESTADDRREQ;
862 sctp_m_freem(m);
863 if (control) {
864 sctp_m_freem(control);
865 control = NULL;
866 }
867 return (error);
868 }
869 #ifdef INET6
870 if (addr->sa_family != AF_INET) {
871 /* must be a v4 address! */
872 sctp_m_freem(m);
873 if (control) {
874 sctp_m_freem(control);
875 control = NULL;
876 }
877 error = EDESTADDRREQ;
878 return EINVAL;
879 }
880 #endif /* INET6 */
881 connected_type:
882 /* now what about control */
883 if (control) {
884 if (inp->control) {
885 kprintf("huh? control set?\n");
886 sctp_m_freem(inp->control);
887 inp->control = NULL;
888 }
889 inp->control = control;
890 }
891 /* add it in possibly */
892 if ((inp->pkt) && (inp->pkt->m_flags & M_PKTHDR)) {
893 struct mbuf *x;
894 int c_len;
895
896 c_len = 0;
897 /* How big is it */
898 for (x=m;x;x = x->m_next) {
899 c_len += x->m_len;
900 }
901 inp->pkt->m_pkthdr.len += c_len;
902 }
903 /* Place the data */
904 if (inp->pkt) {
905 inp->pkt_last->m_next = m;
906 inp->pkt_last = m;
907 } else {
908 inp->pkt_last = inp->pkt = m;
909 }
910 if (
911 #if defined (__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
912 /* FreeBSD uses a flag passed */
913 ((flags & PRUS_MORETOCOME) == 0)
914 #elif defined( __NetBSD__)
915 /* NetBSD uses the so_state field */
916 ((so->so_state & SS_MORETOCOME) == 0)
917 #else
918 1 /* Open BSD does not have any "more to come" indication */
919 #endif
920 ) {
921 /*
922 * note with the current version this code will only be used
923 * by OpenBSD-- NetBSD, FreeBSD, and MacOS have methods for
924 * re-defining sosend to use the sctp_sosend. One can
925 * optionally switch back to this code (by changing back the
926 * definitions) but this is not advisable.
927 */
928 int ret;
929 ret = sctp_output(inp, inp->pkt, addr, inp->control, p, flags);
930 inp->pkt = NULL;
931 inp->control = NULL;
932 return (ret);
933 } else {
934 return (0);
935 }
936 }
937
938 static int
939 sctp_disconnect(struct socket *so)
940 {
941 struct sctp_inpcb *inp;
942
943 crit_enter();
944 inp = (struct sctp_inpcb *)so->so_pcb;
945 if (inp == NULL) {
946 crit_exit();
947 return (ENOTCONN);
948 }
949 SCTP_INP_RLOCK(inp);
950 if (inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
951 if (LIST_EMPTY(&inp->sctp_asoc_list)) {
952 /* No connection */
953 crit_exit();
954 SCTP_INP_RUNLOCK(inp);
955 return (0);
956 } else {
957 int some_on_streamwheel = 0;
958 struct sctp_association *asoc;
959 struct sctp_tcb *stcb;
960
961 stcb = LIST_FIRST(&inp->sctp_asoc_list);
962 if (stcb == NULL) {
963 crit_exit();
964 SCTP_INP_RUNLOCK(inp);
965 return (EINVAL);
966 }
967 asoc = &stcb->asoc;
968 SCTP_TCB_LOCK(stcb);
969 if (((so->so_options & SO_LINGER) &&
970 (so->so_linger == 0)) ||
971 (so->so_rcv.ssb_cc > 0)) {
972 if (SCTP_GET_STATE(asoc) !=
973 SCTP_STATE_COOKIE_WAIT) {
974 /* Left with Data unread */
975 struct mbuf *err;
976 err = NULL;
977 MGET(err, MB_DONTWAIT, MT_DATA);
978 if (err) {
979 /* Fill in the user initiated abort */
980 struct sctp_paramhdr *ph;
981 ph = mtod(err, struct sctp_paramhdr *);
982 err->m_len = sizeof(struct sctp_paramhdr);
983 ph->param_type = htons(SCTP_CAUSE_USER_INITIATED_ABT);
984 ph->param_length = htons(err->m_len);
985 }
986 sctp_send_abort_tcb(stcb, err);
987 }
988 SCTP_INP_RUNLOCK(inp);
989 sctp_free_assoc(inp, stcb);
990 /* No unlock tcb assoc is gone */
991 crit_exit();
992 return (0);
993 }
994 if (!TAILQ_EMPTY(&asoc->out_wheel)) {
995 /* Check to see if some data queued */
996 struct sctp_stream_out *outs;
997 TAILQ_FOREACH(outs, &asoc->out_wheel,
998 next_spoke) {
999 if (!TAILQ_EMPTY(&outs->outqueue)) {
1000 some_on_streamwheel = 1;
1001 break;
1002 }
1003 }
1004 }
1005
1006 if (TAILQ_EMPTY(&asoc->send_queue) &&
1007 TAILQ_EMPTY(&asoc->sent_queue) &&
1008 (some_on_streamwheel == 0)) {
1009 /* there is nothing queued to send, so done */
1010 if ((SCTP_GET_STATE(asoc) !=
1011 SCTP_STATE_SHUTDOWN_SENT) &&
1012 (SCTP_GET_STATE(asoc) !=
1013 SCTP_STATE_SHUTDOWN_ACK_SENT)) {
1014 /* only send SHUTDOWN 1st time thru */
1015 #ifdef SCTP_DEBUG
1016 if (sctp_debug_on & SCTP_DEBUG_OUTPUT4) {
1017 kprintf("%s:%d sends a shutdown\n",
1018 __FILE__,
1019 __LINE__
1020 );
1021 }
1022 #endif
1023 sctp_send_shutdown(stcb,
1024 stcb->asoc.primary_destination);
1025 sctp_chunk_output(stcb->sctp_ep, stcb, 1);
1026 asoc->state = SCTP_STATE_SHUTDOWN_SENT;
1027 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
1028 stcb->sctp_ep, stcb,
1029 asoc->primary_destination);
1030 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
1031 stcb->sctp_ep, stcb,
1032 asoc->primary_destination);
1033 }
1034 } else {
1035 /*
1036 * we still got (or just got) data to send,
1037 * so set SHUTDOWN_PENDING
1038 */
1039 /*
1040 * XXX sockets draft says that MSG_EOF should
1041 * be sent with no data.
1042 * currently, we will allow user data to be
1043 * sent first and move to SHUTDOWN-PENDING
1044 */
1045 asoc->state |= SCTP_STATE_SHUTDOWN_PENDING;
1046 }
1047 SCTP_TCB_UNLOCK(stcb);
1048 SCTP_INP_RUNLOCK(inp);
1049 crit_exit();
1050 return (0);
1051 }
1052 /* not reached */
1053 } else {
1054 /* UDP model does not support this */
1055 SCTP_INP_RUNLOCK(inp);
1056 crit_exit();
1057 return EOPNOTSUPP;
1058 }
1059 }
1060
1061 int
1062 sctp_shutdown(struct socket *so)
1063 {
1064 struct sctp_inpcb *inp;
1065
1066 crit_enter();
1067 inp = (struct sctp_inpcb *)so->so_pcb;
1068 if (inp == 0) {
1069 crit_exit();
1070 return EINVAL;
1071 }
1072 SCTP_INP_RLOCK(inp);
1073 /* For UDP model this is a invalid call */
1074 if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
1075 /* Restore the flags that the soshutdown took away. */
1076 #if defined(__FreeBSD__) && __FreeBSD_version >= 502115
1077 so->so_rcv.sb_state &= ~SBS_CANTRCVMORE;
1078 #else
1079 so->so_state &= ~SS_CANTRCVMORE;
1080 #endif
1081 /* This proc will wakeup for read and do nothing (I hope) */
1082 crit_exit();
1083 SCTP_INP_RUNLOCK(inp);
1084 return (EOPNOTSUPP);
1085 }
1086 /*
1087 * Ok if we reach here its the TCP model and it is either a SHUT_WR
1088 * or SHUT_RDWR. This means we put the shutdown flag against it.
1089 */
1090 {
1091 int some_on_streamwheel = 0;
1092 struct sctp_tcb *stcb;
1093 struct sctp_association *asoc;
1094 socantsendmore(so);
1095
1096 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1097 if (stcb == NULL) {
1098 /*
1099 * Ok we hit the case that the shutdown call was made
1100 * after an abort or something. Nothing to do now.
1101 */
1102 crit_exit();
1103 return (0);
1104 }
1105 SCTP_TCB_LOCK(stcb);
1106 asoc = &stcb->asoc;
1107
1108 if (!TAILQ_EMPTY(&asoc->out_wheel)) {
1109 /* Check to see if some data queued */
1110 struct sctp_stream_out *outs;
1111 TAILQ_FOREACH(outs, &asoc->out_wheel, next_spoke) {
1112 if (!TAILQ_EMPTY(&outs->outqueue)) {
1113 some_on_streamwheel = 1;
1114 break;
1115 }
1116 }
1117 }
1118 if (TAILQ_EMPTY(&asoc->send_queue) &&
1119 TAILQ_EMPTY(&asoc->sent_queue) &&
1120 (some_on_streamwheel == 0)) {
1121 /* there is nothing queued to send, so I'm done... */
1122 if (SCTP_GET_STATE(asoc) != SCTP_STATE_SHUTDOWN_SENT) {
1123 /* only send SHUTDOWN the first time through */
1124 #ifdef SCTP_DEBUG
1125 if (sctp_debug_on & SCTP_DEBUG_OUTPUT4) {
1126 kprintf("%s:%d sends a shutdown\n",
1127 __FILE__,
1128 __LINE__
1129 );
1130 }
1131 #endif
1132 sctp_send_shutdown(stcb,
1133 stcb->asoc.primary_destination);
1134 sctp_chunk_output(stcb->sctp_ep, stcb, 1);
1135 asoc->state = SCTP_STATE_SHUTDOWN_SENT;
1136 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWN,
1137 stcb->sctp_ep, stcb,
1138 asoc->primary_destination);
1139 sctp_timer_start(SCTP_TIMER_TYPE_SHUTDOWNGUARD,
1140 stcb->sctp_ep, stcb,
1141 asoc->primary_destination);
1142 }
1143 } else {
1144 /*
1145 * we still got (or just got) data to send, so
1146 * set SHUTDOWN_PENDING
1147 */
1148 asoc->state |= SCTP_STATE_SHUTDOWN_PENDING;
1149 }
1150 SCTP_TCB_UNLOCK(stcb);
1151 }
1152 SCTP_INP_RUNLOCK(inp);
1153 crit_exit();
1154 return 0;
1155 }
1156
1157 /*
1158 * copies a "user" presentable address and removes embedded scope, etc.
1159 * returns 0 on success, 1 on error
1160 */
1161 static uint32_t
1162 sctp_fill_user_address(struct sockaddr_storage *ss, struct sockaddr *sa)
1163 {
1164 struct sockaddr_in6 lsa6;
1165 sa = (struct sockaddr *)sctp_recover_scope((struct sockaddr_in6 *)sa,
1166 &lsa6);
1167 memcpy(ss, sa, sa->sa_len);
1168 return (0);
1169 }
1170
1171
1172 #if defined(__NetBSD__) || defined(__OpenBSD__)
1173 /*
1174 * On NetBSD and OpenBSD in6_sin_2_v4mapsin6() not used and not exported,
1175 * so we have to export it here.
1176 */
1177 void in6_sin_2_v4mapsin6(struct sockaddr_in *sin, struct sockaddr_in6 *sin6);
1178 #endif
1179
1180 static int
1181 sctp_fill_up_addresses(struct sctp_inpcb *inp,
1182 struct sctp_tcb *stcb,
1183 int limit,
1184 struct sockaddr_storage *sas)
1185 {
1186 struct ifnet *ifn;
1187 int loopback_scope, ipv4_local_scope, local_scope, site_scope, actual;
1188 int ipv4_addr_legal, ipv6_addr_legal;
1189 actual = 0;
1190 if (limit <= 0)
1191 return (actual);
1192
1193 if (stcb) {
1194 /* Turn on all the appropriate scope */
1195 loopback_scope = stcb->asoc.loopback_scope;
1196 ipv4_local_scope = stcb->asoc.ipv4_local_scope;
1197 local_scope = stcb->asoc.local_scope;
1198 site_scope = stcb->asoc.site_scope;
1199 } else {
1200 /* Turn on ALL scope, since we look at the EP */
1201 loopback_scope = ipv4_local_scope = local_scope =
1202 site_scope = 1;
1203 }
1204 ipv4_addr_legal = ipv6_addr_legal = 0;
1205 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
1206 ipv6_addr_legal = 1;
1207 if (
1208 #if defined(__OpenBSD__)
1209 (0) /* we always do dual bind */
1210 #elif defined (__NetBSD__)
1211 (((struct in6pcb *)inp)->in6p_flags & IN6P_IPV6_V6ONLY)
1212 #else
1213 (((struct in6pcb *)inp)->inp_flags & IN6P_IPV6_V6ONLY)
1214 #endif
1215 == 0) {
1216 ipv4_addr_legal = 1;
1217 }
1218 } else {
1219 ipv4_addr_legal = 1;
1220 }
1221
1222 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
1223 TAILQ_FOREACH(ifn, &ifnet, if_list) {
1224 struct ifaddr_container *ifac;
1225
1226 if ((loopback_scope == 0) &&
1227 (ifn->if_type == IFT_LOOP)) {
1228 /* Skip loopback if loopback_scope not set */
1229 continue;
1230 }
1231 TAILQ_FOREACH(ifac, &ifn->if_addrheads[mycpuid],
1232 ifa_link) {
1233 struct ifaddr *ifa = ifac->ifa;
1234
1235 if (stcb) {
1236 /*
1237 * For the BOUND-ALL case, the list
1238 * associated with a TCB is Always
1239 * considered a reverse list.. i.e.
1240 * it lists addresses that are NOT
1241 * part of the association. If this
1242 * is one of those we must skip it.
1243 */
1244 if (sctp_is_addr_restricted(stcb,
1245 ifa->ifa_addr)) {
1246 continue;
1247 }
1248 }
1249 if ((ifa->ifa_addr->sa_family == AF_INET) &&
1250 (ipv4_addr_legal)) {
1251 struct sockaddr_in *sin;
1252 sin = (struct sockaddr_in *)ifa->ifa_addr;
1253 if (sin->sin_addr.s_addr == 0) {
1254 /* we skip unspecifed addresses */
1255 continue;
1256 }
1257 if ((ipv4_local_scope == 0) &&
1258 (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) {
1259 continue;
1260 }
1261 if (inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) {
1262 in6_sin_2_v4mapsin6(sin, (struct sockaddr_in6 *)sas);
1263 ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1264 sas = (struct sockaddr_storage *)((caddr_t)sas + sizeof(struct sockaddr_in6));
1265 actual += sizeof(sizeof(struct sockaddr_in6));
1266 } else {
1267 memcpy(sas, sin, sizeof(*sin));
1268 ((struct sockaddr_in *)sas)->sin_port = inp->sctp_lport;
1269 sas = (struct sockaddr_storage *)((caddr_t)sas + sizeof(*sin));
1270 actual += sizeof(*sin);
1271 }
1272 if (actual >= limit) {
1273 return (actual);
1274 }
1275 } else if ((ifa->ifa_addr->sa_family == AF_INET6) &&
1276 (ipv6_addr_legal)) {
1277 struct sockaddr_in6 *sin6, lsa6;
1278 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
1279 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
1280 /* we skip unspecifed addresses */
1281 continue;
1282 }
1283 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
1284 if (local_scope == 0)
1285 continue;
1286 if (sin6->sin6_scope_id == 0) {
1287 lsa6 = *sin6;
1288 if (in6_recoverscope(&lsa6,
1289 &lsa6.sin6_addr,
1290 NULL))
1291 /* bad link local address */
1292 continue;
1293 sin6 = &lsa6;
1294 }
1295 }
1296 if ((site_scope == 0) &&
1297 (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) {
1298 continue;
1299 }
1300 memcpy(sas, sin6, sizeof(*sin6));
1301 ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1302 sas = (struct sockaddr_storage *)((caddr_t)sas + sizeof(*sin6));
1303 actual += sizeof(*sin6);
1304 if (actual >= limit) {
1305 return (actual);
1306 }
1307 }
1308 }
1309 }
1310 } else {
1311 struct sctp_laddr *laddr;
1312 /*
1313 * If we have a TCB and we do NOT support ASCONF (it's
1314 * turned off or otherwise) then the list is always the
1315 * true list of addresses (the else case below). Otherwise
1316 * the list on the association is a list of addresses that
1317 * are NOT part of the association.
1318 */
1319 if (inp->sctp_flags & SCTP_PCB_FLAGS_DO_ASCONF) {
1320 /* The list is a NEGATIVE list */
1321 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
1322 if (stcb) {
1323 if (sctp_is_addr_restricted(stcb, laddr->ifa->ifa_addr)) {
1324 continue;
1325 }
1326 }
1327 if (sctp_fill_user_address(sas, laddr->ifa->ifa_addr))
1328 continue;
1329
1330 ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1331 sas = (struct sockaddr_storage *)((caddr_t)sas +
1332 laddr->ifa->ifa_addr->sa_len);
1333 actual += laddr->ifa->ifa_addr->sa_len;
1334 if (actual >= limit) {
1335 return (actual);
1336 }
1337 }
1338 } else {
1339 /* The list is a positive list if present */
1340 if (stcb) {
1341 /* Must use the specific association list */
1342 LIST_FOREACH(laddr, &stcb->asoc.sctp_local_addr_list,
1343 sctp_nxt_addr) {
1344 if (sctp_fill_user_address(sas,
1345 laddr->ifa->ifa_addr))
1346 continue;
1347 ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1348 sas = (struct sockaddr_storage *)((caddr_t)sas +
1349 laddr->ifa->ifa_addr->sa_len);
1350 actual += laddr->ifa->ifa_addr->sa_len;
1351 if (actual >= limit) {
1352 return (actual);
1353 }
1354 }
1355 } else {
1356 /* No endpoint so use the endpoints individual list */
1357 LIST_FOREACH(laddr, &inp->sctp_addr_list,
1358 sctp_nxt_addr) {
1359 if (sctp_fill_user_address(sas,
1360 laddr->ifa->ifa_addr))
1361 continue;
1362 ((struct sockaddr_in6 *)sas)->sin6_port = inp->sctp_lport;
1363 sas = (struct sockaddr_storage *)((caddr_t)sas +
1364 laddr->ifa->ifa_addr->sa_len);
1365 actual += laddr->ifa->ifa_addr->sa_len;
1366 if (actual >= limit) {
1367 return (actual);
1368 }
1369 }
1370 }
1371 }
1372 }
1373 return (actual);
1374 }
1375
1376 static int
1377 sctp_count_max_addresses(struct sctp_inpcb *inp)
1378 {
1379 int cnt = 0;
1380 /*
1381 * In both sub-set bound an bound_all cases we return the MAXIMUM
1382 * number of addresses that you COULD get. In reality the sub-set
1383 * bound may have an exclusion list for a given TCB OR in the
1384 * bound-all case a TCB may NOT include the loopback or other
1385 * addresses as well.
1386 */
1387 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
1388 struct ifnet *ifn;
1389
1390 TAILQ_FOREACH(ifn, &ifnet, if_list) {
1391 struct ifaddr_container *ifac;
1392
1393 TAILQ_FOREACH(ifac, &ifn->if_addrheads[mycpuid], ifa_link) {
1394 struct ifaddr *ifa = ifac->ifa;
1395
1396 /* Count them if they are the right type */
1397 if (ifa->ifa_addr->sa_family == AF_INET) {
1398 if (inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)
1399 cnt += sizeof(struct sockaddr_in6);
1400 else
1401 cnt += sizeof(struct sockaddr_in);
1402
1403 } else if (ifa->ifa_addr->sa_family == AF_INET6)
1404 cnt += sizeof(struct sockaddr_in6);
1405 }
1406 }
1407 } else {
1408 struct sctp_laddr *laddr;
1409 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
1410 if (laddr->ifa->ifa_addr->sa_family == AF_INET) {
1411 if (inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)
1412 cnt += sizeof(struct sockaddr_in6);
1413 else
1414 cnt += sizeof(struct sockaddr_in);
1415
1416 } else if (laddr->ifa->ifa_addr->sa_family == AF_INET6)
1417 cnt += sizeof(struct sockaddr_in6);
1418 }
1419 }
1420 return (cnt);
1421 }
1422
1423 static int
1424 sctp_do_connect_x(struct socket *so,
1425 struct sctp_inpcb *inp,
1426 struct mbuf *m,
1427 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
1428 struct thread *p,
1429 #else
1430 struct proc *p,
1431 #endif
1432 int delay
1433 )
1434 {
1435 int error = 0;
1436 struct sctp_tcb *stcb = NULL;
1437 struct sockaddr *sa;
1438 int num_v6=0, num_v4=0, *totaddrp, totaddr, i, incr, at;
1439 #ifdef SCTP_DEBUG
1440 if (sctp_debug_on & SCTP_DEBUG_PCB1) {
1441 kprintf("Connectx called\n");
1442 }
1443 #endif /* SCTP_DEBUG */
1444
1445 crit_enter();
1446 if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
1447 (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
1448 /* We are already connected AND the TCP model */
1449 crit_exit();
1450 return (EADDRINUSE);
1451 }
1452 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
1453 SCTP_INP_RLOCK(inp);
1454 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1455 SCTP_INP_RUNLOCK(inp);
1456 }
1457 if (stcb) {
1458 crit_exit();
1459 return (EALREADY);
1460
1461 }
1462 SCTP_ASOC_CREATE_LOCK(inp);
1463 if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
1464 (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
1465 SCTP_ASOC_CREATE_UNLOCK(inp);
1466 crit_exit();
1467 return (EFAULT);
1468 }
1469
1470 totaddrp = mtod(m, int *);
1471 totaddr = *totaddrp;
1472 sa = (struct sockaddr *)(totaddrp + 1);
1473 at = incr = 0;
1474 /* account and validate addresses */
1475 SCTP_INP_WLOCK(inp);
1476 SCTP_INP_INCR_REF(inp);
1477 SCTP_INP_WUNLOCK(inp);
1478 for (i = 0; i < totaddr; i++) {
1479 if (sa->sa_family == AF_INET) {
1480 num_v4++;
1481 incr = sizeof(struct sockaddr_in);
1482 } else if (sa->sa_family == AF_INET6) {
1483 struct sockaddr_in6 *sin6;
1484 sin6 = (struct sockaddr_in6 *)sa;
1485 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
1486 /* Must be non-mapped for connectx */
1487 SCTP_ASOC_CREATE_UNLOCK(inp);
1488 crit_exit();
1489 return EINVAL;
1490 }
1491 num_v6++;
1492 incr = sizeof(struct sockaddr_in6);
1493 } else {
1494 totaddr = i;
1495 break;
1496 }
1497 stcb = sctp_findassociation_ep_addr(&inp, sa, NULL, NULL, NULL);
1498 if (stcb != NULL) {
1499 /* Already have or am bring up an association */
1500 SCTP_ASOC_CREATE_UNLOCK(inp);
1501 SCTP_TCB_UNLOCK(stcb);
1502 crit_exit();
1503 return (EALREADY);
1504 }
1505 if ((at + incr) > m->m_len) {
1506 totaddr = i;
1507 break;
1508 }
1509 sa = (struct sockaddr *)((caddr_t)sa + incr);
1510 }
1511 sa = (struct sockaddr *)(totaddrp + 1);
1512 SCTP_INP_WLOCK(inp);
1513 SCTP_INP_DECR_REF(inp);
1514 SCTP_INP_WUNLOCK(inp);
1515 #ifdef INET6
1516 if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
1517 (num_v6 > 0)) {
1518 crit_exit();
1519 SCTP_INP_WUNLOCK(inp);
1520 SCTP_ASOC_CREATE_UNLOCK(inp);
1521 return (EINVAL);
1522 }
1523 if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&
1524 (num_v4 > 0)) {
1525 struct in6pcb *inp6;
1526 inp6 = (struct in6pcb *)inp;
1527 if (
1528 #if defined(__OpenBSD__)
1529 (0) /* we always do dual bind */
1530 #elif defined (__NetBSD__)
1531 (inp6->in6p_flags & IN6P_IPV6_V6ONLY)
1532 #else
1533 (inp6->inp_flags & IN6P_IPV6_V6ONLY)
1534 #endif
1535 ) {
1536 /*
1537 * if IPV6_V6ONLY flag, ignore connections
1538 * destined to a v4 addr or v4-mapped addr
1539 */
1540 SCTP_INP_WUNLOCK(inp);
1541 SCTP_ASOC_CREATE_UNLOCK(inp);
1542 crit_exit();
1543 return EINVAL;
1544 }
1545 }
1546 #endif /* INET6 */
1547 if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) ==
1548 SCTP_PCB_FLAGS_UNBOUND) {
1549 /* Bind a ephemeral port */
1550 SCTP_INP_WUNLOCK(inp);
1551 error = sctp_inpcb_bind(so, NULL, p);
1552 if (error) {
1553 SCTP_ASOC_CREATE_UNLOCK(inp);
1554 crit_exit();
1555 return (error);
1556 }
1557 } else {
1558 SCTP_INP_WUNLOCK(inp);
1559 }
1560 /* We are GOOD to go */
1561 stcb = sctp_aloc_assoc(inp, sa, 1, &error, 0);
1562 if (stcb == NULL) {
1563 /* Gak! no memory */
1564 SCTP_ASOC_CREATE_UNLOCK(inp);
1565 crit_exit();
1566 return (error);
1567 }
1568 /* move to second address */
1569 if (sa->sa_family == AF_INET)
1570 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in));
1571 else
1572 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6));
1573
1574 for (i = 1; i < totaddr; i++) {
1575 if (sa->sa_family == AF_INET) {
1576 incr = sizeof(struct sockaddr_in);
1577 if (sctp_add_remote_addr(stcb, sa, 0, 8)) {
1578 /* assoc gone no un-lock */
1579 sctp_free_assoc(inp, stcb);
1580 SCTP_ASOC_CREATE_UNLOCK(inp);
1581 crit_exit();
1582 return (ENOBUFS);
1583 }
1584
1585 } else if (sa->sa_family == AF_INET6) {
1586 incr = sizeof(struct sockaddr_in6);
1587 if (sctp_add_remote_addr(stcb, sa, 0, 8)) {
1588 /* assoc gone no un-lock */
1589 sctp_free_assoc(inp, stcb);
1590 SCTP_ASOC_CREATE_UNLOCK(inp);
1591 crit_exit();
1592 return (ENOBUFS);
1593 }
1594 }
1595 sa = (struct sockaddr *)((caddr_t)sa + incr);
1596 }
1597 stcb->asoc.state = SCTP_STATE_COOKIE_WAIT;
1598 if (delay) {
1599 /* doing delayed connection */
1600 stcb->asoc.delayed_connection = 1;
1601 sctp_timer_start(SCTP_TIMER_TYPE_INIT, inp, stcb, stcb->asoc.primary_destination);
1602 } else {
1603 SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
1604 sctp_send_initiate(inp, stcb);
1605 }
1606 SCTP_TCB_UNLOCK(stcb);
1607 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
1608 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED;
1609 /* Set the connected flag so we can queue data */
1610 soisconnecting(so);
1611 }
1612 SCTP_ASOC_CREATE_UNLOCK(inp);
1613 crit_exit();
1614 return error;
1615 }
1616
1617
1618 static int
1619 sctp_optsget(struct socket *so,
1620 int opt,
1621 struct mbuf **mp,
1622 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
1623 struct thread *p
1624 #else
1625 struct proc *p
1626 #endif
1627 )
1628 {
1629 struct sctp_inpcb *inp;
1630 struct mbuf *m;
1631 int error, optval=0;
1632 struct sctp_tcb *stcb = NULL;
1633
1634 inp = (struct sctp_inpcb *)so->so_pcb;
1635 if (inp == 0)
1636 return EINVAL;
1637 error = 0;
1638
1639 if (mp == NULL) {
1640 #ifdef SCTP_DEBUG
1641 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
1642 kprintf("optsget:MP is NULL EINVAL\n");
1643 }
1644 #endif /* SCTP_DEBUG */
1645 return (EINVAL);
1646 }
1647 m = *mp;
1648 if (m == NULL) {
1649 /* Got to have a mbuf */
1650 #ifdef SCTP_DEBUG
1651 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
1652 kprintf("Huh no mbuf\n");
1653 }
1654 #endif /* SCTP_DEBUG */
1655 return (EINVAL);
1656 }
1657 #ifdef SCTP_DEBUG
1658 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1659 kprintf("optsget opt:%lxx sz:%u\n", (unsigned long)opt,
1660 m->m_len);
1661 }
1662 #endif /* SCTP_DEBUG */
1663
1664 switch (opt) {
1665 case SCTP_NODELAY:
1666 case SCTP_AUTOCLOSE:
1667 case SCTP_AUTO_ASCONF:
1668 case SCTP_DISABLE_FRAGMENTS:
1669 case SCTP_I_WANT_MAPPED_V4_ADDR:
1670 #ifdef SCTP_DEBUG
1671 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1672 kprintf("other stuff\n");
1673 }
1674 #endif /* SCTP_DEBUG */
1675 SCTP_INP_RLOCK(inp);
1676 switch (opt) {
1677 case SCTP_DISABLE_FRAGMENTS:
1678 optval = inp->sctp_flags & SCTP_PCB_FLAGS_NO_FRAGMENT;
1679 break;
1680 case SCTP_I_WANT_MAPPED_V4_ADDR:
1681 optval = inp->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4;
1682 break;
1683 case SCTP_AUTO_ASCONF:
1684 optval = inp->sctp_flags & SCTP_PCB_FLAGS_AUTO_ASCONF;
1685 break;
1686 case SCTP_NODELAY:
1687 optval = inp->sctp_flags & SCTP_PCB_FLAGS_NODELAY;
1688 break;
1689 case SCTP_AUTOCLOSE:
1690 if ((inp->sctp_flags & SCTP_PCB_FLAGS_AUTOCLOSE) ==
1691 SCTP_PCB_FLAGS_AUTOCLOSE)
1692 optval = inp->sctp_ep.auto_close_time;
1693 else
1694 optval = 0;
1695 break;
1696
1697 default:
1698 error = ENOPROTOOPT;
1699 } /* end switch (sopt->sopt_name) */
1700 if (opt != SCTP_AUTOCLOSE) {
1701 /* make it an "on/off" value */
1702 optval = (optval != 0);
1703 }
1704 if ((size_t)m->m_len < sizeof(int)) {
1705 error = EINVAL;
1706 }
1707 SCTP_INP_RUNLOCK(inp);
1708 if (error == 0) {
1709 /* return the option value */
1710 *mtod(m, int *) = optval;
1711 m->m_len = sizeof(optval);
1712 }
1713 break;
1714 case SCTP_GET_ASOC_ID_LIST:
1715 {
1716 struct sctp_assoc_ids *ids;
1717 int cnt, at;
1718 u_int16_t orig;
1719
1720 if ((size_t)m->m_len < sizeof(struct sctp_assoc_ids)) {
1721 error = EINVAL;
1722 break;
1723 }
1724 ids = mtod(m, struct sctp_assoc_ids *);
1725 cnt = 0;
1726 SCTP_INP_RLOCK(inp);
1727 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1728 if (stcb == NULL) {
1729 none_out_now:
1730 ids->asls_numb_present = 0;
1731 ids->asls_more_to_get = 0;
1732 SCTP_INP_RUNLOCK(inp);
1733 break;
1734 }
1735 orig = ids->asls_assoc_start;
1736 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1737 while( orig ) {
1738 stcb = LIST_NEXT(stcb , sctp_tcblist);
1739 orig--;
1740 cnt--;
1741 }
1742 if ( stcb == NULL)
1743 goto none_out_now;
1744
1745 at = 0;
1746 ids->asls_numb_present = 0;
1747 ids->asls_more_to_get = 1;
1748 while(at < MAX_ASOC_IDS_RET) {
1749 ids->asls_assoc_id[at] = sctp_get_associd(stcb);
1750 at++;
1751 ids->asls_numb_present++;
1752 stcb = LIST_NEXT(stcb , sctp_tcblist);
1753 if (stcb == NULL) {
1754 ids->asls_more_to_get = 0;
1755 break;
1756 }
1757 }
1758 SCTP_INP_RUNLOCK(inp);
1759 }
1760 break;
1761 case SCTP_GET_NONCE_VALUES:
1762 {
1763 struct sctp_get_nonce_values *gnv;
1764 if ((size_t)m->m_len < sizeof(struct sctp_get_nonce_values)) {
1765 error = EINVAL;
1766 break;
1767 }
1768 gnv = mtod(m, struct sctp_get_nonce_values *);
1769 stcb = sctp_findassociation_ep_asocid(inp, gnv->gn_assoc_id);
1770 if (stcb == NULL) {
1771 error = ENOTCONN;
1772 } else {
1773 gnv->gn_peers_tag = stcb->asoc.peer_vtag;
1774 gnv->gn_local_tag = stcb->asoc.my_vtag;
1775 SCTP_TCB_UNLOCK(stcb);
1776 }
1777
1778 }
1779 break;
1780 case SCTP_PEER_PUBLIC_KEY:
1781 case SCTP_MY_PUBLIC_KEY:
1782 case SCTP_SET_AUTH_CHUNKS:
1783 case SCTP_SET_AUTH_SECRET:
1784 /* not supported yet and until we refine the draft */
1785 error = EOPNOTSUPP;
1786 break;
1787
1788 case SCTP_DELAYED_ACK_TIME:
1789 {
1790 int32_t *tm;
1791 if ((size_t)m->m_len < sizeof(int32_t)) {
1792 error = EINVAL;
1793 break;
1794 }
1795 tm = mtod(m, int32_t *);
1796
1797 *tm = TICKS_TO_MSEC(inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV]);
1798 }
1799 break;
1800
1801 case SCTP_GET_SNDBUF_USE:
1802 if ((size_t)m->m_len < sizeof(struct sctp_sockstat)) {
1803 error = EINVAL;
1804 } else {
1805 struct sctp_sockstat *ss;
1806 struct sctp_tcb *stcb;
1807 struct sctp_association *asoc;
1808 ss = mtod(m, struct sctp_sockstat *);
1809 stcb = sctp_findassociation_ep_asocid(inp, ss->ss_assoc_id);
1810 if (stcb == NULL) {
1811 error = ENOTCONN;
1812 } else {
1813 asoc = &stcb->asoc;
1814 ss->ss_total_sndbuf = (u_int32_t)asoc->total_output_queue_size;
1815 ss->ss_total_mbuf_sndbuf = (u_int32_t)asoc->total_output_mbuf_queue_size;
1816 ss->ss_total_recv_buf = (u_int32_t)(asoc->size_on_delivery_queue +
1817 asoc->size_on_reasm_queue +
1818 asoc->size_on_all_streams);
1819 SCTP_TCB_UNLOCK(stcb);
1820 error = 0;
1821 m->m_len = sizeof(struct sctp_sockstat);
1822 }
1823 }
1824 break;
1825 case SCTP_MAXBURST:
1826 {
1827 u_int8_t *burst;
1828 burst = mtod(m, u_int8_t *);
1829 SCTP_INP_RLOCK(inp);
1830 *burst = inp->sctp_ep.max_burst;
1831 SCTP_INP_RUNLOCK(inp);
1832 m->m_len = sizeof(u_int8_t);
1833 }
1834 break;
1835 case SCTP_MAXSEG:
1836 {
1837 u_int32_t *segsize;
1838 sctp_assoc_t *assoc_id;
1839 int ovh;
1840
1841 if ((size_t)m->m_len < sizeof(u_int32_t)) {
1842 error = EINVAL;
1843 break;
1844 }
1845 if ((size_t)m->m_len < sizeof(sctp_assoc_t)) {
1846 error = EINVAL;
1847 break;
1848 }
1849 assoc_id = mtod(m, sctp_assoc_t *);
1850 segsize = mtod(m, u_int32_t *);
1851 m->m_len = sizeof(u_int32_t);
1852
1853 if (((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
1854 (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) ||
1855 (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {
1856 struct sctp_tcb *stcb;
1857 SCTP_INP_RLOCK(inp);
1858 stcb = LIST_FIRST(&inp->sctp_asoc_list);
1859 if (stcb) {
1860 SCTP_TCB_LOCK(stcb);
1861 SCTP_INP_RUNLOCK(inp);
1862 *segsize = sctp_get_frag_point(stcb, &stcb->asoc);
1863 SCTP_TCB_UNLOCK(stcb);
1864 } else {
1865 SCTP_INP_RUNLOCK(inp);
1866 goto skipit;
1867 }
1868 } else {
1869 stcb = sctp_findassociation_ep_asocid(inp, *assoc_id);
1870 if (stcb) {
1871 *segsize = sctp_get_frag_point(stcb, &stcb->asoc);
1872 SCTP_TCB_UNLOCK(stcb);
1873 break;
1874 }
1875 skipit:
1876 /* default is to get the max, if I
1877 * can't calculate from an existing association.
1878 */
1879 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
1880 ovh = SCTP_MED_OVERHEAD;
1881 } else {
1882 ovh = SCTP_MED_V4_OVERHEAD;
1883 }
1884 *segsize = inp->sctp_frag_point - ovh;
1885 }
1886 }
1887 break;
1888
1889 case SCTP_SET_DEBUG_LEVEL:
1890 #ifdef SCTP_DEBUG
1891 {
1892 u_int32_t *level;
1893 if ((size_t)m->m_len < sizeof(u_int32_t)) {
1894 error = EINVAL;
1895 break;
1896 }
1897 level = mtod(m, u_int32_t *);
1898 error = 0;
1899 *level = sctp_debug_on;
1900 m->m_len = sizeof(u_int32_t);
1901 kprintf("Returning DEBUG LEVEL %x is set\n",
1902 (u_int)sctp_debug_on);
1903 }
1904 #else /* SCTP_DEBUG */
1905 error = EOPNOTSUPP;
1906 #endif
1907 break;
1908 case SCTP_GET_STAT_LOG:
1909 #ifdef SCTP_STAT_LOGGING
1910 error = sctp_fill_stat_log(m);
1911 #else /* SCTP_DEBUG */
1912 error = EOPNOTSUPP;
1913 #endif
1914 break;
1915 case SCTP_GET_PEGS:
1916 {
1917 u_int32_t *pt;
1918 if ((size_t)m->m_len < sizeof(sctp_pegs)) {
1919 error = EINVAL;
1920 break;
1921 }
1922 pt = mtod(m, u_int32_t *);
1923 memcpy(pt, sctp_pegs, sizeof(sctp_pegs));
1924 m->m_len = sizeof(sctp_pegs);
1925 }
1926 break;
1927 case SCTP_EVENTS:
1928 {
1929 struct sctp_event_subscribe *events;
1930 #ifdef SCTP_DEBUG
1931 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1932 kprintf("get events\n");
1933 }
1934 #endif /* SCTP_DEBUG */
1935 if ((size_t)m->m_len < sizeof(struct sctp_event_subscribe)) {
1936 #ifdef SCTP_DEBUG
1937 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
1938 kprintf("M->M_LEN is %d not %d\n",
1939 (int)m->m_len,
1940 (int)sizeof(struct sctp_event_subscribe));
1941 }
1942 #endif /* SCTP_DEBUG */
1943 error = EINVAL;
1944 break;
1945 }
1946 events = mtod(m, struct sctp_event_subscribe *);
1947 memset(events, 0, sizeof(events));
1948 SCTP_INP_RLOCK(inp);
1949 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVDATAIOEVNT)
1950 events->sctp_data_io_event = 1;
1951
1952 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVASSOCEVNT)
1953 events->sctp_association_event = 1;
1954
1955 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVPADDREVNT)
1956 events->sctp_address_event = 1;
1957
1958 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVSENDFAILEVNT)
1959 events->sctp_send_failure_event = 1;
1960
1961 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVPEERERR)
1962 events->sctp_peer_error_event = 1;
1963
1964 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT)
1965 events->sctp_shutdown_event = 1;
1966
1967 if (inp->sctp_flags & SCTP_PCB_FLAGS_PDAPIEVNT)
1968 events->sctp_partial_delivery_event = 1;
1969
1970 if (inp->sctp_flags & SCTP_PCB_FLAGS_ADAPTIONEVNT)
1971 events->sctp_adaption_layer_event = 1;
1972
1973 if (inp->sctp_flags & SCTP_PCB_FLAGS_STREAM_RESETEVNT)
1974 events->sctp_stream_reset_events = 1;
1975 SCTP_INP_RUNLOCK(inp);
1976 m->m_len = sizeof(struct sctp_event_subscribe);
1977
1978 }
1979 break;
1980
1981 case SCTP_ADAPTION_LAYER:
1982 if ((size_t)m->m_len < sizeof(int)) {
1983 error = EINVAL;
1984 break;
1985 }
1986 #ifdef SCTP_DEBUG
1987 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
1988 kprintf("getadaption ind\n");
1989 }
1990 #endif /* SCTP_DEBUG */
1991 SCTP_INP_RLOCK(inp);
1992 *mtod(m, int *) = inp->sctp_ep.adaption_layer_indicator;
1993 SCTP_INP_RUNLOCK(inp);
1994 m->m_len = sizeof(int);
1995 break;
1996 case SCTP_SET_INITIAL_DBG_SEQ:
1997 if ((size_t)m->m_len < sizeof(int)) {
1998 error = EINVAL;
1999 break;
2000 }
2001 #ifdef SCTP_DEBUG
2002 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2003 kprintf("get initial dbg seq\n");
2004 }
2005 #endif /* SCTP_DEBUG */
2006 SCTP_INP_RLOCK(inp);
2007 *mtod(m, int *) = inp->sctp_ep.initial_sequence_debug;
2008 SCTP_INP_RUNLOCK(inp);
2009 m->m_len = sizeof(int);
2010 break;
2011 case SCTP_GET_LOCAL_ADDR_SIZE:
2012 if ((size_t)m->m_len < sizeof(int)) {
2013 error = EINVAL;
2014 break;
2015 }
2016 #ifdef SCTP_DEBUG
2017 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2018 kprintf("get local sizes\n");
2019 }
2020 #endif /* SCTP_DEBUG */
2021 SCTP_INP_RLOCK(inp);
2022 *mtod(m, int *) = sctp_count_max_addresses(inp);
2023 SCTP_INP_RUNLOCK(inp);
2024 m->m_len = sizeof(int);
2025 break;
2026 case SCTP_GET_REMOTE_ADDR_SIZE:
2027 {
2028 sctp_assoc_t *assoc_id;
2029 u_int32_t *val, sz;
2030 struct sctp_nets *net;
2031 #ifdef SCTP_DEBUG
2032 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2033 kprintf("get remote size\n");
2034 }
2035 #endif /* SCTP_DEBUG */
2036 if ((size_t)m->m_len < sizeof(sctp_assoc_t)) {
2037 #ifdef SCTP_DEBUG
2038 kprintf("m->m_len:%d not %d\n",
2039 m->m_len, sizeof(sctp_assoc_t));
2040 #endif /* SCTP_DEBUG */
2041 error = EINVAL;
2042 break;
2043 }
2044 stcb = NULL;
2045 val = mtod(m, u_int32_t *);
2046 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2047 SCTP_INP_RLOCK(inp);
2048 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2049 if (stcb)
2050 SCTP_TCB_LOCK(stcb);
2051 SCTP_INP_RUNLOCK(inp);
2052 }
2053 if (stcb == NULL) {
2054 assoc_id = mtod(m, sctp_assoc_t *);
2055 stcb = sctp_findassociation_ep_asocid(inp, *assoc_id);
2056 }
2057
2058 if (stcb == NULL) {
2059 error = EINVAL;
2060 break;
2061 }
2062 *val = 0;
2063 sz = 0;
2064 /* Count the sizes */
2065 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
2066 if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) ||
2067 (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET6)) {
2068 sz += sizeof(struct sockaddr_in6);
2069 } else if (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET) {
2070 sz += sizeof(struct sockaddr_in);
2071 } else {
2072 /* huh */
2073 break;
2074 }
2075 }
2076 SCTP_TCB_UNLOCK(stcb);
2077 *val = sz;
2078 m->m_len = sizeof(u_int32_t);
2079 }
2080 break;
2081 case SCTP_GET_PEER_ADDRESSES:
2082 /*
2083 * Get the address information, an array
2084 * is passed in to fill up we pack it.
2085 */
2086 {
2087 int cpsz, left;
2088 struct sockaddr_storage *sas;
2089 struct sctp_nets *net;
2090 struct sctp_getaddresses *saddr;
2091 #ifdef SCTP_DEBUG
2092 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2093 kprintf("get peer addresses\n");
2094 }
2095 #endif /* SCTP_DEBUG */
2096 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
2097 error = EINVAL;
2098 break;
2099 }
2100 left = m->m_len - sizeof(struct sctp_getaddresses);
2101 saddr = mtod(m, struct sctp_getaddresses *);
2102 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2103 SCTP_INP_RLOCK(inp);
2104 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2105 if (stcb)
2106 SCTP_TCB_LOCK(stcb);
2107 SCTP_INP_RUNLOCK(inp);
2108 } else
2109 stcb = sctp_findassociation_ep_asocid(inp,
2110 saddr->sget_assoc_id);
2111 if (stcb == NULL) {
2112 error = ENOENT;
2113 break;
2114 }
2115 m->m_len = sizeof(struct sctp_getaddresses);
2116 sas = (struct sockaddr_storage *)&saddr->addr[0];
2117
2118 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
2119 if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) ||
2120 (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET6)) {
2121 cpsz = sizeof(struct sockaddr_in6);
2122 } else if (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET) {
2123 cpsz = sizeof(struct sockaddr_in);
2124 } else {
2125 /* huh */
2126 break;
2127 }
2128 if (left < cpsz) {
2129 /* not enough room. */
2130 #ifdef SCTP_DEBUG
2131 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2132 kprintf("Out of room\n");
2133 }
2134 #endif /* SCTP_DEBUG */
2135 break;
2136 }
2137 if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_NEEDS_MAPPED_V4) &&
2138 (((struct sockaddr *)&net->ro._l_addr)->sa_family == AF_INET)) {
2139 /* Must map the address */
2140 in6_sin_2_v4mapsin6((struct sockaddr_in *)&net->ro._l_addr,
2141 (struct sockaddr_in6 *)sas);
2142 } else {
2143 memcpy(sas, &net->ro._l_addr, cpsz);
2144 }
2145 ((struct sockaddr_in *)sas)->sin_port = stcb->rport;
2146
2147 sas = (struct sockaddr_storage *)((caddr_t)sas + cpsz);
2148 left -= cpsz;
2149 m->m_len += cpsz;
2150 #ifdef SCTP_DEBUG
2151 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
2152 kprintf("left now:%d mlen:%d\n",
2153 left, m->m_len);
2154 }
2155 #endif /* SCTP_DEBUG */
2156 }
2157 SCTP_TCB_UNLOCK(stcb);
2158 }
2159 #ifdef SCTP_DEBUG
2160 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2161 kprintf("All done\n");
2162 }
2163 #endif /* SCTP_DEBUG */
2164 break;
2165 case SCTP_GET_LOCAL_ADDRESSES:
2166 {
2167 int limit, actual;
2168 struct sockaddr_storage *sas;
2169 struct sctp_getaddresses *saddr;
2170 #ifdef SCTP_DEBUG
2171 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2172 kprintf("get local addresses\n");
2173 }
2174 #endif /* SCTP_DEBUG */
2175 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
2176 error = EINVAL;
2177 break;
2178 }
2179 saddr = mtod(m, struct sctp_getaddresses *);
2180
2181 if (saddr->sget_assoc_id) {
2182 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2183 SCTP_INP_RLOCK(inp);
2184 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2185 if (stcb)
2186 SCTP_TCB_LOCK(stcb);
2187 SCTP_INP_RUNLOCK(inp);
2188 } else
2189 stcb = sctp_findassociation_ep_asocid(inp, saddr->sget_assoc_id);
2190
2191 } else {
2192 stcb = NULL;
2193 }
2194 /*
2195 * assure that the TCP model does not need a assoc id
2196 * once connected.
2197 */
2198 if ( (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) &&
2199 (stcb == NULL) ) {
2200 SCTP_INP_RLOCK(inp);
2201 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2202 if (stcb)
2203 SCTP_TCB_LOCK(stcb);
2204 SCTP_INP_RUNLOCK(inp);
2205 }
2206 sas = (struct sockaddr_storage *)&saddr->addr[0];
2207 limit = m->m_len - sizeof(sctp_assoc_t);
2208 actual = sctp_fill_up_addresses(inp, stcb, limit, sas);
2209 SCTP_TCB_UNLOCK(stcb);
2210 m->m_len = sizeof(struct sockaddr_storage) + actual;
2211 }
2212 break;
2213 case SCTP_PEER_ADDR_PARAMS:
2214 {
2215 struct sctp_paddrparams *paddrp;
2216 struct sctp_nets *net;
2217
2218 #ifdef SCTP_DEBUG
2219 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2220 kprintf("Getting peer_addr_params\n");
2221 }
2222 #endif /* SCTP_DEBUG */
2223 if ((size_t)m->m_len < sizeof(struct sctp_paddrparams)) {
2224 #ifdef SCTP_DEBUG
2225 if (sctp_debug_on & SCTP_DEBUG_USRREQ2) {
2226 kprintf("Hmm m->m_len:%d is to small\n",
2227 m->m_len);
2228 }
2229 #endif /* SCTP_DEBUG */
2230 error = EINVAL;
2231 break;
2232 }
2233 paddrp = mtod(m, struct sctp_paddrparams *);
2234
2235 net = NULL;
2236 if (paddrp->spp_assoc_id) {
2237 #ifdef SCTP_DEBUG
2238 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2239 kprintf("In spp_assoc_id find type\n");
2240 }
2241 #endif /* SCTP_DEBUG */
2242 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2243 SCTP_INP_RLOCK(inp);
2244 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2245 if (stcb) {
2246 SCTP_TCB_LOCK(stcb);
2247 net = sctp_findnet(stcb, (struct sockaddr *)&paddrp->spp_address);
2248 }
2249 SCTP_INP_RLOCK(inp);
2250 } else {
2251 stcb = sctp_findassociation_ep_asocid(inp, paddrp->spp_assoc_id);
2252 }
2253 if (stcb == NULL) {
2254 error = ENOENT;
2255 break;
2256 }
2257 }
2258 if ( (stcb == NULL) &&
2259 ((((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET) ||
2260 (((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET6))) {
2261 /* Lookup via address */
2262 #ifdef SCTP_DEBUG
2263 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2264 kprintf("Ok we need to lookup a param\n");
2265 }
2266 #endif /* SCTP_DEBUG */
2267 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2268 SCTP_INP_RLOCK(inp);
2269 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2270 if (stcb) {
2271 SCTP_TCB_LOCK(stcb);
2272 net = sctp_findnet(stcb, (struct sockaddr *)&paddrp->spp_address);
2273 }
2274 SCTP_INP_RUNLOCK(inp);
2275 } else {
2276 SCTP_INP_WLOCK(inp);
2277 SCTP_INP_INCR_REF(inp);
2278 SCTP_INP_WUNLOCK(inp);
2279 stcb = sctp_findassociation_ep_addr(&inp,
2280 (struct sockaddr *)&paddrp->spp_address,
2281 &net, NULL, NULL);
2282 if (stcb == NULL) {
2283 SCTP_INP_WLOCK(inp);
2284 SCTP_INP_DECR_REF(inp);
2285 SCTP_INP_WUNLOCK(inp);
2286 }
2287 }
2288
2289 if (stcb == NULL) {
2290 error = ENOENT;
2291 break;
2292 }
2293 } else {
2294 /* Effects the Endpoint */
2295 #ifdef SCTP_DEBUG
2296 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2297 kprintf("User wants EP level info\n");
2298 }
2299 #endif /* SCTP_DEBUG */
2300 stcb = NULL;
2301 }
2302 if (stcb) {
2303 /* Applys to the specific association */
2304 #ifdef SCTP_DEBUG
2305 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2306 kprintf("In TCB side\n");
2307 }
2308 #endif /* SCTP_DEBUG */
2309 if (net) {
2310 paddrp->spp_pathmaxrxt = net->failure_threshold;
2311 } else {
2312 /* No destination so return default value */
2313 paddrp->spp_pathmaxrxt = stcb->asoc.def_net_failure;
2314 }
2315 paddrp->spp_hbinterval = stcb->asoc.heart_beat_delay;
2316 paddrp->spp_assoc_id = sctp_get_associd(stcb);
2317 SCTP_TCB_UNLOCK(stcb);
2318 } else {
2319 /* Use endpoint defaults */
2320 SCTP_INP_RLOCK(inp);
2321 #ifdef SCTP_DEBUG
2322 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2323 kprintf("In EP level info\n");
2324 }
2325 #endif /* SCTP_DEBUG */
2326 paddrp->spp_pathmaxrxt = inp->sctp_ep.def_net_failure;
2327 paddrp->spp_hbinterval = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT];
2328 paddrp->spp_assoc_id = (sctp_assoc_t)0;
2329 SCTP_INP_RUNLOCK(inp);
2330 }
2331 m->m_len = sizeof(struct sctp_paddrparams);
2332 }
2333 break;
2334 case SCTP_GET_PEER_ADDR_INFO:
2335 {
2336 struct sctp_paddrinfo *paddri;
2337 struct sctp_nets *net;
2338 #ifdef SCTP_DEBUG
2339 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2340 kprintf("GetPEER ADDR_INFO\n");
2341 }
2342 #endif /* SCTP_DEBUG */
2343 if ((size_t)m->m_len < sizeof(struct sctp_paddrinfo)) {
2344 error = EINVAL;
2345 break;
2346 }
2347 paddri = mtod(m, struct sctp_paddrinfo *);
2348 net = NULL;
2349 if ((((struct sockaddr *)&paddri->spinfo_address)->sa_family == AF_INET) ||
2350 (((struct sockaddr *)&paddri->spinfo_address)->sa_family == AF_INET6)) {
2351 /* Lookup via address */
2352 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2353 SCTP_INP_RLOCK(inp);
2354 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2355 if (stcb) {
2356 SCTP_TCB_LOCK(stcb);
2357 net = sctp_findnet(stcb,
2358 (struct sockaddr *)&paddri->spinfo_address);
2359 }
2360 SCTP_INP_RUNLOCK(inp);
2361 } else {
2362 SCTP_INP_WLOCK(inp);
2363 SCTP_INP_INCR_REF(inp);
2364 SCTP_INP_WUNLOCK(inp);
2365 stcb = sctp_findassociation_ep_addr(&inp,
2366 (struct sockaddr *)&paddri->spinfo_address,
2367 &net, NULL, NULL);
2368 if (stcb == NULL) {
2369 SCTP_INP_WLOCK(inp);
2370 SCTP_INP_DECR_REF(inp);
2371 SCTP_INP_WUNLOCK(inp);
2372 }
2373 }
2374
2375 } else {
2376 stcb = NULL;
2377 }
2378 if ((stcb == NULL) || (net == NULL)) {
2379 error = ENOENT;
2380 break;
2381 }
2382 m->m_len = sizeof(struct sctp_paddrinfo);
2383 paddri->spinfo_state = net->dest_state & (SCTP_REACHABLE_MASK|SCTP_ADDR_NOHB);
2384 paddri->spinfo_cwnd = net->cwnd;
2385 paddri->spinfo_srtt = ((net->lastsa >> 2) + net->lastsv) >> 1;
2386 paddri->spinfo_rto = net->RTO;
2387 paddri->spinfo_assoc_id = sctp_get_associd(stcb);
2388 SCTP_TCB_UNLOCK(stcb);
2389 }
2390 break;
2391 case SCTP_PCB_STATUS:
2392 {
2393 struct sctp_pcbinfo *spcb;
2394 #ifdef SCTP_DEBUG
2395 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2396 kprintf("PCB status\n");
2397 }
2398 #endif /* SCTP_DEBUG */
2399 if ((size_t)m->m_len < sizeof(struct sctp_pcbinfo)) {
2400 error = EINVAL;
2401 break;
2402 }
2403 spcb = mtod(m, struct sctp_pcbinfo *);
2404 sctp_fill_pcbinfo(spcb);
2405 m->m_len = sizeof(struct sctp_pcbinfo);
2406 }
2407 break;
2408 case SCTP_STATUS:
2409 {
2410 struct sctp_nets *net;
2411 struct sctp_status *sstat;
2412 #ifdef SCTP_DEBUG
2413 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2414 kprintf("SCTP status\n");
2415 }
2416 #endif /* SCTP_DEBUG */
2417
2418 if ((size_t)m->m_len < sizeof(struct sctp_status)) {
2419 error = EINVAL;
2420 break;
2421 }
2422 sstat = mtod(m, struct sctp_status *);
2423
2424 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2425 SCTP_INP_RLOCK(inp);
2426 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2427 if (stcb)
2428 SCTP_TCB_LOCK(stcb);
2429 SCTP_INP_RUNLOCK(inp);
2430 } else
2431 stcb = sctp_findassociation_ep_asocid(inp, sstat->sstat_assoc_id);
2432
2433 if (stcb == NULL) {
2434 error = EINVAL;
2435 break;
2436 }
2437 /*
2438 * I think passing the state is fine since
2439 * sctp_constants.h will be available to the user
2440 * land.
2441 */
2442 sstat->sstat_state = stcb->asoc.state;
2443 sstat->sstat_rwnd = stcb->asoc.peers_rwnd;
2444 sstat->sstat_unackdata = stcb->asoc.sent_queue_cnt;
2445 /*
2446 * We can't include chunks that have been passed
2447 * to the socket layer. Only things in queue.
2448 */
2449 sstat->sstat_penddata = (stcb->asoc.cnt_on_delivery_queue +
2450 stcb->asoc.cnt_on_reasm_queue +
2451 stcb->asoc.cnt_on_all_streams);
2452
2453
2454 sstat->sstat_instrms = stcb->asoc.streamincnt;
2455 sstat->sstat_outstrms = stcb->asoc.streamoutcnt;
2456 sstat->sstat_fragmentation_point = sctp_get_frag_point(stcb, &stcb->asoc);
2457 memcpy(&sstat->sstat_primary.spinfo_address,
2458 &stcb->asoc.primary_destination->ro._l_addr,
2459 ((struct sockaddr *)(&stcb->asoc.primary_destination->ro._l_addr))->sa_len);
2460 net = stcb->asoc.primary_destination;
2461 ((struct sockaddr_in *)&sstat->sstat_primary.spinfo_address)->sin_port = stcb->rport;
2462 /*
2463 * Again the user can get info from sctp_constants.h
2464 * for what the state of the network is.
2465 */
2466 sstat->sstat_primary.spinfo_state = net->dest_state & SCTP_REACHABLE_MASK;
2467 sstat->sstat_primary.spinfo_cwnd = net->cwnd;
2468 sstat->sstat_primary.spinfo_srtt = net->lastsa;
2469 sstat->sstat_primary.spinfo_rto = net->RTO;
2470 sstat->sstat_primary.spinfo_mtu = net->mtu;
2471 sstat->sstat_primary.spinfo_assoc_id = sctp_get_associd(stcb);
2472 SCTP_TCB_UNLOCK(stcb);
2473 m->m_len = sizeof(*sstat);
2474 }
2475 break;
2476 case SCTP_RTOINFO:
2477 {
2478 struct sctp_rtoinfo *srto;
2479 #ifdef SCTP_DEBUG
2480 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2481 kprintf("RTO Info\n");
2482 }
2483 #endif /* SCTP_DEBUG */
2484 if ((size_t)m->m_len < sizeof(struct sctp_rtoinfo)) {
2485 error = EINVAL;
2486 break;
2487 }
2488 srto = mtod(m, struct sctp_rtoinfo *);
2489 if (srto->srto_assoc_id == 0) {
2490 /* Endpoint only please */
2491 SCTP_INP_RLOCK(inp);
2492 srto->srto_initial = inp->sctp_ep.initial_rto;
2493 srto->srto_max = inp->sctp_ep.sctp_maxrto;
2494 srto->srto_min = inp->sctp_ep.sctp_minrto;
2495 SCTP_INP_RUNLOCK(inp);
2496 break;
2497 }
2498 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2499 SCTP_INP_RLOCK(inp);
2500 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2501 if (stcb)
2502 SCTP_TCB_LOCK(stcb);
2503 SCTP_INP_RUNLOCK(inp);
2504 } else
2505 stcb = sctp_findassociation_ep_asocid(inp, srto->srto_assoc_id);
2506
2507 if (stcb == NULL) {
2508 error = EINVAL;
2509 break;
2510 }
2511 srto->srto_initial = stcb->asoc.initial_rto;
2512 srto->srto_max = stcb->asoc.maxrto;
2513 srto->srto_min = stcb->asoc.minrto;
2514 SCTP_TCB_UNLOCK(stcb);
2515 m->m_len = sizeof(*srto);
2516 }
2517 break;
2518 case SCTP_ASSOCINFO:
2519 {
2520 struct sctp_assocparams *sasoc;
2521 #ifdef SCTP_DEBUG
2522 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2523 kprintf("Associnfo\n");
2524 }
2525 #endif /* SCTP_DEBUG */
2526 if ((size_t)m->m_len < sizeof(struct sctp_assocparams)) {
2527 error = EINVAL;
2528 break;
2529 }
2530 sasoc = mtod(m, struct sctp_assocparams *);
2531 stcb = NULL;
2532
2533 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2534 SCTP_INP_RLOCK(inp);
2535 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2536 if (stcb)
2537 SCTP_TCB_LOCK(stcb);
2538 SCTP_INP_RUNLOCK(inp);
2539 }
2540 if ((sasoc->sasoc_assoc_id) && (stcb == NULL)) {
2541 stcb = sctp_findassociation_ep_asocid(inp,
2542 sasoc->sasoc_assoc_id);
2543 if (stcb == NULL) {
2544 error = ENOENT;
2545 break;
2546 }
2547 } else {
2548 stcb = NULL;
2549 }
2550
2551 if (stcb) {
2552 sasoc->sasoc_asocmaxrxt = stcb->asoc.max_send_times;
2553 sasoc->sasoc_number_peer_destinations = stcb->asoc.numnets;
2554 sasoc->sasoc_peer_rwnd = stcb->asoc.peers_rwnd;
2555 sasoc->sasoc_local_rwnd = stcb->asoc.my_rwnd;
2556 sasoc->sasoc_cookie_life = stcb->asoc.cookie_life;
2557 SCTP_TCB_UNLOCK(stcb);
2558 } else {
2559 SCTP_INP_RLOCK(inp);
2560 sasoc->sasoc_asocmaxrxt = inp->sctp_ep.max_send_times;
2561 sasoc->sasoc_number_peer_destinations = 0;
2562 sasoc->sasoc_peer_rwnd = 0;
2563 sasoc->sasoc_local_rwnd = ssb_space(&inp->sctp_socket->so_rcv);
2564 sasoc->sasoc_cookie_life = inp->sctp_ep.def_cookie_life;
2565 SCTP_INP_RUNLOCK(inp);
2566 }
2567 m->m_len = sizeof(*sasoc);
2568 }
2569 break;
2570 case SCTP_DEFAULT_SEND_PARAM:
2571 {
2572 struct sctp_sndrcvinfo *s_info;
2573
2574 if (m->m_len != sizeof(struct sctp_sndrcvinfo)) {
2575 error = EINVAL;
2576 break;
2577 }
2578 s_info = mtod(m, struct sctp_sndrcvinfo *);
2579 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2580 SCTP_INP_RLOCK(inp);
2581 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2582 if (stcb)
2583 SCTP_TCB_LOCK(stcb);
2584 SCTP_INP_RUNLOCK(inp);
2585 } else
2586 stcb = sctp_findassociation_ep_asocid(inp, s_info->sinfo_assoc_id);
2587
2588 if (stcb == NULL) {
2589 error = ENOENT;
2590 break;
2591 }
2592 /* Copy it out */
2593 *s_info = stcb->asoc.def_send;
2594 SCTP_TCB_UNLOCK(stcb);
2595 m->m_len = sizeof(*s_info);
2596 }
2597 case SCTP_INITMSG:
2598 {
2599 struct sctp_initmsg *sinit;
2600 #ifdef SCTP_DEBUG
2601 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2602 kprintf("initmsg\n");
2603 }
2604 #endif /* SCTP_DEBUG */
2605 if ((size_t)m->m_len < sizeof(struct sctp_initmsg)) {
2606 error = EINVAL;
2607 break;
2608 }
2609 sinit = mtod(m, struct sctp_initmsg *);
2610 SCTP_INP_RLOCK(inp);
2611 sinit->sinit_num_ostreams = inp->sctp_ep.pre_open_stream_count;
2612 sinit->sinit_max_instreams = inp->sctp_ep.max_open_streams_intome;
2613 sinit->sinit_max_attempts = inp->sctp_ep.max_init_times;
2614 sinit->sinit_max_init_timeo = inp->sctp_ep.initial_init_rto_max;
2615 SCTP_INP_RUNLOCK(inp);
2616 m->m_len = sizeof(*sinit);
2617 }
2618 break;
2619 case SCTP_PRIMARY_ADDR:
2620 /* we allow a "get" operation on this */
2621 {
2622 struct sctp_setprim *ssp;
2623
2624 #ifdef SCTP_DEBUG
2625 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2626 kprintf("setprimary\n");
2627 }
2628 #endif /* SCTP_DEBUG */
2629 if ((size_t)m->m_len < sizeof(struct sctp_setprim)) {
2630 error = EINVAL;
2631 break;
2632 }
2633 ssp = mtod(m, struct sctp_setprim *);
2634 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2635 SCTP_INP_RLOCK(inp);
2636 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2637 if (stcb)
2638 SCTP_TCB_LOCK(stcb);
2639 SCTP_INP_RUNLOCK(inp);
2640 } else {
2641 stcb = sctp_findassociation_ep_asocid(inp, ssp->ssp_assoc_id);
2642 if (stcb == NULL) {
2643 /* one last shot, try it by the address in */
2644 struct sctp_nets *net;
2645
2646 SCTP_INP_WLOCK(inp);
2647 SCTP_INP_INCR_REF(inp);
2648 SCTP_INP_WUNLOCK(inp);
2649 stcb = sctp_findassociation_ep_addr(&inp,
2650 (struct sockaddr *)&ssp->ssp_addr,
2651 &net, NULL, NULL);
2652 if (stcb == NULL) {
2653 SCTP_INP_WLOCK(inp);
2654 SCTP_INP_DECR_REF(inp);
2655 SCTP_INP_WUNLOCK(inp);
2656 }
2657 }
2658 if (stcb == NULL) {
2659 error = EINVAL;
2660 break;
2661 }
2662 }
2663 /* simply copy out the sockaddr_storage... */
2664 memcpy(&ssp->ssp_addr,
2665 &stcb->asoc.primary_destination->ro._l_addr,
2666 ((struct sockaddr *)&stcb->asoc.primary_destination->ro._l_addr)->sa_len);
2667 SCTP_TCB_UNLOCK(stcb);
2668 m->m_len = sizeof(*ssp);
2669 }
2670 break;
2671 default:
2672 error = ENOPROTOOPT;
2673 m->m_len = 0;
2674 break;
2675 } /* end switch (sopt->sopt_name) */
2676 return (error);
2677 }
2678
2679 static int
2680 sctp_optsset(struct socket *so,
2681 int opt,
2682 struct mbuf **mp,
2683 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
2684 struct thread *p
2685 #else
2686 struct proc *p
2687 #endif
2688 )
2689 {
2690 int error, *mopt, set_opt;
2691 struct mbuf *m;
2692 struct sctp_tcb *stcb = NULL;
2693 struct sctp_inpcb *inp;
2694
2695 if (mp == NULL) {
2696 #ifdef SCTP_DEBUG
2697 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
2698 kprintf("optsset:MP is NULL EINVAL\n");
2699 }
2700 #endif /* SCTP_DEBUG */
2701 return (EINVAL);
2702 }
2703 m = *mp;
2704 if (m == NULL)
2705 return (EINVAL);
2706
2707 inp = (struct sctp_inpcb *)so->so_pcb;
2708 if (inp == 0)
2709 return EINVAL;
2710
2711 error = 0;
2712 switch (opt) {
2713 case SCTP_NODELAY:
2714 case SCTP_AUTOCLOSE:
2715 case SCTP_AUTO_ASCONF:
2716 case SCTP_DISABLE_FRAGMENTS:
2717 case SCTP_I_WANT_MAPPED_V4_ADDR:
2718 /* copy in the option value */
2719 if ((size_t)m->m_len < sizeof(int)) {
2720 error = EINVAL;
2721 break;
2722 }
2723 mopt = mtod(m, int *);
2724 set_opt = 0;
2725 if (error)
2726 break;
2727 switch (opt) {
2728 case SCTP_DISABLE_FRAGMENTS:
2729 set_opt = SCTP_PCB_FLAGS_NO_FRAGMENT;
2730 break;
2731 case SCTP_AUTO_ASCONF:
2732 set_opt = SCTP_PCB_FLAGS_AUTO_ASCONF;
2733 break;
2734
2735 case SCTP_I_WANT_MAPPED_V4_ADDR:
2736 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
2737 set_opt = SCTP_PCB_FLAGS_NEEDS_MAPPED_V4;
2738 } else {
2739 return (EINVAL);
2740 }
2741 break;
2742 case SCTP_NODELAY:
2743 set_opt = SCTP_PCB_FLAGS_NODELAY;
2744 break;
2745 case SCTP_AUTOCLOSE:
2746 set_opt = SCTP_PCB_FLAGS_AUTOCLOSE;
2747 /*
2748 * The value is in ticks.
2749 * Note this does not effect old associations, only
2750 * new ones.
2751 */
2752 inp->sctp_ep.auto_close_time = (*mopt * hz);
2753 break;
2754 }
2755 SCTP_INP_WLOCK(inp);
2756 if (*mopt != 0) {
2757 inp->sctp_flags |= set_opt;
2758 } else {
2759 inp->sctp_flags &= ~set_opt;
2760 }
2761 SCTP_INP_WUNLOCK(inp);
2762 break;
2763 case SCTP_MY_PUBLIC_KEY: /* set my public key */
2764 case SCTP_SET_AUTH_CHUNKS: /* set the authenticated chunks required */
2765 case SCTP_SET_AUTH_SECRET: /* set the actual secret for the endpoint */
2766 /* not supported yet and until we refine the draft */
2767 error = EOPNOTSUPP;
2768 break;
2769
2770 case SCTP_CLR_STAT_LOG:
2771 #ifdef SCTP_STAT_LOGGING
2772 sctp_clr_stat_log();
2773 #else
2774 error = EOPNOTSUPP;
2775 #endif
2776 break;
2777 case SCTP_DELAYED_ACK_TIME:
2778 {
2779 int32_t *tm;
2780 if ((size_t)m->m_len < sizeof(int32_t)) {
2781 error = EINVAL;
2782 break;
2783 }
2784 tm = mtod(m, int32_t *);
2785
2786 if ((*tm < 10) || (*tm > 500)) {
2787 /* can't be smaller than 10ms */
2788 /* MUST NOT be larger than 500ms */
2789 error = EINVAL;
2790 break;
2791 }
2792 inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV] = MSEC_TO_TICKS(*tm);
2793 }
2794 break;
2795 case SCTP_RESET_STREAMS:
2796 {
2797 struct sctp_stream_reset *strrst;
2798 uint8_t two_way, not_peer;
2799
2800 if ((size_t)m->m_len < sizeof(struct sctp_stream_reset)) {
2801 error = EINVAL;
2802 break;
2803 }
2804 strrst = mtod(m, struct sctp_stream_reset *);
2805
2806 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2807 SCTP_INP_RLOCK(inp);
2808 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2809 if (stcb)
2810 SCTP_TCB_LOCK(stcb);
2811 SCTP_INP_RUNLOCK(inp);
2812 } else
2813 stcb = sctp_findassociation_ep_asocid(inp, strrst->strrst_assoc_id);
2814 if (stcb == NULL) {
2815 error = ENOENT;
2816 break;
2817 }
2818 if (stcb->asoc.peer_supports_strreset == 0) {
2819 /* Peer does not support it,
2820 * we return protocol not supported since
2821 * this is true for this feature and this
2822 * peer, not the socket request in general.
2823 */
2824 error = EPROTONOSUPPORT;
2825 SCTP_TCB_UNLOCK(stcb);
2826 break;
2827 }
2828
2829 /* Having re-thought this code I added as I write the I-D there
2830 * is NO need for it. The peer, if we are requesting a stream-reset
2831 * will send a request to us but will itself do what we do, take
2832 * and copy off the "reset information" we send and queue TSN's
2833 * larger than the send-next in our response message. Thus they
2834 * will handle it.
2835 */
2836 /* if (stcb->asoc.sending_seq != (stcb->asoc.last_acked_seq + 1)) {*/
2837 /* Must have all sending data ack'd before we
2838 * start this procedure. This is a bit restrictive
2839 * and we SHOULD work on changing this so ONLY the
2840 * streams being RESET get held up. So, a reset-all
2841 * would require this.. but a reset specific just
2842 * needs to be sure that the ones being reset have
2843 * nothing on the send_queue. For now we will
2844 * skip this more detailed method and do a course
2845 * way.. i.e. nothing pending ... for future FIX ME!
2846 */
2847 /* error = EBUSY;*/
2848 /* break;*/
2849 /* }*/
2850
2851 if (stcb->asoc.stream_reset_outstanding) {
2852 error = EALREADY;
2853 SCTP_TCB_UNLOCK(stcb);
2854 break;
2855 }
2856 if (strrst->strrst_flags == SCTP_RESET_LOCAL_RECV) {
2857 two_way = 0;
2858 not_peer = 0;
2859 } else if (strrst->strrst_flags == SCTP_RESET_LOCAL_SEND) {
2860 two_way = 1;
2861 not_peer = 1;
2862 } else if (strrst->strrst_flags == SCTP_RESET_BOTH) {
2863 two_way = 1;
2864 not_peer = 0;
2865 } else {
2866 error = EINVAL;
2867 SCTP_TCB_UNLOCK(stcb);
2868 break;
2869 }
2870 sctp_send_str_reset_req(stcb, strrst->strrst_num_streams,
2871 strrst->strrst_list, two_way, not_peer);
2872 crit_enter();
2873 sctp_chunk_output(inp, stcb, 12);
2874 SCTP_TCB_UNLOCK(stcb);
2875 crit_exit();
2876
2877 }
2878 break;
2879 case SCTP_RESET_PEGS:
2880 memset(sctp_pegs, 0, sizeof(sctp_pegs));
2881 error = 0;
2882 break;
2883 case SCTP_CONNECT_X:
2884 if ((size_t)m->m_len < (sizeof(int) + sizeof(struct sockaddr_in))) {
2885 error = EINVAL;
2886 break;
2887 }
2888 error = sctp_do_connect_x(so, inp, m, p, 0);
2889 break;
2890
2891 case SCTP_CONNECT_X_DELAYED:
2892 if ((size_t)m->m_len < (sizeof(int) + sizeof(struct sockaddr_in))) {
2893 error = EINVAL;
2894 break;
2895 }
2896 error = sctp_do_connect_x(so, inp, m, p, 1);
2897 break;
2898
2899 case SCTP_CONNECT_X_COMPLETE:
2900 {
2901 struct sockaddr *sa;
2902 struct sctp_nets *net;
2903 if ((size_t)m->m_len < sizeof(struct sockaddr_in)) {
2904 error = EINVAL;
2905 break;
2906 }
2907 sa = mtod(m, struct sockaddr *);
2908 /* find tcb */
2909 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
2910 SCTP_INP_RLOCK(inp);
2911 stcb = LIST_FIRST(&inp->sctp_asoc_list);
2912 if (stcb) {
2913 SCTP_TCB_LOCK(stcb);
2914 net = sctp_findnet(stcb, sa);
2915 }
2916 SCTP_INP_RUNLOCK(inp);
2917 } else {
2918 SCTP_INP_WLOCK(inp);
2919 SCTP_INP_INCR_REF(inp);
2920 SCTP_INP_WUNLOCK(inp);
2921 stcb = sctp_findassociation_ep_addr(&inp, sa, &net, NULL, NULL);
2922 if (stcb == NULL) {
2923 SCTP_INP_WLOCK(inp);
2924 SCTP_INP_DECR_REF(inp);
2925 SCTP_INP_WUNLOCK(inp);
2926 }
2927 }
2928
2929 if (stcb == NULL) {
2930 error = ENOENT;
2931 break;
2932 }
2933 if (stcb->asoc.delayed_connection == 1) {
2934 stcb->asoc.delayed_connection = 0;
2935 SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
2936 sctp_timer_stop(SCTP_TIMER_TYPE_INIT, inp, stcb, stcb->asoc.primary_destination);
2937 sctp_send_initiate(inp, stcb);
2938 } else {
2939 /* already expired or did not use delayed connectx */
2940 error = EALREADY;
2941 }
2942 SCTP_TCB_UNLOCK(stcb);
2943 }
2944 break;
2945 case SCTP_MAXBURST:
2946 {
2947 u_int8_t *burst;
2948 SCTP_INP_WLOCK(inp);
2949 burst = mtod(m, u_int8_t *);
2950 if (*burst) {
2951 inp->sctp_ep.max_burst = *burst;
2952 }
2953 SCTP_INP_WUNLOCK(inp);
2954 }
2955 break;
2956 case SCTP_MAXSEG:
2957 {
2958 u_int32_t *segsize;
2959 int ovh;
2960 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {
2961 ovh = SCTP_MED_OVERHEAD;
2962 } else {
2963 ovh = SCTP_MED_V4_OVERHEAD;
2964 }
2965 segsize = mtod(m, u_int32_t *);
2966 if (*segsize < 1) {
2967 error = EINVAL;
2968 break;
2969 }
2970 SCTP_INP_WLOCK(inp);
2971 inp->sctp_frag_point = (*segsize+ovh);
2972 if (inp->sctp_frag_point < MHLEN) {
2973 inp->sctp_frag_point = MHLEN;
2974 }
2975 SCTP_INP_WUNLOCK(inp);
2976 }
2977 break;
2978 case SCTP_SET_DEBUG_LEVEL:
2979 #ifdef SCTP_DEBUG
2980 {
2981 u_int32_t *level;
2982 if ((size_t)m->m_len < sizeof(u_int32_t)) {
2983 error = EINVAL;
2984 break;
2985 }
2986 level = mtod(m, u_int32_t *);
2987 error = 0;
2988 sctp_debug_on = (*level & (SCTP_DEBUG_ALL |
2989 SCTP_DEBUG_NOISY));
2990 kprintf("SETTING DEBUG LEVEL to %x\n",
2991 (u_int)sctp_debug_on);
2992
2993 }
2994 #else
2995 error = EOPNOTSUPP;
2996 #endif /* SCTP_DEBUG */
2997 break;
2998 case SCTP_EVENTS:
2999 {
3000 struct sctp_event_subscribe *events;
3001 if ((size_t)m->m_len < sizeof(struct sctp_event_subscribe)) {
3002 error = EINVAL;
3003 break;
3004 }
3005 SCTP_INP_WLOCK(inp);
3006 events = mtod(m, struct sctp_event_subscribe *);
3007 if (events->sctp_data_io_event) {
3008 inp->sctp_flags |= SCTP_PCB_FLAGS_RECVDATAIOEVNT;
3009 } else {
3010 inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVDATAIOEVNT;
3011 }
3012
3013 if (events->sctp_association_event) {
3014 inp->sctp_flags |= SCTP_PCB_FLAGS_RECVASSOCEVNT;
3015 } else {
3016 inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVASSOCEVNT;
3017 }
3018
3019 if (events->sctp_address_event) {
3020 inp->sctp_flags |= SCTP_PCB_FLAGS_RECVPADDREVNT;
3021 } else {
3022 inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVPADDREVNT;
3023 }
3024
3025 if (events->sctp_send_failure_event) {
3026 inp->sctp_flags |= SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
3027 } else {
3028 inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVSENDFAILEVNT;
3029 }
3030
3031 if (events->sctp_peer_error_event) {
3032 inp->sctp_flags |= SCTP_PCB_FLAGS_RECVPEERERR;
3033 } else {
3034 inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVPEERERR;
3035 }
3036
3037 if (events->sctp_shutdown_event) {
3038 inp->sctp_flags |= SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
3039 } else {
3040 inp->sctp_flags &= ~SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT;
3041 }
3042
3043 if (events->sctp_partial_delivery_event) {
3044 inp->sctp_flags |= SCTP_PCB_FLAGS_PDAPIEVNT;
3045 } else {
3046 inp->sctp_flags &= ~SCTP_PCB_FLAGS_PDAPIEVNT;
3047 }
3048
3049 if (events->sctp_adaption_layer_event) {
3050 inp->sctp_flags |= SCTP_PCB_FLAGS_ADAPTIONEVNT;
3051 } else {
3052 inp->sctp_flags &= ~SCTP_PCB_FLAGS_ADAPTIONEVNT;
3053 }
3054
3055 if (events->sctp_stream_reset_events) {
3056 inp->sctp_flags |= SCTP_PCB_FLAGS_STREAM_RESETEVNT;
3057 } else {
3058 inp->sctp_flags &= ~SCTP_PCB_FLAGS_STREAM_RESETEVNT;
3059 }
3060 SCTP_INP_WUNLOCK(inp);
3061 }
3062 break;
3063
3064 case SCTP_ADAPTION_LAYER:
3065 {
3066 struct sctp_setadaption *adap_bits;
3067 if ((size_t)m->m_len < sizeof(struct sctp_setadaption)) {
3068 error = EINVAL;
3069 break;
3070 }
3071 SCTP_INP_WLOCK(inp);
3072 adap_bits = mtod(m, struct sctp_setadaption *);
3073 inp->sctp_ep.adaption_layer_indicator = adap_bits->ssb_adaption_ind;
3074 SCTP_INP_WUNLOCK(inp);
3075 }
3076 break;
3077 case SCTP_SET_INITIAL_DBG_SEQ:
3078 {
3079 u_int32_t *vvv;
3080 if ((size_t)m->m_len < sizeof(u_int32_t)) {
3081 error = EINVAL;
3082 break;
3083 }
3084 SCTP_INP_WLOCK(inp);
3085 vvv = mtod(m, u_int32_t *);
3086 inp->sctp_ep.initial_sequence_debug = *vvv;
3087 SCTP_INP_WUNLOCK(inp);
3088 }
3089 break;
3090 case SCTP_DEFAULT_SEND_PARAM:
3091 {
3092 struct sctp_sndrcvinfo *s_info;
3093
3094 if (m->m_len != sizeof(struct sctp_sndrcvinfo)) {
3095 error = EINVAL;
3096 break;
3097 }
3098 s_info = mtod(m, struct sctp_sndrcvinfo *);
3099
3100 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3101 SCTP_INP_RLOCK(inp);
3102 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3103 if (stcb)
3104 SCTP_TCB_LOCK(stcb);
3105 SCTP_INP_RUNLOCK(inp);
3106 } else
3107 stcb = sctp_findassociation_ep_asocid(inp, s_info->sinfo_assoc_id);
3108
3109 if (stcb == NULL) {
3110 error = ENOENT;
3111 break;
3112 }
3113 /* Validate things */
3114 if (s_info->sinfo_stream > stcb->asoc.streamoutcnt) {
3115 SCTP_TCB_UNLOCK(stcb);
3116 error = EINVAL;
3117 break;
3118 }
3119 /* Mask off the flags that are allowed */
3120 s_info->sinfo_flags = (s_info->sinfo_flags &
3121 (MSG_UNORDERED | MSG_ADDR_OVER |
3122 MSG_PR_SCTP_TTL | MSG_PR_SCTP_BUF));
3123 /* Copy it in */
3124 stcb->asoc.def_send = *s_info;
3125 SCTP_TCB_UNLOCK(stcb);
3126 }
3127 break;
3128 case SCTP_PEER_ADDR_PARAMS:
3129 {
3130 struct sctp_paddrparams *paddrp;
3131 struct sctp_nets *net;
3132 if ((size_t)m->m_len < sizeof(struct sctp_paddrparams)) {
3133 error = EINVAL;
3134 break;
3135 }
3136 paddrp = mtod(m, struct sctp_paddrparams *);
3137 net = NULL;
3138 if (paddrp->spp_assoc_id) {
3139 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3140 SCTP_INP_RLOCK(inp);
3141 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3142 if (stcb) {
3143 SCTP_TCB_LOCK(stcb);
3144 net = sctp_findnet(stcb, (struct sockaddr *)&paddrp->spp_address);
3145 }
3146 SCTP_INP_RUNLOCK(inp);
3147 } else
3148 stcb = sctp_findassociation_ep_asocid(inp, paddrp->spp_assoc_id);
3149 if (stcb == NULL) {
3150 error = ENOENT;
3151 break;
3152 }
3153
3154 }
3155 if ((stcb == NULL) &&
3156 ((((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET) ||
3157 (((struct sockaddr *)&paddrp->spp_address)->sa_family == AF_INET6))) {
3158 /* Lookup via address */
3159 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3160 SCTP_INP_RLOCK(inp);
3161 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3162 if (stcb) {
3163 SCTP_TCB_LOCK(stcb);
3164 net = sctp_findnet(stcb,
3165 (struct sockaddr *)&paddrp->spp_address);
3166 }
3167 SCTP_INP_RUNLOCK(inp);
3168 } else {
3169 SCTP_INP_WLOCK(inp);
3170 SCTP_INP_INCR_REF(inp);
3171 SCTP_INP_WUNLOCK(inp);
3172 stcb = sctp_findassociation_ep_addr(&inp,
3173 (struct sockaddr *)&paddrp->spp_address,
3174 &net, NULL, NULL);
3175 if (stcb == NULL) {
3176 SCTP_INP_WLOCK(inp);
3177 SCTP_INP_DECR_REF(inp);
3178 SCTP_INP_WUNLOCK(inp);
3179 }
3180 }
3181 } else {
3182 /* Effects the Endpoint */
3183 stcb = NULL;
3184 }
3185 if (stcb) {
3186 /* Applies to the specific association */
3187 if (paddrp->spp_pathmaxrxt) {
3188 if (net) {
3189 if (paddrp->spp_pathmaxrxt)
3190 net->failure_threshold = paddrp->spp_pathmaxrxt;
3191 } else {
3192 if (paddrp->spp_pathmaxrxt)
3193 stcb->asoc.def_net_failure = paddrp->spp_pathmaxrxt;
3194 }
3195 }
3196 if ((paddrp->spp_hbinterval != 0) && (paddrp->spp_hbinterval != 0xffffffff)) {
3197 /* Just a set */
3198 int old;
3199 if (net) {
3200 net->dest_state &= ~SCTP_ADDR_NOHB;
3201 } else {
3202 old = stcb->asoc.heart_beat_delay;
3203 stcb->asoc.heart_beat_delay = paddrp->spp_hbinterval;
3204 if (old == 0) {
3205 /* Turn back on the timer */
3206 sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
3207 }
3208 }
3209 } else if (paddrp->spp_hbinterval == 0xffffffff) {
3210 /* on demand HB */
3211 sctp_send_hb(stcb, 1, net);
3212 } else {
3213 if (net == NULL) {
3214 /* off on association */
3215 if (stcb->asoc.heart_beat_delay) {
3216 int cnt_of_unconf = 0;
3217 struct sctp_nets *lnet;
3218 TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
3219 if (lnet->dest_state & SCTP_ADDR_UNCONFIRMED) {
3220 cnt_of_unconf++;
3221 }
3222 }
3223 /* stop the timer ONLY if we have no unconfirmed addresses
3224 */
3225 if (cnt_of_unconf == 0)
3226 sctp_timer_stop(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);
3227 }
3228 stcb->asoc.heart_beat_delay = 0;
3229 } else {
3230 net->dest_state |= SCTP_ADDR_NOHB;
3231 }
3232 }
3233 SCTP_TCB_UNLOCK(stcb);
3234 } else {
3235 /* Use endpoint defaults */
3236 SCTP_INP_WLOCK(inp);
3237 if (paddrp->spp_pathmaxrxt)
3238 inp->sctp_ep.def_net_failure = paddrp->spp_pathmaxrxt;
3239 if (paddrp->spp_hbinterval != SCTP_ISSUE_HB)
3240 inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT] = paddrp->spp_hbinterval;
3241 SCTP_INP_WUNLOCK(inp);
3242 }
3243 }
3244 break;
3245 case SCTP_RTOINFO:
3246 {
3247 struct sctp_rtoinfo *srto;
3248 if ((size_t)m->m_len < sizeof(struct sctp_rtoinfo)) {
3249 error = EINVAL;
3250 break;
3251 }
3252 srto = mtod(m, struct sctp_rtoinfo *);
3253 if (srto->srto_assoc_id == 0) {
3254 SCTP_INP_WLOCK(inp);
3255 /* If we have a null asoc, its default for the endpoint */
3256 if (srto->srto_initial > 10)
3257 inp->sctp_ep.initial_rto = srto->srto_initial;
3258 if (srto->srto_max > 10)
3259 inp->sctp_ep.sctp_maxrto = srto->srto_max;
3260 if (srto->srto_min > 10)
3261 inp->sctp_ep.sctp_minrto = srto->srto_min;
3262 SCTP_INP_WUNLOCK(inp);
3263 break;
3264 }
3265 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3266 SCTP_INP_RLOCK(inp);
3267 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3268 if (stcb)
3269 SCTP_TCB_LOCK(stcb);
3270 SCTP_INP_RUNLOCK(inp);
3271 } else
3272 stcb = sctp_findassociation_ep_asocid(inp, srto->srto_assoc_id);
3273 if (stcb == NULL) {
3274 error = EINVAL;
3275 break;
3276 }
3277 /* Set in ms we hope :-) */
3278 if (srto->srto_initial > 10)
3279 stcb->asoc.initial_rto = srto->srto_initial;
3280 if (srto->srto_max > 10)
3281 stcb->asoc.maxrto = srto->srto_max;
3282 if (srto->srto_min > 10)
3283 stcb->asoc.minrto = srto->srto_min;
3284 SCTP_TCB_UNLOCK(stcb);
3285 }
3286 break;
3287 case SCTP_ASSOCINFO:
3288 {
3289 struct sctp_assocparams *sasoc;
3290
3291 if ((size_t)m->m_len < sizeof(struct sctp_assocparams)) {
3292 error = EINVAL;
3293 break;
3294 }
3295 sasoc = mtod(m, struct sctp_assocparams *);
3296 if (sasoc->sasoc_assoc_id) {
3297 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3298 SCTP_INP_RLOCK(inp);
3299 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3300 if (stcb)
3301 SCTP_TCB_LOCK(stcb);
3302 SCTP_INP_RUNLOCK(inp);
3303 } else
3304 stcb = sctp_findassociation_ep_asocid(inp,
3305 sasoc->sasoc_assoc_id);
3306 if (stcb == NULL) {
3307 error = ENOENT;
3308 break;
3309 }
3310
3311 } else {
3312 stcb = NULL;
3313 }
3314 if (stcb) {
3315 if (sasoc->sasoc_asocmaxrxt)
3316 stcb->asoc.max_send_times = sasoc->sasoc_asocmaxrxt;
3317 sasoc->sasoc_number_peer_destinations = stcb->asoc.numnets;
3318 sasoc->sasoc_peer_rwnd = 0;
3319 sasoc->sasoc_local_rwnd = 0;
3320 if (stcb->asoc.cookie_life)
3321 stcb->asoc.cookie_life = sasoc->sasoc_cookie_life;
3322 SCTP_TCB_UNLOCK(stcb);
3323 } else {
3324 SCTP_INP_WLOCK(inp);
3325 if (sasoc->sasoc_asocmaxrxt)
3326 inp->sctp_ep.max_send_times = sasoc->sasoc_asocmaxrxt;
3327 sasoc->sasoc_number_peer_destinations = 0;
3328 sasoc->sasoc_peer_rwnd = 0;
3329 sasoc->sasoc_local_rwnd = 0;
3330 if (sasoc->sasoc_cookie_life)
3331 inp->sctp_ep.def_cookie_life = sasoc->sasoc_cookie_life;
3332 SCTP_INP_WUNLOCK(inp);
3333 }
3334 }
3335 break;
3336 case SCTP_INITMSG:
3337 {
3338 struct sctp_initmsg *sinit;
3339
3340 if ((size_t)m->m_len < sizeof(struct sctp_initmsg)) {
3341 error = EINVAL;
3342 break;
3343 }
3344 sinit = mtod(m, struct sctp_initmsg *);
3345 SCTP_INP_WLOCK(inp);
3346 if (sinit->sinit_num_ostreams)
3347 inp->sctp_ep.pre_open_stream_count = sinit->sinit_num_ostreams;
3348
3349 if (sinit->sinit_max_instreams)
3350 inp->sctp_ep.max_open_streams_intome = sinit->sinit_max_instreams;
3351
3352 if (sinit->sinit_max_attempts)
3353 inp->sctp_ep.max_init_times = sinit->sinit_max_attempts;
3354
3355 if (sinit->sinit_max_init_timeo > 10)
3356 /* We must be at least a 100ms (we set in ticks) */
3357 inp->sctp_ep.initial_init_rto_max = sinit->sinit_max_init_timeo;
3358 SCTP_INP_WUNLOCK(inp);
3359 }
3360 break;
3361 case SCTP_PRIMARY_ADDR:
3362 {
3363 struct sctp_setprim *spa;
3364 struct sctp_nets *net, *lnet;
3365 if ((size_t)m->m_len < sizeof(struct sctp_setprim)) {
3366 error = EINVAL;
3367 break;
3368 }
3369 spa = mtod(m, struct sctp_setprim *);
3370
3371 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3372 SCTP_INP_RLOCK(inp);
3373 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3374 if (stcb) {
3375 SCTP_TCB_LOCK(stcb);
3376 } else {
3377 error = EINVAL;
3378 break;
3379 }
3380 SCTP_INP_RUNLOCK(inp);
3381 } else
3382 stcb = sctp_findassociation_ep_asocid(inp, spa->ssp_assoc_id);
3383 if (stcb == NULL) {
3384 /* One last shot */
3385 SCTP_INP_WLOCK(inp);
3386 SCTP_INP_INCR_REF(inp);
3387 SCTP_INP_WUNLOCK(inp);
3388 stcb = sctp_findassociation_ep_addr(&inp,
3389 (struct sockaddr *)&spa->ssp_addr,
3390 &net, NULL, NULL);
3391 if (stcb == NULL) {
3392 SCTP_INP_WLOCK(inp);
3393 SCTP_INP_DECR_REF(inp);
3394 SCTP_INP_WUNLOCK(inp);
3395 error = EINVAL;
3396 break;
3397 }
3398 } else {
3399 /* find the net, associd or connected lookup type */
3400 net = sctp_findnet(stcb, (struct sockaddr *)&spa->ssp_addr);
3401 if (net == NULL) {
3402 SCTP_TCB_UNLOCK(stcb);
3403 error = EINVAL;
3404 break;
3405 }
3406 }
3407 if ((net != stcb->asoc.primary_destination) &&
3408 (!(net->dest_state & SCTP_ADDR_UNCONFIRMED))) {
3409 /* Ok we need to set it */
3410 lnet = stcb->asoc.primary_destination;
3411 lnet->next_tsn_at_change = net->next_tsn_at_change = stcb->asoc.sending_seq;
3412 if (sctp_set_primary_addr(stcb,
3413 (struct sockaddr *)NULL,
3414 net) == 0) {
3415 if (net->dest_state & SCTP_ADDR_SWITCH_PRIMARY) {
3416 net->dest_state |= SCTP_ADDR_DOUBLE_SWITCH;
3417 }
3418 net->dest_state |= SCTP_ADDR_SWITCH_PRIMARY;
3419 }
3420 }
3421 SCTP_TCB_UNLOCK(stcb);
3422 }
3423 break;
3424
3425 case SCTP_SET_PEER_PRIMARY_ADDR:
3426 {
3427 struct sctp_setpeerprim *sspp;
3428 if ((size_t)m->m_len < sizeof(struct sctp_setpeerprim)) {
3429 error = EINVAL;
3430 break;
3431 }
3432 sspp = mtod(m, struct sctp_setpeerprim *);
3433
3434
3435 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3436 SCTP_INP_RLOCK(inp);
3437 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3438 if (stcb)
3439 SCTP_TCB_UNLOCK(stcb);
3440 SCTP_INP_RUNLOCK(inp);
3441 } else
3442 stcb = sctp_findassociation_ep_asocid(inp, sspp->sspp_assoc_id);
3443 if (stcb == NULL) {
3444 error = EINVAL;
3445 break;
3446 }
3447 if (sctp_set_primary_ip_address_sa(stcb, (struct sockaddr *)&sspp->sspp_addr) != 0) {
3448 error = EINVAL;
3449 }
3450 SCTP_TCB_UNLOCK(stcb);
3451 }
3452 break;
3453 case SCTP_BINDX_ADD_ADDR:
3454 {
3455 struct sctp_getaddresses *addrs;
3456 struct sockaddr *addr_touse;
3457 struct sockaddr_in sin;
3458 /* see if we're bound all already! */
3459 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
3460 error = EINVAL;
3461 break;
3462 }
3463 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
3464 error = EINVAL;
3465 break;
3466 }
3467 addrs = mtod(m, struct sctp_getaddresses *);
3468 addr_touse = addrs->addr;
3469 if (addrs->addr->sa_family == AF_INET6) {
3470 struct sockaddr_in6 *sin6;
3471 sin6 = (struct sockaddr_in6 *)addr_touse;
3472 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
3473 in6_sin6_2_sin(&sin, sin6);
3474 addr_touse = (struct sockaddr *)&sin;
3475 }
3476 }
3477 if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
3478 if (p == NULL) {
3479 /* Can't get proc for Net/Open BSD */
3480 error = EINVAL;
3481 break;
3482 }
3483 error = sctp_inpcb_bind(so, addr_touse, p);
3484 break;
3485 }
3486 /* No locks required here since bind and mgmt_ep_sa all
3487 * do their own locking. If we do something for the FIX:
3488 * below we may need to lock in that case.
3489 */
3490 if (addrs->sget_assoc_id == 0) {
3491 /* add the address */
3492 struct sctp_inpcb *lep;
3493 ((struct sockaddr_in *)addr_touse)->sin_port = inp->sctp_lport;
3494 lep = sctp_pcb_findep(addr_touse, 1, 0);
3495 if (lep != NULL) {
3496 /* We must decrement the refcount
3497 * since we have the ep already and
3498 * are binding. No remove going on
3499 * here.
3500 */
3501 SCTP_INP_WLOCK(inp);
3502 SCTP_INP_DECR_REF(inp);
3503 SCTP_INP_WUNLOCK(inp);
3504 }
3505 if (lep == inp) {
3506 /* already bound to it.. ok */
3507 break;
3508 } else if (lep == NULL) {
3509 ((struct sockaddr_in *)addr_touse)->sin_port = 0;
3510 error = sctp_addr_mgmt_ep_sa(inp, addr_touse,
3511 SCTP_ADD_IP_ADDRESS);
3512 } else {
3513 error = EADDRNOTAVAIL;
3514 }
3515 if (error)
3516 break;
3517
3518 } else {
3519 /* FIX: decide whether we allow assoc based bindx */
3520 }
3521 }
3522 break;
3523 case SCTP_BINDX_REM_ADDR:
3524 {
3525 struct sctp_getaddresses *addrs;
3526 struct sockaddr *addr_touse;
3527 struct sockaddr_in sin;
3528 /* see if we're bound all already! */
3529 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
3530 error = EINVAL;
3531 break;
3532 }
3533 if ((size_t)m->m_len < sizeof(struct sctp_getaddresses)) {
3534 error = EINVAL;
3535 break;
3536 }
3537 addrs = mtod(m, struct sctp_getaddresses *);
3538 addr_touse = addrs->addr;
3539 if (addrs->addr->sa_family == AF_INET6) {
3540 struct sockaddr_in6 *sin6;
3541 sin6 = (struct sockaddr_in6 *)addr_touse;
3542 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
3543 in6_sin6_2_sin(&sin, sin6);
3544 addr_touse = (struct sockaddr *)&sin;
3545 }
3546 }
3547 /* No lock required mgmt_ep_sa does its own locking. If
3548 * the FIX: below is ever changed we may need to
3549 * lock before calling association level binding.
3550 */
3551 if (addrs->sget_assoc_id == 0) {
3552 /* delete the address */
3553 sctp_addr_mgmt_ep_sa(inp, addr_touse,
3554 SCTP_DEL_IP_ADDRESS);
3555 } else {
3556 /* FIX: decide whether we allow assoc based bindx */
3557 }
3558 }
3559 break;
3560 default:
3561 error = ENOPROTOOPT;
3562 break;
3563 } /* end switch (opt) */
3564 return (error);
3565 }
3566
3567
3568 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
3569 int
3570 sctp_ctloutput(struct socket *so, struct sockopt *sopt)
3571 {
3572 struct mbuf *m = NULL;
3573 struct sctp_inpcb *inp;
3574 int error;
3575
3576 inp = (struct sctp_inpcb *)so->so_pcb;
3577 crit_enter();
3578 if (inp == 0) {
3579 crit_exit();
3580 /* I made the same as TCP since we are not setup? */
3581 return (ECONNRESET);
3582 }
3583 if (sopt->sopt_level != IPPROTO_SCTP) {
3584 /* wrong proto level... send back up to IP */
3585 #ifdef INET6
3586 if (INP_CHECK_SOCKAF(so, AF_INET6))
3587 error = ip6_ctloutput(so, sopt);
3588 else
3589 #endif /* INET6 */
3590 error = ip_ctloutput(so, sopt);
3591 crit_exit();
3592 return (error);
3593 }
3594 if (sopt->sopt_valsize > MCLBYTES) {
3595 /*
3596 * Restrict us down to a cluster size, that's all we can
3597 * pass either way...
3598 */
3599 sopt->sopt_valsize = MCLBYTES;
3600 }
3601 if (sopt->sopt_valsize) {
3602
3603 m = m_get(MB_WAIT, MT_DATA);
3604 if (sopt->sopt_valsize > MLEN) {
3605 MCLGET(m, MB_DONTWAIT);
3606 if ((m->m_flags & M_EXT) == 0) {
3607 sctp_m_freem(m);
3608 crit_exit();
3609 return (ENOBUFS);
3610 }
3611 }
3612 error = sooptcopyin(sopt, mtod(m, caddr_t), sopt->sopt_valsize,
3613 sopt->sopt_valsize);
3614 if (error) {
3615 m_free(m);
3616 goto out;
3617 }
3618 m->m_len = sopt->sopt_valsize;
3619 }
3620 if (sopt->sopt_dir == SOPT_SET) {
3621 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3622 error = sctp_optsset(so, sopt->sopt_name, &m, sopt->sopt_td);
3623 #else
3624 error = sctp_optsset(so, sopt->sopt_name, &m, sopt->sopt_p);
3625 #endif
3626 } else if (sopt->sopt_dir == SOPT_GET) {
3627 #if (defined (__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3628 error = sctp_optsget(so, sopt->sopt_name, &m, sopt->sopt_td);
3629 #else
3630 error = sctp_optsget(so, sopt->sopt_name, &m, sopt->sopt_p);
3631 #endif
3632 } else {
3633 error = EINVAL;
3634 }
3635 if ( (error == 0) && (m != NULL)) {
3636 error = sooptcopyout(sopt, mtod(m, caddr_t), m->m_len);
3637 sctp_m_freem(m);
3638 } else if (m != NULL) {
3639 sctp_m_freem(m);
3640 }
3641 out:
3642 crit_exit();
3643 return (error);
3644 }
3645
3646 #else
3647 /* NetBSD and OpenBSD */
3648 int
3649 sctp_ctloutput(int op, struct socket *so, int level, int optname,
3650 struct mbuf **mp)
3651 {
3652 int s, error;
3653 struct inpcb *inp;
3654 #ifdef INET6
3655 struct in6pcb *in6p;
3656 #endif
3657 int family; /* family of the socket */
3658
3659 family = so->so_proto->pr_domain->dom_family;
3660 error = 0;
3661 crit_exit();
3662 switch (family) {
3663 case PF_INET:
3664 inp = sotoinpcb(so);
3665 #ifdef INET6
3666 in6p = NULL;
3667 #endif
3668 break;
3669 #ifdef INET6
3670 case PF_INET6:
3671 inp = NULL;
3672 in6p = sotoin6pcb(so);
3673 break;
3674 #endif
3675 default:
3676 crit_exit();
3677 return EAFNOSUPPORT;
3678 }
3679 #ifndef INET6
3680 if (inp == NULL)
3681 #else
3682 if (inp == NULL && in6p == NULL)
3683 #endif
3684 {
3685 crit_exit();
3686 if (op == PRCO_SETOPT && *mp)
3687 m_free(*mp);
3688 return (ECONNRESET);
3689 }
3690 if (level != IPPROTO_SCTP) {
3691 switch (family) {
3692 case PF_INET:
3693 error = ip_ctloutput(op, so, level, optname, mp);
3694 break;
3695 #ifdef INET6
3696 case PF_INET6:
3697 error = ip6_ctloutput(op, so, level, optname, mp);
3698 break;
3699 #endif
3700 }
3701 crit_exit();
3702 return (error);
3703 }
3704 /* Ok if we reach here it is a SCTP option we hope */
3705 if (op == PRCO_SETOPT) {
3706 error = sctp_optsset(so, optname, mp, (struct proc *)NULL);
3707 if (*mp)
3708 m_free(*mp);
3709 } else if (op == PRCO_GETOPT) {
3710 error = sctp_optsget(so, optname, mp, (struct proc *)NULL);
3711 } else {
3712 error = EINVAL;
3713 }
3714 crit_exit();
3715 return (error);
3716 }
3717
3718 #endif
3719
3720 static int
3721 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3722 sctp_connect(struct socket *so, struct sockaddr *addr, struct thread *p)
3723 {
3724 #else
3725 #if defined(__FreeBSD__) || defined(__APPLE__)
3726 sctp_connect(struct socket *so, struct sockaddr *addr, struct proc *p)
3727 {
3728 #else
3729 sctp_connect(struct socket *so, struct mbuf *nam, struct proc *p)
3730 {
3731 struct sockaddr *addr = mtod(nam, struct sockaddr *);
3732 #endif
3733 #endif
3734 int error = 0;
3735 struct sctp_inpcb *inp;
3736 struct sctp_tcb *stcb;
3737
3738 #ifdef SCTP_DEBUG
3739 if (sctp_debug_on & SCTP_DEBUG_PCB1) {
3740 kprintf("Connect called in SCTP to ");
3741 sctp_print_address(addr);
3742 kprintf("Port %d\n", ntohs(((struct sockaddr_in *)addr)->sin_port));
3743 }
3744 #endif /* SCTP_DEBUG */
3745 crit_enter();
3746 inp = (struct sctp_inpcb *)so->so_pcb;
3747 if (inp == 0) {
3748 crit_exit();
3749 /* I made the same as TCP since we are not setup? */
3750 return (ECONNRESET);
3751 }
3752 SCTP_ASOC_CREATE_LOCK(inp);
3753 SCTP_INP_WLOCK(inp);
3754 if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||
3755 (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {
3756 /* Should I really unlock ? */
3757 SCTP_INP_WUNLOCK(inp);
3758 SCTP_ASOC_CREATE_UNLOCK(inp);
3759 crit_exit();
3760 return (EFAULT);
3761 }
3762 #ifdef INET6
3763 if (((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) &&
3764 (addr->sa_family == AF_INET6)) {
3765 SCTP_INP_WUNLOCK(inp);
3766 SCTP_ASOC_CREATE_UNLOCK(inp);
3767 crit_exit();
3768 return (EINVAL);
3769 }
3770 #endif /* INET6 */
3771 if ((inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) ==
3772 SCTP_PCB_FLAGS_UNBOUND) {
3773 /* Bind a ephemeral port */
3774 SCTP_INP_WUNLOCK(inp);
3775 error = sctp_inpcb_bind(so, NULL, p);
3776 if (error) {
3777 SCTP_ASOC_CREATE_UNLOCK(inp);
3778 crit_exit();
3779 return (error);
3780 }
3781 SCTP_INP_WLOCK(inp);
3782 }
3783 /* Now do we connect? */
3784 if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
3785 (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
3786 /* We are already connected AND the TCP model */
3787 crit_exit();
3788 SCTP_INP_WUNLOCK(inp);
3789 SCTP_ASOC_CREATE_UNLOCK(inp);
3790 return (EADDRINUSE);
3791 }
3792 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
3793 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3794 if (stcb)
3795 SCTP_TCB_UNLOCK(stcb);
3796 SCTP_INP_WUNLOCK(inp);
3797 } else {
3798 SCTP_INP_INCR_REF(inp);
3799 SCTP_INP_WUNLOCK(inp);
3800 stcb = sctp_findassociation_ep_addr(&inp, addr, NULL, NULL, NULL);
3801 if (stcb == NULL) {
3802 SCTP_INP_WLOCK(inp);
3803 SCTP_INP_DECR_REF(inp);
3804 SCTP_INP_WUNLOCK(inp);
3805 }
3806 }
3807 if (stcb != NULL) {
3808 /* Already have or am bring up an association */
3809 SCTP_ASOC_CREATE_UNLOCK(inp);
3810 SCTP_TCB_UNLOCK(stcb);
3811 crit_exit();
3812 return (EALREADY);
3813 }
3814 /* We are GOOD to go */
3815 stcb = sctp_aloc_assoc(inp, addr, 1, &error, 0);
3816 if (stcb == NULL) {
3817 /* Gak! no memory */
3818 crit_exit();
3819 return (error);
3820 }
3821 if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) {
3822 stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_CONNECTED;
3823 /* Set the connected flag so we can queue data */
3824 soisconnecting(so);
3825 }
3826 stcb->asoc.state = SCTP_STATE_COOKIE_WAIT;
3827 SCTP_GETTIME_TIMEVAL(&stcb->asoc.time_entered);
3828 sctp_send_initiate(inp, stcb);
3829 SCTP_ASOC_CREATE_UNLOCK(inp);
3830 SCTP_TCB_UNLOCK(stcb);
3831 crit_exit();
3832 return error;
3833 }
3834
3835 int
3836 sctp_usr_recvd(struct socket *so, int flags)
3837 {
3838 struct sctp_socket_q_list *sq=NULL;
3839 /*
3840 * The user has received some data, we may be able to stuff more
3841 * up the socket. And we need to possibly update the rwnd.
3842 */
3843 struct sctp_inpcb *inp;
3844 struct sctp_tcb *stcb=NULL;
3845
3846 inp = (struct sctp_inpcb *)so->so_pcb;
3847 #ifdef SCTP_DEBUG
3848 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3849 kprintf("Read for so:%x inp:%x Flags:%x\n",
3850 (u_int)so, (u_int)inp, (u_int)flags);
3851 #endif
3852
3853 if (inp == 0) {
3854 /* I made the same as TCP since we are not setup? */
3855 #ifdef SCTP_DEBUG
3856 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3857 kprintf("Nope, connection reset\n");
3858 #endif
3859 return (ECONNRESET);
3860 }
3861 crit_enter();
3862 /*
3863 * Grab the first one on the list. It will re-insert itself if
3864 * it runs out of room
3865 */
3866 SCTP_INP_WLOCK(inp);
3867 if ((flags & MSG_EOR) && ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0)
3868 && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3869 /* Ok the other part of our grubby tracking
3870 * stuff for our horrible layer violation that
3871 * the tsvwg thinks is ok for sctp_peeloff.. gak!
3872 * We must update the next vtag pending on the
3873 * socket buffer (if any).
3874 */
3875 inp->sctp_vtag_first = sctp_get_first_vtag_from_sb(so);
3876 sq = TAILQ_FIRST(&inp->sctp_queue_list);
3877 if (sq) {
3878 stcb = sq->tcb;
3879 } else {
3880 stcb = NULL;
3881 }
3882 } else {
3883 stcb = LIST_FIRST(&inp->sctp_asoc_list);
3884 }
3885 if (stcb)
3886 SCTP_TCB_LOCK(stcb);
3887 if (stcb) {
3888 long incr;
3889 /* all code in normal stcb path assumes
3890 * that you have a tcb_lock only. Thus
3891 * we must release the inp write lock.
3892 */
3893 if (flags & MSG_EOR) {
3894 if (((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0)
3895 && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3896 stcb = sctp_remove_from_socket_q(inp);
3897 }
3898 #ifdef SCTP_DEBUG
3899 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3900 kprintf("remove from socket queue for inp:%x tcbret:%x\n",
3901 (u_int)inp, (u_int)stcb);
3902 #endif
3903
3904 stcb->asoc.my_rwnd_control_len = sctp_sbspace_sub(stcb->asoc.my_rwnd_control_len,
3905 sizeof(struct mbuf));
3906 if (inp->sctp_flags & SCTP_PCB_FLAGS_RECVDATAIOEVNT) {
3907 stcb->asoc.my_rwnd_control_len = sctp_sbspace_sub(stcb->asoc.my_rwnd_control_len,
3908 CMSG_LEN(sizeof(struct sctp_sndrcvinfo)));
3909 }
3910 }
3911 if ((TAILQ_EMPTY(&stcb->asoc.delivery_queue) == 0) ||
3912 (TAILQ_EMPTY(&stcb->asoc.reasmqueue) == 0)) {
3913 /* Deliver if there is something to be delivered */
3914 sctp_service_queues(stcb, &stcb->asoc, 1);
3915 }
3916 sctp_set_rwnd(stcb, &stcb->asoc);
3917 /* if we increase by 1 or more MTU's (smallest MTUs of all
3918 * nets) we send a window update sack
3919 */
3920 incr = stcb->asoc.my_rwnd - stcb->asoc.my_last_reported_rwnd;
3921 if (incr < 0) {
3922 incr = 0;
3923 }
3924 if (((uint32_t)incr >= (stcb->asoc.smallest_mtu * SCTP_SEG_TO_RWND_UPD)) ||
3925 ((((uint32_t)incr)*SCTP_SCALE_OF_RWND_TO_UPD) >= so->so_rcv.ssb_hiwat)) {
3926 if (callout_pending(&stcb->asoc.dack_timer.timer)) {
3927 /* If the timer is up, stop it */
3928 sctp_timer_stop(SCTP_TIMER_TYPE_RECV,
3929 stcb->sctp_ep, stcb, NULL);
3930 }
3931 /* Send the sack, with the new rwnd */
3932 sctp_send_sack(stcb);
3933 /* Now do the output */
3934 sctp_chunk_output(inp, stcb, 10);
3935 }
3936 } else {
3937 if ((( sq ) && (flags & MSG_EOR) && ((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0))
3938 && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3939 stcb = sctp_remove_from_socket_q(inp);
3940 }
3941 }
3942 SOCKBUF_LOCK(&so->so_rcv);
3943 if (( so->so_rcv.ssb_mb == NULL ) &&
3944 (TAILQ_EMPTY(&inp->sctp_queue_list) == 0)) {
3945 int sq_cnt=0;
3946 #ifdef SCTP_DEBUG
3947 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3948 kprintf("Something off, inp:%x so->so_rcv->ssb_mb is empty and sockq is not.. cleaning\n",
3949 (u_int)inp);
3950 #endif
3951 if (((inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) == 0)
3952 && ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
3953 int done_yet;
3954 done_yet = TAILQ_EMPTY(&inp->sctp_queue_list);
3955 while (!done_yet) {
3956 sq_cnt++;
3957 sctp_remove_from_socket_q(inp);
3958 done_yet = TAILQ_EMPTY(&inp->sctp_queue_list);
3959 }
3960 }
3961 #ifdef SCTP_DEBUG
3962 if (sctp_debug_on & SCTP_DEBUG_USRREQ2)
3963 kprintf("Cleaned up %d sockq's\n", sq_cnt);
3964 #endif
3965 }
3966 SOCKBUF_UNLOCK(&so->so_rcv);
3967 if (stcb)
3968 SCTP_TCB_UNLOCK(stcb);
3969 SCTP_INP_WUNLOCK(inp);
3970 crit_exit();
3971 return (0);
3972 }
3973
3974 int
3975 #if (defined(__FreeBSD__) && __FreeBSD_version >= 500000) || defined(__DragonFly__)
3976 sctp_listen(struct socket *so, struct thread *p)
3977 #else
3978 sctp_listen(struct socket *so, struct proc *p)
3979 #endif
3980 {
3981 /*
3982 * Note this module depends on the protocol processing being
3983 * called AFTER any socket level flags and backlog are applied
3984 * to the socket. The traditional way that the socket flags are
3985 * applied is AFTER protocol processing. We have made a change
3986 * to the sys/kern/uipc_socket.c module to reverse this but this
3987 * MUST be in place if the socket API for SCTP is to work properly.
3988 */
3989 int error = 0;
3990 struct sctp_inpcb *inp;
3991
3992 crit_enter();
3993 inp = (struct sctp_inpcb *)so->so_pcb;
3994 if (inp == 0) {
3995 crit_exit();
3996 /* I made the same as TCP since we are not setup? */
3997 return (ECONNRESET);
3998 }
3999 SCTP_INP_RLOCK(inp);
4000 if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&
4001 (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED)) {
4002 /* We are already connected AND the TCP model */
4003 crit_exit();
4004 SCTP_INP_RUNLOCK(inp);
4005 return (EADDRINUSE);
4006 }
4007 if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {
4008 /* We must do a bind. */
4009 SCTP_INP_RUNLOCK(inp);
4010 if ((error = sctp_inpcb_bind(so, NULL, p))) {
4011 /* bind error, probably perm */
4012 crit_exit();
4013 return (error);
4014 }
4015 } else {
4016 SCTP_INP_RUNLOCK(inp);
4017 }
4018 SOCK_LOCK(so);
4019 SCTP_INP_WLOCK(inp);
4020 if (inp->sctp_socket->so_qlimit) {
4021 if (inp->sctp_flags & SCTP_PCB_FLAGS_UDPTYPE) {
4022 /*
4023 * For the UDP model we must TURN OFF the ACCEPT
4024 * flags since we do NOT allow the accept() call.
4025 * The TCP model (when present) will do accept which
4026 * then prohibits connect().
4027 */
4028 inp->sctp_socket->so_options &= ~SO_ACCEPTCONN;
4029 }
4030 inp->sctp_flags |= SCTP_PCB_FLAGS_ACCEPTING;
4031 } else {
4032 if (inp->sctp_flags & SCTP_PCB_FLAGS_ACCEPTING) {
4033 /*
4034 * Turning off the listen flags if the backlog is
4035 * set to 0 (i.e. qlimit is 0).
4036 */
4037 inp->sctp_flags &= ~SCTP_PCB_FLAGS_ACCEPTING;
4038 }
4039 inp->sctp_socket->so_options &= ~SO_ACCEPTCONN;
4040 }
4041 SCTP_INP_WUNLOCK(inp);
4042 SOCK_UNLOCK(so);
4043 crit_exit();
4044 return (error);
4045 }
4046
4047 int
4048 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4049 sctp_accept(struct socket *so, struct sockaddr **addr)
4050 {
4051 #else
4052 sctp_accept(struct socket *so, struct mbuf *nam)
4053 {
4054 struct sockaddr *addr = mtod(nam, struct sockaddr *);
4055 #endif
4056 struct sctp_tcb *stcb;
4057 struct sockaddr *prim;
4058 struct sctp_inpcb *inp;
4059
4060 crit_enter();
4061 inp = (struct sctp_inpcb *)so->so_pcb;
4062
4063 if (inp == 0) {
4064 crit_exit();
4065 return (ECONNRESET);
4066 }
4067 SCTP_INP_RLOCK(inp);
4068 if (so->so_state & SS_ISDISCONNECTED) {
4069 crit_exit();
4070 SCTP_INP_RUNLOCK(inp);
4071 return (ECONNABORTED);
4072 }
4073 stcb = LIST_FIRST(&inp->sctp_asoc_list);
4074 if (stcb == NULL) {
4075 crit_exit();
4076 SCTP_INP_RUNLOCK(inp);
4077 return (ECONNRESET);
4078 }
4079 SCTP_TCB_LOCK(stcb);
4080 SCTP_INP_RUNLOCK(inp);
4081 prim = (struct sockaddr *)&stcb->asoc.primary_destination->ro._l_addr;
4082 if (prim->sa_family == AF_INET) {
4083 struct sockaddr_in *sin;
4084 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4085 MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME,
4086 M_WAITOK | M_ZERO);
4087 #else
4088 sin = (struct sockaddr_in *)addr;
4089 bzero((caddr_t)sin, sizeof (*sin));
4090 #endif
4091 sin->sin_family = AF_INET;
4092 sin->sin_len = sizeof(*sin);
4093 sin->sin_port = ((struct sockaddr_in *)prim)->sin_port;
4094 sin->sin_addr = ((struct sockaddr_in *)prim)->sin_addr;
4095 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4096 *addr = (struct sockaddr *)sin;
4097 #else
4098 nam->m_len = sizeof(*sin);
4099 #endif
4100 } else {
4101 struct sockaddr_in6 *sin6;
4102 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4103 MALLOC(sin6, struct sockaddr_in6 *, sizeof *sin6, M_SONAME,
4104 M_WAITOK | M_ZERO);
4105 #else
4106 sin6 = (struct sockaddr_in6 *)addr;
4107 #endif
4108 bzero((caddr_t)sin6, sizeof (*sin6));
4109 sin6->sin6_family = AF_INET6;
4110 sin6->sin6_len = sizeof(*sin6);
4111 sin6->sin6_port = ((struct sockaddr_in6 *)prim)->sin6_port;
4112
4113 sin6->sin6_addr = ((struct sockaddr_in6 *)prim)->sin6_addr;
4114 if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr))
4115 /* sin6->sin6_scope_id = ntohs(sin6->sin6_addr.s6_addr16[1]);*/
4116 in6_recoverscope(sin6, &sin6->sin6_addr, NULL); /* skip ifp check */
4117 else
4118 sin6->sin6_scope_id = 0; /*XXX*/
4119 #if defined(__FreeBSD__) || defined (__APPLE__) || defined(__DragonFly__)
4120 *addr= (struct sockaddr *)sin6;
4121 #else
4122 nam->m_len = sizeof(*sin6);
4123 #endif
4124 }
4125 /* Wake any delayed sleep action */
4126 SCTP_TCB_UNLOCK(stcb);
4127 SCTP_INP_WLOCK(inp);
4128 if (inp->sctp_flags & SCTP_PCB_FLAGS_DONT_WAKE) {
4129 inp->sctp_flags &= ~SCTP_PCB_FLAGS_DONT_WAKE;
4130 if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEOUTPUT) {
4131 inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEOUTPUT;
4132 #if defined(__NetBSD__)
4133 if (sowritable(inp->sctp_socket))
4134 sowwakeup(inp->sctp_socket);
4135 #else
4136 if (sowriteable(inp->sctp_socket))
4137 sowwakeup(inp->sctp_socket);
4138 #endif
4139 }
4140 if (inp->sctp_flags & SCTP_PCB_FLAGS_WAKEINPUT) {
4141 inp->sctp_flags &= ~SCTP_PCB_FLAGS_WAKEINPUT;
4142 if (soreadable(inp->sctp_socket))
4143 sorwakeup(inp->sctp_socket);
4144 }
4145
4146 }
4147 SCTP_INP_WUNLOCK(inp);
4148 crit_exit();
4149 return (0);
4150 }
4151
4152 int
4153 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4154 sctp_ingetaddr(struct socket *so, struct sockaddr **addr)
4155 #else
4156 sctp_ingetaddr(struct socket *so, struct mbuf *nam)
4157 #endif
4158 {
4159 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4160 struct sockaddr_in *sin;
4161 #else
4162 struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
4163 #endif
4164 struct sctp_inpcb *inp;
4165 /*
4166 * Do the malloc first in case it blocks.
4167 */
4168 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4169 MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, M_WAITOK |
4170 M_ZERO);
4171 #else
4172 nam->m_len = sizeof(*sin);
4173 memset(sin, 0, sizeof(*sin));
4174 #endif
4175 sin->sin_family = AF_INET;
4176 sin->sin_len = sizeof(*sin);
4177 crit_enter();
4178 inp = (struct sctp_inpcb *)so->so_pcb;
4179 if (!inp) {
4180 crit_exit();
4181 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4182 FREE(sin, M_SONAME);
4183 #endif
4184 return ECONNRESET;
4185 }
4186 SCTP_INP_RLOCK(inp);
4187 sin->sin_port = inp->sctp_lport;
4188 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {
4189 if (inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) {
4190 struct sctp_tcb *stcb;
4191 struct sockaddr_in *sin_a;
4192 struct sctp_nets *net;
4193 int fnd;
4194
4195 stcb = LIST_FIRST(&inp->sctp_asoc_list);
4196 if (stcb == NULL) {
4197 goto notConn;
4198 }
4199 fnd = 0;
4200 sin_a = NULL;
4201 SCTP_TCB_LOCK(stcb);
4202 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
4203 sin_a = (struct sockaddr_in *)&net->ro._l_addr;
4204 if (sin_a->sin_family == AF_INET) {
4205 fnd = 1;
4206 break;
4207 }
4208 }
4209 if ((!fnd) || (sin_a == NULL)) {
4210 /* punt */
4211 SCTP_TCB_UNLOCK(stcb);
4212 goto notConn;
4213 }
4214 sin->sin_addr = sctp_ipv4_source_address_selection(inp,
4215 stcb, (struct route *)&net->ro, net, 0);
4216 SCTP_TCB_UNLOCK(stcb);
4217 } else {
4218 /* For the bound all case you get back 0 */
4219 notConn:
4220 sin->sin_addr.s_addr = 0;
4221 }
4222
4223 } else {
4224 /* Take the first IPv4 address in the list */
4225 struct sctp_laddr *laddr;
4226 int fnd = 0;
4227 LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {
4228 if (laddr->ifa->ifa_addr->sa_family == AF_INET) {
4229 struct sockaddr_in *sin_a;
4230 sin_a = (struct sockaddr_in *)laddr->ifa->ifa_addr;
4231 sin->sin_addr = sin_a->sin_addr;
4232 fnd = 1;
4233 break;
4234 }
4235 }
4236 if (!fnd) {
4237 crit_exit();
4238 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4239 FREE(sin, M_SONAME);
4240 #endif
4241 SCTP_INP_RUNLOCK(inp);
4242 return ENOENT;
4243 }
4244 }
4245 SCTP_INP_RUNLOCK(inp);
4246 crit_exit();
4247 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4248 (*addr) = (struct sockaddr *)sin;
4249 #endif
4250 return (0);
4251 }
4252
4253 int
4254 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4255 sctp_peeraddr(struct socket *so, struct sockaddr **addr)
4256 {
4257 struct sockaddr_in *sin = (struct sockaddr_in *)*addr;
4258 #else
4259 sctp_peeraddr(struct socket *so, struct mbuf *nam)
4260 {
4261 struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
4262 #endif
4263 int fnd;
4264 struct sockaddr_in *sin_a;
4265 struct sctp_inpcb *inp;
4266 struct sctp_tcb *stcb;
4267 struct sctp_nets *net;
4268
4269 /* Do the malloc first in case it blocks. */
4270 inp = (struct sctp_inpcb *)so->so_pcb;
4271 if ((inp == NULL) ||
4272 ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0)) {
4273 /* UDP type and listeners will drop out here */
4274 return (ENOTCONN);
4275 }
4276 crit_enter();
4277
4278 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4279 MALLOC(sin, struct sockaddr_in *, sizeof *sin, M_SONAME, M_WAITOK |
4280 M_ZERO);
4281 #else
4282 nam->m_len = sizeof(*sin);
4283 memset(sin, 0, sizeof(*sin));
4284 #endif
4285 sin->sin_family = AF_INET;
4286 sin->sin_len = sizeof(*sin);
4287
4288 /* We must recapture incase we blocked */
4289 inp = (struct sctp_inpcb *)so->so_pcb;
4290 if (!inp) {
4291 crit_exit();
4292 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4293 FREE(sin, M_SONAME);
4294 #endif
4295 return ECONNRESET;
4296 }
4297 SCTP_INP_RLOCK(inp);
4298 stcb = LIST_FIRST(&inp->sctp_asoc_list);
4299 if (stcb)
4300 SCTP_TCB_LOCK(stcb);
4301 SCTP_INP_RUNLOCK(inp);
4302 if (stcb == NULL) {
4303 crit_exit();
4304 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4305 FREE(sin, M_SONAME);
4306 #endif
4307 return ECONNRESET;
4308 }
4309 fnd = 0;
4310 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
4311 sin_a = (struct sockaddr_in *)&net->ro._l_addr;
4312 if (sin_a->sin_family == AF_INET) {
4313 fnd = 1;
4314 sin->sin_port = stcb->rport;
4315 sin->sin_addr = sin_a->sin_addr;
4316 break;
4317 }
4318 }
4319 SCTP_TCB_UNLOCK(stcb);
4320 if (!fnd) {
4321 /* No IPv4 address */
4322 crit_exit();
4323 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4324 FREE(sin, M_SONAME);
4325 #endif
4326 return ENOENT;
4327 }
4328 crit_exit();
4329 return (0);
4330 }
4331
4332 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
4333 struct pr_usrreqs sctp_usrreqs = {
4334 .pru_abort = sctp_abort,
4335 .pru_accept = sctp_accept,
4336 .pru_attach = sctp_attach,
4337 .pru_bind = sctp_bind,
4338 .pru_connect = sctp_connect,
4339 .pru_connect2 = pru_connect2_notsupp,
4340 .pru_control = in_control,
4341 .pru_detach = sctp_detach,
4342 .pru_disconnect = sctp_disconnect,
4343 .pru_listen = sctp_listen,
4344 .pru_peeraddr = sctp_peeraddr,
4345 .pru_rcvd = sctp_usr_recvd,
4346 .pru_rcvoob = pru_rcvoob_notsupp,
4347 .pru_send = sctp_send,
4348 .pru_sense = pru_sense_null,
4349 .pru_shutdown = sctp_shutdown,
4350 .pru_sockaddr = sctp_ingetaddr,
4351 .pru_sosend = sctp_sosend,
4352 .pru_soreceive = soreceive,
4353 .pru_sopoll = sopoll
4354 };
4355
4356 #else
4357 #if defined(__NetBSD__)
4358 int
4359 sctp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
4360 struct mbuf *control, struct proc *p)
4361 {
4362 #else
4363 int
4364 sctp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
4365 struct mbuf *control)
4366 {
4367 struct proc *p = curproc;
4368 #endif
4369 int error = 0;
4370 int family;
4371
4372 family = so->so_proto->pr_domain->dom_family;
4373
4374 crit_enter();
4375 if (req == PRU_CONTROL) {
4376 switch (family) {
4377 case PF_INET:
4378 error = in_control(so, (long)m, (caddr_t)nam,
4379 (struct ifnet *)control
4380 #if defined(__NetBSD__)
4381 , p
4382 #endif
4383 );
4384 break;
4385 #ifdef INET6
4386 case PF_INET6:
4387 error = in6_control(so, (long)m, (caddr_t)nam,
4388 (struct ifnet *)control, p);
4389 break;
4390 #endif
4391 default:
4392 error = EAFNOSUPPORT;
4393 }
4394 crit_exit();
4395 return (error);
4396 }
4397 #ifdef __NetBSD__
4398 if (req == PRU_PURGEIF) {
4399 struct ifnet *ifn;
4400 struct ifaddr *ifa;
4401 ifn = (struct ifnet *)control;
4402 TAILQ_FOREACH(ifa, &ifn->if_addrlist, ifa_list) {
4403 if (ifa->ifa_addr->sa_family == family) {
4404 sctp_delete_ip_address(ifa);
4405 }
4406 }
4407 switch (family) {
4408 case PF_INET:
4409 in_purgeif (ifn);
4410 break;
4411 #ifdef INET6
4412 case PF_INET6:
4413 in6_purgeif (ifn);
4414 break;
4415 #endif /* INET6 */
4416 default:
4417 crit_exit();
4418 return (EAFNOSUPPORT);
4419 }
4420 crit_exit();
4421 return (0);
4422 }
4423 #endif
4424 switch (req) {
4425 case PRU_ATTACH:
4426 error = sctp_attach(so, family, p);
4427 break;
4428 case PRU_DETACH:
4429 error = sctp_detach(so);
4430 break;
4431 case PRU_BIND:
4432 if (nam == NULL) {
4433 crit_exit();
4434 return (EINVAL);
4435 }
4436 error = sctp_bind(so, nam, p);
4437 break;
4438 case PRU_LISTEN:
4439 error = sctp_listen(so, p);
4440 break;
4441 case PRU_CONNECT:
4442 if (nam == NULL) {
4443 crit_exit();
4444 return (EINVAL);
4445 }
4446 error = sctp_connect(so, nam, p);
4447 break;
4448 case PRU_DISCONNECT:
4449 error = sctp_disconnect(so);
4450 break;
4451 case PRU_ACCEPT:
4452 if (nam == NULL) {
4453 crit_exit();
4454 return (EINVAL);
4455 }
4456 error = sctp_accept(so, nam);
4457 break;
4458 case PRU_SHUTDOWN:
4459 error = sctp_shutdown(so);
4460 break;
4461
4462 case PRU_RCVD:
4463 /*
4464 * For Open and Net BSD, this is real
4465 * ugly. The mbuf *nam that is passed
4466 * (by soreceive()) is the int flags c
4467 * ast as a (mbuf *) yuck!
4468 */
4469 error = sctp_usr_recvd(so, (int)((long)nam));
4470 break;
4471
4472 case PRU_SEND:
4473 /* Flags are ignored */
4474 #ifdef SCTP_DEBUG
4475 if (sctp_debug_on & SCTP_DEBUG_USRREQ1) {
4476 kprintf("Send called on V4 side\n");
4477 }
4478 #endif
4479 {
4480 struct sockaddr *addr;
4481 if (nam == NULL)
4482 addr = NULL;
4483 else
4484 addr = mtod(nam, struct sockaddr *);
4485
4486 error = sctp_send(so, 0, m, addr, control, p);
4487 }
4488 break;
4489 case PRU_ABORT:
4490 error = sctp_abort(so);
4491 break;
4492
4493 case PRU_SENSE:
4494 error = 0;
4495 break;
4496 case PRU_RCVOOB:
4497 error = EAFNOSUPPORT;
4498 break;
4499 case PRU_SENDOOB:
4500 error = EAFNOSUPPORT;
4501 break;
4502 case PRU_PEERADDR:
4503 error = sctp_peeraddr(so, nam);
4504 break;
4505 case PRU_SOCKADDR:
4506 error = sctp_ingetaddr(so, nam);
4507 break;
4508 case PRU_SLOWTIMO:
4509 error = 0;
4510 break;
4511 default:
4512 break;
4513 }
4514 crit_exit();
4515 return (error);
4516 }
4517 #endif
4518
4519 /* #if defined(__NetBSD__) || defined(__OpenBSD__) */
4520 #if __OpenBSD__
4521 /*
4522 * Sysctl for sctp variables.
4523 */
4524 int
4525 sctp_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
4526 size_t newlen)
4527 {
4528
4529 /* All sysctl names at this level are terminal. */
4530 if (namelen != 1)
4531 return (ENOTDIR);
4532 sysctl_int();
4533
4534 switch (name[0]) {
4535 case SCTPCTL_MAXDGRAM:
4536 return (sysctl_int(oldp, oldlenp, newp, newlen,
4537 &sctp_sendspace));
4538 case SCTPCTL_RECVSPACE:
4539 return (sysctl_int(oldp, oldlenp, newp, newlen,
4540 &sctp_recvspace));
4541 case SCTPCTL_AUTOASCONF:
4542 return (sysctl_int(oldp, oldlenp, newp, newlen,
4543 &sctp_auto_asconf));
4544 case SCTPCTL_ECN_ENABLE:
4545 return (sysctl_int(oldp, oldlenp, newp, newlen,
4546 &sctp_ecn));
4547 case SCTPCTL_ECN_NONCE:
4548 return (sysctl_int(oldp, oldlenp, newp, newlen,
4549 &sctp_ecn_nonce));
4550 case SCTPCTL_STRICT_SACK:
4551 return (sysctl_int(oldp, oldlenp, newp, newlen,
4552 &sctp_strict_sacks));
4553 case SCTPCTL_NOCSUM_LO:
4554 return (sysctl_int(oldp, oldlenp, newp, newlen,
4555 &sctp_no_csum_on_loopback));
4556 case SCTPCTL_STRICT_INIT:
4557 return (sysctl_int(oldp, oldlenp, newp, newlen,
4558 &sctp_strict_init));
4559 case SCTPCTL_PEER_CHK_OH:
4560 return (sysctl_int(oldp, oldlenp, newp, newlen,
4561 &sctp_peer_chunk_oh));
4562 case SCTPCTL_MAXBURST:
4563 return (sysctl_int(oldp, oldlenp, newp, newlen,
4564 &sctp_max_burst_default));
4565 case SCTPCTL_MAXCHUNKONQ:
4566 return (sysctl_int(oldp, oldlenp, newp, newlen,
4567 &sctp_max_chunks_on_queue));
4568 case SCTPCTL_DELAYED_SACK:
4569 return (sysctl_int(oldp, oldlenp, newp, newlen,
4570 &sctp_delayed_sack_time_default));
4571 case SCTPCTL_HB_INTERVAL:
4572 return (sysctl_int(oldp, oldlenp, newp, newlen,
4573 &sctp_heartbeat_interval_default));
4574 case SCTPCTL_PMTU_RAISE:
4575 return (sysctl_int(oldp, oldlenp, newp, newlen,
4576 &sctp_pmtu_raise_time_default));
4577 case SCTPCTL_SHUTDOWN_GUARD:
4578 return (sysctl_int(oldp, oldlenp, newp, newlen,
4579 &sctp_shutdown_guard_time_default));
4580 case SCTPCTL_SECRET_LIFETIME:
4581 return (sysctl_int(oldp, oldlenp, newp, newlen,
4582 &sctp_secret_lifetime_default));
4583 case SCTPCTL_RTO_MAX:
4584 return (sysctl_int(oldp, oldlenp, newp, newlen,
4585 &sctp_rto_max_default));
4586 case SCTPCTL_RTO_MIN:
4587 return (sysctl_int(oldp, oldlenp, newp, newlen,
4588 &sctp_rto_min_default));
4589 case SCTPCTL_RTO_INITIAL:
4590 return (sysctl_int(oldp, oldlenp, newp, newlen,
4591 &sctp_rto_initial_default));
4592 case SCTPCTL_INIT_RTO_MAX:
4593 return (sysctl_int(oldp, oldlenp, newp, newlen,
4594 &sctp_init_rto_max_default));
4595 case SCTPCTL_COOKIE_LIFE:
4596 return (sysctl_int(oldp, oldlenp, newp, newlen,
4597 &sctp_valid_cookie_life_default));
4598 case SCTPCTL_INIT_RTX_MAX:
4599 return (sysctl_int(oldp, oldlenp, newp, newlen,
4600 &sctp_init_rtx_max_default));
4601 case SCTPCTL_ASSOC_RTX_MAX:
4602 return (sysctl_int(oldp, oldlenp, newp, newlen,
4603 &sctp_assoc_rtx_max_default));
4604 case SCTPCTL_PATH_RTX_MAX:
4605 return (sysctl_int(oldp, oldlenp, newp, newlen,
4606 &sctp_path_rtx_max_default));
4607 case SCTPCTL_NR_OUTGOING_STREAMS:
4608 return (sysctl_int(oldp, oldlenp, newp, newlen,
4609 &sctp_nr_outgoing_streams_default));
4610 #ifdef SCTP_DEBUG
4611 case SCTPCTL_DEBUG:
4612 return (sysctl_int(oldp, oldlenp, newp, newlen,
4613 &sctp_debug_on));
4614 #endif
4615 default:
4616 return (ENOPROTOOPT);
4617 }
4618 /* NOTREACHED */
4619 }
4620 #endif
4621 #if __NetBSD__
4622 /*
4623 * Sysctl for sctp variables.
4624 */
4625 SYSCTL_SETUP(sysctl_net_inet_sctp_setup, "sysctl net.inet.sctp subtree setup")
4626 {
4627
4628 sysctl_createv(clog, 0, NULL, NULL,
4629 CTLFLAG_PERMANENT,
4630 CTLTYPE_NODE, "net", NULL,
4631 NULL, 0, NULL, 0,
4632 CTL_NET, CTL_EOL);
4633 sysctl_createv(clog, 0, NULL, NULL,
4634 CTLFLAG_PERMANENT,
4635 CTLTYPE_NODE, "inet", NULL,
4636 NULL, 0, NULL, 0,
4637 CTL_NET, PF_INET, CTL_EOL);
4638 sysctl_createv(clog, 0, NULL, NULL,
4639 CTLFLAG_PERMANENT,
4640 CTLTYPE_NODE, "sctp",
4641 SYSCTL_DESCR("sctp related settings"),
4642 NULL, 0, NULL, 0,
4643 CTL_NET, PF_INET, IPPROTO_SCTP, CTL_EOL);
4644
4645 sysctl_createv(clog, 0, NULL, NULL,
4646 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4647 CTLTYPE_INT, "maxdgram",
4648 SYSCTL_DESCR("Maximum outgoing SCTP buffer size"),
4649 NULL, 0, &sctp_sendspace, 0,
4650 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_MAXDGRAM,
4651 CTL_EOL);
4652
4653 sysctl_createv(clog, 0, NULL, NULL,
4654 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4655 CTLTYPE_INT, "recvspace",
4656 SYSCTL_DESCR("Maximum incoming SCTP buffer size"),
4657 NULL, 0, &sctp_recvspace, 0,
4658 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_RECVSPACE,
4659 CTL_EOL);
4660
4661 sysctl_createv(clog, 0, NULL, NULL,
4662 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4663 CTLTYPE_INT, "autoasconf",
4664 SYSCTL_DESCR("Enable SCTP Auto-ASCONF"),
4665 NULL, 0, &sctp_auto_asconf, 0,
4666 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_AUTOASCONF,
4667 CTL_EOL);
4668
4669 sysctl_createv(clog, 0, NULL, NULL,
4670 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4671 CTLTYPE_INT, "ecn_enable",
4672 SYSCTL_DESCR("Enable SCTP ECN"),
4673 NULL, 0, &sctp_ecn, 0,
4674 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_ECN_ENABLE,
4675 CTL_EOL);
4676
4677 sysctl_createv(clog, 0, NULL, NULL,
4678 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4679 CTLTYPE_INT, "ecn_nonce",
4680 SYSCTL_DESCR("Enable SCTP ECN Nonce"),
4681 NULL, 0, &sctp_ecn_nonce, 0,
4682 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_ECN_NONCE,
4683 CTL_EOL);
4684
4685 sysctl_createv(clog, 0, NULL, NULL,
4686 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4687 CTLTYPE_INT, "strict_sack",
4688 SYSCTL_DESCR("Enable SCTP Strict SACK checking"),
4689 NULL, 0, &sctp_strict_sacks, 0,
4690 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_STRICT_SACK,
4691 CTL_EOL);
4692
4693 sysctl_createv(clog, 0, NULL, NULL,
4694 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4695 CTLTYPE_INT, "loopback_nocsum",
4696 SYSCTL_DESCR("Enable NO Csum on packets sent on loopback"),
4697 NULL, 0, &sctp_no_csum_on_loopback, 0,
4698 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_NOCSUM_LO,
4699 CTL_EOL);
4700
4701 sysctl_createv(clog, 0, NULL, NULL,
4702 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4703 CTLTYPE_INT, "strict_init",
4704 SYSCTL_DESCR("Enable strict INIT/INIT-ACK singleton enforcement"),
4705 NULL, 0, &sctp_strict_init, 0,
4706 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_STRICT_INIT,
4707 CTL_EOL);
4708
4709 sysctl_createv(clog, 0, NULL, NULL,
4710 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4711 CTLTYPE_INT, "peer_chkoh",
4712 SYSCTL_DESCR("Amount to debit peers rwnd per chunk sent"),
4713 NULL, 0, &sctp_peer_chunk_oh, 0,
4714 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_PEER_CHK_OH,
4715 CTL_EOL);
4716
4717 sysctl_createv(clog, 0, NULL, NULL,
4718 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4719 CTLTYPE_INT, "maxburst",
4720 SYSCTL_DESCR("Default max burst for sctp endpoints"),
4721 NULL, 0, &sctp_max_burst_default, 0,
4722 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_MAXBURST,
4723 CTL_EOL);
4724
4725 sysctl_createv(clog, 0, NULL, NULL,
4726 CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
4727 CTLTYPE_INT, "maxchunks",
4728 SYSCTL_DESCR("Default max chunks on queue per asoc"),
4729 NULL, 0, &sctp_max_chunks_on_queue, 0,
4730 CTL_NET, PF_INET, IPPROTO_SCTP, SCTPCTL_MAXCHUNKONQ,
4731 CTL_EOL);
4732
4733 }
4734 #endif
DragonFly BSD