1 /*
2 * Copyright (c) 2023 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 <stdbool.h>
30 #if DEVELOPMENT || DEBUG
31
32 #include <kern/startup.h>
33 #include <kern/zalloc.h>
34 #include <sys/proc_ro.h>
35 #include <sys/vm.h>
36
37 #include <tests/ktest.h>
38
39 #include <libkern/tree.h>
40
41 #include <sys/socket.h>
42 #include <net/if_dl.h>
43 #include <net/ndrv.h>
44 #include <netinet/if_ether.h>
45 #include <sys/kern_control.h>
46 #include <sys/un.h>
47 #include <net/sockaddr_utils.h>
48
49 struct sockaddr *sockaddr_ptr;
50 const struct sockaddr *sockaddr_const_ptr;
51
52 struct sockaddr src_sockaddr = {
53 .sa_len = 16,
54 .sa_family = AF_UNSPEC,
55 .sa_data = {0, }
56 };
57 struct sockaddr *sockaddr_ptr = &src_sockaddr;
58 const struct sockaddr *sockaddr_const_ptr = &src_sockaddr;
59
60
61 struct sockaddr_storage src_sockaddr_storage = {
62 .ss_len = 255,
63 .ss_family = AF_UNSPEC
64 };
65 struct sockaddr_storage *sockaddr_storage_ptr = &src_sockaddr_storage;
66 const struct sockaddr_storage *sockaddr_storage_const_ptr = &src_sockaddr_storage;
67
68
69 struct sockaddr_ctl src_sockaddr_ctl = {
70 .sc_len = 16,
71 .sc_family = AF_SYSTEM
72 };
73 struct sockaddr_ctl *sockaddr_ctl_ptr = &src_sockaddr_ctl;
74 const struct sockaddr_ctl *sockaddr_ctl_const_ptr = &src_sockaddr_ctl;
75
76
77 struct sockaddr_dl src_sockaddr_dl = {
78 .sdl_len = 16,
79 .sdl_family = AF_LINK,
80 .sdl_index = 0,
81 };
82 struct sockaddr_dl *sockaddr_dl_ptr = &src_sockaddr_dl;
83 const struct sockaddr_dl *sockaddr_dl_const_ptr = &src_sockaddr_dl;
84
85
86
87 struct sockaddr_in src_sockaddr_in = {
88 .sin_len = 16,
89 .sin_family = AF_INET,
90 .sin_addr = {.s_addr = 0001001001001 },
91 .sin_port = 1111,
92 .sin_zero = {0, }
93 };
94 struct sockaddr_in *sockaddr_in_ptr = &src_sockaddr_in;
95 const struct sockaddr_in *sockaddr_in_const_ptr = &src_sockaddr_in;
96
97
98 struct sockaddr_in6 src_sockaddr_in6 = {
99 .sin6_len = 28,
100 .sin6_family = AF_INET6,
101 .sin6_flowinfo = 100,
102 };
103 struct sockaddr_in6 *sockaddr_in6_ptr = &src_sockaddr_in6;
104 const struct sockaddr_in6 *sockaddr_in6_const_ptr = &src_sockaddr_in6;
105
106
107
108 struct sockaddr_inarp src_sockaddr_inarp = {
109 .sin_len = 16,
110 .sin_family = AF_INET,
111 .sin_addr = {.s_addr = 0001001001001 },
112 .sin_srcaddr = {.s_addr = 0001001001001 },
113 .sin_tos = 1,
114 .sin_other = 2
115 };
116
117 struct sockaddr_inarp *sockaddr_inarp_ptr = &src_sockaddr_inarp;
118 const struct sockaddr_inarp *sockaddr_inarp_const_ptr = &src_sockaddr_inarp;
119
120
121 struct sockaddr_inifscope src_sockaddr_inifscope = {
122 .sin_len = 16,
123 .sin_family = AF_INET,
124 .sin_addr = {.s_addr = 0001001001001 },
125 .sin_port = 1111,
126 };
127 struct sockaddr_inifscope *sockaddr_inifscope_ptr = &src_sockaddr_inifscope;
128 const struct sockaddr_inifscope *sockaddr_inifscope_const_ptr = &src_sockaddr_inifscope;
129
130
131 struct sockaddr_ndrv src_sockaddr_ndrv = {
132 .snd_len = 16,
133 .snd_family = AF_NDRV,
134 };
135 struct sockaddr_ndrv *sockaddr_ndrv_ptr = &src_sockaddr_ndrv;
136 const struct sockaddr_ndrv *sockaddr_ndrv_const_ptr = &src_sockaddr_ndrv;
137
138
139 struct sockaddr_sys src_sockaddr_sys = {
140 .ss_len = 16,
141 .ss_family = AF_SYSTEM
142 };
143 struct sockaddr_sys *sockaddr_sys_ptr = &src_sockaddr_sys;
144 const struct sockaddr_sys *sockaddr_sys_const_ptr = &src_sockaddr_sys;
145
146
147
148 struct sockaddr_un src_sockaddr_un = {
149 .sun_len = 106,
150 .sun_family = AF_UNIX
151 };
152 struct sockaddr_un *sockaddr_un_ptr = &src_sockaddr_un;
153 const struct sockaddr_un *sockaddr_un_const_ptr = &src_sockaddr_un;
154
155
156 union sockaddr_in_4_6 src_sockaddr_in_4_6 = {
157 .sa = {
158 .sa_len = 28,
159 .sa_family = AF_INET6
160 },
161 };
162 union sockaddr_in_4_6 *sockaddr_in_4_6_ptr = &src_sockaddr_in_4_6;
163 const union sockaddr_in_4_6 *sockaddr_in_4_6_const_ptr = &src_sockaddr_in_4_6;
164
165
166 #define BYTE_INPUT_SIZE 256
167
168 char src_bytes[BYTE_INPUT_SIZE];
169 char * bytes_ptr __sized_by(BYTE_INPUT_SIZE) = &src_bytes[0];
170 const char * bytes_const_ptr __sized_by(BYTE_INPUT_SIZE) = &src_bytes[0];
171
172 uint8_t src_uint8_t[BYTE_INPUT_SIZE];
173 uint8_t * uint8_t_ptr __sized_by(BYTE_INPUT_SIZE) = &src_uint8_t[0];
174 const uint8_t * uint8_t_const_ptr __sized_by(BYTE_INPUT_SIZE) = &src_uint8_t[0];
175
176
177 __attribute__((__noinline__))
178 static void
validate_conversion_result(const void * result)179 validate_conversion_result(const void *result)
180 {
181 T_ASSERT_NOTNULL(result, "The conversion is invalid at %s:%u", __FILE__, __LINE__);
182 }
183
184
185 static void
test_valid_conversions_to_bytes()186 test_valid_conversions_to_bytes()
187 {
188 uint8_t *result;
189 const uint8_t *const_result;
190
191 /* Non-const to non-const conversions. */
192 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_ptr);
193 validate_conversion_result(result);
194
195 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_storage_ptr);
196 validate_conversion_result(result);
197
198 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_ctl_ptr);
199 validate_conversion_result(result);
200
201 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_dl_ptr);
202 validate_conversion_result(result);
203
204 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_in_ptr);
205 validate_conversion_result(result);
206
207 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_in6_ptr);
208 validate_conversion_result(result);
209
210 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_inarp_ptr);
211 validate_conversion_result(result);
212
213 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_inifscope_ptr);
214 validate_conversion_result(result);
215
216 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_ndrv_ptr);
217 validate_conversion_result(result);
218
219 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_sys_ptr);
220 validate_conversion_result(result);
221
222 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_un_ptr);
223 validate_conversion_result(result);
224
225 result = __SA_UTILS_CONV_TO_BYTES(sockaddr_in_4_6_ptr);
226 validate_conversion_result(result);
227
228 /* Const to const conversions. */
229 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_const_ptr);
230 validate_conversion_result(const_result);
231
232 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_storage_const_ptr);
233 validate_conversion_result(const_result);
234
235 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_ctl_const_ptr);
236 validate_conversion_result(const_result);
237
238 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_dl_const_ptr);
239 validate_conversion_result(const_result);
240
241 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_in_const_ptr);
242 validate_conversion_result(const_result);
243
244 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_in6_const_ptr);
245 validate_conversion_result(const_result);
246
247 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_inarp_const_ptr);
248 validate_conversion_result(const_result);
249
250 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_inifscope_const_ptr);
251 validate_conversion_result(const_result);
252
253 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_ndrv_const_ptr);
254 validate_conversion_result(const_result);
255
256 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_sys_const_ptr);
257 validate_conversion_result(const_result);
258
259 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_un_const_ptr);
260 validate_conversion_result(const_result);
261
262 const_result = __SA_UTILS_CONV_TO_BYTES(sockaddr_in_4_6_const_ptr);
263 validate_conversion_result(const_result);
264 }
265
266 static void
test_valid_conversions_to_sockaddr()267 test_valid_conversions_to_sockaddr()
268 {
269 struct sockaddr *result;
270 const struct sockaddr *const_result;
271
272 /* Non-const to non-const conversions. */
273 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_ptr);
274 validate_conversion_result(result);
275
276 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_storage_ptr);
277 validate_conversion_result(result);
278
279 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_ctl_ptr);
280 validate_conversion_result(result);
281
282 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_dl_ptr);
283 validate_conversion_result(result);
284
285 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_in_ptr);
286 validate_conversion_result(result);
287
288 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_in6_ptr);
289 validate_conversion_result(result);
290
291 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_inarp_ptr);
292 validate_conversion_result(result);
293
294 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_inifscope_ptr);
295 validate_conversion_result(result);
296
297 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_ndrv_ptr);
298 validate_conversion_result(result);
299
300 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_sys_ptr);
301 validate_conversion_result(result);
302
303 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_un_ptr);
304 validate_conversion_result(result);
305
306 result = __SA_UTILS_CONV_TO_SOCKADDR(bytes_ptr);
307 validate_conversion_result(result);
308
309 result = __SA_UTILS_CONV_TO_SOCKADDR(uint8_t_ptr);
310 validate_conversion_result(result);
311
312 result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_in_4_6_ptr);
313 validate_conversion_result(result);
314
315
316 /* Const to const conversions. */
317 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_const_ptr);
318 validate_conversion_result(const_result);
319
320 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_storage_const_ptr);
321 validate_conversion_result(const_result);
322
323 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_ctl_const_ptr);
324 validate_conversion_result(const_result);
325
326 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_dl_const_ptr);
327 validate_conversion_result(const_result);
328
329 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_in_const_ptr);
330 validate_conversion_result(const_result);
331
332 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_in6_const_ptr);
333 validate_conversion_result(const_result);
334
335 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_inarp_const_ptr);
336 validate_conversion_result(const_result);
337
338 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_inifscope_const_ptr);
339 validate_conversion_result(const_result);
340
341 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_ndrv_const_ptr);
342 validate_conversion_result(const_result);
343
344 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_sys_const_ptr);
345 validate_conversion_result(const_result);
346
347 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_un_const_ptr);
348 validate_conversion_result(const_result);
349
350 const_result = __SA_UTILS_CONV_TO_SOCKADDR(bytes_const_ptr);
351 validate_conversion_result(const_result);
352
353 const_result = __SA_UTILS_CONV_TO_SOCKADDR(uint8_t_const_ptr);
354 validate_conversion_result(const_result);
355
356 const_result = __SA_UTILS_CONV_TO_SOCKADDR(sockaddr_in_4_6_const_ptr);
357 validate_conversion_result(const_result);
358
359 /* Const to non-const (a.k.a. "deconst") conversions. */
360 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_const_ptr);
361 validate_conversion_result(result);
362
363 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_storage_const_ptr);
364 validate_conversion_result(result);
365
366 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_ctl_const_ptr);
367 validate_conversion_result(result);
368
369 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_dl_const_ptr);
370 validate_conversion_result(result);
371
372 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_in_const_ptr);
373 validate_conversion_result(result);
374
375 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_in6_const_ptr);
376 validate_conversion_result(result);
377
378 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_inarp_const_ptr);
379 validate_conversion_result(result);
380
381 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_inifscope_const_ptr);
382 validate_conversion_result(result);
383
384 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_ndrv_const_ptr);
385 validate_conversion_result(result);
386
387 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_sys_const_ptr);
388 validate_conversion_result(result);
389
390 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_un_const_ptr);
391 validate_conversion_result(result);
392
393 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR(sockaddr_in_4_6_const_ptr);
394 validate_conversion_result(result);
395 }
396
397 static void
test_valid_conversions_to_sockaddr_ctl()398 test_valid_conversions_to_sockaddr_ctl()
399 {
400 struct sockaddr_ctl *result;
401 const struct sockaddr_ctl *const_result;
402
403 /* Non-const to non-const conversions. */
404 result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(sockaddr_ptr);
405 validate_conversion_result(result);
406
407 result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(sockaddr_storage_ptr);
408 validate_conversion_result(result);
409
410 result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(sockaddr_ctl_ptr);
411 validate_conversion_result(result);
412
413 result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(bytes_ptr);
414 validate_conversion_result(result);
415
416 result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(uint8_t_ptr);
417 validate_conversion_result(result);
418
419 /* Const to const conversions. */
420 const_result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(sockaddr_const_ptr);
421 validate_conversion_result(const_result);
422
423 const_result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(sockaddr_storage_const_ptr);
424 validate_conversion_result(const_result);
425
426 const_result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(sockaddr_ctl_const_ptr);
427 validate_conversion_result(const_result);
428
429 const_result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(bytes_const_ptr);
430 validate_conversion_result(const_result);
431
432 const_result = __SA_UTILS_CONV_TO_SOCKADDR_CTL(uint8_t_const_ptr);
433 validate_conversion_result(const_result);
434
435 /* Const to non-const (a.k.a. "deconst") conversions. */
436 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_CTL(sockaddr_const_ptr);
437 validate_conversion_result(result);
438
439 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_CTL(sockaddr_storage_const_ptr);
440 validate_conversion_result(result);
441
442 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_CTL(sockaddr_ctl_const_ptr);
443 validate_conversion_result(result);
444 }
445
446 static void
test_valid_conversions_to_sockaddr_dl()447 test_valid_conversions_to_sockaddr_dl()
448 {
449 struct sockaddr_dl *result;
450 const struct sockaddr_dl *const_result;
451
452 /* Non-const to non-const conversions. */
453 result = __SA_UTILS_CONV_TO_SOCKADDR_DL(sockaddr_ptr);
454 validate_conversion_result(result);
455
456 result = __SA_UTILS_CONV_TO_SOCKADDR_DL(sockaddr_storage_ptr);
457 validate_conversion_result(result);
458
459 result = __SA_UTILS_CONV_TO_SOCKADDR_DL(sockaddr_dl_ptr);
460 validate_conversion_result(result);
461
462 result = __SA_UTILS_CONV_TO_SOCKADDR_DL(bytes_ptr);
463 validate_conversion_result(result);
464
465 result = __SA_UTILS_CONV_TO_SOCKADDR_DL(uint8_t_ptr);
466 validate_conversion_result(result);
467
468 /* Const to const conversions. */
469 const_result = __SA_UTILS_CONV_TO_SOCKADDR_DL(sockaddr_const_ptr);
470 validate_conversion_result(const_result);
471
472 const_result = __SA_UTILS_CONV_TO_SOCKADDR_DL(sockaddr_storage_const_ptr);
473 validate_conversion_result(const_result);
474
475 const_result = __SA_UTILS_CONV_TO_SOCKADDR_DL(sockaddr_dl_const_ptr);
476 validate_conversion_result(const_result);
477
478 const_result = __SA_UTILS_CONV_TO_SOCKADDR_DL(bytes_const_ptr);
479 validate_conversion_result(const_result);
480
481 const_result = __SA_UTILS_CONV_TO_SOCKADDR_DL(uint8_t_const_ptr);
482 validate_conversion_result(const_result);
483
484 /* Const to non-const (a.k.a. "deconst") conversions. */
485 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_DL(sockaddr_const_ptr);
486 validate_conversion_result(result);
487
488 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_DL(sockaddr_storage_const_ptr);
489 validate_conversion_result(result);
490
491 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_DL(sockaddr_dl_const_ptr);
492 validate_conversion_result(result);
493 }
494
495 static void
test_valid_conversions_to_sockaddr_in()496 test_valid_conversions_to_sockaddr_in()
497 {
498 struct sockaddr_in *result;
499 const struct sockaddr_in *const_result;
500
501 /* Non-const to non-const conversions. */
502 result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_ptr);
503 validate_conversion_result(result);
504
505 result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_storage_ptr);
506 validate_conversion_result(result);
507
508 result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_in_ptr);
509 validate_conversion_result(result);
510
511 result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_in_4_6_ptr);
512 validate_conversion_result(result);
513
514 result = __SA_UTILS_CONV_TO_SOCKADDR_IN(bytes_ptr);
515 validate_conversion_result(result);
516
517 result = __SA_UTILS_CONV_TO_SOCKADDR_IN(uint8_t_ptr);
518 validate_conversion_result(result);
519
520 /* Const to const conversions. */
521 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_const_ptr);
522 validate_conversion_result(const_result);
523
524 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_storage_const_ptr);
525 validate_conversion_result(const_result);
526
527 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_in_const_ptr);
528 validate_conversion_result(const_result);
529
530 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN(sockaddr_in_4_6_const_ptr);
531 validate_conversion_result(const_result);
532
533 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN(bytes_const_ptr);
534 validate_conversion_result(const_result);
535
536 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN(uint8_t_const_ptr);
537 validate_conversion_result(const_result);
538
539 /* Const to non-const (a.k.a. "deconst") conversions. */
540 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN(sockaddr_const_ptr);
541 validate_conversion_result(result);
542
543 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN(sockaddr_storage_const_ptr);
544 validate_conversion_result(result);
545
546 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN(sockaddr_in_const_ptr);
547 validate_conversion_result(result);
548
549 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN(sockaddr_in_4_6_const_ptr);
550 validate_conversion_result(result);
551 }
552
553 static void
test_valid_conversions_to_sockaddr_in6()554 test_valid_conversions_to_sockaddr_in6()
555 {
556 struct sockaddr_in6 *result;
557 const struct sockaddr_in6 *const_result;
558
559 /* Non-const to non-const conversions. */
560 result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_ptr);
561 validate_conversion_result(result);
562
563 result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_storage_ptr);
564 validate_conversion_result(result);
565
566 result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_in6_ptr);
567 validate_conversion_result(result);
568
569 result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_in_4_6_ptr);
570 validate_conversion_result(result);
571
572 result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(bytes_ptr);
573 validate_conversion_result(result);
574
575 result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(uint8_t_ptr);
576 validate_conversion_result(result);
577
578 /* Const to const conversions. */
579 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_const_ptr);
580 validate_conversion_result(const_result);
581
582 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_storage_const_ptr);
583 validate_conversion_result(const_result);
584
585 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_in6_const_ptr);
586 validate_conversion_result(const_result);
587
588 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(sockaddr_in_4_6_const_ptr);
589 validate_conversion_result(const_result);
590
591 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(bytes_const_ptr);
592 validate_conversion_result(const_result);
593
594 const_result = __SA_UTILS_CONV_TO_SOCKADDR_IN6(uint8_t_const_ptr);
595 validate_conversion_result(const_result);
596
597 /* Const to non-const (a.k.a. "deconst") conversions. */
598 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN6(sockaddr_const_ptr);
599 validate_conversion_result(result);
600
601 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN6(sockaddr_storage_const_ptr);
602 validate_conversion_result(result);
603
604 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN6(sockaddr_in6_const_ptr);
605 validate_conversion_result(result);
606
607 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_IN6(sockaddr_in_4_6_const_ptr);
608 validate_conversion_result(result);
609 }
610
611 static void
test_valid_conversions_to_sockaddr_inarp()612 test_valid_conversions_to_sockaddr_inarp()
613 {
614 struct sockaddr_inarp *result;
615 const struct sockaddr_inarp *const_result;
616
617 /* Non-const to non-const conversions. */
618 result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(sockaddr_ptr);
619 validate_conversion_result(result);
620
621 result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(sockaddr_storage_ptr);
622 validate_conversion_result(result);
623
624 result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(sockaddr_inarp_ptr);
625 validate_conversion_result(result);
626
627 result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(bytes_ptr);
628 validate_conversion_result(result);
629
630 result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(uint8_t_ptr);
631 validate_conversion_result(result);
632
633 /* Const to const conversions. */
634 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(sockaddr_const_ptr);
635 validate_conversion_result(const_result);
636
637 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(sockaddr_storage_const_ptr);
638 validate_conversion_result(const_result);
639
640 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(sockaddr_inarp_const_ptr);
641 validate_conversion_result(const_result);
642
643 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(bytes_const_ptr);
644 validate_conversion_result(const_result);
645
646 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INARP(uint8_t_const_ptr);
647 validate_conversion_result(const_result);
648
649 /* Const to non-const (a.k.a. "deconst") conversions. */
650 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_INARP(sockaddr_const_ptr);
651 validate_conversion_result(result);
652
653 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_INARP(sockaddr_storage_const_ptr);
654 validate_conversion_result(result);
655
656 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_INARP(sockaddr_inarp_const_ptr);
657 validate_conversion_result(result);
658 }
659
660 static void
test_valid_conversions_to_sockaddr_inifscope()661 test_valid_conversions_to_sockaddr_inifscope()
662 {
663 struct sockaddr_inifscope *result;
664 const struct sockaddr_inifscope *const_result;
665
666 /* Non-const to non-const conversions. */
667 result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_ptr);
668 validate_conversion_result(result);
669
670 result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_storage_ptr);
671 validate_conversion_result(result);
672
673 result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_inifscope_ptr);
674 validate_conversion_result(result);
675
676 result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_in_4_6_ptr);
677 validate_conversion_result(result);
678
679 result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(bytes_ptr);
680 validate_conversion_result(result);
681
682 result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(uint8_t_ptr);
683 validate_conversion_result(result);
684
685 /* Const to const conversions. */
686 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_const_ptr);
687 validate_conversion_result(const_result);
688
689 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_storage_const_ptr);
690 validate_conversion_result(const_result);
691
692 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_inifscope_const_ptr);
693 validate_conversion_result(const_result);
694
695 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_in_4_6_const_ptr);
696 validate_conversion_result(const_result);
697
698 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(bytes_const_ptr);
699 validate_conversion_result(const_result);
700
701 const_result = __SA_UTILS_CONV_TO_SOCKADDR_INIFSCOPE(uint8_t_const_ptr);
702 validate_conversion_result(const_result);
703
704 /* Const to non-const (a.k.a. "deconst") conversions. */
705 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_const_ptr);
706 validate_conversion_result(result);
707
708 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_storage_const_ptr);
709 validate_conversion_result(result);
710
711 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_inifscope_const_ptr);
712 validate_conversion_result(result);
713
714 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_INIFSCOPE(sockaddr_in_4_6_const_ptr);
715 validate_conversion_result(result);
716 }
717
718 static void
test_valid_conversions_to_sockaddr_ndrv()719 test_valid_conversions_to_sockaddr_ndrv()
720 {
721 struct sockaddr_ndrv *result;
722 const struct sockaddr_ndrv *const_result;
723
724 /* Non-const to non-const conversions. */
725 result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(sockaddr_ptr);
726 validate_conversion_result(result);
727
728 result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(sockaddr_storage_ptr);
729 validate_conversion_result(result);
730
731 result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(sockaddr_ndrv_ptr);
732 validate_conversion_result(result);
733
734 result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(bytes_ptr);
735 validate_conversion_result(result);
736
737 result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(uint8_t_ptr);
738 validate_conversion_result(result);
739
740 /* Const to const conversions. */
741 const_result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(sockaddr_const_ptr);
742 validate_conversion_result(const_result);
743
744 const_result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(sockaddr_storage_const_ptr);
745 validate_conversion_result(const_result);
746
747 const_result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(sockaddr_ndrv_const_ptr);
748 validate_conversion_result(const_result);
749
750 const_result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(bytes_const_ptr);
751 validate_conversion_result(const_result);
752
753 const_result = __SA_UTILS_CONV_TO_SOCKADDR_NDRV(uint8_t_const_ptr);
754 validate_conversion_result(const_result);
755
756 /* Const to non-const (a.k.a. "deconst") conversions. */
757 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_NDRV(sockaddr_const_ptr);
758 validate_conversion_result(result);
759
760 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_NDRV(sockaddr_storage_const_ptr);
761 validate_conversion_result(result);
762
763 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_NDRV(sockaddr_ndrv_const_ptr);
764 validate_conversion_result(result);
765 }
766
767 static void
test_valid_conversions_to_sockaddr_sys()768 test_valid_conversions_to_sockaddr_sys()
769 {
770 struct sockaddr_sys *result;
771 const struct sockaddr_sys *const_result;
772
773 /* Non-const to non-const conversions. */
774 result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(sockaddr_ptr);
775 validate_conversion_result(result);
776
777 result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(sockaddr_storage_ptr);
778 validate_conversion_result(result);
779
780 result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(sockaddr_sys_ptr);
781 validate_conversion_result(result);
782
783 result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(bytes_ptr);
784 validate_conversion_result(result);
785
786 result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(uint8_t_ptr);
787 validate_conversion_result(result);
788
789 /* Const to const conversions. */
790 const_result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(sockaddr_const_ptr);
791 validate_conversion_result(const_result);
792
793 const_result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(sockaddr_storage_const_ptr);
794 validate_conversion_result(const_result);
795
796 const_result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(sockaddr_sys_const_ptr);
797 validate_conversion_result(const_result);
798
799 const_result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(bytes_const_ptr);
800 validate_conversion_result(const_result);
801
802 const_result = __SA_UTILS_CONV_TO_SOCKADDR_SYS(uint8_t_const_ptr);
803 validate_conversion_result(const_result);
804
805 /* Const to non-const (a.k.a. "deconst") conversions. */
806 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_SYS(sockaddr_const_ptr);
807 validate_conversion_result(result);
808
809 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_SYS(sockaddr_storage_const_ptr);
810 validate_conversion_result(result);
811
812 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_SYS(sockaddr_sys_const_ptr);
813 validate_conversion_result(result);
814 }
815
816 static void
test_valid_conversions_to_sockaddr_un()817 test_valid_conversions_to_sockaddr_un()
818 {
819 struct sockaddr_un *result;
820 const struct sockaddr_un *const_result;
821
822 /* Non-const to non-const conversions. */
823 result = __SA_UTILS_CONV_TO_SOCKADDR_UN(sockaddr_ptr);
824 validate_conversion_result(result);
825
826 result = __SA_UTILS_CONV_TO_SOCKADDR_UN(sockaddr_storage_ptr);
827 validate_conversion_result(result);
828
829 result = __SA_UTILS_CONV_TO_SOCKADDR_UN(sockaddr_un_ptr);
830 validate_conversion_result(result);
831
832 result = __SA_UTILS_CONV_TO_SOCKADDR_UN(bytes_ptr);
833 validate_conversion_result(result);
834
835 result = __SA_UTILS_CONV_TO_SOCKADDR_UN(uint8_t_ptr);
836 validate_conversion_result(result);
837
838 /* Const to const conversions. */
839 const_result = __SA_UTILS_CONV_TO_SOCKADDR_UN(sockaddr_const_ptr);
840 validate_conversion_result(const_result);
841
842 const_result = __SA_UTILS_CONV_TO_SOCKADDR_UN(sockaddr_storage_const_ptr);
843 validate_conversion_result(const_result);
844
845 const_result = __SA_UTILS_CONV_TO_SOCKADDR_UN(sockaddr_un_const_ptr);
846 validate_conversion_result(const_result);
847
848 const_result = __SA_UTILS_CONV_TO_SOCKADDR_UN(bytes_const_ptr);
849 validate_conversion_result(const_result);
850
851 const_result = __SA_UTILS_CONV_TO_SOCKADDR_UN(uint8_t_const_ptr);
852 validate_conversion_result(const_result);
853
854 /* Const to non-const (a.k.a. "deconst") conversions. */
855 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_UN(sockaddr_const_ptr);
856 validate_conversion_result(result);
857
858 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_UN(sockaddr_storage_const_ptr);
859 validate_conversion_result(result);
860
861 result = __SA_UTILS_DECONST_AND_CONV_TO_SOCKADDR_UN(sockaddr_un_const_ptr);
862 validate_conversion_result(result);
863 }
864
865 static int
sockaddr_utils_test_run(__unused int64_t in,int64_t * out)866 sockaddr_utils_test_run(__unused int64_t in, int64_t *out)
867 {
868 test_valid_conversions_to_bytes();
869 test_valid_conversions_to_sockaddr();
870 test_valid_conversions_to_sockaddr_ctl();
871 test_valid_conversions_to_sockaddr_dl();
872 test_valid_conversions_to_sockaddr_in();
873 test_valid_conversions_to_sockaddr_in6();
874 test_valid_conversions_to_sockaddr_inarp();
875 test_valid_conversions_to_sockaddr_inifscope();
876 test_valid_conversions_to_sockaddr_ndrv();
877 test_valid_conversions_to_sockaddr_sys();
878 test_valid_conversions_to_sockaddr_un();
879
880 *out = 0;
881 return 0;
882 }
883
884 SYSCTL_TEST_REGISTER(sockaddr_utils_test, sockaddr_utils_test_run);
885
886 #endif /* DEVELOPMENT || DEBUG */
887