crypto/bio/bss_dgram.c

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