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