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