crypto/bio/bss_dgram.c

   1 /* crypto/bio/bio_dgram.c */
   2 /*
   3  * DTLS implementation written by Nagendra Modadugu
   4  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
   5  */
   6 /* ====================================================================
   7  * Copyright (c) 1999-2005 The OpenSSL Project.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  *
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in
  18  *    the documentation and/or other materials provided with the
  19  *    distribution.
  20  *
  21  * 3. All advertising materials mentioning features or use of this
  22  *    software must display the following acknowledgment:
  23  *    "This product includes software developed by the OpenSSL Project
  24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  25  *
  26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  27  *    endorse or promote products derived from this software without
  28  *    prior written permission. For written permission, please contact
  29  *    openssl-core@OpenSSL.org.
  30  *
  31  * 5. Products derived from this software may not be called "OpenSSL"
  32  *    nor may "OpenSSL" appear in their names without prior written
  33  *    permission of the OpenSSL Project.
  34  *
  35  * 6. Redistributions of any form whatsoever must retain the following
  36  *    acknowledgment:
  37  *    "This product includes software developed by the OpenSSL Project
  38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  39  *
  40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  51  * OF THE POSSIBILITY OF SUCH DAMAGE.
  52  * ====================================================================
  53  *
  54  * This product includes cryptographic software written by Eric Young
  55  * (eay@cryptsoft.com).  This product includes software written by Tim
  56  * Hudson (tjh@cryptsoft.com).
  57  *
  58  */
  59
  60 #include <stdio.h>
  61 #include <errno.h>
  62 #define USE_SOCKETS
  63 #include "internal/cryptlib.h"
  64
  65 #include <openssl/bio.h>
  66 #ifndef OPENSSL_NO_DGRAM
  67
  68 # if !(defined(_WIN32) || defined(OPENSSL_SYS_VMS))
  69 #  include <sys/time.h>
  70 # endif
  71 # if defined(OPENSSL_SYS_VMS)
  72 #  include <sys/timeb.h>
  73 # endif
  74
  75 # ifndef OPENSSL_NO_SCTP
  76 #  include <netinet/sctp.h>
  77 #  include <fcntl.h>
  78 #  define OPENSSL_SCTP_DATA_CHUNK_TYPE            0x00
  79 #  define OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE 0xc0
  80 # endif
  81
  82 # if defined(OPENSSL_SYS_LINUX) && !defined(IP_MTU)
  83 #  define IP_MTU      14        /* linux is lame */
  84 # endif
  85
  86 # if OPENSSL_USE_IPV6 && !defined(IPPROTO_IPV6)
  87 #  define IPPROTO_IPV6 41       /* windows is lame */
  88 # endif
  89
  90 # if defined(__FreeBSD__) && defined(IN6_IS_ADDR_V4MAPPED)
  91 /* Standard definition causes type-punning problems. */
  92 #  undef IN6_IS_ADDR_V4MAPPED
  93 #  define s6_addr32 __u6_addr.__u6_addr32
  94 #  define IN6_IS_ADDR_V4MAPPED(a)               \
  95         (((a)->s6_addr32[0] == 0) &&          \
  96          ((a)->s6_addr32[1] == 0) &&          \
  97          ((a)->s6_addr32[2] == htonl(0x0000ffff)))
  98 # endif
  99
 100 # ifdef WATT32
 101 #  define sock_write SockWrite  /* Watt-32 uses same names */
 102 #  define sock_read  SockRead
 103 #  define sock_puts  SockPuts
 104 # endif
 105
 106 static int dgram_write(BIO *h, const char *buf, int num);
 107 static int dgram_read(BIO *h, char *buf, int size);
 108 static int dgram_puts(BIO *h, const char *str);
 109 static long dgram_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 110 static int dgram_new(BIO *h);
 111 static int dgram_free(BIO *data);
 112 static int dgram_clear(BIO *bio);
 113
 114 # ifndef OPENSSL_NO_SCTP
 115 static int dgram_sctp_write(BIO *h, const char *buf, int num);
 116 static int dgram_sctp_read(BIO *h, char *buf, int size);
 117 static int dgram_sctp_puts(BIO *h, const char *str);
 118 static long dgram_sctp_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 119 static int dgram_sctp_new(BIO *h);
 120 static int dgram_sctp_free(BIO *data);
 121 #  ifdef SCTP_AUTHENTICATION_EVENT
 122 static void dgram_sctp_handle_auth_free_key_event(BIO *b, union sctp_notification
 123                                                   *snp);
 124 #  endif
 125 # endif
 126
 127 static int BIO_dgram_should_retry(int s);
 128
 129 static void get_current_time(struct timeval *t);
 130
 131 static BIO_METHOD methods_dgramp = {
 132     BIO_TYPE_DGRAM,
 133     "datagram socket",
 134     dgram_write,
 135     dgram_read,
 136     dgram_puts,
 137     NULL,                       /* dgram_gets, */
 138     dgram_ctrl,
 139     dgram_new,
 140     dgram_free,
 141     NULL,
 142 };
 143
 144 # ifndef OPENSSL_NO_SCTP
 145 static BIO_METHOD methods_dgramp_sctp = {
 146     BIO_TYPE_DGRAM_SCTP,
 147     "datagram sctp socket",
 148     dgram_sctp_write,
 149     dgram_sctp_read,
 150     dgram_sctp_puts,
 151     NULL,                       /* dgram_gets, */
 152     dgram_sctp_ctrl,
 153     dgram_sctp_new,
 154     dgram_sctp_free,
 155     NULL,
 156 };
 157 # endif
 158
 159 typedef struct bio_dgram_data_st {
 160     union {
 161         struct sockaddr sa;
 162         struct sockaddr_in sa_in;
 163 # if OPENSSL_USE_IPV6
 164         struct sockaddr_in6 sa_in6;
 165 # endif
 166     } peer;
 167     unsigned int connected;
 168     unsigned int _errno;
 169     unsigned int mtu;
 170     struct timeval next_timeout;
 171     struct timeval socket_timeout;
 172 } bio_dgram_data;
 173
 174 # ifndef OPENSSL_NO_SCTP
 175 typedef struct bio_dgram_sctp_save_message_st {
 176     BIO *bio;
 177     char *data;
 178     int length;
 179 } bio_dgram_sctp_save_message;
 180
 181 typedef struct bio_dgram_sctp_data_st {
 182     union {
 183         struct sockaddr sa;
 184         struct sockaddr_in sa_in;
 185 #  if OPENSSL_USE_IPV6
 186         struct sockaddr_in6 sa_in6;
 187 #  endif
 188     } peer;
 189     unsigned int connected;
 190     unsigned int _errno;
 191     unsigned int mtu;
 192     struct bio_dgram_sctp_sndinfo sndinfo;
 193     struct bio_dgram_sctp_rcvinfo rcvinfo;
 194     struct bio_dgram_sctp_prinfo prinfo;
 195     void (*handle_notifications) (BIO *bio, void *context, void *buf);
 196     void *notification_context;
 197     int in_handshake;
 198     int ccs_rcvd;
 199     int ccs_sent;
 200     int save_shutdown;
 201     int peer_auth_tested;
 202     bio_dgram_sctp_save_message saved_message;
 203 } bio_dgram_sctp_data;
 204 # endif
 205
 206 BIO_METHOD *BIO_s_datagram(void)
 207 {
 208     return (&methods_dgramp);
 209 }
 210
 211 BIO *BIO_new_dgram(int fd, int close_flag)
 212 {
 213     BIO *ret;
 214
 215     ret = BIO_new(BIO_s_datagram());
 216     if (ret == NULL)
 217         return (NULL);
 218     BIO_set_fd(ret, fd, close_flag);
 219     return (ret);
 220 }
 221
 222 static int dgram_new(BIO *bi)
 223 {
 224     bio_dgram_data *data = OPENSSL_zalloc(sizeof(*data));
 225
 226     if (data == NULL)
 227         return 0;
 228     bi->init = 0;
 229     bi->num = 0;
 230     bi->ptr = data;
 231     bi->flags = 0;
 232     return (1);
 233 }
 234
 235 static int dgram_free(BIO *a)
 236 {
 237     bio_dgram_data *data;
 238
 239     if (a == NULL)
 240         return (0);
 241     if (!dgram_clear(a))
 242         return 0;
 243
 244     data = (bio_dgram_data *)a->ptr;
 245     OPENSSL_free(data);
 246
 247     return (1);
 248 }
 249
 250 static int dgram_clear(BIO *a)
 251 {
 252     if (a == NULL)
 253         return (0);
 254     if (a->shutdown) {
 255         if (a->init) {
 256             SHUTDOWN2(a->num);
 257         }
 258         a->init = 0;
 259         a->flags = 0;
 260     }
 261     return (1);
 262 }
 263
 264 static void dgram_adjust_rcv_timeout(BIO *b)
 265 {
 266 # if defined(SO_RCVTIMEO)
 267     bio_dgram_data *data = (bio_dgram_data *)b->ptr;
 268     union {
 269         size_t s;
 270         int i;
 271     } sz = {
 272         0
 273     };
 274
 275     /* Is a timer active? */
 276     if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) {
 277         struct timeval timenow, timeleft;
 278
 279         /* Read current socket timeout */
 280 #  ifdef OPENSSL_SYS_WINDOWS
 281         int timeout;
 282
 283         sz.i = sizeof(timeout);
 284         if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
 285                        (void *)&timeout, &sz.i) < 0) {
 286             perror("getsockopt");
 287         } else {
 288             data->socket_timeout.tv_sec = timeout / 1000;
 289             data->socket_timeout.tv_usec = (timeout % 1000) * 1000;
 290         }
 291 #  else
 292         sz.i = sizeof(data->socket_timeout);
 293         if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
 294                        &(data->socket_timeout), (void *)&sz) < 0) {
 295             perror("getsockopt");
 296         } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0)
 297             OPENSSL_assert(sz.s <= sizeof(data->socket_timeout));
 298 #  endif
 299
 300         /* Get current time */
 301         get_current_time(&timenow);
 302
 303         /* Calculate time left until timer expires */
 304         memcpy(&timeleft, &(data->next_timeout), sizeof(struct timeval));
 305         if (timeleft.tv_usec < timenow.tv_usec) {
 306             timeleft.tv_usec = 1000000 - timenow.tv_usec + timeleft.tv_usec;
 307             timeleft.tv_sec--;
 308         } else {
 309             timeleft.tv_usec -= timenow.tv_usec;
 310         }
 311         if (timeleft.tv_sec < timenow.tv_sec) {
 312             timeleft.tv_sec = 0;
 313             timeleft.tv_usec = 1;
 314         } else {
 315             timeleft.tv_sec -= timenow.tv_sec;
 316         }
 317
 318         /*
 319          * Adjust socket timeout if next handhake message timer will expire
 320          * earlier.
 321          */
 322         if ((data->socket_timeout.tv_sec == 0
 323              && data->socket_timeout.tv_usec == 0)
 324             || (data->socket_timeout.tv_sec > timeleft.tv_sec)
 325             || (data->socket_timeout.tv_sec == timeleft.tv_sec
 326                 && data->socket_timeout.tv_usec >= timeleft.tv_usec)) {
 327 #  ifdef OPENSSL_SYS_WINDOWS
 328             timeout = timeleft.tv_sec * 1000 + timeleft.tv_usec / 1000;
 329             if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
 330                            (void *)&timeout, sizeof(timeout)) < 0) {
 331                 perror("setsockopt");
 332             }
 333 #  else
 334             if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &timeleft,
 335                            sizeof(struct timeval)) < 0) {
 336                 perror("setsockopt");
 337             }
 338 #  endif
 339         }
 340     }
 341 # endif
 342 }
 343
 344 static void dgram_reset_rcv_timeout(BIO *b)
 345 {
 346 # if defined(SO_RCVTIMEO)
 347     bio_dgram_data *data = (bio_dgram_data *)b->ptr;
 348
 349     /* Is a timer active? */
 350     if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) {
 351 #  ifdef OPENSSL_SYS_WINDOWS
 352         int timeout = data->socket_timeout.tv_sec * 1000 +
 353             data->socket_timeout.tv_usec / 1000;
 354         if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
 355                        (void *)&timeout, sizeof(timeout)) < 0) {
 356             perror("setsockopt");
 357         }
 358 #  else
 359         if (setsockopt
 360             (b->num, SOL_SOCKET, SO_RCVTIMEO, &(data->socket_timeout),
 361              sizeof(struct timeval)) < 0) {
 362             perror("setsockopt");
 363         }
 364 #  endif
 365     }
 366 # endif
 367 }
 368
 369 static int dgram_read(BIO *b, char *out, int outl)
 370 {
 371     int ret = 0;
 372     bio_dgram_data *data = (bio_dgram_data *)b->ptr;
 373
 374     struct {
 375         /*
 376          * See commentary in b_sock.c. <appro>
 377          */
 378         union {
 379             size_t s;
 380             int i;
 381         } len;
 382         union {
 383             struct sockaddr sa;
 384             struct sockaddr_in sa_in;
 385 # if OPENSSL_USE_IPV6
 386             struct sockaddr_in6 sa_in6;
 387 # endif
 388         } peer;
 389     } sa;
 390
 391     sa.len.s = 0;
 392     sa.len.i = sizeof(sa.peer);
 393
 394     if (out != NULL) {
 395         clear_socket_error();
 396         memset(&sa.peer, 0, sizeof(sa.peer));
 397         dgram_adjust_rcv_timeout(b);
 398         ret = recvfrom(b->num, out, outl, 0, &sa.peer.sa, (void *)&sa.len);
 399         if (sizeof(sa.len.i) != sizeof(sa.len.s) && sa.len.i == 0) {
 400             OPENSSL_assert(sa.len.s <= sizeof(sa.peer));
 401             sa.len.i = (int)sa.len.s;
 402         }
 403
 404         if (!data->connected && ret >= 0)
 405             BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, &sa.peer);
 406
 407         BIO_clear_retry_flags(b);
 408         if (ret < 0) {
 409             if (BIO_dgram_should_retry(ret)) {
 410                 BIO_set_retry_read(b);
 411                 data->_errno = get_last_socket_error();
 412             }
 413         }
 414
 415         dgram_reset_rcv_timeout(b);
 416     }
 417     return (ret);
 418 }
 419
 420 static int dgram_write(BIO *b, const char *in, int inl)
 421 {
 422     int ret;
 423     bio_dgram_data *data = (bio_dgram_data *)b->ptr;
 424     clear_socket_error();
 425
 426     if (data->connected)
 427         ret = writesocket(b->num, in, inl);
 428     else {
 429         int peerlen = sizeof(data->peer);
 430
 431         if (data->peer.sa.sa_family == AF_INET)
 432             peerlen = sizeof(data->peer.sa_in);
 433 # if OPENSSL_USE_IPV6
 434         else if (data->peer.sa.sa_family == AF_INET6)
 435             peerlen = sizeof(data->peer.sa_in6);
 436 # endif
 437 # if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK)
 438         ret = sendto(b->num, (char *)in, inl, 0, &data->peer.sa, peerlen);
 439 # else
 440         ret = sendto(b->num, in, inl, 0, &data->peer.sa, peerlen);
 441 # endif
 442     }
 443
 444     BIO_clear_retry_flags(b);
 445     if (ret <= 0) {
 446         if (BIO_dgram_should_retry(ret)) {
 447             BIO_set_retry_write(b);
 448             data->_errno = get_last_socket_error();
 449         }
 450     }
 451     return (ret);
 452 }
 453
 454 static long dgram_get_mtu_overhead(bio_dgram_data *data)
 455 {
 456     long ret;
 457
 458     switch (data->peer.sa.sa_family) {
 459     case AF_INET:
 460         /*
 461          * Assume this is UDP - 20 bytes for IP, 8 bytes for UDP
 462          */
 463         ret = 28;
 464         break;
 465 # if OPENSSL_USE_IPV6
 466     case AF_INET6:
 467 #  ifdef IN6_IS_ADDR_V4MAPPED
 468         if (IN6_IS_ADDR_V4MAPPED(&data->peer.sa_in6.sin6_addr))
 469             /*
 470              * Assume this is UDP - 20 bytes for IP, 8 bytes for UDP
 471              */
 472             ret = 28;
 473         else
 474 #  endif
 475             /*
 476              * Assume this is UDP - 40 bytes for IP, 8 bytes for UDP
 477              */
 478             ret = 48;
 479         break;
 480 # endif
 481     default:
 482         /* We don't know. Go with the historical default */
 483         ret = 28;
 484         break;
 485     }
 486     return ret;
 487 }
 488
 489 static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr)
 490 {
 491     long ret = 1;
 492     int *ip;
 493     struct sockaddr *to = NULL;
 494     bio_dgram_data *data = NULL;
 495     int sockopt_val = 0;
 496 # if defined(OPENSSL_SYS_LINUX) && (defined(IP_MTU_DISCOVER) || defined(IP_MTU))
 497     socklen_t sockopt_len;      /* assume that system supporting IP_MTU is
 498                                  * modern enough to define socklen_t */
 499     socklen_t addr_len;
 500     union {
 501         struct sockaddr sa;
 502         struct sockaddr_in s4;
 503 #  if OPENSSL_USE_IPV6
 504         struct sockaddr_in6 s6;
 505 #  endif
 506     } addr;
 507 # endif
 508
 509     data = (bio_dgram_data *)b->ptr;
 510
 511     switch (cmd) {
 512     case BIO_CTRL_RESET:
 513         num = 0;
 514     case BIO_C_FILE_SEEK:
 515         ret = 0;
 516         break;
 517     case BIO_C_FILE_TELL:
 518     case BIO_CTRL_INFO:
 519         ret = 0;
 520         break;
 521     case BIO_C_SET_FD:
 522         dgram_clear(b);
 523         b->num = *((int *)ptr);
 524         b->shutdown = (int)num;
 525         b->init = 1;
 526         break;
 527     case BIO_C_GET_FD:
 528         if (b->init) {
 529             ip = (int *)ptr;
 530             if (ip != NULL)
 531                 *ip = b->num;
 532             ret = b->num;
 533         } else
 534             ret = -1;
 535         break;
 536     case BIO_CTRL_GET_CLOSE:
 537         ret = b->shutdown;
 538         break;
 539     case BIO_CTRL_SET_CLOSE:
 540         b->shutdown = (int)num;
 541         break;
 542     case BIO_CTRL_PENDING:
 543     case BIO_CTRL_WPENDING:
 544         ret = 0;
 545         break;
 546     case BIO_CTRL_DUP:
 547     case BIO_CTRL_FLUSH:
 548         ret = 1;
 549         break;
 550     case BIO_CTRL_DGRAM_CONNECT:
 551         to = (struct sockaddr *)ptr;
 552         switch (to->sa_family) {
 553         case AF_INET:
 554             memcpy(&data->peer, to, sizeof(data->peer.sa_in));
 555             break;
 556 # if OPENSSL_USE_IPV6
 557         case AF_INET6:
 558             memcpy(&data->peer, to, sizeof(data->peer.sa_in6));
 559             break;
 560 # endif
 561         default:
 562             memcpy(&data->peer, to, sizeof(data->peer.sa));
 563             break;
 564         }
 565         break;
 566         /* (Linux)kernel sets DF bit on outgoing IP packets */
 567     case BIO_CTRL_DGRAM_MTU_DISCOVER:
 568 # if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO)
 569         addr_len = (socklen_t) sizeof(addr);
 570         memset(&addr, 0, sizeof(addr));
 571         if (getsockname(b->num, &addr.sa, &addr_len) < 0) {
 572             ret = 0;
 573             break;
 574         }
 575         switch (addr.sa.sa_family) {
 576         case AF_INET:
 577             sockopt_val = IP_PMTUDISC_DO;
 578             if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
 579                                   &sockopt_val, sizeof(sockopt_val))) < 0)
 580                 perror("setsockopt");
 581             break;
 582 #  if OPENSSL_USE_IPV6 && defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO)
 583         case AF_INET6:
 584             sockopt_val = IPV6_PMTUDISC_DO;
 585             if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
 586                                   &sockopt_val, sizeof(sockopt_val))) < 0)
 587                 perror("setsockopt");
 588             break;
 589 #  endif
 590         default:
 591             ret = -1;
 592             break;
 593         }
 594 # else
 595         ret = -1;
 596 # endif
 597         break;
 598     case BIO_CTRL_DGRAM_QUERY_MTU:
 599 # if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU)
 600         addr_len = (socklen_t) sizeof(addr);
 601         memset(&addr, 0, sizeof(addr));
 602         if (getsockname(b->num, &addr.sa, &addr_len) < 0) {
 603             ret = 0;
 604             break;
 605         }
 606         sockopt_len = sizeof(sockopt_val);
 607         switch (addr.sa.sa_family) {
 608         case AF_INET:
 609             if ((ret =
 610                  getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val,
 611                             &sockopt_len)) < 0 || sockopt_val < 0) {
 612                 ret = 0;
 613             } else {
 614                 /*
 615                  * we assume that the transport protocol is UDP and no IP
 616                  * options are used.
 617                  */
 618                 data->mtu = sockopt_val - 8 - 20;
 619                 ret = data->mtu;
 620             }
 621             break;
 622 #  if OPENSSL_USE_IPV6 && defined(IPV6_MTU)
 623         case AF_INET6:
 624             if ((ret =
 625                  getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU,
 626                             (void *)&sockopt_val, &sockopt_len)) < 0
 627                 || sockopt_val < 0) {
 628                 ret = 0;
 629             } else {
 630                 /*
 631                  * we assume that the transport protocol is UDP and no IPV6
 632                  * options are used.
 633                  */
 634                 data->mtu = sockopt_val - 8 - 40;
 635                 ret = data->mtu;
 636             }
 637             break;
 638 #  endif
 639         default:
 640             ret = 0;
 641             break;
 642         }
 643 # else
 644         ret = 0;
 645 # endif
 646         break;
 647     case BIO_CTRL_DGRAM_GET_FALLBACK_MTU:
 648         ret = -dgram_get_mtu_overhead(data);
 649         switch (data->peer.sa.sa_family) {
 650         case AF_INET:
 651             ret += 576;
 652             break;
 653 # if OPENSSL_USE_IPV6
 654         case AF_INET6:
 655 #  ifdef IN6_IS_ADDR_V4MAPPED
 656             if (IN6_IS_ADDR_V4MAPPED(&data->peer.sa_in6.sin6_addr))
 657                 ret += 576;
 658             else
 659 #  endif
 660                 ret += 1280;
 661             break;
 662 # endif
 663         default:
 664             ret += 576;
 665             break;
 666         }
 667         break;
 668     case BIO_CTRL_DGRAM_GET_MTU:
 669         return data->mtu;
 670     case BIO_CTRL_DGRAM_SET_MTU:
 671         data->mtu = num;
 672         ret = num;
 673         break;
 674     case BIO_CTRL_DGRAM_SET_CONNECTED:
 675         to = (struct sockaddr *)ptr;
 676
 677         if (to != NULL) {
 678             data->connected = 1;
 679             switch (to->sa_family) {
 680             case AF_INET:
 681                 memcpy(&data->peer, to, sizeof(data->peer.sa_in));
 682                 break;
 683 # if OPENSSL_USE_IPV6
 684             case AF_INET6:
 685                 memcpy(&data->peer, to, sizeof(data->peer.sa_in6));
 686                 break;
 687 # endif
 688             default:
 689                 memcpy(&data->peer, to, sizeof(data->peer.sa));
 690                 break;
 691             }
 692         } else {
 693             data->connected = 0;
 694             memset(&data->peer, 0, sizeof(data->peer));
 695         }
 696         break;
 697     case BIO_CTRL_DGRAM_GET_PEER:
 698         switch (data->peer.sa.sa_family) {
 699         case AF_INET:
 700             ret = sizeof(data->peer.sa_in);
 701             break;
 702 # if OPENSSL_USE_IPV6
 703         case AF_INET6:
 704             ret = sizeof(data->peer.sa_in6);
 705             break;
 706 # endif
 707         default:
 708             ret = sizeof(data->peer.sa);
 709             break;
 710         }
 711         if (num == 0 || num > ret)
 712             num = ret;
 713         memcpy(ptr, &data->peer, (ret = num));
 714         break;
 715     case BIO_CTRL_DGRAM_SET_PEER:
 716         to = (struct sockaddr *)ptr;
 717         switch (to->sa_family) {
 718         case AF_INET:
 719             memcpy(&data->peer, to, sizeof(data->peer.sa_in));
 720             break;
 721 # if OPENSSL_USE_IPV6
 722         case AF_INET6:
 723             memcpy(&data->peer, to, sizeof(data->peer.sa_in6));
 724             break;
 725 # endif
 726         default:
 727             memcpy(&data->peer, to, sizeof(data->peer.sa));
 728             break;
 729         }
 730         break;
 731     case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
 732         memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));
 733         break;
 734 # if defined(SO_RCVTIMEO)
 735     case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
 736 #  ifdef OPENSSL_SYS_WINDOWS
 737         {
 738             struct timeval *tv = (struct timeval *)ptr;
 739             int timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;
 740             if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
 741                            (void *)&timeout, sizeof(timeout)) < 0) {
 742                 perror("setsockopt");
 743                 ret = -1;
 744             }
 745         }
 746 #  else
 747         if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr,
 748                        sizeof(struct timeval)) < 0) {
 749             perror("setsockopt");
 750             ret = -1;
 751         }
 752 #  endif
 753         break;
 754     case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT:
 755         {
 756             union {
 757                 size_t s;
 758                 int i;
 759             } sz = {
 760                 0
 761             };
 762 #  ifdef OPENSSL_SYS_WINDOWS
 763             int timeout;
 764             struct timeval *tv = (struct timeval *)ptr;
 765
 766             sz.i = sizeof(timeout);
 767             if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
 768                            (void *)&timeout, &sz.i) < 0) {
 769                 perror("getsockopt");
 770                 ret = -1;
 771             } else {
 772                 tv->tv_sec = timeout / 1000;
 773                 tv->tv_usec = (timeout % 1000) * 1000;
 774                 ret = sizeof(*tv);
 775             }
 776 #  else
 777             sz.i = sizeof(struct timeval);
 778             if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
 779                            ptr, (void *)&sz) < 0) {
 780                 perror("getsockopt");
 781                 ret = -1;
 782             } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) {
 783                 OPENSSL_assert(sz.s <= sizeof(struct timeval));
 784                 ret = (int)sz.s;
 785             } else
 786                 ret = sz.i;
 787 #  endif
 788         }
 789         break;
 790 # endif
 791 # if defined(SO_SNDTIMEO)
 792     case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT:
 793 #  ifdef OPENSSL_SYS_WINDOWS
 794         {
 795             struct timeval *tv = (struct timeval *)ptr;
 796             int timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;
 797             if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
 798                            (void *)&timeout, sizeof(timeout)) < 0) {
 799                 perror("setsockopt");
 800                 ret = -1;
 801             }
 802         }
 803 #  else
 804         if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr,
 805                        sizeof(struct timeval)) < 0) {
 806             perror("setsockopt");
 807             ret = -1;
 808         }
 809 #  endif
 810         break;
 811     case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT:
 812         {
 813             union {
 814                 size_t s;
 815                 int i;
 816             } sz = {
 817                 0
 818             };
 819 #  ifdef OPENSSL_SYS_WINDOWS
 820             int timeout;
 821             struct timeval *tv = (struct timeval *)ptr;
 822
 823             sz.i = sizeof(timeout);
 824             if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
 825                            (void *)&timeout, &sz.i) < 0) {
 826                 perror("getsockopt");
 827                 ret = -1;
 828             } else {
 829                 tv->tv_sec = timeout / 1000;
 830                 tv->tv_usec = (timeout % 1000) * 1000;
 831                 ret = sizeof(*tv);
 832             }
 833 #  else
 834             sz.i = sizeof(struct timeval);
 835             if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
 836                            ptr, (void *)&sz) < 0) {
 837                 perror("getsockopt");
 838                 ret = -1;
 839             } else if (sizeof(sz.s) != sizeof(sz.i) && sz.i == 0) {
 840                 OPENSSL_assert(sz.s <= sizeof(struct timeval));
 841                 ret = (int)sz.s;
 842             } else
 843                 ret = sz.i;
 844 #  endif
 845         }
 846         break;
 847 # endif
 848     case BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP:
 849         /* fall-through */
 850     case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP:
 851 # ifdef OPENSSL_SYS_WINDOWS
 852         if (data->_errno == WSAETIMEDOUT)
 853 # else
 854         if (data->_errno == EAGAIN)
 855 # endif
 856         {
 857             ret = 1;
 858             data->_errno = 0;
 859         } else
 860             ret = 0;
 861         break;
 862 # ifdef EMSGSIZE
 863     case BIO_CTRL_DGRAM_MTU_EXCEEDED:
 864         if (data->_errno == EMSGSIZE) {
 865             ret = 1;
 866             data->_errno = 0;
 867         } else
 868             ret = 0;
 869         break;
 870 # endif
 871     case BIO_CTRL_DGRAM_SET_DONT_FRAG:
 872         sockopt_val = num ? 1 : 0;
 873
 874         switch (data->peer.sa.sa_family) {
 875         case AF_INET:
 876 # if defined(IP_DONTFRAG)
 877             if ((ret = setsockopt(b->num, IPPROTO_IP, IP_DONTFRAG,
 878                                   &sockopt_val, sizeof(sockopt_val))) < 0) {
 879                 perror("setsockopt");
 880                 ret = -1;
 881             }
 882 # elif defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined (IP_PMTUDISC_PROBE)
 883             if ((sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT),
 884                 (ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
 885                                   &sockopt_val, sizeof(sockopt_val))) < 0) {
 886                 perror("setsockopt");
 887                 ret = -1;
 888             }
 889 # elif defined(OPENSSL_SYS_WINDOWS) && defined(IP_DONTFRAGMENT)
 890             if ((ret = setsockopt(b->num, IPPROTO_IP, IP_DONTFRAGMENT,
 891                                   (const char *)&sockopt_val,
 892                                   sizeof(sockopt_val))) < 0) {
 893                 perror("setsockopt");
 894                 ret = -1;
 895             }
 896 # else
 897             ret = -1;
 898 # endif
 899             break;
 900 # if OPENSSL_USE_IPV6
 901         case AF_INET6:
 902 #  if defined(IPV6_DONTFRAG)
 903             if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_DONTFRAG,
 904                                   (const void *)&sockopt_val,
 905                                   sizeof(sockopt_val))) < 0) {
 906                 perror("setsockopt");
 907                 ret = -1;
 908             }
 909 #  elif defined(OPENSSL_SYS_LINUX) && defined(IPV6_MTUDISCOVER)
 910             if ((sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT),
 911                 (ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
 912                                   &sockopt_val, sizeof(sockopt_val))) < 0) {
 913                 perror("setsockopt");
 914                 ret = -1;
 915             }
 916 #  else
 917             ret = -1;
 918 #  endif
 919             break;
 920 # endif
 921         default:
 922             ret = -1;
 923             break;
 924         }
 925         break;
 926     case BIO_CTRL_DGRAM_GET_MTU_OVERHEAD:
 927         ret = dgram_get_mtu_overhead(data);
 928         break;
 929     default:
 930         ret = 0;
 931         break;
 932     }
 933     return (ret);
 934 }
 935
 936 static int dgram_puts(BIO *bp, const char *str)
 937 {
 938     int n, ret;
 939
 940     n = strlen(str);
 941     ret = dgram_write(bp, str, n);
 942     return (ret);
 943 }
 944
 945 # ifndef OPENSSL_NO_SCTP
 946 BIO_METHOD *BIO_s_datagram_sctp(void)
 947 {
 948     return (&methods_dgramp_sctp);
 949 }
 950
 951 BIO *BIO_new_dgram_sctp(int fd, int close_flag)
 952 {
 953     BIO *bio;
 954     int ret, optval = 20000;
 955     int auth_data = 0, auth_forward = 0;
 956     unsigned char *p;
 957     struct sctp_authchunk auth;
 958     struct sctp_authchunks *authchunks;
 959     socklen_t sockopt_len;
 960 #  ifdef SCTP_AUTHENTICATION_EVENT
 961 #   ifdef SCTP_EVENT
 962     struct sctp_event event;
 963 #   else
 964     struct sctp_event_subscribe event;
 965 #   endif
 966 #  endif
 967
 968     bio = BIO_new(BIO_s_datagram_sctp());
 969     if (bio == NULL)
 970         return (NULL);
 971     BIO_set_fd(bio, fd, close_flag);
 972
 973     /* Activate SCTP-AUTH for DATA and FORWARD-TSN chunks */
 974     auth.sauth_chunk = OPENSSL_SCTP_DATA_CHUNK_TYPE;
 975     ret =
 976         setsockopt(fd, IPPROTO_SCTP, SCTP_AUTH_CHUNK, &auth,
 977                    sizeof(struct sctp_authchunk));
 978     if (ret < 0) {
 979         BIO_vfree(bio);
 980         return (NULL);
 981     }
 982     auth.sauth_chunk = OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE;
 983     ret =
 984         setsockopt(fd, IPPROTO_SCTP, SCTP_AUTH_CHUNK, &auth,
 985                    sizeof(struct sctp_authchunk));
 986     if (ret < 0) {
 987         BIO_vfree(bio);
 988         return (NULL);
 989     }
 990
 991     /*
 992      * Test if activation was successful. When using accept(), SCTP-AUTH has
 993      * to be activated for the listening socket already, otherwise the
 994      * connected socket won't use it.
 995      */
 996     sockopt_len = (socklen_t) (sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
 997     authchunks = OPENSSL_zalloc(sockopt_len);
 998     if (!authchunks) {
 999         BIO_vfree(bio);
1000         return (NULL);
1001     }
1002     ret = getsockopt(fd, IPPROTO_SCTP, SCTP_LOCAL_AUTH_CHUNKS, authchunks,
1003                    &sockopt_len);
1004     if (ret < 0) {
1005         OPENSSL_free(authchunks);
1006         BIO_vfree(bio);
1007         return (NULL);
1008     }
1009
1010     for (p = (unsigned char *)authchunks->gauth_chunks;
1011          p < (unsigned char *)authchunks + sockopt_len;
1012          p += sizeof(uint8_t)) {
1013         if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE)
1014             auth_data = 1;
1015         if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE)
1016             auth_forward = 1;
1017     }
1018
1019     OPENSSL_free(authchunks);
1020
1021     OPENSSL_assert(auth_data);
1022     OPENSSL_assert(auth_forward);
1023
1024 #  ifdef SCTP_AUTHENTICATION_EVENT
1025 #   ifdef SCTP_EVENT
1026     memset(&event, 0, sizeof(event));
1027     event.se_assoc_id = 0;
1028     event.se_type = SCTP_AUTHENTICATION_EVENT;
1029     event.se_on = 1;
1030     ret =
1031         setsockopt(fd, IPPROTO_SCTP, SCTP_EVENT, &event,
1032                    sizeof(struct sctp_event));
1033     if (ret < 0) {
1034         BIO_vfree(bio);
1035         return (NULL);
1036     }
1037 #   else
1038     sockopt_len = (socklen_t) sizeof(struct sctp_event_subscribe);
1039     ret = getsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, &event, &sockopt_len);
1040     if (ret < 0) {
1041         BIO_vfree(bio);
1042         return (NULL);
1043     }
1044
1045     event.sctp_authentication_event = 1;
1046
1047     ret =
1048         setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, &event,
1049                    sizeof(struct sctp_event_subscribe));
1050     if (ret < 0) {
1051         BIO_vfree(bio);
1052         return (NULL);
1053     }
1054 #   endif
1055 #  endif
1056
1057     /*
1058      * Disable partial delivery by setting the min size larger than the max
1059      * record size of 2^14 + 2048 + 13
1060      */
1061     ret =
1062         setsockopt(fd, IPPROTO_SCTP, SCTP_PARTIAL_DELIVERY_POINT, &optval,
1063                    sizeof(optval));
1064     if (ret < 0) {
1065         BIO_vfree(bio);
1066         return (NULL);
1067     }
1068
1069     return (bio);
1070 }
1071
1072 int BIO_dgram_is_sctp(BIO *bio)
1073 {
1074     return (BIO_method_type(bio) == BIO_TYPE_DGRAM_SCTP);
1075 }
1076
1077 static int dgram_sctp_new(BIO *bi)
1078 {
1079     bio_dgram_sctp_data *data = NULL;
1080
1081     bi->init = 0;
1082     bi->num = 0;
1083     data = OPENSSL_zalloc(sizeof(*data));
1084     if (data == NULL)
1085         return 0;
1086 #  ifdef SCTP_PR_SCTP_NONE
1087     data->prinfo.pr_policy = SCTP_PR_SCTP_NONE;
1088 #  endif
1089     bi->ptr = data;
1090
1091     bi->flags = 0;
1092     return (1);
1093 }
1094
1095 static int dgram_sctp_free(BIO *a)
1096 {
1097     bio_dgram_sctp_data *data;
1098
1099     if (a == NULL)
1100         return (0);
1101     if (!dgram_clear(a))
1102         return 0;
1103
1104     data = (bio_dgram_sctp_data *) a->ptr;
1105     if (data != NULL) {
1106         OPENSSL_free(data->saved_message.data);
1107         OPENSSL_free(data);
1108     }
1109
1110     return (1);
1111 }
1112
1113 #  ifdef SCTP_AUTHENTICATION_EVENT
1114 void dgram_sctp_handle_auth_free_key_event(BIO *b,
1115                                            union sctp_notification *snp)
1116 {
1117     int ret;
1118     struct sctp_authkey_event *authkeyevent = &snp->sn_auth_event;
1119
1120     if (authkeyevent->auth_indication == SCTP_AUTH_FREE_KEY) {
1121         struct sctp_authkeyid authkeyid;
1122
1123         /* delete key */
1124         authkeyid.scact_keynumber = authkeyevent->auth_keynumber;
1125         ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY,
1126                          &authkeyid, sizeof(struct sctp_authkeyid));
1127     }
1128 }
1129 #  endif
1130
1131 static int dgram_sctp_read(BIO *b, char *out, int outl)
1132 {
1133     int ret = 0, n = 0, i, optval;
1134     socklen_t optlen;
1135     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1136     union sctp_notification *snp;
1137     struct msghdr msg;
1138     struct iovec iov;
1139     struct cmsghdr *cmsg;
1140     char cmsgbuf[512];
1141
1142     if (out != NULL) {
1143         clear_socket_error();
1144
1145         do {
1146             memset(&data->rcvinfo, 0, sizeof(data->rcvinfo));
1147             iov.iov_base = out;
1148             iov.iov_len = outl;
1149             msg.msg_name = NULL;
1150             msg.msg_namelen = 0;
1151             msg.msg_iov = &iov;
1152             msg.msg_iovlen = 1;
1153             msg.msg_control = cmsgbuf;
1154             msg.msg_controllen = 512;
1155             msg.msg_flags = 0;
1156             n = recvmsg(b->num, &msg, 0);
1157
1158             if (n <= 0) {
1159                 if (n < 0)
1160                     ret = n;
1161                 break;
1162             }
1163
1164             if (msg.msg_controllen > 0) {
1165                 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
1166                      cmsg = CMSG_NXTHDR(&msg, cmsg)) {
1167                     if (cmsg->cmsg_level != IPPROTO_SCTP)
1168                         continue;
1169 #  ifdef SCTP_RCVINFO
1170                     if (cmsg->cmsg_type == SCTP_RCVINFO) {
1171                         struct sctp_rcvinfo *rcvinfo;
1172
1173                         rcvinfo = (struct sctp_rcvinfo *)CMSG_DATA(cmsg);
1174                         data->rcvinfo.rcv_sid = rcvinfo->rcv_sid;
1175                         data->rcvinfo.rcv_ssn = rcvinfo->rcv_ssn;
1176                         data->rcvinfo.rcv_flags = rcvinfo->rcv_flags;
1177                         data->rcvinfo.rcv_ppid = rcvinfo->rcv_ppid;
1178                         data->rcvinfo.rcv_tsn = rcvinfo->rcv_tsn;
1179                         data->rcvinfo.rcv_cumtsn = rcvinfo->rcv_cumtsn;
1180                         data->rcvinfo.rcv_context = rcvinfo->rcv_context;
1181                     }
1182 #  endif
1183 #  ifdef SCTP_SNDRCV
1184                     if (cmsg->cmsg_type == SCTP_SNDRCV) {
1185                         struct sctp_sndrcvinfo *sndrcvinfo;
1186
1187                         sndrcvinfo =
1188                             (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
1189                         data->rcvinfo.rcv_sid = sndrcvinfo->sinfo_stream;
1190                         data->rcvinfo.rcv_ssn = sndrcvinfo->sinfo_ssn;
1191                         data->rcvinfo.rcv_flags = sndrcvinfo->sinfo_flags;
1192                         data->rcvinfo.rcv_ppid = sndrcvinfo->sinfo_ppid;
1193                         data->rcvinfo.rcv_tsn = sndrcvinfo->sinfo_tsn;
1194                         data->rcvinfo.rcv_cumtsn = sndrcvinfo->sinfo_cumtsn;
1195                         data->rcvinfo.rcv_context = sndrcvinfo->sinfo_context;
1196                     }
1197 #  endif
1198                 }
1199             }
1200
1201             if (msg.msg_flags & MSG_NOTIFICATION) {
1202                 snp = (union sctp_notification *)out;
1203                 if (snp->sn_header.sn_type == SCTP_SENDER_DRY_EVENT) {
1204 #  ifdef SCTP_EVENT
1205                     struct sctp_event event;
1206 #  else
1207                     struct sctp_event_subscribe event;
1208                     socklen_t eventsize;
1209 #  endif
1210                     /*
1211                      * If a message has been delayed until the socket is dry,
1212                      * it can be sent now.
1213                      */
1214                     if (data->saved_message.length > 0) {
1215                         i = dgram_sctp_write(data->saved_message.bio,
1216                                          data->saved_message.data,
1217                                          data->saved_message.length);
1218                         if (i < 0) {
1219                             ret = i;
1220                             break;
1221                         }
1222                         OPENSSL_free(data->saved_message.data);
1223                         data->saved_message.data = NULL;
1224                         data->saved_message.length = 0;
1225                     }
1226
1227                     /* disable sender dry event */
1228 #  ifdef SCTP_EVENT
1229                     memset(&event, 0, sizeof(event));
1230                     event.se_assoc_id = 0;
1231                     event.se_type = SCTP_SENDER_DRY_EVENT;
1232                     event.se_on = 0;
1233                     i = setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENT, &event,
1234                                    sizeof(struct sctp_event));
1235                     if (i < 0) {
1236                         ret = i;
1237                         break;
1238                     }
1239 #  else
1240                     eventsize = sizeof(struct sctp_event_subscribe);
1241                     i = getsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1242                                    &eventsize);
1243                     if (i < 0) {
1244                         ret = i;
1245                         break;
1246                     }
1247
1248                     event.sctp_sender_dry_event = 0;
1249
1250                     i = setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1251                                    sizeof(struct sctp_event_subscribe));
1252                     if (i < 0) {
1253                         ret = i;
1254                         break;
1255                     }
1256 #  endif
1257                 }
1258 #  ifdef SCTP_AUTHENTICATION_EVENT
1259                 if (snp->sn_header.sn_type == SCTP_AUTHENTICATION_EVENT)
1260                     dgram_sctp_handle_auth_free_key_event(b, snp);
1261 #  endif
1262
1263                 if (data->handle_notifications != NULL)
1264                     data->handle_notifications(b, data->notification_context,
1265                                                (void *)out);
1266
1267                 memset(out, 0, outl);
1268             } else
1269                 ret += n;
1270         }
1271         while ((msg.msg_flags & MSG_NOTIFICATION) && (msg.msg_flags & MSG_EOR)
1272                && (ret < outl));
1273
1274         if (ret > 0 && !(msg.msg_flags & MSG_EOR)) {
1275             /* Partial message read, this should never happen! */
1276
1277             /*
1278              * The buffer was too small, this means the peer sent a message
1279              * that was larger than allowed.
1280              */
1281             if (ret == outl)
1282                 return -1;
1283
1284             /*
1285              * Test if socket buffer can handle max record size (2^14 + 2048
1286              * + 13)
1287              */
1288             optlen = (socklen_t) sizeof(int);
1289             ret = getsockopt(b->num, SOL_SOCKET, SO_RCVBUF, &optval, &optlen);
1290             if (ret >= 0)
1291                 OPENSSL_assert(optval >= 18445);
1292
1293             /*
1294              * Test if SCTP doesn't partially deliver below max record size
1295              * (2^14 + 2048 + 13)
1296              */
1297             optlen = (socklen_t) sizeof(int);
1298             ret =
1299                 getsockopt(b->num, IPPROTO_SCTP, SCTP_PARTIAL_DELIVERY_POINT,
1300                            &optval, &optlen);
1301             if (ret >= 0)
1302                 OPENSSL_assert(optval >= 18445);
1303
1304             /*
1305              * Partially delivered notification??? Probably a bug....
1306              */
1307             OPENSSL_assert(!(msg.msg_flags & MSG_NOTIFICATION));
1308
1309             /*
1310              * Everything seems ok till now, so it's most likely a message
1311              * dropped by PR-SCTP.
1312              */
1313             memset(out, 0, outl);
1314             BIO_set_retry_read(b);
1315             return -1;
1316         }
1317
1318         BIO_clear_retry_flags(b);
1319         if (ret < 0) {
1320             if (BIO_dgram_should_retry(ret)) {
1321                 BIO_set_retry_read(b);
1322                 data->_errno = get_last_socket_error();
1323             }
1324         }
1325
1326         /* Test if peer uses SCTP-AUTH before continuing */
1327         if (!data->peer_auth_tested) {
1328             int ii, auth_data = 0, auth_forward = 0;
1329             unsigned char *p;
1330             struct sctp_authchunks *authchunks;
1331
1332             optlen =
1333                 (socklen_t) (sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
1334             authchunks = OPENSSL_malloc(optlen);
1335             if (!authchunks) {
1336                 BIOerr(BIO_F_DGRAM_SCTP_READ, ERR_R_MALLOC_FAILURE);
1337                 return -1;
1338             }
1339             memset(authchunks, 0, optlen);
1340             ii = getsockopt(b->num, IPPROTO_SCTP, SCTP_PEER_AUTH_CHUNKS,
1341                             authchunks, &optlen);
1342
1343             if (ii >= 0)
1344                 for (p = (unsigned char *)authchunks->gauth_chunks;
1345                      p < (unsigned char *)authchunks + optlen;
1346                      p += sizeof(uint8_t)) {
1347                     if (*p == OPENSSL_SCTP_DATA_CHUNK_TYPE)
1348                         auth_data = 1;
1349                     if (*p == OPENSSL_SCTP_FORWARD_CUM_TSN_CHUNK_TYPE)
1350                         auth_forward = 1;
1351                 }
1352
1353             OPENSSL_free(authchunks);
1354
1355             if (!auth_data || !auth_forward) {
1356                 BIOerr(BIO_F_DGRAM_SCTP_READ, BIO_R_CONNECT_ERROR);
1357                 return -1;
1358             }
1359
1360             data->peer_auth_tested = 1;
1361         }
1362     }
1363     return (ret);
1364 }
1365
1366 /*
1367  * dgram_sctp_write - send message on SCTP socket
1368  * @b: BIO to write to
1369  * @in: data to send
1370  * @inl: amount of bytes in @in to send
1371  *
1372  * Returns -1 on error or the sent amount of bytes on success
1373  */
1374 static int dgram_sctp_write(BIO *b, const char *in, int inl)
1375 {
1376     int ret;
1377     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1378     struct bio_dgram_sctp_sndinfo *sinfo = &(data->sndinfo);
1379     struct bio_dgram_sctp_prinfo *pinfo = &(data->prinfo);
1380     struct bio_dgram_sctp_sndinfo handshake_sinfo;
1381     struct iovec iov[1];
1382     struct msghdr msg;
1383     struct cmsghdr *cmsg;
1384 #  if defined(SCTP_SNDINFO) && defined(SCTP_PRINFO)
1385     char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndinfo)) +
1386                  CMSG_SPACE(sizeof(struct sctp_prinfo))];
1387     struct sctp_sndinfo *sndinfo;
1388     struct sctp_prinfo *prinfo;
1389 #  else
1390     char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
1391     struct sctp_sndrcvinfo *sndrcvinfo;
1392 #  endif
1393
1394     clear_socket_error();
1395
1396     /*
1397      * If we're send anything else than application data, disable all user
1398      * parameters and flags.
1399      */
1400     if (in[0] != 23) {
1401         memset(&handshake_sinfo, 0, sizeof(handshake_sinfo));
1402 #  ifdef SCTP_SACK_IMMEDIATELY
1403         handshake_sinfo.snd_flags = SCTP_SACK_IMMEDIATELY;
1404 #  endif
1405         sinfo = &handshake_sinfo;
1406     }
1407
1408     /*
1409      * If we have to send a shutdown alert message and the socket is not dry
1410      * yet, we have to save it and send it as soon as the socket gets dry.
1411      */
1412     if (data->save_shutdown) {
1413         ret = BIO_dgram_sctp_wait_for_dry(b);
1414         if (ret < 0) {
1415             return -1;
1416         }
1417         if (ret == 0) {
1418             char *tmp;
1419             data->saved_message.bio = b;
1420             if ((tmp = OPENSSL_malloc(inl)) == NULL) {
1421                 BIOerr(BIO_F_DGRAM_SCTP_WRITE, ERR_R_MALLOC_FAILURE);
1422                 return -1;
1423             }
1424             OPENSSL_free(data->saved_message.data);
1425             data->saved_message.data = tmp;
1426             memcpy(data->saved_message.data, in, inl);
1427             data->saved_message.length = inl;
1428             return inl;
1429         }
1430     }
1431
1432     iov[0].iov_base = (char *)in;
1433     iov[0].iov_len = inl;
1434     msg.msg_name = NULL;
1435     msg.msg_namelen = 0;
1436     msg.msg_iov = iov;
1437     msg.msg_iovlen = 1;
1438     msg.msg_control = (caddr_t) cmsgbuf;
1439     msg.msg_controllen = 0;
1440     msg.msg_flags = 0;
1441 #  if defined(SCTP_SNDINFO) && defined(SCTP_PRINFO)
1442     cmsg = (struct cmsghdr *)cmsgbuf;
1443     cmsg->cmsg_level = IPPROTO_SCTP;
1444     cmsg->cmsg_type = SCTP_SNDINFO;
1445     cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
1446     sndinfo = (struct sctp_sndinfo *)CMSG_DATA(cmsg);
1447     memset(sndinfo, 0, sizeof(*sndinfo));
1448     sndinfo->snd_sid = sinfo->snd_sid;
1449     sndinfo->snd_flags = sinfo->snd_flags;
1450     sndinfo->snd_ppid = sinfo->snd_ppid;
1451     sndinfo->snd_context = sinfo->snd_context;
1452     msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
1453
1454     cmsg =
1455         (struct cmsghdr *)&cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndinfo))];
1456     cmsg->cmsg_level = IPPROTO_SCTP;
1457     cmsg->cmsg_type = SCTP_PRINFO;
1458     cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
1459     prinfo = (struct sctp_prinfo *)CMSG_DATA(cmsg);
1460     memset(prinfo, 0, sizeof(*prinfo));
1461     prinfo->pr_policy = pinfo->pr_policy;
1462     prinfo->pr_value = pinfo->pr_value;
1463     msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
1464 #  else
1465     cmsg = (struct cmsghdr *)cmsgbuf;
1466     cmsg->cmsg_level = IPPROTO_SCTP;
1467     cmsg->cmsg_type = SCTP_SNDRCV;
1468     cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
1469     sndrcvinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
1470     memset(sndrcvinfo, 0, sizeof(*sndrcvinfo));
1471     sndrcvinfo->sinfo_stream = sinfo->snd_sid;
1472     sndrcvinfo->sinfo_flags = sinfo->snd_flags;
1473 #   ifdef __FreeBSD__
1474     sndrcvinfo->sinfo_flags |= pinfo->pr_policy;
1475 #   endif
1476     sndrcvinfo->sinfo_ppid = sinfo->snd_ppid;
1477     sndrcvinfo->sinfo_context = sinfo->snd_context;
1478     sndrcvinfo->sinfo_timetolive = pinfo->pr_value;
1479     msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndrcvinfo));
1480 #  endif
1481
1482     ret = sendmsg(b->num, &msg, 0);
1483
1484     BIO_clear_retry_flags(b);
1485     if (ret <= 0) {
1486         if (BIO_dgram_should_retry(ret)) {
1487             BIO_set_retry_write(b);
1488             data->_errno = get_last_socket_error();
1489         }
1490     }
1491     return (ret);
1492 }
1493
1494 static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr)
1495 {
1496     long ret = 1;
1497     bio_dgram_sctp_data *data = NULL;
1498     socklen_t sockopt_len = 0;
1499     struct sctp_authkeyid authkeyid;
1500     struct sctp_authkey *authkey = NULL;
1501
1502     data = (bio_dgram_sctp_data *) b->ptr;
1503
1504     switch (cmd) {
1505     case BIO_CTRL_DGRAM_QUERY_MTU:
1506         /*
1507          * Set to maximum (2^14) and ignore user input to enable transport
1508          * protocol fragmentation. Returns always 2^14.
1509          */
1510         data->mtu = 16384;
1511         ret = data->mtu;
1512         break;
1513     case BIO_CTRL_DGRAM_SET_MTU:
1514         /*
1515          * Set to maximum (2^14) and ignore input to enable transport
1516          * protocol fragmentation. Returns always 2^14.
1517          */
1518         data->mtu = 16384;
1519         ret = data->mtu;
1520         break;
1521     case BIO_CTRL_DGRAM_SET_CONNECTED:
1522     case BIO_CTRL_DGRAM_CONNECT:
1523         /* Returns always -1. */
1524         ret = -1;
1525         break;
1526     case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
1527         /*
1528          * SCTP doesn't need the DTLS timer Returns always 1.
1529          */
1530         break;
1531     case BIO_CTRL_DGRAM_GET_MTU_OVERHEAD:
1532         /*
1533          * We allow transport protocol fragmentation so this is irrelevant
1534          */
1535         ret = 0;
1536         break;
1537     case BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE:
1538         if (num > 0)
1539             data->in_handshake = 1;
1540         else
1541             data->in_handshake = 0;
1542
1543         ret =
1544             setsockopt(b->num, IPPROTO_SCTP, SCTP_NODELAY,
1545                        &data->in_handshake, sizeof(int));
1546         break;
1547     case BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY:
1548         /*
1549          * New shared key for SCTP AUTH. Returns 0 on success, -1 otherwise.
1550          */
1551
1552         /* Get active key */
1553         sockopt_len = sizeof(struct sctp_authkeyid);
1554         ret =
1555             getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid,
1556                        &sockopt_len);
1557         if (ret < 0)
1558             break;
1559
1560         /* Add new key */
1561         sockopt_len = sizeof(struct sctp_authkey) + 64 * sizeof(uint8_t);
1562         authkey = OPENSSL_malloc(sockopt_len);
1563         if (authkey == NULL) {
1564             ret = -1;
1565             break;
1566         }
1567         memset(authkey, 0, sockopt_len);
1568         authkey->sca_keynumber = authkeyid.scact_keynumber + 1;
1569 #  ifndef __FreeBSD__
1570         /*
1571          * This field is missing in FreeBSD 8.2 and earlier, and FreeBSD 8.3
1572          * and higher work without it.
1573          */
1574         authkey->sca_keylength = 64;
1575 #  endif
1576         memcpy(&authkey->sca_key[0], ptr, 64 * sizeof(uint8_t));
1577
1578         ret =
1579             setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_KEY, authkey,
1580                        sockopt_len);
1581         OPENSSL_free(authkey);
1582         authkey = NULL;
1583         if (ret < 0)
1584             break;
1585
1586         /* Reset active key */
1587         ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY,
1588                          &authkeyid, sizeof(struct sctp_authkeyid));
1589         if (ret < 0)
1590             break;
1591
1592         break;
1593     case BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY:
1594         /* Returns 0 on success, -1 otherwise. */
1595
1596         /* Get active key */
1597         sockopt_len = sizeof(struct sctp_authkeyid);
1598         ret =
1599             getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid,
1600                        &sockopt_len);
1601         if (ret < 0)
1602             break;
1603
1604         /* Set active key */
1605         authkeyid.scact_keynumber = authkeyid.scact_keynumber + 1;
1606         ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY,
1607                          &authkeyid, sizeof(struct sctp_authkeyid));
1608         if (ret < 0)
1609             break;
1610
1611         /*
1612          * CCS has been sent, so remember that and fall through to check if
1613          * we need to deactivate an old key
1614          */
1615         data->ccs_sent = 1;
1616
1617     case BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD:
1618         /* Returns 0 on success, -1 otherwise. */
1619
1620         /*
1621          * Has this command really been called or is this just a
1622          * fall-through?
1623          */
1624         if (cmd == BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD)
1625             data->ccs_rcvd = 1;
1626
1627         /*
1628          * CSS has been both, received and sent, so deactivate an old key
1629          */
1630         if (data->ccs_rcvd == 1 && data->ccs_sent == 1) {
1631             /* Get active key */
1632             sockopt_len = sizeof(struct sctp_authkeyid);
1633             ret =
1634                 getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY,
1635                            &authkeyid, &sockopt_len);
1636             if (ret < 0)
1637                 break;
1638
1639             /*
1640              * Deactivate key or delete second last key if
1641              * SCTP_AUTHENTICATION_EVENT is not available.
1642              */
1643             authkeyid.scact_keynumber = authkeyid.scact_keynumber - 1;
1644 #  ifdef SCTP_AUTH_DEACTIVATE_KEY
1645             sockopt_len = sizeof(struct sctp_authkeyid);
1646             ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DEACTIVATE_KEY,
1647                              &authkeyid, sockopt_len);
1648             if (ret < 0)
1649                 break;
1650 #  endif
1651 #  ifndef SCTP_AUTHENTICATION_EVENT
1652             if (authkeyid.scact_keynumber > 0) {
1653                 authkeyid.scact_keynumber = authkeyid.scact_keynumber - 1;
1654                 ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY,
1655                                  &authkeyid, sizeof(struct sctp_authkeyid));
1656                 if (ret < 0)
1657                     break;
1658             }
1659 #  endif
1660
1661             data->ccs_rcvd = 0;
1662             data->ccs_sent = 0;
1663         }
1664         break;
1665     case BIO_CTRL_DGRAM_SCTP_GET_SNDINFO:
1666         /* Returns the size of the copied struct. */
1667         if (num > (long)sizeof(struct bio_dgram_sctp_sndinfo))
1668             num = sizeof(struct bio_dgram_sctp_sndinfo);
1669
1670         memcpy(ptr, &(data->sndinfo), num);
1671         ret = num;
1672         break;
1673     case BIO_CTRL_DGRAM_SCTP_SET_SNDINFO:
1674         /* Returns the size of the copied struct. */
1675         if (num > (long)sizeof(struct bio_dgram_sctp_sndinfo))
1676             num = sizeof(struct bio_dgram_sctp_sndinfo);
1677
1678         memcpy(&(data->sndinfo), ptr, num);
1679         break;
1680     case BIO_CTRL_DGRAM_SCTP_GET_RCVINFO:
1681         /* Returns the size of the copied struct. */
1682         if (num > (long)sizeof(struct bio_dgram_sctp_rcvinfo))
1683             num = sizeof(struct bio_dgram_sctp_rcvinfo);
1684
1685         memcpy(ptr, &data->rcvinfo, num);
1686
1687         ret = num;
1688         break;
1689     case BIO_CTRL_DGRAM_SCTP_SET_RCVINFO:
1690         /* Returns the size of the copied struct. */
1691         if (num > (long)sizeof(struct bio_dgram_sctp_rcvinfo))
1692             num = sizeof(struct bio_dgram_sctp_rcvinfo);
1693
1694         memcpy(&(data->rcvinfo), ptr, num);
1695         break;
1696     case BIO_CTRL_DGRAM_SCTP_GET_PRINFO:
1697         /* Returns the size of the copied struct. */
1698         if (num > (long)sizeof(struct bio_dgram_sctp_prinfo))
1699             num = sizeof(struct bio_dgram_sctp_prinfo);
1700
1701         memcpy(ptr, &(data->prinfo), num);
1702         ret = num;
1703         break;
1704     case BIO_CTRL_DGRAM_SCTP_SET_PRINFO:
1705         /* Returns the size of the copied struct. */
1706         if (num > (long)sizeof(struct bio_dgram_sctp_prinfo))
1707             num = sizeof(struct bio_dgram_sctp_prinfo);
1708
1709         memcpy(&(data->prinfo), ptr, num);
1710         break;
1711     case BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN:
1712         /* Returns always 1. */
1713         if (num > 0)
1714             data->save_shutdown = 1;
1715         else
1716             data->save_shutdown = 0;
1717         break;
1718
1719     default:
1720         /*
1721          * Pass to default ctrl function to process SCTP unspecific commands
1722          */
1723         ret = dgram_ctrl(b, cmd, num, ptr);
1724         break;
1725     }
1726     return (ret);
1727 }
1728
1729 int BIO_dgram_sctp_notification_cb(BIO *b,
1730                                    void (*handle_notifications) (BIO *bio,
1731                                                                  void
1732                                                                  *context,
1733                                                                  void *buf),
1734                                    void *context)
1735 {
1736     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1737
1738     if (handle_notifications != NULL) {
1739         data->handle_notifications = handle_notifications;
1740         data->notification_context = context;
1741     } else
1742         return -1;
1743
1744     return 0;
1745 }
1746
1747 /*
1748  * BIO_dgram_sctp_wait_for_dry - Wait for SCTP SENDER_DRY event
1749  * @b: The BIO to check for the dry event
1750  *
1751  * Wait until the peer confirms all packets have been received, and so that
1752  * our kernel doesn't have anything to send anymore.  This is only received by
1753  * the peer's kernel, not the application.
1754  *
1755  * Returns:
1756  * -1 on error
1757  *  0 when not dry yet
1758  *  1 when dry
1759  */
1760 int BIO_dgram_sctp_wait_for_dry(BIO *b)
1761 {
1762     int is_dry = 0;
1763     int n, sockflags, ret;
1764     union sctp_notification snp;
1765     struct msghdr msg;
1766     struct iovec iov;
1767 #  ifdef SCTP_EVENT
1768     struct sctp_event event;
1769 #  else
1770     struct sctp_event_subscribe event;
1771     socklen_t eventsize;
1772 #  endif
1773     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1774
1775     /* set sender dry event */
1776 #  ifdef SCTP_EVENT
1777     memset(&event, 0, sizeof(event));
1778     event.se_assoc_id = 0;
1779     event.se_type = SCTP_SENDER_DRY_EVENT;
1780     event.se_on = 1;
1781     ret =
1782         setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENT, &event,
1783                    sizeof(struct sctp_event));
1784 #  else
1785     eventsize = sizeof(struct sctp_event_subscribe);
1786     ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, &eventsize);
1787     if (ret < 0)
1788         return -1;
1789
1790     event.sctp_sender_dry_event = 1;
1791
1792     ret =
1793         setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1794                    sizeof(struct sctp_event_subscribe));
1795 #  endif
1796     if (ret < 0)
1797         return -1;
1798
1799     /* peek for notification */
1800     memset(&snp, 0, sizeof(snp));
1801     iov.iov_base = (char *)&snp;
1802     iov.iov_len = sizeof(union sctp_notification);
1803     msg.msg_name = NULL;
1804     msg.msg_namelen = 0;
1805     msg.msg_iov = &iov;
1806     msg.msg_iovlen = 1;
1807     msg.msg_control = NULL;
1808     msg.msg_controllen = 0;
1809     msg.msg_flags = 0;
1810
1811     n = recvmsg(b->num, &msg, MSG_PEEK);
1812     if (n <= 0) {
1813         if ((n < 0) && (get_last_socket_error() != EAGAIN)
1814             && (get_last_socket_error() != EWOULDBLOCK))
1815             return -1;
1816         else
1817             return 0;
1818     }
1819
1820     /* if we find a notification, process it and try again if necessary */
1821     while (msg.msg_flags & MSG_NOTIFICATION) {
1822         memset(&snp, 0, sizeof(snp));
1823         iov.iov_base = (char *)&snp;
1824         iov.iov_len = sizeof(union sctp_notification);
1825         msg.msg_name = NULL;
1826         msg.msg_namelen = 0;
1827         msg.msg_iov = &iov;
1828         msg.msg_iovlen = 1;
1829         msg.msg_control = NULL;
1830         msg.msg_controllen = 0;
1831         msg.msg_flags = 0;
1832
1833         n = recvmsg(b->num, &msg, 0);
1834         if (n <= 0) {
1835             if ((n < 0) && (get_last_socket_error() != EAGAIN)
1836                 && (get_last_socket_error() != EWOULDBLOCK))
1837                 return -1;
1838             else
1839                 return is_dry;
1840         }
1841
1842         if (snp.sn_header.sn_type == SCTP_SENDER_DRY_EVENT) {
1843             is_dry = 1;
1844
1845             /* disable sender dry event */
1846 #  ifdef SCTP_EVENT
1847             memset(&event, 0, sizeof(event));
1848             event.se_assoc_id = 0;
1849             event.se_type = SCTP_SENDER_DRY_EVENT;
1850             event.se_on = 0;
1851             ret =
1852                 setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENT, &event,
1853                            sizeof(struct sctp_event));
1854 #  else
1855             eventsize = (socklen_t) sizeof(struct sctp_event_subscribe);
1856             ret =
1857                 getsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1858                            &eventsize);
1859             if (ret < 0)
1860                 return -1;
1861
1862             event.sctp_sender_dry_event = 0;
1863
1864             ret =
1865                 setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1866                            sizeof(struct sctp_event_subscribe));
1867 #  endif
1868             if (ret < 0)
1869                 return -1;
1870         }
1871 #  ifdef SCTP_AUTHENTICATION_EVENT
1872         if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT)
1873             dgram_sctp_handle_auth_free_key_event(b, &snp);
1874 #  endif
1875
1876         if (data->handle_notifications != NULL)
1877             data->handle_notifications(b, data->notification_context,
1878                                        (void *)&snp);
1879
1880         /* found notification, peek again */
1881         memset(&snp, 0, sizeof(snp));
1882         iov.iov_base = (char *)&snp;
1883         iov.iov_len = sizeof(union sctp_notification);
1884         msg.msg_name = NULL;
1885         msg.msg_namelen = 0;
1886         msg.msg_iov = &iov;
1887         msg.msg_iovlen = 1;
1888         msg.msg_control = NULL;
1889         msg.msg_controllen = 0;
1890         msg.msg_flags = 0;
1891
1892         /* if we have seen the dry already, don't wait */
1893         if (is_dry) {
1894             sockflags = fcntl(b->num, F_GETFL, 0);
1895             fcntl(b->num, F_SETFL, O_NONBLOCK);
1896         }
1897
1898         n = recvmsg(b->num, &msg, MSG_PEEK);
1899
1900         if (is_dry) {
1901             fcntl(b->num, F_SETFL, sockflags);
1902         }
1903
1904         if (n <= 0) {
1905             if ((n < 0) && (get_last_socket_error() != EAGAIN)
1906                 && (get_last_socket_error() != EWOULDBLOCK))
1907                 return -1;
1908             else
1909                 return is_dry;
1910         }
1911     }
1912
1913     /* read anything else */
1914     return is_dry;
1915 }
1916
1917 int BIO_dgram_sctp_msg_waiting(BIO *b)
1918 {
1919     int n, sockflags;
1920     union sctp_notification snp;
1921     struct msghdr msg;
1922     struct iovec iov;
1923     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1924
1925     /* Check if there are any messages waiting to be read */
1926     do {
1927         memset(&snp, 0, sizeof(snp));
1928         iov.iov_base = (char *)&snp;
1929         iov.iov_len = sizeof(union sctp_notification);
1930         msg.msg_name = NULL;
1931         msg.msg_namelen = 0;
1932         msg.msg_iov = &iov;
1933         msg.msg_iovlen = 1;
1934         msg.msg_control = NULL;
1935         msg.msg_controllen = 0;
1936         msg.msg_flags = 0;
1937
1938         sockflags = fcntl(b->num, F_GETFL, 0);
1939         fcntl(b->num, F_SETFL, O_NONBLOCK);
1940         n = recvmsg(b->num, &msg, MSG_PEEK);
1941         fcntl(b->num, F_SETFL, sockflags);
1942
1943         /* if notification, process and try again */
1944         if (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)) {
1945 #  ifdef SCTP_AUTHENTICATION_EVENT
1946             if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT)
1947                 dgram_sctp_handle_auth_free_key_event(b, &snp);
1948 #  endif
1949
1950             memset(&snp, 0, sizeof(snp));
1951             iov.iov_base = (char *)&snp;
1952             iov.iov_len = sizeof(union sctp_notification);
1953             msg.msg_name = NULL;
1954             msg.msg_namelen = 0;
1955             msg.msg_iov = &iov;
1956             msg.msg_iovlen = 1;
1957             msg.msg_control = NULL;
1958             msg.msg_controllen = 0;
1959             msg.msg_flags = 0;
1960             n = recvmsg(b->num, &msg, 0);
1961
1962             if (data->handle_notifications != NULL)
1963                 data->handle_notifications(b, data->notification_context,
1964                                            (void *)&snp);
1965         }
1966
1967     } while (n > 0 && (msg.msg_flags & MSG_NOTIFICATION));
1968
1969     /* Return 1 if there is a message to be read, return 0 otherwise. */
1970     if (n > 0)
1971         return 1;
1972     else
1973         return 0;
1974 }
1975
1976 static int dgram_sctp_puts(BIO *bp, const char *str)
1977 {
1978     int n, ret;
1979
1980     n = strlen(str);
1981     ret = dgram_sctp_write(bp, str, n);
1982     return (ret);
1983 }
1984 # endif
1985
1986 static int BIO_dgram_should_retry(int i)
1987 {
1988     int err;
1989
1990     if ((i == 0) || (i == -1)) {
1991         err = get_last_socket_error();
1992
1993 # if defined(OPENSSL_SYS_WINDOWS)
1994         /*
1995          * If the socket return value (i) is -1 and err is unexpectedly 0 at
1996          * this point, the error code was overwritten by another system call
1997          * before this error handling is called.
1998          */
1999 # endif
2000
2001         return (BIO_dgram_non_fatal_error(err));
2002     }
2003     return (0);
2004 }
2005
2006 int BIO_dgram_non_fatal_error(int err)
2007 {
2008     switch (err) {
2009 # if defined(OPENSSL_SYS_WINDOWS)
2010 #  if defined(WSAEWOULDBLOCK)
2011     case WSAEWOULDBLOCK:
2012 #  endif
2013 # endif
2014
2015 # ifdef EWOULDBLOCK
2016 #  ifdef WSAEWOULDBLOCK
2017 #   if WSAEWOULDBLOCK != EWOULDBLOCK
2018     case EWOULDBLOCK:
2019 #   endif
2020 #  else
2021     case EWOULDBLOCK:
2022 #  endif
2023 # endif
2024
2025 # ifdef EINTR
2026     case EINTR:
2027 # endif
2028
2029 # ifdef EAGAIN
2030 #  if EWOULDBLOCK != EAGAIN
2031     case EAGAIN:
2032 #  endif
2033 # endif
2034
2035 # ifdef EPROTO
2036     case EPROTO:
2037 # endif
2038
2039 # ifdef EINPROGRESS
2040     case EINPROGRESS:
2041 # endif
2042
2043 # ifdef EALREADY
2044     case EALREADY:
2045 # endif
2046
2047         return (1);
2048         /* break; */
2049     default:
2050         break;
2051     }
2052     return (0);
2053 }
2054
2055 static void get_current_time(struct timeval *t)
2056 {
2057 # if defined(_WIN32)
2058     SYSTEMTIME st;
2059     union {
2060         unsigned __int64 ul;
2061         FILETIME ft;
2062     } now;
2063
2064     GetSystemTime(&st);
2065     SystemTimeToFileTime(&st, &now.ft);
2066 #  ifdef  __MINGW32__
2067     now.ul -= 116444736000000000ULL;
2068 #  else
2069     now.ul -= 116444736000000000UI64; /* re-bias to 1/1/1970 */
2070 #  endif
2071     t->tv_sec = (long)(now.ul / 10000000);
2072     t->tv_usec = ((int)(now.ul % 10000000)) / 10;
2073 # elif defined(OPENSSL_SYS_VMS)
2074     struct timeb tb;
2075     ftime(&tb);
2076     t->tv_sec = (long)tb.time;
2077     t->tv_usec = (long)tb.millitm * 1000;
2078 # else
2079     gettimeofday(t, NULL);
2080 # endif
2081 }
2082
2083 #endif