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_MAX_BURST:
 344                 ((struct sctp_assoc_value *)arg)->assoc_id = id;
 345                 break;
 346         case SCTP_ENABLE_STREAM_RESET:
 347                 ((struct sctp_assoc_value *)arg)->assoc_id = id;
 348                 break;
 349         default:
 350                 break;
 351         }
 352         return (getsockopt(sd, IPPROTO_SCTP, opt, arg, size));
 353 }
 354
 355 int
 356 sctp_getpaddrs(int sd, sctp_assoc_t id, struct sockaddr **raddrs)
 357 {
 358         struct sctp_getaddresses *addrs;
 359         struct sockaddr *sa;
 360         sctp_assoc_t asoc;
 361         caddr_t lim;
 362         socklen_t opt_len;
 363         int cnt;
 364
 365         if (raddrs == NULL) {
 366                 errno = EFAULT;
 367                 return (-1);
 368         }
 369         asoc = id;
 370         opt_len = (socklen_t) sizeof(sctp_assoc_t);
 371         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_REMOTE_ADDR_SIZE,
 372             &asoc, &opt_len) != 0) {
 373                 return (-1);
 374         }
 375         /* size required is returned in 'asoc' */
 376         opt_len = (socklen_t) ((size_t)asoc + sizeof(struct sctp_getaddresses));
 377         addrs = calloc(1, (size_t)opt_len);
 378         if (addrs == NULL) {
 379                 errno = ENOMEM;
 380                 return (-1);
 381         }
 382         addrs->sget_assoc_id = id;
 383         /* Now lets get the array of addresses */
 384         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_PEER_ADDRESSES,
 385             addrs, &opt_len) != 0) {
 386                 free(addrs);
 387                 return (-1);
 388         }
 389         *raddrs = (struct sockaddr *)&addrs->addr[0];
 390         cnt = 0;
 391         sa = (struct sockaddr *)&addrs->addr[0];
 392         lim = (caddr_t)addrs + opt_len;
 393         while (((caddr_t)sa < lim) && (sa->sa_len > 0)) {
 394                 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
 395                 cnt++;
 396         }
 397         return (cnt);
 398 }
 399
 400 void
 401 sctp_freepaddrs(struct sockaddr *addrs)
 402 {
 403         void *fr_addr;
 404
 405         /* Take away the hidden association id */
 406         fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
 407         /* Now free it */
 408         free(fr_addr);
 409 }
 410
 411 int
 412 sctp_getladdrs(int sd, sctp_assoc_t id, struct sockaddr **raddrs)
 413 {
 414         struct sctp_getaddresses *addrs;
 415         caddr_t lim;
 416         struct sockaddr *sa;
 417         size_t size_of_addresses;
 418         socklen_t opt_len;
 419         int cnt;
 420
 421         if (raddrs == NULL) {
 422                 errno = EFAULT;
 423                 return (-1);
 424         }
 425         size_of_addresses = 0;
 426         opt_len = (socklen_t) sizeof(int);
 427         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDR_SIZE,
 428             &size_of_addresses, &opt_len) != 0) {
 429                 errno = ENOMEM;
 430                 return (-1);
 431         }
 432         if (size_of_addresses == 0) {
 433                 errno = ENOTCONN;
 434                 return (-1);
 435         }
 436         opt_len = (socklen_t) (size_of_addresses +
 437             sizeof(struct sockaddr_storage) +
 438             sizeof(struct sctp_getaddresses));
 439         addrs = calloc(1, (size_t)opt_len);
 440         if (addrs == NULL) {
 441                 errno = ENOMEM;
 442                 return (-1);
 443         }
 444         addrs->sget_assoc_id = id;
 445         /* Now lets get the array of addresses */
 446         if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDRESSES, addrs,
 447             &opt_len) != 0) {
 448                 free(addrs);
 449                 errno = ENOMEM;
 450                 return (-1);
 451         }
 452         *raddrs = (struct sockaddr *)&addrs->addr[0];
 453         cnt = 0;
 454         sa = (struct sockaddr *)&addrs->addr[0];
 455         lim = (caddr_t)addrs + opt_len;
 456         while (((caddr_t)sa < lim) && (sa->sa_len > 0)) {
 457                 sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
 458                 cnt++;
 459         }
 460         return (cnt);
 461 }
 462
 463 void
 464 sctp_freeladdrs(struct sockaddr *addrs)
 465 {
 466         void *fr_addr;
 467
 468         /* Take away the hidden association id */
 469         fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
 470         /* Now free it */
 471         free(fr_addr);
 472 }
 473
 474 ssize_t
 475 sctp_sendmsg(int s,
 476     const void *data,
 477     size_t len,
 478     const struct sockaddr *to,
 479     socklen_t tolen,
 480     uint32_t ppid,
 481     uint32_t flags,
 482     uint16_t stream_no,
 483     uint32_t timetolive,
 484     uint32_t context)
 485 {
 486 #ifdef SYS_sctp_generic_sendmsg
 487         struct sctp_sndrcvinfo sinfo;
 488
 489         memset(&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
 490         sinfo.sinfo_ppid = ppid;
 491         sinfo.sinfo_flags = flags;
 492         sinfo.sinfo_stream = stream_no;
 493         sinfo.sinfo_timetolive = timetolive;
 494         sinfo.sinfo_context = context;
 495         sinfo.sinfo_assoc_id = 0;
 496         return (syscall(SYS_sctp_generic_sendmsg, s,
 497             data, len, to, tolen, &sinfo, 0));
 498 #else
 499         struct msghdr msg;
 500         struct sctp_sndrcvinfo *sinfo;
 501         struct iovec iov;
 502         char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
 503         struct cmsghdr *cmsg;
 504         struct sockaddr *who = NULL;
 505         union {
 506                 struct sockaddr_in in;
 507                 struct sockaddr_in6 in6;
 508         }     addr;
 509
 510         if ((tolen > 0) &&
 511             ((to == NULL) || (tolen < sizeof(struct sockaddr)))) {
 512                 errno = EINVAL;
 513                 return (-1);
 514         }
 515         if ((to != NULL) && (tolen > 0)) {
 516                 switch (to->sa_family) {
 517                 case AF_INET:
 518                         if (tolen != sizeof(struct sockaddr_in)) {
 519                                 errno = EINVAL;
 520                                 return (-1);
 521                         }
 522                         if ((to->sa_len > 0) &&
 523                             (to->sa_len != sizeof(struct sockaddr_in))) {
 524                                 errno = EINVAL;
 525                                 return (-1);
 526                         }
 527                         memcpy(&addr, to, sizeof(struct sockaddr_in));
 528                         addr.in.sin_len = sizeof(struct sockaddr_in);
 529                         break;
 530                 case AF_INET6:
 531                         if (tolen != sizeof(struct sockaddr_in6)) {
 532                                 errno = EINVAL;
 533                                 return (-1);
 534                         }
 535                         if ((to->sa_len > 0) &&
 536                             (to->sa_len != sizeof(struct sockaddr_in6))) {
 537                                 errno = EINVAL;
 538                                 return (-1);
 539                         }
 540                         memcpy(&addr, to, sizeof(struct sockaddr_in6));
 541                         addr.in6.sin6_len = sizeof(struct sockaddr_in6);
 542                         break;
 543                 default:
 544                         errno = EAFNOSUPPORT;
 545                         return (-1);
 546                 }
 547                 who = (struct sockaddr *)&addr;
 548         }
 549         iov.iov_base = (char *)data;
 550         iov.iov_len = len;
 551
 552         if (who) {
 553                 msg.msg_name = (caddr_t)who;
 554                 msg.msg_namelen = who->sa_len;
 555         } else {
 556                 msg.msg_name = (caddr_t)NULL;
 557                 msg.msg_namelen = 0;
 558         }
 559         msg.msg_iov = &iov;
 560         msg.msg_iovlen = 1;
 561         msg.msg_control = cmsgbuf;
 562         msg.msg_controllen = CMSG_SPACE(sizeof(struct sctp_sndrcvinfo));
 563         cmsg = (struct cmsghdr *)cmsgbuf;
 564         cmsg->cmsg_level = IPPROTO_SCTP;
 565         cmsg->cmsg_type = SCTP_SNDRCV;
 566         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
 567         sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
 568         sinfo->sinfo_stream = stream_no;
 569         sinfo->sinfo_ssn = 0;
 570         sinfo->sinfo_flags = flags;
 571         sinfo->sinfo_ppid = ppid;
 572         sinfo->sinfo_context = context;
 573         sinfo->sinfo_assoc_id = 0;
 574         sinfo->sinfo_timetolive = timetolive;
 575         return (sendmsg(s, &msg, 0));
 576 #endif
 577 }
 578
 579
 580 sctp_assoc_t
 581 sctp_getassocid(int sd, struct sockaddr *sa)
 582 {
 583         struct sctp_paddrinfo sp;
 584         socklen_t siz;
 585
 586         /* First get the assoc id */
 587         siz = sizeof(sp);
 588         memset(&sp, 0, sizeof(sp));
 589         memcpy((caddr_t)&sp.spinfo_address, sa, sa->sa_len);
 590         if (getsockopt(sd, IPPROTO_SCTP,
 591             SCTP_GET_PEER_ADDR_INFO, &sp, &siz) != 0) {
 592                 /* We depend on the fact that 0 can never be returned */
 593                 return ((sctp_assoc_t) 0);
 594         }
 595         return (sp.spinfo_assoc_id);
 596 }
 597
 598 ssize_t
 599 sctp_send(int sd, const void *data, size_t len,
 600     const struct sctp_sndrcvinfo *sinfo,
 601     int flags)
 602 {
 603
 604 #ifdef SYS_sctp_generic_sendmsg
 605         struct sockaddr *to = NULL;
 606
 607         return (syscall(SYS_sctp_generic_sendmsg, sd,
 608             data, len, to, 0, sinfo, flags));
 609 #else
 610         struct msghdr msg;
 611         struct iovec iov;
 612         char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
 613         struct cmsghdr *cmsg;
 614
 615         if (sinfo == NULL) {
 616                 errno = EINVAL;
 617                 return (-1);
 618         }
 619         iov.iov_base = (char *)data;
 620         iov.iov_len = len;
 621
 622         msg.msg_name = NULL;
 623         msg.msg_namelen = 0;
 624         msg.msg_iov = &iov;
 625         msg.msg_iovlen = 1;
 626         msg.msg_control = cmsgbuf;
 627         msg.msg_controllen = CMSG_SPACE(sizeof(struct sctp_sndrcvinfo));
 628         cmsg = (struct cmsghdr *)cmsgbuf;
 629         cmsg->cmsg_level = IPPROTO_SCTP;
 630         cmsg->cmsg_type = SCTP_SNDRCV;
 631         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
 632         memcpy(CMSG_DATA(cmsg), sinfo, sizeof(struct sctp_sndrcvinfo));
 633         return (sendmsg(sd, &msg, flags));
 634 #endif
 635 }
 636
 637
 638
 639 ssize_t
 640 sctp_sendx(int sd, const void *msg, size_t msg_len,
 641     struct sockaddr *addrs, int addrcnt,
 642     struct sctp_sndrcvinfo *sinfo,
 643     int flags)
 644 {
 645         struct sctp_sndrcvinfo __sinfo;
 646         ssize_t ret;
 647         int i, cnt, *aa, saved_errno;
 648         char *buf;
 649         int no_end_cx = 0;
 650         size_t len, add_len;
 651         struct sockaddr *at;
 652
 653         if (addrs == NULL) {
 654                 errno = EINVAL;
 655                 return (-1);
 656         }
 657 #ifdef SYS_sctp_generic_sendmsg
 658         if (addrcnt == 1) {
 659                 socklen_t l;
 660
 661                 /*
 662                  * Quick way, we don't need to do a connectx so lets use the
 663                  * syscall directly.
 664                  */
 665                 l = addrs->sa_len;
 666                 return (syscall(SYS_sctp_generic_sendmsg, sd,
 667                     msg, msg_len, addrs, l, sinfo, flags));
 668         }
 669 #endif
 670
 671         len = sizeof(int);
 672         at = addrs;
 673         cnt = 0;
 674         /* validate all the addresses and get the size */
 675         for (i = 0; i < addrcnt; i++) {
 676                 if (at->sa_family == AF_INET) {
 677                         add_len = sizeof(struct sockaddr_in);
 678                 } else if (at->sa_family == AF_INET6) {
 679                         add_len = sizeof(struct sockaddr_in6);
 680                 } else {
 681                         errno = EINVAL;
 682                         return (-1);
 683                 }
 684                 len += add_len;
 685                 at = (struct sockaddr *)((caddr_t)at + add_len);
 686                 cnt++;
 687         }
 688         /* do we have any? */
 689         if (cnt == 0) {
 690                 errno = EINVAL;
 691                 return (-1);
 692         }
 693         buf = malloc(len);
 694         if (buf == NULL) {
 695                 errno = ENOMEM;
 696                 return (-1);
 697         }
 698         aa = (int *)buf;
 699         *aa = cnt;
 700         aa++;
 701         memcpy((caddr_t)aa, addrs, (size_t)(len - sizeof(int)));
 702         ret = setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_DELAYED, (void *)buf,
 703             (socklen_t) len);
 704
 705         free(buf);
 706         if (ret != 0) {
 707                 if (errno == EALREADY) {
 708                         no_end_cx = 1;
 709                         goto continue_send;
 710                 }
 711                 return (ret);
 712         }
 713 continue_send:
 714         if (sinfo == NULL) {
 715                 sinfo = &__sinfo;
 716                 memset(&__sinfo, 0, sizeof(__sinfo));
 717         }
 718         sinfo->sinfo_assoc_id = sctp_getassocid(sd, addrs);
 719         if (sinfo->sinfo_assoc_id == 0) {
 720                 (void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
 721                     (socklen_t) addrs->sa_len);
 722                 errno = ENOENT;
 723                 return (-1);
 724         }
 725         ret = sctp_send(sd, msg, msg_len, sinfo, flags);
 726         saved_errno = errno;
 727         if (no_end_cx == 0)
 728                 (void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
 729                     (socklen_t) addrs->sa_len);
 730
 731         errno = saved_errno;
 732         return (ret);
 733 }
 734
 735 ssize_t
 736 sctp_sendmsgx(int sd,
 737     const void *msg,
 738     size_t len,
 739     struct sockaddr *addrs,
 740     int addrcnt,
 741     uint32_t ppid,
 742     uint32_t flags,
 743     uint16_t stream_no,
 744     uint32_t timetolive,
 745     uint32_t context)
 746 {
 747         struct sctp_sndrcvinfo sinfo;
 748
 749         memset((void *)&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
 750         sinfo.sinfo_ppid = ppid;
 751         sinfo.sinfo_flags = flags;
 752         sinfo.sinfo_ssn = stream_no;
 753         sinfo.sinfo_timetolive = timetolive;
 754         sinfo.sinfo_context = context;
 755         return (sctp_sendx(sd, msg, len, addrs, addrcnt, &sinfo, 0));
 756 }
 757
 758 ssize_t
 759 sctp_recvmsg(int s,
 760     void *dbuf,
 761     size_t len,
 762     struct sockaddr *from,
 763     socklen_t * fromlen,
 764     struct sctp_sndrcvinfo *sinfo,
 765     int *msg_flags)
 766 {
 767 #ifdef SYS_sctp_generic_recvmsg
 768         struct iovec iov;
 769
 770         iov.iov_base = dbuf;
 771         iov.iov_len = len;
 772         return (syscall(SYS_sctp_generic_recvmsg, s,
 773             &iov, 1, from, fromlen, sinfo, msg_flags));
 774 #else
 775         ssize_t sz;
 776         struct msghdr msg;
 777         struct iovec iov;
 778         char cmsgbuf[SCTP_CONTROL_VEC_SIZE_RCV];
 779         struct cmsghdr *cmsg;
 780
 781         if (msg_flags == NULL) {
 782                 errno = EINVAL;
 783                 return (-1);
 784         }
 785         msg.msg_flags = 0;
 786         iov.iov_base = dbuf;
 787         iov.iov_len = len;
 788         msg.msg_name = (caddr_t)from;
 789         if (fromlen == NULL)
 790                 msg.msg_namelen = 0;
 791         else
 792                 msg.msg_namelen = *fromlen;
 793         msg.msg_iov = &iov;
 794         msg.msg_iovlen = 1;
 795         msg.msg_control = cmsgbuf;
 796         msg.msg_controllen = sizeof(cmsgbuf);
 797         sz = recvmsg(s, &msg, *msg_flags);
 798         *msg_flags = msg.msg_flags;
 799         if (sz <= 0) {
 800                 return (sz);
 801         }
 802         if (sinfo) {
 803                 sinfo->sinfo_assoc_id = 0;
 804         }
 805         if ((msg.msg_controllen > 0) && (sinfo != NULL)) {
 806                 /*
 807                  * parse through and see if we find the sctp_sndrcvinfo (if
 808                  * the user wants it).
 809                  */
 810                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 811                         if (cmsg->cmsg_level != IPPROTO_SCTP) {
 812                                 continue;
 813                         }
 814                         if (cmsg->cmsg_type == SCTP_SNDRCV) {
 815                                 memcpy(sinfo, CMSG_DATA(cmsg), sizeof(struct sctp_sndrcvinfo));
 816                                 break;
 817                         }
 818                         if (cmsg->cmsg_type == SCTP_EXTRCV) {
 819                                 /*
 820                                  * Let's hope that the user provided enough
 821                                  * enough memory. At least he asked for more
 822                                  * information.
 823                                  */
 824                                 memcpy(sinfo, CMSG_DATA(cmsg), sizeof(struct sctp_extrcvinfo));
 825                                 break;
 826                         }
 827                 }
 828         }
 829         return (sz);
 830 #endif
 831 }
 832
 833 ssize_t
 834 sctp_recvv(int sd,
 835     const struct iovec *iov,
 836     int iovlen,
 837     struct sockaddr *from,
 838     socklen_t * fromlen,
 839     void *info,
 840     socklen_t * infolen,
 841     unsigned int *infotype,
 842     int *flags)
 843 {
 844         char cmsgbuf[SCTP_CONTROL_VEC_SIZE_RCV];
 845         struct msghdr msg;
 846         struct cmsghdr *cmsg;
 847         ssize_t ret;
 848         struct sctp_rcvinfo *rcvinfo;
 849         struct sctp_nxtinfo *nxtinfo;
 850
 851         if (((info != NULL) && (infolen == NULL)) |
 852             ((info == NULL) && (infolen != NULL) && (*infolen != 0)) ||
 853             ((info != NULL) && (infotype == NULL))) {
 854                 errno = EINVAL;
 855                 return (-1);
 856         }
 857         if (infotype) {
 858                 *infotype = SCTP_RECVV_NOINFO;
 859         }
 860         msg.msg_name = from;
 861         if (fromlen == NULL) {
 862                 msg.msg_namelen = 0;
 863         } else {
 864                 msg.msg_namelen = *fromlen;
 865         }
 866         msg.msg_iov = (struct iovec *)iov;
 867         msg.msg_iovlen = iovlen;
 868         msg.msg_control = cmsgbuf;
 869         msg.msg_controllen = sizeof(cmsgbuf);
 870         ret = recvmsg(sd, &msg, *flags);
 871         *flags = msg.msg_flags;
 872         if ((ret > 0) &&
 873             (msg.msg_controllen > 0) &&
 874             (infotype != NULL) &&
 875             (infolen != NULL) &&
 876             (*infolen > 0)) {
 877                 rcvinfo = NULL;
 878                 nxtinfo = NULL;
 879                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 880                         if (cmsg->cmsg_level != IPPROTO_SCTP) {
 881                                 continue;
 882                         }
 883                         if (cmsg->cmsg_type == SCTP_RCVINFO) {
 884                                 rcvinfo = (struct sctp_rcvinfo *)CMSG_DATA(cmsg);
 885                                 if (nxtinfo != NULL) {
 886                                         break;
 887                                 } else {
 888                                         continue;
 889                                 }
 890                         }
 891                         if (cmsg->cmsg_type == SCTP_NXTINFO) {
 892                                 nxtinfo = (struct sctp_nxtinfo *)CMSG_DATA(cmsg);
 893                                 if (rcvinfo != NULL) {
 894                                         break;
 895                                 } else {
 896                                         continue;
 897                                 }
 898                         }
 899                 }
 900                 if (rcvinfo != NULL) {
 901                         if ((nxtinfo != NULL) && (*infolen >= sizeof(struct sctp_recvv_rn))) {
 902                                 struct sctp_recvv_rn *rn_info;
 903
 904                                 rn_info = (struct sctp_recvv_rn *)info;
 905                                 rn_info->recvv_rcvinfo = *rcvinfo;
 906                                 rn_info->recvv_nxtinfo = *nxtinfo;
 907                                 *infolen = (socklen_t) sizeof(struct sctp_recvv_rn);
 908                                 *infotype = SCTP_RECVV_RN;
 909                         } else if (*infolen >= sizeof(struct sctp_rcvinfo)) {
 910                                 memcpy(info, rcvinfo, sizeof(struct sctp_rcvinfo));
 911                                 *infolen = (socklen_t) sizeof(struct sctp_rcvinfo);
 912                                 *infotype = SCTP_RECVV_RCVINFO;
 913                         }
 914                 } else if (nxtinfo != NULL) {
 915                         if (*infolen >= sizeof(struct sctp_nxtinfo)) {
 916                                 memcpy(info, nxtinfo, sizeof(struct sctp_nxtinfo));
 917                                 *infolen = (socklen_t) sizeof(struct sctp_nxtinfo);
 918                                 *infotype = SCTP_RECVV_NXTINFO;
 919                         }
 920                 }
 921         }
 922         return (ret);
 923 }
 924
 925 ssize_t
 926 sctp_sendv(int sd,
 927     const struct iovec *iov, int iovcnt,
 928     struct sockaddr *addrs, int addrcnt,
 929     void *info, socklen_t infolen, unsigned int infotype,
 930     int flags)
 931 {
 932         ssize_t ret;
 933         int i;
 934         socklen_t addr_len;
 935         struct msghdr msg;
 936         in_port_t port;
 937         struct sctp_sendv_spa *spa_info;
 938         struct cmsghdr *cmsg;
 939         char *cmsgbuf;
 940         struct sockaddr *addr;
 941         struct sockaddr_in *addr_in;
 942         struct sockaddr_in6 *addr_in6;
 943
 944         if ((addrcnt < 0) ||
 945             (iovcnt < 0) ||
 946             ((addrs == NULL) && (addrcnt > 0)) ||
 947             ((addrs != NULL) && (addrcnt == 0)) ||
 948             ((iov == NULL) && (iovcnt > 0)) ||
 949             ((iov != NULL) && (iovcnt == 0))) {
 950                 errno = EINVAL;
 951                 return (-1);
 952         }
 953         cmsgbuf = malloc(CMSG_SPACE(sizeof(struct sctp_sndinfo)) +
 954             CMSG_SPACE(sizeof(struct sctp_prinfo)) +
 955             CMSG_SPACE(sizeof(struct sctp_authinfo)) +
 956             (size_t)addrcnt * CMSG_SPACE(sizeof(struct in6_addr)));
 957         if (cmsgbuf == NULL) {
 958                 errno = ENOMEM;
 959                 return (-1);
 960         }
 961         msg.msg_control = cmsgbuf;
 962         msg.msg_controllen = 0;
 963         cmsg = (struct cmsghdr *)cmsgbuf;
 964         switch (infotype) {
 965         case SCTP_SENDV_NOINFO:
 966                 if ((infolen != 0) || (info != NULL)) {
 967                         free(cmsgbuf);
 968                         errno = EINVAL;
 969                         return (-1);
 970                 }
 971                 break;
 972         case SCTP_SENDV_SNDINFO:
 973                 if ((info == NULL) || (infolen < sizeof(struct sctp_sndinfo))) {
 974                         free(cmsgbuf);
 975                         errno = EINVAL;
 976                         return (-1);
 977                 }
 978                 cmsg->cmsg_level = IPPROTO_SCTP;
 979                 cmsg->cmsg_type = SCTP_SNDINFO;
 980                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
 981                 memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_sndinfo));
 982                 msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
 983                 cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
 984                 break;
 985         case SCTP_SENDV_PRINFO:
 986                 if ((info == NULL) || (infolen < sizeof(struct sctp_prinfo))) {
 987                         free(cmsgbuf);
 988                         errno = EINVAL;
 989                         return (-1);
 990                 }
 991                 cmsg->cmsg_level = IPPROTO_SCTP;
 992                 cmsg->cmsg_type = SCTP_PRINFO;
 993                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
 994                 memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_prinfo));
 995                 msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
 996                 cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
 997                 break;
 998         case SCTP_SENDV_AUTHINFO:
 999                 if ((info == NULL) || (infolen < sizeof(struct sctp_authinfo))) {
1000                         free(cmsgbuf);
1001                         errno = EINVAL;
1002                         return (-1);
1003                 }
1004                 cmsg->cmsg_level = IPPROTO_SCTP;
1005                 cmsg->cmsg_type = SCTP_AUTHINFO;
1006                 cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
1007                 memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_authinfo));
1008                 msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
1009                 cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
1010                 break;
1011         case SCTP_SENDV_SPA:
1012                 if ((info == NULL) || (infolen < sizeof(struct sctp_sendv_spa))) {
1013                         free(cmsgbuf);
1014                         errno = EINVAL;
1015                         return (-1);
1016                 }
1017                 spa_info = (struct sctp_sendv_spa *)info;
1018                 if (spa_info->sendv_flags & SCTP_SEND_SNDINFO_VALID) {
1019                         cmsg->cmsg_level = IPPROTO_SCTP;
1020                         cmsg->cmsg_type = SCTP_SNDINFO;
1021                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
1022                         memcpy(CMSG_DATA(cmsg), &spa_info->sendv_sndinfo, sizeof(struct sctp_sndinfo));
1023                         msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
1024                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
1025                 }
1026                 if (spa_info->sendv_flags & SCTP_SEND_PRINFO_VALID) {
1027                         cmsg->cmsg_level = IPPROTO_SCTP;
1028                         cmsg->cmsg_type = SCTP_PRINFO;
1029                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
1030                         memcpy(CMSG_DATA(cmsg), &spa_info->sendv_prinfo, sizeof(struct sctp_prinfo));
1031                         msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
1032                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
1033                 }
1034                 if (spa_info->sendv_flags & SCTP_SEND_AUTHINFO_VALID) {
1035                         cmsg->cmsg_level = IPPROTO_SCTP;
1036                         cmsg->cmsg_type = SCTP_AUTHINFO;
1037                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
1038                         memcpy(CMSG_DATA(cmsg), &spa_info->sendv_authinfo, sizeof(struct sctp_authinfo));
1039                         msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
1040                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
1041                 }
1042                 break;
1043         default:
1044                 free(cmsgbuf);
1045                 errno = EINVAL;
1046                 return (-1);
1047         }
1048         addr = addrs;
1049         msg.msg_name = NULL;
1050         msg.msg_namelen = 0;
1051
1052         for (i = 0; i < addrcnt; i++) {
1053                 switch (addr->sa_family) {
1054                 case AF_INET:
1055                         addr_len = (socklen_t) sizeof(struct sockaddr_in);
1056                         addr_in = (struct sockaddr_in *)addr;
1057                         if (addr_in->sin_len != addr_len) {
1058                                 free(cmsgbuf);
1059                                 errno = EINVAL;
1060                                 return (-1);
1061                         }
1062                         if (i == 0) {
1063                                 port = addr_in->sin_port;
1064                         } else {
1065                                 if (port == addr_in->sin_port) {
1066                                         cmsg->cmsg_level = IPPROTO_SCTP;
1067                                         cmsg->cmsg_type = SCTP_DSTADDRV4;
1068                                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
1069                                         memcpy(CMSG_DATA(cmsg), &addr_in->sin_addr, sizeof(struct in_addr));
1070                                         msg.msg_controllen += CMSG_SPACE(sizeof(struct in_addr));
1071                                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in_addr)));
1072                                 } else {
1073                                         free(cmsgbuf);
1074                                         errno = EINVAL;
1075                                         return (-1);
1076                                 }
1077                         }
1078                         break;
1079                 case AF_INET6:
1080                         addr_len = (socklen_t) sizeof(struct sockaddr_in6);
1081                         addr_in6 = (struct sockaddr_in6 *)addr;
1082                         if (addr_in6->sin6_len != addr_len) {
1083                                 free(cmsgbuf);
1084                                 errno = EINVAL;
1085                                 return (-1);
1086                         }
1087                         if (i == 0) {
1088                                 port = addr_in6->sin6_port;
1089                         } else {
1090                                 if (port == addr_in6->sin6_port) {
1091                                         cmsg->cmsg_level = IPPROTO_SCTP;
1092                                         cmsg->cmsg_type = SCTP_DSTADDRV6;
1093                                         cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_addr));
1094                                         memcpy(CMSG_DATA(cmsg), &addr_in6->sin6_addr, sizeof(struct in6_addr));
1095                                         msg.msg_controllen += CMSG_SPACE(sizeof(struct in6_addr));
1096                                         cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in6_addr)));
1097                                 } else {
1098                                         free(cmsgbuf);
1099                                         errno = EINVAL;
1100                                         return (-1);
1101                                 }
1102                         }
1103                         break;
1104                 default:
1105                         free(cmsgbuf);
1106                         errno = EINVAL;
1107                         return (-1);
1108                 }
1109                 if (i == 0) {
1110                         msg.msg_name = addr;
1111                         msg.msg_namelen = addr_len;
1112                 }
1113                 addr = (struct sockaddr *)((caddr_t)addr + addr_len);
1114         }
1115         if (msg.msg_controllen == 0) {
1116                 msg.msg_control = NULL;
1117         }
1118         msg.msg_iov = (struct iovec *)iov;
1119         msg.msg_iovlen = iovcnt;
1120         msg.msg_flags = 0;
1121         ret = sendmsg(sd, &msg, flags);
1122         free(cmsgbuf);
1123         return (ret);
1124 }
1125
1126
1127 #if !defined(SYS_sctp_peeloff) && !defined(HAVE_SCTP_PEELOFF_SOCKOPT)
1128
1129 int
1130 sctp_peeloff(int sd, sctp_assoc_t assoc_id)
1131 {
1132         /* NOT supported, return invalid sd */
1133         errno = ENOTSUP;
1134         return (-1);
1135 }
1136
1137 #endif
1138 #if defined(SYS_sctp_peeloff) && !defined(HAVE_SCTP_PEELOFF_SOCKOPT)
1139 int
1140 sctp_peeloff(int sd, sctp_assoc_t assoc_id)
1141 {
1142         return (syscall(SYS_sctp_peeloff, sd, assoc_id));
1143 }
1144
1145 #endif
1146
1147 #undef SCTP_CONTROL_VEC_SIZE_RCV