diff options
| -rw-r--r-- | include/sys/socket.h | 10 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/Makefile | 10 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/recvmmsg.c | 36 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/recvmsg.c | 34 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c | 1 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c | 265 |
6 files changed, 330 insertions, 26 deletions
diff --git a/include/sys/socket.h b/include/sys/socket.h index a1d749f9fa..6e4cf5077f 100644 --- a/include/sys/socket.h +++ b/include/sys/socket.h @@ -98,15 +98,21 @@ extern int __sendmmsg (int __fd, struct mmsghdr *__vmessages, libc_hidden_proto (__sendmmsg) #endif -/* Receive a message as described by MESSAGE from socket FD. - Returns the number of bytes read or -1 for errors. */ extern ssize_t __libc_recvmsg (int __fd, struct msghdr *__message, int __flags); extern ssize_t __recvmsg (int __fd, struct msghdr *__message, int __flags) attribute_hidden; #if __TIMESIZE == 64 +# define __libc_recvmsg64 __libc_recvmsg +# define __recvmsg64 __recvmsg # define __recvmmsg64 __recvmmsg #else +extern ssize_t __libc_recvmsg64 (int __fd, struct msghdr *__message, + int __flags); +extern ssize_t __recvmsg64 (int __fd, struct msghdr *__message, + int __flags); +/* Receive a message as described by MESSAGE from socket FD. + Returns the number of bytes read or -1 for errors. */ extern int __recvmmsg64 (int __fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, struct __timespec64 *timeout); diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile index 4c80ff809c..7122f55975 100644 --- a/sysdeps/unix/sysv/linux/Makefile +++ b/sysdeps/unix/sysv/linux/Makefile @@ -277,8 +277,14 @@ sysdep_routines += cmsg_nxthdr CFLAGS-recvmmsg.c = -fexceptions -fasynchronous-unwind-tables CFLAGS-sendmmsg.c = -fexceptions -fasynchronous-unwind-tables -tests += tst-socket-timestamp -tests-time64 += tst-socket-timestamp-time64 +tests += \ + tst-socket-timestamp \ + tst-socket-timestamp-compat \ + # tests +tests-time64 += \ + tst-socket-timestamp-time64 \ + tst-socket-timestamp-compat-time64 + # tests-time64 tests-special += $(objpfx)tst-socket-consts.out $(objpfx)tst-socket-consts.out: ../sysdeps/unix/sysv/linux/tst-socket-consts.py diff --git a/sysdeps/unix/sysv/linux/recvmmsg.c b/sysdeps/unix/sysv/linux/recvmmsg.c index 3b9b5f9d1f..d9664d61c4 100644 --- a/sysdeps/unix/sysv/linux/recvmmsg.c +++ b/sysdeps/unix/sysv/linux/recvmmsg.c @@ -19,9 +19,9 @@ #include <sysdep.h> #include <socketcall.h> -int -__recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, - struct __timespec64 *timeout) +static int +recvmmsg_syscall (int fd, struct mmsghdr *vmessages, unsigned int vlen, + int flags, struct __timespec64 *timeout) { #ifndef __NR_recvmmsg_time64 # define __NR_recvmmsg_time64 __NR_recvmmsg @@ -44,12 +44,6 @@ __recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, pts32 = &ts32; } - socklen_t csize[IOV_MAX]; - if (vlen > IOV_MAX) - vlen = IOV_MAX; - for (int i = 0; i < vlen; i++) - csize[i] = vmessages[i].msg_hdr.msg_controllen; - # ifdef __ASSUME_RECVMMSG_SYSCALL r = SYSCALL_CANCEL (recvmmsg, fd, vmessages, vlen, flags, pts32); # else @@ -59,11 +53,31 @@ __recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, { if (timeout != NULL) *timeout = valid_timespec_to_timespec64 (ts32); + } +#endif + return r; +} + +int +__recvmmsg64 (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, + struct __timespec64 *timeout) +{ +#if __TIMESIZE != 64 + socklen_t csize[IOV_MAX]; + if (vlen > IOV_MAX) + vlen = IOV_MAX; + for (int i = 0; i < vlen; i++) + csize[i] = vmessages[i].msg_hdr.msg_controllen; +#endif + int r = recvmmsg_syscall (fd, vmessages, vlen, flags, timeout); +#if __TIMESIZE != 64 + if (r > 0) + { for (int i=0; i < r; i++) __convert_scm_timestamps (&vmessages[i].msg_hdr, csize[i]); } -#endif /* __ASSUME_TIME64_SYSCALLS */ +#endif return r; } #if __TIMESIZE != 64 @@ -79,7 +93,7 @@ __recvmmsg (int fd, struct mmsghdr *vmessages, unsigned int vlen, int flags, ts64 = valid_timespec_to_timespec64 (*timeout); pts64 = &ts64; } - int r = __recvmmsg64 (fd, vmessages, vlen, flags, pts64); + int r = recvmmsg_syscall (fd, vmessages, vlen, flags, pts64); if (r >= 0 && timeout != NULL) /* The remanining timeout will be always less the input TIMEOUT. */ *timeout = valid_timespec64_to_timespec (ts64); diff --git a/sysdeps/unix/sysv/linux/recvmsg.c b/sysdeps/unix/sysv/linux/recvmsg.c index 53e567ed31..401d415b2c 100644 --- a/sysdeps/unix/sysv/linux/recvmsg.c +++ b/sysdeps/unix/sysv/linux/recvmsg.c @@ -20,29 +20,41 @@ #include <sysdep-cancel.h> #include <socketcall.h> +static int +__recvmsg_syscall (int fd, struct msghdr *msg, int flags) +{ +#ifdef __ASSUME_RECVMSG_SYSCALL + return SYSCALL_CANCEL (recvmsg, fd, msg, flags); +#else + return SOCKETCALL_CANCEL (recvmsg, fd, msg, flags); +#endif +} + ssize_t -__libc_recvmsg (int fd, struct msghdr *msg, int flags) +__libc_recvmsg64 (int fd, struct msghdr *msg, int flags) { ssize_t r; -#ifndef __ASSUME_TIME64_SYSCALLS +#if __TIMESIZE != 64 socklen_t orig_controllen = msg != NULL ? msg->msg_controllen : 0; #endif -#ifdef __ASSUME_RECVMSG_SYSCALL - r = SYSCALL_CANCEL (recvmsg, fd, msg, flags); -#else - r = SOCKETCALL_CANCEL (recvmsg, fd, msg, flags); -#endif + r = __recvmsg_syscall (fd, msg, flags); -#ifndef __ASSUME_TIME64_SYSCALLS +#if __TIMESIZE != 64 if (r >= 0 && orig_controllen != 0) __convert_scm_timestamps (msg, orig_controllen); #endif return r; } -weak_alias (__libc_recvmsg, recvmsg) -weak_alias (__libc_recvmsg, __recvmsg) #if __TIMESIZE != 64 -weak_alias (__recvmsg, __recvmsg64) +weak_alias (__libc_recvmsg64, __recvmsg64) + +ssize_t +__libc_recvmsg (int fd, struct msghdr *msg, int flags) +{ + return __recvmsg_syscall (fd, msg, flags); +} #endif +weak_alias (__libc_recvmsg, recvmsg) +weak_alias (__libc_recvmsg, __recvmsg) diff --git a/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c new file mode 100644 index 0000000000..96a0bef0bf --- /dev/null +++ b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat-time64.c @@ -0,0 +1 @@ +#include "tst-socket-timestamp-compat.c" diff --git a/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c new file mode 100644 index 0000000000..de261dae5a --- /dev/null +++ b/sysdeps/unix/sysv/linux/tst-socket-timestamp-compat.c @@ -0,0 +1,265 @@ +/* Check recvmsg/recvmmsg 64-bit timestamp support. + Copyright (C) 2022 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <https://www.gnu.org/licenses/>. */ + +#include <arpa/inet.h> +#include <string.h> +#include <support/check.h> +#include <support/xsocket.h> +#include <support/xunistd.h> +#include <stdbool.h> + +/* AF_INET socket and address used to receive data. */ +static int srv; +static struct sockaddr_in srv_addr; + +static int +do_sendto (const struct sockaddr_in *addr, int payload) +{ + int s = xsocket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); + xconnect (s, (const struct sockaddr *) addr, sizeof (*addr)); + + xsendto (s, &payload, sizeof (payload), 0, (const struct sockaddr *) addr, + sizeof (*addr)); + + xclose (s); + + return 0; +} + +static void +do_recvmsg_ancillary (bool use_multi_call, struct mmsghdr *mmhdr, + void *msgbuf, size_t msgbuflen, int exp_payload) +{ + int payload; + struct iovec iov = + { + .iov_base = &payload, + .iov_len = sizeof (payload) + }; + mmhdr->msg_hdr.msg_name = NULL; + mmhdr->msg_hdr.msg_iov = &iov; + mmhdr->msg_hdr.msg_iovlen = 1; + mmhdr->msg_hdr.msg_control = msgbuf; + mmhdr->msg_hdr.msg_controllen = msgbuflen; + + int r; + if (use_multi_call) + { + r = recvmmsg (srv, mmhdr, 1, 0, NULL); + if (r >= 0) + r = mmhdr->msg_len; + } + else + r = recvmsg (srv, &mmhdr->msg_hdr, 0); + TEST_COMPARE (r, sizeof (int)); + TEST_COMPARE (payload, exp_payload); +} + +/* Check if recvmsg create the additional 64 bit timestamp if only 32 bit + is enabled for 64 bit recvmsg symbol. */ +static void +do_test_large_buffer (bool mc) +{ + struct mmsghdr mmhdr = { 0 }; + /* It should be large enought for either timeval/timespec and the + 64 time type as well. */ + + union + { + struct cmsghdr cmsghdr; + char msgbuf[512]; + } control; + + /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp + is created. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMP_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMP_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMP_NEW); + } + + TEST_COMPARE (found_timestamp, sizeof (time_t) > 4); + } + + /* Same as before, but for timespec. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMPNS_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMPNS_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMPNS_NEW); + } + + TEST_COMPARE (found_timestamp, sizeof (time_t) > 4); + } +} + +/* Check if recvmsg does not create the additional 64 bit timestamp if + only 32 bit timestamp is enabled if the ancillary buffer is not large + enought. Also checks if MSG_CTRUNC is set iff for 64 bit recvmsg + symbol. */ +static void +do_test_small_buffer (bool mc) +{ + struct mmsghdr mmhdr = { 0 }; + + /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp + is created. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMP_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + union + { + struct cmsghdr cmsghdr; + char msgbuf[CMSG_SPACE (sizeof (struct timeval))]; + } control; + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMP_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMP_NEW); + } + + if (sizeof (time_t) > 4) + { + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); + TEST_COMPARE (found_timestamp, 0); + } + else + { + TEST_VERIFY (!(mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); + TEST_COMPARE (found_timestamp, 0); + } + } + + /* Same as before, but for timespec. */ + { + int r = setsockopt (srv, SOL_SOCKET, SO_TIMESTAMPNS_OLD, &(int){1}, + sizeof (int)); + TEST_VERIFY_EXIT (r != -1); + + union + { + struct cmsghdr cmsghdr; + char msgbuf[CMSG_SPACE (sizeof (struct timespec))]; + } control; + + do_sendto (&srv_addr, 42); + do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42); + + bool found_timestamp = false; + for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr); + cmsg != NULL; + cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg)) + { + if (cmsg->cmsg_level != SOL_SOCKET) + continue; + + if (sizeof (time_t) > 4 && cmsg->cmsg_type == SO_TIMESTAMPNS_NEW) + found_timestamp = true; + else + TEST_VERIFY (cmsg->cmsg_type != SO_TIMESTAMPNS_NEW); + } + + if (sizeof (time_t) > 4) + { + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC)); + TEST_COMPARE (found_timestamp, 0); + } + else + { + TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC) == 0); + TEST_COMPARE (found_timestamp, 0); + } + } +} + +static int +do_test (void) +{ + /* This test only make sense for ABIs that support 32 bit time_t socket + timestampss. */ + if (sizeof (time_t) > 4 && __WORDSIZE == 64) + return 0; + + srv = xsocket (AF_INET, SOCK_DGRAM, 0); + srv_addr = (struct sockaddr_in) { + .sin_family = AF_INET, + .sin_addr = {.s_addr = htonl (INADDR_LOOPBACK) }, + }; + xbind (srv, (struct sockaddr *) &srv_addr, sizeof (srv_addr)); + { + socklen_t sa_len = sizeof (srv_addr); + xgetsockname (srv, (struct sockaddr *) &srv_addr, &sa_len); + TEST_VERIFY (sa_len == sizeof (srv_addr)); + } + + /* Check recvmsg; */ + do_test_large_buffer (false); + do_test_small_buffer (false); + /* Check recvmmsg. */ + do_test_large_buffer (true); + do_test_small_buffer (true); + + return 0; +} + +#include <support/test-driver.c> |