25#include <freeradius-devel/bio/fd_priv.h>
26#include <freeradius-devel/bio/null.h>
33# define SOL_IP IPPROTO_IP
47# ifdef IPV6_RECVPKTINFO
48# include <linux/version.h>
49# if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14)
50# ifdef IPV6_2292PKTINFO
51# undef IPV6_RECVPKTINFO
53# define IPV6_RECVPKTINFO IPV6_2292PKTINFO
54# define IPV6_PKTINFO IPV6_2292PKTINFO
58# elif defined(IPV6_2292PKTINFO)
59# define IPV6_RECVPKTINFO IPV6_2292PKTINFO
72# if !defined(IPV6_RECVPKTINFO) && defined(IPV6_PKTINFO)
73# define IPV6_RECVPKTINFO IPV6_PKTINFO
79# elif !defined(IPV6_PKTINFO)
80# undef IPV6_RECVPKTINFO
84#define ADDR_INIT do { \
85 addr->when = fr_time(); \
86 addr->socket.type = my->info.socket.type; \
87 addr->socket.fd = -1; \
88 addr->socket.inet.ifindex = my->info.socket.inet.ifindex; \
104 if (
my->connect.el) {
106 my->connect.el = NULL;
109 if (
my->cb.shutdown)
my->cb.shutdown(&
my->bio);
133 my->info.write_blocked =
false;
150 rcode = read(
my->info.socket.fd,
buffer, size);
174 struct sockaddr_storage sockaddr;
176#ifdef STATIC_ANALYZER
177 sockaddr = (
struct sockaddr_storage) {};
181 salen =
sizeof(sockaddr);
183 rcode = recvfrom(
my->info.socket.fd,
buffer, size, 0, (
struct sockaddr *) &sockaddr, &salen);
186 fr_assert(sockaddr.ss_family ==
my->remote_sockaddr.ss_family);
187 fr_assert((sockaddr.ss_family == AF_INET) || (sockaddr.ss_family == AF_INET6));
193 if (rcode == 0)
return rcode;
208 struct sockaddr_storage sockaddr;
211 salen =
sizeof(sockaddr);
213 rcode = recvfrom(
my->info.socket.fd,
buffer, size, 0, (
struct sockaddr *) &sockaddr, &salen);
219 addr->
socket.inet.dst_ipaddr =
my->info.socket.inet.src_ipaddr;
220 addr->
socket.inet.dst_port =
my->info.socket.inet.src_port;
226 if (rcode == 0)
return rcode;
263 rcode = write(
my->info.socket.fd,
buffer, size);
280 struct sockaddr_storage sockaddr;
291 rcode = sendto(
my->info.socket.fd,
buffer, size, 0, (
struct sockaddr *) &sockaddr, salen);
299#if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR) || defined(IPV6_PKTINFO)
304 struct sockaddr_storage from;
307#ifdef STATIC_ANALYZER
308 from.ss_family = AF_UNSPEC;
311 memset(&
my->cbuf, 0,
sizeof(
my->cbuf));
312 memset(&
my->msgh, 0,
sizeof(
struct msghdr));
314 my->iov = (
struct iovec) {
319 my->msgh = (
struct msghdr) {
320 .msg_control =
my->cbuf,
321 .msg_controllen =
sizeof(
my->cbuf),
323 .msg_namelen =
sizeof(from),
330 rcode = recvmsg(
my->info.socket.fd, &
my->msgh, 0);
335 &from,
my->msgh.msg_namelen);
338 if (rcode == 0)
return rcode;
346#if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
353 struct cmsghdr *cmsg;
358 rcode = fd_fd_recvfromto_common(
my, packet_ctx,
buffer, size);
359 if (rcode <= 0)
return rcode;
363 for (cmsg = CMSG_FIRSTHDR(&
my->msgh);
365 cmsg = CMSG_NXTHDR(&
my->msgh, cmsg)) {
369 if ((cmsg->cmsg_level ==
SOL_IP) &&
370 (cmsg->cmsg_type == IP_PKTINFO)) {
371 struct in_pktinfo *i = (
struct in_pktinfo *) CMSG_DATA(cmsg);
372 struct sockaddr_in to;
374 to.sin_addr = i->ipi_addr;
377 (
struct sockaddr_storage *) &to,
sizeof(
struct sockaddr_in));
378 addr->
socket.inet.ifindex = i->ipi_ifindex;
384 if ((cmsg->cmsg_level == IPPROTO_IP) &&
385 (cmsg->cmsg_type == IP_RECVDSTADDR)) {
386 struct in_addr *i = (
struct in_addr *) CMSG_DATA(cmsg);
387 struct sockaddr_in to;
391 (
struct sockaddr_storage *) &to,
sizeof(
struct sockaddr_in));
397 if ((cmsg->cmsg_level ==
SOL_IP) && (cmsg->cmsg_type == SO_TIMESTAMPNS)) {
401#elif defined(SO_TIMESTAMP)
402 if ((cmsg->cmsg_level ==
SOL_IP) && (cmsg->cmsg_type == SO_TIMESTAMP)) {
417static
ssize_t fr_bio_fd_sendfromto4(
fr_bio_t *bio,
void *packet_ctx, const
void *
buffer,
size_t size)
421 struct cmsghdr *cmsg;
422 struct sockaddr_storage to;
427 memset(&
my->cbuf, 0,
sizeof(
my->cbuf));
428 memset(&
my->msgh, 0,
sizeof(
struct msghdr));
432 my->iov = (
struct iovec) {
437 my->msgh = (
struct msghdr) {
438 .msg_control =
my->cbuf,
441 .msg_namelen = to_len,
449 struct in_pktinfo *pkt;
451 my->msgh.msg_controllen = CMSG_SPACE(
sizeof(*pkt));
453 cmsg = CMSG_FIRSTHDR(&
my->msgh);
454 cmsg->cmsg_level =
SOL_IP;
455 cmsg->cmsg_type = IP_PKTINFO;
456 cmsg->cmsg_len = CMSG_LEN(
sizeof(*pkt));
458 pkt = (
struct in_pktinfo *) CMSG_DATA(cmsg);
459 memset(pkt, 0,
sizeof(*pkt));
460 pkt->ipi_spec_dst = addr->
socket.inet.src_ipaddr.addr.v4;
461 pkt->ipi_ifindex = addr->
socket.inet.ifindex;
463#elif defined(IP_SENDSRCADDR)
466 my->msgh.msg_controllen = CMSG_SPACE(
sizeof(*
in));
468 cmsg = CMSG_FIRSTHDR(&
my->msgh);
469 cmsg->cmsg_level = IPPROTO_IP;
470 cmsg->cmsg_type = IP_SENDSRCADDR;
471 cmsg->cmsg_len = CMSG_LEN(
sizeof(*
in));
473 in = (
struct in_addr *) CMSG_DATA(cmsg);
474 *
in = addr->
socket.inet.src_ipaddr.addr.v4;
479 rcode = sendmsg(
my->info.socket.fd, &
my->msgh, 0);
486static inline int fr_bio_fd_udpfromto_init4(
int fd)
488 int proto = 0, flag = 0, opt = 1;
490#ifdef HAVE_IP_PKTINFO
497#elif defined(IP_RECVDSTADDR)
503 flag = IP_RECVDSTADDR;
506 return setsockopt(fd, proto, flag, &opt,
sizeof(opt));
510#if defined(IPV6_PKTINFO)
516 struct cmsghdr *cmsg;
521 rcode = fd_fd_recvfromto_common(
my, packet_ctx,
buffer, size);
522 if (rcode <= 0)
return rcode;
526 for (cmsg = CMSG_FIRSTHDR(&
my->msgh);
528 cmsg = CMSG_NXTHDR(&
my->msgh, cmsg)) {
531 if ((cmsg->cmsg_level == IPPROTO_IPV6) &&
532 (cmsg->cmsg_type == IPV6_PKTINFO)) {
533 struct in6_pktinfo *i = (
struct in6_pktinfo *) CMSG_DATA(cmsg);
534 struct sockaddr_in6 to;
536 to.sin6_addr = i->ipi6_addr;
539 (
struct sockaddr_storage *) &to,
sizeof(
struct sockaddr_in6));
540 addr->
socket.inet.ifindex = i->ipi6_ifindex;
545 if ((cmsg->cmsg_level ==
SOL_IP) && (cmsg->cmsg_type == SO_TIMESTAMPNS)) {
549#elif defined(SO_TIMESTAMP)
550 if ((cmsg->cmsg_level ==
SOL_IP) && (cmsg->cmsg_type == SO_TIMESTAMP)) {
565static
ssize_t fr_bio_fd_sendfromto6(
fr_bio_t *bio,
void *packet_ctx, const
void *
buffer,
size_t size)
569 struct cmsghdr *cmsg;
570 struct sockaddr_storage to;
575 memset(&
my->cbuf, 0,
sizeof(
my->cbuf));
576 memset(&
my->msgh, 0,
sizeof(
struct msghdr));
580 my->iov = (
struct iovec) {
585 my->msgh = (
struct msghdr) {
586 .msg_control =
my->cbuf,
589 .msg_namelen = to_len,
596 struct in6_pktinfo *pkt;
598 my->msgh.msg_controllen = CMSG_SPACE(
sizeof(*pkt));
600 cmsg = CMSG_FIRSTHDR(&
my->msgh);
601 cmsg->cmsg_level = IPPROTO_IPV6;
602 cmsg->cmsg_type = IPV6_PKTINFO;
603 cmsg->cmsg_len = CMSG_LEN(
sizeof(*pkt));
605 pkt = (
struct in6_pktinfo *) CMSG_DATA(cmsg);
606 memset(pkt, 0,
sizeof(*pkt));
607 pkt->ipi6_addr = addr->
socket.inet.src_ipaddr.addr.v6;
608 pkt->ipi6_ifindex = addr->
socket.inet.ifindex;
612 rcode = sendmsg(
my->info.socket.fd, &
my->msgh, 0);
620static inline int fr_bio_fd_udpfromto_init6(
int fd)
624 return setsockopt(fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &opt,
sizeof(opt));
632 len = strlen(filename);
633 if (len >=
sizeof(sun->sun_path)) {
634 fr_strerror_const(
"Failed parsing unix domain socket filename: Name is too long");
638 sun->sun_family = AF_LOCAL;
639 memcpy(sun->sun_path, filename, len + 1);
641 *sunlen = SUN_LEN(sun);
649 struct sockaddr_storage salocal;
655 (
my->info.socket.inet.src_port != 0)) {
664 salen =
sizeof(salocal);
665 memset(&salocal, 0, salen);
666 if (getsockname(
my->info.socket.fd, (
struct sockaddr *) &salocal, &salen) < 0) {
674 my->info.socket.inet.ifindex =
my->info.socket.inet.src_ipaddr.scope_id;
682 my->info.eof =
false;
683 my->info.read_blocked =
false;
684 my->info.write_blocked =
false;
689 if (
my->cb.connected)
my->cb.connected(&
my->bio);
706 if (
my->info.socket.af != AF_LOCAL) {
708 &
my->info.socket.inet.dst_ipaddr,
my->info.socket.inet.dst_port);
711 my->info.socket.unix.path);
722 if (connect(
my->info.socket.fd, (
struct sockaddr *) &
my->remote_sockaddr,
my->remote_sockaddr_len) == 0) {
738 if (tries <= my->max_tries)
goto retry;
752 if (!
my->info.write_blocked) {
753 my->info.write_blocked =
true;
756 if (rcode < 0)
return rcode;
781 switch (
my->info.cfg->flags & (O_RDONLY | O_WRONLY | O_RDWR)) {
829 my->info.eof =
false;
831 my->info.read_blocked =
false;
832 my->info.write_blocked =
false;
845 setsockopt(
my->info.socket.fd, SOL_SOCKET, SO_NOSIGPIPE, &on,
sizeof(on));
852 if (!
my->info.cfg->async)
return 0;
855 if (rcode == 0)
return 0;
857 if (rcode !=
fr_bio_error(IO_WOULD_BLOCK))
return rcode;
870 if (
my->info.socket.type == SOCK_STREAM) {
882#if defined(IP_PKTINFO) || defined(IP_RECVDSTADDR)
883 }
else if (
my->info.socket.inet.src_ipaddr.af == AF_INET) {
884 if (fr_bio_fd_udpfromto_init4(
my->info.socket.fd) < 0)
return -1;
886 my->bio.read = fr_bio_fd_recvfromto4;
887 my->bio.write = fr_bio_fd_sendfromto4;
890#if defined(IPV6_PKTINFO)
891 }
else if (
my->info.socket.inet.src_ipaddr.af == AF_INET6) {
893 if (fr_bio_fd_udpfromto_init6(
my->info.socket.fd) < 0)
return -1;
895 my->bio.read = fr_bio_fd_recvfromto6;
896 my->bio.write = fr_bio_fd_sendfromto6;
914 if (listen(
my->info.socket.fd, 8) < 0) {
962 if (!
my)
return NULL;
976 .read_blocked =
false,
977 .write_blocked =
false,
1015 if (rcode < 0)
return rcode;
1032 (void) shutdown(
my->info.socket.fd, SHUT_RDWR);
1036 rcode =
close(
my->info.socket.fd);
1042 if (tries < my->max_tries)
goto retry;
1054 my->info.read_blocked =
true;
1055 my->info.write_blocked =
true;
1056 my->info.eof =
true;
1068 my->info.connect_errno = fd_errno;
1070 if (
my->connect.error) {
1071 my->connect.error(&
my->bio);
1098 socklen_t socklen =
sizeof(error);
1113 if (getsockopt(
my->info.socket.fd, SOL_SOCKET, SO_ERROR, (
void *)&error, &socklen) < 0) {
1138 my->connect.el = NULL;
1143 my->connect.success(&
my->bio);
1155 my->connect.timeout(&
my->bio);
1189 my->info.connect_errno = ECONNABORTED;
1191 my->info.connect_errno = ECONNREFUSED;
1193 if (error_cb) error_cb(bio);
1204 if (connected_cb) connected_cb(bio);
1226 if (!connected_cb) {
1231 if (error_cb) error_cb(bio);
1246 my->connect.success = connected_cb;
1247 my->connect.error = error_cb;
1248 my->connect.timeout = timeout_cb;
1266 my->connect.el =
el;
1291 rcode = read(
my->info.socket.fd,
buffer, size);
1292 if (rcode >= 0)
return 0;
1295#define flag_blocked read_blocked
1310 rcode = read(
my->info.socket.fd,
buffer, size);
1311 if (rcode > 0 )
return 0;
1318#define flag_blocked read_blocked
1331 switch (
my->info.type) {
1336 if (
my->info.socket.type != SOCK_DGRAM) {
1340 goto set_recv_buff_zero;
1347 if (shutdown(
my->info.socket.fd, SHUT_RD) < 0) {
1362 if (setsockopt(
my->info.socket.fd, SOL_SOCKET, SO_RCVBUF, &opt,
sizeof(opt)) < 0) {
1393 struct sockaddr_storage sockaddr;
1397 salen =
sizeof(sockaddr);
1408 fd = accept4(
my->info.socket.fd, (
struct sockaddr *) &sockaddr, &salen, SOCK_NONBLOCK | SOCK_CLOEXEC);
1410 fd = accept(
my->info.socket.fd, (
struct sockaddr *) &sockaddr, &salen);
1419 if (tries <= my->max_tries)
goto retry;
1426#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)
1461 cfg = talloc_memdup(
out,
my->info.cfg,
sizeof(*
my->info.cfg));
1473 out->info.socket.fd = fd;
static int const char char buffer[256]
fr_bio_write_t _CONST write
write to the underlying bio
static fr_bio_t * fr_bio_prev(fr_bio_t *bio)
fr_bio_read_t _CONST read
read from the underlying bio
static fr_bio_t * fr_bio_next(fr_bio_t *bio)
void(* fr_bio_callback_t)(fr_bio_t *bio)
#define UNCONST(_type, _ptr)
Remove const qualification from a pointer.
#define FALL_THROUGH
clang 10 doesn't recognised the FALL-THROUGH comment anymore
#define fr_event_fd_insert(...)
@ FR_EVENT_FILTER_IO
Combined filter for read/write functions/.
int fr_bio_fd_connect_full(fr_bio_t *bio, fr_event_list_t *el, fr_bio_callback_t connected_cb, fr_bio_callback_t error_cb, fr_time_delta_t *timeout, fr_bio_callback_t timeout_cb)
Finalize a connect()
static ssize_t fr_bio_fd_write(fr_bio_t *bio, UNUSED void *packet_ctx, const void *buffer, size_t size)
Write to fd.
int fr_bio_fd_socket_name(fr_bio_fd_t *my)
static void fr_bio_fd_el_connect(NDEBUG_UNUSED fr_event_list_t *el, NDEBUG_UNUSED int fd, NDEBUG_UNUSED int flags, void *uctx)
Connect callback for when the socket is writable.
static int fr_bio_fd_write_resume(fr_bio_t *bio)
fr_bio_t * fr_bio_fd_alloc(TALLOC_CTX *ctx, fr_bio_fd_config_t const *cfg, size_t offset)
Allocate a FD bio.
static ssize_t fr_bio_fd_read_discard_stream(fr_bio_t *bio, UNUSED void *packet_ctx, void *buffer, size_t size)
Discard all reads from a TCP socket.
int fr_bio_fd_init_connected(fr_bio_fd_t *my)
static ssize_t fr_bio_fd_read_connected_datagram(fr_bio_t *bio, UNUSED void *packet_ctx, void *buffer, size_t size)
Connected datagram read.
static ssize_t fr_bio_fd_try_connect(fr_bio_fd_t *my)
Try to connect().
static ssize_t fr_bio_fd_recvfrom(fr_bio_t *bio, void *packet_ctx, void *buffer, size_t size)
Read from a UDP socket where we know our IP.
static int fr_bio_fd_eof(fr_bio_t *bio)
static ssize_t fr_bio_fd_sendto(fr_bio_t *bio, void *packet_ctx, const void *buffer, size_t size)
Write to a UDP socket where we know our IP.
int fr_filename_to_sockaddr(struct sockaddr_un *sun, socklen_t *sunlen, char const *filename)
int fr_bio_fd_init_listen(fr_bio_fd_t *my)
int fr_bio_fd_accept(TALLOC_CTX *ctx, fr_bio_t **out_p, fr_bio_t *bio)
Alternative to calling fr_bio_read() on new socket.
fr_bio_fd_info_t const * fr_bio_fd_info(fr_bio_t *bio)
Returns a pointer to the bio-specific information.
static int fr_bio_fd_init_file(fr_bio_fd_t *my)
Files are a special case of connected sockets.
static void fr_bio_fd_el_timeout(UNUSED fr_timer_list_t *tl, UNUSED fr_time_t now, void *uctx)
We have a timeout on the conenction.
static int fr_bio_fd_destructor(fr_bio_fd_t *my)
int fr_bio_fd_init_common(fr_bio_fd_t *my)
int fr_bio_fd_write_only(fr_bio_t *bio)
Mark up a bio as write-only.
static ssize_t fr_bio_fd_read_discard_datagram(fr_bio_t *bio, UNUSED void *packet_ctx, void *buffer, size_t size)
Discard all reads from a UDP socket.
static void fr_bio_fd_el_error(UNUSED fr_event_list_t *el, UNUSED int fd, UNUSED int flags, int fd_errno, void *uctx)
FD error when trying to connect, give up on the BIO.
int fr_bio_fd_close(fr_bio_t *bio)
Close the FD, but leave the bio allocated and alive.
static void fr_bio_fd_set_open(fr_bio_fd_t *my)
static ssize_t fr_bio_fd_read_stream(fr_bio_t *bio, UNUSED void *packet_ctx, void *buffer, size_t size)
Stream read.
@ FR_BIO_FD_ACCEPTED
temporarily until it's connected.
@ FR_BIO_FD_CONNECTED
connected client sockets (UDP or TCP)
@ FR_BIO_FD_INVALID
not set
@ FR_BIO_FD_UNCONNECTED
unconnected UDP / datagram only
@ FR_BIO_FD_LISTEN
returns new fd in buffer on fr_bio_read() or fr_bio_fd_accept()
@ FR_BIO_FD_STATE_CONNECTING
@ FR_BIO_FD_STATE_OPEN
error states must be before this
fr_bio_fd_type_t type
accept, connected, unconnected, etc.
int fr_bio_fd_open(fr_bio_t *bio, fr_bio_fd_config_t const *cfg)
Opens a socket and updates sock->fd.
fr_socket_t socket
socket information, including FD.
Configuration for sockets.
Run-time status of the socket.
#define fr_bio_fd_packet_ctx(_my, _packet_ctx)
void fr_ipaddr_get_scope_id(fr_ipaddr_t *ipaddr)
int fr_ipaddr_from_sockaddr(fr_ipaddr_t *ipaddr, uint16_t *port, struct sockaddr_storage const *sa, socklen_t salen)
Convert sockaddr to our internal ip address representation.
int fr_ipaddr_is_inaddr_any(fr_ipaddr_t const *ipaddr)
Determine if an address is the INADDR_ANY address for its address family.
int fr_ipaddr_to_sockaddr(struct sockaddr_storage *sa, socklen_t *salen, fr_ipaddr_t const *ipaddr, uint16_t port)
Convert our internal ip address representation to a sockaddr.
int fr_bio_write_blocked(fr_bio_t *bio)
Internal BIO function to tell all BIOs that it's blocked.
void fr_bio_eof(fr_bio_t *bio)
Internal BIO function to run EOF callbacks.
int fr_bio_shutdown(fr_bio_t *bio)
Shut down a set of BIOs.
int fr_event_fd_delete(fr_event_list_t *el, int fd, fr_event_filter_t filter)
Remove a file descriptor from the event loop.
Stores all information relating to an event list.
ssize_t fr_bio_null_write(UNUSED fr_bio_t *bio, UNUSED void *packet_ctx, UNUSED void const *buffer, UNUSED size_t size)
Always return 0 on write.
ssize_t fr_bio_null_read(UNUSED fr_bio_t *bio, UNUSED void *packet_ctx, UNUSED void *buffer, UNUSED size_t size)
Always return 0 on read.
ssize_t fr_bio_fail_read(UNUSED fr_bio_t *bio, UNUSED void *packet_ctx, UNUSED void *buffer, UNUSED size_t size)
Always return error on read.
ssize_t fr_bio_fail_write(UNUSED fr_bio_t *bio, UNUSED void *packet_ctx, UNUSED void const *buffer, UNUSED size_t size)
Always return 0 on write.
#define fr_time()
Allow us to arbitrarily manipulate time.
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
static fr_time_t fr_time_from_timeval(struct timeval const *when_tv)
Convert a timeval (wallclock time) to a fr_time_t (internal time)
#define fr_time_wrap(_time)
#define fr_time_eq(_a, _b)
static fr_time_t fr_time_from_timespec(struct timespec const *when_ts)
Convert a timespec (wallclock time) to a fr_time_t (internal time)
A time delta, a difference in time measured in nanoseconds.
#define FR_TIMER_DELETE(_ev_p)
static fr_event_list_t * el
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
#define fr_strerror_const(_msg)
static size_t char ** out