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