lib/libc/net/sctp_sys_calls.c

   1 /*-
   2  * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved.
   3  * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved.
   4  * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * a) Redistributions of source code must retain the above copyright notice,
  10  *    this list of conditions and the following disclaimer.
  11  *
  12  * b) Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the distribution.
  15  *
  16  * c) Neither the name of Cisco Systems, Inc. nor the names of its
  17  *    contributors may be used to endorse or promote products derived
  18  *    from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <errno.h>
  39 #include <stdlib.h>
  40 #include <unistd.h>
  41 #include <sys/types.h>
  42 #include <sys/socket.h>
  43 #include <sys/errno.h>
  44 #include <sys/syscall.h>
  45 #include <sys/uio.h>
  46 #include <netinet/in.h>
  47 #include <arpa/inet.h>
  48 #include <netinet/sctp_uio.h>
  49 #include <netinet/sctp.h>
  50
  51 #ifndef IN6_IS_ADDR_V4MAPPED
  52 #define IN6_IS_ADDR_V4MAPPED(a)               \
  53         ((*(const uint32_t *)(const void *)(&(a)->s6_addr[0]) == 0) &&  \
  54          (*(const uint32_t *)(const void *)(&(a)->s6_addr[4]) == 0) &&  \
  55          (*(const uint32_t *)(const void *)(&(a)->s6_addr[8]) == ntohl(0x0000ffff)))
  56 #endif
  57
  58 #define SCTP_CONTROL_VEC_SIZE_RCV  16384
  59
  60
  61 static void
  62 in6_sin6_2_sin(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
  63 {
  64         bzero(sin, sizeof(*sin));
  65         sin->sin_len = sizeof(struct sockaddr_in);
  66         sin->sin_family = AF_INET;
  67         sin->sin_port = sin6->sin6_port;
  68         sin->sin_addr.s_addr = sin6->sin6_addr.__u6_addr.__u6_addr32[3];
  69 }
  70
  71 int
  72 sctp_getaddrlen(sa_family_t family)
  73 {
  74         int ret, sd;
  75         socklen_t siz;
  76         struct sctp_assoc_value av;
  77
  78         av.assoc_value = family;
  79         siz = sizeof(av);
  80 #if defined(AF_INET)
  81         sd = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
  82 #elif defined(AF_INET6)
  83         sd = socket(AF_INET6, SOCK_SEQPACKET, IPPROTO_SCTP);
  84 #else
  85         sd = -1;
  86 #endif
  87         if (sd == -1) {
  88                 return (-1);
  89         }
  90         ret = getsockopt(sd, IPPROTO_SCTP, SCTP_GET_ADDR_LEN, &av, &siz);
  91         close(sd);
  92         if (ret == 0) {
  93                 return ((int)av.assoc_value);
  94         } else {
  95                 return (-1);
  96         }
  97 }
  98
  99 int
 100 sctp_connectx(int sd, const struct sockaddr *addrs, int addrcnt,
 101     sctp_assoc_t * id)
 102 {
 103         char *buf;
 104         int i, ret, cnt, *aa;
 105         char *cpto;
 106         const struct sockaddr *at;
 107         size_t len = sizeof(int);
 108
 109         /* validate the address count and list */
 110         if ((addrs == NULL) || (addrcnt <= 0)) {
 111                 errno = EINVAL;
 112                 return (-1);
 113         }
 114         if ((buf = malloc(sizeof(int) + (size_t)addrcnt * sizeof(struct sockaddr_in6))) == NULL) {
 115                 errno = E2BIG;
 116                 return (-1);
 117         }
 118         at = addrs;
 119         cnt = 0;
 120         cpto = buf + sizeof(int);
 121         /* validate all the addresses and get the size */
 122         for (i = 0; i < addrcnt; i++) {
 123                 switch (at->sa_family) {
 124                 case AF_INET:
 125                         if (at->sa_len != sizeof(struct sockaddr_in)) {
 126                                 free(buf);
 127                                 errno = EINVAL;
 128                                 return (-1);
 129                         }
 130                         memcpy(cpto, at, sizeof(struct sockaddr_in));
 131                         cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in));
 132                         len += sizeof(struct sockaddr_in);
 133                         break;
 134                 case AF_INET6:
 135                         if (at->sa_len != sizeof(struct sockaddr_in6)) {
 136                                 free(buf);
 137                                 errno = EINVAL;
 138                                 return (-1);
 139                         }
 140                         if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)at)->sin6_addr)) {
 141                                 in6_sin6_2_sin((struct sockaddr_in *)cpto, (struct sockaddr_in6 *)at);
 142                                 cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in));
 143                                 len += sizeof(struct sockaddr_in);
 144                         } else {
 145                                 memcpy(cpto, at, sizeof(struct sockaddr_in6));
 146                                 cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in6));
 147                                 len += sizeof(struct sockaddr_in6);
 148                         }
 149                         break;
 150                 default:
 151                         free(buf);
 152                         errno = EINVAL;
 153                         return (-1);
 154                 }
 155                 at = (struct sockaddr *)((caddr_t)at + at->sa_len);
 156         }
 157         aa = (int *)buf;
 158         *aa = addrcnt;
 159         ret = setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X, (void *)buf,
 160             (socklen_t) len);
 161         if ((ret == 0) && (id != NULL)) {
 162                 *id = *(sctp_assoc_t *) buf;
 163         }
 164         return (ret);
 165 }
 166
 167 int
 168 sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt, int flags)
 169 {
 170         struct sctp_getaddresses *gaddrs;
 171         struct sockaddr *sa;
 172         struct sockaddr_in *sin;
 173         struct sockaddr_in6 *sin6;
 174         int i;
 175         size_t argsz;
 176         uint16_t sport = 0;
 177
 178         /* validate the flags */
 179         if ((flags != SCTP_BINDX_ADD_ADDR) &&
 180             (flags != SCTP_BINDX_REM_ADDR)) {
 181                 errno = EFAULT;
 182                 return (-1);
 183         }
 184         /* validate the address count and list */
 185         if ((addrcnt <= 0) || (addrs == NULL)) {
 186                 errno = EINVAL;
 187                 return (-1);
 188         }
 189         /* First pre-screen the addresses */
 190         sa = addrs;
 191         for (i = 0; i < addrcnt; i++) {
 192                 switch (sa->sa_family) {
 193                 case AF_INET:
 194                         if (sa->sa_len != sizeof(struct sockaddr_in)) {
 195                                 errno = EINVAL;
 196                                 return (-1);
 197                         }
 198                         sin = (struct sockaddr_in *)sa;
 199                         if (sin->sin_port) {
 200                                 /* non-zero port, check or save */
 201                                 if (sport) {
 202                                         /* Check against our port */
 203                                         if (sport != sin->sin_port) {
 204                                                 errno = EINVAL;
 205                                                 return (-1);
 206                                         }
 207                                 } else {
 208                                         /* save off the port */
 209                                         sport = sin->sin_port;
 210                                 }
 211                         }
 212                         break;
 213                 case AF_INET6:
 214                         if (sa->sa_len != sizeof(struct sockaddr_in6)) {
 215                                 errno = EINVAL;
 216                                 return (-1);
 217                         }
 218                         sin6 = (struct sockaddr_in6 *)sa;
 219                         if (sin6->sin6_port) {
 220                                 /* non-zero port, check or save */
 221                                 if (sport) {
 222                                         /* Check against our port */
 223                                         if (sport != sin6->sin6_port) {
 224                                                 errno = EINVAL;
 225                                                 return (-1);
 226                                         }
 227                                 } else {
 228                                         /* save off the port */
 229                                         sport = sin6->sin6_port;
 230                                 }
 231                         }
 232                         break;
 233                 default:
 234                         /* Invalid address family specified. */
 235                         errno = EINVAL;
 236                         return (-1);
 237                 }
 238                 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
 239         }
 240         /*
 241          * Now if there was a port mentioned, assure that the first address
 242          * has that port to make sure it fails or succeeds correctly.
 243          */
 244         if (sport) {
 245                 sin = (struct sockaddr_in *)sa;
 246                 sin->sin_port = sport;
 247         }
 248         argsz = sizeof(struct sctp_getaddresses) +
 249             sizeof(struct sockaddr_storage);
 250         if ((gaddrs = (struct sctp_getaddresses *)malloc(argsz)) == NULL) {
 251                 errno = ENOMEM;
 252                 return (-1);
 253         }
 254         sa = addrs;
 255         for (i = 0; i < addrcnt; i++) {
 256                 memset(gaddrs, 0, argsz);
 257                 gaddrs->sget_assoc_id = 0;
 258                 memcpy(gaddrs->addr, sa, sa->sa_len);
 259                 if (setsockopt(sd, IPPROTO_SCTP, flags, gaddrs,
 260                     (socklen_t) argsz) != 0) {
 261                         free(gaddrs);
 262                         return (-1);
 263                 }
 264                 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
 265         }
 266         free(gaddrs);
 267         return (0);
 268 }
 269
 270 int
 271 sctp_opt_info(int sd, sctp_assoc_t id, int opt, void *arg, socklen_t * size)
 272 {
 273         if (arg == NULL) {
 274                 errno = EINVAL;
 275                 return (-1);
 276         }
 277         if ((id == SCTP_CURRENT_ASSOC) ||
 278             (id == SCTP_ALL_ASSOC)) {
 279                 errno = EINVAL;
 280                 return (-1);
 281         }
 282         switch (opt) {
 283         case SCTP_RTOINFO:
 284                 ((struct sctp_rtoinfo *)arg)->srto_assoc_id = id;
 285                 break;
 286         case SCTP_ASSOCINFO:
 287                 ((struct sctp_assocparams *)arg)->sasoc_assoc_id = id;
 288                 break;
 289         case SCTP_DEFAULT_SEND_PARAM:
 290                 ((struct sctp_assocparams *)arg)->sasoc_assoc_id = id;
 291                 break;
 292         case SCTP_PRIMARY_ADDR:
 293                 ((struct sctp_setprim *)arg)->ssp_assoc_id = id;
 294                 break;
 295         case SCTP_PEER_ADDR_PARAMS:
 296                 ((struct sctp_paddrparams *)arg)->spp_assoc_id = id;
 297                 break;
 298         case SCTP_MAXSEG:
 299                 ((struct sctp_assoc_value *)arg)->assoc_id = id;
 300                 break;
 301         case SCTP_AUTH_KEY:
 302                 ((struct sctp_authkey *)arg)->sca_assoc_id = id;
 303                 break;
 304         case SCTP_AUTH_ACTIVE_KEY:
 305                 ((struct sctp_authkeyid *)arg)->scact_assoc_id = id;
 306                 break;
 307         case SCTP_DELAYED_SACK:
 308                 ((struct sctp_sack_info *)arg)->sack_assoc_id = id;
 309                 break;
 310         case SCTP_CONTEXT:
 311                 ((struct sctp_assoc_value *)arg)->assoc_id = id;
 312                 break;
 313         case SCTP_STATUS:
 314                 ((struct sctp_status *)arg)->sstat_assoc_id = id;
 315                 break;
 316         case SCTP_GET_PEER_ADDR_INFO:
 317                 ((struct sctp_paddrinfo *)arg)->spinfo_assoc_id = id;
 318                 break;
 319         case SCTP_PEER_AUTH_CHUNKS:
 320                 ((struct sctp_authchunks *)arg)->gauth_assoc_id = id;
 321                 break;
 322         case SCTP_LOCAL_AUTH_CHUNKS:
 323                 ((struct sctp_authchunks *)arg)->gauth_assoc_id = id;
 324                 break;
 325         case SCTP_TIMEOUTS:
 326                 ((struct sctp_timeouts *)arg)->stimo_assoc_id = id;
 327                 break;
 328         case SCTP_EVENT:
 329                 ((struct sctp_event *)arg)->se_assoc_id = id;
 330                 break;
 331         case SCTP_DEFAULT_SNDINFO:
 332                 ((struct sctp_sndinfo *)arg)->snd_assoc_id = id;
 333                 break;
 334         case SCTP_DEFAULT_PRINFO:
 335                 ((struct sctp_default_prinfo *)arg)->pr_assoc_id = id;
 336                 break;
 337         case SCTP_PEER_ADDR_THLDS:
 338                 ((struct sctp_paddrthlds *)arg)->spt_assoc_id = id;
 339                 break;
 340         case SCTP_REMOTE_UDP_ENCAPS_PORT:
 341                 ((struct sctp_udpencaps *)arg)->sue_assoc_id = id;
 342                 break;
 343         case SCTP_ENABLE_STREAM_RESET:
 344                 ((struct sctp_assoc_value *)arg)->assoc_id = id;
 345                 break;
 346         default:
 347                 break;
 348         }
 349         return (getsockopt(sd, IPPROTO_SCTP, opt, arg, size));
 350 }
 351
 352 int
 353 sctp_getpaddrs(int sd, sctp_assoc_t id, struct sockaddr **raddrs)
 354 {
 355         struct sctp_getaddresses *addrs;
 356         struct sockaddr *sa;
 357         sctp_assoc_t asoc;
 358         caddr_t lim;
 359         socklen_t opt_len;
 360         int cnt;
 361
 362         if (raddrs == NULL) {
 363                 errno = EFAULT;
 364                 return (-1);
 365         }
 366         asoc = id;
 367         opt_len = (socklen_t) sizeof(sctp_assoc_t);
 368         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_REMOTE_ADDR_SIZE,
 369             &asoc, &opt_len) != 0) {
 370                 return (-1);
 371         }
 372         /* size required is returned in 'asoc' */
 373         opt_len = (socklen_t) ((size_t)asoc + sizeof(struct sctp_getaddresses));
 374         addrs = calloc(1, (size_t)opt_len);
 375         if (addrs == NULL) {
 376                 errno = ENOMEM;
 377                 return (-1);
 378         }
 379         addrs->sget_assoc_id = id;
 380         /* Now lets get the array of addresses */
 381         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_PEER_ADDRESSES,
 382             addrs, &opt_len) != 0) {
 383                 free(addrs);
 384                 return (-1);
 385         }
 386         *raddrs = (struct sockaddr *)&addrs->addr[0];
 387         cnt = 0;
 388         sa = (struct sockaddr *)&addrs->addr[0];
 389         lim = (caddr_t)addrs + opt_len;
 390         while (((caddr_t)sa < lim) && (sa->sa_len > 0)) {
 391                 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
 392                 cnt++;
 393         }
 394         return (cnt);
 395 }
 396
 397 void
 398 sctp_freepaddrs(struct sockaddr *addrs)
 399 {
 400         void *fr_addr;
 401
 402         /* Take away the hidden association id */
 403         fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
 404         /* Now free it */
 405         free(fr_addr);
 406 }
 407
 408 int
 409 sctp_getladdrs(int sd, sctp_assoc_t id, struct sockaddr **raddrs)
 410 {
 411         struct sctp_getaddresses *addrs;
 412         caddr_t lim;
 413         struct sockaddr *sa;
 414         size_t size_of_addresses;
 415         socklen_t opt_len;
 416         int cnt;
 417
 418         if (raddrs == NULL) {
 419                 errno = EFAULT;
 420                 return (-1);
 421         }
 422         size_of_addresses = 0;
 423         opt_len = (socklen_t) sizeof(int);
 424         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDR_SIZE,
 425             &size_of_addresses, &opt_len) != 0) {
 426                 errno = ENOMEM;
 427                 return (-1);
 428         }
 429         if (size_of_addresses == 0) {
 430                 errno = ENOTCONN;
 431                 return (-1);
 432         }
 433         opt_len = (socklen_t) (size_of_addresses +
 434             sizeof(struct sockaddr_storage) +
 435             sizeof(struct sctp_getaddresses));
 436         addrs = calloc(1, (size_t)opt_len);
 437         if (addrs == NULL) {
 438                 errno = ENOMEM;
 439                 return (-1);
 440         }
 441         addrs->sget_assoc_id = id;
 442         /* Now lets get the array of addresses */
 443         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDRESSES, addrs,
 444             &opt_len) != 0) {
 445                 free(addrs);
 446                 errno = ENOMEM;
 447                 return (-1);
 448         }
 449         *raddrs = (struct sockaddr *)&addrs->addr[0];
 450         cnt = 0;
 451         sa = (struct sockaddr *)&addrs->addr[0];
 452         lim = (caddr_t)addrs + opt_len;
 453         while (((caddr_t)sa < lim) && (sa->sa_len > 0)) {
 454                 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
 455                 cnt++;
 456         }
 457         return (cnt);
 458 }
 459
 460 void
 461 sctp_freeladdrs(struct sockaddr *addrs)
 462 {
 463         void *fr_addr;
 464
 465         /* Take away the hidden association id */
 466         fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
 467         /* Now free it */
 468         free(fr_addr);
 469 }
 470
 471 ssize_t
 472 sctp_sendmsg(int s,
 473     const void *data,
 474     size_t len,
 475     const struct sockaddr *to,
 476     socklen_t tolen,
 477     uint32_t ppid,
 478     uint32_t flags,
 479     uint16_t stream_no,
 480     uint32_t timetolive,
 481     uint32_t context)
 482 {
 483 #ifdef SYS_sctp_generic_sendmsg
 484         struct sctp_sndrcvinfo sinfo;
 485
 486         memset(&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
 487         sinfo.sinfo_ppid = ppid;
 488         sinfo.sinfo_flags = flags;
 489         sinfo.sinfo_stream = stream_no;
 490         sinfo.sinfo_timetolive = timetolive;
 491         sinfo.sinfo_context = context;
 492         sinfo.sinfo_assoc_id = 0;
 493         return (syscall(SYS_sctp_generic_sendmsg, s,
 494             data, len, to, tolen, &sinfo, 0));
 495 #else
 496         struct msghdr msg;
 497         struct sctp_sndrcvinfo *sinfo;
 498         struct iovec iov;
 499         char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
 500         struct cmsghdr *cmsg;
 501         struct sockaddr *who = NULL;
 502         union {
 503                 struct sockaddr_in in;
 504                 struct sockaddr_in6 in6;
 505         }     addr;
 506
 507         if ((tolen > 0) &&
 508             ((to == NULL) || (tolen < sizeof(struct sockaddr)))) {
 509                 errno = EINVAL;
 510                 return (-1);
 511         }
 512         if ((to != NULL) && (tolen > 0)) {
 513                 switch (to->sa_family) {
 514                 case AF_INET:
 515                         if (tolen != sizeof(struct sockaddr_in)) {
 516                                 errno = EINVAL;
 517                                 return (-1);
 518                         }
 519                         if ((to->sa_len > 0) &&
 520                             (to->sa_len != sizeof(struct sockaddr_in))) {
 521                                 errno = EINVAL;
 522                                 return (-1);
 523                         }
 524                         memcpy(&addr, to, sizeof(struct sockaddr_in));
 525                         addr.in.sin_len = sizeof(struct sockaddr_in);
 526                         break;
 527                 case AF_INET6:
 528                         if (tolen != sizeof(struct sockaddr_in6)) {
 529                                 errno = EINVAL;
 530                                 return (-1);
 531                         }
 532                         if ((to->sa_len > 0) &&
 533                             (to->sa_len != sizeof(struct sockaddr_in6))) {
 534                                 errno = EINVAL;
 535                                 return (-1);
 536                         }
 537                         memcpy(&addr, to, sizeof(struct sockaddr_in6));
 538                         addr.in6.sin6_len = sizeof(struct sockaddr_in6);
 539                         break;
 540                 default:
 541                         errno = EAFNOSUPPORT;
 542                         return (-1);
 543                 }
 544                 who = (struct sockaddr *)&addr;
 545         }
 546         iov.iov_base = (char *)data;
 547         iov.iov_len = len;
 548
 549         if (who) {
 550                 msg.msg_name = (caddr_t)who;
 551                 msg.msg_namelen = who->sa_len;
 552         } else {
 553                 msg.msg_name = (caddr_t)NULL;
 554                 msg.msg_namelen = 0;
 555         }
 556         msg.msg_iov = &iov;
 557         msg.msg_iovlen = 1;
 558         msg.msg_control = cmsgbuf;
 559         msg.msg_controllen = CMSG_SPACE(sizeof(struct sctp_sndrcvinfo));
 560         cmsg = (struct cmsghdr *)cmsgbuf;
 561         cmsg->cmsg_level = IPPROTO_SCTP;
 562         cmsg->cmsg_type = SCTP_SNDRCV;
 563         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
 564         sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
 565         sinfo->sinfo_stream = stream_no;
 566         sinfo->sinfo_ssn = 0;
 567         sinfo->sinfo_flags = flags;
 568         sinfo->sinfo_ppid = ppid;
 569         sinfo->sinfo_context = context;
 570         sinfo->sinfo_assoc_id = 0;
 571         sinfo->sinfo_timetolive = timetolive;
 572         return (sendmsg(s, &msg, 0));
 573 #endif
 574 }
 575
 576
 577 sctp_assoc_t
 578 sctp_getassocid(int sd, struct sockaddr *sa)
 579 {
 580         struct sctp_paddrinfo sp;
 581         socklen_t siz;
 582
 583         /* First get the assoc id */
 584         siz = sizeof(sp);
 585         memset(&sp, 0, sizeof(sp));
 586         memcpy((caddr_t)&sp.spinfo_address, sa, sa->sa_len);
 587         if (getsockopt(sd, IPPROTO_SCTP,
 588             SCTP_GET_PEER_ADDR_INFO, &sp, &siz) != 0) {
 589                 /* We depend on the fact that 0 can never be returned */
 590                 return ((sctp_assoc_t) 0);
 591         }
 592         return (sp.spinfo_assoc_id);
 593 }
 594
 595 ssize_t
 596 sctp_send(int sd, const void *data, size_t len,
 597     const struct sctp_sndrcvinfo *sinfo,
 598     int flags)
 599 {
 600
 601 #ifdef SYS_sctp_generic_sendmsg
 602         struct sockaddr *to = NULL;
 603
 604         return (syscall(SYS_sctp_generic_sendmsg, sd,
 605             data, len, to, 0, sinfo, flags));
 606 #else
 607         struct msghdr msg;
 608         struct iovec iov;
 609         char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
 610         struct cmsghdr *cmsg;
 611
 612         if (sinfo == NULL) {
 613                 errno = EINVAL;
 614                 return (-1);
 615         }
 616         iov.iov_base = (char *)data;
 617         iov.iov_len = len;
 618
 619         msg.msg_name = NULL;
 620         msg.msg_namelen = 0;
 621         msg.msg_iov = &iov;
 622         msg.msg_iovlen = 1;
 623         msg.msg_control = cmsgbuf;
 624         msg.msg_controllen = CMSG_SPACE(sizeof(struct sctp_sndrcvinfo));
 625         cmsg = (struct cmsghdr *)cmsgbuf;
 626         cmsg->cmsg_level = IPPROTO_SCTP;
 627         cmsg->cmsg_type = SCTP_SNDRCV;
 628         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
 629         memcpy(CMSG_DATA(cmsg), sinfo, sizeof(struct sctp_sndrcvinfo));
 630         return (sendmsg(sd, &msg, flags));
 631 #endif
 632 }
 633
 634
 635
 636 ssize_t
 637 sctp_sendx(int sd, const void *msg, size_t msg_len,
 638     struct sockaddr *addrs, int addrcnt,
 639     struct sctp_sndrcvinfo *sinfo,
 640     int flags)
 641 {
 642         struct sctp_sndrcvinfo __sinfo;
 643         ssize_t ret;
 644         int i, cnt, *aa, saved_errno;
 645         char *buf;
 646         int no_end_cx = 0;
 647         size_t len, add_len;
 648         struct sockaddr *at;
 649
 650         if (addrs == NULL) {
 651                 errno = EINVAL;
 652                 return (-1);
 653         }
 654 #ifdef SYS_sctp_generic_sendmsg
 655         if (addrcnt == 1) {
 656                 socklen_t l;
 657
 658                 /*
 659                  * Quick way, we don't need to do a connectx so lets use the
 660                  * syscall directly.
 661                  */
 662                 l = addrs->sa_len;
 663                 return (syscall(SYS_sctp_generic_sendmsg, sd,
 664                     msg, msg_len, addrs, l, sinfo, flags));
 665         }
 666 #endif
 667
 668         len = sizeof(int);
 669         at = addrs;
 670         cnt = 0;
 671         /* validate all the addresses and get the size */
 672         for (i = 0; i < addrcnt; i++) {
 673                 if (at->sa_family == AF_INET) {
 674                         add_len = sizeof(struct sockaddr_in);
 675                 } else if (at->sa_family == AF_INET6) {
 676                         add_len = sizeof(struct sockaddr_in6);
 677                 } else {
 678                         errno = EINVAL;
 679                         return (-1);
 680                 }
 681                 len += add_len;
 682                 at = (struct sockaddr *)((caddr_t)at + add_len);
 683                 cnt++;
 684         }
 685         /* do we have any? */
 686         if (cnt == 0) {
 687                 errno = EINVAL;
 688                 return (-1);
 689         }
 690         buf = malloc(len);
 691         if (buf == NULL) {
 692                 errno = ENOMEM;
 693                 return (-1);
 694         }
 695         aa = (int *)buf;
 696         *aa = cnt;
 697         aa++;
 698         memcpy((caddr_t)aa, addrs, (size_t)(len - sizeof(int)));
 699         ret = setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_DELAYED, (void *)buf,
 700             (socklen_t) len);
 701
 702         free(buf);
 703         if (ret != 0) {
 704                 if (errno == EALREADY) {
 705                         no_end_cx = 1;
 706                         goto continue_send;
 707                 }
 708                 return (ret);
 709         }
 710 continue_send:
 711         if (sinfo == NULL) {
 712                 sinfo = &__sinfo;
 713                 memset(&__sinfo, 0, sizeof(__sinfo));
 714         }
 715         sinfo->sinfo_assoc_id = sctp_getassocid(sd, addrs);
 716         if (sinfo->sinfo_assoc_id == 0) {
 717                 (void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
 718                     (socklen_t) addrs->sa_len);
 719                 errno = ENOENT;
 720                 return (-1);
 721         }
 722         ret = sctp_send(sd, msg, msg_len, sinfo, flags);
 723         saved_errno = errno;
 724         if (no_end_cx == 0)
 725                 (void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
 726                     (socklen_t) addrs->sa_len);
 727
 728         errno = saved_errno;
 729         return (ret);
 730 }
 731
 732 ssize_t
 733 sctp_sendmsgx(int sd,
 734     const void *msg,
 735     size_t len,
 736     struct sockaddr *addrs,
 737     int addrcnt,
 738     uint32_t ppid,
 739     uint32_t flags,
 740     uint16_t stream_no,
 741     uint32_t timetolive,
 742     uint32_t context)
 743 {
 744         struct sctp_sndrcvinfo sinfo;
 745
 746         memset((void *)&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
 747         sinfo.sinfo_ppid = ppid;
 748         sinfo.sinfo_flags = flags;
 749         sinfo.sinfo_ssn = stream_no;
 750         sinfo.sinfo_timetolive = timetolive;
 751         sinfo.sinfo_context = context;
 752         return (sctp_sendx(sd, msg, len, addrs, addrcnt, &sinfo, 0));
 753 }
 754
 755 ssize_t
 756 sctp_recvmsg(int s,
 757     void *dbuf,
 758     size_t len,
 759     struct sockaddr *from,
 760     socklen_t * fromlen,
 761     struct sctp_sndrcvinfo *sinfo,
 762     int *msg_flags)
 763 {
 764 #ifdef SYS_sctp_generic_recvmsg
 765         struct iovec iov;
 766
 767         iov.iov_base = dbuf;
 768         iov.iov_len = len;
 769         return (syscall(SYS_sctp_generic_recvmsg, s,
 770             &iov, 1, from, fromlen, sinfo, msg_flags));
 771 #else
 772         ssize_t sz;
 773         struct msghdr msg;
 774         struct iovec iov;
 775         char cmsgbuf[SCTP_CONTROL_VEC_SIZE_RCV];
 776         struct cmsghdr *cmsg;
 777
 778         if (msg_flags == NULL) {
 779                 errno = EINVAL;
 780                 return (-1);
 781         }
 782         msg.msg_flags = 0;
 783         iov.iov_base = dbuf;
 784         iov.iov_len = len;
 785         msg.msg_name = (caddr_t)from;
 786         if (fromlen == NULL)
 787                 msg.msg_namelen = 0;
 788         else
 789                 msg.msg_namelen = *fromlen;
 790         msg.msg_iov = &iov;
 791         msg.msg_iovlen = 1;
 792         msg.msg_control = cmsgbuf;
 793         msg.msg_controllen = sizeof(cmsgbuf);
 794         sz = recvmsg(s, &msg, *msg_flags);
 795         *msg_flags = msg.msg_flags;
 796         if (sz <= 0) {
 797                 return (sz);
 798         }
 799         if (sinfo) {
 800                 sinfo->sinfo_assoc_id = 0;
 801         }
 802         if ((msg.msg_controllen > 0) && (sinfo != NULL)) {
 803                 /*
 804                  * parse through and see if we find the sctp_sndrcvinfo (if
 805                  * the user wants it).
 806                  */
 807                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 808                         if (cmsg->cmsg_level != IPPROTO_SCTP) {
 809                                 continue;
 810                         }
 811                         if (cmsg->cmsg_type == SCTP_SNDRCV) {
 812                                 memcpy(sinfo, CMSG_DATA(cmsg), sizeof(struct sctp_sndrcvinfo));
 813                                 break;
 814                         }
 815                         if (cmsg->cmsg_type == SCTP_EXTRCV) {
 816                                 /*
 817                                  * Let's hope that the user provided enough
 818                                  * enough memory. At least he asked for more
 819                                  * information.
 820                                  */
 821                                 memcpy(sinfo, CMSG_DATA(cmsg), sizeof(struct sctp_extrcvinfo));
 822                                 break;
 823                         }
 824                 }
 825         }
 826         return (sz);
 827 #endif
 828 }
 829
 830 ssize_t
 831 sctp_recvv(int sd,
 832     const struct iovec *iov,
 833     int iovlen,
 834     struct sockaddr *from,
 835     socklen_t * fromlen,
 836     void *info,
 837     socklen_t * infolen,
 838     unsigned int *infotype,
 839     int *flags)
 840 {
 841         char cmsgbuf[SCTP_CONTROL_VEC_SIZE_RCV];
 842         struct msghdr msg;
 843         struct cmsghdr *cmsg;
 844         ssize_t ret;
 845         struct sctp_rcvinfo *rcvinfo;
 846         struct sctp_nxtinfo *nxtinfo;
 847
 848         if (((info != NULL) && (infolen == NULL)) |
 849             ((info == NULL) && (infolen != NULL) && (*infolen != 0)) ||
 850             ((info != NULL) && (infotype == NULL))) {
 851                 errno = EINVAL;
 852                 return (-1);
 853         }
 854         if (infotype) {
 855                 *infotype = SCTP_RECVV_NOINFO;
 856         }
 857         msg.msg_name = from;
 858         if (fromlen == NULL) {
 859                 msg.msg_namelen = 0;
 860         } else {
 861                 msg.msg_namelen = *fromlen;
 862         }
 863         msg.msg_iov = (struct iovec *)iov;
 864         msg.msg_iovlen = iovlen;
 865         msg.msg_control = cmsgbuf;
 866         msg.msg_controllen = sizeof(cmsgbuf);
 867         ret = recvmsg(sd, &msg, *flags);
 868         *flags = msg.msg_flags;
 869         if ((ret > 0) &&
 870             (msg.msg_controllen > 0) &&
 871             (infotype != NULL) &&
 872             (infolen != NULL) &&
 873             (*infolen > 0)) {
 874                 rcvinfo = NULL;
 875                 nxtinfo = NULL;
 876                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 877                         if (cmsg->cmsg_level != IPPROTO_SCTP) {
 878                                 continue;
 879                         }
 880                         if (cmsg->cmsg_type == SCTP_RCVINFO) {
 881                                 rcvinfo = (struct sctp_rcvinfo *)CMSG_DATA(cmsg);
 882                                 if (nxtinfo != NULL) {
 883                                         break;
 884                                 } else {
 885                                         continue;
 886                                 }
 887                         }
 888                         if (cmsg->cmsg_type == SCTP_NXTINFO) {
 889                                 nxtinfo = (struct sctp_nxtinfo *)CMSG_DATA(cmsg);
 890                                 if (rcvinfo != NULL) {
 891                                         break;
 892                                 } else {
 893                                         continue;
 894                                 }
 895                         }
 896                 }
 897                 if (rcvinfo != NULL) {
 898                         if ((nxtinfo != NULL) && (*infolen >= sizeof(struct sctp_recvv_rn))) {
 899                                 struct sctp_recvv_rn *rn_info;
 900
 901                                 rn_info = (struct sctp_recvv_rn *)info;
 902                                 rn_info->recvv_rcvinfo = *rcvinfo;
 903                                 rn_info->recvv_nxtinfo = *nxtinfo;
 904                                 *infolen = (socklen_t) sizeof(struct sctp_recvv_rn);
 905                                 *infotype = SCTP_RECVV_RN;
 906                         } else if (*infolen >= sizeof(struct sctp_rcvinfo)) {
 907                                 memcpy(info, rcvinfo, sizeof(struct sctp_rcvinfo));
 908                                 *infolen = (socklen_t) sizeof(struct sctp_rcvinfo);
 909                                 *infotype = SCTP_RECVV_RCVINFO;
 910                         }
 911                 } else if (nxtinfo != NULL) {
 912                         if (*infolen >= sizeof(struct sctp_nxtinfo)) {
 913                                 memcpy(info, nxtinfo, sizeof(struct sctp_nxtinfo));
 914                                 *infolen = (socklen_t) sizeof(struct sctp_nxtinfo);
 915                                 *infotype = SCTP_RECVV_NXTINFO;
 916                         }
 917                 }
 918         }
 919         return (ret);
 920 }
 921
 922 ssize_t
 923 sctp_sendv(int sd,
 924     const struct iovec *iov, int iovcnt,
 925     struct sockaddr *addrs, int addrcnt,
 926     void *info, socklen_t infolen, unsigned int infotype,
 927     int flags)
 928 {
 929         ssize_t ret;
 930         int i;
 931         socklen_t addr_len;
 932         struct msghdr msg;
 933         in_port_t port;
 934         struct sctp_sendv_spa *spa_info;
 935         struct cmsghdr *cmsg;
 936         char *cmsgbuf;
 937         struct sockaddr *addr;
 938         struct sockaddr_in *addr_in;
 939         struct sockaddr_in6 *addr_in6;
 940
 941         if ((addrcnt < 0) ||
 942             (iovcnt < 0) ||
 943             ((addrs == NULL) && (addrcnt > 0)) ||
 944             ((addrs != NULL) && (addrcnt == 0)) ||
 945             ((iov == NULL) && (iovcnt > 0)) ||
 946             ((iov != NULL) && (iovcnt == 0))) {
 947                 errno = EINVAL;
 948                 return (-1);
 949         }
 950         cmsgbuf = malloc(CMSG_SPACE(sizeof(struct sctp_sndinfo)) +
 951             CMSG_SPACE(sizeof(struct sctp_prinfo)) +
 952             CMSG_SPACE(sizeof(struct sctp_authinfo)) +
 953             (size_t)addrcnt * CMSG_SPACE(sizeof(struct in6_addr)));
 954         if (cmsgbuf == NULL) {
 955                 errno = ENOMEM;
 956                 return (-1);
 957         }
 958         msg.msg_control = cmsgbuf;
 959         msg.msg_controllen = 0;
 960         cmsg = (struct cmsghdr *)cmsgbuf;
 961         switch (infotype) {
 962         case SCTP_SENDV_NOINFO:
 963                 if ((infolen != 0) || (info != NULL)) {
 964                         free(cmsgbuf);
 965                         errno = EINVAL;
 966                         return (-1);
 967                 }
 968                 break;
 969         case SCTP_SENDV_SNDINFO:
 970                 if ((info == NULL) || (infolen < sizeof(struct sctp_sndinfo))) {
 971                         free(cmsgbuf);
 972                         errno = EINVAL;
 973                         return (-1);
 974                 }
 975                 cmsg->cmsg_level = IPPROTO_SCTP;
 976                 cmsg->cmsg_type = SCTP_SNDINFO;
 977                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
 978                 memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_sndinfo));
 979                 msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
 980                 cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
 981                 break;
 982         case SCTP_SENDV_PRINFO:
 983                 if ((info == NULL) || (infolen < sizeof(struct sctp_prinfo))) {
 984                         free(cmsgbuf);
 985                         errno = EINVAL;
 986                         return (-1);
 987                 }
 988                 cmsg->cmsg_level = IPPROTO_SCTP;
 989                 cmsg->cmsg_type = SCTP_PRINFO;
 990                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
 991                 memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_prinfo));
 992                 msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
 993                 cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
 994                 break;
 995         case SCTP_SENDV_AUTHINFO:
 996                 if ((info == NULL) || (infolen < sizeof(struct sctp_authinfo))) {
 997                         free(cmsgbuf);
 998                         errno = EINVAL;
 999                         return (-1);
1000                 }
1001                 cmsg->cmsg_level = IPPROTO_SCTP;
1002                 cmsg->cmsg_type = SCTP_AUTHINFO;
1003                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
1004                 memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_authinfo));
1005                 msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
1006                 cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
1007                 break;
1008         case SCTP_SENDV_SPA:
1009                 if ((info == NULL) || (infolen < sizeof(struct sctp_sendv_spa))) {
1010                         free(cmsgbuf);
1011                         errno = EINVAL;
1012                         return (-1);
1013                 }
1014                 spa_info = (struct sctp_sendv_spa *)info;
1015                 if (spa_info->sendv_flags & SCTP_SEND_SNDINFO_VALID) {
1016                         cmsg->cmsg_level = IPPROTO_SCTP;
1017                         cmsg->cmsg_type = SCTP_SNDINFO;
1018                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
1019                         memcpy(CMSG_DATA(cmsg), &spa_info->sendv_sndinfo, sizeof(struct sctp_sndinfo));
1020                         msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
1021                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
1022                 }
1023                 if (spa_info->sendv_flags & SCTP_SEND_PRINFO_VALID) {
1024                         cmsg->cmsg_level = IPPROTO_SCTP;
1025                         cmsg->cmsg_type = SCTP_PRINFO;
1026                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
1027                         memcpy(CMSG_DATA(cmsg), &spa_info->sendv_prinfo, sizeof(struct sctp_prinfo));
1028                         msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
1029                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
1030                 }
1031                 if (spa_info->sendv_flags & SCTP_SEND_AUTHINFO_VALID) {
1032                         cmsg->cmsg_level = IPPROTO_SCTP;
1033                         cmsg->cmsg_type = SCTP_AUTHINFO;
1034                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
1035                         memcpy(CMSG_DATA(cmsg), &spa_info->sendv_authinfo, sizeof(struct sctp_authinfo));
1036                         msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
1037                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
1038                 }
1039                 break;
1040         default:
1041                 free(cmsgbuf);
1042                 errno = EINVAL;
1043                 return (-1);
1044         }
1045         addr = addrs;
1046         msg.msg_name = NULL;
1047         msg.msg_namelen = 0;
1048
1049         for (i = 0; i < addrcnt; i++) {
1050                 switch (addr->sa_family) {
1051                 case AF_INET:
1052                         addr_len = (socklen_t) sizeof(struct sockaddr_in);
1053                         addr_in = (struct sockaddr_in *)addr;
1054                         if (addr_in->sin_len != addr_len) {
1055                                 free(cmsgbuf);
1056                                 errno = EINVAL;
1057                                 return (-1);
1058                         }
1059                         if (i == 0) {
1060                                 port = addr_in->sin_port;
1061                         } else {
1062                                 if (port == addr_in->sin_port) {
1063                                         cmsg->cmsg_level = IPPROTO_SCTP;
1064                                         cmsg->cmsg_type = SCTP_DSTADDRV4;
1065                                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
1066                                         memcpy(CMSG_DATA(cmsg), &addr_in->sin_addr, sizeof(struct in_addr));
1067                                         msg.msg_controllen += CMSG_SPACE(sizeof(struct in_addr));
1068                                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in_addr)));
1069                                 } else {
1070                                         free(cmsgbuf);
1071                                         errno = EINVAL;
1072                                         return (-1);
1073                                 }
1074                         }
1075                         break;
1076                 case AF_INET6:
1077                         addr_len = (socklen_t) sizeof(struct sockaddr_in6);
1078                         addr_in6 = (struct sockaddr_in6 *)addr;
1079                         if (addr_in6->sin6_len != addr_len) {
1080                                 free(cmsgbuf);
1081                                 errno = EINVAL;
1082                                 return (-1);
1083                         }
1084                         if (i == 0) {
1085                                 port = addr_in6->sin6_port;
1086                         } else {
1087                                 if (port == addr_in6->sin6_port) {
1088                                         cmsg->cmsg_level = IPPROTO_SCTP;
1089                                         cmsg->cmsg_type = SCTP_DSTADDRV6;
1090                                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_addr));
1091                                         memcpy(CMSG_DATA(cmsg), &addr_in6->sin6_addr, sizeof(struct in6_addr));
1092                                         msg.msg_controllen += CMSG_SPACE(sizeof(struct in6_addr));
1093                                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in6_addr)));
1094                                 } else {
1095                                         free(cmsgbuf);
1096                                         errno = EINVAL;
1097                                         return (-1);
1098                                 }
1099                         }
1100                         break;
1101                 default:
1102                         free(cmsgbuf);
1103                         errno = EINVAL;
1104                         return (-1);
1105                 }
1106                 if (i == 0) {
1107                         msg.msg_name = addr;
1108                         msg.msg_namelen = addr_len;
1109                 }
1110                 addr = (struct sockaddr *)((caddr_t)addr + addr_len);
1111         }
1112         if (msg.msg_controllen == 0) {
1113                 msg.msg_control = NULL;
1114         }
1115         msg.msg_iov = (struct iovec *)iov;
1116         msg.msg_iovlen = iovcnt;
1117         msg.msg_flags = 0;
1118         ret = sendmsg(sd, &msg, flags);
1119         free(cmsgbuf);
1120         return (ret);
1121 }
1122
1123
1124 #if !defined(SYS_sctp_peeloff) && !defined(HAVE_SCTP_PEELOFF_SOCKOPT)
1125
1126 int
1127 sctp_peeloff(int sd, sctp_assoc_t assoc_id)
1128 {
1129         /* NOT supported, return invalid sd */
1130         errno = ENOTSUP;
1131         return (-1);
1132 }
1133
1134 #endif
1135 #if defined(SYS_sctp_peeloff) && !defined(HAVE_SCTP_PEELOFF_SOCKOPT)
1136 int
1137 sctp_peeloff(int sd, sctp_assoc_t assoc_id)
1138 {
1139         return (syscall(SYS_sctp_peeloff, sd, assoc_id));
1140 }
1141
1142 #endif
1143
1144 #undef SCTP_CONTROL_VEC_SIZE_RCV