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 && !BIO_dgram_sctp_wait_for_dry(b)) {
1408         char *tmp;
1409         data->saved_message.bio = b;
1410         if ((tmp = OPENSSL_malloc(inl)) == NULL) {
1411             BIOerr(BIO_F_DGRAM_SCTP_WRITE, ERR_R_MALLOC_FAILURE);
1412             return -1;
1413         }
1414         OPENSSL_free(data->saved_message.data);
1415         data->saved_message.data = tmp;
1416         memcpy(data->saved_message.data, in, inl);
1417         data->saved_message.length = inl;
1418         return inl;
1419     }
1420
1421     iov[0].iov_base = (char *)in;
1422     iov[0].iov_len = inl;
1423     msg.msg_name = NULL;
1424     msg.msg_namelen = 0;
1425     msg.msg_iov = iov;
1426     msg.msg_iovlen = 1;
1427     msg.msg_control = (caddr_t) cmsgbuf;
1428     msg.msg_controllen = 0;
1429     msg.msg_flags = 0;
1430 #  if defined(SCTP_SNDINFO) && defined(SCTP_PRINFO)
1431     cmsg = (struct cmsghdr *)cmsgbuf;
1432     cmsg->cmsg_level = IPPROTO_SCTP;
1433     cmsg->cmsg_type = SCTP_SNDINFO;
1434     cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
1435     sndinfo = (struct sctp_sndinfo *)CMSG_DATA(cmsg);
1436     memset(sndinfo, 0, sizeof(*sndinfo));
1437     sndinfo->snd_sid = sinfo->snd_sid;
1438     sndinfo->snd_flags = sinfo->snd_flags;
1439     sndinfo->snd_ppid = sinfo->snd_ppid;
1440     sndinfo->snd_context = sinfo->snd_context;
1441     msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
1442
1443     cmsg =
1444         (struct cmsghdr *)&cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndinfo))];
1445     cmsg->cmsg_level = IPPROTO_SCTP;
1446     cmsg->cmsg_type = SCTP_PRINFO;
1447     cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
1448     prinfo = (struct sctp_prinfo *)CMSG_DATA(cmsg);
1449     memset(prinfo, 0, sizeof(*prinfo));
1450     prinfo->pr_policy = pinfo->pr_policy;
1451     prinfo->pr_value = pinfo->pr_value;
1452     msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
1453 #  else
1454     cmsg = (struct cmsghdr *)cmsgbuf;
1455     cmsg->cmsg_level = IPPROTO_SCTP;
1456     cmsg->cmsg_type = SCTP_SNDRCV;
1457     cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
1458     sndrcvinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
1459     memset(sndrcvinfo, 0, sizeof(*sndrcvinfo));
1460     sndrcvinfo->sinfo_stream = sinfo->snd_sid;
1461     sndrcvinfo->sinfo_flags = sinfo->snd_flags;
1462 #   ifdef __FreeBSD__
1463     sndrcvinfo->sinfo_flags |= pinfo->pr_policy;
1464 #   endif
1465     sndrcvinfo->sinfo_ppid = sinfo->snd_ppid;
1466     sndrcvinfo->sinfo_context = sinfo->snd_context;
1467     sndrcvinfo->sinfo_timetolive = pinfo->pr_value;
1468     msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndrcvinfo));
1469 #  endif
1470
1471     ret = sendmsg(b->num, &msg, 0);
1472
1473     BIO_clear_retry_flags(b);
1474     if (ret <= 0) {
1475         if (BIO_dgram_should_retry(ret)) {
1476             BIO_set_retry_write(b);
1477             data->_errno = get_last_socket_error();
1478         }
1479     }
1480     return (ret);
1481 }
1482
1483 static long dgram_sctp_ctrl(BIO *b, int cmd, long num, void *ptr)
1484 {
1485     long ret = 1;
1486     bio_dgram_sctp_data *data = NULL;
1487     socklen_t sockopt_len = 0;
1488     struct sctp_authkeyid authkeyid;
1489     struct sctp_authkey *authkey = NULL;
1490
1491     data = (bio_dgram_sctp_data *) b->ptr;
1492
1493     switch (cmd) {
1494     case BIO_CTRL_DGRAM_QUERY_MTU:
1495         /*
1496          * Set to maximum (2^14) and ignore user input to enable transport
1497          * protocol fragmentation. Returns always 2^14.
1498          */
1499         data->mtu = 16384;
1500         ret = data->mtu;
1501         break;
1502     case BIO_CTRL_DGRAM_SET_MTU:
1503         /*
1504          * Set to maximum (2^14) and ignore input to enable transport
1505          * protocol fragmentation. Returns always 2^14.
1506          */
1507         data->mtu = 16384;
1508         ret = data->mtu;
1509         break;
1510     case BIO_CTRL_DGRAM_SET_CONNECTED:
1511     case BIO_CTRL_DGRAM_CONNECT:
1512         /* Returns always -1. */
1513         ret = -1;
1514         break;
1515     case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
1516         /*
1517          * SCTP doesn't need the DTLS timer Returns always 1.
1518          */
1519         break;
1520     case BIO_CTRL_DGRAM_GET_MTU_OVERHEAD:
1521         /*
1522          * We allow transport protocol fragmentation so this is irrelevant
1523          */
1524         ret = 0;
1525         break;
1526     case BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE:
1527         if (num > 0)
1528             data->in_handshake = 1;
1529         else
1530             data->in_handshake = 0;
1531
1532         ret =
1533             setsockopt(b->num, IPPROTO_SCTP, SCTP_NODELAY,
1534                        &data->in_handshake, sizeof(int));
1535         break;
1536     case BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY:
1537         /*
1538          * New shared key for SCTP AUTH. Returns 0 on success, -1 otherwise.
1539          */
1540
1541         /* Get active key */
1542         sockopt_len = sizeof(struct sctp_authkeyid);
1543         ret =
1544             getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid,
1545                        &sockopt_len);
1546         if (ret < 0)
1547             break;
1548
1549         /* Add new key */
1550         sockopt_len = sizeof(struct sctp_authkey) + 64 * sizeof(uint8_t);
1551         authkey = OPENSSL_malloc(sockopt_len);
1552         if (authkey == NULL) {
1553             ret = -1;
1554             break;
1555         }
1556         memset(authkey, 0, sockopt_len);
1557         authkey->sca_keynumber = authkeyid.scact_keynumber + 1;
1558 #  ifndef __FreeBSD__
1559         /*
1560          * This field is missing in FreeBSD 8.2 and earlier, and FreeBSD 8.3
1561          * and higher work without it.
1562          */
1563         authkey->sca_keylength = 64;
1564 #  endif
1565         memcpy(&authkey->sca_key[0], ptr, 64 * sizeof(uint8_t));
1566
1567         ret =
1568             setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_KEY, authkey,
1569                        sockopt_len);
1570         OPENSSL_free(authkey);
1571         authkey = NULL;
1572         if (ret < 0)
1573             break;
1574
1575         /* Reset active key */
1576         ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY,
1577                          &authkeyid, sizeof(struct sctp_authkeyid));
1578         if (ret < 0)
1579             break;
1580
1581         break;
1582     case BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY:
1583         /* Returns 0 on success, -1 otherwise. */
1584
1585         /* Get active key */
1586         sockopt_len = sizeof(struct sctp_authkeyid);
1587         ret =
1588             getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, &authkeyid,
1589                        &sockopt_len);
1590         if (ret < 0)
1591             break;
1592
1593         /* Set active key */
1594         authkeyid.scact_keynumber = authkeyid.scact_keynumber + 1;
1595         ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY,
1596                          &authkeyid, sizeof(struct sctp_authkeyid));
1597         if (ret < 0)
1598             break;
1599
1600         /*
1601          * CCS has been sent, so remember that and fall through to check if
1602          * we need to deactivate an old key
1603          */
1604         data->ccs_sent = 1;
1605
1606     case BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD:
1607         /* Returns 0 on success, -1 otherwise. */
1608
1609         /*
1610          * Has this command really been called or is this just a
1611          * fall-through?
1612          */
1613         if (cmd == BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD)
1614             data->ccs_rcvd = 1;
1615
1616         /*
1617          * CSS has been both, received and sent, so deactivate an old key
1618          */
1619         if (data->ccs_rcvd == 1 && data->ccs_sent == 1) {
1620             /* Get active key */
1621             sockopt_len = sizeof(struct sctp_authkeyid);
1622             ret =
1623                 getsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY,
1624                            &authkeyid, &sockopt_len);
1625             if (ret < 0)
1626                 break;
1627
1628             /*
1629              * Deactivate key or delete second last key if
1630              * SCTP_AUTHENTICATION_EVENT is not available.
1631              */
1632             authkeyid.scact_keynumber = authkeyid.scact_keynumber - 1;
1633 #  ifdef SCTP_AUTH_DEACTIVATE_KEY
1634             sockopt_len = sizeof(struct sctp_authkeyid);
1635             ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DEACTIVATE_KEY,
1636                              &authkeyid, sockopt_len);
1637             if (ret < 0)
1638                 break;
1639 #  endif
1640 #  ifndef SCTP_AUTHENTICATION_EVENT
1641             if (authkeyid.scact_keynumber > 0) {
1642                 authkeyid.scact_keynumber = authkeyid.scact_keynumber - 1;
1643                 ret = setsockopt(b->num, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY,
1644                                  &authkeyid, sizeof(struct sctp_authkeyid));
1645                 if (ret < 0)
1646                     break;
1647             }
1648 #  endif
1649
1650             data->ccs_rcvd = 0;
1651             data->ccs_sent = 0;
1652         }
1653         break;
1654     case BIO_CTRL_DGRAM_SCTP_GET_SNDINFO:
1655         /* Returns the size of the copied struct. */
1656         if (num > (long)sizeof(struct bio_dgram_sctp_sndinfo))
1657             num = sizeof(struct bio_dgram_sctp_sndinfo);
1658
1659         memcpy(ptr, &(data->sndinfo), num);
1660         ret = num;
1661         break;
1662     case BIO_CTRL_DGRAM_SCTP_SET_SNDINFO:
1663         /* Returns the size of the copied struct. */
1664         if (num > (long)sizeof(struct bio_dgram_sctp_sndinfo))
1665             num = sizeof(struct bio_dgram_sctp_sndinfo);
1666
1667         memcpy(&(data->sndinfo), ptr, num);
1668         break;
1669     case BIO_CTRL_DGRAM_SCTP_GET_RCVINFO:
1670         /* Returns the size of the copied struct. */
1671         if (num > (long)sizeof(struct bio_dgram_sctp_rcvinfo))
1672             num = sizeof(struct bio_dgram_sctp_rcvinfo);
1673
1674         memcpy(ptr, &data->rcvinfo, num);
1675
1676         ret = num;
1677         break;
1678     case BIO_CTRL_DGRAM_SCTP_SET_RCVINFO:
1679         /* Returns the size of the copied struct. */
1680         if (num > (long)sizeof(struct bio_dgram_sctp_rcvinfo))
1681             num = sizeof(struct bio_dgram_sctp_rcvinfo);
1682
1683         memcpy(&(data->rcvinfo), ptr, num);
1684         break;
1685     case BIO_CTRL_DGRAM_SCTP_GET_PRINFO:
1686         /* Returns the size of the copied struct. */
1687         if (num > (long)sizeof(struct bio_dgram_sctp_prinfo))
1688             num = sizeof(struct bio_dgram_sctp_prinfo);
1689
1690         memcpy(ptr, &(data->prinfo), num);
1691         ret = num;
1692         break;
1693     case BIO_CTRL_DGRAM_SCTP_SET_PRINFO:
1694         /* Returns the size of the copied struct. */
1695         if (num > (long)sizeof(struct bio_dgram_sctp_prinfo))
1696             num = sizeof(struct bio_dgram_sctp_prinfo);
1697
1698         memcpy(&(data->prinfo), ptr, num);
1699         break;
1700     case BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN:
1701         /* Returns always 1. */
1702         if (num > 0)
1703             data->save_shutdown = 1;
1704         else
1705             data->save_shutdown = 0;
1706         break;
1707
1708     default:
1709         /*
1710          * Pass to default ctrl function to process SCTP unspecific commands
1711          */
1712         ret = dgram_ctrl(b, cmd, num, ptr);
1713         break;
1714     }
1715     return (ret);
1716 }
1717
1718 int BIO_dgram_sctp_notification_cb(BIO *b,
1719                                    void (*handle_notifications) (BIO *bio,
1720                                                                  void
1721                                                                  *context,
1722                                                                  void *buf),
1723                                    void *context)
1724 {
1725     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1726
1727     if (handle_notifications != NULL) {
1728         data->handle_notifications = handle_notifications;
1729         data->notification_context = context;
1730     } else
1731         return -1;
1732
1733     return 0;
1734 }
1735
1736 int BIO_dgram_sctp_wait_for_dry(BIO *b)
1737 {
1738     int is_dry = 0;
1739     int n, sockflags, ret;
1740     union sctp_notification snp;
1741     struct msghdr msg;
1742     struct iovec iov;
1743 #  ifdef SCTP_EVENT
1744     struct sctp_event event;
1745 #  else
1746     struct sctp_event_subscribe event;
1747     socklen_t eventsize;
1748 #  endif
1749     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1750
1751     /* set sender dry event */
1752 #  ifdef SCTP_EVENT
1753     memset(&event, 0, sizeof(event));
1754     event.se_assoc_id = 0;
1755     event.se_type = SCTP_SENDER_DRY_EVENT;
1756     event.se_on = 1;
1757     ret =
1758         setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENT, &event,
1759                    sizeof(struct sctp_event));
1760 #  else
1761     eventsize = sizeof(struct sctp_event_subscribe);
1762     ret = getsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event, &eventsize);
1763     if (ret < 0)
1764         return -1;
1765
1766     event.sctp_sender_dry_event = 1;
1767
1768     ret =
1769         setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1770                    sizeof(struct sctp_event_subscribe));
1771 #  endif
1772     if (ret < 0)
1773         return -1;
1774
1775     /* peek for notification */
1776     memset(&snp, 0, sizeof(snp));
1777     iov.iov_base = (char *)&snp;
1778     iov.iov_len = sizeof(union sctp_notification);
1779     msg.msg_name = NULL;
1780     msg.msg_namelen = 0;
1781     msg.msg_iov = &iov;
1782     msg.msg_iovlen = 1;
1783     msg.msg_control = NULL;
1784     msg.msg_controllen = 0;
1785     msg.msg_flags = 0;
1786
1787     n = recvmsg(b->num, &msg, MSG_PEEK);
1788     if (n <= 0) {
1789         if ((n < 0) && (get_last_socket_error() != EAGAIN)
1790             && (get_last_socket_error() != EWOULDBLOCK))
1791             return -1;
1792         else
1793             return 0;
1794     }
1795
1796     /* if we find a notification, process it and try again if necessary */
1797     while (msg.msg_flags & MSG_NOTIFICATION) {
1798         memset(&snp, 0, sizeof(snp));
1799         iov.iov_base = (char *)&snp;
1800         iov.iov_len = sizeof(union sctp_notification);
1801         msg.msg_name = NULL;
1802         msg.msg_namelen = 0;
1803         msg.msg_iov = &iov;
1804         msg.msg_iovlen = 1;
1805         msg.msg_control = NULL;
1806         msg.msg_controllen = 0;
1807         msg.msg_flags = 0;
1808
1809         n = recvmsg(b->num, &msg, 0);
1810         if (n <= 0) {
1811             if ((n < 0) && (get_last_socket_error() != EAGAIN)
1812                 && (get_last_socket_error() != EWOULDBLOCK))
1813                 return -1;
1814             else
1815                 return is_dry;
1816         }
1817
1818         if (snp.sn_header.sn_type == SCTP_SENDER_DRY_EVENT) {
1819             is_dry = 1;
1820
1821             /* disable sender dry event */
1822 #  ifdef SCTP_EVENT
1823             memset(&event, 0, sizeof(event));
1824             event.se_assoc_id = 0;
1825             event.se_type = SCTP_SENDER_DRY_EVENT;
1826             event.se_on = 0;
1827             ret =
1828                 setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENT, &event,
1829                            sizeof(struct sctp_event));
1830 #  else
1831             eventsize = (socklen_t) sizeof(struct sctp_event_subscribe);
1832             ret =
1833                 getsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1834                            &eventsize);
1835             if (ret < 0)
1836                 return -1;
1837
1838             event.sctp_sender_dry_event = 0;
1839
1840             ret =
1841                 setsockopt(b->num, IPPROTO_SCTP, SCTP_EVENTS, &event,
1842                            sizeof(struct sctp_event_subscribe));
1843 #  endif
1844             if (ret < 0)
1845                 return -1;
1846         }
1847 #  ifdef SCTP_AUTHENTICATION_EVENT
1848         if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT)
1849             dgram_sctp_handle_auth_free_key_event(b, &snp);
1850 #  endif
1851
1852         if (data->handle_notifications != NULL)
1853             data->handle_notifications(b, data->notification_context,
1854                                        (void *)&snp);
1855
1856         /* found notification, peek again */
1857         memset(&snp, 0, sizeof(snp));
1858         iov.iov_base = (char *)&snp;
1859         iov.iov_len = sizeof(union sctp_notification);
1860         msg.msg_name = NULL;
1861         msg.msg_namelen = 0;
1862         msg.msg_iov = &iov;
1863         msg.msg_iovlen = 1;
1864         msg.msg_control = NULL;
1865         msg.msg_controllen = 0;
1866         msg.msg_flags = 0;
1867
1868         /* if we have seen the dry already, don't wait */
1869         if (is_dry) {
1870             sockflags = fcntl(b->num, F_GETFL, 0);
1871             fcntl(b->num, F_SETFL, O_NONBLOCK);
1872         }
1873
1874         n = recvmsg(b->num, &msg, MSG_PEEK);
1875
1876         if (is_dry) {
1877             fcntl(b->num, F_SETFL, sockflags);
1878         }
1879
1880         if (n <= 0) {
1881             if ((n < 0) && (get_last_socket_error() != EAGAIN)
1882                 && (get_last_socket_error() != EWOULDBLOCK))
1883                 return -1;
1884             else
1885                 return is_dry;
1886         }
1887     }
1888
1889     /* read anything else */
1890     return is_dry;
1891 }
1892
1893 int BIO_dgram_sctp_msg_waiting(BIO *b)
1894 {
1895     int n, sockflags;
1896     union sctp_notification snp;
1897     struct msghdr msg;
1898     struct iovec iov;
1899     bio_dgram_sctp_data *data = (bio_dgram_sctp_data *) b->ptr;
1900
1901     /* Check if there are any messages waiting to be read */
1902     do {
1903         memset(&snp, 0, sizeof(snp));
1904         iov.iov_base = (char *)&snp;
1905         iov.iov_len = sizeof(union sctp_notification);
1906         msg.msg_name = NULL;
1907         msg.msg_namelen = 0;
1908         msg.msg_iov = &iov;
1909         msg.msg_iovlen = 1;
1910         msg.msg_control = NULL;
1911         msg.msg_controllen = 0;
1912         msg.msg_flags = 0;
1913
1914         sockflags = fcntl(b->num, F_GETFL, 0);
1915         fcntl(b->num, F_SETFL, O_NONBLOCK);
1916         n = recvmsg(b->num, &msg, MSG_PEEK);
1917         fcntl(b->num, F_SETFL, sockflags);
1918
1919         /* if notification, process and try again */
1920         if (n > 0 && (msg.msg_flags & MSG_NOTIFICATION)) {
1921 #  ifdef SCTP_AUTHENTICATION_EVENT
1922             if (snp.sn_header.sn_type == SCTP_AUTHENTICATION_EVENT)
1923                 dgram_sctp_handle_auth_free_key_event(b, &snp);
1924 #  endif
1925
1926             memset(&snp, 0, sizeof(snp));
1927             iov.iov_base = (char *)&snp;
1928             iov.iov_len = sizeof(union sctp_notification);
1929             msg.msg_name = NULL;
1930             msg.msg_namelen = 0;
1931             msg.msg_iov = &iov;
1932             msg.msg_iovlen = 1;
1933             msg.msg_control = NULL;
1934             msg.msg_controllen = 0;
1935             msg.msg_flags = 0;
1936             n = recvmsg(b->num, &msg, 0);
1937
1938             if (data->handle_notifications != NULL)
1939                 data->handle_notifications(b, data->notification_context,
1940                                            (void *)&snp);
1941         }
1942
1943     } while (n > 0 && (msg.msg_flags & MSG_NOTIFICATION));
1944
1945     /* Return 1 if there is a message to be read, return 0 otherwise. */
1946     if (n > 0)
1947         return 1;
1948     else
1949         return 0;
1950 }
1951
1952 static int dgram_sctp_puts(BIO *bp, const char *str)
1953 {
1954     int n, ret;
1955
1956     n = strlen(str);
1957     ret = dgram_sctp_write(bp, str, n);
1958     return (ret);
1959 }
1960 # endif
1961
1962 static int BIO_dgram_should_retry(int i)
1963 {
1964     int err;
1965
1966     if ((i == 0) || (i == -1)) {
1967         err = get_last_socket_error();
1968
1969 # if defined(OPENSSL_SYS_WINDOWS)
1970         /*
1971          * If the socket return value (i) is -1 and err is unexpectedly 0 at
1972          * this point, the error code was overwritten by another system call
1973          * before this error handling is called.
1974          */
1975 # endif
1976
1977         return (BIO_dgram_non_fatal_error(err));
1978     }
1979     return (0);
1980 }
1981
1982 int BIO_dgram_non_fatal_error(int err)
1983 {
1984     switch (err) {
1985 # if defined(OPENSSL_SYS_WINDOWS)
1986 #  if defined(WSAEWOULDBLOCK)
1987     case WSAEWOULDBLOCK:
1988 #  endif
1989 # endif
1990
1991 # ifdef EWOULDBLOCK
1992 #  ifdef WSAEWOULDBLOCK
1993 #   if WSAEWOULDBLOCK != EWOULDBLOCK
1994     case EWOULDBLOCK:
1995 #   endif
1996 #  else
1997     case EWOULDBLOCK:
1998 #  endif
1999 # endif
2000
2001 # ifdef EINTR
2002     case EINTR:
2003 # endif
2004
2005 # ifdef EAGAIN
2006 #  if EWOULDBLOCK != EAGAIN
2007     case EAGAIN:
2008 #  endif
2009 # endif
2010
2011 # ifdef EPROTO
2012     case EPROTO:
2013 # endif
2014
2015 # ifdef EINPROGRESS
2016     case EINPROGRESS:
2017 # endif
2018
2019 # ifdef EALREADY
2020     case EALREADY:
2021 # endif
2022
2023         return (1);
2024         /* break; */
2025     default:
2026         break;
2027     }
2028     return (0);
2029 }
2030
2031 static void get_current_time(struct timeval *t)
2032 {
2033 # if defined(_WIN32)
2034     SYSTEMTIME st;
2035     union {
2036         unsigned __int64 ul;
2037         FILETIME ft;
2038     } now;
2039
2040     GetSystemTime(&st);
2041     SystemTimeToFileTime(&st, &now.ft);
2042 #  ifdef  __MINGW32__
2043     now.ul -= 116444736000000000ULL;
2044 #  else
2045     now.ul -= 116444736000000000UI64; /* re-bias to 1/1/1970 */
2046 #  endif
2047     t->tv_sec = (long)(now.ul / 10000000);
2048     t->tv_usec = ((int)(now.ul % 10000000)) / 10;
2049 # elif defined(OPENSSL_SYS_VMS)
2050     struct timeb tb;
2051     ftime(&tb);
2052     t->tv_sec = (long)tb.time;
2053     t->tv_usec = (long)tb.millitm * 1000;
2054 # else
2055     gettimeofday(t, NULL);
2056 # endif
2057 }
2058
2059 #endif