/*
- * Copyright 2005-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2005-2024 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
#include <stdio.h>
#include <errno.h>
+#include "internal/time.h"
#include "bio_local.h"
#ifndef OPENSSL_NO_DGRAM
((a)->s6_addr32[2] == htonl(0x0000ffff)))
# endif
+/* Determine what method to use for BIO_sendmmsg and BIO_recvmmsg. */
+# define M_METHOD_NONE 0
+# define M_METHOD_RECVMMSG 1
+# define M_METHOD_RECVMSG 2
+# define M_METHOD_RECVFROM 3
+# define M_METHOD_WSARECVMSG 4
+
+# if defined(__GLIBC__) && defined(__GLIBC_PREREQ)
+# if !(__GLIBC_PREREQ(2, 14))
+# undef NO_RECVMMSG
+ /*
+ * Some old glibc versions may have recvmmsg and MSG_WAITFORONE flag, but
+ * not sendmmsg. We need both so force this to be disabled on these old
+ * versions
+ */
+# define NO_RECVMMSG
+# endif
+# endif
+# if defined(__GNU__)
+ /* GNU/Hurd does not have IP_PKTINFO yet */
+ #undef NO_RECVMSG
+ #define NO_RECVMSG
+# endif
+# if defined(__ANDROID_API__) && __ANDROID_API__ < 21
+# undef NO_RECVMMSG
+# define NO_RECVMMSG
+# endif
+# if !defined(M_METHOD)
+# if defined(OPENSSL_SYS_WINDOWS) && defined(BIO_HAVE_WSAMSG) && !defined(NO_WSARECVMSG)
+# define M_METHOD M_METHOD_WSARECVMSG
+# elif !defined(OPENSSL_SYS_WINDOWS) && defined(MSG_WAITFORONE) && !defined(NO_RECVMMSG)
+# define M_METHOD M_METHOD_RECVMMSG
+# elif !defined(OPENSSL_SYS_WINDOWS) && defined(CMSG_LEN) && !defined(NO_RECVMSG)
+# define M_METHOD M_METHOD_RECVMSG
+# elif !defined(NO_RECVFROM)
+# define M_METHOD M_METHOD_RECVFROM
+# else
+# define M_METHOD M_METHOD_NONE
+# endif
+# endif
+
+# if defined(OPENSSL_SYS_WINDOWS)
+# define BIO_CMSG_SPACE(x) WSA_CMSG_SPACE(x)
+# define BIO_CMSG_FIRSTHDR(x) WSA_CMSG_FIRSTHDR(x)
+# define BIO_CMSG_NXTHDR(x, y) WSA_CMSG_NXTHDR(x, y)
+# define BIO_CMSG_DATA(x) WSA_CMSG_DATA(x)
+# define BIO_CMSG_LEN(x) WSA_CMSG_LEN(x)
+# define MSGHDR_TYPE WSAMSG
+# define CMSGHDR_TYPE WSACMSGHDR
+# else
+# define MSGHDR_TYPE struct msghdr
+# define CMSGHDR_TYPE struct cmsghdr
+# define BIO_CMSG_SPACE(x) CMSG_SPACE(x)
+# define BIO_CMSG_FIRSTHDR(x) CMSG_FIRSTHDR(x)
+# define BIO_CMSG_NXTHDR(x, y) CMSG_NXTHDR(x, y)
+# define BIO_CMSG_DATA(x) CMSG_DATA(x)
+# define BIO_CMSG_LEN(x) CMSG_LEN(x)
+# endif
+
+# if M_METHOD == M_METHOD_RECVMMSG \
+ || M_METHOD == M_METHOD_RECVMSG \
+ || M_METHOD == M_METHOD_WSARECVMSG
+# if defined(__APPLE__)
+ /*
+ * CMSG_SPACE is not a constant expression on OSX even though POSIX
+ * says it's supposed to be. This should be adequate.
+ */
+# define BIO_CMSG_ALLOC_LEN 64
+# else
+# if defined(IPV6_PKTINFO)
+# define BIO_CMSG_ALLOC_LEN_1 BIO_CMSG_SPACE(sizeof(struct in6_pktinfo))
+# else
+# define BIO_CMSG_ALLOC_LEN_1 0
+# endif
+# if defined(IP_PKTINFO)
+# define BIO_CMSG_ALLOC_LEN_2 BIO_CMSG_SPACE(sizeof(struct in_pktinfo))
+# else
+# define BIO_CMSG_ALLOC_LEN_2 0
+# endif
+# if defined(IP_RECVDSTADDR)
+# define BIO_CMSG_ALLOC_LEN_3 BIO_CMSG_SPACE(sizeof(struct in_addr))
+# else
+# define BIO_CMSG_ALLOC_LEN_3 0
+# endif
+# define BIO_MAX(X,Y) ((X) > (Y) ? (X) : (Y))
+# define BIO_CMSG_ALLOC_LEN \
+ BIO_MAX(BIO_CMSG_ALLOC_LEN_1, \
+ BIO_MAX(BIO_CMSG_ALLOC_LEN_2, BIO_CMSG_ALLOC_LEN_3))
+# endif
+# if (defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)) && defined(IPV6_RECVPKTINFO)
+# define SUPPORT_LOCAL_ADDR
+# endif
+# endif
+
+# define BIO_MSG_N(array, stride, n) (*(BIO_MSG *)((char *)(array) + (n)*(stride)))
+
static int dgram_write(BIO *h, const char *buf, int num);
static int dgram_read(BIO *h, char *buf, int size);
static int dgram_puts(BIO *h, const char *str);
static int dgram_new(BIO *h);
static int dgram_free(BIO *data);
static int dgram_clear(BIO *bio);
+static int dgram_sendmmsg(BIO *b, BIO_MSG *msg,
+ size_t stride, size_t num_msg,
+ uint64_t flags, size_t *num_processed);
+static int dgram_recvmmsg(BIO *b, BIO_MSG *msg,
+ size_t stride, size_t num_msg,
+ uint64_t flags, size_t *num_processed);
# ifndef OPENSSL_NO_SCTP
static int dgram_sctp_write(BIO *h, const char *buf, int num);
static int BIO_dgram_should_retry(int s);
-static void get_current_time(struct timeval *t);
-
static const BIO_METHOD methods_dgramp = {
BIO_TYPE_DGRAM,
"datagram socket",
dgram_new,
dgram_free,
NULL, /* dgram_callback_ctrl */
+ dgram_sendmmsg,
+ dgram_recvmmsg,
};
# ifndef OPENSSL_NO_SCTP
dgram_sctp_new,
dgram_sctp_free,
NULL, /* dgram_callback_ctrl */
+ NULL, /* sendmmsg */
+ NULL, /* recvmmsg */
};
# endif
typedef struct bio_dgram_data_st {
BIO_ADDR peer;
+ BIO_ADDR local_addr;
unsigned int connected;
unsigned int _errno;
unsigned int mtu;
- struct timeval next_timeout;
- struct timeval socket_timeout;
+ OSSL_TIME next_timeout;
+ OSSL_TIME socket_timeout;
unsigned int peekmode;
+ char local_addr_enabled;
} bio_dgram_data;
# ifndef OPENSSL_NO_SCTP
int length;
} bio_dgram_sctp_save_message;
+/*
+ * Note: bio_dgram_data must be first here
+ * as we use dgram_ctrl for underlying dgram operations
+ * which will cast this struct to a bio_dgram_data
+ */
typedef struct bio_dgram_sctp_data_st {
- BIO_ADDR peer;
- unsigned int connected;
- unsigned int _errno;
- unsigned int mtu;
+ bio_dgram_data dgram;
struct bio_dgram_sctp_sndinfo sndinfo;
struct bio_dgram_sctp_rcvinfo rcvinfo;
struct bio_dgram_sctp_prinfo prinfo;
{
# if defined(SO_RCVTIMEO)
bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ OSSL_TIME timeleft;
/* Is a timer active? */
- if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) {
- struct timeval timenow, timeleft;
-
+ if (!ossl_time_is_zero(data->next_timeout)) {
/* Read current socket timeout */
# ifdef OPENSSL_SYS_WINDOWS
int timeout;
-
int sz = sizeof(timeout);
+
if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
- (void *)&timeout, &sz) < 0) {
- perror("getsockopt");
- } else {
- data->socket_timeout.tv_sec = timeout / 1000;
- data->socket_timeout.tv_usec = (timeout % 1000) * 1000;
- }
+ (void *)&timeout, &sz) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling getsockopt()");
+ else
+ data->socket_timeout = ossl_ms2time(timeout);
# else
- socklen_t sz = sizeof(data->socket_timeout);
- if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
- &(data->socket_timeout), &sz) < 0) {
- perror("getsockopt");
- } else
- OPENSSL_assert(sz <= sizeof(data->socket_timeout));
-# endif
+ struct timeval tv;
+ socklen_t sz = sizeof(tv);
- /* Get current time */
- get_current_time(&timenow);
+ if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &tv, &sz) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling getsockopt()");
+ else
+ data->socket_timeout = ossl_time_from_timeval(tv);
+# endif
/* Calculate time left until timer expires */
- memcpy(&timeleft, &(data->next_timeout), sizeof(struct timeval));
- if (timeleft.tv_usec < timenow.tv_usec) {
- timeleft.tv_usec = 1000000 - timenow.tv_usec + timeleft.tv_usec;
- timeleft.tv_sec--;
- } else {
- timeleft.tv_usec -= timenow.tv_usec;
- }
- if (timeleft.tv_sec < timenow.tv_sec) {
- timeleft.tv_sec = 0;
- timeleft.tv_usec = 1;
- } else {
- timeleft.tv_sec -= timenow.tv_sec;
- }
+ timeleft = ossl_time_subtract(data->next_timeout, ossl_time_now());
+ if (ossl_time_compare(timeleft, ossl_ticks2time(OSSL_TIME_US)) < 0)
+ timeleft = ossl_ticks2time(OSSL_TIME_US);
/*
* Adjust socket timeout if next handshake message timer will expire
* earlier.
*/
- if ((data->socket_timeout.tv_sec == 0
- && data->socket_timeout.tv_usec == 0)
- || (data->socket_timeout.tv_sec > timeleft.tv_sec)
- || (data->socket_timeout.tv_sec == timeleft.tv_sec
- && data->socket_timeout.tv_usec >= timeleft.tv_usec)) {
+ if (ossl_time_is_zero(data->socket_timeout)
+ || ossl_time_compare(data->socket_timeout, timeleft) >= 0) {
# ifdef OPENSSL_SYS_WINDOWS
- timeout = timeleft.tv_sec * 1000 + timeleft.tv_usec / 1000;
+ timeout = (int)ossl_time2ms(timeleft);
if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
- (void *)&timeout, sizeof(timeout)) < 0) {
- perror("setsockopt");
- }
+ (void *)&timeout, sizeof(timeout)) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# else
- if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &timeleft,
- sizeof(struct timeval)) < 0) {
- perror("setsockopt");
- }
+ tv = ossl_time_to_timeval(timeleft);
+ if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &tv,
+ sizeof(tv)) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# endif
}
}
# endif
}
+static void dgram_update_local_addr(BIO *b)
+{
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ socklen_t addr_len = sizeof(data->local_addr);
+
+ if (getsockname(b->num, &data->local_addr.sa, &addr_len) < 0)
+ /*
+ * This should not be possible, but zero-initialize and return
+ * anyway.
+ */
+ BIO_ADDR_clear(&data->local_addr);
+}
+
+# if M_METHOD == M_METHOD_RECVMMSG || M_METHOD == M_METHOD_RECVMSG || M_METHOD == M_METHOD_WSARECVMSG
+static int dgram_get_sock_family(BIO *b)
+{
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ return data->local_addr.sa.sa_family;
+}
+# endif
+
static void dgram_reset_rcv_timeout(BIO *b)
{
# if defined(SO_RCVTIMEO)
bio_dgram_data *data = (bio_dgram_data *)b->ptr;
/* Is a timer active? */
- if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0) {
+ if (!ossl_time_is_zero(data->next_timeout)) {
# ifdef OPENSSL_SYS_WINDOWS
- int timeout = data->socket_timeout.tv_sec * 1000 +
- data->socket_timeout.tv_usec / 1000;
+ int timeout = (int)ossl_time2ms(data->socket_timeout);
+
if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
- (void *)&timeout, sizeof(timeout)) < 0) {
- perror("setsockopt");
- }
+ (void *)&timeout, sizeof(timeout)) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# else
- if (setsockopt
- (b->num, SOL_SOCKET, SO_RCVTIMEO, &(data->socket_timeout),
- sizeof(struct timeval)) < 0) {
- perror("setsockopt");
- }
+ struct timeval tv = ossl_time_to_timeval(data->socket_timeout);
+
+ if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# endif
}
# endif
if (out != NULL) {
clear_socket_error();
- memset(&peer, 0, sizeof(peer));
+ BIO_ADDR_clear(&peer);
dgram_adjust_rcv_timeout(b);
if (data->peekmode)
flags = MSG_PEEK;
return ret;
}
+/* Enables appropriate destination address reception option on the socket. */
+# if defined(SUPPORT_LOCAL_ADDR)
+static int enable_local_addr(BIO *b, int enable) {
+ int af = dgram_get_sock_family(b);
+
+ if (af == AF_INET) {
+# if defined(IP_PKTINFO)
+ /* IP_PKTINFO is preferred */
+ if (setsockopt(b->num, IPPROTO_IP, IP_PKTINFO,
+ (void *)&enable, sizeof(enable)) < 0)
+ return 0;
+
+ return 1;
+
+# elif defined(IP_RECVDSTADDR)
+ /* Fall back to IP_RECVDSTADDR */
+
+ if (setsockopt(b->num, IPPROTO_IP, IP_RECVDSTADDR,
+ &enable, sizeof(enable)) < 0)
+ return 0;
+
+ return 1;
+# endif
+ }
+
+# if OPENSSL_USE_IPV6
+ if (af == AF_INET6) {
+# if defined(IPV6_RECVPKTINFO)
+ if (setsockopt(b->num, IPPROTO_IPV6, IPV6_RECVPKTINFO,
+ &enable, sizeof(enable)) < 0)
+ return 0;
+
+ return 1;
+# endif
+ }
+# endif
+
+ return 0;
+}
+# endif
+
static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr)
{
long ret = 1;
int *ip;
bio_dgram_data *data = NULL;
+# ifndef __DJGPP__
+ /* There are currently no cases where this is used on djgpp/watt32. */
int sockopt_val = 0;
+# endif
int d_errno;
# if defined(OPENSSL_SYS_LINUX) && (defined(IP_MTU_DISCOVER) || defined(IP_MTU))
socklen_t sockopt_len; /* assume that system supporting IP_MTU is
b->num = *((int *)ptr);
b->shutdown = (int)num;
b->init = 1;
+ dgram_update_local_addr(b);
+# if defined(SUPPORT_LOCAL_ADDR)
+ if (data->local_addr_enabled) {
+ if (enable_local_addr(b, 1) < 1)
+ data->local_addr_enabled = 0;
+ }
+# endif
break;
case BIO_C_GET_FD:
if (b->init) {
case BIO_CTRL_DGRAM_MTU_DISCOVER:
# if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO)
addr_len = (socklen_t) sizeof(addr);
- memset(&addr, 0, sizeof(addr));
+ BIO_ADDR_clear(&addr);
if (getsockname(b->num, &addr.sa, &addr_len) < 0) {
ret = 0;
break;
sockopt_val = IP_PMTUDISC_DO;
if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
&sockopt_val, sizeof(sockopt_val))) < 0)
- perror("setsockopt");
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
break;
# if OPENSSL_USE_IPV6 && defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO)
case AF_INET6:
sockopt_val = IPV6_PMTUDISC_DO;
if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
&sockopt_val, sizeof(sockopt_val))) < 0)
- perror("setsockopt");
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
break;
# endif
default:
case BIO_CTRL_DGRAM_QUERY_MTU:
# if defined(OPENSSL_SYS_LINUX) && defined(IP_MTU)
addr_len = (socklen_t) sizeof(addr);
- memset(&addr, 0, sizeof(addr));
+ BIO_ADDR_clear(&addr);
if (getsockname(b->num, &addr.sa, &addr_len) < 0) {
ret = 0;
break;
BIO_ADDR_make(&data->peer, BIO_ADDR_sockaddr((BIO_ADDR *)ptr));
} else {
data->connected = 0;
- memset(&data->peer, 0, sizeof(data->peer));
+ BIO_ADDR_clear(&data->peer);
}
break;
case BIO_CTRL_DGRAM_GET_PEER:
case BIO_CTRL_DGRAM_SET_PEER:
BIO_ADDR_make(&data->peer, BIO_ADDR_sockaddr((BIO_ADDR *)ptr));
break;
+ case BIO_CTRL_DGRAM_DETECT_PEER_ADDR:
+ {
+ BIO_ADDR xaddr, *p = &data->peer;
+ socklen_t xaddr_len = sizeof(xaddr.sa);
+
+ if (BIO_ADDR_family(p) == AF_UNSPEC) {
+ if (getpeername(b->num, (void *)&xaddr.sa, &xaddr_len) == 0
+ && BIO_ADDR_family(&xaddr) != AF_UNSPEC) {
+ p = &xaddr;
+ } else {
+ ret = 0;
+ break;
+ }
+ }
+
+ ret = BIO_ADDR_sockaddr_size(p);
+ if (num == 0 || num > ret)
+ num = ret;
+
+ memcpy(ptr, p, (ret = num));
+ }
+ break;
+ case BIO_C_SET_NBIO:
+ if (!BIO_socket_nbio(b->num, num != 0))
+ ret = 0;
+ break;
case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
- memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));
+ data->next_timeout = ossl_time_from_timeval(*(struct timeval *)ptr);
break;
# if defined(SO_RCVTIMEO)
case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
{
struct timeval *tv = (struct timeval *)ptr;
int timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;
- if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
- (void *)&timeout, sizeof(timeout)) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+
+ if ((ret = setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
+ (void *)&timeout, sizeof(timeout))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
}
# else
- if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr,
- sizeof(struct timeval)) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+ if ((ret = setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr,
+ sizeof(struct timeval))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# endif
break;
case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT:
struct timeval *tv = (struct timeval *)ptr;
sz = sizeof(timeout);
- if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
- (void *)&timeout, &sz) < 0) {
- perror("getsockopt");
- ret = -1;
+ if ((ret = getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
+ (void *)&timeout, &sz)) < 0) {
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling getsockopt()");
} else {
tv->tv_sec = timeout / 1000;
tv->tv_usec = (timeout % 1000) * 1000;
}
# else
socklen_t sz = sizeof(struct timeval);
- if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
- ptr, &sz) < 0) {
- perror("getsockopt");
- ret = -1;
+ if ((ret = getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
+ ptr, &sz)) < 0) {
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling getsockopt()");
} else {
- OPENSSL_assert(sz <= sizeof(struct timeval));
+ OPENSSL_assert((size_t)sz <= sizeof(struct timeval));
ret = (int)sz;
}
# endif
{
struct timeval *tv = (struct timeval *)ptr;
int timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;
- if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
- (void *)&timeout, sizeof(timeout)) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+
+ if ((ret = setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
+ (void *)&timeout, sizeof(timeout))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
}
# else
- if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr,
- sizeof(struct timeval)) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+ if ((ret = setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr,
+ sizeof(struct timeval))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# endif
break;
case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT:
struct timeval *tv = (struct timeval *)ptr;
sz = sizeof(timeout);
- if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
- (void *)&timeout, &sz) < 0) {
- perror("getsockopt");
- ret = -1;
+ if ((ret = getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
+ (void *)&timeout, &sz)) < 0) {
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling getsockopt()");
} else {
tv->tv_sec = timeout / 1000;
tv->tv_usec = (timeout % 1000) * 1000;
}
# else
socklen_t sz = sizeof(struct timeval);
- if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
- ptr, &sz) < 0) {
- perror("getsockopt");
- ret = -1;
+
+ if ((ret = getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
+ ptr, &sz)) < 0) {
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling getsockopt()");
} else {
- OPENSSL_assert(sz <= sizeof(struct timeval));
+ OPENSSL_assert((size_t)sz <= sizeof(struct timeval));
ret = (int)sz;
}
# endif
break;
# endif
case BIO_CTRL_DGRAM_SET_DONT_FRAG:
- sockopt_val = num ? 1 : 0;
-
switch (data->peer.sa.sa_family) {
case AF_INET:
# if defined(IP_DONTFRAG)
+ sockopt_val = num ? 1 : 0;
if ((ret = setsockopt(b->num, IPPROTO_IP, IP_DONTFRAG,
- &sockopt_val, sizeof(sockopt_val))) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+ &sockopt_val, sizeof(sockopt_val))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# elif defined(OPENSSL_SYS_LINUX) && defined(IP_MTU_DISCOVER) && defined (IP_PMTUDISC_PROBE)
- if ((sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT),
- (ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
- &sockopt_val, sizeof(sockopt_val))) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+ sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT;
+ if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
+ &sockopt_val, sizeof(sockopt_val))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# elif defined(OPENSSL_SYS_WINDOWS) && defined(IP_DONTFRAGMENT)
+ sockopt_val = num ? 1 : 0;
if ((ret = setsockopt(b->num, IPPROTO_IP, IP_DONTFRAGMENT,
(const char *)&sockopt_val,
- sizeof(sockopt_val))) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+ sizeof(sockopt_val))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# else
ret = -1;
# endif
# if OPENSSL_USE_IPV6
case AF_INET6:
# if defined(IPV6_DONTFRAG)
+ sockopt_val = num ? 1 : 0;
if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_DONTFRAG,
(const void *)&sockopt_val,
- sizeof(sockopt_val))) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+ sizeof(sockopt_val))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
+
# elif defined(OPENSSL_SYS_LINUX) && defined(IPV6_MTUDISCOVER)
- if ((sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT),
- (ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
- &sockopt_val, sizeof(sockopt_val))) < 0) {
- perror("setsockopt");
- ret = -1;
- }
+ sockopt_val = num ? IP_PMTUDISC_PROBE : IP_PMTUDISC_DONT;
+ if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
+ &sockopt_val, sizeof(sockopt_val))) < 0)
+ ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
+ "calling setsockopt()");
# else
ret = -1;
# endif
case BIO_CTRL_DGRAM_SET_PEEK_MODE:
data->peekmode = (unsigned int)num;
break;
+
+ case BIO_CTRL_DGRAM_GET_LOCAL_ADDR_CAP:
+# if defined(SUPPORT_LOCAL_ADDR)
+ ret = 1;
+# else
+ ret = 0;
+# endif
+ break;
+
+ case BIO_CTRL_DGRAM_SET_LOCAL_ADDR_ENABLE:
+# if defined(SUPPORT_LOCAL_ADDR)
+ num = num > 0;
+ if (num != data->local_addr_enabled) {
+ if (enable_local_addr(b, num) < 1) {
+ ret = 0;
+ break;
+ }
+
+ data->local_addr_enabled = (char)num;
+ }
+# else
+ ret = 0;
+# endif
+ break;
+
+ case BIO_CTRL_DGRAM_GET_LOCAL_ADDR_ENABLE:
+ *(int *)ptr = data->local_addr_enabled;
+ break;
+
+ case BIO_CTRL_DGRAM_GET_EFFECTIVE_CAPS:
+ ret = (long)(BIO_DGRAM_CAP_HANDLES_DST_ADDR
+ | BIO_DGRAM_CAP_HANDLES_SRC_ADDR
+ | BIO_DGRAM_CAP_PROVIDES_DST_ADDR
+ | BIO_DGRAM_CAP_PROVIDES_SRC_ADDR);
+ break;
+
+ case BIO_CTRL_GET_RPOLL_DESCRIPTOR:
+ case BIO_CTRL_GET_WPOLL_DESCRIPTOR:
+ {
+ BIO_POLL_DESCRIPTOR *pd = ptr;
+
+ pd->type = BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD;
+ pd->value.fd = b->num;
+ }
+ break;
+
default:
ret = 0;
break;
}
+ /* Normalize if error */
+ if (ret < 0)
+ ret = -1;
return ret;
}
return ret;
}
+# if M_METHOD == M_METHOD_WSARECVMSG
+static void translate_msg_win(BIO *b, WSAMSG *mh, WSABUF *iov,
+ unsigned char *control, BIO_MSG *msg)
+{
+ iov->len = msg->data_len;
+ iov->buf = msg->data;
+
+ /* Windows requires namelen to be set exactly */
+ mh->name = msg->peer != NULL ? &msg->peer->sa : NULL;
+ if (msg->peer != NULL && dgram_get_sock_family(b) == AF_INET)
+ mh->namelen = sizeof(struct sockaddr_in);
+# if OPENSSL_USE_IPV6
+ else if (msg->peer != NULL && dgram_get_sock_family(b) == AF_INET6)
+ mh->namelen = sizeof(struct sockaddr_in6);
+# endif
+ else
+ mh->namelen = 0;
+
+ /*
+ * When local address reception (IP_PKTINFO, etc.) is enabled, on Windows
+ * this causes WSARecvMsg to fail if the control buffer is too small to hold
+ * the structure, or if no control buffer is passed. So we need to give it
+ * the control buffer even if we aren't actually going to examine the
+ * result.
+ */
+ mh->lpBuffers = iov;
+ mh->dwBufferCount = 1;
+ mh->Control.len = BIO_CMSG_ALLOC_LEN;
+ mh->Control.buf = control;
+ mh->dwFlags = 0;
+}
+# endif
+
+# if M_METHOD == M_METHOD_RECVMMSG || M_METHOD == M_METHOD_RECVMSG
+/* Translates a BIO_MSG to a msghdr and iovec. */
+static void translate_msg(BIO *b, struct msghdr *mh, struct iovec *iov,
+ unsigned char *control, BIO_MSG *msg)
+{
+ iov->iov_base = msg->data;
+ iov->iov_len = msg->data_len;
+
+ /* macOS requires msg_namelen be 0 if msg_name is NULL */
+ mh->msg_name = msg->peer != NULL ? &msg->peer->sa : NULL;
+ if (msg->peer != NULL && dgram_get_sock_family(b) == AF_INET)
+ mh->msg_namelen = sizeof(struct sockaddr_in);
+# if OPENSSL_USE_IPV6
+ else if (msg->peer != NULL && dgram_get_sock_family(b) == AF_INET6)
+ mh->msg_namelen = sizeof(struct sockaddr_in6);
+# endif
+ else
+ mh->msg_namelen = 0;
+
+ mh->msg_iov = iov;
+ mh->msg_iovlen = 1;
+ mh->msg_control = msg->local != NULL ? control : NULL;
+ mh->msg_controllen = msg->local != NULL ? BIO_CMSG_ALLOC_LEN : 0;
+ mh->msg_flags = 0;
+}
+# endif
+
+# if M_METHOD == M_METHOD_RECVMMSG || M_METHOD == M_METHOD_RECVMSG || M_METHOD == M_METHOD_WSARECVMSG
+/* Extracts destination address from the control buffer. */
+static int extract_local(BIO *b, MSGHDR_TYPE *mh, BIO_ADDR *local) {
+# if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR) || defined(IPV6_PKTINFO)
+ CMSGHDR_TYPE *cmsg;
+ int af = dgram_get_sock_family(b);
+
+ for (cmsg = BIO_CMSG_FIRSTHDR(mh); cmsg != NULL;
+ cmsg = BIO_CMSG_NXTHDR(mh, cmsg)) {
+ if (af == AF_INET) {
+ if (cmsg->cmsg_level != IPPROTO_IP)
+ continue;
+
+# if defined(IP_PKTINFO)
+ if (cmsg->cmsg_type != IP_PKTINFO)
+ continue;
+
+ local->s_in.sin_addr =
+ ((struct in_pktinfo *)BIO_CMSG_DATA(cmsg))->ipi_addr;
+
+# elif defined(IP_RECVDSTADDR)
+ if (cmsg->cmsg_type != IP_RECVDSTADDR)
+ continue;
+
+ local->s_in.sin_addr = *(struct in_addr *)BIO_CMSG_DATA(cmsg);
+# endif
+
+# if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
+ {
+ bio_dgram_data *data = b->ptr;
+
+ local->s_in.sin_family = AF_INET;
+ local->s_in.sin_port = data->local_addr.s_in.sin_port;
+ }
+ return 1;
+# endif
+ }
+# if OPENSSL_USE_IPV6
+ else if (af == AF_INET6) {
+ if (cmsg->cmsg_level != IPPROTO_IPV6)
+ continue;
+
+# if defined(IPV6_RECVPKTINFO)
+ if (cmsg->cmsg_type != IPV6_PKTINFO)
+ continue;
+
+ {
+ bio_dgram_data *data = b->ptr;
+
+ local->s_in6.sin6_addr =
+ ((struct in6_pktinfo *)BIO_CMSG_DATA(cmsg))->ipi6_addr;
+ local->s_in6.sin6_family = AF_INET6;
+ local->s_in6.sin6_port = data->local_addr.s_in6.sin6_port;
+ local->s_in6.sin6_scope_id =
+ data->local_addr.s_in6.sin6_scope_id;
+ local->s_in6.sin6_flowinfo = 0;
+ }
+ return 1;
+# endif
+ }
+# endif
+ }
+# endif
+
+ return 0;
+}
+
+static int pack_local(BIO *b, MSGHDR_TYPE *mh, const BIO_ADDR *local) {
+ int af = dgram_get_sock_family(b);
+# if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR) || defined(IPV6_PKTINFO)
+ CMSGHDR_TYPE *cmsg;
+ bio_dgram_data *data = b->ptr;
+# endif
+
+ if (af == AF_INET) {
+# if defined(IP_PKTINFO)
+ struct in_pktinfo *info;
+
+# if defined(OPENSSL_SYS_WINDOWS)
+ cmsg = (CMSGHDR_TYPE *)mh->Control.buf;
+# else
+ cmsg = (CMSGHDR_TYPE *)mh->msg_control;
+# endif
+
+ cmsg->cmsg_len = BIO_CMSG_LEN(sizeof(struct in_pktinfo));
+ cmsg->cmsg_level = IPPROTO_IP;
+ cmsg->cmsg_type = IP_PKTINFO;
+
+ info = (struct in_pktinfo *)BIO_CMSG_DATA(cmsg);
+# if !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_CYGWIN) && !defined(__FreeBSD__)
+ info->ipi_spec_dst = local->s_in.sin_addr;
+# endif
+ info->ipi_addr.s_addr = 0;
+ info->ipi_ifindex = 0;
+
+ /*
+ * We cannot override source port using this API, therefore
+ * ensure the application specified a source port of 0
+ * or the one we are bound to. (Better to error than silently
+ * ignore this.)
+ */
+ if (local->s_in.sin_port != 0
+ && data->local_addr.s_in.sin_port != local->s_in.sin_port) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_PORT_MISMATCH);
+ return 0;
+ }
+
+# if defined(OPENSSL_SYS_WINDOWS)
+ mh->Control.len = BIO_CMSG_SPACE(sizeof(struct in_pktinfo));
+# else
+ mh->msg_controllen = BIO_CMSG_SPACE(sizeof(struct in_pktinfo));
+# endif
+ return 1;
+
+# elif defined(IP_SENDSRCADDR)
+ struct in_addr *info;
+
+ /*
+ * At least FreeBSD is very pedantic about using IP_SENDSRCADDR when we
+ * are not bound to 0.0.0.0 or ::, even if the address matches what we
+ * bound to. Support this by not packing the structure if the address
+ * matches our understanding of our local address. IP_SENDSRCADDR is a
+ * BSD thing, so we don't need an explicit test for BSD here.
+ */
+ if (local->s_in.sin_addr.s_addr == data->local_addr.s_in.sin_addr.s_addr) {
+ mh->msg_control = NULL;
+ mh->msg_controllen = 0;
+ return 1;
+ }
+
+ cmsg = (struct cmsghdr *)mh->msg_control;
+ cmsg->cmsg_len = BIO_CMSG_LEN(sizeof(struct in_addr));
+ cmsg->cmsg_level = IPPROTO_IP;
+ cmsg->cmsg_type = IP_SENDSRCADDR;
+
+ info = (struct in_addr *)BIO_CMSG_DATA(cmsg);
+ *info = local->s_in.sin_addr;
+
+ /* See comment above. */
+ if (local->s_in.sin_port != 0
+ && data->local_addr.s_in.sin_port != local->s_in.sin_port) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_PORT_MISMATCH);
+ return 0;
+ }
+
+ mh->msg_controllen = BIO_CMSG_SPACE(sizeof(struct in_addr));
+ return 1;
+# endif
+ }
+# if OPENSSL_USE_IPV6
+ else if (af == AF_INET6) {
+# if defined(IPV6_PKTINFO)
+ struct in6_pktinfo *info;
+
+# if defined(OPENSSL_SYS_WINDOWS)
+ cmsg = (CMSGHDR_TYPE *)mh->Control.buf;
+# else
+ cmsg = (CMSGHDR_TYPE *)mh->msg_control;
+# endif
+ cmsg->cmsg_len = BIO_CMSG_LEN(sizeof(struct in6_pktinfo));
+ cmsg->cmsg_level = IPPROTO_IPV6;
+ cmsg->cmsg_type = IPV6_PKTINFO;
+
+ info = (struct in6_pktinfo *)BIO_CMSG_DATA(cmsg);
+ info->ipi6_addr = local->s_in6.sin6_addr;
+ info->ipi6_ifindex = 0;
+
+ /*
+ * See comment above, but also applies to the other fields
+ * in sockaddr_in6.
+ */
+ if (local->s_in6.sin6_port != 0
+ && data->local_addr.s_in6.sin6_port != local->s_in6.sin6_port) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_PORT_MISMATCH);
+ return 0;
+ }
+
+ if (local->s_in6.sin6_scope_id != 0
+ && data->local_addr.s_in6.sin6_scope_id != local->s_in6.sin6_scope_id) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_PORT_MISMATCH);
+ return 0;
+ }
+
+# if defined(OPENSSL_SYS_WINDOWS)
+ mh->Control.len = BIO_CMSG_SPACE(sizeof(struct in6_pktinfo));
+# else
+ mh->msg_controllen = BIO_CMSG_SPACE(sizeof(struct in6_pktinfo));
+# endif
+ return 1;
+# endif
+ }
+# endif
+
+ return 0;
+}
+# endif
+
+/*
+ * Converts flags passed to BIO_sendmmsg or BIO_recvmmsg to syscall flags. You
+ * should mask out any system flags returned by this function you cannot support
+ * in a particular circumstance. Currently no flags are defined.
+ */
+# if M_METHOD != M_METHOD_NONE
+static int translate_flags(uint64_t flags) {
+ return 0;
+}
+# endif
+
+static int dgram_sendmmsg(BIO *b, BIO_MSG *msg, size_t stride,
+ size_t num_msg, uint64_t flags, size_t *num_processed)
+{
+# if M_METHOD != M_METHOD_NONE && M_METHOD != M_METHOD_RECVMSG
+ int ret;
+# endif
+# if M_METHOD == M_METHOD_RECVMMSG
+# define BIO_MAX_MSGS_PER_CALL 64
+ int sysflags;
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ size_t i;
+ struct mmsghdr mh[BIO_MAX_MSGS_PER_CALL];
+ struct iovec iov[BIO_MAX_MSGS_PER_CALL];
+ unsigned char control[BIO_MAX_MSGS_PER_CALL][BIO_CMSG_ALLOC_LEN];
+ int have_local_enabled = data->local_addr_enabled;
+# elif M_METHOD == M_METHOD_RECVMSG
+ int sysflags;
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ ossl_ssize_t l;
+ struct msghdr mh;
+ struct iovec iov;
+ unsigned char control[BIO_CMSG_ALLOC_LEN];
+ int have_local_enabled = data->local_addr_enabled;
+# elif M_METHOD == M_METHOD_WSARECVMSG
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ int have_local_enabled = data->local_addr_enabled;
+ WSAMSG wmsg;
+ WSABUF wbuf;
+ DWORD num_bytes_sent = 0;
+ unsigned char control[BIO_CMSG_ALLOC_LEN];
+# endif
+# if M_METHOD == M_METHOD_RECVFROM || M_METHOD == M_METHOD_WSARECVMSG
+ int sysflags;
+# endif
+
+ if (num_msg == 0) {
+ *num_processed = 0;
+ return 1;
+ }
+
+ if (num_msg > OSSL_SSIZE_MAX)
+ num_msg = OSSL_SSIZE_MAX;
+
+# if M_METHOD != M_METHOD_NONE
+ sysflags = translate_flags(flags);
+# endif
+
+# if M_METHOD == M_METHOD_RECVMMSG
+ /*
+ * In the sendmmsg/recvmmsg case, we need to allocate our translated struct
+ * msghdr and struct iovec on the stack to support multithreaded use. Thus
+ * we place a fixed limit on the number of messages per call, in the
+ * expectation that we will be called again if there were more messages to
+ * be sent.
+ */
+ if (num_msg > BIO_MAX_MSGS_PER_CALL)
+ num_msg = BIO_MAX_MSGS_PER_CALL;
+
+ for (i = 0; i < num_msg; ++i) {
+ translate_msg(b, &mh[i].msg_hdr, &iov[i],
+ control[i], &BIO_MSG_N(msg, stride, i));
+
+ /* If local address was requested, it must have been enabled */
+ if (BIO_MSG_N(msg, stride, i).local != NULL) {
+ if (!have_local_enabled) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+
+ if (pack_local(b, &mh[i].msg_hdr,
+ BIO_MSG_N(msg, stride, i).local) < 1) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+ }
+ }
+
+ /* Do the batch */
+ ret = sendmmsg(b->num, mh, num_msg, sysflags);
+ if (ret < 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ *num_processed = 0;
+ return 0;
+ }
+
+ for (i = 0; i < (size_t)ret; ++i) {
+ BIO_MSG_N(msg, stride, i).data_len = mh[i].msg_len;
+ BIO_MSG_N(msg, stride, i).flags = 0;
+ }
+
+ *num_processed = (size_t)ret;
+ return 1;
+
+# elif M_METHOD == M_METHOD_RECVMSG
+ /*
+ * If sendmsg is available, use it.
+ */
+ translate_msg(b, &mh, &iov, control, msg);
+
+ if (msg->local != NULL) {
+ if (!have_local_enabled) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+
+ if (pack_local(b, &mh, msg->local) < 1) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+ }
+
+ l = sendmsg(b->num, &mh, sysflags);
+ if (l < 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ *num_processed = 0;
+ return 0;
+ }
+
+ msg->data_len = (size_t)l;
+ msg->flags = 0;
+ *num_processed = 1;
+ return 1;
+
+# elif M_METHOD == M_METHOD_WSARECVMSG || M_METHOD == M_METHOD_RECVFROM
+# if M_METHOD == M_METHOD_WSARECVMSG
+ if (bio_WSASendMsg != NULL) {
+ /* WSASendMsg-based implementation for Windows. */
+ translate_msg_win(b, &wmsg, &wbuf, control, msg);
+
+ if (msg[0].local != NULL) {
+ if (!have_local_enabled) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+
+ if (pack_local(b, &wmsg, msg[0].local) < 1) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+ }
+
+ ret = WSASendMsg((SOCKET)b->num, &wmsg, 0, &num_bytes_sent, NULL, NULL);
+ if (ret < 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ *num_processed = 0;
+ return 0;
+ }
+
+ msg[0].data_len = num_bytes_sent;
+ msg[0].flags = 0;
+ *num_processed = 1;
+ return 1;
+ }
+# endif
+
+ /*
+ * Fallback to sendto and send a single message.
+ */
+ if (msg[0].local != NULL) {
+ /*
+ * We cannot set the local address if using sendto
+ * so fail in this case
+ */
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+
+ ret = sendto(b->num, msg[0].data,
+# if defined(OPENSSL_SYS_WINDOWS)
+ (int)msg[0].data_len,
+# else
+ msg[0].data_len,
+# endif
+ sysflags,
+ msg[0].peer != NULL ? BIO_ADDR_sockaddr(msg[0].peer) : NULL,
+ msg[0].peer != NULL ? BIO_ADDR_sockaddr_size(msg[0].peer) : 0);
+ if (ret <= 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ *num_processed = 0;
+ return 0;
+ }
+
+ msg[0].data_len = ret;
+ msg[0].flags = 0;
+ *num_processed = 1;
+ return 1;
+
+# else
+ ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
+ *num_processed = 0;
+ return 0;
+# endif
+}
+
+static int dgram_recvmmsg(BIO *b, BIO_MSG *msg,
+ size_t stride, size_t num_msg,
+ uint64_t flags, size_t *num_processed)
+{
+# if M_METHOD != M_METHOD_NONE && M_METHOD != M_METHOD_RECVMSG
+ int ret;
+# endif
+# if M_METHOD == M_METHOD_RECVMMSG
+ int sysflags;
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ size_t i;
+ struct mmsghdr mh[BIO_MAX_MSGS_PER_CALL];
+ struct iovec iov[BIO_MAX_MSGS_PER_CALL];
+ unsigned char control[BIO_MAX_MSGS_PER_CALL][BIO_CMSG_ALLOC_LEN];
+ int have_local_enabled = data->local_addr_enabled;
+# elif M_METHOD == M_METHOD_RECVMSG
+ int sysflags;
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ ossl_ssize_t l;
+ struct msghdr mh;
+ struct iovec iov;
+ unsigned char control[BIO_CMSG_ALLOC_LEN];
+ int have_local_enabled = data->local_addr_enabled;
+# elif M_METHOD == M_METHOD_WSARECVMSG
+ bio_dgram_data *data = (bio_dgram_data *)b->ptr;
+ int have_local_enabled = data->local_addr_enabled;
+ WSAMSG wmsg;
+ WSABUF wbuf;
+ DWORD num_bytes_received = 0;
+ unsigned char control[BIO_CMSG_ALLOC_LEN];
+# endif
+# if M_METHOD == M_METHOD_RECVFROM || M_METHOD == M_METHOD_WSARECVMSG
+ int sysflags;
+ socklen_t slen;
+# endif
+
+ if (num_msg == 0) {
+ *num_processed = 0;
+ return 1;
+ }
+
+ if (num_msg > OSSL_SSIZE_MAX)
+ num_msg = OSSL_SSIZE_MAX;
+
+# if M_METHOD != M_METHOD_NONE
+ sysflags = translate_flags(flags);
+# endif
+
+# if M_METHOD == M_METHOD_RECVMMSG
+ /*
+ * In the sendmmsg/recvmmsg case, we need to allocate our translated struct
+ * msghdr and struct iovec on the stack to support multithreaded use. Thus
+ * we place a fixed limit on the number of messages per call, in the
+ * expectation that we will be called again if there were more messages to
+ * be sent.
+ */
+ if (num_msg > BIO_MAX_MSGS_PER_CALL)
+ num_msg = BIO_MAX_MSGS_PER_CALL;
+
+ for (i = 0; i < num_msg; ++i) {
+ translate_msg(b, &mh[i].msg_hdr, &iov[i],
+ control[i], &BIO_MSG_N(msg, stride, i));
+
+ /* If local address was requested, it must have been enabled */
+ if (BIO_MSG_N(msg, stride, i).local != NULL && !have_local_enabled) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+ }
+
+ /* Do the batch */
+ ret = recvmmsg(b->num, mh, num_msg, sysflags, NULL);
+ if (ret < 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ *num_processed = 0;
+ return 0;
+ }
+
+ for (i = 0; i < (size_t)ret; ++i) {
+ BIO_MSG_N(msg, stride, i).data_len = mh[i].msg_len;
+ BIO_MSG_N(msg, stride, i).flags = 0;
+ /*
+ * *(msg->peer) will have been filled in by recvmmsg;
+ * for msg->local we parse the control data returned
+ */
+ if (BIO_MSG_N(msg, stride, i).local != NULL)
+ if (extract_local(b, &mh[i].msg_hdr,
+ BIO_MSG_N(msg, stride, i).local) < 1)
+ /*
+ * It appears BSDs do not support local addresses for
+ * loopback sockets. In this case, just clear the local
+ * address, as for OS X and Windows in some circumstances
+ * (see below).
+ */
+ BIO_ADDR_clear(msg->local);
+ }
+
+ *num_processed = (size_t)ret;
+ return 1;
+
+# elif M_METHOD == M_METHOD_RECVMSG
+ /*
+ * If recvmsg is available, use it.
+ */
+ translate_msg(b, &mh, &iov, control, msg);
+
+ /* If local address was requested, it must have been enabled */
+ if (msg->local != NULL && !have_local_enabled) {
+ /*
+ * If we have done at least one message, we must return the
+ * count; if we haven't done any, we can give an error code
+ */
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+
+ l = recvmsg(b->num, &mh, sysflags);
+ if (l < 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ *num_processed = 0;
+ return 0;
+ }
+
+ msg->data_len = (size_t)l;
+ msg->flags = 0;
+
+ if (msg->local != NULL)
+ if (extract_local(b, &mh, msg->local) < 1)
+ /*
+ * OS X exhibits odd behaviour where it appears that if a packet is
+ * sent before the receiving interface enables IP_PKTINFO, it will
+ * sometimes not have any control data returned even if the
+ * receiving interface enables IP_PKTINFO before calling recvmsg().
+ * This appears to occur non-deterministically. Presumably, OS X
+ * handles IP_PKTINFO at the time the packet is enqueued into a
+ * socket's receive queue, rather than at the time recvmsg() is
+ * called, unlike most other operating systems. Thus (if this
+ * hypothesis is correct) there is a race between where IP_PKTINFO
+ * is enabled by the process and when the kernel's network stack
+ * queues the incoming message.
+ *
+ * We cannot return the local address if we do not have it, but this
+ * is not a caller error either, so just return a zero address
+ * structure. This is similar to how we handle Windows loopback
+ * interfaces (see below). We enable this workaround for all
+ * platforms, not just Apple, as this kind of quirk in OS networking
+ * stacks seems to be common enough that failing hard if a local
+ * address is not provided appears to be too brittle.
+ */
+ BIO_ADDR_clear(msg->local);
+
+ *num_processed = 1;
+ return 1;
+
+# elif M_METHOD == M_METHOD_RECVFROM || M_METHOD == M_METHOD_WSARECVMSG
+# if M_METHOD == M_METHOD_WSARECVMSG
+ if (bio_WSARecvMsg != NULL) {
+ /* WSARecvMsg-based implementation for Windows. */
+ translate_msg_win(b, &wmsg, &wbuf, control, msg);
+
+ /* If local address was requested, it must have been enabled */
+ if (msg[0].local != NULL && !have_local_enabled) {
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+
+ ret = WSARecvMsg((SOCKET)b->num, &wmsg, &num_bytes_received, NULL, NULL);
+ if (ret < 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ *num_processed = 0;
+ return 0;
+ }
+
+ msg[0].data_len = num_bytes_received;
+ msg[0].flags = 0;
+ if (msg[0].local != NULL)
+ if (extract_local(b, &wmsg, msg[0].local) < 1)
+ /*
+ * On Windows, loopback is not a "proper" interface and it works
+ * differently; packets are essentially short-circuited and
+ * don't go through all of the normal processing. A consequence
+ * of this is that packets sent from the local machine to the
+ * local machine _will not have IP_PKTINFO_ even if the
+ * IP_PKTINFO socket option is enabled. WSARecvMsg just sets
+ * Control.len to 0 on returning.
+ *
+ * This applies regardless of whether the loopback address,
+ * 127.0.0.1 is used, or a local interface address (e.g.
+ * 192.168.1.1); in both cases IP_PKTINFO will not be present.
+ *
+ * We report this condition by setting the local BIO_ADDR's
+ * family to 0.
+ */
+ BIO_ADDR_clear(msg[0].local);
+
+ *num_processed = 1;
+ return 1;
+ }
+# endif
+
+ /*
+ * Fallback to recvfrom and receive a single message.
+ */
+ if (msg[0].local != NULL) {
+ /*
+ * We cannot determine the local address if using recvfrom
+ * so fail in this case
+ */
+ ERR_raise(ERR_LIB_BIO, BIO_R_LOCAL_ADDR_NOT_AVAILABLE);
+ *num_processed = 0;
+ return 0;
+ }
+
+ slen = sizeof(*msg[0].peer);
+ ret = recvfrom(b->num, msg[0].data,
+# if defined(OPENSSL_SYS_WINDOWS)
+ (int)msg[0].data_len,
+# else
+ msg[0].data_len,
+# endif
+ sysflags,
+ msg[0].peer != NULL ? &msg[0].peer->sa : NULL,
+ msg[0].peer != NULL ? &slen : NULL);
+ if (ret <= 0) {
+ ERR_raise(ERR_LIB_SYS, get_last_socket_error());
+ return 0;
+ }
+
+ msg[0].data_len = ret;
+ msg[0].flags = 0;
+ *num_processed = 1;
+ return 1;
+
+# else
+ ERR_raise(ERR_LIB_BIO, BIO_R_UNSUPPORTED_METHOD);
+ *num_processed = 0;
+ return 0;
+# endif
+}
+
# ifndef OPENSSL_NO_SCTP
const BIO_METHOD *BIO_s_datagram_sctp(void)
{
bi->init = 0;
bi->num = 0;
- if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL)
return 0;
- }
# ifdef SCTP_PR_SCTP_NONE
data->prinfo.pr_policy = SCTP_PR_SCTP_NONE;
# endif
if (ret < 0) {
if (BIO_dgram_should_retry(ret)) {
BIO_set_retry_read(b);
- data->_errno = get_last_socket_error();
+ data->dgram._errno = get_last_socket_error();
}
}
optlen =
(socklen_t) (sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
authchunks = OPENSSL_malloc(optlen);
- if (authchunks == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (authchunks == NULL)
return -1;
- }
memset(authchunks, 0, optlen);
ii = getsockopt(b->num, IPPROTO_SCTP, SCTP_PEER_AUTH_CHUNKS,
authchunks, &optlen);
if (ret <= 0) {
if (BIO_dgram_should_retry(ret)) {
BIO_set_retry_write(b);
- data->_errno = get_last_socket_error();
+ data->dgram._errno = get_last_socket_error();
}
}
return ret;
* Set to maximum (2^14) and ignore user input to enable transport
* protocol fragmentation. Returns always 2^14.
*/
- data->mtu = 16384;
- ret = data->mtu;
+ data->dgram.mtu = 16384;
+ ret = data->dgram.mtu;
break;
case BIO_CTRL_DGRAM_SET_MTU:
/*
* Set to maximum (2^14) and ignore input to enable transport
* protocol fragmentation. Returns always 2^14.
*/
- data->mtu = 16384;
- ret = data->mtu;
+ data->dgram.mtu = 16384;
+ ret = data->dgram.mtu;
break;
case BIO_CTRL_DGRAM_SET_CONNECTED:
case BIO_CTRL_DGRAM_CONNECT:
return 0;
}
-static void get_current_time(struct timeval *t)
-{
-# if defined(_WIN32)
- SYSTEMTIME st;
- unsigned __int64 now_ul;
- FILETIME now_ft;
-
- GetSystemTime(&st);
- SystemTimeToFileTime(&st, &now_ft);
- now_ul = ((unsigned __int64)now_ft.dwHighDateTime << 32) | now_ft.dwLowDateTime;
-# ifdef __MINGW32__
- now_ul -= 116444736000000000ULL;
-# else
- now_ul -= 116444736000000000UI64; /* re-bias to 1/1/1970 */
-# endif
- t->tv_sec = (long)(now_ul / 10000000);
- t->tv_usec = ((int)(now_ul % 10000000)) / 10;
-# else
- gettimeofday(t, NULL);
-# endif
-}
-
#endif
projects / thirdparty / openssl.git / blobdiff