1 /*
2 * Copyright (c) 2020-2022 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29 /* -*- compile-command: "xcrun --sdk macosx.internal make -C tests recvmsg_x_test" -*- */
30
31
32 #define __APPLE_USE_RFC_3542 1
33
34 #include <sys/errno.h>
35 #include <sys/fcntl.h>
36 #include <sys/socket.h>
37 #include <netinet/in.h>
38 #include <stdbool.h>
39 #include <err.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <sysexits.h>
44 #include <unistd.h>
45
46 #include <arpa/inet.h>
47
48 #include <darwintest.h>
49 #include <darwintest_utils.h>
50
51 #define NMSGS 10
52 #define BUFFERLEN 1000
53
54 T_GLOBAL_META(T_META_NAMESPACE("xnu.net"));
55
56 static void
send_packets(int sendSocket,u_int packetCount,struct sockaddr * to,int proto)57 send_packets(int sendSocket, u_int packetCount, struct sockaddr *to, int proto)
58 {
59 u_int nmsgs = NMSGS;
60 ssize_t sentMsgsCount = 0;
61 struct msghdr_x msgList[NMSGS];
62
63 struct msghdr_x *msg;
64 struct iovec iovarray[NMSGS];
65 char bytes[nmsgs][100];
66 const socklen_t cmsg_size = (socklen_t)CMSG_SPACE(sizeof(int));
67 char cmsgbuf[NMSGS][cmsg_size];
68
69 bzero(msgList, sizeof(msgList));
70 bzero(cmsgbuf, sizeof(cmsgbuf));
71
72 for (int i = 0; i < NMSGS; i++) {
73 msg = &msgList[i];
74
75 int dscp = (i % 64) << 2;
76 struct cmsghdr *cm;
77
78 cm = (struct cmsghdr *)(void *)&cmsgbuf[i][0];
79 if (proto == IPPROTO_IP) {
80 cm->cmsg_len = CMSG_LEN(sizeof(int));
81 cm->cmsg_level = IPPROTO_IP;
82 cm->cmsg_type = IP_TOS;
83 *(int *)(void *)CMSG_DATA(cm) = dscp;
84 msg->msg_control = cmsgbuf[i];
85 msg->msg_controllen = CMSG_SPACE(sizeof(int));
86 } else if (proto == IPPROTO_IPV6) {
87 cm->cmsg_len = CMSG_LEN(sizeof(sizeof(int)));
88 cm->cmsg_level = IPPROTO_IPV6;
89 cm->cmsg_type = IPV6_TCLASS;
90 *(int *)(void *)CMSG_DATA(cm) = dscp;
91 msg->msg_control = cmsgbuf[i];
92 msg->msg_controllen = CMSG_SPACE(sizeof(int));
93 }
94
95 msg->msg_name = (void *)to;
96 msg->msg_namelen = to->sa_len;
97 msg->msg_iov = &iovarray[i];
98 msg->msg_iovlen = 1;
99 iovarray[i].iov_base = &bytes[i];
100 iovarray[i].iov_len = 100;
101 msg->msg_flags = 0;
102 }
103
104 while (1) {
105 if (packetCount < nmsgs) {
106 nmsgs = packetCount;
107 }
108 T_EXPECT_POSIX_SUCCESS(sentMsgsCount = sendmsg_x(sendSocket, msgList, nmsgs, 0), "sendmsg_x()");
109 if (sentMsgsCount < 0) {
110 break;
111 } else {
112 packetCount -= sentMsgsCount;
113 }
114 if (packetCount == 0) {
115 break;
116 }
117 }
118 }
119
120 static bool
receive_packets(int recvSocket)121 receive_packets(int recvSocket)
122 {
123 uint8_t maxPacketsToRead = NMSGS;
124 int i;
125 struct msghdr_x msglist[NMSGS];
126 char bytes[NMSGS][100];
127 struct iovec vec[NMSGS];
128 const socklen_t cmsg_size = (socklen_t)MAX(CMSG_SPACE(sizeof(struct in_pktinfo)), CMSG_SPACE(sizeof(struct in6_pktinfo))) + CMSG_SPACE(sizeof(int));
129 char cmsgbuf[NMSGS][cmsg_size];
130 struct sockaddr_storage remoteAddress[NMSGS];
131 bool success = true;
132
133 bzero(msglist, sizeof(msglist));
134 bzero(vec, sizeof(vec));
135 bzero(cmsgbuf, sizeof(cmsgbuf));
136
137
138 ssize_t total_received = 0;
139 while (1) {
140 ssize_t npkts;
141
142 for (i = 0; i < maxPacketsToRead; i++) {
143 struct msghdr_x *msg = &msglist[i];
144 vec[i].iov_base = &bytes[i];
145 vec[i].iov_len = 100;
146
147 msg->msg_name = &remoteAddress[i];
148 msg->msg_namelen = sizeof(struct sockaddr_storage);
149 msg->msg_iov = &vec[i];
150 msg->msg_iovlen = 1;
151 msg->msg_control = cmsgbuf[i];
152 msg->msg_controllen = cmsg_size;
153 }
154
155 npkts = recvmsg_x(recvSocket, msglist, maxPacketsToRead, 0);
156 if (npkts < 0) {
157 if (errno == EINTR || errno == EWOULDBLOCK) {
158 continue;
159 }
160 T_EXPECT_POSIX_SUCCESS(npkts, "recvmsg_x() npkts %ld total_received %ld", npkts, total_received);
161 break;
162 }
163 total_received += npkts;
164
165 for (i = 0; i < npkts; i++) {
166 struct msghdr_x *msg = &msglist[i];
167
168 if ((msg->msg_controllen < (socklen_t)sizeof(struct cmsghdr)) || (msg->msg_flags & MSG_CTRUNC)) {
169 success = false;
170 T_LOG("msg[%d] bad control message len=%d (< %u?) msg_flags 0x%x socket %d",
171 i, msg->msg_controllen, cmsg_size, msg->msg_flags, recvSocket);
172 } else {
173 T_LOG("msg[%d] good control message len=%d (< %u?) msg_flags 0x%x socket %d",
174 i, msg->msg_controllen, cmsg_size, msg->msg_flags, recvSocket);
175 }
176 for (struct cmsghdr *cm = (struct cmsghdr *)CMSG_FIRSTHDR(msg);
177 cm != NULL;
178 cm = (struct cmsghdr *)CMSG_NXTHDR(msg, cm)) {
179 T_LOG(" cmsg_level %u cmsg_type %u cmsg_len %u",
180 cm->cmsg_level, cm->cmsg_type, cm->cmsg_len);
181
182 if (cm->cmsg_level == IPPROTO_IP &&
183 cm->cmsg_type == IP_RECVTOS &&
184 cm->cmsg_len == CMSG_LEN(sizeof(u_char))) {
185 u_char ip_tos = *(u_char *)(void *)CMSG_DATA(cm);
186
187 T_LOG(" ip_tos 0x%x", ip_tos);
188 } else if (cm->cmsg_level == IPPROTO_IPV6 &&
189 cm->cmsg_type == IPV6_TCLASS &&
190 cm->cmsg_len == CMSG_LEN(sizeof(int))) {
191 int ipv6_tclass = *(int *)(void *)CMSG_DATA(cm);
192
193 T_LOG(" ipv6_tclass 0x%x", ipv6_tclass);
194 } else if (cm->cmsg_level == IPPROTO_IPV6 &&
195 cm->cmsg_type == IPV6_PKTINFO &&
196 cm->cmsg_len == CMSG_LEN(sizeof(struct in6_pktinfo))) {
197 struct in6_pktinfo *pktinfo = (struct in6_pktinfo *)(void *)CMSG_DATA(cm);
198 char addr[40];
199
200 T_LOG(" pktinfo addr %s ifindex %u",
201 inet_ntop(AF_INET6, &pktinfo->ipi6_addr, addr, sizeof(addr)), pktinfo->ipi6_ifindex);
202 } else if (cm->cmsg_level == IPPROTO_IP &&
203 cm->cmsg_type == IP_PKTINFO &&
204 cm->cmsg_len == CMSG_LEN(sizeof(struct in_pktinfo))) {
205 struct in_pktinfo *pktinfo = (struct in_pktinfo *)(void *)CMSG_DATA(cm);
206 char spec_dst[20];
207 char addr[20];
208
209 inet_ntop(AF_INET, &pktinfo->ipi_spec_dst, spec_dst, sizeof(spec_dst));
210 inet_ntop(AF_INET, &pktinfo->ipi_addr, addr, sizeof(addr));
211
212 T_LOG(" pktinfo ifindex %u spec_dest %s addr %s",
213 pktinfo->ipi_ifindex, spec_dst, addr);
214 }
215 }
216 }
217
218 if (total_received >= maxPacketsToRead) {
219 // Since we received max number of packets in the last loop, it is not clear if there
220 // are any more left in the socket buffer. So we need to try again
221 break;
222 }
223 }
224 return success;
225 }
226
227 T_DECL(recvmsg_x_ipv4_udp, "revcmsg_x() ipv4")
228 {
229 struct sockaddr_in addr = {
230 .sin_len = sizeof(addr),
231 .sin_family = AF_INET,
232 .sin_addr.s_addr = htonl(0x7f000001),
233 .sin_port = 0
234 };
235
236 int recvSocket;
237 T_QUIET; T_EXPECT_POSIX_SUCCESS(recvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), "socket()");
238 T_QUIET; T_EXPECT_POSIX_SUCCESS(bind(recvSocket, (const struct sockaddr *)&addr, sizeof(addr)), "bind()");
239
240 socklen_t addrLen = sizeof(addr);
241 T_QUIET; T_EXPECT_POSIX_SUCCESS(getsockname(recvSocket, (struct sockaddr *)&addr, &addrLen), "getsockname()");
242
243 int one = 1;
244 T_QUIET; T_EXPECT_POSIX_SUCCESS(setsockopt(recvSocket, IPPROTO_IP, IP_RECVPKTINFO, (void *)&one, sizeof(one)), "setsockopt(IP_RECVPKTINFO)");
245
246 T_QUIET; T_EXPECT_POSIX_SUCCESS(setsockopt(recvSocket, IPPROTO_IP, IP_RECVTOS, (void *)&one, sizeof(one)), "setsockopt(IP_RECVTOS)");
247
248 int flags = fcntl(recvSocket, F_GETFL, 0);
249 T_QUIET; T_EXPECT_POSIX_SUCCESS(fcntl(recvSocket, F_SETFL, flags | O_NONBLOCK), "fcntl()");
250
251 int sendSocket;
252 T_QUIET; T_EXPECT_POSIX_SUCCESS(sendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), "sendSocket socket()");
253
254 send_packets(sendSocket, 10, (struct sockaddr *)&addr, IPPROTO_IP);
255
256 bool result;
257 T_EXPECT_EQ(result = receive_packets(recvSocket), true, "receive_packets");
258
259 close(sendSocket);
260 close(recvSocket);
261 }
262
263 T_DECL(recvmsg_x_ipv6_udp, "exercise revcmsg_x() ")
264 {
265 struct sockaddr_in6 addr = {
266 .sin6_len = sizeof(addr),
267 .sin6_family = AF_INET6,
268 .sin6_addr = IN6ADDR_LOOPBACK_INIT,
269 .sin6_flowinfo = 0,
270 .sin6_scope_id = 0,
271 .sin6_port = 0
272 };
273
274 int recvSocket;
275 T_QUIET; T_EXPECT_POSIX_SUCCESS(recvSocket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), "socket()");
276 T_QUIET; T_EXPECT_POSIX_SUCCESS(bind(recvSocket, (const struct sockaddr *)&addr, sizeof(addr)), "bind()");
277
278 socklen_t addrLen = sizeof(addr);
279 T_QUIET; T_EXPECT_POSIX_SUCCESS(getsockname(recvSocket, (struct sockaddr *)&addr, &addrLen), "getsockname()");
280
281 int one = 1;
282 T_QUIET; T_EXPECT_POSIX_SUCCESS(setsockopt(recvSocket, IPPROTO_IPV6, IPV6_RECVPKTINFO, (void *)&one, sizeof(one)), "setsockopt(IPV6_RECVPKTINFO)");
283
284 T_QUIET; T_EXPECT_POSIX_SUCCESS(setsockopt(recvSocket, IPPROTO_IPV6, IPV6_RECVTCLASS, (void *)&one, sizeof(one)), "setsockopt(IPV6_RECVTCLASS)");
285
286 int flags = fcntl(recvSocket, F_GETFL, 0);
287 T_QUIET; T_EXPECT_POSIX_SUCCESS(fcntl(recvSocket, F_SETFL, flags | O_NONBLOCK), "fcntl()");
288
289 int sendSocket;
290 T_QUIET; T_EXPECT_POSIX_SUCCESS(sendSocket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), "sendSocket socket()");
291
292 send_packets(sendSocket, 10, (struct sockaddr *)&addr, IPPROTO_IPV6);
293
294 bool result;
295 T_EXPECT_EQ(result = receive_packets(recvSocket), true, "receive_packets");
296
297 close(sendSocket);
298 close(recvSocket);
299 }
300