crypto/bio/bss_dgram.c

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