1 /*
2 * Copyright (c) 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 #include <sys/fcntl.h>
30 #include <sys/socket.h>
31
32 #include <net/if.h>
33 #include <net/route.h>
34
35 #include <netinet/in.h>
36
37 #include <stdbool.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <unistd.h>
41
42 #include <arpa/inet.h>
43
44 #include <darwintest.h>
45
46 T_GLOBAL_META(
47 T_META_NAMESPACE("xnu.net"),
48 T_META_RADAR_COMPONENT_NAME("xnu"),
49 T_META_RADAR_COMPONENT_VERSION("networking")
50 );
51
52 #define MAX_IPv6_STR_LEN 64
53
54 static char l_addr_str[MAX_IPv6_STR_LEN];
55 static char f_addr_str[MAX_IPv6_STR_LEN];
56
57 const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
58 #define s6_addr32 __u6_addr.__u6_addr32
59
60 #define RTM_BUFLEN (sizeof(struct rt_msghdr) + 6 * SOCK_MAXADDRLEN)
61
62 #define ROUNDUP(a) \
63 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
64 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
65
66 static bool
has_v4_default_route(void)67 has_v4_default_route(void)
68 {
69 bool result = false;
70 struct rt_msghdr *rtm = NULL;
71 struct sockaddr_in sin = {};
72
73 sin.sin_len = sizeof(struct sockaddr_in);
74 sin.sin_family = AF_INET;
75 sin.sin_addr.s_addr = INADDR_ANY;
76
77 T_QUIET; T_ASSERT_NOTNULL(rtm = (struct rt_msghdr *)calloc(1, RTM_BUFLEN), NULL);
78
79 rtm->rtm_msglen = sizeof(struct rt_msghdr) + sizeof(struct sockaddr_in);
80 rtm->rtm_version = RTM_VERSION;
81 rtm->rtm_type = RTM_GET;
82 rtm->rtm_flags = RTF_UP | RTF_STATIC | RTF_GATEWAY | RTF_HOST;
83 rtm->rtm_addrs = RTA_DST;
84 rtm->rtm_pid = getpid();
85 rtm->rtm_seq = 1;
86
87 uint8_t *cp = (unsigned char *)(rtm + 1);
88
89 bcopy(&sin, cp, sin.sin_len);
90 cp += ROUNDUP(sin.sin_len);
91
92 u_short len = (u_short)(cp - (uint8_t *)rtm);
93
94 rtm->rtm_msglen = len;
95
96 int fd;
97 T_QUIET; T_ASSERT_POSIX_SUCCESS(fd = socket(PF_ROUTE, SOCK_RAW, 0), NULL);
98
99 ssize_t sent = send(fd, rtm, len, 0);
100 if (sent == len) {
101 result = true;
102 } else {
103 result = false;
104 }
105
106 (void) close(fd);
107 free(rtm);
108
109 return result;
110 }
111
112 static bool
has_v6_default_route(void)113 has_v6_default_route(void)
114 {
115 bool result = false;
116 struct rt_msghdr *rtm = NULL;
117 struct sockaddr_in6 sin6 = {};
118
119 sin6.sin6_len = sizeof(struct sockaddr_in6);
120 sin6.sin6_family = AF_INET6;
121
122 T_QUIET; T_ASSERT_NOTNULL(rtm = (struct rt_msghdr *)calloc(1, RTM_BUFLEN), NULL);
123
124 rtm->rtm_msglen = sizeof(struct rt_msghdr) + sizeof(struct sockaddr_in);
125 rtm->rtm_version = RTM_VERSION;
126 rtm->rtm_type = RTM_GET;
127 rtm->rtm_flags = RTF_UP | RTF_STATIC | RTF_GATEWAY | RTF_HOST;
128 rtm->rtm_addrs = RTA_DST;
129 rtm->rtm_pid = getpid();
130 rtm->rtm_seq = 1;
131
132 uint8_t *cp = (unsigned char *)(rtm + 1);
133
134 bcopy(&sin6, cp, sin6.sin6_len);
135 cp += ROUNDUP(sin6.sin6_len);
136
137 u_short len = (u_short)(cp - (uint8_t *)rtm);
138
139 rtm->rtm_msglen = len;
140
141 int fd;
142 T_QUIET; T_ASSERT_POSIX_SUCCESS(fd = socket(PF_ROUTE, SOCK_RAW, 0), NULL);
143
144 ssize_t sent = send(fd, rtm, len, 0);
145 if (sent == len) {
146 result = true;
147 } else {
148 result = false;
149 }
150
151 (void) close(fd);
152 free(rtm);
153
154 return result;
155 }
156
157
158 static void
init_sin_address(struct sockaddr_in * sin)159 init_sin_address(struct sockaddr_in *sin)
160 {
161 memset(sin, 0, sizeof(struct sockaddr_in));
162 sin->sin_len = sizeof(struct sockaddr_in);
163 sin->sin_family = AF_INET;
164 }
165
166 static void
init_sin6_address(struct sockaddr_in6 * sin6)167 init_sin6_address(struct sockaddr_in6 *sin6)
168 {
169 memset(sin6, 0, sizeof(struct sockaddr_in6));
170 sin6->sin6_len = sizeof(struct sockaddr_in6);
171 sin6->sin6_family = AF_INET6;
172 }
173
174 static void
udp_connect_v4(int client_fd,struct sockaddr_in * sin_to,int expected_error)175 udp_connect_v4(int client_fd, struct sockaddr_in *sin_to, int expected_error)
176 {
177 int listen_fd = -1;
178 socklen_t socklen;
179 struct sockaddr_in sin_local = {};
180 struct sockaddr_in sin_peer = {};
181 struct sockaddr_in sin;
182
183 init_sin_address(&sin);
184 init_sin_address(&sin_local);
185 init_sin_address(&sin_peer);
186
187 T_ASSERT_POSIX_SUCCESS(listen_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
188
189 T_ASSERT_POSIX_SUCCESS(bind(listen_fd, (struct sockaddr *)&sin, sizeof(sin)), NULL);
190
191 socklen = sizeof(sin);
192 T_ASSERT_POSIX_SUCCESS(getsockname(listen_fd, (struct sockaddr *)&sin, &socklen), NULL);
193
194 T_LOG("listening on port: %u", ntohs(sin.sin_port));
195 sin_to->sin_port = sin.sin_port;
196
197 T_LOG("connect with sin_len: %u sin_family: %u sin_port: %u sin_addr: 0x%08x expected_error: %d",
198 sin_to->sin_len, sin_to->sin_family, ntohs(sin_to->sin_port), ntohl(sin_to->sin_addr.s_addr), expected_error);
199
200 if (expected_error == 0) {
201 T_EXPECT_POSIX_SUCCESS(connect(client_fd, (struct sockaddr *)sin_to, sizeof(struct sockaddr_in)), NULL);
202
203 socklen = sizeof(sin_local);
204 T_ASSERT_POSIX_SUCCESS(getsockname(client_fd, (struct sockaddr *)&sin_local, &socklen), NULL);
205 (void)inet_ntop(AF_INET, &sin_local.sin_addr, l_addr_str, sizeof(l_addr_str));
206
207 socklen = sizeof(sin_peer);
208 T_ASSERT_POSIX_SUCCESS(getpeername(client_fd, (struct sockaddr *)&sin_peer, &socklen), NULL);
209 (void)inet_ntop(AF_INET, &sin_peer.sin_addr, f_addr_str, sizeof(f_addr_str));
210
211 T_LOG("connected from %s:%u to %s:%u",
212 l_addr_str, ntohs(sin_local.sin_port),
213 f_addr_str, ntohs(sin_peer.sin_port));
214 } else {
215 T_EXPECT_POSIX_FAILURE(connect(client_fd, (struct sockaddr *)sin_to, sizeof(struct sockaddr_in)), expected_error, NULL);
216 }
217 T_ASSERT_POSIX_SUCCESS(close(listen_fd), NULL);
218 }
219
220 static void
udp_connect_v6(int client_fd,struct sockaddr_in6 * sin6_to,int expected_error)221 udp_connect_v6(int client_fd, struct sockaddr_in6 *sin6_to, int expected_error)
222 {
223 int listen_fd = -1;
224 socklen_t socklen;
225 int off = 0;
226 struct sockaddr_in6 sin6_local = {};
227 struct sockaddr_in6 sin6_peer = {};
228 struct sockaddr_in6 sin6;
229
230 init_sin6_address(&sin6);
231 init_sin6_address(&sin6_local);
232 init_sin6_address(&sin6_peer);
233
234 T_ASSERT_POSIX_SUCCESS(listen_fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
235
236 T_ASSERT_POSIX_SUCCESS(setsockopt(listen_fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off)), NULL);
237
238 T_ASSERT_POSIX_SUCCESS(bind(listen_fd, (struct sockaddr *)&sin6, sizeof(sin6)), NULL);
239
240 socklen = sizeof(sin6);
241 T_ASSERT_POSIX_SUCCESS(getsockname(listen_fd, (struct sockaddr *)&sin6, &socklen), NULL);
242
243 T_LOG("listening on port: %u", ntohs(sin6.sin6_port));
244 sin6_to->sin6_port = sin6.sin6_port;
245
246 (void)inet_ntop(AF_INET6, &sin6_to->sin6_addr, l_addr_str, sizeof(l_addr_str));
247 T_LOG("connect with sin6_len: %u sin6_family: %u sin6_port: %u sin6_addr: %s expected_error: %d",
248 sin6_to->sin6_len, sin6_to->sin6_family, ntohs(sin6_to->sin6_port), l_addr_str, expected_error);
249
250 if (expected_error == 0) {
251 T_EXPECT_POSIX_SUCCESS(connect(client_fd, (struct sockaddr *)sin6_to, sizeof(struct sockaddr_in6)), NULL);
252
253 socklen = sizeof(sin6_local);
254 T_ASSERT_POSIX_SUCCESS(getsockname(client_fd, (struct sockaddr *)&sin6_local, &socklen), NULL);
255 (void)inet_ntop(AF_INET6, &sin6_local.sin6_addr, l_addr_str, sizeof(l_addr_str));
256
257 socklen = sizeof(sin6_peer);
258 T_ASSERT_POSIX_SUCCESS(getpeername(client_fd, (struct sockaddr *)&sin6_peer, &socklen), NULL);
259 (void)inet_ntop(AF_INET6, &sin6_peer.sin6_addr, f_addr_str, sizeof(f_addr_str));
260
261 T_LOG("connected from %s:%u to %s:%u",
262 l_addr_str, ntohs(sin6_local.sin6_port),
263 f_addr_str, ntohs(sin6_peer.sin6_port));
264 } else {
265 T_EXPECT_POSIX_FAILURE(connect(client_fd, (struct sockaddr *)sin6_to, sizeof(struct sockaddr_in6)), expected_error, NULL);
266 }
267 T_ASSERT_POSIX_SUCCESS(close(listen_fd), NULL);
268 }
269
270 T_DECL(udp_bind_ipv4_loopback, "UDP bind with a IPv4 loopback address")
271 {
272 int s = -1;
273 struct sockaddr_in sin = {};
274
275 init_sin_address(&sin);
276 T_ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sin.sin_addr), 1, NULL);
277
278 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
279
280 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin, sizeof(sin)), 0, NULL);
281
282 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
283 }
284
285 T_DECL(udp_connect_ipv4_loopback, "UDP connect with a IPv4 loopback address")
286 {
287 int s = -1;
288 struct sockaddr_in sin = {};
289
290 init_sin_address(&sin);
291 T_ASSERT_EQ(inet_pton(AF_INET, "127.0.0.1", &sin.sin_addr), 1, NULL);
292
293 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
294
295 udp_connect_v4(s, &sin, 0);
296
297 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
298 }
299
300 T_DECL(udp_bind_ipv4_multicast, "UDP bind with a IPv4 multicast address")
301 {
302 int s = -1;
303 struct sockaddr_in sin = {};
304
305 init_sin_address(&sin);
306 T_ASSERT_EQ(inet_pton(AF_INET, "224.0.0.1", &sin.sin_addr), 1, NULL);
307
308 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
309
310 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin, sizeof(sin)), NULL);
311
312 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
313 }
314
315 T_DECL(udp_connect_ipv4_multicast, "UDP connect with an IPv4 multicast address")
316 {
317 if (!has_v4_default_route()) {
318 T_SKIP("test require IPv4 default route");
319 }
320
321 int s = -1;
322 struct sockaddr_in sin = {};
323
324 init_sin_address(&sin);
325 T_ASSERT_EQ(inet_pton(AF_INET, "224.0.0.1", &sin.sin_addr), 1, NULL);
326
327 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
328
329 udp_connect_v4(s, &sin, 0);
330
331 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
332 }
333
334 T_DECL(udp_bind_ipv4_broadcast, "UDP bind with the IPv4 broadcast address")
335 {
336 int s = -1;
337 struct sockaddr_in sin = {};
338
339 init_sin_address(&sin);
340 T_ASSERT_EQ(inet_pton(AF_INET, "255.255.255.255", &sin.sin_addr), 1, NULL);
341
342 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
343
344 T_EXPECT_POSIX_FAILURE(bind(s, (const struct sockaddr *)&sin, sizeof(sin)), EADDRNOTAVAIL, NULL);
345
346 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
347 }
348
349 T_DECL(udp_connect_ipv4_broadcast, "UDP connect with the IPv4 broadcast address")
350 {
351 if (!has_v4_default_route()) {
352 T_SKIP("test require IPv4 default route");
353 }
354
355 int s = -1;
356 struct sockaddr_in sin = {};
357
358 init_sin_address(&sin);
359 T_ASSERT_EQ(inet_pton(AF_INET, "255.255.255.255", &sin.sin_addr), 1, NULL);
360
361 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
362
363 udp_connect_v4(s, &sin, 0);
364
365 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
366 }
367
368 T_DECL(udp_bind_ipv4_null, "UDP bind with the null IPv4 address")
369 {
370 int s = -1;
371 struct sockaddr_in sin = {};
372
373 init_sin_address(&sin);
374 T_ASSERT_EQ(inet_pton(AF_INET, "0.0.0.0", &sin.sin_addr), 1, NULL);
375
376 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
377
378 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin, sizeof(sin)), NULL);
379
380 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
381 }
382
383 T_DECL(udp_connect_ipv4_null, "UDP connect with the null IPv4 address")
384 {
385 if (!has_v4_default_route()) {
386 T_SKIP("test require IPv4 default route");
387 }
388
389 int s = -1;
390 struct sockaddr_in sin = {};
391
392 init_sin_address(&sin);
393 T_ASSERT_EQ(inet_pton(AF_INET, "0.0.0.0", &sin.sin_addr), 1, NULL);
394
395 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP), NULL);
396
397 udp_connect_v4(s, &sin, 0);
398
399 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
400 }
401
402 T_DECL(udp_bind_ipv6_loopback, "UDP bind with the IPv6 loopback address")
403 {
404 int s = -1;
405 struct sockaddr_in6 sin6 = {};
406
407 sin6.sin6_scope_id = if_nametoindex("lo0");
408 T_ASSERT_EQ(inet_pton(AF_INET6, "::1", &sin6.sin6_addr), 1, NULL);
409
410 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
411
412 init_sin6_address(&sin6);
413 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), NULL);
414
415 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
416 }
417
418 T_DECL(udp_connect_ipv6_loopback, "UDP connect with the IPv6 loopback address")
419 {
420 int s = -1;
421 struct sockaddr_in6 sin6 = {};
422
423 init_sin6_address(&sin6);
424 T_ASSERT_EQ(inet_pton(AF_INET6, "::1", &sin6.sin6_addr), 1, NULL);
425
426 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
427
428 udp_connect_v6(s, &sin6, 0);
429
430 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
431 }
432
433 T_DECL(udp_bind_ipv6_multicast, "UDP bind with a IPv6 multicast address")
434 {
435 int s = -1;
436 struct sockaddr_in6 sin6 = {};
437
438 init_sin6_address(&sin6);
439 sin6.sin6_scope_id = if_nametoindex("lo0");
440 T_ASSERT_EQ(inet_pton(AF_INET6, "ff01::1", &sin6.sin6_addr), 1, NULL);
441
442 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
443
444 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), NULL);
445
446 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
447 }
448
449 T_DECL(udp_connect_ipv6_multicast, "UDP connect with a IPv6 multicast address")
450 {
451 int s = -1;
452 struct sockaddr_in6 sin6 = {};
453
454 init_sin6_address(&sin6);
455 sin6.sin6_scope_id = if_nametoindex("lo0");
456 T_ASSERT_EQ(inet_pton(AF_INET6, "ff01::1", &sin6.sin6_addr), 1, NULL);
457
458 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
459
460 udp_connect_v6(s, &sin6, 0);
461
462 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
463 }
464
465 T_DECL(udp_bind_null_ipv6, "UDP bind with the IPv6 null address")
466 {
467 int s = -1;
468 struct sockaddr_in6 sin6 = {};
469
470 init_sin6_address(&sin6);
471 T_ASSERT_EQ(inet_pton(AF_INET6, "::", &sin6.sin6_addr), 1, NULL);
472
473 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
474
475 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), NULL);
476
477 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
478 }
479
480 T_DECL(udp_connect_null_ipv6, "UDP connect with the IPv6 null address")
481 {
482 int s = -1;
483 struct sockaddr_in6 sin6 = {};
484
485 init_sin6_address(&sin6);
486 T_ASSERT_EQ(inet_pton(AF_INET6, "::", &sin6.sin6_addr), 1, NULL);
487
488 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
489
490 udp_connect_v6(s, &sin6, 0);
491
492 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
493 }
494
495 T_DECL(udp_bind_ipv4_multicast_mapped_ipv6, "UDP bind with IPv4 multicast mapped IPv6 address")
496 {
497 int s = -1;
498 struct sockaddr_in6 sin6 = {};
499
500 init_sin6_address(&sin6);
501 T_ASSERT_EQ(inet_pton(AF_INET6, "::ffff:224.0.0.1", &sin6.sin6_addr), 1, NULL);
502
503 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
504
505 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), NULL);
506
507 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
508 }
509
510 T_DECL(udp_connect_ipv4_multicast_mapped_ipv6, "UDP connect with IPv4 multicast mapped IPv6 address")
511 {
512 if (!has_v4_default_route()) {
513 T_SKIP("test require IPv4 default route");
514 }
515
516 int s = -1;
517 struct sockaddr_in6 sin6 = {};
518
519 init_sin6_address(&sin6);
520 T_ASSERT_EQ(inet_pton(AF_INET6, "::ffff:224.0.0.1", &sin6.sin6_addr), 1, NULL);
521
522 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
523
524 udp_connect_v6(s, &sin6, 0);
525
526 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
527 }
528
529 T_DECL(udp_bind_ipv4_broadcast_mapped_ipv6, "UDP bind with IPv4 broadcast mapped IPv6 address")
530 {
531 int s = -1;
532 struct sockaddr_in6 sin6 = {};
533
534 init_sin6_address(&sin6);
535 T_ASSERT_EQ(inet_pton(AF_INET6, "::ffff:255.255.255.255", &sin6.sin6_addr), 1, NULL);
536
537 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
538
539 T_EXPECT_POSIX_FAILURE(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), EADDRNOTAVAIL, NULL);
540
541 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
542 }
543
544 T_DECL(udp_connect_ipv4_broadcast_mapped_ipv6, "UDP connect with IPv4 broadcast mapped IPv6 address")
545 {
546 if (!has_v4_default_route()) {
547 T_SKIP("test require IPv4 default route");
548 }
549
550 int s = -1;
551 struct sockaddr_in6 sin6 = {};
552
553 init_sin6_address(&sin6);
554 T_ASSERT_EQ(inet_pton(AF_INET6, "::ffff:255.255.255.255", &sin6.sin6_addr), 1, NULL);
555
556 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
557
558 udp_connect_v6(s, &sin6, 0);
559
560 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
561 }
562
563 T_DECL(udp_bind_ipv4_null_mapped_ipv6, "UDP bind with IPv4 null mapped IPv6 address")
564 {
565 int s = -1;
566 struct sockaddr_in6 sin6 = {};
567
568 init_sin6_address(&sin6);
569 T_ASSERT_EQ(inet_pton(AF_INET6, "::ffff:0.0.0.0", &sin6.sin6_addr), 1, NULL);
570
571 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
572
573 udp_connect_v6(s, &sin6, 0);
574
575 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
576 }
577
578 T_DECL(udp_connect_ipv4_null_mapped_ipv6, "UDP connect with IPv4 null mapped IPv6 address")
579 {
580 if (!has_v4_default_route()) {
581 T_SKIP("test require IPv4 default route");
582 }
583
584 int s = -1;
585 struct sockaddr_in6 sin6 = {};
586
587 init_sin6_address(&sin6);
588 T_ASSERT_EQ(inet_pton(AF_INET6, "::ffff:0.0.0.0", &sin6.sin6_addr), 1, NULL);
589
590 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
591
592 udp_connect_v6(s, &sin6, 0);
593
594 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
595 }
596
597 T_DECL(udp_bind_ipv4_multicast_compatible_ipv6, "UDP bind with IPv4 multicast compatible IPv6 address")
598 {
599 int s = -1;
600 struct sockaddr_in6 sin6 = {};
601
602 init_sin6_address(&sin6);
603 T_ASSERT_EQ(inet_pton(AF_INET6, "::224.0.0.1", &sin6.sin6_addr), 1, NULL);
604
605 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
606
607 T_EXPECT_POSIX_FAILURE(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), EADDRNOTAVAIL, NULL);
608
609 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
610 }
611
612 T_DECL(udp_connect_ipv4_multicast_compatible_ipv6, "UDP connect with IPv4 multicast compatible IPv6 address")
613 {
614 if (!has_v6_default_route()) {
615 T_SKIP("test require IPv6 default route");
616 }
617
618 int s = -1;
619 struct sockaddr_in6 sin6 = {};
620
621 init_sin6_address(&sin6);
622 T_ASSERT_EQ(inet_pton(AF_INET6, "::224.0.0.1", &sin6.sin6_addr), 1, NULL);
623
624 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
625
626 udp_connect_v6(s, &sin6, 0);
627
628 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
629 }
630
631 T_DECL(udp_bind_ipv4_broadcast_compatible_ipv6, "UDP bind with IPv4 broadcast compatible IPv6 address")
632 {
633 int s = -1;
634 struct sockaddr_in6 sin6 = {};
635
636 init_sin6_address(&sin6);
637 T_ASSERT_EQ(inet_pton(AF_INET6, "::255.255.255.255", &sin6.sin6_addr), 1, NULL);
638
639 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
640
641 T_EXPECT_POSIX_FAILURE(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), EADDRNOTAVAIL, NULL);
642
643 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
644 }
645
646 T_DECL(udp_connect_ipv4_broadcast_compatible_ipv6, "UDP connect with IPv4 broadcast compatible IPv6 address")
647 {
648 if (!has_v6_default_route()) {
649 T_SKIP("test require IPv6 default route");
650 }
651
652 int s = -1;
653 struct sockaddr_in6 sin6 = {};
654
655 init_sin6_address(&sin6);
656 T_ASSERT_EQ(inet_pton(AF_INET6, "::255.255.255.255", &sin6.sin6_addr), 1, NULL);
657
658 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
659
660 udp_connect_v6(s, &sin6, 0);
661
662 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
663 }
664
665 T_DECL(udp_bind_ipv4_null_compatible_ipv6, "UDP bind with IPv4 null compatible IPv6 address")
666 {
667 int s = -1;
668 struct sockaddr_in6 sin6 = {};
669
670 init_sin6_address(&sin6);
671 T_ASSERT_EQ(inet_pton(AF_INET6, "::0.0.0.0", &sin6.sin6_addr), 1, NULL);
672
673 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
674
675 T_ASSERT_POSIX_SUCCESS(bind(s, (const struct sockaddr *)&sin6, sizeof(sin6)), NULL);
676
677 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
678 }
679
680 T_DECL(udp_connect_ipv4_null_compatible_ipv6, "UDP connect with IPv4 null compatible IPv6 address")
681 {
682 if (!has_v6_default_route()) {
683 T_SKIP("test require IPv6 default route");
684 }
685
686 int s = -1;
687 struct sockaddr_in6 sin6 = {};
688
689 init_sin6_address(&sin6);
690 T_ASSERT_EQ(inet_pton(AF_INET6, "::0.0.0.0", &sin6.sin6_addr), 1, NULL);
691
692 T_ASSERT_POSIX_SUCCESS(s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP), NULL);
693
694 udp_connect_v6(s, &sin6, 0);
695
696 T_ASSERT_POSIX_SUCCESS(close(s), NULL);
697 }
698