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