1 /*
2 * Check decoding of sockaddr fields under xlat styles.
3 *
4 * Copyright (c) 2015-2021 The strace developers.
5 * All rights reserved.
6 *
7 * SPDX-License-Identifier: GPL-2.0-or-later
8 */
9 #include "tests.h"
10 #include <stdio.h>
11 #include <sys/socket.h>
12 #include <arpa/inet.h>
13 #include <netinet/in.h>
14 #include <linux/ax25.h>
15 #include <linux/if_arp.h>
16 #include <linux/if_ether.h>
17 #include <linux/if_packet.h>
18 #include <linux/mctp.h>
19
20 #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
21 # include <bluetooth/bluetooth.h>
22 # include <bluetooth/hci.h>
23 # include <bluetooth/l2cap.h>
24 # include <bluetooth/rfcomm.h>
25 # include <bluetooth/sco.h>
26 #endif
27
28 #ifdef HAVE_LINUX_RXRPC_H
29 # include <linux/rxrpc.h>
30 #else
31 struct sockaddr_rxrpc {
32 uint16_t srx_family;
33 uint16_t srx_service;
34 uint16_t transport_type;
35 uint16_t transport_len;
36 union {
37 uint16_t family;
38 struct sockaddr_in sin;
39 struct sockaddr_in6 sin6;
40 } transport;
41 };
42 #endif
43
44 /* From include/net/af_ieee802154.h */
45 enum {
46 IEEE802154_ADDR_NONE = 0x0,
47 /* RESERVED = 0x01, */
48 IEEE802154_ADDR_SHORT = 0x2, /* 16-bit address + PANid */
49 IEEE802154_ADDR_LONG = 0x3, /* 64-bit address + PANid */
50 };
51
52 /* address length, octets */
53 #define IEEE802154_ADDR_LEN 8
54
55 struct ieee802154_addr_sa {
56 int addr_type;
57 uint16_t pan_id;
58 union {
59 uint8_t hwaddr[IEEE802154_ADDR_LEN];
60 uint16_t short_addr;
61 };
62 };
63
64 #define IEEE802154_PANID_BROADCAST 0xffff
65 #define IEEE802154_ADDR_BROADCAST 0xffff
66 #define IEEE802154_ADDR_UNDEF 0xfffe
67
68 struct sockaddr_ieee802154 {
69 __kernel_sa_family_t family; /* AF_IEEE802154 */
70 struct ieee802154_addr_sa addr;
71 };
72 /* End of include/net/af_ieee802154.h copy-paste */
73
74 #ifdef HAVE_LINUX_IF_ALG_H
75 # include <linux/if_alg.h>
76 #else
77 struct sockaddr_alg {
78 uint16_t salg_family;
79 uint8_t salg_type[14];
80 uint32_t salg_feat;
81 uint32_t salg_mask;
82 uint8_t salg_name[64];
83 };
84 #endif
85
86 #ifndef CRYPTO_ALG_KERN_DRIVER_ONLY
87 # define CRYPTO_ALG_KERN_DRIVER_ONLY 0x1000
88 #endif
89
90 #ifndef HAVE_STRUCT_SOCKADDR_ALG_NEW
91 struct sockaddr_alg_new {
92 uint16_t salg_family;
93 uint8_t salg_type[14];
94 uint32_t salg_feat;
95 uint32_t salg_mask;
96 uint8_t salg_name[];
97 };
98 #endif
99
100 #ifdef HAVE_LINUX_NFC_H
101 # include <linux/nfc.h>
102 #else
103 struct sockaddr_nfc {
104 uint16_t sa_family;
105 uint32_t dev_idx;
106 uint32_t target_idx;
107 uint32_t nfc_protocol;
108 };
109
110 # define NFC_LLCP_MAX_SERVICE_NAME 63
111 struct sockaddr_nfc_llcp {
112 uint16_t sa_family;
113 uint32_t dev_idx;
114 uint32_t target_idx;
115 uint32_t nfc_protocol;
116 uint8_t dsap;
117 uint8_t ssap;
118 char service_name[NFC_LLCP_MAX_SERVICE_NAME];
119 size_t service_name_len;
120 };
121 #endif
122
123 #ifdef HAVE_LINUX_VM_SOCKETS_H
124 # include <linux/vm_sockets.h>
125 #endif
126
127 #ifdef HAVE_STRUCT_SOCKADDR_VM
128 # ifdef HAVE_STRUCT_SOCKADDR_VM_SVM_FLAGS
129 # define SVM_FLAGS svm_flags
130 # define SVM_ZERO svm_zero
131 # define SVM_ZERO_FIRST svm_zero[0]
132 # else
133 # define SVM_FLAGS svm_zero[0]
134 # define SVM_ZERO svm_zero + 1
135 # define SVM_ZERO_FIRST svm_zero[1]
136 # endif
137 #else
138 struct sockaddr_vm {
139 uint16_t svm_family;
140 uint16_t svm_reserved1;
141 uint32_t svm_port;
142 uint32_t svm_cid;
143 uint8_t svm_flags;
144 uint8_t svm_zero[sizeof(struct sockaddr) - 13];
145 };
146 # define SVM_FLAGS svm_flags
147 # define SVM_ZERO svm_zero
148 # define SVM_ZERO_FIRST svm_zero[0]
149 #endif
150
151 #ifdef HAVE_LINUX_QRTR_H
152 # include <linux/qrtr.h>
153 #else
154 struct sockaddr_qrtr {
155 uint16_t sq_family;
156 uint32_t sq_node;
157 uint32_t sq_port;
158 };
159 #endif
160
161 #ifdef HAVE_LINUX_IF_XDP_H
162 # include <linux/if_xdp.h>
163 #endif
164
165 #ifndef HAVE_STRUCT_SOCKADDR_XDP
166 struct sockaddr_xdp {
167 uint16_t sxdp_family;
168 uint16_t sxdp_flags;
169 uint32_t sxdp_ifindex;
170 uint32_t sxdp_queue_id;
171 uint32_t sxdp_shared_umem_fd;
172 };
173 #endif
174
175 #include "xlat.h"
176 #include "xlat/addrfams.h"
177 #include "xlat/xdp_sockaddr_flags.h"
178
179 #ifndef SKIP_IF_PROC_IS_UNAVAILABLE
180 # define SKIP_IF_PROC_IS_UNAVAILABLE
181 #endif
182 #ifndef FD0_PATH
183 # define FD0_PATH ""
184 #endif
185 #ifndef FD7_PATH
186 # define FD7_PATH ""
187 #endif
188
189 static void
190 check_ll(void)
191 {
192 struct sockaddr_ll c_ll = {
193 .sll_family = AF_PACKET,
194 .sll_protocol = htons(ETH_P_ALL),
195 .sll_ifindex = 0xfacefeed,
196 .sll_hatype = ARPHRD_ETHER,
197 .sll_pkttype = PACKET_HOST,
198 .sll_halen = sizeof(c_ll.sll_addr),
199 .sll_addr = "abcdefgh"
200 };
201 unsigned int len = sizeof(c_ll);
202 int rc = connect(-1, (void *) &c_ll, len);
203 const char *errstr = sprintrc(rc);
204
205 #if XLAT_RAW
206 printf("connect(-1, {sa_family=%#x, sll_protocol=", AF_PACKET);
207 print_quoted_hex(&c_ll.sll_protocol, sizeof(c_ll.sll_protocol));
208 printf(", sll_ifindex=%u, sll_hatype=%#x"
209 ", sll_pkttype=%u, sll_halen=%u, sll_addr="
210 "[%#02x, %#02x, %#02x, %#02x, %#02x, %#02x, %#02x, %#02x]"
211 "}, %u) = %s\n",
212 c_ll.sll_ifindex, ARPHRD_ETHER,
213 PACKET_HOST, c_ll.sll_halen,
214 c_ll.sll_addr[0], c_ll.sll_addr[1],
215 c_ll.sll_addr[2], c_ll.sll_addr[3],
216 c_ll.sll_addr[4], c_ll.sll_addr[5],
217 c_ll.sll_addr[6], c_ll.sll_addr[7],
218 len, errstr);
219 #elif XLAT_VERBOSE
220 printf("connect(-1, {sa_family=%#x /* AF_PACKET */"
221 ", sll_protocol=", AF_PACKET);
222 print_quoted_hex(&c_ll.sll_protocol, sizeof(c_ll.sll_protocol));
223 printf(" /* htons(ETH_P_ALL) */"
224 ", sll_ifindex=%u, sll_hatype=%#x /* ARPHRD_ETHER */"
225 ", sll_pkttype=%u /* PACKET_HOST */, sll_halen=%u, sll_addr="
226 "[%#02x, %#02x, %#02x, %#02x, %#02x, %#02x, %#02x, %#02x]"
227 "}, %u) = %s\n",
228 c_ll.sll_ifindex, ARPHRD_ETHER,
229 PACKET_HOST, c_ll.sll_halen,
230 c_ll.sll_addr[0], c_ll.sll_addr[1],
231 c_ll.sll_addr[2], c_ll.sll_addr[3],
232 c_ll.sll_addr[4], c_ll.sll_addr[5],
233 c_ll.sll_addr[6], c_ll.sll_addr[7],
234 len, errstr);
235
236 #else /* XLAT_ABBREV */
237 printf("connect(-1, {sa_family=AF_PACKET"
238 ", sll_protocol=htons(ETH_P_ALL)"
239 ", sll_ifindex=%u, sll_hatype=ARPHRD_ETHER"
240 ", sll_pkttype=PACKET_HOST, sll_halen=%u, sll_addr="
241 "[%#02x, %#02x, %#02x, %#02x, %#02x, %#02x, %#02x, %#02x]"
242 "}, %u) = %s\n",
243 c_ll.sll_ifindex, c_ll.sll_halen,
244 c_ll.sll_addr[0], c_ll.sll_addr[1],
245 c_ll.sll_addr[2], c_ll.sll_addr[3],
246 c_ll.sll_addr[4], c_ll.sll_addr[5],
247 c_ll.sll_addr[6], c_ll.sll_addr[7],
248 len, errstr);
249 #endif
250 }
251
252 static void
253 check_in(void)
254 {
255 const unsigned short h_port = 12345;
256 static const char h_addr[] = "127.0.0.1";
257 struct sockaddr_in in = {
258 .sin_family = AF_INET,
259 .sin_port = htons(h_port),
260 .sin_addr.s_addr = inet_addr(h_addr)
261 };
262 unsigned int len = sizeof(in);
263 int rc = connect(-1, (void *) &in, len);
264 const char * errstr = sprintrc(rc);
265 #if XLAT_RAW
266 printf("connect(-1, {sa_family=%#x, sin_port=", AF_INET);
267 print_quoted_hex((const void *) &in.sin_port, sizeof(in.sin_port));
268 printf(", sin_addr=");
269 print_quoted_hex((const void *) &in.sin_addr.s_addr,
270 sizeof(in.sin_addr.s_addr));
271 printf("}, %u) = %s\n", len, errstr);
272 #elif XLAT_VERBOSE
273 printf("connect(-1, {sa_family=%#x /* AF_INET */, sin_port=", AF_INET);
274 print_quoted_hex((const void *) &in.sin_port, sizeof(in.sin_port));
275 printf(" /* htons(%hu) */, sin_addr=", h_port);
276 print_quoted_hex((const void *) &in.sin_addr.s_addr,
277 sizeof(in.sin_addr.s_addr));
278 printf(" /* inet_addr(\"%s\") */}, %u) = %s\n",
279 h_addr, len, errstr);
280 #else /* XLAT_ABBREV */
281 printf("connect(-1, {sa_family=AF_INET, sin_port=htons(%hu)"
282 ", sin_addr=inet_addr(\"%s\")}, %u) = %s\n",
283 h_port, h_addr, len, errstr);
284 #endif
285 }
286
287 static void
288 validate_in6(struct sockaddr_in6 *const in6, const char *const h_addr)
289 {
290 inet_pton(AF_INET6, h_addr, &in6->sin6_addr);
291
292 unsigned int len = sizeof(*in6);
293 int rc = connect(-1, (void *) in6, len);
294 const char *errstr = sprintrc(rc);
295 #if XLAT_RAW
296 printf("connect(-1, {sa_family=%#x, sin6_port=", AF_INET6);
297 print_quoted_hex(&in6->sin6_port, sizeof(in6->sin6_port));
298 printf(", sin6_flowinfo=");
299 print_quoted_hex(&in6->sin6_flowinfo, sizeof(in6->sin6_flowinfo));
300 printf(", sin6_addr=");
301 print_quoted_hex(&in6->sin6_addr, sizeof(struct in6_addr));
302 printf(", sin6_scope_id=%u}, %u) = %s\n",
303 in6->sin6_scope_id, len, errstr);
304 #elif XLAT_VERBOSE
305 printf("connect(-1, {sa_family=%#x /* AF_INET6 */", AF_INET6);
306 printf(", sin6_port=");
307 print_quoted_hex(&in6->sin6_port, sizeof(in6->sin6_port));
308 printf(" /* htons(%hu) */", ntohs(in6->sin6_port));
309 printf(", sin6_flowinfo=");
310 print_quoted_hex(&in6->sin6_flowinfo, sizeof(in6->sin6_flowinfo));
311 printf(" /* htonl(%u) */", ntohl(in6->sin6_flowinfo));
312 printf(", sin6_addr=");
313 print_quoted_hex(&in6->sin6_addr, sizeof(struct in6_addr));
314 printf(" /* inet_pton(AF_INET6, \"%s\") */", h_addr);
315 printf(", sin6_scope_id=%u}, %u) = %s\n",
316 in6->sin6_scope_id, len, errstr);
317 #else
318 printf("connect(-1, {sa_family=AF_INET6, sin6_port=htons(%hu)"
319 ", sin6_flowinfo=htonl(%u)"
320 ", inet_pton(AF_INET6, \"%s\", &sin6_addr)"
321 ", sin6_scope_id=%u}, %u)"
322 " = %s\n",
323 ntohs(in6->sin6_port), ntohl(in6->sin6_flowinfo),
324 h_addr, in6->sin6_scope_id, len, errstr);
325 #endif
326 }
327
328 static void
329 check_in6(void)
330 {
331 struct sockaddr_in6 in6 = {
332 .sin6_family = AF_INET6,
333 .sin6_port = htons(12345),
334 .sin6_flowinfo = htonl(123456890),
335 .sin6_scope_id = 0xfacefeed
336 };
337
338 validate_in6(&in6, "12:34:56:78:90:ab:cd:ef");
339 validate_in6(&in6, "::");
340 validate_in6(&in6, "::1");
341 }
342
343 #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
344 static void
345 check_sco(void)
346 {
347 const struct sockaddr_sco c_sco = {
348 .sco_family = AF_BLUETOOTH,
349 .sco_bdaddr.b = "abcdef"
350 };
351 void *sco = tail_memdup(&c_sco, sizeof(c_sco));
352 unsigned int len = sizeof(c_sco);
353 int ret = connect(-1, sco, len);
354 const char *errstr = sprintrc(ret);
355 # if XLAT_RAW
356 printf("connect(-1, {sa_family=%#x, sco_bdaddr=", AF_BLUETOOTH);
357 print_quoted_hex((const void *) &c_sco.sco_bdaddr,
358 sizeof(c_sco.sco_bdaddr));
359 printf("}, %u) = %s\n", len, errstr);
360 # elif XLAT_VERBOSE
361 printf("connect(-1, {sa_family=%#x /* AF_BLUETOOTH */"
362 ", sco_bdaddr=", AF_BLUETOOTH);
363 print_quoted_hex((const void *) &c_sco.sco_bdaddr,
364 sizeof(c_sco.sco_bdaddr));
365 printf(" /* %02x:%02x:%02x:%02x:%02x:%02x */"
366 "}, %u) = %s\n",
367 c_sco.sco_bdaddr.b[0], c_sco.sco_bdaddr.b[1],
368 c_sco.sco_bdaddr.b[2], c_sco.sco_bdaddr.b[3],
369 c_sco.sco_bdaddr.b[4], c_sco.sco_bdaddr.b[5],
370 len, errstr);
371 # else
372 printf("connect(-1, {sa_family=AF_BLUETOOTH"
373 ", sco_bdaddr=%02x:%02x:%02x:%02x:%02x:%02x"
374 "}, %u) = %s\n",
375 c_sco.sco_bdaddr.b[0], c_sco.sco_bdaddr.b[1],
376 c_sco.sco_bdaddr.b[2], c_sco.sco_bdaddr.b[3],
377 c_sco.sco_bdaddr.b[4], c_sco.sco_bdaddr.b[5],
378 len, errstr);
379 # endif
380 }
381
382 static void
383 check_rc(void)
384 {
385 const struct sockaddr_rc c_rc = {
386 .rc_family = AF_BLUETOOTH,
387 .rc_bdaddr.b = "abcdef",
388 .rc_channel = 42
389 };
390 void *rc = tail_memdup(&c_rc, sizeof(c_rc));
391 unsigned int len = sizeof(c_rc);
392 int ret = connect(-1, rc, len);
393 const char *errstr = sprintrc(ret);
394 # if XLAT_RAW
395 printf("connect(-1, {sa_family=%#x, rc_bdaddr=", AF_BLUETOOTH);
396 print_quoted_hex((const void *) &c_rc.rc_bdaddr,
397 sizeof(c_rc.rc_bdaddr));
398 printf(", rc_channel=%u}, %u) = %s\n", c_rc.rc_channel, len, errstr);
399 # elif XLAT_VERBOSE
400 printf("connect(-1, {sa_family=%#x /* AF_BLUETOOTH */"
401 ", rc_bdaddr=", AF_BLUETOOTH);
402 print_quoted_hex((const void *) &c_rc.rc_bdaddr,
403 sizeof(c_rc.rc_bdaddr));
404 printf(" /* %02x:%02x:%02x:%02x:%02x:%02x */"
405 ", rc_channel=%u}, %u) = %s\n",
406 c_rc.rc_bdaddr.b[0], c_rc.rc_bdaddr.b[1],
407 c_rc.rc_bdaddr.b[2], c_rc.rc_bdaddr.b[3],
408 c_rc.rc_bdaddr.b[4], c_rc.rc_bdaddr.b[5],
409 c_rc.rc_channel, len, errstr);
410 # else
411 printf("connect(-1, {sa_family=AF_BLUETOOTH"
412 ", rc_bdaddr=%02x:%02x:%02x:%02x:%02x:%02x"
413 ", rc_channel=%u}, %u) = %s\n",
414 c_rc.rc_bdaddr.b[0], c_rc.rc_bdaddr.b[1],
415 c_rc.rc_bdaddr.b[2], c_rc.rc_bdaddr.b[3],
416 c_rc.rc_bdaddr.b[4], c_rc.rc_bdaddr.b[5],
417 c_rc.rc_channel, len, errstr);
418 # endif
419 }
420 #endif /* HAVE_BLUETOOTH_BLUETOOTH_H */
421
422 static void
423 check_rxrpc(void)
424 {
425 static const struct {
426 struct sockaddr_rxrpc sa;
427 const char *str;
428 } rxrpc_vecs[] = {
429 { { AF_RXRPC },
430 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
431 ", srx_service=0" NRAW(" /* ???_SERVICE */")
432 ", transport_type=0" NRAW(" /* SOCK_??? */")
433 ", transport_len=0, transport="
434 "{family=" XLAT_KNOWN(AF_UNSPEC, "AF_UNSPEC") "}}" },
435 { { AF_RXRPC, .srx_service = 1, .transport_type = 1,
436 .transport_len = 42, .transport = { .family = 1 } },
437 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
438 ", srx_service=0x1" NRAW(" /* CM_SERVICE */")
439 ", transport_type="
440 #ifdef __mips__
441 XLAT_KNOWN(0x1, "SOCK_DGRAM")
442 #else
443 XLAT_KNOWN(0x1, "SOCK_STREAM")
444 #endif
445 ", transport_len=42, transport={family="
446 XLAT_KNOWN(0x1, "AF_UNIX") ", \"\\0\\0\\0\\0\\0\\0\\0\\0\\0"
447 "\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\"}}" },
448 { { AF_RXRPC, .srx_service = 2, .transport_type = 2,
449 .transport_len = 5,
450 .transport = { .sin = { 1, 0xdead, { 0xfacefeed } } } },
451 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
452 ", srx_service=0x2" NRAW(" /* ???_SERVICE */")
453 ", transport_type="
454 #ifdef __mips__
455 XLAT_KNOWN(0x2, "SOCK_STREAM")
456 #else
457 XLAT_KNOWN(0x2, "SOCK_DGRAM")
458 #endif
459 ", transport_len=5, transport="
460 "{family=" XLAT_KNOWN(0x1, "AF_UNIX") ", \""
461 BE_LE("\\336\\255", "\\255\\336") BE_LE("\\372", "\\355")
462 "\"}}" },
463 { { AF_RXRPC, .srx_service = 2500, .transport_type = 3,
464 .transport_len = 7,
465 .transport = { .sin = { 2, 0xdead, { 0xfacefeed } } } },
466 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
467 ", srx_service=0x9c4" NRAW(" /* YFS_FS_SERVICE */")
468 ", transport_type=" XLAT_KNOWN(0x3, "SOCK_RAW")
469 ", transport_len=7, transport="
470 "{sin={sin_family=" XLAT_KNOWN(0x2, "AF_INET") ", \""
471 BE_LE("\\336\\255", "\\255\\336")
472 BE_LE("\\372\\316\\376", "\\355\\376\\316") "\"}}}" },
473 { { AF_RXRPC, .srx_service = 2501, .transport_type = 4,
474 .transport_len = 16,
475 .transport = { .sin = { 2, 0xdead, { 0xfacefeed } } } },
476 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
477 ", srx_service=0x9c5" NRAW(" /* YFS_CM_SERVICE */")
478 ", transport_type=" XLAT_KNOWN(0x4, "SOCK_RDM")
479 ", transport_len=16, transport="
480 "{sin={sin_family=" XLAT_KNOWN(0x2, "AF_INET") ", sin_port="
481 XLAT_KNOWN_FMT("\"" BE_LE("\\xde\\xad", "\\xad\\xde") "\"",
482 "htons(" BE_LE("57005", "44510") ")")
483 ", sin_addr="
484 XLAT_KNOWN_FMT("\"" BE_LE("\\xfa\\xce\\xfe\\xed",
485 "\\xed\\xfe\\xce\\xfa") "\"",
486 "inet_addr(\"" BE_LE("250.206.254.237",
487 "237.254.206.250") "\")")
488 "}}}" },
489 { { AF_RXRPC, .srx_service = 2502, .transport_type = 5,
490 .transport_len = 20,
491 .transport = { .sin = { 2, BE16(0xdead),
492 { BE32(0xfacefeed) }, "OH HAI" } }
493 },
494 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
495 ", srx_service=0x9c6" NRAW(" /* ???_SERVICE */")
496 ", transport_type=" XLAT_KNOWN(0x5, "SOCK_SEQPACKET")
497 ", transport_len=20, transport="
498 "{sin={sin_family=" XLAT_KNOWN(0x2, "AF_INET")
499 ", sin_port=" XLAT_KNOWN_FMT("\"\\xde\\xad\"", "htons(57005)")
500 ", sin_addr="
501 XLAT_KNOWN_FMT("\"\\xfa\\xce\\xfe\\xed\"",
502 "inet_addr(\"250.206.254.237\")")
503 "}}}" },
504 { { AF_RXRPC, .srx_service = 2503, .transport_type = 6,
505 .transport_len = 23,
506 .transport = { .sin6 = { 10, 0xdead, 0xcafeface,
507 { .s6_addr = "OH HAI THAR!\0\0\0\xf" } } } },
508 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
509 ", srx_service=0x9c7" NRAW(" /* YFS_VL_SERVICE */")
510 ", transport_type=" XLAT_KNOWN(0x6, "SOCK_DCCP")
511 ", transport_len=23, transport="
512 "{sin6={sin6_family=" XLAT_KNOWN(0xa, "AF_INET6") ", \""
513 BE_LE("\\336\\255", "\\255\\336")
514 BE_LE("\\312\\376\\372\\316", "\\316\\372\\376\\312")
515 "OH HAI THAR!\\0\\0\\0\"}}}" },
516 { { AF_RXRPC, .srx_service = 2504, .transport_type = 7,
517 .transport_len = 24,
518 .transport = { .sin6 = { 10, 0xdead, 0xcafeface,
519 { .s6_addr = "OH HAI THAR!\0\0\0\xf" } } } },
520 "{sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
521 ", srx_service=0x9c8" NRAW(" /* ???_SERVICE */")
522 ", transport_type=0x7" NRAW(" /* SOCK_??? */")
523 ", transport_len=24, transport="
524 "{sin6={sin6_family=" XLAT_KNOWN(0xa, "AF_INET6")
525 ", sin6_port="
526 XLAT_KNOWN_FMT("\"" BE_LE("\\xde\\xad", "\\xad\\xde") "\"",
527 "htons(" BE_LE("57005", "44510") ")")
528 ", sin6_flowinfo="
529 XLAT_KNOWN_FMT("\"" BE_LE("\\xca\\xfe\\xfa\\xce",
530 "\\xce\\xfa\\xfe\\xca") "\"",
531 "htonl(" BE_LE("3405707982", "3472555722") ")")
532 ", " XLAT_KNOWN_FMT("sin6_addr="
533 "\"\\x4f\\x48\\x20\\x48\\x41\\x49\\x20\\x54"
534 "\\x48\\x41\\x52\\x21\\x00\\x00\\x00\\x0f\"",
535 "inet_pton(AF_INET6, \"4f48:2048:4149:2054"
536 ":4841:5221:0:f\"" NVERB(", &sin6_addr") ")")
537 "}}}" },
538 };
539
540 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_rxrpc, sa_rxrpc);
541 int rc;
542
543 fill_memory(sa_rxrpc, sizeof(*sa_rxrpc));
544 sa_rxrpc->srx_family = AF_RXRPC;
545
546 rc = connect(-1, (void *) sa_rxrpc, sizeof(*sa_rxrpc) + 1);
547 printf("connect(-1, %p, %zu) = %s\n",
548 (void *) sa_rxrpc, sizeof(*sa_rxrpc) + 1, sprintrc(rc));
549
550 rc = connect(-1, (void *) sa_rxrpc, sizeof(*sa_rxrpc) - 1);
551 const char *errstr = sprintrc(rc);
552 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
553 ", sa_data=");
554 print_quoted_memory((void *) sa_rxrpc + sizeof(sa_rxrpc->srx_family),
555 sizeof(*sa_rxrpc) - sizeof(sa_rxrpc->srx_family)
556 - 1);
557 printf("}, %zu) = %s\n", sizeof(*sa_rxrpc) - 1, errstr);
558
559 static const uint8_t skip_af[] = { AF_INET, AF_INET6 };
560 size_t skip_pos = 0;
561 for (size_t i = 0; i < 512; i++) {
562 if (skip_pos < ARRAY_SIZE(skip_af) && skip_af[skip_pos] == i) {
563 ++skip_pos;
564 continue;
565 }
566
567 sa_rxrpc->transport.family = i;
568 rc = connect(-1, (void *) sa_rxrpc, sizeof(*sa_rxrpc));
569 errstr = sprintrc(rc);
570 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x21, "AF_RXRPC")
571 ", srx_service=%#x" NRAW(" /* ???_SERVICE */")
572 ", transport_type=%#x" NRAW(" /* SOCK_??? */")
573 ", transport_len=%u"
574 ", transport={family=%s, ",
575 sa_rxrpc->srx_service, sa_rxrpc->transport_type,
576 sa_rxrpc->transport_len,
577 sprintxval(addrfams, sa_rxrpc->transport.family,
578 "AF_???"));
579 const size_t offs = offsetofend(struct sockaddr_rxrpc,
580 transport.family);
581 print_quoted_memory((char *) sa_rxrpc + offs,
582 sizeof(*sa_rxrpc) - offs);
583 printf("}}, %zu) = %s\n", sizeof(*sa_rxrpc), errstr);
584 }
585
586 for (size_t i = 0; i < ARRAY_SIZE(rxrpc_vecs); i++) {
587 *sa_rxrpc = rxrpc_vecs[i].sa;
588
589 rc = connect(-1, (void *) sa_rxrpc, sizeof(*sa_rxrpc));
590 printf("connect(-1, %s, %zu) = %s\n",
591 rxrpc_vecs[i].str, sizeof(*sa_rxrpc), sprintrc(rc));
592 }
593 }
594
595 static void
596 check_ieee802154(void)
597 {
598 static const struct {
599 struct sockaddr_ieee802154 sa;
600 const char *str;
601 } ieee802154_vecs[] = {
602 { { AF_IEEE802154 },
603 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
604 ", addr={addr_type=0" NRAW(" /* IEEE802154_ADDR_NONE */")
605 ", pan_id=0}}" },
606 { { AF_IEEE802154, { .addr_type = 1, .pan_id = 1 } },
607 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
608 ", addr={addr_type=0x1" NRAW(" /* IEEE802154_ADDR_??? */")
609 ", pan_id=0x1, hwaddr="
610 XLAT_KNOWN_FMT("\"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"",
611 "00:00:00:00:00:00:00:00") "}}" },
612 { { AF_IEEE802154, { .addr_type = 4, .pan_id = 0xcafe,
613 { .short_addr = 0xfeed } } },
614 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
615 ", addr={addr_type=0x4" NRAW(" /* IEEE802154_ADDR_??? */")
616 ", pan_id=0xcafe, hwaddr="
617 XLAT_KNOWN_FMT("\"" BE_LE("\\xfe\\xed", "\\xed\\xfe")
618 "\\x00\\x00\\x00\\x00\\x00\\x00\"",
619 BE_LE("fe:ed", "ed:fe") ":00:00:00:00:00:00")
620 "}}" },
621 { { AF_IEEE802154, { .addr_type = 2, .pan_id = 0xfffe } },
622 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
623 ", addr={addr_type=0x2" NRAW(" /* IEEE802154_ADDR_SHORT */")
624 ", pan_id=0xfffe, short_addr=0}}" },
625 { { AF_IEEE802154, { .addr_type = 2, .pan_id = 0xffff,
626 { .hwaddr = "\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff" } } },
627 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
628 ", addr={addr_type=0x2" NRAW(" /* IEEE802154_ADDR_SHORT */")
629 ", pan_id=0xffff" NRAW(" /* IEEE802154_PANID_BROADCAST */")
630 ", short_addr=" BE_LE("0xf8f9", "0xf9f8") "}}" },
631 { { AF_IEEE802154, { .addr_type = 2, .pan_id = 0,
632 { .short_addr = 0xfffd } } },
633 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
634 ", addr={addr_type=0x2" NRAW(" /* IEEE802154_ADDR_SHORT */")
635 ", pan_id=0, short_addr=0xfffd}}" },
636 { { AF_IEEE802154, { .addr_type = 2, .pan_id = 0,
637 { .short_addr = 0xfffe } } },
638 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
639 ", addr={addr_type=0x2" NRAW(" /* IEEE802154_ADDR_SHORT */")
640 ", pan_id=0, short_addr=0xfffe"
641 NRAW(" /* IEEE802154_ADDR_UNDEF */") "}}" },
642 { { AF_IEEE802154, { .addr_type = 2, .pan_id = 0,
643 { .short_addr = 0xffff } } },
644 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
645 ", addr={addr_type=0x2" NRAW(" /* IEEE802154_ADDR_SHORT */")
646 ", pan_id=0, short_addr=0xffff"
647 NRAW(" /* IEEE802154_ADDR_BROADCAST */") "}}" },
648 { { AF_IEEE802154, { .addr_type = 3, .pan_id = 0xface,
649 { .short_addr = 0xdead } } },
650 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
651 ", addr={addr_type=0x3" NRAW(" /* IEEE802154_ADDR_LONG */")
652 ", pan_id=0xface, hwaddr="
653 XLAT_KNOWN_FMT("\"" BE_LE("\\xde\\xad", "\\xad\\xde")
654 "\\x00\\x00\\x00\\x00\\x00\\x00\"",
655 BE_LE("de:ad", "ad:de") ":00:00:00:00:00:00")
656 "}}" },
657 { { AF_IEEE802154, { .addr_type = 3, .pan_id = 0,
658 { .hwaddr = "Oh Hai!" } } },
659 "{sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
660 ", addr={addr_type=0x3" NRAW(" /* IEEE802154_ADDR_LONG */")
661 ", pan_id=0, hwaddr="
662 XLAT_KNOWN_FMT("\"\\x4f\\x68\\x20\\x48\\x61\\x69\\x21\\x00\"",
663 "4f:68:20:48:61:69:21:00") "}}" },
664 };
665
666 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_ieee802154, sa_ieee802154);
667 int rc;
668
669 fill_memory(sa_ieee802154, sizeof(*sa_ieee802154));
670 sa_ieee802154->family = AF_IEEE802154;
671
672 rc = connect(-1, (void *) sa_ieee802154, sizeof(*sa_ieee802154) + 1);
673 printf("connect(-1, %p, %zu) = %s\n",
674 (void *) sa_ieee802154, sizeof(*sa_ieee802154) + 1,
675 sprintrc(rc));
676
677 rc = connect(-1, (void *) sa_ieee802154, sizeof(*sa_ieee802154) - 1);
678 const char *errstr = sprintrc(rc);
679 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
680 ", sa_data=");
681 print_quoted_memory((void *) sa_ieee802154
682 + sizeof(sa_ieee802154->family),
683 sizeof(*sa_ieee802154)
684 - sizeof(sa_ieee802154->family) - 1);
685 printf("}, %zu) = %s\n", sizeof(*sa_ieee802154) - 1, errstr);
686
687 rc = connect(-1, (void *) sa_ieee802154, sizeof(*sa_ieee802154));
688 errstr = sprintrc(rc);
689 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x24, "AF_IEEE802154")
690 ", addr={addr_type=%#x" NRAW(" /* IEEE802154_ADDR_??? */")
691 ", pan_id=%#hx, hwaddr=",
692 sa_ieee802154->addr.addr_type, sa_ieee802154->addr.pan_id);
693 #if XLAT_RAW || XLAT_VERBOSE
694 print_quoted_hex(sa_ieee802154->addr.hwaddr,
695 sizeof(sa_ieee802154->addr.hwaddr));
696 #endif
697 #if !XLAT_RAW
698 printf(VERB(" /* ") "%02hhx:%02hhx:%02hhx:%02hhx"
699 ":%02hhx:%02hhx:%02hhx:%02hhx" VERB(" */"),
700 sa_ieee802154->addr.hwaddr[0], sa_ieee802154->addr.hwaddr[1],
701 sa_ieee802154->addr.hwaddr[2], sa_ieee802154->addr.hwaddr[3],
702 sa_ieee802154->addr.hwaddr[4], sa_ieee802154->addr.hwaddr[5],
703 sa_ieee802154->addr.hwaddr[6], sa_ieee802154->addr.hwaddr[7]);
704 #endif
705 printf("}}, %zu) = %s\n", sizeof(*sa_ieee802154), errstr);
706
707 for (size_t i = 0; i < ARRAY_SIZE(ieee802154_vecs); i++) {
708 *sa_ieee802154 = ieee802154_vecs[i].sa;
709
710 rc = connect(-1, (void *) sa_ieee802154,
711 sizeof(*sa_ieee802154));
712 printf("connect(-1, %s, %zu) = %s\n",
713 ieee802154_vecs[i].str, sizeof(*sa_ieee802154),
714 sprintrc(rc));
715 }
716 }
717
718 static void
719 check_alg(void)
720 {
721 static const struct {
722 struct sockaddr_alg sa;
723 const char *str;
724 const char *str8;
725 const char *str64;
726 } alg_vecs[] = {
727 { { AF_ALG },
728 "{sa_family="XLAT_KNOWN(0x26, "AF_ALG") ", salg_type=\"\""
729 ", salg_feat=0, salg_mask=0, salg_name=\"\"}", "", "" },
730 { { AF_ALG, .salg_feat = CRYPTO_ALG_KERN_DRIVER_ONLY,
731 .salg_mask = CRYPTO_ALG_KERN_DRIVER_ONLY },
732 "{sa_family="XLAT_KNOWN(0x26, "AF_ALG") ", salg_type=\"\""
733 ", salg_feat=0x1000" NRAW(" /* CRYPTO_ALG_KERN_DRIVER_ONLY */")
734 ", salg_mask=0x1000" NRAW(" /* CRYPTO_ALG_KERN_DRIVER_ONLY */")
735 ", salg_name=\"\"}", "", "" },
736 { { AF_ALG, .salg_type = "OH HAI\1\n\377\\\"\0\t\v",
737 .salg_feat = 0xdeadcafe, .salg_mask = 0xbeefaead,
738 .salg_name = "1234567890abcdef1234567890ABCEF\1\2\3\4\5\6\7"
739 "\x08\x09\0\x0A\x0B\x0C\x0D\x0E\x0F" },
740 "{sa_family="XLAT_KNOWN(0x26, "AF_ALG")
741 ", salg_type=\"OH HAI\\1\\n\\377\\\\\\\"\""
742 ", salg_feat=0xdeadcafe" NRAW(" /* CRYPTO_ALG_??? */")
743 ", salg_mask=0xbeefaead" NRAW(" /* CRYPTO_ALG_??? */")
744 ", salg_name=\"1234567", "\"...}",
745 "890abcdef1234567890ABCEF\\1\\2\\3\\4\\5\\6\\7\\10\\t\"}" },
746 };
747
748 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_alg, sa_alg);
749 int rc;
750
751 fill_memory(sa_alg, sizeof(*sa_alg));
752 sa_alg->salg_family = AF_ALG;
753
754 rc = connect(-1, (void *) sa_alg, sizeof(*sa_alg) + 1);
755 printf("connect(-1, %p, %zu) = %s\n",
756 (void *) sa_alg, sizeof(*sa_alg) + 1, sprintrc(rc));
757
758 rc = connect(-1, (void *) sa_alg, sizeof(struct sockaddr_alg_new));
759 const char *errstr = sprintrc(rc);
760 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x26, "AF_ALG")
761 ", sa_data=");
762 print_quoted_memory((void *) sa_alg + sizeof(sa_alg->salg_family),
763 sizeof(struct sockaddr_alg_new)
764 - sizeof(sa_alg->salg_family));
765 printf("}, %zu) = %s\n", sizeof(struct sockaddr_alg_new), errstr);
766
767 rc = connect(-1, (void *) sa_alg, sizeof(struct sockaddr_alg_new) + 1);
768 errstr = sprintrc(rc);
769 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x26, "AF_ALG")
770 ", salg_type=");
771 print_quoted_stringn((const char *) sa_alg->salg_type,
772 sizeof(sa_alg->salg_type) - 1);
773 printf(", salg_feat=%#x" NRAW(" /* CRYPTO_ALG_KERN_DRIVER_ONLY|%#x */")
774 ", salg_mask=%#x" NRAW(" /* CRYPTO_ALG_KERN_DRIVER_ONLY|%#x */")
775 ", salg_name=\"\"...}, %zu) = %s\n",
776 sa_alg->salg_feat,
777 #if !XLAT_RAW
778 sa_alg->salg_feat & ~CRYPTO_ALG_KERN_DRIVER_ONLY,
779 #endif
780 sa_alg->salg_mask,
781 #if !XLAT_RAW
782 sa_alg->salg_mask & ~CRYPTO_ALG_KERN_DRIVER_ONLY,
783 #endif
784 sizeof(struct sockaddr_alg_new) + 1, errstr);
785
786 rc = connect(-1, (void *) sa_alg, sizeof(*sa_alg) - 1);
787 errstr = sprintrc(rc);
788 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x26, "AF_ALG")
789 ", salg_type=");
790 print_quoted_stringn((const char *) sa_alg->salg_type,
791 sizeof(sa_alg->salg_type) - 1);
792 printf(", salg_feat=%#x" NRAW(" /* CRYPTO_ALG_KERN_DRIVER_ONLY|%#x */")
793 ", salg_mask=%#x" NRAW(" /* CRYPTO_ALG_KERN_DRIVER_ONLY|%#x */")
794 ", salg_name=",
795 sa_alg->salg_feat,
796 #if !XLAT_RAW
797 sa_alg->salg_feat & ~CRYPTO_ALG_KERN_DRIVER_ONLY,
798 #endif
799 sa_alg->salg_mask
800 #if !XLAT_RAW
801 , sa_alg->salg_mask & ~CRYPTO_ALG_KERN_DRIVER_ONLY
802 #endif
803 );
804 print_quoted_stringn((const char *) sa_alg->salg_name,
805 sizeof(sa_alg->salg_name) - 2);
806 printf("}, %zu) = %s\n", sizeof(*sa_alg) - 1, errstr);
807
808 for (size_t i = 0; i < ARRAY_SIZE(alg_vecs); i++) {
809 *sa_alg = alg_vecs[i].sa;
810
811 for (size_t j = 0; j < 2; j++) {
812 rc = connect(-1, (void *) sa_alg,
813 sizeof(struct sockaddr_alg_new)
814 + (j ? 64 : 8));
815 printf("connect(-1, %s%s, %zu) = %s\n",
816 alg_vecs[i].str,
817 j ? alg_vecs[i].str64 : alg_vecs[i].str8,
818 sizeof(struct sockaddr_alg_new) + (j ? 64 : 8),
819 sprintrc(rc));
820 }
821 }
822 }
823
824 static void
825 check_nfc(void)
826 {
827 const struct {
828 struct sockaddr_nfc sa;
829 const char *str;
830 } nfc_vecs[] = {
831 { { AF_NFC },
832 "{sa_family=" XLAT_KNOWN(0x27, "AF_NFC") ", dev_idx=0"
833 ", target_idx=0, nfc_protocol=0" NRAW(" /* NFC_PROTO_??? */")
834 "}" },
835 { { AF_NFC, .dev_idx = ifindex_lo(), .target_idx = 1,
836 .nfc_protocol = 1 },
837 "{sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
838 ", dev_idx=" XLAT_KNOWN(1, IFINDEX_LO_STR) ", target_idx=0x1"
839 ", nfc_protocol=" XLAT_KNOWN(0x1, "NFC_PROTO_JEWEL") "}" },
840 { { AF_NFC, .dev_idx = 0xcafebeef, .target_idx = 0xdeadface,
841 .nfc_protocol = 0xfeedbabe },
842 "{sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
843 ", dev_idx=3405692655, target_idx=0xdeadface"
844 ", nfc_protocol=0xfeedbabe" NRAW(" /* NFC_PROTO_??? */")
845 "}" },
846 };
847 const struct {
848 struct sockaddr_nfc_llcp sa;
849 const char *str;
850 } nfc_llcp_vecs[] = {
851 { { AF_NFC },
852 "{sa_family=" XLAT_KNOWN(0x27, "AF_NFC") ", dev_idx=0"
853 ", target_idx=0, nfc_protocol=0" NRAW(" /* NFC_PROTO_??? */")
854 ", dsap=0, ssap=0, service_name=\"\", service_name_len=0}" },
855 { { AF_NFC, .dev_idx = ifindex_lo(), .target_idx = 0x42,
856 .nfc_protocol = 7, .dsap = 1, .ssap = 5,
857 .service_name_len = 1 },
858 "{sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
859 ", dev_idx=" XLAT_KNOWN(1, IFINDEX_LO_STR) ", target_idx=0x42"
860 ", nfc_protocol=" XLAT_KNOWN(0x7, "NFC_PROTO_ISO15693")
861 ", dsap=0x1" NRAW(" /* LLCP_SAP_SDP */")
862 ", ssap=0x5, service_name=\"\\0\", service_name_len=1}" },
863 { { AF_NFC, .dev_idx = 0xcafed1ce, .target_idx = 0x42,
864 .nfc_protocol = 8, .dsap = 42, .ssap = 0xff,
865 .service_name="OH HAI THAR\0EHLO\n\t\v\f'\"\\\177\333",
866 .service_name_len = 42 },
867 "{sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
868 ", dev_idx=3405697486, target_idx=0x42"
869 ", nfc_protocol=0x8" NRAW(" /* NFC_PROTO_??? */")
870 ", dsap=0x2a, ssap=0xff" NRAW(" /* LLCP_SAP_MAX */")
871 ", service_name=\"OH HAI THAR\\0EHLO\\n\\t\\v\\f'\\\""
872 "\\\\\\177\\333\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0"
873 "\\0\\0\\0\\0\\0\", service_name_len=42}" },
874 };
875
876 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_nfc, sa_nfc);
877 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_nfc_llcp, sa_nfc_llcp);
878 int rc;
879
880 fill_memory(sa_nfc, sizeof(*sa_nfc));
881 sa_nfc->sa_family = AF_NFC;
882
883 rc = connect(-1, (void *) sa_nfc, sizeof(*sa_nfc) + 1);
884 printf("connect(-1, %p, %zu) = %s\n",
885 (void *) sa_nfc, sizeof(*sa_nfc) + 1, sprintrc(rc));
886
887 rc = connect(-1, (void *) sa_nfc, sizeof(*sa_nfc) - 1);
888 const char *errstr = sprintrc(rc);
889 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
890 ", sa_data=");
891 print_quoted_memory((void *) sa_nfc + sizeof(sa_nfc->sa_family),
892 sizeof(*sa_nfc) - sizeof(sa_nfc->sa_family) - 1);
893 printf("}, %zu) = %s\n", sizeof(*sa_nfc) - 1, errstr);
894
895 rc = connect(-1, (void *) sa_nfc, sizeof(*sa_nfc));
896 errstr = sprintrc(rc);
897 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
898 ", dev_idx=%u, target_idx=%#x, nfc_protocol=%#x"
899 NRAW(" /* NFC_PROTO_??? */") "}, %zu) = %s\n",
900 sa_nfc->dev_idx, sa_nfc->target_idx, sa_nfc->nfc_protocol,
901 sizeof(*sa_nfc), errstr);
902
903 for (size_t i = 0; i < ARRAY_SIZE(nfc_vecs); i++) {
904 *sa_nfc = nfc_vecs[i].sa;
905
906 rc = connect(-1, (void *) sa_nfc, sizeof(*sa_nfc));
907 printf("connect(-1, %s, %zu) = %s\n",
908 nfc_vecs[i].str, sizeof(*sa_nfc), sprintrc(rc));
909 }
910
911 fill_memory(sa_nfc_llcp, sizeof(*sa_nfc_llcp));
912 sa_nfc_llcp->sa_family = AF_NFC;
913
914 rc = connect(-1, (void *) sa_nfc_llcp, sizeof(*sa_nfc_llcp) + 1);
915 printf("connect(-1, %p, %zu) = %s\n",
916 (void *) sa_nfc_llcp, sizeof(*sa_nfc_llcp) + 1, sprintrc(rc));
917
918 for (size_t i = 0; i < 3; i++) {
919 size_t sz = i ? i == 2 ? sizeof(*sa_nfc_llcp) - 1
920 : sizeof(struct sockaddr_nfc) + 1
921 : sizeof(struct sockaddr_nfc);
922
923 rc = connect(-1, (void *) sa_nfc_llcp, sz);
924 errstr = sprintrc(rc);
925 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
926 ", dev_idx=%u, target_idx=%#x, nfc_protocol=%#x"
927 NRAW(" /* NFC_PROTO_??? */") "%s}, %zu) = %s\n",
928 sa_nfc_llcp->dev_idx, sa_nfc_llcp->target_idx,
929 sa_nfc_llcp->nfc_protocol, i ? ", ..." : "", sz, errstr);
930 }
931
932 rc = connect(-1, (void *) sa_nfc_llcp, sizeof(*sa_nfc_llcp));
933 errstr = sprintrc(rc);
934 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x27, "AF_NFC")
935 ", dev_idx=%u, target_idx=%#x, nfc_protocol=%#x"
936 NRAW(" /* NFC_PROTO_??? */") ", dsap=%#hhx, ssap=%#hhx"
937 ", service_name=",
938 sa_nfc_llcp->dev_idx, sa_nfc_llcp->target_idx,
939 sa_nfc_llcp->nfc_protocol, sa_nfc_llcp->dsap, sa_nfc_llcp->ssap);
940 print_quoted_memory(sa_nfc_llcp->service_name,
941 sizeof(sa_nfc_llcp->service_name));
942 printf(", service_name_len=%zu}, %zu) = %s\n",
943 sa_nfc_llcp->service_name_len, sizeof(*sa_nfc_llcp), errstr);
944
945 for (size_t i = 0; i < ARRAY_SIZE(nfc_llcp_vecs); i++) {
946 *sa_nfc_llcp = nfc_llcp_vecs[i].sa;
947
948 rc = connect(-1, (void *) sa_nfc_llcp, sizeof(*sa_nfc_llcp));
949 printf("connect(-1, %s, %zu) = %s\n",
950 nfc_llcp_vecs[i].str, sizeof(*sa_nfc_llcp),
951 sprintrc(rc));
952 }
953 }
954
955 static void
956 check_vsock(void)
957 {
958 static const struct {
959 struct sockaddr_vm sa;
960 const char *str;
961 } vsock_vecs[] = {
962 { { AF_VSOCK },
963 "{sa_family=" XLAT_KNOWN(0x28, "AF_VSOCK")
964 ", svm_cid=" XLAT_KNOWN(0, "VMADDR_CID_HYPERVISOR")
965 ", svm_port=0, svm_flags=0}" },
966 { { AF_VSOCK, .svm_cid = 1, .svm_port = 1, .SVM_FLAGS = 1 },
967 "{sa_family=" XLAT_KNOWN(0x28, "AF_VSOCK")
968 ", svm_cid=" XLAT_KNOWN(0x1, "VMADDR_CID_LOCAL")
969 ", svm_port=0x1"
970 ", svm_flags=" XLAT_KNOWN(0x1, "VMADDR_FLAG_TO_HOST") "}" },
971 { { AF_VSOCK, .svm_reserved1 = 0xdead, .svm_cid = 2,
972 .svm_port = 0xfacebeef, .SVM_FLAGS = 2, },
973 "{sa_family=" XLAT_KNOWN(0x28, "AF_VSOCK")
974 ", svm_reserved1=0xdead"
975 ", svm_cid=" XLAT_KNOWN(0x2, "VMADDR_CID_HOST")
976 ", svm_port=0xfacebeef"
977 ", svm_flags=" XLAT_UNKNOWN(0x2, "VMADDR_FLAG_???") "}" },
978 { { AF_VSOCK, .svm_cid = 3,
979 .svm_port = 0xfffffffe, .SVM_FLAGS = 0xef,
980 .SVM_ZERO_FIRST = 0x42 },
981 "{sa_family=" XLAT_KNOWN(0x28, "AF_VSOCK")
982 ", svm_cid=0x3, svm_port=0xfffffffe, svm_flags="
983 XLAT_KNOWN(0xef, "VMADDR_FLAG_TO_HOST|0xee")
984 ", svm_zero=\"\\x42\\x00\\x00\"}" },
985 { { AF_VSOCK, .svm_reserved1 = 0x1, .svm_cid = -1U,
986 .svm_port = -1U, .SVM_FLAGS = 0xfe,
987 .SVM_ZERO_FIRST = 0xae },
988 "{sa_family=" XLAT_KNOWN(0x28, "AF_VSOCK")
989 ", svm_reserved1=0x1"
990 ", svm_cid=" XLAT_KNOWN(0xffffffff, "VMADDR_CID_ANY")
991 ", svm_port=" XLAT_KNOWN(0xffffffff, "VMADDR_PORT_ANY")
992 ", svm_flags=" XLAT_UNKNOWN(0xfe, "VMADDR_FLAG_???")
993 ", svm_zero=\"\\xae\\x00\\x00\"}" },
994 };
995
996 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_vm, sa_vm);
997 int rc;
998
999 fill_memory(sa_vm, sizeof(*sa_vm));
1000 sa_vm->svm_family = AF_VSOCK;
1001
1002 rc = connect(-1, (void *) sa_vm, sizeof(*sa_vm) + 1);
1003 printf("connect(-1, %p, %zu) = %s\n",
1004 (void *) sa_vm, sizeof(*sa_vm) + 1, sprintrc(rc));
1005
1006 rc = connect(-1, (void *) sa_vm, sizeof(*sa_vm) - 1);
1007 const char *errstr = sprintrc(rc);
1008 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x28, "AF_VSOCK")
1009 ", sa_data=");
1010 print_quoted_memory((void *) sa_vm + sizeof(sa_vm->svm_family),
1011 sizeof(*sa_vm) - sizeof(sa_vm->svm_family)
1012 - 1);
1013 printf("}, %zu) = %s\n", sizeof(*sa_vm) - 1, errstr);
1014
1015 rc = connect(-1, (void *) sa_vm, sizeof(*sa_vm));
1016 errstr = sprintrc(rc);
1017 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x28, "AF_VSOCK")
1018 ", svm_reserved1=%#x, svm_cid=%#x, svm_port=%#x, svm_flags=%#x"
1019 NRAW(" /* VMADDR_FLAG_??? */") ", svm_zero=",
1020 sa_vm->svm_reserved1, sa_vm->svm_cid, sa_vm->svm_port,
1021 sa_vm->SVM_FLAGS);
1022 print_quoted_hex(sa_vm->SVM_ZERO,
1023 (uint8_t *) sa_vm + sizeof(*sa_vm)
1024 - (sa_vm->SVM_ZERO));
1025 printf("}, %zu) = %s\n", sizeof(*sa_vm), errstr);
1026
1027 for (size_t i = 0; i < ARRAY_SIZE(vsock_vecs); i++) {
1028 *sa_vm = vsock_vecs[i].sa;
1029
1030 rc = connect(-1, (void *) sa_vm, sizeof(*sa_vm));
1031 printf("connect(-1, %s, %zu) = %s\n",
1032 vsock_vecs[i].str, sizeof(*sa_vm), sprintrc(rc));
1033 }
1034 }
1035
1036 static void
1037 check_qrtr(void)
1038 {
1039 static const struct {
1040 struct sockaddr_qrtr sa;
1041 const char *str;
1042 } qrtr_vecs[] = {
1043 { { AF_QIPCRTR },
1044 "{sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1045 ", sq_node=0, sq_port=0}" },
1046 { { AF_QIPCRTR, .sq_node = 0xdeadface },
1047 "{sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1048 ", sq_node=0xdeadface, sq_port=0}" },
1049 { { AF_QIPCRTR, .sq_port = 0xdeedfade },
1050 "{sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1051 ", sq_node=0, sq_port=0xdeedfade}" },
1052 { { AF_QIPCRTR, .sq_node = 0xfffffffd, .sq_port = 0xfffffffd },
1053 "{sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1054 ", sq_node=0xfffffffd, sq_port=0xfffffffd}" },
1055 { { AF_QIPCRTR, .sq_node = 0xfffffffe, .sq_port = 0xfffffffe },
1056 "{sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1057 ", sq_node=0xfffffffe, sq_port="
1058 XLAT_KNOWN(0xfffffffe, "QRTR_PORT_CTRL") "}" },
1059 { { AF_QIPCRTR, .sq_node = 0xffffffff, .sq_port = 0xffffffff },
1060 "{sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1061 ", sq_node=" XLAT_KNOWN(0xffffffff, "QRTR_NODE_BCAST")
1062 ", sq_port=0xffffffff}" },
1063 };
1064
1065 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_qrtr, sa_qrtr);
1066 int rc;
1067
1068 fill_memory(sa_qrtr, sizeof(*sa_qrtr));
1069 sa_qrtr->sq_family = AF_QIPCRTR;
1070
1071 rc = connect(-1, (void *) sa_qrtr, sizeof(*sa_qrtr) + 1);
1072 printf("connect(-1, %p, %zu) = %s\n",
1073 (void *) sa_qrtr, sizeof(*sa_qrtr) + 1, sprintrc(rc));
1074
1075 rc = connect(-1, (void *) sa_qrtr, sizeof(*sa_qrtr) - 1);
1076 const char *errstr = sprintrc(rc);
1077 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1078 ", sa_data=");
1079 print_quoted_memory((void *) sa_qrtr + sizeof(sa_qrtr->sq_family),
1080 sizeof(*sa_qrtr) - sizeof(sa_qrtr->sq_family)
1081 - 1);
1082 printf("}, %zu) = %s\n", sizeof(*sa_qrtr) - 1, errstr);
1083
1084 rc = connect(-1, (void *) sa_qrtr, sizeof(*sa_qrtr));
1085 errstr = sprintrc(rc);
1086 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x2a, "AF_QIPCRTR")
1087 ", sq_node=%#x, sq_port=%#x}, %zu) = %s\n",
1088 sa_qrtr->sq_node, sa_qrtr->sq_port, sizeof(*sa_qrtr), errstr);
1089
1090 for (size_t i = 0; i < ARRAY_SIZE(qrtr_vecs); i++) {
1091 *sa_qrtr = qrtr_vecs[i].sa;
1092
1093 rc = connect(-1, (void *) sa_qrtr, sizeof(*sa_qrtr));
1094 printf("connect(-1, %s, %zu) = %s\n",
1095 qrtr_vecs[i].str, sizeof(*sa_qrtr), sprintrc(rc));
1096 }
1097 }
1098
1099 static void
1100 check_xdp(void)
1101 {
1102 const struct {
1103 struct sockaddr_xdp sa;
1104 const char *str;
1105 } xdp_vecs[] = {
1106 { { AF_XDP },
1107 "{sa_family=" XLAT_KNOWN(0x2c, "AF_XDP")
1108 ", sxdp_flags=0, sxdp_ifindex=0, sxdp_queue_id=0}" },
1109 { { AF_XDP, XDP_SHARED_UMEM },
1110 "{sa_family=" XLAT_KNOWN(0x2c, "AF_XDP")
1111 ", sxdp_flags=" XLAT_KNOWN(0x1, "XDP_SHARED_UMEM")
1112 ", sxdp_ifindex=0, sxdp_queue_id=0"
1113 ", sxdp_shared_umem_fd=0" FD0_PATH "}" },
1114 { { AF_XDP, .sxdp_flags = 0xdead,
1115 .sxdp_ifindex = ifindex_lo(),
1116 .sxdp_queue_id = 0xfacebeef,
1117 .sxdp_shared_umem_fd = 7 },
1118 "{sa_family=" XLAT_KNOWN(0x2c, "AF_XDP") ", sxdp_flags="
1119 XLAT_KNOWN(0xdead, "XDP_SHARED_UMEM|XDP_ZEROCOPY"
1120 "|XDP_USE_NEED_WAKEUP|0xdea0")
1121 ", sxdp_ifindex=" XLAT_KNOWN(1, IFINDEX_LO_STR)
1122 ", sxdp_queue_id=4207853295"
1123 ", sxdp_shared_umem_fd=7" FD7_PATH "}" },
1124 { { AF_XDP, .sxdp_flags = 0xbad0,
1125 .sxdp_ifindex = 0xcafefade,
1126 .sxdp_queue_id = 0xba5ed,
1127 .sxdp_shared_umem_fd = 0xfeedbead },
1128 "{sa_family=" XLAT_KNOWN(0x2c, "AF_XDP") ", sxdp_flags=0xbad0"
1129 NRAW(" /* XDP_??? */") ", sxdp_ifindex=3405707998"
1130 ", sxdp_queue_id=763373, sxdp_shared_umem_fd=0xfeedbead}" },
1131 };
1132
1133 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_xdp, sa_xdp);
1134 int rc;
1135
1136 fill_memory(sa_xdp, sizeof(*sa_xdp));
1137 sa_xdp->sxdp_family = AF_XDP;
1138
1139 rc = connect(-1, (void *) sa_xdp, sizeof(*sa_xdp) + 1);
1140 printf("connect(-1, %p, %zu) = %s\n",
1141 (void *) sa_xdp, sizeof(*sa_xdp) + 1, sprintrc(rc));
1142
1143 rc = connect(-1, (void *) sa_xdp, sizeof(*sa_xdp) - 1);
1144 const char *errstr = sprintrc(rc);
1145 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x2c, "AF_XDP")
1146 ", sa_data=");
1147 print_quoted_memory((void *) sa_xdp + sizeof(sa_xdp->sxdp_family),
1148 sizeof(*sa_xdp) - sizeof(sa_xdp->sxdp_family)
1149 - 1);
1150 printf("}, %zu) = %s\n", sizeof(*sa_xdp) - 1, errstr);
1151
1152 rc = connect(-1, (void *) sa_xdp, sizeof(*sa_xdp));
1153 errstr = sprintrc(rc);
1154 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x2c, "AF_XDP")
1155 ", sxdp_flags=");
1156 #if XLAT_RAW || XLAT_VERBOSE
1157 printf("%#x" VERB(" /* "), sa_xdp->sxdp_flags);
1158 #endif
1159 #if !XLAT_RAW
1160 printflags(xdp_sockaddr_flags, sa_xdp->sxdp_flags, "XDP_???");
1161 #endif
1162 printf(VERB(" */") ", sxdp_ifindex=%u, sxdp_queue_id=%u"
1163 ", sxdp_shared_umem_fd=" BE_LE("%d", "%#x") "}, %zu) = %s\n",
1164 sa_xdp->sxdp_ifindex, sa_xdp->sxdp_queue_id,
1165 sa_xdp->sxdp_shared_umem_fd, sizeof(*sa_xdp), errstr);
1166
1167 for (size_t i = 0; i < ARRAY_SIZE(xdp_vecs); i++) {
1168 *sa_xdp = xdp_vecs[i].sa;
1169
1170 rc = connect(-1, (void *) sa_xdp, sizeof(*sa_xdp));
1171 printf("connect(-1, %s, %zu) = %s\n",
1172 xdp_vecs[i].str, sizeof(*sa_xdp), sprintrc(rc));
1173 }
1174 }
1175
1176 static void
1177 check_mctp(void)
1178 {
1179 static const struct {
1180 struct sockaddr_mctp sa;
1181 const char *str;
1182 } mctp_vecs[] = {
1183 { { AF_MCTP },
1184 "{sa_family=" XLAT_KNOWN(0x2d, "AF_MCTP")
1185 ", smctp_network=" XLAT_KNOWN(0, "MCTP_NET_ANY")
1186 ", smctp_addr={s_addr=" XLAT_KNOWN(0, "MCTP_ADDR_NULL") "}"
1187 ", smctp_type=0, smctp_tag=0}" },
1188 { { AF_MCTP, .__smctp_pad0 = 0xdead,
1189 .smctp_network = MCTP_NET_ANY,
1190 .smctp_addr = { .s_addr = MCTP_ADDR_NULL } },
1191 "{sa_family=" XLAT_KNOWN(0x2d, "AF_MCTP")
1192 ", __smctp_pad0=0xdead"
1193 ", smctp_network=" XLAT_KNOWN(0, "MCTP_NET_ANY")
1194 ", smctp_addr={s_addr=" XLAT_KNOWN(0, "MCTP_ADDR_NULL") "}"
1195 ", smctp_type=0, smctp_tag=0}" },
1196 { { AF_MCTP, .smctp_network = -1234567890,
1197 .smctp_addr = { .s_addr = MCTP_ADDR_ANY },
1198 .smctp_type = 1, .smctp_tag = 8, .__smctp_pad1 = 0xea },
1199 "{sa_family=" XLAT_KNOWN(0x2d, "AF_MCTP")
1200 ", smctp_network=0xb669fd2e"
1201 ", smctp_addr={s_addr=" XLAT_KNOWN(0xff, "MCTP_ADDR_ANY") "}"
1202 ", smctp_type=0x1, smctp_tag=0x8, __smctp_pad1=0xea}" },
1203 { { AF_MCTP, .__smctp_pad0 = 0xface,
1204 .smctp_network = 2134567890,
1205 .smctp_addr = { .s_addr = 0x42 },
1206 .smctp_type = 0x23, .smctp_tag = 0x69,
1207 .__smctp_pad1= 0xda },
1208 "{sa_family=" XLAT_KNOWN(0x2d, "AF_MCTP")
1209 ", __smctp_pad0=0xface, smctp_network=0x7f3aebd2"
1210 ", smctp_addr={s_addr=0x42}, smctp_type=0x23"
1211 ", smctp_tag=0x69, __smctp_pad1=0xda}" },
1212 };
1213
1214 TAIL_ALLOC_OBJECT_CONST_PTR(struct sockaddr_mctp, sa_mctp);
1215 int rc;
1216
1217 fill_memory(sa_mctp, sizeof(*sa_mctp));
1218 sa_mctp->smctp_family = AF_MCTP;
1219
1220 rc = connect(-1, (void *) sa_mctp, sizeof(*sa_mctp) + 1);
1221 printf("connect(-1, %p, %zu) = %s\n",
1222 (void *) sa_mctp, sizeof(*sa_mctp) + 1, sprintrc(rc));
1223
1224 rc = connect(-1, (void *) sa_mctp, sizeof(*sa_mctp) - 1);
1225 const char *errstr = sprintrc(rc);
1226 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x2d, "AF_MCTP")
1227 ", sa_data=");
1228 print_quoted_memory((void *) sa_mctp + sizeof(sa_mctp->smctp_family),
1229 sizeof(*sa_mctp) - sizeof(sa_mctp->smctp_family)
1230 - 1);
1231 printf("}, %zu) = %s\n", sizeof(*sa_mctp) - 1, errstr);
1232
1233 rc = connect(-1, (void *) sa_mctp, sizeof(*sa_mctp));
1234 printf("connect(-1, {sa_family=" XLAT_KNOWN(0x2d, "AF_MCTP")
1235 ", __smctp_pad0=%#hx, smctp_network=%#x"
1236 ", smctp_addr={s_addr=%#hhx}, smctp_type=%#hhx, smctp_tag=%#hhx"
1237 ", __smctp_pad1=%#hhx}, %zu) = %s\n",
1238 sa_mctp->__smctp_pad0, sa_mctp->smctp_network,
1239 sa_mctp->smctp_addr.s_addr, sa_mctp->smctp_type,
1240 sa_mctp->smctp_tag, sa_mctp->__smctp_pad1, sizeof(*sa_mctp),
1241 sprintrc(rc));
1242
1243 for (size_t i = 0; i < ARRAY_SIZE(mctp_vecs); i++) {
1244 *sa_mctp = mctp_vecs[i].sa;
1245
1246 rc = connect(-1, (void *) sa_mctp, sizeof(*sa_mctp));
1247 printf("connect(-1, %s, %zu) = %s\n",
1248 mctp_vecs[i].str, sizeof(*sa_mctp), sprintrc(rc));
1249 }
1250 }
1251
1252 int
1253 main(void)
1254 {
1255 SKIP_IF_PROC_IS_UNAVAILABLE;
1256
1257 check_ll();
1258 check_in();
1259 check_in6();
1260 #ifdef HAVE_BLUETOOTH_BLUETOOTH_H
1261 check_sco();
1262 check_rc();
1263 #endif
1264 check_rxrpc();
1265 check_ieee802154();
1266 check_alg();
1267 check_nfc();
1268 check_vsock();
1269 check_qrtr();
1270 check_xdp();
1271 check_mctp();
1272
1273 puts("+++ exited with 0 +++");
1274 return 0;
1275 }