/*

 * Copyright 2005-2019 The OpenSSL Project Authors. All Rights Reserved.

 *

 * Licensed under the OpenSSL license (the "License").  You may not use

 * this file except in compliance with the License.  You can obtain a copy

 * in the file LICENSE in the source distribution or at

 * https://www.openssl.org/source/license.html

 */

#include <stdio.h>

#include <errno.h>

#include "bio_local.h"

#ifndef OPENSSL_NO_DGRAM

# ifndef OPENSSL_NO_SCTP

#  include <netinet/sctp.h>

#  include <fcntl.h>

#  define OPENSSL_SCTP_DATA_CHUNK_TYPE            0x00

#  define OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE 0xc0

# endif

# if defined(OPENSSL_SYS_LINUX) && !defined(IP_MTU)

#  define IP_MTU      14        /* linux is lame */

# endif

# if OPENSSL_USE_IPV6 && !defined(IPPROTO_IPV6)

#  define IPPROTO_IPV6 41       /* windows is lame */

# endif

# if defined(__FreeBSD__) && defined(IN6_IS_ADDR_V4MAPPED)

/* Standard definition causes type-punning problems. */

#  undef IN6_IS_ADDR_V4MAPPED

#  define s6_addr32 __u6_addr.__u6_addr32

#  define IN6_IS_ADDR_V4MAPPED(a)               \

        (((a)->s6_addr32[0] == 0) &&          \

         ((a)->s6_addr32[1] == 0) &&          \

         ((a)->s6_addr32[2] == htonl(0x0000ffff)))

# endif

static int dgram_write(BIO *h, const char *buf, int num);

static int dgram_read(BIO *h, char *buf, int size);

static int dgram_puts(BIO *h, const char *str);

static long dgram_ctrl(BIO *h, int cmd, long arg1, void *arg2);

static int dgram_new(BIO *h);

static int dgram_free(BIO *data);

static int dgram_clear(BIO *bio);

# ifndef OPENSSL_NO_SCTP

static int dgram_sctp_write(BIO *h, const char *buf, int num);

static int dgram_sctp_read(BIO *h, char *buf, int size);

static int dgram_sctp_puts(BIO *h, const char *str);

static long dgram_sctp_ctrl(BIO *h, int cmd, long arg1, void *arg2);

static int dgram_sctp_new(BIO *h);

static int dgram_sctp_free(BIO *data);

#  ifdef SCTP_AUTHENTICATION_EVENT

static void dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification

                                                  *snp);

#  endif

# endif

static int BIO_dgram_should_retry(int s);

static void get_current_time(struct timeval *t);

static const BIO_METHOD methods_dgramp = {

    BIO_TYPE_DGRAM,

    "datagram socket",

    /* TODO: Convert to new style write function */

    bwrite_conv,

    dgram_write,

    /* TODO: Convert to new style read function */

    bread_conv,

    dgram_read,

    dgram_puts,

    NULL,                       /* dgram_gets,         */

    dgram_ctrl,

    dgram_new,

    dgram_free,

    NULL,                       /* dgram_callback_ctrl */

};

# ifndef OPENSSL_NO_SCTP

static const BIO_METHOD methods_dgramp_sctp = {

    BIO_TYPE_DGRAM_SCTP,

    "datagram sctp socket",

    /* TODO: Convert to new style write function */

    bwrite_conv,

    dgram_sctp_write,

    /* TODO: Convert to new style write function */

    bread_conv,

    dgram_sctp_read,

    dgram_sctp_puts,

    NULL,                       /* dgram_gets,         */

    dgram_sctp_ctrl,

    dgram_sctp_new,

    dgram_sctp_free,

    NULL,                       /* dgram_callback_ctrl */

};

# endif

typedef struct bio_dgram_data_st {

    BIO_ADDR peer;

    unsigned int connected;

    unsigned int _errno;

    unsigned int mtu;

    struct timeval next_timeout;

    struct timeval socket_timeout;

    unsigned int peekmode;

} bio_dgram_data;

# ifndef OPENSSL_NO_SCTP

typedef struct bio_dgram_sctp_save_message_st {

    BIO *bio;

    char *data;

    int length;

} bio_dgram_sctp_save_message;

typedef struct bio_dgram_sctp_data_st {

    BIO_ADDR peer;

    unsigned int connected;

    unsigned int _errno;

    unsigned int mtu;

    struct bio_dgram_sctp_sndinfo sndinfo;

    struct bio_dgram_sctp_rcvinfo rcvinfo;

    struct bio_dgram_sctp_prinfo prinfo;

    void (*handle_notifications) (BIO *bio, void *context, void *buf);

    void *notification_context;

    int in_handshake;

    int ccs_rcvd;

    int ccs_sent;

    int save_shutdown;

    int peer_auth_tested;

} bio_dgram_sctp_data;

# endif

const BIO_METHOD *BIO_s_datagram(void)

{

    return &methods_dgramp;

}

BIO *BIO_new_dgram(int fd, int close_flag)

{

    BIO *ret;

    ret = BIO_new(BIO_s_datagram());

    if (ret == NULL)

        return NULL;

    BIO_set_fd(ret, fd, close_flag);

    return ret;

}

static int dgram_new(BIO *bi)

{

    bio_dgram_data *data = OPENSSL_zalloc(sizeof(*data));

    if (data == NULL)

        return 0;

    bi->ptr = data;

    return 1;

}

static int dgram_free(BIO *a)

{

    bio_dgram_data *data;

    if (a == NULL)

        return 0;

    if (!dgram_clear(a))

        return 0;

    data = (bio_dgram_data *)a->ptr;

    OPENSSL_free(data);

    return 1;

}

static int dgram_clear(BIO *a)

{

    if (a == NULL)

        return 0;

    if (a->shutdown) {

        if (a->init) {

            BIO_closesocket(a->num);

        }

        a->init = 0;

        a->flags = 0;

    }

    return 1;

}

static void dgram_adjust_rcv_timeout(BIO *b)

{

# if defined(SO_RCVTIMEO)

    bio_dgram_data *data = (bio_dgram_data *)b->ptr;

    union {

        size_t s;

        int i;

    } sz = {

        0

    };

    /* Is a timer active? */

    if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) {

        struct timeval timenow, timeleft;

        /* Read current socket timeout */

#  ifdef OPENSSL_SYS_WINDOWS

        int timeout;

        sz.i = sizeof(timeout);

        if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,

                       (void *)&timeout, &sz.i) < 0) {

            perror("getsockopt");

        } else {

            data->socket_timeout.tv_sec = timeout / 1000;

            data->socket_timeout.tv_usec = (timeout % 1000) * 1000;

        }

#  else

        sz.i = sizeof(data->socket_timeout);

        if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,

                       &(data->socket_timeout), (void *)&sz) < 0) {

            perror("getsockopt");

        } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0)

            OPENSSL_assert(sz.s <= sizeof(data->socket_timeout));

#  endif

        /* Get current time */

        get_current_time(&timenow);

        /* Calculate time left until timer expires */

        memcpy(&timeleft, &(data->next_timeout), sizeof(struct timeval));

        if (timeleft.tv_usec < timenow.tv_usec) {

            timeleft.tv_usec = 1000000 - timenow.tv_usec + timeleft.tv_usec;

            timeleft.tv_sec--;

        } else {

            timeleft.tv_usec -= timenow.tv_usec;

        }

        if (timeleft.tv_sec < timenow.tv_sec) {

            timeleft.tv_sec = 0;

            timeleft.tv_usec = 1;

        } else {

            timeleft.tv_sec -= timenow.tv_sec;

        }

        /*

         * Adjust socket timeout if next handshake message timer will expire

         * earlier.

         */

        if ((data->socket_timeout.tv_sec == 0

             && data->socket_timeout.tv_usec == 0)

            || (data->socket_timeout.tv_sec > timeleft.tv_sec)

            || (data->socket_timeout.tv_sec == timeleft.tv_sec

                && data->socket_timeout.tv_usec >= timeleft.tv_usec)) {

#  ifdef OPENSSL_SYS_WINDOWS

            timeout = timeleft.tv_sec * 1000 + timeleft.tv_usec / 1000;

            if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,

                           (void *)&timeout, sizeof(timeout)) < 0) {

                perror("setsockopt");

            }

#  else

            if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &timeleft,

                           sizeof(struct timeval)) < 0) {

                perror("setsockopt");

            }

#  endif

        }

    }

# endif

}

static void dgram_reset_rcv_timeout(BIO *b)

{

# if defined(SO_RCVTIMEO)

    bio_dgram_data *data = (bio_dgram_data *)b->ptr;

    /* Is a timer active? */

    if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) {

#  ifdef OPENSSL_SYS_WINDOWS

        int timeout = data->socket_timeout.tv_sec * 1000 +

            data->socket_timeout.tv_usec / 1000;

        if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,

                       (void *)&timeout, sizeof(timeout)) < 0) {

            perror("setsockopt");

        }

#  else

        if (setsockopt

            (b->num, SOL_SOCKET, SO_RCVTIMEO, &(data->socket_timeout),

             sizeof(struct timeval)) < 0) {

            perror("setsockopt");

        }

#  endif

    }

# endif

}

static int dgram_read(BIO *b, char *out, int outl)

{

    int ret = 0;

    bio_dgram_data *data = (bio_dgram_data *)b->ptr;

    int flags = 0;

    BIO_ADDR peer;

    socklen_t len = sizeof(peer);

    if (out != NULL) {

        clear_socket_error();

        memset(&peer, 0, sizeof(peer));

        dgram_adjust_rcv_timeout(b);

        if (data->peekmode)

            flags = MSG_PEEK;

        ret = recvfrom(b->num, out, outl, flags,

                       BIO_ADDR_sockaddr_noconst(&peer), &len;;

        if (!data->connected && ret >= 0)

            BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, &peer);

        BIO_clear_retry_flags(b);

        if (ret < 0) {

            if (BIO_dgram_should_retry(ret)) {

                BIO_set_retry_read(b);

                data->_errno = get_last_socket_error();

            }

        }

        dgram_reset_rcv_timeout(b);

    }

    return ret;

}

static int dgram_write(BIO *b, const char *in, int inl)

{

    int ret;

    bio_dgram_data *data = (bio_dgram_data *)b->ptr;

    clear_socket_error();

    if (data->connected)

        ret = writesocket(b->num, in, inl);

    else {

        int peerlen = BIO_ADDR_sockaddr_size(&data->peer);

        ret = sendto(b->num, in, inl, 0,

                     BIO_ADDR_sockaddr(&data->peer), peerlen);

    }

    BIO_clear_retry_flags(b);

    if (ret <= 0) {

        if (BIO_dgram_should_retry(ret)) {

            BIO_set_retry_write(b);

            data->_errno = get_last_socket_error();

        }

    }

    return ret;

}

static long dgram_get_mtu_overhead(bio_dgram_data *data)

{

    long ret;

    switch (BIO_ADDR_family(&data->peer)) {

    case AF_INET:

        /*

         * Assume this is UDP - 20 bytes for IP, 8 bytes for UDP

         */

        ret = 28;

        break;

# if OPENSSL_USE_IPV6

    case AF_INET6:

        {

#  ifdef IN6_IS_ADDR_V4MAPPED

            struct in6_addr tmp_addr;

            if (BIO_ADDR_rawaddress(&data->peer, &tmp_addr, NULL)

                && IN6_IS_ADDR_V4MAPPED(&tmp_addr))

                /*

                 * Assume this is UDP - 20 bytes for IP, 8 bytes for UDP

                 */

                ret = 28;

            else

#  endif

            /*

             * Assume this is UDP - 40 bytes for IP, 8 bytes for UDP

             */

            ret = 48;

        }

        break;

# endif

    default:

        /* We don't know. Go with the historical default */

        ret = 28;

        break;

    }

    return ret;

}

static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr)

{

    long ret = 1;

    int *ip;

    bio_dgram_data *data = NULL;

    int sockopt_val = 0;

    int d_errno;

# if defined(OPENSSL_SYS_LINUX) && (defined(IP_MTU_DISCOVER) || defined(IP_MTU))

    socklen_t sockopt_len;      /* assume that system supporting IP_MTU is

                                 * modern enough to define socklen_t */

    socklen_t addr_len;

    BIO_ADDR addr;

# endif

    data = (bio_dgram_data *)b->ptr;

    switch (cmd) {

    case BIO_CTRL_RESET:

        num = 0;

        ret = 0;

        break;

    case BIO_CTRL_INFO:

        ret = 0;

        break;

    case BIO_C_SET_FD:

        dgram_clear(b);

        b->num = *((int *)ptr);

        b->shutdown = (int)num;

        b->init = 1;

        break;

    case BIO_C_GET_FD:

        if (b->init) {

            ip = (int *)ptr;

            if (ip != NULL)

                *ip = b->num;

            ret = b->num;

        } else

            ret = -1;

        break;

    case BIO_CTRL_GET_CLOSE:

        ret = b->shutdown;

        break;

    case BIO_CTRL_SET_CLOSE:

        b->shutdown = (int)num;

        break;

    case BIO_CTRL_PENDING:

    case BIO_CTRL_WPENDING:

        ret = 0;

        break;

    case BIO_CTRL_DUP:

    case BIO_CTRL_FLUSH:

        ret = 1;

        break;

    case BIO_CTRL_DGRAM_CONNECT:

        BIO_ADDR_make(&data->peer, BIO_ADDR_sockaddr((BIO_ADDR *)ptr));

        break;

        /* (Linux)kernel sets DF bit on outgoing IP packets */

    case BIO_CTRL_DGRAM_MTU_DISCOVER:

# if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO)

        addr_len = (socklen_t) sizeof(addr);

        memset(&addr, 0, sizeof(addr));

        if (getsockname(b->num, &addr.sa, &addr_len) < 0) {

            ret = 0;

            break;

        }

        switch (addr.sa.sa_family) {

        case AF_INET:

            sockopt_val = IP_PMTUDISC_DO;

            if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,

                                  &sockopt_val, sizeof(sockopt_val))) < 0)

                perror("setsockopt");

            break;

#  if OPENSSL_USE_IPV6 && defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO)

        case AF_INET6:

            sockopt_val = IPV6_PMTUDISC_DO;

            if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,

                                  &sockopt_val, sizeof(sockopt_val))) < 0)

                perror("setsockopt");

            break;

#  endif

        default:

            ret = -1;

            break;

        }

# else

        ret = -1;

# endif

        break;

    case BIO_CTRL_DGRAM_QUERY_MTU:

# if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU)

        addr_len = (socklen_t) sizeof(addr);

        memset(&addr, 0, sizeof(addr));

        if (getsockname(b->num, &addr.sa, &addr_len) < 0) {

            ret = 0;

            break;

        }

        sockopt_len = sizeof(sockopt_val);

        switch (addr.sa.sa_family) {

        case AF_INET:

            if ((ret =

                 getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val,

                            &sockopt_len)) < 0 || sockopt_val < 0) {

                ret = 0;

            } else {

                /*

                 * we assume that the transport protocol is UDP and no IP

                 * options are used.

                 */

                data->mtu = sockopt_val - 8 - 20;

                ret = data->mtu;

            }

            break;

#  if OPENSSL_USE_IPV6 && defined(IPV6_MTU)

        case AF_INET6:

            if ((ret =

                 getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU,

                            (void *)&sockopt_val, &sockopt_len)) < 0

                || sockopt_val < 0) {

                ret = 0;

            } else {

                /*

                 * we assume that the transport protocol is UDP and no IPV6

                 * options are used.

                 */

                data->mtu = sockopt_val - 8 - 40;

                ret = data->mtu;

            }

            break;

#  endif

        default:

            ret = 0;

            break;

        }

# else

        ret = 0;

# endif

        break;

    case BIO_CTRL_DGRAM_GET_FALLBACK_MTU:

        ret = -dgram_get_mtu_overhead(data);

        switch (BIO_ADDR_family(&data->peer)) {

        case AF_INET:

            ret += 576;

            break;

# if OPENSSL_USE_IPV6

        case AF_INET6:

            {

#  ifdef IN6_IS_ADDR_V4MAPPED

                struct in6_addr tmp_addr;

                if (BIO_ADDR_rawaddress(&data->peer, &tmp_addr, NULL)

                    && IN6_IS_ADDR_V4MAPPED(&tmp_addr))

                    ret += 576;

                else

#  endif

                    ret += 1280;

            }

            break;

# endif

        default:

            ret += 576;

            break;

        }

        break;

    case BIO_CTRL_DGRAM_GET_MTU:

        return data->mtu;

    case BIO_CTRL_DGRAM_SET_MTU:

        data->mtu = num;

        ret = num;

        break;

    case BIO_CTRL_DGRAM_SET_CONNECTED:

        if (ptr != NULL) {

            data->connected = 1;

            BIO_ADDR_make(&data->peer, BIO_ADDR_sockaddr((BIO_ADDR *)ptr));

        } else {

            data->connected = 0;

            memset(&data->peer, 0, sizeof(data->peer));

        }

        break;

    case BIO_CTRL_DGRAM_GET_PEER:

        ret = BIO_ADDR_sockaddr_size(&data->peer);

        /* FIXME: if num < ret, we will only return part of an address.

           That should bee an error, no? */

        if (num == 0 || num > ret)

            num = ret;

        memcpy(ptr, &data->peer, (ret = num));

        break;

    case BIO_CTRL_DGRAM_SET_PEER:

        BIO_ADDR_make(&data->peer, BIO_ADDR_sockaddr((BIO_ADDR *)ptr));

        break;

    case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:

        memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));

        break;

# if defined(SO_RCVTIMEO)

    case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:

#  ifdef OPENSSL_SYS_WINDOWS

        {

            struct timeval *tv = (struct timeval *)ptr;

            int timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;

            if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,

                           (void *)&timeout, sizeof(timeout)) < 0) {

                perror("setsockopt");

                ret = -1;

            }

        }

#  else

        if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr,

                       sizeof(struct timeval)) < 0) {

            perror("setsockopt");

            ret = -1;

        }

#  endif

        break;

    case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT:

        {

            union {

                size_t s;

                int i;

            } sz = {

                0

            };

#  ifdef OPENSSL_SYS_WINDOWS

            int timeout;

            struct timeval *tv = (struct timeval *)ptr;

            sz.i = sizeof(timeout);

            if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,

                           (void *)&timeout, &sz.i) < 0) {

                perror("getsockopt");

                ret = -1;

            } else {

                tv->tv_sec = timeout / 1000;

                tv->tv_usec = (timeout % 1000) * 1000;

                ret = sizeof(*tv);

            }

#  else

            sz.i = sizeof(struct timeval);

            if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,

                           ptr, (void *)&sz) < 0) {

                perror("getsockopt");

                ret = -1;

            } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) {

                OPENSSL_assert(sz.s <= sizeof(struct timeval));

                ret = (int)sz.s;

            } else

                ret = sz.i;

#  endif

        }

        break;

# endif

# if defined(SO_SNDTIMEO)

    case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT:

#  ifdef OPENSSL_SYS_WINDOWS

        {

            struct timeval *tv = (struct timeval *)ptr;

            int timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;

            if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,

                           (void *)&timeout, sizeof(timeout)) < 0) {

                perror("setsockopt");

                ret = -1;

            }

        }

#  else

        if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr,

                       sizeof(struct timeval)) < 0) {

            perror("setsockopt");

            ret = -1;

        }

#  endif

        break;

    case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT:

        {

            union {

                size_t s;

                int i;

            } sz = {

                0

            };

#  ifdef OPENSSL_SYS_WINDOWS

            int timeout;

            struct timeval *tv = (struct timeval *)ptr;

            sz.i = sizeof(timeout);

            if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,

                           (void *)&timeout, &sz.i) < 0) {

                perror("getsockopt");

                ret = -1;

            } else {

                tv->tv_sec = timeout / 1000;

                tv->tv_usec = (timeout % 1000) * 1000;

                ret = sizeof(*tv);

            }

#  else

            sz.i = sizeof(struct timeval);

            if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,

                           ptr, (void *)&sz) < 0) {

                perror("getsockopt");

                ret = -1;

            } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) {

                OPENSSL_assert(sz.s <= sizeof(struct timeval));

                ret = (int)sz.s;

            } else

                ret = sz.i;

#  endif

        }

        break;

# endif

    case BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP:

        /* fall-through */

    case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP:

# ifdef OPENSSL_SYS_WINDOWS

        d_errno = (data->_errno == WSAETIMEDOUT);

# else

        d_errno = (data->_errno == EAGAIN);

# endif

        if (d_errno) {

            ret = 1;

            data->_errno = 0;

        } else

            ret = 0;

        break;

# ifdef EMSGSIZE

    case BIO_CTRL_DGRAM_MTU_EXCEEDED:

        if (data->_errno == EMSGSIZE) {

            ret = 1;

            data->_errno = 0;

        } else

            ret = 0;

        break;

# endif

    case BIO_CTRL_DGRAM_SET_DONT_FRAG:

        sockopt_val = num ? 1 : 0;

        switch (data->peer.sa.sa_family) {

        case AF_INET:

# if defined(IP_DONTFRAG)

            if ((ret = setsockopt(b->num, IPPROTO_IP, IP_DONTFRAG,

                                  &sockopt_val, sizeof(sockopt_val))) < 0) {

                perror("setsockopt");

                ret = -1;

            }

# elif defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined (IP_PMTUDISC_PROBE)

            if ((sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT),

                (ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,

                                  &sockopt_val, sizeof(sockopt_val))) < 0) {

                perror("setsockopt");

                ret = -1;

            }

# elif defined(OPENSSL_SYS_WINDOWS) && defined(IP_DONTFRAGMENT)

            if ((ret = setsockopt(b->num, IPPROTO_IP, IP_DONTFRAGMENT,

                                  (const char *)&sockopt_val,

                                  sizeof(sockopt_val))) < 0) {

                perror("setsockopt");

                ret = -1;

            }

# else

            ret = -1;

# endif

            break;

# if OPENSSL_USE_IPV6

        case AF_INET6:

#  if defined(IPV6_DONTFRAG)

            if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_DONTFRAG,

                                  (const void *)&sockopt_val,

                                  sizeof(sockopt_val))) < 0) {

                perror("setsockopt");

                ret = -1;

            }

#  elif defined(OPENSSL_SYS_LINUX) && defined(IPV6_MTUDISCOVER)

            if ((sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT),

                (ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,

                                  &sockopt_val, sizeof(sockopt_val))) < 0) {

                perror("setsockopt");

                ret = -1;

            }

#  else

            ret = -1;

#  endif

            break;

# endif

        default:

            ret = -1;

            break;

        }

        break;

    case BIO_CTRL_DGRAM_GET_MTU_OVERHEAD:

        ret = dgram_get_mtu_overhead(data);

        break;

    /*

     * BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE is used here for compatibility

     * reasons. When BIO_CTRL_DGRAM_SET_PEEK_MODE was first defined its value

     * was incorrectly clashing with BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE. The

     * value has been updated to a non-clashing value. However to preserve

     * binary compatibility we now respond to both the old value and the new one

     */

    case BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE:

    case BIO_CTRL_DGRAM_SET_PEEK_MODE:

        data->peekmode = (unsigned int)num;

        break;

    default:

        ret = 0;

        break;

    }

    return ret;

}

static int dgram_puts(BIO *bp, const char *str)

{

    int n, ret;

    n = strlen(str);

    ret = dgram_write(bp, str, n);

    return ret;

}

# ifndef OPENSSL_NO_SCTP

const BIO_METHOD *BIO_s_datagram_sctp(void)

{

    return &methods_dgramp_sctp;

}

BIO *BIO_new_dgram_sctp(int fd, int close_flag)

{

    BIO *bio;

    int ret, optval = 20000;

    int auth_data = 0, auth_forward = 0;

    unsigned char *p;

    struct sctp_authchunk auth;

    struct sctp_authchunks *authchunks;

    socklen_t sockopt_len;

#  ifdef SCTP_AUTHENTICATION_EVENT

#   ifdef SCTP_EVENT

    struct sctp_event event;

#   else

    struct sctp_event_subscribe event;

#   endif

#  endif

    bio = BIO_new(BIO_s_datagram_sctp());

    if (bio == NULL)

        return NULL;

    BIO_set_fd(bio, fd, close_flag);

    /* Activate SCTP-AUTH for DATA and FORWARD-TSN chunks */

    auth.sauth_chunk = OPENSSL_SCTP_DATA_CHUNK_TYPE;

    ret =

        setsockopt(fd, IPPROTO_SCTP, SCTP_AUTH_CHUNK, &auth,

                   sizeof(struct sctp_authchunk));

    if (ret < 0) {

        BIO_vfree(bio);

        BIOerr(BIO_F_BIO_NEW_DGRAM_SCTP, ERR_R_SYS_LIB);

        ERR_add_error_data(1, "Ensure SCTP AUTH chunks are enabled in kernel");

        return NULL;

    }

    auth.sauth_chunk = OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE;

    ret =

        setsockopt(fd, IPPROTO_SCTP, SCTP_AUTH_CHUNK, &auth,

                   sizeof(struct sctp_authchunk));

    if (ret < 0) {

        BIO_vfree(bio);

        BIOerr(BIO_F_BIO_NEW_DGRAM_SCTP, ERR_R_SYS_LIB);

        ERR_add_error_data(1, "Ensure SCTP AUTH chunks are enabled in kernel");

        return NULL;

    }

    /*

     * Test if activation was successful. When using accept(), SCTP-AUTH has

     * to be activated for the listening socket already, otherwise the

     * connected socket won't use it. Similarly with connect(): the socket

     * prior to connection must be activated for SCTP-AUTH

     */

    sockopt_len = (socklen_t) (sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));

    authchunks = OPENSSL_zalloc(sockopt_len);

    if (authchunks == NULL) {

        BIO_vfree(bio);

        return NULL;

    }

    ret = getsockopt(fd, IPPROTO_SCTP, SCTP_LOCAL_AUTH_CHUNKS, authchunks,

                   &sockopt_len);

    if (ret < 0) {

        OPENSSL_free(authchunks);

        BIO_vfree(bio);

        return NULL;

    }

    for (p = (unsigned char *)authchunks->gauth_chunks;

         p < (unsigned char *)authchunks + sockopt_len;