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