1 /*- 2 * Copyright (c) 1982, 1986, 1988, 1990, 1993 3 * The Regents of the University of California. 4 * Copyright (c) 2004 The FreeBSD Foundation 5 * Copyright (c) 2004-2008 Robert N. M. Watson 6 * Copyright (c) 2009-2010 Brad Penoff 7 * Copyright (c) 2009-2010 Humaira Kamal 8 * Copyright (c) 2011-2012 Irene Ruengeler 9 * Copyright (c) 2011-2012 Michael Tuexen 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 */ 34 35 #include <netinet/sctp_os.h> 36 #include <netinet/sctp_pcb.h> 37 #include <netinet/sctputil.h> 38 #include <netinet/sctp_var.h> 39 #include <netinet/sctp_sysctl.h> 40 #include <netinet/sctp_input.h> 41 #include <netinet/sctp_peeloff.h> 42 #ifdef INET6 43 #include <netinet6/sctp6_var.h> 44 #endif 45 #if defined(__Userspace_os_Linux) 46 #define __FAVOR_BSD /* (on Ubuntu at least) enables UDP header field names like BSD in RFC 768 */ 47 #endif 48 #if !defined (__Userspace_os_Windows) 49 #if defined INET || defined INET6 50 #include <netinet/udp.h> 51 #endif 52 #include <arpa/inet.h> 53 #else 54 #include <user_socketvar.h> 55 #endif 56 userland_mutex_t accept_mtx; 57 userland_cond_t accept_cond; 58 #ifdef _WIN32 59 #include <time.h> 60 #include <sys/timeb.h> 61 #endif 62 63 MALLOC_DEFINE(M_PCB, "sctp_pcb", "sctp pcb"); 64 MALLOC_DEFINE(M_SONAME, "sctp_soname", "sctp soname"); 65 #define MAXLEN_MBUF_CHAIN 32 66 67 /* Prototypes */ 68 extern int sctp_sosend(struct socket *so, struct sockaddr *addr, struct uio *uio, 69 struct mbuf *top, struct mbuf *control, int flags, 70 /* proc is a dummy in __Userspace__ and will not be passed to sctp_lower_sosend */ struct proc *p); 71 72 extern int sctp_attach(struct socket *so, int proto, uint32_t vrf_id); 73 extern int sctpconn_attach(struct socket *so, int proto, uint32_t vrf_id); 74 75 void 76 usrsctp_init(uint16_t port, 77 int (*conn_output)(void *addr, void *buffer, size_t length, uint8_t tos, uint8_t set_df), 78 void (*debug_printf)(const char *format, ...)) 79 { 80 sctp_init(port, conn_output, debug_printf); 81 } 82 83 84 /* Taken from usr/src/sys/kern/uipc_sockbuf.c and modified for __Userspace__*/ 85 /* 86 * Socantsendmore indicates that no more data will be sent on the socket; it 87 * would normally be applied to a socket when the user informs the system 88 * that no more data is to be sent, by the protocol code (in case 89 * PRU_SHUTDOWN). Socantrcvmore indicates that no more data will be 90 * received, and will normally be applied to the socket by a protocol when it 91 * detects that the peer will send no more data. Data queued for reading in 92 * the socket may yet be read. 93 */ 94 95 void socantrcvmore_locked(struct socket *so) 96 { 97 SOCKBUF_LOCK_ASSERT(&so->so_rcv); 98 so->so_rcv.sb_state |= SBS_CANTRCVMORE; 99 sorwakeup_locked(so); 100 } 101 102 void socantrcvmore(struct socket *so) 103 { 104 SOCKBUF_LOCK(&so->so_rcv); 105 socantrcvmore_locked(so); 106 } 107 108 void 109 socantsendmore_locked(struct socket *so) 110 { 111 SOCKBUF_LOCK_ASSERT(&so->so_snd); 112 so->so_snd.sb_state |= SBS_CANTSENDMORE; 113 sowwakeup_locked(so); 114 } 115 116 void 117 socantsendmore(struct socket *so) 118 { 119 SOCKBUF_LOCK(&so->so_snd); 120 socantsendmore_locked(so); 121 } 122 123 124 125 /* Taken from usr/src/sys/kern/uipc_sockbuf.c and called within sctp_lower_sosend. 126 */ 127 int 128 sbwait(struct sockbuf *sb) 129 { 130 #if defined(__Userspace__) /* __Userspace__ */ 131 132 SOCKBUF_LOCK_ASSERT(sb); 133 134 sb->sb_flags |= SB_WAIT; 135 #if defined (__Userspace_os_Windows) 136 if (SleepConditionVariableCS(&(sb->sb_cond), &(sb->sb_mtx), INFINITE)) 137 return 0; 138 else 139 return -1; 140 #else 141 return (pthread_cond_wait(&(sb->sb_cond), &(sb->sb_mtx))); 142 #endif 143 144 #else 145 SOCKBUF_LOCK_ASSERT(sb); 146 147 sb->sb_flags |= SB_WAIT; 148 return (msleep(&sb->sb_cc, &sb->sb_mtx, 149 (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sbwait", 150 sb->sb_timeo)); 151 #endif 152 } 153 154 155 156 157 /* Taken from /src/sys/kern/uipc_socket.c 158 * and modified for __Userspace__ 159 */ 160 static struct socket * 161 soalloc(void) 162 { 163 struct socket *so; 164 165 /* 166 * soalloc() sets of socket layer state for a socket, 167 * called only by socreate() and sonewconn(). 168 * 169 * sodealloc() tears down socket layer state for a socket, 170 * called only by sofree() and sonewconn(). 171 * __Userspace__ TODO : Make sure so is properly deallocated 172 * when tearing down the connection. 173 */ 174 175 so = (struct socket *)malloc(sizeof(struct socket)); 176 177 if (so == NULL) { 178 return (NULL); 179 } 180 memset(so, 0, sizeof(struct socket)); 181 182 /* __Userspace__ Initializing the socket locks here */ 183 SOCKBUF_LOCK_INIT(&so->so_snd, "so_snd"); 184 SOCKBUF_LOCK_INIT(&so->so_rcv, "so_rcv"); 185 SOCKBUF_COND_INIT(&so->so_snd); 186 SOCKBUF_COND_INIT(&so->so_rcv); 187 SOCK_COND_INIT(so); /* timeo_cond */ 188 189 /* __Userspace__ Any ref counting required here? Will we have any use for aiojobq? 190 What about gencnt and numopensockets?*/ 191 TAILQ_INIT(&so->so_aiojobq); 192 return (so); 193 } 194 195 static void 196 sodealloc(struct socket *so) 197 { 198 199 KASSERT(so->so_count == 0, ("sodealloc(): so_count %d", so->so_count)); 200 KASSERT(so->so_pcb == NULL, ("sodealloc(): so_pcb != NULL")); 201 202 SOCKBUF_COND_DESTROY(&so->so_snd); 203 SOCKBUF_COND_DESTROY(&so->so_rcv); 204 205 SOCK_COND_DESTROY(so); 206 207 SOCKBUF_LOCK_DESTROY(&so->so_snd); 208 SOCKBUF_LOCK_DESTROY(&so->so_rcv); 209 210 free(so); 211 } 212 213 /* Taken from /src/sys/kern/uipc_socket.c 214 * and modified for __Userspace__ 215 */ 216 void 217 sofree(struct socket *so) 218 { 219 struct socket *head; 220 221 ACCEPT_LOCK_ASSERT(); 222 SOCK_LOCK_ASSERT(so); 223 /* SS_NOFDREF unset in accept call. this condition seems irrelevent 224 * for __Userspace__... 225 */ 226 if (so->so_count != 0 || 227 (so->so_state & SS_PROTOREF) || (so->so_qstate & SQ_COMP)) { 228 SOCK_UNLOCK(so); 229 ACCEPT_UNLOCK(); 230 return; 231 } 232 head = so->so_head; 233 if (head != NULL) { 234 KASSERT((so->so_qstate & SQ_COMP) != 0 || 235 (so->so_qstate & SQ_INCOMP) != 0, 236 ("sofree: so_head != NULL, but neither SQ_COMP nor " 237 "SQ_INCOMP")); 238 KASSERT((so->so_qstate & SQ_COMP) == 0 || 239 (so->so_qstate & SQ_INCOMP) == 0, 240 ("sofree: so->so_qstate is SQ_COMP and also SQ_INCOMP")); 241 TAILQ_REMOVE(&head->so_incomp, so, so_list); 242 head->so_incqlen--; 243 so->so_qstate &= ~SQ_INCOMP; 244 so->so_head = NULL; 245 } 246 KASSERT((so->so_qstate & SQ_COMP) == 0 && 247 (so->so_qstate & SQ_INCOMP) == 0, 248 ("sofree: so_head == NULL, but still SQ_COMP(%d) or SQ_INCOMP(%d)", 249 so->so_qstate & SQ_COMP, so->so_qstate & SQ_INCOMP)); 250 if (so->so_options & SCTP_SO_ACCEPTCONN) { 251 KASSERT((TAILQ_EMPTY(&so->so_comp)), ("sofree: so_comp populated")); 252 KASSERT((TAILQ_EMPTY(&so->so_incomp)), ("sofree: so_comp populated")); 253 } 254 SOCK_UNLOCK(so); 255 ACCEPT_UNLOCK(); 256 sctp_close(so); /* was... sctp_detach(so); */ 257 /* 258 * From this point on, we assume that no other references to this 259 * socket exist anywhere else in the stack. Therefore, no locks need 260 * to be acquired or held. 261 * 262 * We used to do a lot of socket buffer and socket locking here, as 263 * well as invoke sorflush() and perform wakeups. The direct call to 264 * dom_dispose() and sbrelease_internal() are an inlining of what was 265 * necessary from sorflush(). 266 * 267 * Notice that the socket buffer and kqueue state are torn down 268 * before calling pru_detach. This means that protocols shold not 269 * assume they can perform socket wakeups, etc, in their detach code. 270 */ 271 sodealloc(so); 272 } 273 274 275 276 /* Taken from /src/sys/kern/uipc_socket.c */ 277 int 278 soabort(so) 279 struct socket *so; 280 { 281 int error; 282 #if defined(INET6) 283 struct sctp_inpcb *inp; 284 #endif 285 286 #if defined(INET6) 287 inp = (struct sctp_inpcb *)so->so_pcb; 288 if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { 289 error = sctp6_abort(so); 290 } else { 291 #if defined(INET) 292 error = sctp_abort(so); 293 #else 294 error = EAFNOSUPPORT; 295 #endif 296 } 297 #elif defined(INET) 298 error = sctp_abort(so); 299 #else 300 error = EAFNOSUPPORT; 301 #endif 302 if (error) { 303 sofree(so); 304 return error; 305 } 306 return (0); 307 } 308 309 310 /* Taken from usr/src/sys/kern/uipc_socket.c and called within sctp_connect (sctp_usrreq.c). 311 * We use sctp_connect for send_one_init_real in ms1. 312 */ 313 void 314 soisconnecting(struct socket *so) 315 { 316 317 SOCK_LOCK(so); 318 so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING); 319 so->so_state |= SS_ISCONNECTING; 320 SOCK_UNLOCK(so); 321 } 322 323 /* Taken from usr/src/sys/kern/uipc_socket.c and called within sctp_disconnect (sctp_usrreq.c). 324 * TODO Do we use sctp_disconnect? 325 */ 326 void 327 soisdisconnecting(struct socket *so) 328 { 329 330 /* 331 * Note: This code assumes that SOCK_LOCK(so) and 332 * SOCKBUF_LOCK(&so->so_rcv) are the same. 333 */ 334 SOCKBUF_LOCK(&so->so_rcv); 335 so->so_state &= ~SS_ISCONNECTING; 336 so->so_state |= SS_ISDISCONNECTING; 337 so->so_rcv.sb_state |= SBS_CANTRCVMORE; 338 sorwakeup_locked(so); 339 SOCKBUF_LOCK(&so->so_snd); 340 so->so_snd.sb_state |= SBS_CANTSENDMORE; 341 sowwakeup_locked(so); 342 wakeup("dummy",so); 343 /* requires 2 args but this was in orig */ 344 /* wakeup(&so->so_timeo); */ 345 } 346 347 348 /* Taken from sys/kern/kern_synch.c and 349 modified for __Userspace__ 350 */ 351 352 /* 353 * Make all threads sleeping on the specified identifier runnable. 354 * Associating wakeup with so_timeo identifier and timeo_cond 355 * condition variable. TODO. If we use iterator thread then we need to 356 * modify wakeup so it can distinguish between iterator identifier and 357 * timeo identifier. 358 */ 359 void 360 wakeup(ident, so) 361 void *ident; 362 struct socket *so; 363 { 364 SOCK_LOCK(so); 365 #if defined (__Userspace_os_Windows) 366 WakeAllConditionVariable(&(so)->timeo_cond); 367 #else 368 pthread_cond_broadcast(&(so)->timeo_cond); 369 #endif 370 SOCK_UNLOCK(so); 371 } 372 373 374 /* 375 * Make a thread sleeping on the specified identifier runnable. 376 * May wake more than one thread if a target thread is currently 377 * swapped out. 378 */ 379 void 380 wakeup_one(ident) 381 void *ident; 382 { 383 /* __Userspace__ Check: We are using accept_cond for wakeup_one. 384 It seems that wakeup_one is only called within 385 soisconnected() and sonewconn() with ident &head->so_timeo 386 head is so->so_head, which is back pointer to listen socket 387 This seems to indicate that the use of accept_cond is correct 388 since socket where accepts occur is so_head in all 389 subsidiary sockets. 390 */ 391 ACCEPT_LOCK(); 392 #if defined (__Userspace_os_Windows) 393 WakeAllConditionVariable(&accept_cond); 394 #else 395 pthread_cond_broadcast(&accept_cond); 396 #endif 397 ACCEPT_UNLOCK(); 398 } 399 400 401 /* Called within sctp_process_cookie_[existing/new] */ 402 void 403 soisconnected(struct socket *so) 404 { 405 struct socket *head; 406 407 ACCEPT_LOCK(); 408 SOCK_LOCK(so); 409 so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING); 410 so->so_state |= SS_ISCONNECTED; 411 head = so->so_head; 412 if (head != NULL && (so->so_qstate & SQ_INCOMP)) { 413 SOCK_UNLOCK(so); 414 TAILQ_REMOVE(&head->so_incomp, so, so_list); 415 head->so_incqlen--; 416 so->so_qstate &= ~SQ_INCOMP; 417 TAILQ_INSERT_TAIL(&head->so_comp, so, so_list); 418 head->so_qlen++; 419 so->so_qstate |= SQ_COMP; 420 ACCEPT_UNLOCK(); 421 sorwakeup(head); 422 wakeup_one(&head->so_timeo); 423 return; 424 } 425 SOCK_UNLOCK(so); 426 ACCEPT_UNLOCK(); 427 wakeup(&so->so_timeo, so); 428 sorwakeup(so); 429 sowwakeup(so); 430 431 } 432 433 /* called within sctp_handle_cookie_echo */ 434 435 struct socket * 436 sonewconn(struct socket *head, int connstatus) 437 { 438 struct socket *so; 439 int over; 440 441 ACCEPT_LOCK(); 442 over = (head->so_qlen > 3 * head->so_qlimit / 2); 443 ACCEPT_UNLOCK(); 444 #ifdef REGRESSION 445 if (regression_sonewconn_earlytest && over) 446 #else 447 if (over) 448 #endif 449 return (NULL); 450 so = soalloc(); 451 if (so == NULL) 452 return (NULL); 453 so->so_head = head; 454 so->so_type = head->so_type; 455 so->so_options = head->so_options &~ SCTP_SO_ACCEPTCONN; 456 so->so_linger = head->so_linger; 457 so->so_state = head->so_state | SS_NOFDREF; 458 so->so_dom = head->so_dom; 459 #ifdef MAC 460 SOCK_LOCK(head); 461 mac_create_socket_from_socket(head, so); 462 SOCK_UNLOCK(head); 463 #endif 464 if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat)) { 465 sodealloc(so); 466 return (NULL); 467 } 468 switch (head->so_dom) { 469 #ifdef INET 470 case AF_INET: 471 if (sctp_attach(so, IPPROTO_SCTP, SCTP_DEFAULT_VRFID)) { 472 sodealloc(so); 473 return (NULL); 474 } 475 break; 476 #endif 477 #ifdef INET6 478 case AF_INET6: 479 if (sctp6_attach(so, IPPROTO_SCTP, SCTP_DEFAULT_VRFID)) { 480 sodealloc(so); 481 return (NULL); 482 } 483 break; 484 #endif 485 case AF_CONN: 486 if (sctpconn_attach(so, IPPROTO_SCTP, SCTP_DEFAULT_VRFID)) { 487 sodealloc(so); 488 return (NULL); 489 } 490 break; 491 default: 492 sodealloc(so); 493 return (NULL); 494 break; 495 } 496 so->so_rcv.sb_lowat = head->so_rcv.sb_lowat; 497 so->so_snd.sb_lowat = head->so_snd.sb_lowat; 498 so->so_rcv.sb_timeo = head->so_rcv.sb_timeo; 499 so->so_snd.sb_timeo = head->so_snd.sb_timeo; 500 so->so_rcv.sb_flags |= head->so_rcv.sb_flags & SB_AUTOSIZE; 501 so->so_snd.sb_flags |= head->so_snd.sb_flags & SB_AUTOSIZE; 502 so->so_state |= connstatus; 503 ACCEPT_LOCK(); 504 if (connstatus) { 505 TAILQ_INSERT_TAIL(&head->so_comp, so, so_list); 506 so->so_qstate |= SQ_COMP; 507 head->so_qlen++; 508 } else { 509 /* 510 * Keep removing sockets from the head until there's room for 511 * us to insert on the tail. In pre-locking revisions, this 512 * was a simple if(), but as we could be racing with other 513 * threads and soabort() requires dropping locks, we must 514 * loop waiting for the condition to be true. 515 */ 516 while (head->so_incqlen > head->so_qlimit) { 517 struct socket *sp; 518 sp = TAILQ_FIRST(&head->so_incomp); 519 TAILQ_REMOVE(&head->so_incomp, sp, so_list); 520 head->so_incqlen--; 521 sp->so_qstate &= ~SQ_INCOMP; 522 sp->so_head = NULL; 523 ACCEPT_UNLOCK(); 524 soabort(sp); 525 ACCEPT_LOCK(); 526 } 527 TAILQ_INSERT_TAIL(&head->so_incomp, so, so_list); 528 so->so_qstate |= SQ_INCOMP; 529 head->so_incqlen++; 530 } 531 ACCEPT_UNLOCK(); 532 if (connstatus) { 533 sorwakeup(head); 534 wakeup_one(&head->so_timeo); 535 } 536 return (so); 537 538 } 539 540 /* From /src/sys/sys/sysproto.h */ 541 struct sctp_generic_sendmsg_args { 542 int sd; 543 caddr_t msg; 544 int mlen; 545 caddr_t to; 546 socklen_t tolen; /* was __socklen_t */ 547 struct sctp_sndrcvinfo * sinfo; 548 int flags; 549 }; 550 551 struct sctp_generic_recvmsg_args { 552 int sd; 553 struct iovec *iov; 554 int iovlen; 555 struct sockaddr *from; 556 socklen_t *fromlenaddr; /* was __socklen_t */ 557 struct sctp_sndrcvinfo *sinfo; 558 int *msg_flags; 559 }; 560 561 562 /* 563 Source: /src/sys/gnu/fs/xfs/FreeBSD/xfs_ioctl.c 564 */ 565 static __inline__ int 566 copy_to_user(void *dst, void *src, int len) { 567 memcpy(dst, src, len); 568 return 0; 569 } 570 571 static __inline__ int 572 copy_from_user(void *dst, void *src, int len) { 573 memcpy(dst, src, len); 574 return 0; 575 } 576 577 /* 578 References: 579 src/sys/dev/lmc/if_lmc.h: 580 src/sys/powerpc/powerpc/copyinout.c 581 src/sys/sys/systm.h 582 */ 583 # define copyin(u, k, len) copy_from_user(k, u, len) 584 585 /* References: 586 src/sys/powerpc/powerpc/copyinout.c 587 src/sys/sys/systm.h 588 */ 589 # define copyout(k, u, len) copy_to_user(u, k, len) 590 591 592 /* copyiniov definition copied/modified from src/sys/kern/kern_subr.c */ 593 int 594 copyiniov(struct iovec *iovp, u_int iovcnt, struct iovec **iov, int error) 595 { 596 u_int iovlen; 597 598 *iov = NULL; 599 if (iovcnt > UIO_MAXIOV) 600 return (error); 601 iovlen = iovcnt * sizeof (struct iovec); 602 *iov = malloc(iovlen); /*, M_IOV, M_WAITOK); */ 603 error = copyin(iovp, *iov, iovlen); 604 if (error) { 605 free(*iov); /*, M_IOV); */ 606 *iov = NULL; 607 } 608 return (error); 609 } 610 611 /* (__Userspace__) version of uiomove */ 612 int 613 uiomove(void *cp, int n, struct uio *uio) 614 { 615 struct iovec *iov; 616 int cnt; 617 int error = 0; 618 619 if ((uio->uio_rw != UIO_READ) && 620 (uio->uio_rw != UIO_WRITE)) { 621 return (EINVAL); 622 } 623 624 while (n > 0 && uio->uio_resid) { 625 iov = uio->uio_iov; 626 cnt = iov->iov_len; 627 if (cnt == 0) { 628 uio->uio_iov++; 629 uio->uio_iovcnt--; 630 continue; 631 } 632 if (cnt > n) 633 cnt = n; 634 635 switch (uio->uio_segflg) { 636 637 case UIO_USERSPACE: 638 if (uio->uio_rw == UIO_READ) 639 error = copyout(cp, iov->iov_base, cnt); 640 else 641 error = copyin(iov->iov_base, cp, cnt); 642 if (error) 643 goto out; 644 break; 645 646 case UIO_SYSSPACE: 647 if (uio->uio_rw == UIO_READ) 648 bcopy(cp, iov->iov_base, cnt); 649 else 650 bcopy(iov->iov_base, cp, cnt); 651 break; 652 } 653 iov->iov_base = (char *)iov->iov_base + cnt; 654 iov->iov_len -= cnt; 655 uio->uio_resid -= cnt; 656 uio->uio_offset += cnt; 657 cp = (char *)cp + cnt; 658 n -= cnt; 659 } 660 out: 661 return (error); 662 } 663 664 665 /* Source: src/sys/kern/uipc_syscalls.c */ 666 int 667 getsockaddr(namp, uaddr, len) 668 struct sockaddr **namp; 669 caddr_t uaddr; 670 size_t len; 671 { 672 struct sockaddr *sa; 673 int error; 674 675 if (len > SOCK_MAXADDRLEN) 676 return (ENAMETOOLONG); 677 if (len < offsetof(struct sockaddr, sa_data)) 678 return (EINVAL); 679 MALLOC(sa, struct sockaddr *, len, M_SONAME, M_WAITOK); 680 error = copyin(uaddr, sa, len); 681 if (error) { 682 FREE(sa, M_SONAME); 683 } else { 684 #ifdef HAVE_SA_LEN 685 sa->sa_len = len; 686 #endif 687 *namp = sa; 688 } 689 return (error); 690 } 691 692 693 /* Taken from /src/lib/libc/net/sctp_sys_calls.c 694 * and modified for __Userspace__ 695 * calling sctp_generic_sendmsg from this function 696 */ 697 ssize_t 698 userspace_sctp_sendmsg(struct socket *so, 699 const void *data, 700 size_t len, 701 struct sockaddr *to, 702 socklen_t tolen, 703 u_int32_t ppid, 704 u_int32_t flags, 705 u_int16_t stream_no, 706 u_int32_t timetolive, 707 u_int32_t context) 708 { 709 struct sctp_sndrcvinfo sndrcvinfo, *sinfo = &sndrcvinfo; 710 struct uio auio; 711 struct iovec iov[1]; 712 713 memset(sinfo, 0, sizeof(struct sctp_sndrcvinfo)); 714 sinfo->sinfo_ppid = ppid; 715 sinfo->sinfo_flags = flags; 716 sinfo->sinfo_stream = stream_no; 717 sinfo->sinfo_timetolive = timetolive; 718 sinfo->sinfo_context = context; 719 sinfo->sinfo_assoc_id = 0; 720 721 722 /* Perform error checks on destination (to) */ 723 if (tolen > SOCK_MAXADDRLEN){ 724 errno = ENAMETOOLONG; 725 return (-1); 726 } 727 if ((tolen > 0) && 728 ((to == NULL) || (tolen < (socklen_t)sizeof(struct sockaddr)))) { 729 errno = EINVAL; 730 return (-1); 731 } 732 /* Adding the following as part of defensive programming, in case the application 733 does not do it when preparing the destination address.*/ 734 #ifdef HAVE_SA_LEN 735 if (to != NULL) { 736 to->sa_len = tolen; 737 } 738 #endif 739 740 iov[0].iov_base = (caddr_t)data; 741 iov[0].iov_len = len; 742 743 auio.uio_iov = iov; 744 auio.uio_iovcnt = 1; 745 auio.uio_segflg = UIO_USERSPACE; 746 auio.uio_rw = UIO_WRITE; 747 auio.uio_offset = 0; /* XXX */ 748 auio.uio_resid = len; 749 errno = sctp_lower_sosend(so, to, &auio, NULL, NULL, 0, sinfo); 750 if (errno == 0) { 751 return (len - auio.uio_resid); 752 } else { 753 return (-1); 754 } 755 } 756 757 758 ssize_t 759 usrsctp_sendv(struct socket *so, 760 const void *data, 761 size_t len, 762 struct sockaddr *to, 763 int addrcnt, 764 void *info, 765 socklen_t infolen, 766 unsigned int infotype, 767 int flags) 768 { 769 struct sctp_sndrcvinfo sinfo; 770 struct uio auio; 771 struct iovec iov[1]; 772 int use_sinfo; 773 774 if (so == NULL) { 775 errno = EBADF; 776 return (-1); 777 } 778 memset(&sinfo, 0, sizeof(struct sctp_sndrcvinfo)); 779 use_sinfo = 0; 780 switch (infotype) { 781 case SCTP_SENDV_NOINFO: 782 if ((infolen != 0) || (info != NULL)) { 783 errno = EINVAL; 784 return (-1); 785 } 786 break; 787 case SCTP_SENDV_SNDINFO: 788 if ((info == NULL) || (infolen != sizeof(struct sctp_sndinfo))) { 789 errno = EINVAL; 790 return (-1); 791 } 792 sinfo.sinfo_stream = ((struct sctp_sndinfo *)info)->snd_sid; 793 sinfo.sinfo_flags = ((struct sctp_sndinfo *)info)->snd_flags; 794 sinfo.sinfo_ppid = ((struct sctp_sndinfo *)info)->snd_ppid; 795 sinfo.sinfo_context = ((struct sctp_sndinfo *)info)->snd_context; 796 sinfo.sinfo_assoc_id = ((struct sctp_sndinfo *)info)->snd_assoc_id; 797 use_sinfo = 1; 798 break; 799 case SCTP_SENDV_PRINFO: 800 if ((info == NULL) || (infolen != sizeof(struct sctp_prinfo))) { 801 errno = EINVAL; 802 return (-1); 803 } 804 sinfo.sinfo_stream = 0; 805 sinfo.sinfo_flags = PR_SCTP_POLICY(((struct sctp_prinfo *)info)->pr_policy); 806 sinfo.sinfo_timetolive = ((struct sctp_prinfo *)info)->pr_value; 807 use_sinfo = 1; 808 break; 809 case SCTP_SENDV_AUTHINFO: 810 errno = EINVAL; 811 return (-1); 812 case SCTP_SENDV_SPA: 813 if ((info == NULL) || (infolen != sizeof(struct sctp_sendv_spa))) { 814 errno = EINVAL; 815 return (-1); 816 } 817 if (((struct sctp_sendv_spa *)info)->sendv_flags & SCTP_SEND_SNDINFO_VALID) { 818 sinfo.sinfo_stream = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_sid; 819 sinfo.sinfo_flags = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_flags; 820 sinfo.sinfo_ppid = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_ppid; 821 sinfo.sinfo_context = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_context; 822 sinfo.sinfo_assoc_id = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_assoc_id; 823 } else { 824 sinfo.sinfo_flags = 0; 825 sinfo.sinfo_stream = 0; 826 } 827 if (((struct sctp_sendv_spa *)info)->sendv_flags & SCTP_SEND_PRINFO_VALID) { 828 sinfo.sinfo_flags |= PR_SCTP_POLICY(((struct sctp_sendv_spa *)info)->sendv_prinfo.pr_policy); 829 sinfo.sinfo_timetolive = ((struct sctp_sendv_spa *)info)->sendv_prinfo.pr_value; 830 } 831 if (((struct sctp_sendv_spa *)info)->sendv_flags & SCTP_SEND_AUTHINFO_VALID) { 832 errno = EINVAL; 833 return (-1); 834 } 835 use_sinfo = 1; 836 break; 837 default: 838 errno = EINVAL; 839 return (-1); 840 } 841 842 /* Perform error checks on destination (to) */ 843 if (addrcnt > 1) { 844 errno = EINVAL; 845 return (-1); 846 } 847 848 iov[0].iov_base = (caddr_t)data; 849 iov[0].iov_len = len; 850 851 auio.uio_iov = iov; 852 auio.uio_iovcnt = 1; 853 auio.uio_segflg = UIO_USERSPACE; 854 auio.uio_rw = UIO_WRITE; 855 auio.uio_offset = 0; /* XXX */ 856 auio.uio_resid = len; 857 errno = sctp_lower_sosend(so, to, &auio, NULL, NULL, flags, use_sinfo ? &sinfo : NULL); 858 if (errno == 0) { 859 return (len - auio.uio_resid); 860 } else { 861 return (-1); 862 } 863 } 864 865 866 ssize_t 867 userspace_sctp_sendmbuf(struct socket *so, 868 struct mbuf* mbufdata, 869 size_t len, 870 struct sockaddr *to, 871 socklen_t tolen, 872 u_int32_t ppid, 873 u_int32_t flags, 874 u_int16_t stream_no, 875 u_int32_t timetolive, 876 u_int32_t context) 877 { 878 879 struct sctp_sndrcvinfo sndrcvinfo, *sinfo = &sndrcvinfo; 880 /* struct uio auio; 881 struct iovec iov[1]; */ 882 int error = 0; 883 int uflags = 0; 884 int retvalsendmsg; 885 886 sinfo->sinfo_ppid = ppid; 887 sinfo->sinfo_flags = flags; 888 sinfo->sinfo_stream = stream_no; 889 sinfo->sinfo_timetolive = timetolive; 890 sinfo->sinfo_context = context; 891 sinfo->sinfo_assoc_id = 0; 892 893 /* Perform error checks on destination (to) */ 894 if (tolen > SOCK_MAXADDRLEN){ 895 error = (ENAMETOOLONG); 896 goto sendmsg_return; 897 } 898 if (tolen < (socklen_t)offsetof(struct sockaddr, sa_data)){ 899 error = (EINVAL); 900 goto sendmsg_return; 901 } 902 /* Adding the following as part of defensive programming, in case the application 903 does not do it when preparing the destination address.*/ 904 #ifdef HAVE_SA_LEN 905 to->sa_len = tolen; 906 #endif 907 908 error = sctp_lower_sosend(so, to, NULL/*uio*/, 909 (struct mbuf *)mbufdata, (struct mbuf *)NULL, 910 uflags, sinfo); 911 sendmsg_return: 912 /* TODO: Needs a condition for non-blocking when error is EWOULDBLOCK */ 913 if (0 == error) 914 retvalsendmsg = len; 915 else if(error == EWOULDBLOCK) { 916 errno = EWOULDBLOCK; 917 retvalsendmsg = (-1); 918 } else { 919 SCTP_PRINTF("%s: error = %d\n", __func__, error); 920 errno = error; 921 retvalsendmsg = (-1); 922 } 923 return retvalsendmsg; 924 925 } 926 927 928 /* taken from usr.lib/sctp_sys_calls.c and needed here */ 929 #define SCTP_SMALL_IOVEC_SIZE 2 930 931 /* Taken from /src/lib/libc/net/sctp_sys_calls.c 932 * and modified for __Userspace__ 933 * calling sctp_generic_recvmsg from this function 934 */ 935 ssize_t 936 userspace_sctp_recvmsg(struct socket *so, 937 void *dbuf, 938 size_t len, 939 struct sockaddr *from, 940 socklen_t *fromlenp, 941 struct sctp_sndrcvinfo *sinfo, 942 int *msg_flags) 943 { 944 struct uio auio; 945 struct iovec iov[SCTP_SMALL_IOVEC_SIZE]; 946 struct iovec *tiov; 947 int iovlen = 1; 948 int error = 0; 949 int ulen, i, retval; 950 socklen_t fromlen; 951 952 iov[0].iov_base = dbuf; 953 iov[0].iov_len = len; 954 955 auio.uio_iov = iov; 956 auio.uio_iovcnt = iovlen; 957 auio.uio_segflg = UIO_USERSPACE; 958 auio.uio_rw = UIO_READ; 959 auio.uio_offset = 0; /* XXX */ 960 auio.uio_resid = 0; 961 tiov = iov; 962 for (i = 0; i <iovlen; i++, tiov++) { 963 if ((auio.uio_resid += tiov->iov_len) < 0) { 964 error = EINVAL; 965 SCTP_PRINTF("%s: error = %d\n", __func__, error); 966 return (-1); 967 } 968 } 969 ulen = auio.uio_resid; 970 if (fromlenp != NULL) { 971 fromlen = *fromlenp; 972 } else { 973 fromlen = 0; 974 } 975 error = sctp_sorecvmsg(so, &auio, (struct mbuf **)NULL, 976 from, fromlen, msg_flags, 977 (struct sctp_sndrcvinfo *)sinfo, 1); 978 979 if (error) { 980 if (auio.uio_resid != (int)ulen && 981 (error == EINTR || 982 #if !defined(__Userspace_os_NetBSD) 983 error == ERESTART || 984 #endif 985 error == EWOULDBLOCK)) { 986 error = 0; 987 } 988 } 989 if ((fromlenp != NULL) && (fromlen > 0) && (from != NULL)) { 990 switch (from->sa_family) { 991 #if defined(INET) 992 case AF_INET: 993 *fromlenp = sizeof(struct sockaddr_in); 994 break; 995 #endif 996 #if defined(INET6) 997 case AF_INET6: 998 *fromlenp = sizeof(struct sockaddr_in6); 999 break; 1000 #endif 1001 case AF_CONN: 1002 *fromlenp = sizeof(struct sockaddr_conn); 1003 break; 1004 default: 1005 *fromlenp = 0; 1006 break; 1007 } 1008 if (*fromlenp > fromlen) { 1009 *fromlenp = fromlen; 1010 } 1011 } 1012 if (error == 0){ 1013 /* ready return value */ 1014 retval = (int)ulen - auio.uio_resid; 1015 return (retval); 1016 } else { 1017 SCTP_PRINTF("%s: error = %d\n", __func__, error); 1018 return (-1); 1019 } 1020 } 1021 1022 ssize_t 1023 usrsctp_recvv(struct socket *so, 1024 void *dbuf, 1025 size_t len, 1026 struct sockaddr *from, 1027 socklen_t *fromlenp, 1028 void *info, 1029 socklen_t *infolen, 1030 unsigned int *infotype, 1031 int *msg_flags) 1032 { 1033 struct uio auio; 1034 struct iovec iov[SCTP_SMALL_IOVEC_SIZE]; 1035 struct iovec *tiov; 1036 int iovlen = 1; 1037 int ulen, i; 1038 socklen_t fromlen; 1039 struct sctp_rcvinfo *rcv; 1040 struct sctp_recvv_rn *rn; 1041 struct sctp_extrcvinfo seinfo; 1042 1043 if (so == NULL) { 1044 errno = EBADF; 1045 return (-1); 1046 } 1047 iov[0].iov_base = dbuf; 1048 iov[0].iov_len = len; 1049 1050 auio.uio_iov = iov; 1051 auio.uio_iovcnt = iovlen; 1052 auio.uio_segflg = UIO_USERSPACE; 1053 auio.uio_rw = UIO_READ; 1054 auio.uio_offset = 0; /* XXX */ 1055 auio.uio_resid = 0; 1056 tiov = iov; 1057 for (i = 0; i <iovlen; i++, tiov++) { 1058 if ((auio.uio_resid += tiov->iov_len) < 0) { 1059 errno = EINVAL; 1060 return (-1); 1061 } 1062 } 1063 ulen = auio.uio_resid; 1064 if (fromlenp != NULL) { 1065 fromlen = *fromlenp; 1066 } else { 1067 fromlen = 0; 1068 } 1069 errno = sctp_sorecvmsg(so, &auio, (struct mbuf **)NULL, 1070 from, fromlen, msg_flags, 1071 (struct sctp_sndrcvinfo *)&seinfo, 1); 1072 if (errno) { 1073 if (auio.uio_resid != (int)ulen && 1074 (errno == EINTR || 1075 #if !defined(__Userspace_os_NetBSD) 1076 errno == ERESTART || 1077 #endif 1078 errno == EWOULDBLOCK)) { 1079 errno = 0; 1080 } 1081 } 1082 if ((*msg_flags & MSG_NOTIFICATION) == 0) { 1083 struct sctp_inpcb *inp; 1084 1085 inp = (struct sctp_inpcb *)so->so_pcb; 1086 if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO) && 1087 sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO) && 1088 *infolen >= (socklen_t)sizeof(struct sctp_recvv_rn) && 1089 seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_AVAIL) { 1090 rn = (struct sctp_recvv_rn *)info; 1091 rn->recvv_rcvinfo.rcv_sid = seinfo.sinfo_stream; 1092 rn->recvv_rcvinfo.rcv_ssn = seinfo.sinfo_ssn; 1093 rn->recvv_rcvinfo.rcv_flags = seinfo.sinfo_flags; 1094 rn->recvv_rcvinfo.rcv_ppid = seinfo.sinfo_ppid; 1095 rn->recvv_rcvinfo.rcv_context = seinfo.sinfo_context; 1096 rn->recvv_rcvinfo.rcv_tsn = seinfo.sinfo_tsn; 1097 rn->recvv_rcvinfo.rcv_cumtsn = seinfo.sinfo_cumtsn; 1098 rn->recvv_rcvinfo.rcv_assoc_id = seinfo.sinfo_assoc_id; 1099 rn->recvv_nxtinfo.nxt_sid = seinfo.sreinfo_next_stream; 1100 rn->recvv_nxtinfo.nxt_flags = 0; 1101 if (seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_IS_UNORDERED) { 1102 rn->recvv_nxtinfo.nxt_flags |= SCTP_UNORDERED; 1103 } 1104 if (seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_IS_NOTIFICATION) { 1105 rn->recvv_nxtinfo.nxt_flags |= SCTP_NOTIFICATION; 1106 } 1107 if (seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_ISCOMPLETE) { 1108 rn->recvv_nxtinfo.nxt_flags |= SCTP_COMPLETE; 1109 } 1110 rn->recvv_nxtinfo.nxt_ppid = seinfo.sreinfo_next_ppid; 1111 rn->recvv_nxtinfo.nxt_length = seinfo.sreinfo_next_length; 1112 rn->recvv_nxtinfo.nxt_assoc_id = seinfo.sreinfo_next_aid; 1113 *infolen = (socklen_t)sizeof(struct sctp_recvv_rn); 1114 *infotype = SCTP_RECVV_RN; 1115 } else if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO) && 1116 *infolen >= (socklen_t)sizeof(struct sctp_rcvinfo)) { 1117 rcv = (struct sctp_rcvinfo *)info; 1118 rcv->rcv_sid = seinfo.sinfo_stream; 1119 rcv->rcv_ssn = seinfo.sinfo_ssn; 1120 rcv->rcv_flags = seinfo.sinfo_flags; 1121 rcv->rcv_ppid = seinfo.sinfo_ppid; 1122 rcv->rcv_context = seinfo.sinfo_context; 1123 rcv->rcv_tsn = seinfo.sinfo_tsn; 1124 rcv->rcv_cumtsn = seinfo.sinfo_cumtsn; 1125 rcv->rcv_assoc_id = seinfo.sinfo_assoc_id; 1126 *infolen = (socklen_t)sizeof(struct sctp_rcvinfo); 1127 *infotype = SCTP_RECVV_RCVINFO; 1128 } else { 1129 *infotype = SCTP_RECVV_NOINFO; 1130 *infolen = 0; 1131 } 1132 } 1133 if ((fromlenp != NULL) && (fromlen > 0) && (from != NULL)) { 1134 switch (from->sa_family) { 1135 #if defined(INET) 1136 case AF_INET: 1137 *fromlenp = sizeof(struct sockaddr_in); 1138 break; 1139 #endif 1140 #if defined(INET6) 1141 case AF_INET6: 1142 *fromlenp = sizeof(struct sockaddr_in6); 1143 break; 1144 #endif 1145 case AF_CONN: 1146 *fromlenp = sizeof(struct sockaddr_conn); 1147 break; 1148 default: 1149 *fromlenp = 0; 1150 break; 1151 } 1152 if (*fromlenp > fromlen) { 1153 *fromlenp = fromlen; 1154 } 1155 } 1156 if (errno == 0) { 1157 /* ready return value */ 1158 return ((int)ulen - auio.uio_resid); 1159 } else { 1160 return (-1); 1161 } 1162 } 1163 1164 1165 1166 1167 #if defined(__Userspace__) 1168 /* Taken from /src/sys/kern/uipc_socket.c 1169 * and modified for __Userspace__ 1170 * socreate returns a socket. The socket should be 1171 * closed with soclose(). 1172 */ 1173 int 1174 socreate(int dom, struct socket **aso, int type, int proto) 1175 { 1176 struct socket *so; 1177 int error; 1178 1179 if ((dom != AF_CONN) && (dom != AF_INET) && (dom != AF_INET6)) { 1180 return (EINVAL); 1181 } 1182 if ((type != SOCK_STREAM) && (type != SOCK_SEQPACKET)) { 1183 return (EINVAL); 1184 } 1185 if (proto != IPPROTO_SCTP) { 1186 return (EINVAL); 1187 } 1188 1189 so = soalloc(); 1190 if (so == NULL) { 1191 return (ENOBUFS); 1192 } 1193 1194 /* 1195 * so_incomp represents a queue of connections that 1196 * must be completed at protocol level before being 1197 * returned. so_comp field heads a list of sockets 1198 * that are ready to be returned to the listening process 1199 *__Userspace__ These queues are being used at a number of places like accept etc. 1200 */ 1201 TAILQ_INIT(&so->so_incomp); 1202 TAILQ_INIT(&so->so_comp); 1203 so->so_type = type; 1204 so->so_count = 1; 1205 so->so_dom = dom; 1206 /* 1207 * Auto-sizing of socket buffers is managed by the protocols and 1208 * the appropriate flags must be set in the pru_attach function. 1209 * For __Userspace__ The pru_attach function in this case is sctp_attach. 1210 */ 1211 switch (dom) { 1212 #if defined(INET) 1213 case AF_INET: 1214 error = sctp_attach(so, proto, SCTP_DEFAULT_VRFID); 1215 break; 1216 #endif 1217 #if defined(INET6) 1218 case AF_INET6: 1219 error = sctp6_attach(so, proto, SCTP_DEFAULT_VRFID); 1220 break; 1221 #endif 1222 case AF_CONN: 1223 error = sctpconn_attach(so, proto, SCTP_DEFAULT_VRFID); 1224 break; 1225 default: 1226 error = EAFNOSUPPORT; 1227 break; 1228 } 1229 if (error) { 1230 KASSERT(so->so_count == 1, ("socreate: so_count %d", so->so_count)); 1231 so->so_count = 0; 1232 sodealloc(so); 1233 return (error); 1234 } 1235 *aso = so; 1236 return (0); 1237 } 1238 #else 1239 /* The kernel version for reference is below. The #else 1240 should be removed once the __Userspace__ 1241 version is tested. 1242 * socreate returns a socket with a ref count of 1. The socket should be 1243 * closed with soclose(). 1244 */ 1245 int 1246 socreate(int dom, struct socket **aso, int type, int proto, 1247 struct ucred *cred, struct thread *td) 1248 { 1249 struct protosw *prp; 1250 struct socket *so; 1251 int error; 1252 1253 if (proto) 1254 prp = pffindproto(dom, proto, type); 1255 else 1256 prp = pffindtype(dom, type); 1257 1258 if (prp == NULL || prp->pr_usrreqs->pru_attach == NULL || 1259 prp->pr_usrreqs->pru_attach == pru_attach_notsupp) 1260 return (EPROTONOSUPPORT); 1261 1262 if (jailed(cred) && jail_socket_unixiproute_only && 1263 prp->pr_domain->dom_family != PF_LOCAL && 1264 prp->pr_domain->dom_family != PF_INET && 1265 prp->pr_domain->dom_family != PF_ROUTE) { 1266 return (EPROTONOSUPPORT); 1267 } 1268 1269 if (prp->pr_type != type) 1270 return (EPROTOTYPE); 1271 so = soalloc(); 1272 if (so == NULL) 1273 return (ENOBUFS); 1274 1275 TAILQ_INIT(&so->so_incomp); 1276 TAILQ_INIT(&so->so_comp); 1277 so->so_type = type; 1278 so->so_cred = crhold(cred); 1279 so->so_proto = prp; 1280 #ifdef MAC 1281 mac_create_socket(cred, so); 1282 #endif 1283 knlist_init(&so->so_rcv.sb_sel.si_note, SOCKBUF_MTX(&so->so_rcv), 1284 NULL, NULL, NULL); 1285 knlist_init(&so->so_snd.sb_sel.si_note, SOCKBUF_MTX(&so->so_snd), 1286 NULL, NULL, NULL); 1287 so->so_count = 1; 1288 /* 1289 * Auto-sizing of socket buffers is managed by the protocols and 1290 * the appropriate flags must be set in the pru_attach function. 1291 */ 1292 error = (*prp->pr_usrreqs->pru_attach)(so, proto, td); 1293 if (error) { 1294 KASSERT(so->so_count == 1, ("socreate: so_count %d", 1295 so->so_count)); 1296 so->so_count = 0; 1297 sodealloc(so); 1298 return (error); 1299 } 1300 *aso = so; 1301 return (0); 1302 } 1303 #endif 1304 1305 1306 1307 1308 /* Taken from /src/sys/kern/uipc_syscalls.c 1309 * and modified for __Userspace__ 1310 * Removing struct thread td. 1311 */ 1312 struct socket * 1313 userspace_socket(int domain, int type, int protocol) 1314 { 1315 struct socket *so = NULL; 1316 1317 errno = socreate(domain, &so, type, protocol); 1318 if (errno) { 1319 return (NULL); 1320 } 1321 /* 1322 * The original socket call returns the file descriptor fd. 1323 * td->td_retval[0] = fd. 1324 * We are returning struct socket *so. 1325 */ 1326 return (so); 1327 } 1328 1329 struct socket * 1330 usrsctp_socket(int domain, int type, int protocol, 1331 int (*receive_cb)(struct socket *sock, union sctp_sockstore addr, void *data, 1332 size_t datalen, struct sctp_rcvinfo, int flags, void *ulp_info), 1333 int (*send_cb)(struct socket *sock, uint32_t sb_free), 1334 uint32_t sb_threshold, 1335 void *ulp_info) 1336 { 1337 struct socket *so; 1338 1339 if ((protocol = IPPROTO_SCTP) && (SCTP_BASE_VAR(sctp_pcb_initialized) == 0)) { 1340 errno = EPROTONOSUPPORT; 1341 return (NULL); 1342 } 1343 if ((receive_cb == NULL) && 1344 ((send_cb != NULL) || (sb_threshold != 0) || (ulp_info != NULL))) { 1345 errno = EINVAL; 1346 return (NULL); 1347 } 1348 if ((domain == AF_CONN) && (SCTP_BASE_VAR(conn_output) == NULL)) { 1349 errno = EAFNOSUPPORT; 1350 return (NULL); 1351 } 1352 errno = socreate(domain, &so, type, protocol); 1353 if (errno) { 1354 return (NULL); 1355 } 1356 /* 1357 * The original socket call returns the file descriptor fd. 1358 * td->td_retval[0] = fd. 1359 * We are returning struct socket *so. 1360 */ 1361 register_recv_cb(so, receive_cb); 1362 register_send_cb(so, sb_threshold, send_cb); 1363 register_ulp_info(so, ulp_info); 1364 return (so); 1365 } 1366 1367 1368 u_long sb_max = SB_MAX; 1369 u_long sb_max_adj = 1370 SB_MAX * MCLBYTES / (MSIZE + MCLBYTES); /* adjusted sb_max */ 1371 1372 static u_long sb_efficiency = 8; /* parameter for sbreserve() */ 1373 1374 /* 1375 * Allot mbufs to a sockbuf. Attempt to scale mbmax so that mbcnt doesn't 1376 * become limiting if buffering efficiency is near the normal case. 1377 */ 1378 int 1379 sbreserve_locked(struct sockbuf *sb, u_long cc, struct socket *so) 1380 { 1381 SOCKBUF_LOCK_ASSERT(sb); 1382 sb->sb_mbmax = (u_int)min(cc * sb_efficiency, sb_max); 1383 sb->sb_hiwat = cc; 1384 if (sb->sb_lowat > (int)sb->sb_hiwat) 1385 sb->sb_lowat = (int)sb->sb_hiwat; 1386 return (1); 1387 } 1388 1389 static int 1390 sbreserve(struct sockbuf *sb, u_long cc, struct socket *so) 1391 { 1392 int error; 1393 1394 SOCKBUF_LOCK(sb); 1395 error = sbreserve_locked(sb, cc, so); 1396 SOCKBUF_UNLOCK(sb); 1397 return (error); 1398 } 1399 1400 #if defined(__Userspace__) 1401 int 1402 soreserve(struct socket *so, u_long sndcc, u_long rcvcc) 1403 { 1404 SOCKBUF_LOCK(&so->so_snd); 1405 SOCKBUF_LOCK(&so->so_rcv); 1406 so->so_snd.sb_hiwat = (uint32_t)sndcc; 1407 so->so_rcv.sb_hiwat = (uint32_t)rcvcc; 1408 1409 if (sbreserve_locked(&so->so_snd, sndcc, so) == 0) { 1410 goto bad; 1411 } 1412 if (sbreserve_locked(&so->so_rcv, rcvcc, so) == 0) { 1413 goto bad; 1414 } 1415 if (so->so_rcv.sb_lowat == 0) 1416 so->so_rcv.sb_lowat = 1; 1417 if (so->so_snd.sb_lowat == 0) 1418 so->so_snd.sb_lowat = MCLBYTES; 1419 if (so->so_snd.sb_lowat > (int)so->so_snd.sb_hiwat) 1420 so->so_snd.sb_lowat = (int)so->so_snd.sb_hiwat; 1421 SOCKBUF_UNLOCK(&so->so_rcv); 1422 SOCKBUF_UNLOCK(&so->so_snd); 1423 return (0); 1424 1425 bad: 1426 SOCKBUF_UNLOCK(&so->so_rcv); 1427 SOCKBUF_UNLOCK(&so->so_snd); 1428 return (ENOBUFS); 1429 } 1430 #else /* kernel version for reference */ 1431 int 1432 soreserve(struct socket *so, u_long sndcc, u_long rcvcc) 1433 { 1434 struct thread *td = curthread; 1435 1436 SOCKBUF_LOCK(&so->so_snd); 1437 SOCKBUF_LOCK(&so->so_rcv); 1438 if (sbreserve_locked(&so->so_snd, sndcc, so, td) == 0) 1439 goto bad; 1440 if (sbreserve_locked(&so->so_rcv, rcvcc, so, td) == 0) 1441 goto bad2; 1442 if (so->so_rcv.sb_lowat == 0) 1443 so->so_rcv.sb_lowat = 1; 1444 if (so->so_snd.sb_lowat == 0) 1445 so->so_snd.sb_lowat = MCLBYTES; 1446 if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat) 1447 so->so_snd.sb_lowat = so->so_snd.sb_hiwat; 1448 SOCKBUF_UNLOCK(&so->so_rcv); 1449 SOCKBUF_UNLOCK(&so->so_snd); 1450 return (0); 1451 bad2: 1452 sbrelease_locked(&so->so_snd, so); 1453 bad: 1454 SOCKBUF_UNLOCK(&so->so_rcv); 1455 SOCKBUF_UNLOCK(&so->so_snd); 1456 return (ENOBUFS); 1457 } 1458 #endif 1459 1460 1461 1462 1463 1464 /* Taken from /src/sys/kern/uipc_sockbuf.c 1465 * and modified for __Userspace__ 1466 */ 1467 1468 #if defined(__Userspace__) 1469 void 1470 sowakeup(struct socket *so, struct sockbuf *sb) 1471 { 1472 1473 SOCKBUF_LOCK_ASSERT(sb); 1474 1475 sb->sb_flags &= ~SB_SEL; 1476 if (sb->sb_flags & SB_WAIT) { 1477 sb->sb_flags &= ~SB_WAIT; 1478 #if defined (__Userspace_os_Windows) 1479 WakeAllConditionVariable(&(sb)->sb_cond); 1480 #else 1481 pthread_cond_broadcast(&(sb)->sb_cond); 1482 #endif 1483 } 1484 SOCKBUF_UNLOCK(sb); 1485 /*__Userspace__ what todo about so_upcall?*/ 1486 1487 } 1488 #else /* kernel version for reference */ 1489 /* 1490 * Wakeup processes waiting on a socket buffer. Do asynchronous notification 1491 * via SIGIO if the socket has the SS_ASYNC flag set. 1492 * 1493 * Called with the socket buffer lock held; will release the lock by the end 1494 * of the function. This allows the caller to acquire the socket buffer lock 1495 * while testing for the need for various sorts of wakeup and hold it through 1496 * to the point where it's no longer required. We currently hold the lock 1497 * through calls out to other subsystems (with the exception of kqueue), and 1498 * then release it to avoid lock order issues. It's not clear that's 1499 * correct. 1500 */ 1501 void 1502 sowakeup(struct socket *so, struct sockbuf *sb) 1503 { 1504 1505 SOCKBUF_LOCK_ASSERT(sb); 1506 1507 selwakeuppri(&sb->sb_sel, PSOCK); 1508 sb->sb_flags &= ~SB_SEL; 1509 if (sb->sb_flags & SB_WAIT) { 1510 sb->sb_flags &= ~SB_WAIT; 1511 wakeup(&sb->sb_cc); 1512 } 1513 KNOTE_LOCKED(&sb->sb_sel.si_note, 0); 1514 SOCKBUF_UNLOCK(sb); 1515 if ((so->so_state & SS_ASYNC) && so->so_sigio != NULL) 1516 pgsigio(&so->so_sigio, SIGIO, 0); 1517 if (sb->sb_flags & SB_UPCALL) 1518 (*so->so_upcall)(so, so->so_upcallarg, M_NOWAIT); 1519 if (sb->sb_flags & SB_AIO) 1520 aio_swake(so, sb); 1521 mtx_assert(SOCKBUF_MTX(sb), MA_NOTOWNED); 1522 } 1523 #endif 1524 1525 1526 1527 /* Taken from /src/sys/kern/uipc_socket.c 1528 * and modified for __Userspace__ 1529 */ 1530 1531 int 1532 sobind(struct socket *so, struct sockaddr *nam) 1533 { 1534 switch (nam->sa_family) { 1535 #if defined(INET) 1536 case AF_INET: 1537 return (sctp_bind(so, nam)); 1538 #endif 1539 #if defined(INET6) 1540 case AF_INET6: 1541 return (sctp6_bind(so, nam, NULL)); 1542 #endif 1543 case AF_CONN: 1544 return (sctpconn_bind(so, nam)); 1545 default: 1546 return EAFNOSUPPORT; 1547 } 1548 } 1549 1550 /* Taken from /src/sys/kern/uipc_syscalls.c 1551 * and modified for __Userspace__ 1552 */ 1553 1554 int 1555 usrsctp_bind(struct socket *so, struct sockaddr *name, int namelen) 1556 { 1557 struct sockaddr *sa; 1558 1559 if (so == NULL) { 1560 errno = EBADF; 1561 return (-1); 1562 } 1563 if ((errno = getsockaddr(&sa, (caddr_t)name, namelen)) != 0) 1564 return (-1); 1565 1566 errno = sobind(so, sa); 1567 FREE(sa, M_SONAME); 1568 if (errno) { 1569 return (-1); 1570 } else { 1571 return (0); 1572 } 1573 } 1574 1575 int 1576 userspace_bind(struct socket *so, struct sockaddr *name, int namelen) 1577 { 1578 return (usrsctp_bind(so, name, namelen)); 1579 } 1580 1581 /* Taken from /src/sys/kern/uipc_socket.c 1582 * and modified for __Userspace__ 1583 */ 1584 1585 int 1586 solisten(struct socket *so, int backlog) 1587 { 1588 if (so == NULL) { 1589 return (EBADF); 1590 } else { 1591 return (sctp_listen(so, backlog, NULL)); 1592 } 1593 } 1594 1595 1596 int 1597 solisten_proto_check(struct socket *so) 1598 { 1599 1600 SOCK_LOCK_ASSERT(so); 1601 1602 if (so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING | 1603 SS_ISDISCONNECTING)) 1604 return (EINVAL); 1605 return (0); 1606 } 1607 1608 static int somaxconn = SOMAXCONN; 1609 1610 void 1611 solisten_proto(struct socket *so, int backlog) 1612 { 1613 1614 SOCK_LOCK_ASSERT(so); 1615 1616 if (backlog < 0 || backlog > somaxconn) 1617 backlog = somaxconn; 1618 so->so_qlimit = backlog; 1619 so->so_options |= SCTP_SO_ACCEPTCONN; 1620 } 1621 1622 1623 1624 1625 /* Taken from /src/sys/kern/uipc_syscalls.c 1626 * and modified for __Userspace__ 1627 */ 1628 1629 int 1630 usrsctp_listen(struct socket *so, int backlog) 1631 { 1632 errno = solisten(so, backlog); 1633 if (errno) { 1634 return (-1); 1635 } else { 1636 return (0); 1637 } 1638 } 1639 1640 int 1641 userspace_listen(struct socket *so, int backlog) 1642 { 1643 return (usrsctp_listen(so, backlog)); 1644 } 1645 1646 /* Taken from /src/sys/kern/uipc_socket.c 1647 * and modified for __Userspace__ 1648 */ 1649 1650 int 1651 soaccept(struct socket *so, struct sockaddr **nam) 1652 { 1653 int error; 1654 1655 SOCK_LOCK(so); 1656 KASSERT((so->so_state & SS_NOFDREF) != 0, ("soaccept: !NOFDREF")); 1657 so->so_state &= ~SS_NOFDREF; 1658 SOCK_UNLOCK(so); 1659 error = sctp_accept(so, nam); 1660 return (error); 1661 } 1662 1663 1664 1665 /* Taken from /src/sys/kern/uipc_syscalls.c 1666 * kern_accept modified for __Userspace__ 1667 */ 1668 int 1669 user_accept(struct socket *head, struct sockaddr **name, socklen_t *namelen, struct socket **ptr_accept_ret_sock) 1670 { 1671 struct sockaddr *sa = NULL; 1672 int error; 1673 struct socket *so = NULL; 1674 1675 1676 if (name) { 1677 *name = NULL; 1678 } 1679 1680 if ((head->so_options & SCTP_SO_ACCEPTCONN) == 0) { 1681 error = EINVAL; 1682 goto done; 1683 } 1684 1685 ACCEPT_LOCK(); 1686 if ((head->so_state & SS_NBIO) && TAILQ_EMPTY(&head->so_comp)) { 1687 ACCEPT_UNLOCK(); 1688 error = EWOULDBLOCK; 1689 goto noconnection; 1690 } 1691 while (TAILQ_EMPTY(&head->so_comp) && head->so_error == 0) { 1692 if (head->so_rcv.sb_state & SBS_CANTRCVMORE) { 1693 head->so_error = ECONNABORTED; 1694 break; 1695 } 1696 #if defined (__Userspace_os_Windows) 1697 if (SleepConditionVariableCS(&accept_cond, &accept_mtx, INFINITE)) 1698 error = 0; 1699 else 1700 error = GetLastError(); 1701 #else 1702 error = pthread_cond_wait(&accept_cond, &accept_mtx); 1703 #endif 1704 if (error) { 1705 ACCEPT_UNLOCK(); 1706 goto noconnection; 1707 } 1708 } 1709 if (head->so_error) { 1710 error = head->so_error; 1711 head->so_error = 0; 1712 ACCEPT_UNLOCK(); 1713 goto noconnection; 1714 } 1715 so = TAILQ_FIRST(&head->so_comp); 1716 KASSERT(!(so->so_qstate & SQ_INCOMP), ("accept1: so SQ_INCOMP")); 1717 KASSERT(so->so_qstate & SQ_COMP, ("accept1: so not SQ_COMP")); 1718 1719 /* 1720 * Before changing the flags on the socket, we have to bump the 1721 * reference count. Otherwise, if the protocol calls sofree(), 1722 * the socket will be released due to a zero refcount. 1723 */ 1724 SOCK_LOCK(so); /* soref() and so_state update */ 1725 soref(so); /* file descriptor reference */ 1726 1727 TAILQ_REMOVE(&head->so_comp, so, so_list); 1728 head->so_qlen--; 1729 so->so_state |= (head->so_state & SS_NBIO); 1730 so->so_qstate &= ~SQ_COMP; 1731 so->so_head = NULL; 1732 SOCK_UNLOCK(so); 1733 ACCEPT_UNLOCK(); 1734 1735 1736 /* 1737 * The original accept returns fd value via td->td_retval[0] = fd; 1738 * we will return the socket for accepted connection. 1739 */ 1740 1741 error = soaccept(so, &sa); 1742 if (error) { 1743 /* 1744 * return a namelen of zero for older code which might 1745 * ignore the return value from accept. 1746 */ 1747 if (name) 1748 *namelen = 0; 1749 goto noconnection; 1750 } 1751 if (sa == NULL) { 1752 if (name) 1753 *namelen = 0; 1754 goto done; 1755 } 1756 if (name) { 1757 #ifdef HAVE_SA_LEN 1758 /* check sa_len before it is destroyed */ 1759 if (*namelen > sa->sa_len) { 1760 *namelen = sa->sa_len; 1761 } 1762 #else 1763 socklen_t sa_len; 1764 1765 switch (sa->sa_family) { 1766 #ifdef INET 1767 case AF_INET: 1768 sa_len = sizeof(struct sockaddr_in); 1769 break; 1770 #endif 1771 #ifdef INET6 1772 case AF_INET6: 1773 sa_len = sizeof(struct sockaddr_in6); 1774 break; 1775 #endif 1776 case AF_CONN: 1777 sa_len = sizeof(struct sockaddr_conn); 1778 break; 1779 default: 1780 sa_len = 0; 1781 break; 1782 } 1783 if (*namelen > sa_len) { 1784 *namelen = sa_len; 1785 } 1786 #endif 1787 *name = sa; 1788 sa = NULL; 1789 } 1790 noconnection: 1791 if (sa) { 1792 FREE(sa, M_SONAME); 1793 } 1794 1795 done: 1796 *ptr_accept_ret_sock = so; 1797 return (error); 1798 } 1799 1800 1801 1802 /* Taken from /src/sys/kern/uipc_syscalls.c 1803 * and modified for __Userspace__ 1804 */ 1805 /* 1806 * accept1() 1807 */ 1808 static int 1809 accept1(struct socket *so, struct sockaddr *aname, socklen_t *anamelen, struct socket **ptr_accept_ret_sock) 1810 { 1811 struct sockaddr *name; 1812 socklen_t namelen; 1813 int error; 1814 1815 if (so == NULL) { 1816 return (EBADF); 1817 } 1818 if (aname == NULL) { 1819 return (user_accept(so, NULL, NULL, ptr_accept_ret_sock)); 1820 } 1821 1822 error = copyin(anamelen, &namelen, sizeof (namelen)); 1823 if (error) 1824 return (error); 1825 1826 error = user_accept(so, &name, &namelen, ptr_accept_ret_sock); 1827 1828 /* 1829 * return a namelen of zero for older code which might 1830 * ignore the return value from accept. 1831 */ 1832 if (error) { 1833 (void) copyout(&namelen, 1834 anamelen, sizeof(*anamelen)); 1835 return (error); 1836 } 1837 1838 if (error == 0 && name != NULL) { 1839 error = copyout(name, aname, namelen); 1840 } 1841 if (error == 0) { 1842 error = copyout(&namelen, anamelen, sizeof(namelen)); 1843 } 1844 1845 if (name) { 1846 FREE(name, M_SONAME); 1847 } 1848 return (error); 1849 } 1850 1851 struct socket * 1852 usrsctp_accept(struct socket *so, struct sockaddr *aname, socklen_t *anamelen) 1853 { 1854 struct socket *accept_return_sock; 1855 1856 errno = accept1(so, aname, anamelen, &accept_return_sock); 1857 if (errno) { 1858 return (NULL); 1859 } else { 1860 return (accept_return_sock); 1861 } 1862 } 1863 1864 struct socket * 1865 userspace_accept(struct socket *so, struct sockaddr *aname, socklen_t *anamelen) 1866 { 1867 return (usrsctp_accept(so, aname, anamelen)); 1868 } 1869 1870 struct socket * 1871 usrsctp_peeloff(struct socket *head, sctp_assoc_t id) 1872 { 1873 struct socket *so; 1874 1875 if ((errno = sctp_can_peel_off(head, id)) != 0) { 1876 return (NULL); 1877 } 1878 if ((so = sonewconn(head, SS_ISCONNECTED)) == NULL) { 1879 return (NULL); 1880 } 1881 ACCEPT_LOCK(); 1882 SOCK_LOCK(so); 1883 soref(so); 1884 TAILQ_REMOVE(&head->so_comp, so, so_list); 1885 head->so_qlen--; 1886 so->so_state |= (head->so_state & SS_NBIO); 1887 so->so_qstate &= ~SQ_COMP; 1888 so->so_head = NULL; 1889 SOCK_UNLOCK(so); 1890 ACCEPT_UNLOCK(); 1891 if ((errno = sctp_do_peeloff(head, so, id)) != 0) { 1892 so->so_count = 0; 1893 sodealloc(so); 1894 return (NULL); 1895 } 1896 return (so); 1897 } 1898 1899 int 1900 sodisconnect(struct socket *so) 1901 { 1902 int error; 1903 1904 if ((so->so_state & SS_ISCONNECTED) == 0) 1905 return (ENOTCONN); 1906 if (so->so_state & SS_ISDISCONNECTING) 1907 return (EALREADY); 1908 error = sctp_disconnect(so); 1909 return (error); 1910 } 1911 1912 int 1913 usrsctp_set_non_blocking(struct socket *so, int onoff) 1914 { 1915 if (so == NULL) { 1916 errno = EBADF; 1917 return (-1); 1918 } 1919 SOCK_LOCK(so); 1920 if (onoff != 0) { 1921 so->so_state |= SS_NBIO; 1922 } else { 1923 so->so_state &= ~SS_NBIO; 1924 } 1925 SOCK_UNLOCK(so); 1926 return (0); 1927 } 1928 1929 int 1930 usrsctp_get_non_blocking(struct socket *so) 1931 { 1932 int result; 1933 1934 if (so == NULL) { 1935 errno = EBADF; 1936 return (-1); 1937 } 1938 SOCK_LOCK(so); 1939 if (so->so_state | SS_NBIO) { 1940 result = 1; 1941 } else { 1942 result = 0; 1943 } 1944 SOCK_UNLOCK(so); 1945 return (result); 1946 } 1947 1948 int 1949 soconnect(struct socket *so, struct sockaddr *nam) 1950 { 1951 int error; 1952 1953 if (so->so_options & SCTP_SO_ACCEPTCONN) 1954 return (EOPNOTSUPP); 1955 /* 1956 * If protocol is connection-based, can only connect once. 1957 * Otherwise, if connected, try to disconnect first. This allows 1958 * user to disconnect by connecting to, e.g., a null address. 1959 */ 1960 if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) && (error = sodisconnect(so))) { 1961 error = EISCONN; 1962 } else { 1963 /* 1964 * Prevent accumulated error from previous connection from 1965 * biting us. 1966 */ 1967 so->so_error = 0; 1968 switch (nam->sa_family) { 1969 #if defined(INET) 1970 case AF_INET: 1971 error = sctp_connect(so, nam); 1972 break; 1973 #endif 1974 #if defined(INET6) 1975 case AF_INET6: 1976 error = sctp6_connect(so, nam); 1977 break; 1978 #endif 1979 case AF_CONN: 1980 error = sctpconn_connect(so, nam); 1981 break; 1982 default: 1983 error = EAFNOSUPPORT; 1984 } 1985 } 1986 1987 return (error); 1988 } 1989 1990 1991 1992 int user_connect(struct socket *so, struct sockaddr *sa) 1993 { 1994 int error; 1995 int interrupted = 0; 1996 1997 if (so == NULL) { 1998 error = EBADF; 1999 goto done1; 2000 } 2001 if (so->so_state & SS_ISCONNECTING) { 2002 error = EALREADY; 2003 goto done1; 2004 } 2005 2006 error = soconnect(so, sa); 2007 if (error) { 2008 goto bad; 2009 } 2010 if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) { 2011 error = EINPROGRESS; 2012 goto done1; 2013 } 2014 2015 SOCK_LOCK(so); 2016 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) { 2017 #if defined (__Userspace_os_Windows) 2018 if (SleepConditionVariableCS(SOCK_COND(so), SOCK_MTX(so), INFINITE)) 2019 error = 0; 2020 else 2021 error = -1; 2022 #else 2023 error = pthread_cond_wait(SOCK_COND(so), SOCK_MTX(so)); 2024 #endif 2025 if (error) { 2026 #if defined(__Userspace_os_NetBSD) 2027 if (error == EINTR) { 2028 #else 2029 if (error == EINTR || error == ERESTART) { 2030 #endif 2031 interrupted = 1; 2032 } 2033 break; 2034 } 2035 } 2036 if (error == 0) { 2037 error = so->so_error; 2038 so->so_error = 0; 2039 } 2040 SOCK_UNLOCK(so); 2041 2042 bad: 2043 if (!interrupted) { 2044 so->so_state &= ~SS_ISCONNECTING; 2045 } 2046 #if !defined(__Userspace_os_NetBSD) 2047 if (error == ERESTART) { 2048 error = EINTR; 2049 } 2050 #endif 2051 done1: 2052 return (error); 2053 } 2054 2055 int usrsctp_connect(struct socket *so, struct sockaddr *name, int namelen) 2056 { 2057 struct sockaddr *sa; 2058 2059 errno = getsockaddr(&sa, (caddr_t)name, namelen); 2060 if (errno) 2061 return (-1); 2062 2063 errno = user_connect(so, sa); 2064 FREE(sa, M_SONAME); 2065 if (errno) { 2066 return (-1); 2067 } else { 2068 return (0); 2069 } 2070 } 2071 2072 int userspace_connect(struct socket *so, struct sockaddr *name, int namelen) 2073 { 2074 return (usrsctp_connect(so, name, namelen)); 2075 } 2076 2077 #define SCTP_STACK_BUF_SIZE 2048 2078 2079 void 2080 usrsctp_close(struct socket *so) { 2081 if (so != NULL) { 2082 if (so->so_options & SCTP_SO_ACCEPTCONN) { 2083 struct socket *sp; 2084 2085 ACCEPT_LOCK(); 2086 while ((sp = TAILQ_FIRST(&so->so_comp)) != NULL) { 2087 TAILQ_REMOVE(&so->so_comp, sp, so_list); 2088 so->so_qlen--; 2089 sp->so_qstate &= ~SQ_COMP; 2090 sp->so_head = NULL; 2091 ACCEPT_UNLOCK(); 2092 soabort(sp); 2093 ACCEPT_LOCK(); 2094 } 2095 ACCEPT_UNLOCK(); 2096 } 2097 ACCEPT_LOCK(); 2098 SOCK_LOCK(so); 2099 sorele(so); 2100 } 2101 } 2102 2103 void 2104 userspace_close(struct socket *so) 2105 { 2106 usrsctp_close(so); 2107 } 2108 2109 int 2110 usrsctp_shutdown(struct socket *so, int how) 2111 { 2112 if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR)) { 2113 errno = EINVAL; 2114 return (-1); 2115 } 2116 if (so == NULL) { 2117 errno = EBADF; 2118 return (-1); 2119 } 2120 sctp_flush(so, how); 2121 if (how != SHUT_WR) 2122 socantrcvmore(so); 2123 if (how != SHUT_RD) { 2124 errno = sctp_shutdown(so); 2125 if (errno) { 2126 return (-1); 2127 } else { 2128 return (0); 2129 } 2130 } 2131 return (0); 2132 } 2133 2134 int 2135 userspace_shutdown(struct socket *so, int how) 2136 { 2137 return (usrsctp_shutdown(so, how)); 2138 } 2139 2140 int 2141 usrsctp_finish(void) 2142 { 2143 if (SCTP_BASE_VAR(sctp_pcb_initialized) == 0) { 2144 return (0); 2145 } 2146 if (SCTP_INP_INFO_TRYLOCK()) { 2147 if (!LIST_EMPTY(&SCTP_BASE_INFO(listhead))) { 2148 SCTP_INP_INFO_RUNLOCK(); 2149 return (-1); 2150 } 2151 SCTP_INP_INFO_RUNLOCK(); 2152 } else { 2153 return (-1); 2154 } 2155 sctp_finish(); 2156 return (0); 2157 } 2158 2159 int 2160 userspace_finish(void) 2161 { 2162 return (usrsctp_finish()); 2163 } 2164 2165 /* needed from sctp_usrreq.c */ 2166 int 2167 sctp_setopt(struct socket *so, int optname, void *optval, size_t optsize, void *p); 2168 2169 int 2170 usrsctp_setsockopt(struct socket *so, int level, int option_name, 2171 const void *option_value, socklen_t option_len) 2172 { 2173 if (so == NULL) { 2174 errno = EBADF; 2175 return (-1); 2176 } 2177 switch (level) { 2178 case SOL_SOCKET: 2179 { 2180 switch (option_name) { 2181 case SO_RCVBUF: 2182 if (option_len < (socklen_t)sizeof(int)) { 2183 errno = EINVAL; 2184 return (-1); 2185 } else { 2186 int *buf_size; 2187 2188 buf_size = (int *)option_value; 2189 if (*buf_size < 1) { 2190 errno = EINVAL; 2191 return (-1); 2192 } 2193 sbreserve(&so->so_rcv, (u_long)*buf_size, so); 2194 return (0); 2195 } 2196 break; 2197 case SO_SNDBUF: 2198 if (option_len < (socklen_t)sizeof(int)) { 2199 errno = EINVAL; 2200 return (-1); 2201 } else { 2202 int *buf_size; 2203 2204 buf_size = (int *)option_value; 2205 if (*buf_size < 1) { 2206 errno = EINVAL; 2207 return (-1); 2208 } 2209 sbreserve(&so->so_snd, (u_long)*buf_size, so); 2210 return (0); 2211 } 2212 break; 2213 case SO_LINGER: 2214 if (option_len < (socklen_t)sizeof(struct linger)) { 2215 errno = EINVAL; 2216 return (-1); 2217 } else { 2218 struct linger *l; 2219 2220 l = (struct linger *)option_value; 2221 so->so_linger = l->l_linger; 2222 if (l->l_onoff) { 2223 so->so_options |= SCTP_SO_LINGER; 2224 } else { 2225 so->so_options &= ~SCTP_SO_LINGER; 2226 } 2227 return (0); 2228 } 2229 default: 2230 errno = EINVAL; 2231 return (-1); 2232 } 2233 } 2234 case IPPROTO_SCTP: 2235 errno = sctp_setopt(so, option_name, (void *) option_value, (size_t)option_len, NULL); 2236 if (errno) { 2237 return (-1); 2238 } else { 2239 return (0); 2240 } 2241 default: 2242 errno = ENOPROTOOPT; 2243 return (-1); 2244 } 2245 } 2246 2247 int 2248 userspace_setsockopt(struct socket *so, int level, int option_name, 2249 const void *option_value, socklen_t option_len) 2250 { 2251 return (usrsctp_setsockopt(so, level, option_name, option_value, option_len)); 2252 } 2253 2254 /* needed from sctp_usrreq.c */ 2255 int 2256 sctp_getopt(struct socket *so, int optname, void *optval, size_t *optsize, 2257 void *p); 2258 2259 int 2260 usrsctp_getsockopt(struct socket *so, int level, int option_name, 2261 void *option_value, socklen_t *option_len) 2262 { 2263 if (so == NULL) { 2264 errno = EBADF; 2265 return (-1); 2266 } 2267 if (option_len == NULL) { 2268 errno = EFAULT; 2269 return (-1); 2270 } 2271 switch (level) { 2272 case SOL_SOCKET: 2273 switch (option_name) { 2274 case SO_RCVBUF: 2275 if (*option_len < (socklen_t)sizeof(int)) { 2276 errno = EINVAL; 2277 return (-1); 2278 } else { 2279 int *buf_size; 2280 2281 buf_size = (int *)option_value; 2282 *buf_size = so->so_rcv.sb_hiwat;; 2283 *option_len = (socklen_t)sizeof(int); 2284 return (0); 2285 } 2286 break; 2287 case SO_SNDBUF: 2288 if (*option_len < (socklen_t)sizeof(int)) { 2289 errno = EINVAL; 2290 return (-1); 2291 } else { 2292 int *buf_size; 2293 2294 buf_size = (int *)option_value; 2295 *buf_size = so->so_snd.sb_hiwat; 2296 *option_len = (socklen_t)sizeof(int); 2297 return (0); 2298 } 2299 break; 2300 case SO_LINGER: 2301 if (*option_len < (socklen_t)sizeof(struct linger)) { 2302 errno = EINVAL; 2303 return (-1); 2304 } else { 2305 struct linger *l; 2306 2307 l = (struct linger *)option_value; 2308 l->l_linger = so->so_linger; 2309 if (so->so_options & SCTP_SO_LINGER) { 2310 l->l_onoff = 1; 2311 } else { 2312 l->l_onoff = 0; 2313 } 2314 *option_len = (socklen_t)sizeof(struct linger); 2315 return (0); 2316 } 2317 default: 2318 errno = EINVAL; 2319 return (-1); 2320 } 2321 case IPPROTO_SCTP: 2322 { 2323 size_t len; 2324 2325 len = (size_t)*option_len; 2326 errno = sctp_getopt(so, option_name, option_value, &len, NULL); 2327 *option_len = (socklen_t)len; 2328 if (errno) { 2329 return (-1); 2330 } else { 2331 return (0); 2332 } 2333 } 2334 default: 2335 errno = ENOPROTOOPT; 2336 return (-1); 2337 } 2338 } 2339 2340 int 2341 userspace_getsockopt(struct socket *so, int level, int option_name, 2342 void *option_value, socklen_t *option_len) 2343 { 2344 return (usrsctp_getsockopt(so, level, option_name, option_value, option_len)); 2345 } 2346 2347 int 2348 usrsctp_bindx(struct socket *so, struct sockaddr *addrs, int addrcnt, int flags) 2349 { 2350 struct sctp_getaddresses *gaddrs; 2351 struct sockaddr *sa; 2352 #ifdef INET 2353 struct sockaddr_in *sin; 2354 #endif 2355 #ifdef INET6 2356 struct sockaddr_in6 *sin6; 2357 #endif 2358 int i; 2359 size_t argsz; 2360 #if defined(INET) || defined(INET6) 2361 uint16_t sport = 0; 2362 #endif 2363 2364 /* validate the flags */ 2365 if ((flags != SCTP_BINDX_ADD_ADDR) && 2366 (flags != SCTP_BINDX_REM_ADDR)) { 2367 errno = EFAULT; 2368 return (-1); 2369 } 2370 /* validate the address count and list */ 2371 if ((addrcnt <= 0) || (addrs == NULL)) { 2372 errno = EINVAL; 2373 return (-1); 2374 } 2375 /* First pre-screen the addresses */ 2376 sa = addrs; 2377 for (i = 0; i < addrcnt; i++) { 2378 switch (sa->sa_family) { 2379 #ifdef INET 2380 case AF_INET: 2381 #ifdef HAVE_SA_LEN 2382 if (sa->sa_len != sizeof(struct sockaddr_in)) { 2383 errno = EINVAL; 2384 return (-1); 2385 } 2386 #endif 2387 sin = (struct sockaddr_in *)sa; 2388 if (sin->sin_port) { 2389 /* non-zero port, check or save */ 2390 if (sport) { 2391 /* Check against our port */ 2392 if (sport != sin->sin_port) { 2393 errno = EINVAL; 2394 return (-1); 2395 } 2396 } else { 2397 /* save off the port */ 2398 sport = sin->sin_port; 2399 } 2400 } 2401 #ifndef HAVE_SA_LEN 2402 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in)); 2403 #endif 2404 break; 2405 #endif 2406 #ifdef INET6 2407 case AF_INET6: 2408 #ifdef HAVE_SA_LEN 2409 if (sa->sa_len != sizeof(struct sockaddr_in6)) { 2410 errno = EINVAL; 2411 return (-1); 2412 } 2413 #endif 2414 sin6 = (struct sockaddr_in6 *)sa; 2415 if (sin6->sin6_port) { 2416 /* non-zero port, check or save */ 2417 if (sport) { 2418 /* Check against our port */ 2419 if (sport != sin6->sin6_port) { 2420 errno = EINVAL; 2421 return (-1); 2422 } 2423 } else { 2424 /* save off the port */ 2425 sport = sin6->sin6_port; 2426 } 2427 } 2428 #ifndef HAVE_SA_LEN 2429 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6)); 2430 #endif 2431 break; 2432 #endif 2433 default: 2434 /* Invalid address family specified. */ 2435 errno = EAFNOSUPPORT; 2436 return (-1); 2437 } 2438 #ifdef HAVE_SA_LEN 2439 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); 2440 #endif 2441 } 2442 argsz = sizeof(struct sctp_getaddresses) + 2443 sizeof(struct sockaddr_storage); 2444 if ((gaddrs = (struct sctp_getaddresses *)malloc(argsz)) == NULL) { 2445 errno = ENOMEM; 2446 return (-1); 2447 } 2448 sa = addrs; 2449 for (i = 0; i < addrcnt; i++) { 2450 #ifndef HAVE_SA_LEN 2451 size_t sa_len; 2452 #endif 2453 memset(gaddrs, 0, argsz); 2454 gaddrs->sget_assoc_id = 0; 2455 #ifdef HAVE_SA_LEN 2456 memcpy(gaddrs->addr, sa, sa->sa_len); 2457 if (usrsctp_setsockopt(so, IPPROTO_SCTP, flags, gaddrs, (socklen_t)argsz) != 0) { 2458 free(gaddrs); 2459 return (-1); 2460 } 2461 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); 2462 #else 2463 switch (sa->sa_family) { 2464 #ifdef INET 2465 case AF_INET: 2466 sa_len = sizeof(struct sockaddr_in); 2467 break; 2468 #endif 2469 #ifdef INET6 2470 case AF_INET6: 2471 sa_len = sizeof(struct sockaddr_in6); 2472 break; 2473 #endif 2474 default: 2475 sa_len = 0; 2476 break; 2477 } 2478 memcpy(gaddrs->addr, sa, sa_len); 2479 /* 2480 * Now, if there was a port mentioned, assure that the 2481 * first address has that port to make sure it fails or 2482 * succeeds correctly. 2483 */ 2484 #if defined(INET) || defined(INET6) 2485 if ((i == 0) && (sport != 0)) { 2486 switch (gaddrs->addr->sa_family) { 2487 #ifdef INET 2488 case AF_INET: 2489 sin = (struct sockaddr_in *)gaddrs->addr; 2490 sin->sin_port = sport; 2491 break; 2492 #endif 2493 #ifdef INET6 2494 case AF_INET6: 2495 sin6 = (struct sockaddr_in6 *)gaddrs->addr; 2496 sin6->sin6_port = sport; 2497 break; 2498 #endif 2499 } 2500 } 2501 #endif 2502 if (usrsctp_setsockopt(so, IPPROTO_SCTP, flags, gaddrs, (socklen_t)argsz) != 0) { 2503 free(gaddrs); 2504 return (-1); 2505 } 2506 sa = (struct sockaddr *)((caddr_t)sa + sa_len); 2507 #endif 2508 } 2509 free(gaddrs); 2510 return (0); 2511 } 2512 2513 int 2514 usrsctp_connectx(struct socket *so, 2515 const struct sockaddr *addrs, int addrcnt, 2516 sctp_assoc_t *id) 2517 { 2518 #if defined(INET) || defined(INET6) 2519 char buf[SCTP_STACK_BUF_SIZE]; 2520 int i, ret, cnt, *aa; 2521 char *cpto; 2522 const struct sockaddr *at; 2523 sctp_assoc_t *p_id; 2524 size_t len = sizeof(int); 2525 2526 /* validate the address count and list */ 2527 if ((addrs == NULL) || (addrcnt <= 0)) { 2528 errno = EINVAL; 2529 return (-1); 2530 } 2531 at = addrs; 2532 cnt = 0; 2533 cpto = ((caddr_t)buf + sizeof(int)); 2534 /* validate all the addresses and get the size */ 2535 for (i = 0; i < addrcnt; i++) { 2536 switch (at->sa_family) { 2537 #ifdef INET 2538 case AF_INET: 2539 #ifdef HAVE_SA_LEN 2540 if (at->sa_len != sizeof(struct sockaddr_in)) { 2541 errno = EINVAL; 2542 return (-1); 2543 } 2544 #endif 2545 memcpy(cpto, at, sizeof(struct sockaddr_in)); 2546 cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in)); 2547 len += sizeof(struct sockaddr_in); 2548 at = (struct sockaddr *)((caddr_t)at + sizeof(struct sockaddr_in)); 2549 break; 2550 #endif 2551 #ifdef INET6 2552 case AF_INET6: 2553 #ifdef HAVE_SA_LEN 2554 if (at->sa_len != sizeof(struct sockaddr_in6)) { 2555 errno = EINVAL; 2556 return (-1); 2557 } 2558 #endif 2559 if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)at)->sin6_addr)) { 2560 in6_sin6_2_sin((struct sockaddr_in *)cpto, (struct sockaddr_in6 *)at); 2561 cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in)); 2562 len += sizeof(struct sockaddr_in); 2563 } else { 2564 memcpy(cpto, at, sizeof(struct sockaddr_in6)); 2565 cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in6)); 2566 len += sizeof(struct sockaddr_in6); 2567 } 2568 at = (struct sockaddr *)((caddr_t)at + sizeof(struct sockaddr_in6)); 2569 break; 2570 #endif 2571 default: 2572 errno = EINVAL; 2573 return (-1); 2574 } 2575 if (len > (sizeof(buf) - sizeof(int))) { 2576 /* Never enough memory */ 2577 errno = E2BIG; 2578 return (-1); 2579 } 2580 cnt++; 2581 } 2582 /* do we have any? */ 2583 if (cnt == 0) { 2584 errno = EINVAL; 2585 return (-1); 2586 } 2587 aa = (int *)buf; 2588 *aa = cnt; 2589 ret = usrsctp_setsockopt(so, IPPROTO_SCTP, SCTP_CONNECT_X, (void *)buf, (socklen_t)len); 2590 if ((ret == 0) && id) { 2591 p_id = (sctp_assoc_t *)buf; 2592 *id = *p_id; 2593 } 2594 return (ret); 2595 #else 2596 errno = EINVAL; 2597 return (-1); 2598 #endif 2599 } 2600 2601 int 2602 usrsctp_getpaddrs(struct socket *so, sctp_assoc_t id, struct sockaddr **raddrs) 2603 { 2604 struct sctp_getaddresses *addrs; 2605 struct sockaddr *sa; 2606 sctp_assoc_t asoc; 2607 caddr_t lim; 2608 socklen_t opt_len; 2609 int cnt; 2610 2611 if (raddrs == NULL) { 2612 errno = EFAULT; 2613 return (-1); 2614 } 2615 asoc = id; 2616 opt_len = (socklen_t)sizeof(sctp_assoc_t); 2617 if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_REMOTE_ADDR_SIZE, &asoc, &opt_len) != 0) { 2618 return (-1); 2619 } 2620 /* size required is returned in 'asoc' */ 2621 opt_len = (socklen_t)((size_t)asoc + sizeof(struct sctp_getaddresses)); 2622 addrs = calloc(1, (size_t)opt_len); 2623 if (addrs == NULL) { 2624 errno = ENOMEM; 2625 return (-1); 2626 } 2627 addrs->sget_assoc_id = id; 2628 /* Now lets get the array of addresses */ 2629 if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_PEER_ADDRESSES, addrs, &opt_len) != 0) { 2630 free(addrs); 2631 return (-1); 2632 } 2633 *raddrs = (struct sockaddr *)&addrs->addr[0]; 2634 cnt = 0; 2635 sa = (struct sockaddr *)&addrs->addr[0]; 2636 lim = (caddr_t)addrs + opt_len; 2637 #ifdef HAVE_SA_LEN 2638 while (((caddr_t)sa < lim) && (sa->sa_len > 0)) { 2639 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); 2640 #else 2641 while ((caddr_t)sa < lim) { 2642 switch (sa->sa_family) { 2643 #ifdef INET 2644 case AF_INET: 2645 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in)); 2646 break; 2647 #endif 2648 #ifdef INET6 2649 case AF_INET6: 2650 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6)); 2651 break; 2652 #endif 2653 case AF_CONN: 2654 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_conn)); 2655 break; 2656 default: 2657 return (cnt); 2658 break; 2659 } 2660 #endif 2661 cnt++; 2662 } 2663 return (cnt); 2664 } 2665 2666 void 2667 usrsctp_freepaddrs(struct sockaddr *addrs) 2668 { 2669 /* Take away the hidden association id */ 2670 void *fr_addr; 2671 2672 fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t)); 2673 /* Now free it */ 2674 free(fr_addr); 2675 } 2676 2677 int 2678 usrsctp_getladdrs(struct socket *so, sctp_assoc_t id, struct sockaddr **raddrs) 2679 { 2680 struct sctp_getaddresses *addrs; 2681 caddr_t lim; 2682 struct sockaddr *sa; 2683 size_t size_of_addresses; 2684 socklen_t opt_len; 2685 int cnt; 2686 2687 if (raddrs == NULL) { 2688 errno = EFAULT; 2689 return (-1); 2690 } 2691 size_of_addresses = 0; 2692 opt_len = (socklen_t)sizeof(int); 2693 if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDR_SIZE, &size_of_addresses, &opt_len) != 0) { 2694 errno = ENOMEM; 2695 return (-1); 2696 } 2697 if (size_of_addresses == 0) { 2698 errno = ENOTCONN; 2699 return (-1); 2700 } 2701 opt_len = (socklen_t)(size_of_addresses + 2702 sizeof(struct sockaddr_storage) + 2703 sizeof(struct sctp_getaddresses)); 2704 addrs = calloc(1, (size_t)opt_len); 2705 if (addrs == NULL) { 2706 errno = ENOMEM; 2707 return (-1); 2708 } 2709 addrs->sget_assoc_id = id; 2710 /* Now lets get the array of addresses */ 2711 if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDRESSES, addrs, &opt_len) != 0) { 2712 free(addrs); 2713 errno = ENOMEM; 2714 return (-1); 2715 } 2716 *raddrs = (struct sockaddr *)&addrs->addr[0]; 2717 cnt = 0; 2718 sa = (struct sockaddr *)&addrs->addr[0]; 2719 lim = (caddr_t)addrs + opt_len; 2720 #ifdef HAVE_SA_LEN 2721 while (((caddr_t)sa < lim) && (sa->sa_len > 0)) { 2722 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); 2723 #else 2724 while ((caddr_t)sa < lim) { 2725 switch (sa->sa_family) { 2726 #ifdef INET 2727 case AF_INET: 2728 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in)); 2729 break; 2730 #endif 2731 #ifdef INET6 2732 case AF_INET6: 2733 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6)); 2734 break; 2735 #endif 2736 case AF_CONN: 2737 sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_conn)); 2738 break; 2739 default: 2740 return (cnt); 2741 break; 2742 } 2743 #endif 2744 cnt++; 2745 } 2746 return (cnt); 2747 } 2748 2749 void 2750 usrsctp_freeladdrs(struct sockaddr *addrs) 2751 { 2752 /* Take away the hidden association id */ 2753 void *fr_addr; 2754 2755 fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t)); 2756 /* Now free it */ 2757 free(fr_addr); 2758 } 2759 2760 #ifdef INET 2761 void 2762 sctp_userspace_ip_output(int *result, struct mbuf *o_pak, 2763 sctp_route_t *ro, void *stcb, 2764 uint32_t vrf_id) 2765 { 2766 struct mbuf *m; 2767 struct mbuf *m_orig; 2768 int iovcnt; 2769 int send_len; 2770 int len; 2771 int send_count; 2772 struct ip *ip; 2773 struct udphdr *udp; 2774 #if !defined (__Userspace_os_Windows) 2775 int res; 2776 #endif 2777 struct sockaddr_in dst; 2778 #if defined (__Userspace_os_Windows) 2779 WSAMSG win_msg_hdr; 2780 int win_sent_len; 2781 WSABUF send_iovec[MAXLEN_MBUF_CHAIN]; 2782 WSABUF winbuf; 2783 #else 2784 struct iovec send_iovec[MAXLEN_MBUF_CHAIN]; 2785 struct msghdr msg_hdr; 2786 #endif 2787 int use_udp_tunneling; 2788 2789 *result = 0; 2790 2791 m = SCTP_HEADER_TO_CHAIN(o_pak); 2792 m_orig = m; 2793 2794 len = sizeof(struct ip); 2795 if (SCTP_BUF_LEN(m) < len) { 2796 if ((m = m_pullup(m, len)) == 0) { 2797 SCTP_PRINTF("Can not get the IP header in the first mbuf.\n"); 2798 return; 2799 } 2800 } 2801 ip = mtod(m, struct ip *); 2802 use_udp_tunneling = (ip->ip_p == IPPROTO_UDP); 2803 2804 if (use_udp_tunneling) { 2805 len = sizeof(struct ip) + sizeof(struct udphdr); 2806 if (SCTP_BUF_LEN(m) < len) { 2807 if ((m = m_pullup(m, len)) == 0) { 2808 SCTP_PRINTF("Can not get the UDP/IP header in the first mbuf.\n"); 2809 return; 2810 } 2811 ip = mtod(m, struct ip *); 2812 } 2813 udp = (struct udphdr *)(ip + 1); 2814 } else { 2815 udp = NULL; 2816 } 2817 2818 if (!use_udp_tunneling) { 2819 if (ip->ip_src.s_addr == INADDR_ANY) { 2820 /* TODO get addr of outgoing interface */ 2821 SCTP_PRINTF("Why did the SCTP implementation did not choose a source address?\n"); 2822 } 2823 /* TODO need to worry about ro->ro_dst as in ip_output? */ 2824 #if defined(__Userspace_os_Linux) || defined (__Userspace_os_Windows) 2825 /* need to put certain fields into network order for Linux */ 2826 ip->ip_len = htons(ip->ip_len); 2827 ip->ip_off = 0; 2828 #endif 2829 } 2830 2831 memset((void *)&dst, 0, sizeof(struct sockaddr_in)); 2832 dst.sin_family = AF_INET; 2833 dst.sin_addr.s_addr = ip->ip_dst.s_addr; 2834 #ifdef HAVE_SIN_LEN 2835 dst.sin_len = sizeof(struct sockaddr_in); 2836 #endif 2837 if (use_udp_tunneling) { 2838 dst.sin_port = udp->uh_dport; 2839 } else { 2840 dst.sin_port = 0; 2841 } 2842 2843 /* tweak the mbuf chain */ 2844 if (use_udp_tunneling) { 2845 m_adj(m, sizeof(struct ip) + sizeof(struct udphdr)); 2846 } 2847 2848 send_len = SCTP_HEADER_LEN(m); /* length of entire packet */ 2849 send_count = 0; 2850 for (iovcnt = 0; m != NULL && iovcnt < MAXLEN_MBUF_CHAIN; m = m->m_next, iovcnt++) { 2851 #if !defined (__Userspace_os_Windows) 2852 send_iovec[iovcnt].iov_base = (caddr_t)m->m_data; 2853 send_iovec[iovcnt].iov_len = SCTP_BUF_LEN(m); 2854 send_count += send_iovec[iovcnt].iov_len; 2855 #else 2856 send_iovec[iovcnt].buf = (caddr_t)m->m_data; 2857 send_iovec[iovcnt].len = SCTP_BUF_LEN(m); 2858 send_count += send_iovec[iovcnt].len; 2859 #endif 2860 } 2861 2862 if (m != NULL) { 2863 SCTP_PRINTF("mbuf chain couldn't be copied completely\n"); 2864 goto free_mbuf; 2865 } 2866 2867 #if !defined (__Userspace_os_Windows) 2868 msg_hdr.msg_name = (struct sockaddr *) &dst; 2869 msg_hdr.msg_namelen = sizeof(struct sockaddr_in); 2870 msg_hdr.msg_iov = send_iovec; 2871 msg_hdr.msg_iovlen = iovcnt; 2872 msg_hdr.msg_control = NULL; 2873 msg_hdr.msg_controllen = 0; 2874 msg_hdr.msg_flags = 0; 2875 2876 if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp) > -1)) { 2877 if ((res = sendmsg(SCTP_BASE_VAR(userspace_rawsctp), &msg_hdr, MSG_DONTWAIT)) != send_len) { 2878 *result = errno; 2879 } 2880 } 2881 if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp) > -1)) { 2882 if ((res = sendmsg(SCTP_BASE_VAR(userspace_udpsctp), &msg_hdr, MSG_DONTWAIT)) != send_len) { 2883 *result = errno; 2884 } 2885 } 2886 #else 2887 win_msg_hdr.name = (struct sockaddr *) &dst; 2888 win_msg_hdr.namelen = sizeof(struct sockaddr_in); 2889 win_msg_hdr.lpBuffers = (LPWSABUF)send_iovec; 2890 win_msg_hdr.dwBufferCount = iovcnt; 2891 winbuf.len = 0; 2892 winbuf.buf = NULL; 2893 win_msg_hdr.Control = winbuf; 2894 win_msg_hdr.dwFlags = 0; 2895 2896 if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp) > -1)) { 2897 if (WSASendTo(SCTP_BASE_VAR(userspace_rawsctp), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { 2898 *result = WSAGetLastError(); 2899 } else if (win_sent_len != send_len) { 2900 *result = WSAGetLastError(); 2901 } 2902 } 2903 if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp) > -1)) { 2904 if (WSASendTo(SCTP_BASE_VAR(userspace_udpsctp), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { 2905 *result = WSAGetLastError(); 2906 } else if (win_sent_len != send_len) { 2907 *result = WSAGetLastError(); 2908 } 2909 } 2910 #endif 2911 free_mbuf: 2912 sctp_m_freem(m_orig); 2913 } 2914 #endif 2915 2916 #if defined (INET6) 2917 void sctp_userspace_ip6_output(int *result, struct mbuf *o_pak, 2918 struct route_in6 *ro, void *stcb, 2919 uint32_t vrf_id) 2920 { 2921 struct mbuf *m; 2922 struct mbuf *m_orig; 2923 int iovcnt; 2924 int send_len; 2925 int len; 2926 int send_count; 2927 struct ip6_hdr *ip6; 2928 struct udphdr *udp; 2929 #if !defined (__Userspace_os_Windows) 2930 int res; 2931 #endif 2932 struct sockaddr_in6 dst; 2933 #if defined (__Userspace_os_Windows) 2934 WSAMSG win_msg_hdr; 2935 int win_sent_len; 2936 WSABUF send_iovec[MAXLEN_MBUF_CHAIN]; 2937 WSABUF winbuf; 2938 #else 2939 struct iovec send_iovec[MAXLEN_MBUF_CHAIN]; 2940 struct msghdr msg_hdr; 2941 #endif 2942 int use_udp_tunneling; 2943 2944 *result = 0; 2945 2946 m = SCTP_HEADER_TO_CHAIN(o_pak); 2947 m_orig = m; 2948 2949 len = sizeof(struct ip6_hdr); 2950 2951 if (SCTP_BUF_LEN(m) < len) { 2952 if ((m = m_pullup(m, len)) == 0) { 2953 SCTP_PRINTF("Can not get the IP header in the first mbuf.\n"); 2954 return; 2955 } 2956 } 2957 2958 ip6 = mtod(m, struct ip6_hdr *); 2959 use_udp_tunneling = (ip6->ip6_nxt == IPPROTO_UDP); 2960 2961 if (use_udp_tunneling) { 2962 len = sizeof(struct ip6_hdr) + sizeof(struct udphdr); 2963 if (SCTP_BUF_LEN(m) < len) { 2964 if ((m = m_pullup(m, len)) == 0) { 2965 SCTP_PRINTF("Can not get the UDP/IP header in the first mbuf.\n"); 2966 return; 2967 } 2968 ip6 = mtod(m, struct ip6_hdr *); 2969 } 2970 udp = (struct udphdr *)(ip6 + 1); 2971 } else { 2972 udp = NULL; 2973 } 2974 2975 if (!use_udp_tunneling) { 2976 if (ip6->ip6_src.s6_addr == in6addr_any.s6_addr) { 2977 /* TODO get addr of outgoing interface */ 2978 SCTP_PRINTF("Why did the SCTP implementation did not choose a source address?\n"); 2979 } 2980 /* TODO need to worry about ro->ro_dst as in ip_output? */ 2981 #if defined(__Userspace_os_Linux) || defined (__Userspace_os_Windows) 2982 /* need to put certain fields into network order for Linux */ 2983 ip6->ip6_plen = htons(ip6->ip6_plen); 2984 #endif 2985 } 2986 2987 memset((void *)&dst, 0, sizeof(struct sockaddr_in6)); 2988 dst.sin6_family = AF_INET6; 2989 dst.sin6_addr = ip6->ip6_dst; 2990 #ifdef HAVE_SIN6_LEN 2991 dst.sin6_len = sizeof(struct sockaddr_in6); 2992 #endif 2993 2994 if (use_udp_tunneling) { 2995 dst.sin6_port = udp->uh_dport; 2996 } else { 2997 dst.sin6_port = 0; 2998 } 2999 3000 /* tweak the mbuf chain */ 3001 if (use_udp_tunneling) { 3002 m_adj(m, sizeof(struct ip6_hdr) + sizeof(struct udphdr)); 3003 } else { 3004 m_adj(m, sizeof(struct ip6_hdr)); 3005 } 3006 3007 send_len = SCTP_HEADER_LEN(m); /* length of entire packet */ 3008 send_count = 0; 3009 for (iovcnt = 0; m != NULL && iovcnt < MAXLEN_MBUF_CHAIN; m = m->m_next, iovcnt++) { 3010 #if !defined (__Userspace_os_Windows) 3011 send_iovec[iovcnt].iov_base = (caddr_t)m->m_data; 3012 send_iovec[iovcnt].iov_len = SCTP_BUF_LEN(m); 3013 send_count += send_iovec[iovcnt].iov_len; 3014 #else 3015 send_iovec[iovcnt].buf = (caddr_t)m->m_data; 3016 send_iovec[iovcnt].len = SCTP_BUF_LEN(m); 3017 send_count += send_iovec[iovcnt].len; 3018 #endif 3019 } 3020 if (m != NULL) { 3021 SCTP_PRINTF("mbuf chain couldn't be copied completely\n"); 3022 goto free_mbuf; 3023 } 3024 3025 #if !defined (__Userspace_os_Windows) 3026 msg_hdr.msg_name = (struct sockaddr *) &dst; 3027 msg_hdr.msg_namelen = sizeof(struct sockaddr_in6); 3028 msg_hdr.msg_iov = send_iovec; 3029 msg_hdr.msg_iovlen = iovcnt; 3030 msg_hdr.msg_control = NULL; 3031 msg_hdr.msg_controllen = 0; 3032 msg_hdr.msg_flags = 0; 3033 3034 if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp6) > -1)) { 3035 if ((res = sendmsg(SCTP_BASE_VAR(userspace_rawsctp6), &msg_hdr, MSG_DONTWAIT)) != send_len) { 3036 *result = errno; 3037 } 3038 } 3039 if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp6) > -1)) { 3040 if ((res = sendmsg(SCTP_BASE_VAR(userspace_udpsctp6), &msg_hdr, MSG_DONTWAIT)) != send_len) { 3041 *result = errno; 3042 } 3043 } 3044 #else 3045 win_msg_hdr.name = (struct sockaddr *) &dst; 3046 win_msg_hdr.namelen = sizeof(struct sockaddr_in6); 3047 win_msg_hdr.lpBuffers = (LPWSABUF)send_iovec; 3048 win_msg_hdr.dwBufferCount = iovcnt; 3049 winbuf.len = 0; 3050 winbuf.buf = NULL; 3051 win_msg_hdr.Control = winbuf; 3052 win_msg_hdr.dwFlags = 0; 3053 3054 if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp6) > -1)) { 3055 if (WSASendTo(SCTP_BASE_VAR(userspace_rawsctp6), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { 3056 *result = WSAGetLastError(); 3057 } else if (win_sent_len != send_len) { 3058 *result = WSAGetLastError(); 3059 } 3060 } 3061 if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp6) > -1)) { 3062 if (WSASendTo(SCTP_BASE_VAR(userspace_udpsctp6), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { 3063 *result = WSAGetLastError(); 3064 } else if (win_sent_len != send_len) { 3065 *result = WSAGetLastError(); 3066 } 3067 } 3068 #endif 3069 free_mbuf: 3070 sctp_m_freem(m_orig); 3071 } 3072 #endif 3073 3074 void 3075 usrsctp_register_address(void *addr) 3076 { 3077 struct sockaddr_conn sconn; 3078 3079 memset(&sconn, 0, sizeof(struct sockaddr_conn)); 3080 sconn.sconn_family = AF_CONN; 3081 #ifdef HAVE_SCONN_LEN 3082 sconn.sconn_len = sizeof(struct sockaddr_conn); 3083 #endif 3084 sconn.sconn_port = 0; 3085 sconn.sconn_addr = addr; 3086 sctp_add_addr_to_vrf(SCTP_DEFAULT_VRFID, 3087 NULL, 3088 0xffffffff, 3089 0, 3090 "conn", 3091 NULL, 3092 (struct sockaddr *)&sconn, 3093 0, 3094 0); 3095 } 3096 3097 void 3098 usrsctp_deregister_address(void *addr) 3099 { 3100 struct sockaddr_conn sconn; 3101 3102 memset(&sconn, 0, sizeof(struct sockaddr_conn)); 3103 sconn.sconn_family = AF_CONN; 3104 #ifdef HAVE_SCONN_LEN 3105 sconn.sconn_len = sizeof(struct sockaddr_conn); 3106 #endif 3107 sconn.sconn_port = 0; 3108 sconn.sconn_addr = addr; 3109 sctp_del_addr_from_vrf(SCTP_DEFAULT_VRFID, 3110 (struct sockaddr *)&sconn, 3111 0xffffffff, 3112 "conn"); 3113 } 3114 3115 #define PREAMBLE_FORMAT "\n%c %02d:%02d:%02d.%06ld " 3116 #define PREAMBLE_LENGTH 19 3117 #define HEADER "0000 " 3118 #define TRAILER "# SCTP_PACKET\n" 3119 3120 char * 3121 usrsctp_dumppacket(void *buf, size_t len, int outbound) 3122 { 3123 size_t i, pos; 3124 char *dump_buf, *packet; 3125 #ifdef _WIN32 3126 struct timeb tb; 3127 struct tm t; 3128 #else 3129 struct timeval tv; 3130 struct tm *t; 3131 time_t sec; 3132 #endif 3133 3134 if ((len == 0) || (buf == NULL)) { 3135 return (NULL); 3136 } 3137 if ((dump_buf = malloc(PREAMBLE_LENGTH + strlen(HEADER) + 3 * len + strlen(TRAILER) + 1)) == NULL) { 3138 return (NULL); 3139 } 3140 pos = 0; 3141 #ifdef _WIN32 3142 ftime(&tb); 3143 localtime_s(&t, &tb.time); 3144 _snprintf_s(dump_buf, PREAMBLE_LENGTH + 1, PREAMBLE_LENGTH, PREAMBLE_FORMAT, 3145 outbound ? 'O' : 'I', 3146 t.tm_hour, t.tm_min, t.tm_sec, (long)(1000 * tb.millitm)); 3147 #else 3148 gettimeofday(&tv, NULL); 3149 sec = (time_t)tv.tv_sec; 3150 t = localtime((const time_t *)&sec); 3151 snprintf(dump_buf, PREAMBLE_LENGTH + 1, PREAMBLE_FORMAT, 3152 outbound ? 'O' : 'I', 3153 t->tm_hour, t->tm_min, t->tm_sec, (long)tv.tv_usec); 3154 #endif 3155 pos += PREAMBLE_LENGTH; 3156 #ifdef _WIN32 3157 strncpy_s(dump_buf + pos, strlen(HEADER) + 1, HEADER, strlen(HEADER)); 3158 #else 3159 strcpy(dump_buf + pos, HEADER); 3160 #endif 3161 pos += strlen(HEADER); 3162 packet = (char *)buf; 3163 for (i = 0; i < len; i++) { 3164 uint8_t byte, low, high; 3165 3166 byte = (uint8_t)packet[i]; 3167 high = byte / 16; 3168 low = byte % 16; 3169 dump_buf[pos++] = high < 10 ? '0' + high : 'a' + (high - 10); 3170 dump_buf[pos++] = low < 10 ? '0' + low : 'a' + (low - 10); 3171 dump_buf[pos++] = ' '; 3172 } 3173 #ifdef _WIN32 3174 strncpy_s(dump_buf + pos, strlen(TRAILER) + 1, TRAILER, strlen(TRAILER)); 3175 #else 3176 strcpy(dump_buf + pos, TRAILER); 3177 #endif 3178 pos += strlen(TRAILER); 3179 dump_buf[pos++] = '\0'; 3180 return (dump_buf); 3181 } 3182 3183 void 3184 usrsctp_freedumpbuffer(char *buf) 3185 { 3186 free(buf); 3187 } 3188 3189 void 3190 usrsctp_conninput(void *addr, const void *buffer, size_t length, uint8_t ecn_bits) 3191 { 3192 struct sockaddr_conn src, dst; 3193 struct mbuf *m; 3194 struct sctphdr *sh; 3195 struct sctp_chunkhdr *ch; 3196 3197 SCTP_STAT_INCR(sctps_recvpackets); 3198 SCTP_STAT_INCR_COUNTER64(sctps_inpackets); 3199 memset(&src, 0, sizeof(struct sockaddr_conn)); 3200 src.sconn_family = AF_CONN; 3201 #ifdef HAVE_SCONN_LEN 3202 src.sconn_len = sizeof(struct sockaddr_conn); 3203 #endif 3204 src.sconn_addr = addr; 3205 memset(&dst, 0, sizeof(struct sockaddr_conn)); 3206 dst.sconn_family = AF_CONN; 3207 #ifdef HAVE_SCONN_LEN 3208 dst.sconn_len = sizeof(struct sockaddr_conn); 3209 #endif 3210 dst.sconn_addr = addr; 3211 if ((m = sctp_get_mbuf_for_msg(length, 1, M_NOWAIT, 0, MT_DATA)) == NULL) { 3212 return; 3213 } 3214 m_copyback(m, 0, length, (caddr_t)buffer); 3215 if (SCTP_BUF_LEN(m) < (int)(sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr))) { 3216 if ((m = m_pullup(m, sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr))) == NULL) { 3217 SCTP_STAT_INCR(sctps_hdrops); 3218 return; 3219 } 3220 } 3221 sh = mtod(m, struct sctphdr *);; 3222 ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr)); 3223 src.sconn_port = sh->src_port; 3224 dst.sconn_port = sh->dest_port; 3225 sctp_common_input_processing(&m, 0, sizeof(struct sctphdr), length, 3226 (struct sockaddr *)&src, 3227 (struct sockaddr *)&dst, 3228 sh, ch, 3229 #if !defined(SCTP_WITH_NO_CSUM) 3230 1, 3231 #endif 3232 ecn_bits, 3233 SCTP_DEFAULT_VRFID, 0); 3234 if (m) { 3235 sctp_m_freem(m); 3236 } 3237 return; 3238 } 3239 3240 3241 #define USRSCTP_SYSCTL_SET_DEF(__field) \ 3242 void usrsctp_sysctl_set_ ## __field(uint32_t value) { \ 3243 SCTP_BASE_SYSCTL(__field) = value; \ 3244 } 3245 3246 USRSCTP_SYSCTL_SET_DEF(sctp_sendspace) 3247 USRSCTP_SYSCTL_SET_DEF(sctp_recvspace) 3248 USRSCTP_SYSCTL_SET_DEF(sctp_auto_asconf) 3249 USRSCTP_SYSCTL_SET_DEF(sctp_multiple_asconfs) 3250 USRSCTP_SYSCTL_SET_DEF(sctp_ecn_enable) 3251 USRSCTP_SYSCTL_SET_DEF(sctp_pr_enable) 3252 USRSCTP_SYSCTL_SET_DEF(sctp_auth_enable) 3253 USRSCTP_SYSCTL_SET_DEF(sctp_asconf_enable) 3254 USRSCTP_SYSCTL_SET_DEF(sctp_reconfig_enable) 3255 USRSCTP_SYSCTL_SET_DEF(sctp_nrsack_enable) 3256 USRSCTP_SYSCTL_SET_DEF(sctp_pktdrop_enable) 3257 USRSCTP_SYSCTL_SET_DEF(sctp_strict_sacks) 3258 #if !defined(SCTP_WITH_NO_CSUM) 3259 USRSCTP_SYSCTL_SET_DEF(sctp_no_csum_on_loopback) 3260 #endif 3261 USRSCTP_SYSCTL_SET_DEF(sctp_peer_chunk_oh) 3262 USRSCTP_SYSCTL_SET_DEF(sctp_max_burst_default) 3263 USRSCTP_SYSCTL_SET_DEF(sctp_max_chunks_on_queue) 3264 USRSCTP_SYSCTL_SET_DEF(sctp_hashtblsize) 3265 USRSCTP_SYSCTL_SET_DEF(sctp_pcbtblsize) 3266 USRSCTP_SYSCTL_SET_DEF(sctp_min_split_point) 3267 USRSCTP_SYSCTL_SET_DEF(sctp_chunkscale) 3268 USRSCTP_SYSCTL_SET_DEF(sctp_delayed_sack_time_default) 3269 USRSCTP_SYSCTL_SET_DEF(sctp_sack_freq_default) 3270 USRSCTP_SYSCTL_SET_DEF(sctp_system_free_resc_limit) 3271 USRSCTP_SYSCTL_SET_DEF(sctp_asoc_free_resc_limit) 3272 USRSCTP_SYSCTL_SET_DEF(sctp_heartbeat_interval_default) 3273 USRSCTP_SYSCTL_SET_DEF(sctp_pmtu_raise_time_default) 3274 USRSCTP_SYSCTL_SET_DEF(sctp_shutdown_guard_time_default) 3275 USRSCTP_SYSCTL_SET_DEF(sctp_secret_lifetime_default) 3276 USRSCTP_SYSCTL_SET_DEF(sctp_rto_max_default) 3277 USRSCTP_SYSCTL_SET_DEF(sctp_rto_min_default) 3278 USRSCTP_SYSCTL_SET_DEF(sctp_rto_initial_default) 3279 USRSCTP_SYSCTL_SET_DEF(sctp_init_rto_max_default) 3280 USRSCTP_SYSCTL_SET_DEF(sctp_valid_cookie_life_default) 3281 USRSCTP_SYSCTL_SET_DEF(sctp_init_rtx_max_default) 3282 USRSCTP_SYSCTL_SET_DEF(sctp_assoc_rtx_max_default) 3283 USRSCTP_SYSCTL_SET_DEF(sctp_path_rtx_max_default) 3284 USRSCTP_SYSCTL_SET_DEF(sctp_add_more_threshold) 3285 USRSCTP_SYSCTL_SET_DEF(sctp_nr_outgoing_streams_default) 3286 USRSCTP_SYSCTL_SET_DEF(sctp_cmt_on_off) 3287 USRSCTP_SYSCTL_SET_DEF(sctp_cmt_use_dac) 3288 USRSCTP_SYSCTL_SET_DEF(sctp_use_cwnd_based_maxburst) 3289 USRSCTP_SYSCTL_SET_DEF(sctp_nat_friendly) 3290 USRSCTP_SYSCTL_SET_DEF(sctp_L2_abc_variable) 3291 USRSCTP_SYSCTL_SET_DEF(sctp_mbuf_threshold_count) 3292 USRSCTP_SYSCTL_SET_DEF(sctp_do_drain) 3293 USRSCTP_SYSCTL_SET_DEF(sctp_hb_maxburst) 3294 USRSCTP_SYSCTL_SET_DEF(sctp_abort_if_one_2_one_hits_limit) 3295 USRSCTP_SYSCTL_SET_DEF(sctp_strict_data_order) 3296 USRSCTP_SYSCTL_SET_DEF(sctp_min_residual) 3297 USRSCTP_SYSCTL_SET_DEF(sctp_max_retran_chunk) 3298 USRSCTP_SYSCTL_SET_DEF(sctp_logging_level) 3299 USRSCTP_SYSCTL_SET_DEF(sctp_default_cc_module) 3300 USRSCTP_SYSCTL_SET_DEF(sctp_default_frag_interleave) 3301 USRSCTP_SYSCTL_SET_DEF(sctp_mobility_base) 3302 USRSCTP_SYSCTL_SET_DEF(sctp_mobility_fasthandoff) 3303 USRSCTP_SYSCTL_SET_DEF(sctp_inits_include_nat_friendly) 3304 USRSCTP_SYSCTL_SET_DEF(sctp_udp_tunneling_port) 3305 USRSCTP_SYSCTL_SET_DEF(sctp_enable_sack_immediately) 3306 USRSCTP_SYSCTL_SET_DEF(sctp_vtag_time_wait) 3307 USRSCTP_SYSCTL_SET_DEF(sctp_blackhole) 3308 USRSCTP_SYSCTL_SET_DEF(sctp_diag_info_code) 3309 USRSCTP_SYSCTL_SET_DEF(sctp_fr_max_burst_default) 3310 USRSCTP_SYSCTL_SET_DEF(sctp_path_pf_threshold) 3311 USRSCTP_SYSCTL_SET_DEF(sctp_default_ss_module) 3312 USRSCTP_SYSCTL_SET_DEF(sctp_rttvar_bw) 3313 USRSCTP_SYSCTL_SET_DEF(sctp_rttvar_rtt) 3314 USRSCTP_SYSCTL_SET_DEF(sctp_rttvar_eqret) 3315 USRSCTP_SYSCTL_SET_DEF(sctp_steady_step) 3316 USRSCTP_SYSCTL_SET_DEF(sctp_use_dccc_ecn) 3317 USRSCTP_SYSCTL_SET_DEF(sctp_buffer_splitting) 3318 USRSCTP_SYSCTL_SET_DEF(sctp_initial_cwnd) 3319 #ifdef SCTP_DEBUG 3320 USRSCTP_SYSCTL_SET_DEF(sctp_debug_on) 3321 #endif 3322 3323 #define USRSCTP_SYSCTL_GET_DEF(__field) \ 3324 uint32_t usrsctp_sysctl_get_ ## __field(void) { \ 3325 return SCTP_BASE_SYSCTL(__field); \ 3326 } 3327 3328 USRSCTP_SYSCTL_GET_DEF(sctp_sendspace) 3329 USRSCTP_SYSCTL_GET_DEF(sctp_recvspace) 3330 USRSCTP_SYSCTL_GET_DEF(sctp_auto_asconf) 3331 USRSCTP_SYSCTL_GET_DEF(sctp_multiple_asconfs) 3332 USRSCTP_SYSCTL_GET_DEF(sctp_ecn_enable) 3333 USRSCTP_SYSCTL_GET_DEF(sctp_pr_enable) 3334 USRSCTP_SYSCTL_GET_DEF(sctp_auth_enable) 3335 USRSCTP_SYSCTL_GET_DEF(sctp_asconf_enable) 3336 USRSCTP_SYSCTL_GET_DEF(sctp_reconfig_enable) 3337 USRSCTP_SYSCTL_GET_DEF(sctp_nrsack_enable) 3338 USRSCTP_SYSCTL_GET_DEF(sctp_pktdrop_enable) 3339 USRSCTP_SYSCTL_GET_DEF(sctp_strict_sacks) 3340 #if !defined(SCTP_WITH_NO_CSUM) 3341 USRSCTP_SYSCTL_GET_DEF(sctp_no_csum_on_loopback) 3342 #endif 3343 USRSCTP_SYSCTL_GET_DEF(sctp_peer_chunk_oh) 3344 USRSCTP_SYSCTL_GET_DEF(sctp_max_burst_default) 3345 USRSCTP_SYSCTL_GET_DEF(sctp_max_chunks_on_queue) 3346 USRSCTP_SYSCTL_GET_DEF(sctp_hashtblsize) 3347 USRSCTP_SYSCTL_GET_DEF(sctp_pcbtblsize) 3348 USRSCTP_SYSCTL_GET_DEF(sctp_min_split_point) 3349 USRSCTP_SYSCTL_GET_DEF(sctp_chunkscale) 3350 USRSCTP_SYSCTL_GET_DEF(sctp_delayed_sack_time_default) 3351 USRSCTP_SYSCTL_GET_DEF(sctp_sack_freq_default) 3352 USRSCTP_SYSCTL_GET_DEF(sctp_system_free_resc_limit) 3353 USRSCTP_SYSCTL_GET_DEF(sctp_asoc_free_resc_limit) 3354 USRSCTP_SYSCTL_GET_DEF(sctp_heartbeat_interval_default) 3355 USRSCTP_SYSCTL_GET_DEF(sctp_pmtu_raise_time_default) 3356 USRSCTP_SYSCTL_GET_DEF(sctp_shutdown_guard_time_default) 3357 USRSCTP_SYSCTL_GET_DEF(sctp_secret_lifetime_default) 3358 USRSCTP_SYSCTL_GET_DEF(sctp_rto_max_default) 3359 USRSCTP_SYSCTL_GET_DEF(sctp_rto_min_default) 3360 USRSCTP_SYSCTL_GET_DEF(sctp_rto_initial_default) 3361 USRSCTP_SYSCTL_GET_DEF(sctp_init_rto_max_default) 3362 USRSCTP_SYSCTL_GET_DEF(sctp_valid_cookie_life_default) 3363 USRSCTP_SYSCTL_GET_DEF(sctp_init_rtx_max_default) 3364 USRSCTP_SYSCTL_GET_DEF(sctp_assoc_rtx_max_default) 3365 USRSCTP_SYSCTL_GET_DEF(sctp_path_rtx_max_default) 3366 USRSCTP_SYSCTL_GET_DEF(sctp_add_more_threshold) 3367 USRSCTP_SYSCTL_GET_DEF(sctp_nr_outgoing_streams_default) 3368 USRSCTP_SYSCTL_GET_DEF(sctp_cmt_on_off) 3369 USRSCTP_SYSCTL_GET_DEF(sctp_cmt_use_dac) 3370 USRSCTP_SYSCTL_GET_DEF(sctp_use_cwnd_based_maxburst) 3371 USRSCTP_SYSCTL_GET_DEF(sctp_nat_friendly) 3372 USRSCTP_SYSCTL_GET_DEF(sctp_L2_abc_variable) 3373 USRSCTP_SYSCTL_GET_DEF(sctp_mbuf_threshold_count) 3374 USRSCTP_SYSCTL_GET_DEF(sctp_do_drain) 3375 USRSCTP_SYSCTL_GET_DEF(sctp_hb_maxburst) 3376 USRSCTP_SYSCTL_GET_DEF(sctp_abort_if_one_2_one_hits_limit) 3377 USRSCTP_SYSCTL_GET_DEF(sctp_strict_data_order) 3378 USRSCTP_SYSCTL_GET_DEF(sctp_min_residual) 3379 USRSCTP_SYSCTL_GET_DEF(sctp_max_retran_chunk) 3380 USRSCTP_SYSCTL_GET_DEF(sctp_logging_level) 3381 USRSCTP_SYSCTL_GET_DEF(sctp_default_cc_module) 3382 USRSCTP_SYSCTL_GET_DEF(sctp_default_frag_interleave) 3383 USRSCTP_SYSCTL_GET_DEF(sctp_mobility_base) 3384 USRSCTP_SYSCTL_GET_DEF(sctp_mobility_fasthandoff) 3385 USRSCTP_SYSCTL_GET_DEF(sctp_inits_include_nat_friendly) 3386 USRSCTP_SYSCTL_GET_DEF(sctp_udp_tunneling_port) 3387 USRSCTP_SYSCTL_GET_DEF(sctp_enable_sack_immediately) 3388 USRSCTP_SYSCTL_GET_DEF(sctp_vtag_time_wait) 3389 USRSCTP_SYSCTL_GET_DEF(sctp_blackhole) 3390 USRSCTP_SYSCTL_GET_DEF(sctp_diag_info_code) 3391 USRSCTP_SYSCTL_GET_DEF(sctp_fr_max_burst_default) 3392 USRSCTP_SYSCTL_GET_DEF(sctp_path_pf_threshold) 3393 USRSCTP_SYSCTL_GET_DEF(sctp_default_ss_module) 3394 USRSCTP_SYSCTL_GET_DEF(sctp_rttvar_bw) 3395 USRSCTP_SYSCTL_GET_DEF(sctp_rttvar_rtt) 3396 USRSCTP_SYSCTL_GET_DEF(sctp_rttvar_eqret) 3397 USRSCTP_SYSCTL_GET_DEF(sctp_steady_step) 3398 USRSCTP_SYSCTL_GET_DEF(sctp_use_dccc_ecn) 3399 USRSCTP_SYSCTL_GET_DEF(sctp_buffer_splitting) 3400 USRSCTP_SYSCTL_GET_DEF(sctp_initial_cwnd) 3401 #ifdef SCTP_DEBUG 3402 USRSCTP_SYSCTL_GET_DEF(sctp_debug_on) 3403 #endif 3404 3405 void usrsctp_get_stat(struct sctpstat *stat) 3406 { 3407 *stat = SCTP_BASE_STATS; 3408 } 3409
