1 /* Check recvmsg/recvmmsg 64-bit timestamp support.
2 Copyright (C) 2022-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <arpa/inet.h>
20 #include <string.h>
21 #include <support/check.h>
22 #include <support/xsocket.h>
23 #include <support/xunistd.h>
24 #include <stdbool.h>
25 #include <socket-constants-time64.h>
26
27 /* AF_INET socket and address used to receive data. */
28 static int srv;
29 static struct sockaddr_in srv_addr;
30
31 static int
32 do_sendto (const struct sockaddr_in *addr, int payload)
33 {
34 int s = xsocket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
35 xconnect (s, (const struct sockaddr *) addr, sizeof (*addr));
36
37 xsendto (s, &payload, sizeof (payload), 0, (const struct sockaddr *) addr,
38 sizeof (*addr));
39
40 xclose (s);
41
42 return 0;
43 }
44
45 static void
46 do_recvmsg_ancillary (bool use_multi_call, struct mmsghdr *mmhdr,
47 void *msgbuf, size_t msgbuflen, int exp_payload)
48 {
49 int payload;
50 struct iovec iov =
51 {
52 .iov_base = &payload,
53 .iov_len = sizeof (payload)
54 };
55 mmhdr->msg_hdr.msg_name = NULL;
56 mmhdr->msg_hdr.msg_iov = &iov;
57 mmhdr->msg_hdr.msg_iovlen = 1;
58 mmhdr->msg_hdr.msg_control = msgbuf;
59 mmhdr->msg_hdr.msg_controllen = msgbuflen;
60
61 int r;
62 if (use_multi_call)
63 {
64 r = recvmmsg (srv, mmhdr, 1, 0, NULL);
65 if (r >= 0)
66 r = mmhdr->msg_len;
67 }
68 else
69 r = recvmsg (srv, &mmhdr->msg_hdr, 0);
70 TEST_COMPARE (r, sizeof (int));
71 TEST_COMPARE (payload, exp_payload);
72 }
73
74 /* Check if recvmsg create the additional 64 bit timestamp if only 32 bit
75 is enabled for 64 bit recvmsg symbol. */
76 static void
77 do_test_large_buffer (bool mc)
78 {
79 struct mmsghdr mmhdr = { 0 };
80 /* It should be large enough for either timeval/timespec and the
81 64 time type as well. */
82
83 union
84 {
85 struct cmsghdr cmsghdr;
86 char msgbuf[512];
87 } control;
88
89 /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp
90 is created. */
91 {
92 int r = setsockopt (srv, SOL_SOCKET, COMPAT_SO_TIMESTAMP_OLD, &(int){1},
93 sizeof (int));
94 TEST_VERIFY_EXIT (r != -1);
95
96 do_sendto (&srv_addr, 42);
97 do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42);
98
99 bool found_timestamp = false;
100 for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr);
101 cmsg != NULL;
102 cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg))
103 {
104 if (cmsg->cmsg_level != SOL_SOCKET)
105 continue;
106
107 if (sizeof (time_t) > 4 && cmsg->cmsg_type == COMPAT_SO_TIMESTAMP_NEW)
108 found_timestamp = true;
109 else
110 TEST_VERIFY (cmsg->cmsg_type != COMPAT_SO_TIMESTAMP_NEW);
111 }
112
113 TEST_COMPARE (found_timestamp, sizeof (time_t) > 4);
114 }
115
116 /* Same as before, but for timespec. */
117 {
118 int r = setsockopt (srv, SOL_SOCKET, COMPAT_SO_TIMESTAMPNS_OLD, &(int){1},
119 sizeof (int));
120 TEST_VERIFY_EXIT (r != -1);
121
122 do_sendto (&srv_addr, 42);
123 do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42);
124
125 bool found_timestamp = false;
126 for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr);
127 cmsg != NULL;
128 cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg))
129 {
130 if (cmsg->cmsg_level != SOL_SOCKET)
131 continue;
132
133 if (sizeof (time_t) > 4 && cmsg->cmsg_type == COMPAT_SO_TIMESTAMPNS_NEW)
134 found_timestamp = true;
135 else
136 TEST_VERIFY (cmsg->cmsg_type != COMPAT_SO_TIMESTAMPNS_NEW);
137 }
138
139 TEST_COMPARE (found_timestamp, sizeof (time_t) > 4);
140 }
141 }
142
143 /* Check if recvmsg does not create the additional 64 bit timestamp if
144 only 32 bit timestamp is enabled if the ancillary buffer is not large
145 enough. Also checks if MSG_CTRUNC is set iff for 64 bit recvmsg
146 symbol. */
147 static void
148 do_test_small_buffer (bool mc)
149 {
150 struct mmsghdr mmhdr = { 0 };
151
152 /* Enable 32 bit timeval precision and check if no 64 bit timeval stamp
153 is created. */
154 {
155 int r = setsockopt (srv, SOL_SOCKET, COMPAT_SO_TIMESTAMP_OLD, &(int){1},
156 sizeof (int));
157 TEST_VERIFY_EXIT (r != -1);
158
159 union
160 {
161 struct cmsghdr cmsghdr;
162 char msgbuf[CMSG_SPACE (sizeof (struct timeval))];
163 } control;
164
165 do_sendto (&srv_addr, 42);
166 do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42);
167
168 bool found_timestamp = false;
169 for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr);
170 cmsg != NULL;
171 cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg))
172 {
173 if (cmsg->cmsg_level != SOL_SOCKET)
174 continue;
175
176 if (sizeof (time_t) > 4 && cmsg->cmsg_type == COMPAT_SO_TIMESTAMP_NEW)
177 found_timestamp = true;
178 else
179 TEST_VERIFY (cmsg->cmsg_type != COMPAT_SO_TIMESTAMP_NEW);
180 }
181
182 if (sizeof (time_t) > 4)
183 {
184 TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC));
185 TEST_COMPARE (found_timestamp, 0);
186 }
187 else
188 {
189 TEST_VERIFY (!(mmhdr.msg_hdr.msg_flags & MSG_CTRUNC));
190 TEST_COMPARE (found_timestamp, 0);
191 }
192 }
193
194 /* Same as before, but for timespec. */
195 {
196 int r = setsockopt (srv, SOL_SOCKET, COMPAT_SO_TIMESTAMPNS_OLD, &(int){1},
197 sizeof (int));
198 TEST_VERIFY_EXIT (r != -1);
199
200 union
201 {
202 struct cmsghdr cmsghdr;
203 char msgbuf[CMSG_SPACE (sizeof (struct timespec))];
204 } control;
205
206 do_sendto (&srv_addr, 42);
207 do_recvmsg_ancillary (mc, &mmhdr, &control, sizeof control, 42);
208
209 bool found_timestamp = false;
210 for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mmhdr.msg_hdr);
211 cmsg != NULL;
212 cmsg = CMSG_NXTHDR (&mmhdr.msg_hdr, cmsg))
213 {
214 if (cmsg->cmsg_level != SOL_SOCKET)
215 continue;
216
217 if (sizeof (time_t) > 4 && cmsg->cmsg_type == COMPAT_SO_TIMESTAMPNS_NEW)
218 found_timestamp = true;
219 else
220 TEST_VERIFY (cmsg->cmsg_type != COMPAT_SO_TIMESTAMPNS_NEW);
221 }
222
223 if (sizeof (time_t) > 4)
224 {
225 TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC));
226 TEST_COMPARE (found_timestamp, 0);
227 }
228 else
229 {
230 TEST_VERIFY ((mmhdr.msg_hdr.msg_flags & MSG_CTRUNC) == 0);
231 TEST_COMPARE (found_timestamp, 0);
232 }
233 }
234 }
235
236 static int
237 do_test (void)
238 {
239 /* This test only make sense for ABIs that support 32 bit time_t socket
240 timestampss. */
241 if (sizeof (time_t) > 4 && __TIMESIZE == 64)
242 return 0;
243
244 srv = xsocket (AF_INET, SOCK_DGRAM, 0);
245 srv_addr = (struct sockaddr_in) {
246 .sin_family = AF_INET,
247 .sin_addr = {.s_addr = htonl (INADDR_LOOPBACK) },
248 };
249 xbind (srv, (struct sockaddr *) &srv_addr, sizeof (srv_addr));
250 {
251 socklen_t sa_len = sizeof (srv_addr);
252 xgetsockname (srv, (struct sockaddr *) &srv_addr, &sa_len);
253 TEST_VERIFY (sa_len == sizeof (srv_addr));
254 }
255
256 /* Check recvmsg; */
257 do_test_large_buffer (false);
258 do_test_small_buffer (false);
259 /* Check recvmmsg. */
260 do_test_large_buffer (true);
261 do_test_small_buffer (true);
262
263 return 0;
264 }
265
266 #include <support/test-driver.c>