crypto/bio/bss_dgram.c

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