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