/*      $KAME: sctp_sys_calls.c,v 1.10 2005/03/06 16:04:16 itojun Exp $ */
/*      $NetBSD: sctp_sys_calls.c,v 1.2 2024/01/20 14:52:48 christos Exp $ */

/*
* Copyright (C) 2002, 2003, 2004 Cisco Systems Inc,
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the project nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/errno.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/sctp_uio.h>
#include <netinet/sctp.h>

#include <net/if_dl.h>

#ifndef IN6_IS_ADDR_V4MAPPED
#define IN6_IS_ADDR_V4MAPPED(a)              \
       ((*(const u_int32_t *)(const void *)(&(a)->s6_addr[0]) == 0) && \
        (*(const u_int32_t *)(const void *)(&(a)->s6_addr[4]) == 0) && \
        (*(const u_int32_t *)(const void *)(&(a)->s6_addr[8]) == ntohl(0x0000ffff)))
#endif

#define SCTP_CONTROL_VEC_SIZE_RCV       16384

#ifdef SCTP_DEBUG_PRINT_ADDRESS
static void
SCTPPrintAnAddress(struct sockaddr *a)
{
       char stringToPrint[256];
       u_short prt;
       char *srcaddr, *txt;

       if (a == NULL) {
               printf("NULL\n");
               return;
       }
       if (a->sa_family == AF_INET) {
               srcaddr = (char *)&((struct sockaddr_in *)a)->sin_addr;
               txt = "IPv4 Address: ";
               prt = ntohs(((struct sockaddr_in *)a)->sin_port);
       } else if (a->sa_family == AF_INET6) {
               srcaddr = (char *)&((struct sockaddr_in6 *)a)->sin6_addr;
               prt = ntohs(((struct sockaddr_in6 *)a)->sin6_port);
               txt = "IPv6 Address: ";
       } else if (a->sa_family == AF_LINK) {
               int i;
               char tbuf[200];
               u_char adbuf[200];
               struct sockaddr_dl *dl;

               dl = (struct sockaddr_dl *)a;
               strncpy(tbuf, dl->sdl_data, dl->sdl_nlen);
               tbuf[dl->sdl_nlen] = 0;
               printf("Intf:%s (len:%d)Interface index:%d type:%x(%d) ll-len:%d ",
                   tbuf, dl->sdl_nlen, dl->sdl_index, dl->sdl_type,
                   dl->sdl_type, dl->sdl_alen);
               memcpy(adbuf, LLADDR(dl), dl->sdl_alen);
               for (i = 0; i < dl->sdl_alen; i++){
                       printf("%2.2x", adbuf[i]);
                       if (i < (dl->sdl_alen - 1))
                               printf(":");
               }
               printf("\n");
       /*      u_short sdl_route[16];*/        /* source routing information */
               return;
       } else {
               return;
       }
       if (inet_ntop(a->sa_family, srcaddr, stringToPrint,
           sizeof(stringToPrint))) {
               if (a->sa_family == AF_INET6) {
                       printf("%s%s:%d scope:%d\n", txt, stringToPrint, prt,
                           ((struct sockaddr_in6 *)a)->sin6_scope_id);
               } else {
                       printf("%s%s:%d\n", txt, stringToPrint, prt);
               }

       } else {
               printf("%s unprintable?\n", txt);
       }
}
#endif /* SCTP_DEBUG_PRINT_ADDRESS */

void
in6_sin6_2_sin(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
{
       memset(sin, 0, sizeof(*sin));
       sin->sin_len = sizeof(struct sockaddr_in);
       sin->sin_family = AF_INET;
       sin->sin_port = sin6->sin6_port;
       sin->sin_addr.s_addr = sin6->sin6_addr.__u6_addr.__u6_addr32[3];
}

int
sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt,
               sctp_assoc_t *id)
{
       int i, ret, cnt;
       struct sockaddr *at;
       struct sctp_connectx_addrs sca;
#if 0
       char *cpto;
#endif
       size_t len;

       at = addrs;
       cnt = 0;
       len = 0;
       /* validate all the addresses and get the size */
       for (i = 0; i < addrcnt; i++) {
               if (at->sa_family == AF_INET) {
                       len += at->sa_len;
               } else if (at->sa_family == AF_INET6){
                       if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)(void *)at)->sin6_addr)){
                               len += sizeof(struct sockaddr_in);
#if 0
                               in6_sin6_2_sin((struct sockaddr_in *)cpto,
                                   (struct sockaddr_in6 *)at);
                               cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in));
                               len += sizeof(struct sockaddr_in);
#endif
                       } else {
                               len += at->sa_len;
                       }
               } else {
                       errno = EINVAL;
                       return (-1);
               }
               at = (struct sockaddr *)((caddr_t)at + at->sa_len);
               cnt++;
       }
       /* do we have any? */
       if (cnt == 0) {
               errno = EINVAL;
               return(-1);
       }

       sca.cx_num = cnt;
       sca.cx_len = (int)len;
       sca.cx_addrs = addrs;
       ret = ioctl(sd, SIOCCONNECTX, (void *)&sca);
       if ((ret == 0) && (id != NULL)) {
               memcpy(id, &sca.cx_num, sizeof(sctp_assoc_t));
       }
       return (ret);
}

int
sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt, int flags)
{
       struct sctp_getaddresses *gaddrs;
       struct sockaddr *sa;
       int i, sz, fam, argsz;

       if ((flags != SCTP_BINDX_ADD_ADDR) &&
           (flags != SCTP_BINDX_REM_ADDR)) {
               errno = EFAULT;
               return(-1);
       }
       argsz = (sizeof(struct sockaddr_storage) +
           sizeof(struct sctp_getaddresses));
       gaddrs = (struct sctp_getaddresses *)calloc(1, argsz);
       if (gaddrs == NULL) {
               errno = ENOMEM;
               return(-1);
       }
       gaddrs->sget_assoc_id = 0;
       sa = addrs;
       for (i = 0; i < addrcnt; i++) {
               sz = sa->sa_len;
               fam = sa->sa_family;
               ((struct sockaddr_in *)(void *)&addrs[i])->sin_port = ((struct sockaddr_in *)(void *)sa)->sin_port;
               if ((fam != AF_INET) && (fam != AF_INET6)) {
                       errno = EINVAL;
                       return(-1);
               }
               memcpy(gaddrs->addr, sa, sz);
               if (setsockopt(sd, IPPROTO_SCTP, flags, gaddrs,
                   (unsigned int)argsz) != 0) {
                       free(gaddrs);
                       return(-1);
               }
               memset(gaddrs, 0, argsz);
               sa = (struct sockaddr *)((caddr_t)sa + sz);
       }
       free(gaddrs);
       return(0);
}


int
sctp_opt_info(int sd, sctp_assoc_t id, int opt, void *arg, socklen_t *size)
{
       if ((opt == SCTP_RTOINFO) ||
           (opt == SCTP_ASSOCINFO) ||
           (opt == SCTP_PRIMARY_ADDR) ||
           (opt == SCTP_SET_PEER_PRIMARY_ADDR) ||
           (opt == SCTP_PEER_ADDR_PARAMS) ||
           (opt == SCTP_STATUS) ||
           (opt == SCTP_GET_PEER_ADDR_INFO)) {
               *(sctp_assoc_t *)arg = id;
               return(getsockopt2(sd, IPPROTO_SCTP, opt, arg, size));
       } else {
               errno = EOPNOTSUPP;
               return(-1);
       }
}

int
sctp_getpaddrs(int sd, sctp_assoc_t id, struct sockaddr **raddrs)
{
       struct sctp_getaddresses *addrs;
       struct sockaddr *sa;
       struct sockaddr *re;
       sctp_assoc_t asoc;
       caddr_t lim;
       unsigned int siz;
       int cnt;

       if (raddrs == NULL) {
               errno = EFAULT;
               return(-1);
       }
       asoc = id;
       siz = sizeof(sctp_assoc_t);
       if (getsockopt2(sd, IPPROTO_SCTP, SCTP_GET_REMOTE_ADDR_SIZE,
           &asoc, &siz) != 0) {
               return(-1);
       }
       siz = (unsigned int)asoc;
       siz += sizeof(struct sctp_getaddresses);
       addrs = calloc((unsigned long)1, (unsigned long)siz);
       if (addrs == NULL) {
               errno = ENOMEM;
               return(-1);
       }
       memset(addrs, 0, (size_t)siz);
       addrs->sget_assoc_id = id;
       /* Now lets get the array of addresses */
       if (getsockopt2(sd, IPPROTO_SCTP, SCTP_GET_PEER_ADDRESSES,
           addrs, &siz) != 0) {
               free(addrs);
               return(-1);
       }
       re = (struct sockaddr *)&addrs->addr[0];
       *raddrs = re;
       cnt = 0;
       sa = (struct sockaddr *)&addrs->addr[0];
       lim = (caddr_t)addrs + siz;
       while ((caddr_t)sa < lim) {
               cnt++;
               sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
               if (sa->sa_len == 0)
                       break;
       }
       return(cnt);
}

void sctp_freepaddrs(struct sockaddr *addrs)
{
       /* Take away the hidden association id */
       void *fr_addr;
       fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
       /* Now free it */
       free(fr_addr);
}

int
sctp_getladdrs (int sd, sctp_assoc_t id, struct sockaddr **raddrs)
{
       struct sctp_getaddresses *addrs;
       struct sockaddr *re;
       caddr_t lim;
       struct sockaddr *sa;
       int size_of_addresses;
       socklen_t siz;
       int cnt;

       if (raddrs == NULL) {
               errno = EFAULT;
               return(-1);
       }
       size_of_addresses = 0;
       siz = sizeof(int);
       if (getsockopt2(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDR_SIZE,
           &size_of_addresses, &siz) != 0) {
               return(-1);
       }
       if (size_of_addresses == 0) {
               errno = ENOTCONN;
               return(-1);
       }
       siz = (socklen_t)(size_of_addresses + sizeof(struct sockaddr_storage));
       siz += sizeof(struct sctp_getaddresses);
       addrs = calloc((unsigned long)1, (unsigned long)siz);
       if (addrs == NULL) {
               errno = ENOMEM;
               return(-1);
       }
       memset(addrs, 0, (size_t)siz);
       addrs->sget_assoc_id = id;
       /* Now lets get the array of addresses */
       if (getsockopt2(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDRESSES, addrs,
           &siz) != 0) {
               free(addrs);
               return(-1);
       }
       re = (struct sockaddr *)&addrs->addr[0];
       *raddrs = re;
       cnt = 0;
       sa = (struct sockaddr *)&addrs->addr[0];
       lim = (caddr_t)addrs + siz;
       while ((caddr_t)sa < lim) {
               cnt++;
               sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
               if (sa->sa_len == 0)
                       break;
       }
       return(cnt);
}

void sctp_freeladdrs(struct sockaddr *addrs)
{
       /* Take away the hidden association id */
       void *fr_addr;
       fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
       /* Now free it */
       free(fr_addr);
}

ssize_t
sctp_sendmsg(int s,
            const void *data,
            size_t len,
            const struct sockaddr *to,
            socklen_t tolen __attribute__((unused)),
            u_int32_t ppid,
            u_int32_t flags,
            u_int16_t stream_no,
            u_int32_t timetolive,
            u_int32_t context)
{
       ssize_t sz;
       struct msghdr msg;
       struct iovec iov[2];
       char controlVector[256];
       struct sctp_sndrcvinfo *s_info;
       struct cmsghdr *cmsg;
       struct sockaddr *who=NULL;
       union {
               struct sockaddr_in in;
               struct sockaddr_in6 in6;
       } addr;

#if 0
       fprintf(io, "sctp_sendmsg(sd:%d, data:%x, len:%d, to:%x, tolen:%d, ppid:%x, flags:%x str:%d ttl:%d ctx:%x\n",
           s, (u_int)data, (int)len, (u_int)to, (int)tolen, ppid, flags,
           (int)stream_no, (int)timetolive, (u_int)context);
       fflush(io);
#endif
       if (to) {
               if (to->sa_len == 0) {
                       /*
                        * For the lazy app, that did not
                        * set sa_len, we attempt to set for them.
                        */
                       switch (to->sa_family) {
                       case AF_INET:
                               memcpy(&addr, to, sizeof(struct sockaddr_in));
                               addr.in.sin_len = sizeof(struct sockaddr_in);
                               break;
                       case AF_INET6:
                               memcpy(&addr, to, sizeof(struct sockaddr_in6));
                               addr.in6.sin6_len = sizeof(struct sockaddr_in6);
                               break;
                       default:
                               errno = EAFNOSUPPORT;
                               return -1;
                       }
               } else {
                       memcpy (&addr, to, to->sa_len);
               }
               who = (struct sockaddr *)(void *)&addr;
       }
       iov[0].iov_base = (void *)(unsigned long)data;
       iov[0].iov_len = len;
       iov[1].iov_base = NULL;
       iov[1].iov_len = 0;

       if (to) {
               msg.msg_name = (caddr_t)who;
               msg.msg_namelen = who->sa_len;
       } else {
               msg.msg_name = (caddr_t)NULL;
               msg.msg_namelen = 0;
       }
       msg.msg_iov = iov;
       msg.msg_iovlen = 1;
       msg.msg_control = (caddr_t)controlVector;

       cmsg = (struct cmsghdr *)controlVector;

       cmsg->cmsg_level = IPPROTO_SCTP;
       cmsg->cmsg_type = SCTP_SNDRCV;
       cmsg->cmsg_len = CMSG_LEN (sizeof(struct sctp_sndrcvinfo) );
       s_info = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);

       s_info->sinfo_stream = stream_no;
       s_info->sinfo_ssn = 0;
       s_info->sinfo_flags = flags;
       s_info->sinfo_ppid = ppid;
       s_info->sinfo_context = context;
       s_info->sinfo_assoc_id = 0;
       s_info->sinfo_timetolive = timetolive;
       errno = 0;
       msg.msg_controllen = cmsg->cmsg_len;
       sz = sendmsg(s, &msg, 0);
       return(sz);
}

sctp_assoc_t
sctp_getassocid(int sd, struct sockaddr *sa)
{
       struct sctp_paddrparams sp;
       socklen_t siz;

       /* First get the assoc id */
       siz = sizeof(struct sctp_paddrparams);
       memset(&sp, 0, sizeof(sp));
       memcpy((caddr_t)&sp.spp_address, sa, sa->sa_len);
       errno = 0;
       if (getsockopt2(sd, IPPROTO_SCTP, SCTP_PEER_ADDR_PARAMS, &sp, &siz) != 0)
               return((sctp_assoc_t)0);
       /* We depend on the fact that 0 can never be returned */
       return(sp.spp_assoc_id);
}



ssize_t
sctp_send(int sd, const void *data, size_t len,
         const struct sctp_sndrcvinfo *sinfo,
         int flags)
{
       ssize_t sz;
       struct msghdr msg;
       struct iovec iov[2];
       struct sctp_sndrcvinfo *s_info;
       char controlVector[256];
       struct cmsghdr *cmsg;

       iov[0].iov_base = (void *)(unsigned long)data;
       iov[0].iov_len = len;
       iov[1].iov_base = NULL;
       iov[1].iov_len = 0;

       msg.msg_name = 0;
       msg.msg_namelen = 0;
       msg.msg_iov = iov;
       msg.msg_iovlen = 1;
       msg.msg_control = (caddr_t)controlVector;

       cmsg = (struct cmsghdr *)controlVector;

       cmsg->cmsg_level = IPPROTO_SCTP;
       cmsg->cmsg_type = SCTP_SNDRCV;
       cmsg->cmsg_len = CMSG_LEN (sizeof(struct sctp_sndrcvinfo) );
       s_info = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
       /* copy in the data */
       *s_info = *sinfo;
       errno = 0;
       msg.msg_controllen = cmsg->cmsg_len;
       sz = sendmsg(sd, &msg, flags);
       return(sz);
}


ssize_t
sctp_sendx(int sd, const void *msg, size_t len,
          struct sockaddr *addrs, int addrcnt,
          struct sctp_sndrcvinfo *sinfo,
          int flags)
{
       int i, cnt, saved_errno;
       ssize_t ret;
       int add_len;
       struct sockaddr *at;
       struct sctp_connectx_addrs sca;

       len = 0;
       at = addrs;
       cnt = 0;
       /* validate all the addresses and get the size */
       for (i = 0; i < addrcnt; i++) {
               if (at->sa_family == AF_INET) {
                       add_len = sizeof(struct sockaddr_in);
               } else if (at->sa_family == AF_INET6) {
                       add_len = sizeof(struct sockaddr_in6);
               } else {
                       errno = EINVAL;
                       return (-1);
               }
               len += add_len;
               at = (struct sockaddr *)((caddr_t)at + add_len);
               cnt++;
       }
       /* do we have any? */
       if (cnt == 0) {
               errno = EINVAL;
               return(-1);
       }

       sca.cx_num = cnt;
       sca.cx_len = (int)len;
       sca.cx_addrs = addrs;
       ret = ioctl(sd, SIOCCONNECTXDEL, (void *)&sca);
       if (ret != 0) {
               return(ret);
       }
       sinfo->sinfo_assoc_id = sctp_getassocid(sd, addrs);
       if (sinfo->sinfo_assoc_id == 0) {
               printf("Huh, can't get associd? TSNH!\n");
               (void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
                                (unsigned int)addrs->sa_len);
               errno = ENOENT;
               return (-1);
       }
       ret = sctp_send(sd, msg, len, sinfo, flags);
       saved_errno = errno;
       (void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
                        (unsigned int)addrs->sa_len);

       errno = saved_errno;
       return (ret);
}

ssize_t
sctp_sendmsgx(int sd,
             const void *msg,
             size_t len,
             struct sockaddr *addrs,
             int addrcnt,
             u_int32_t ppid,
             u_int32_t flags,
             u_int16_t stream_no,
             u_int32_t timetolive,
             u_int32_t context)
{
       struct sctp_sndrcvinfo sinfo;

       memset((void *) &sinfo, 0, sizeof(struct sctp_sndrcvinfo));
       sinfo.sinfo_ppid       = ppid;
       sinfo.sinfo_flags      = flags;
       sinfo.sinfo_ssn        = stream_no;
       sinfo.sinfo_timetolive = timetolive;
       sinfo.sinfo_context    = context;
       return sctp_sendx(sd, msg, len, addrs, addrcnt, &sinfo, 0);
}

ssize_t
sctp_recvmsg (int s,
             void *dbuf,
             size_t len,
             struct sockaddr *from,
             socklen_t *fromlen,
             struct sctp_sndrcvinfo *sinfo,
             int *msg_flags)
{
       struct sctp_sndrcvinfo *s_info;
       ssize_t sz;
       struct msghdr msg;
       struct iovec iov[2];
       char controlVector[2048];
       struct cmsghdr *cmsg;
       iov[0].iov_base = dbuf;
       iov[0].iov_len = len;
       iov[1].iov_base = NULL;
       iov[1].iov_len = 0;
       msg.msg_name = (caddr_t)from;
       msg.msg_namelen = *fromlen;
       msg.msg_iov = iov;
       msg.msg_iovlen = 1;
       msg.msg_control = (caddr_t)controlVector;
       msg.msg_controllen = sizeof(controlVector);
       errno = 0;
       sz = recvmsg(s, &msg, 0);

       s_info = NULL;
       len = sz;
       *msg_flags = msg.msg_flags;
       *fromlen = msg.msg_namelen;
       if ((msg.msg_controllen) && sinfo) {
               /* parse through and see if we find
                * the sctp_sndrcvinfo (if the user wants it).
                */
               cmsg = (struct cmsghdr *)controlVector;
               while (cmsg) {
                       if (cmsg->cmsg_level == IPPROTO_SCTP) {
                               if (cmsg->cmsg_type == SCTP_SNDRCV) {
                                       /* Got it */
                                       s_info = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
                                       /* Copy it to the user */
                                       *sinfo = *s_info;
                                       break;
                               }
                       }
                       cmsg = CMSG_NXTHDR(&msg, cmsg);
               }
       }
       return(sz);
}

ssize_t
sctp_recvv(int sd,
   const struct iovec *iov,
   int iovlen,
   struct sockaddr *from,
   socklen_t * fromlen,
   void *info,
   socklen_t * infolen,
   unsigned int *infotype,
   int *flags)
{
       char cmsgbuf[SCTP_CONTROL_VEC_SIZE_RCV];
       struct msghdr msg;
       struct cmsghdr *cmsg;
       ssize_t ret;
       struct sctp_rcvinfo *rcvinfo;
       struct sctp_nxtinfo *nxtinfo;

       if (((info != NULL) && (infolen == NULL)) ||
           ((info == NULL) && (infolen != NULL) && (*infolen != 0)) ||
           ((info != NULL) && (infotype == NULL))) {
               errno = EINVAL;
               return (-1);
       }
       if (infotype) {
               *infotype = SCTP_RECVV_NOINFO;
       }
       msg.msg_name = from;
       if (fromlen == NULL) {
               msg.msg_namelen = 0;
       } else {
               msg.msg_namelen = *fromlen;
       }
       msg.msg_iov = __UNCONST(iov);
       msg.msg_iovlen = iovlen;
       msg.msg_control = cmsgbuf;
       msg.msg_controllen = sizeof(cmsgbuf);
       msg.msg_flags = 0;
       ret = recvmsg(sd, &msg, *flags);
       *flags = msg.msg_flags;
       if ((ret > 0) &&
           (msg.msg_controllen > 0) &&
           (infotype != NULL) &&
           (infolen != NULL) &&
           (*infolen > 0)) {
               rcvinfo = NULL;
               nxtinfo = NULL;
               for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
                       if (cmsg->cmsg_level != IPPROTO_SCTP) {
                               continue;
                       }
                       if (cmsg->cmsg_type == SCTP_RCVINFO) {
                               rcvinfo = (struct sctp_rcvinfo *)CMSG_DATA(cmsg);
                               if (nxtinfo != NULL) {
                                       break;
                               } else {
                                       continue;
                               }
                       }
                       if (cmsg->cmsg_type == SCTP_NXTINFO) {
                               nxtinfo = (struct sctp_nxtinfo *)CMSG_DATA(cmsg);
                               if (rcvinfo != NULL) {
                                       break;
                               } else {
                                       continue;
                               }
                       }
               }
               if (rcvinfo != NULL) {
                       if ((nxtinfo != NULL) && (*infolen >= sizeof(struct sctp_recvv_rn))) {
                               struct sctp_recvv_rn *rn_info;

                               rn_info = (struct sctp_recvv_rn *)info;
                               rn_info->recvv_rcvinfo = *rcvinfo;
                               rn_info->recvv_nxtinfo = *nxtinfo;
                               *infolen = (socklen_t) sizeof(struct sctp_recvv_rn);
                               *infotype = SCTP_RECVV_RN;
                       } else if (*infolen >= sizeof(struct sctp_rcvinfo)) {
                               memcpy(info, rcvinfo, sizeof(struct sctp_rcvinfo));
                               *infolen = (socklen_t) sizeof(struct sctp_rcvinfo);
                               *infotype = SCTP_RECVV_RCVINFO;
                       }
               } else if (nxtinfo != NULL) {
                       if (*infolen >= sizeof(struct sctp_nxtinfo)) {
                               memcpy(info, nxtinfo, sizeof(struct sctp_nxtinfo));
                               *infolen = (socklen_t) sizeof(struct sctp_nxtinfo);
                               *infotype = SCTP_RECVV_NXTINFO;
                       }
               }
       }
       return (ret);
}

ssize_t
sctp_sendv(int sd,
   const struct iovec *iov, int iovcnt,
   struct sockaddr *addrs, int addrcnt,
   void *info, socklen_t infolen, unsigned int infotype,
   int flags)
{
       ssize_t ret;
       int i;
       socklen_t addr_len;
       struct msghdr msg;
       in_port_t port;
       struct sctp_sendv_spa *spa_info;
       struct cmsghdr *cmsg;
       char *cmsgbuf;
       struct sockaddr *addr;
       struct sockaddr_in *addr_in;
       struct sockaddr_in6 *addr_in6;
       void *assoc_id_ptr;
       sctp_assoc_t assoc_id;

       if ((addrcnt < 0) ||
           (iovcnt < 0) ||
           ((addrs == NULL) && (addrcnt > 0)) ||
           ((addrs != NULL) && (addrcnt == 0)) ||
           ((iov == NULL) && (iovcnt > 0)) ||
           ((iov != NULL) && (iovcnt == 0))) {
               errno = EINVAL;
               return (-1);
       }
       cmsgbuf = malloc(CMSG_SPACE(sizeof(struct sctp_sndinfo)) +
           CMSG_SPACE(sizeof(struct sctp_prinfo)) +
           CMSG_SPACE(sizeof(struct sctp_authinfo)) +
           (size_t)addrcnt * CMSG_SPACE(sizeof(struct in6_addr)));
       if (cmsgbuf == NULL) {
               errno = ENOMEM;
               return (-1);
       }
       assoc_id_ptr = NULL;
       msg.msg_control = cmsgbuf;
       msg.msg_controllen = 0;
       cmsg = (struct cmsghdr *)cmsgbuf;
       switch (infotype) {
       case SCTP_SENDV_NOINFO:
               if ((infolen != 0) || (info != NULL)) {
                       free(cmsgbuf);
                       errno = EINVAL;
                       return (-1);
               }
               break;
       case SCTP_SENDV_SNDINFO:
               if ((info == NULL) || (infolen < sizeof(struct sctp_sndinfo))) {
                       free(cmsgbuf);
                       errno = EINVAL;
                       return (-1);
               }
               cmsg->cmsg_level = IPPROTO_SCTP;
               cmsg->cmsg_type = SCTP_SNDINFO;
               cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
               memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_sndinfo));
               msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
               cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
               assoc_id_ptr = &(((struct sctp_sndinfo *)info)->snd_assoc_id);
               break;
       case SCTP_SENDV_PRINFO:
               if ((info == NULL) || (infolen < sizeof(struct sctp_prinfo))) {
                       free(cmsgbuf);
                       errno = EINVAL;
                       return (-1);
               }
               cmsg->cmsg_level = IPPROTO_SCTP;
               cmsg->cmsg_type = SCTP_PRINFO;
               cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
               memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_prinfo));
               msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
               cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
               break;
       case SCTP_SENDV_AUTHINFO:
               if ((info == NULL) || (infolen < sizeof(struct sctp_authinfo))) {
                       free(cmsgbuf);
                       errno = EINVAL;
                       return (-1);
               }
               cmsg->cmsg_level = IPPROTO_SCTP;
               cmsg->cmsg_type = SCTP_AUTHINFO;
               cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
               memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_authinfo));
               msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
               cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
               break;
       case SCTP_SENDV_SPA:
               if ((info == NULL) || (infolen < sizeof(struct sctp_sendv_spa))) {
                       free(cmsgbuf);
                       errno = EINVAL;
                       return (-1);
               }
               spa_info = (struct sctp_sendv_spa *)info;
               if (spa_info->sendv_flags & SCTP_SEND_SNDINFO_VALID) {
                       cmsg->cmsg_level = IPPROTO_SCTP;
                       cmsg->cmsg_type = SCTP_SNDINFO;
                       cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
                       memcpy(CMSG_DATA(cmsg), &spa_info->sendv_sndinfo, sizeof(struct sctp_sndinfo));
                       msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
                       cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
                       assoc_id_ptr = &(spa_info->sendv_sndinfo.snd_assoc_id);
               }
               if (spa_info->sendv_flags & SCTP_SEND_PRINFO_VALID) {
                       cmsg->cmsg_level = IPPROTO_SCTP;
                       cmsg->cmsg_type = SCTP_PRINFO;
                       cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
                       memcpy(CMSG_DATA(cmsg), &spa_info->sendv_prinfo, sizeof(struct sctp_prinfo));
                       msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
                       cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
               }
               if (spa_info->sendv_flags & SCTP_SEND_AUTHINFO_VALID) {
                       cmsg->cmsg_level = IPPROTO_SCTP;
                       cmsg->cmsg_type = SCTP_AUTHINFO;
                       cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
                       memcpy(CMSG_DATA(cmsg), &spa_info->sendv_authinfo, sizeof(struct sctp_authinfo));
                       msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
                       cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
               }
               break;
       default:
               free(cmsgbuf);
               errno = EINVAL;
               return (-1);
       }
       addr = addrs;
       msg.msg_name = NULL;
       msg.msg_namelen = 0;

       for (i = 0; i < addrcnt; i++) {
               switch (addr->sa_family) {
               case AF_INET:
                       addr_len = (socklen_t) sizeof(struct sockaddr_in);
                       addr_in = (struct sockaddr_in *)(void *)addr;
                       if (addr_in->sin_len != addr_len) {
                               free(cmsgbuf);
                               errno = EINVAL;
                               return (-1);
                       }
                       if (i == 0) {
                               port = addr_in->sin_port;
                       } else {
                               if (port == addr_in->sin_port) {
                                       cmsg->cmsg_level = IPPROTO_SCTP;
                                       cmsg->cmsg_type = SCTP_DSTADDRV4;
                                       cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
                                       memcpy(CMSG_DATA(cmsg), &addr_in->sin_addr, sizeof(struct in_addr));
                                       msg.msg_controllen += CMSG_SPACE(sizeof(struct in_addr));
                                       cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in_addr)));
                               } else {
                                       free(cmsgbuf);
                                       errno = EINVAL;
                                       return (-1);
                               }
                       }
                       break;
               case AF_INET6:
                       addr_len = (socklen_t) sizeof(struct sockaddr_in6);
                       addr_in6 = (struct sockaddr_in6 *)(void *)addr;
                       if (addr_in6->sin6_len != addr_len) {
                               free(cmsgbuf);
                               errno = EINVAL;
                               return (-1);
                       }
                       if (i == 0) {
                               port = addr_in6->sin6_port;
                       } else {
                               if (port == addr_in6->sin6_port) {
                                       cmsg->cmsg_level = IPPROTO_SCTP;
                                       cmsg->cmsg_type = SCTP_DSTADDRV6;
                                       cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_addr));
                                       memcpy(CMSG_DATA(cmsg), &addr_in6->sin6_addr, sizeof(struct in6_addr));
                                       msg.msg_controllen += CMSG_SPACE(sizeof(struct in6_addr));
                                       cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in6_addr)));
                               } else {
                                       free(cmsgbuf);
                                       errno = EINVAL;
                                       return (-1);
                               }
                       }
                       break;
               default:
                       free(cmsgbuf);
                       errno = EINVAL;
                       return (-1);
               }
               if (i == 0) {
                       msg.msg_name = addr;
                       msg.msg_namelen = addr_len;
               }
               addr = (struct sockaddr *)((caddr_t)addr + addr_len);
       }
       if (msg.msg_controllen == 0) {
               msg.msg_control = NULL;
       }
       msg.msg_iov = __UNCONST(iov);
       msg.msg_iovlen = iovcnt;
       msg.msg_flags = 0;
       ret = sendmsg(sd, &msg, flags);
       free(cmsgbuf);
       if ((ret >= 0) && (addrs != NULL) && (assoc_id_ptr != NULL)) {
               assoc_id = sctp_getassocid(sd, addrs);
               memcpy(assoc_id_ptr, &assoc_id, sizeof(assoc_id));
       }
       return (ret);
}

int
sctp_peeloff(int sd, sctp_assoc_t assoc_id)
{
       int ret;
       uint32_t val;

       val = assoc_id;
       ret = ioctl(sd, SIOCPEELOFF, &val);
       if (ret == -1)
               return ret;
       else
               return (int) val;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.