1 /*
2 * Copyright (c) 1991, 1992 Paul Kranenburg <pk@cs.few.eur.nl>
3 * Copyright (c) 1993 Branko Lankester <branko@hacktic.nl>
4 * Copyright (c) 1993, 1994, 1995, 1996 Rick Sladkey <jrs@world.std.com>
5 * Copyright (c) 1996-2000 Wichert Akkerman <wichert@cistron.nl>
6 * Copyright (c) 2005-2016 Dmitry V. Levin <ldv@strace.io>
7 * Copyright (c) 2016-2022 The strace developers.
8 * All rights reserved.
9 *
10 * SPDX-License-Identifier: LGPL-2.1-or-later
11 */
12
13 #include "defs.h"
14
15 #include <sys/socket.h>
16 #include <sys/un.h>
17 #include <netinet/in.h>
18 #include <arpa/inet.h>
19
20 #include "netlink.h"
21 #include <linux/ax25.h>
22 #include <linux/if_packet.h>
23 #include <linux/if_alg.h>
24 #include <linux/if_arp.h>
25 #include <linux/if_ether.h>
26 #include <linux/if_xdp.h>
27 #include <linux/mctp.h>
28 #include <linux/nfc.h>
29 #include <linux/qrtr.h>
30 #include <linux/vm_sockets.h>
31 #include <linux/x25.h>
32
33 #include "xlat/addrfams.h"
34 #include "xlat/arp_hardware_types.h"
35 #include "xlat/ethernet_protocols.h"
36 #include "xlat/af_packet_types.h"
37
38 #include "xlat/bdaddr_types.h"
39 #include "xlat/bluetooth_l2_cid.h"
40 #include "xlat/bluetooth_l2_psm.h"
41 #include "xlat/hci_channels.h"
42
43 #include "xlat/rxrpc_services.h"
44
45 #include "xlat/ieee802154_addr_types.h"
46 #include "xlat/ieee802154_addrs.h"
47 #include "xlat/ieee802154_pan_ids.h"
48
49 #include "xlat/alg_sockaddr_flags.h"
50
51 #include "xlat/nfc_saps.h"
52 #include "xlat/nfc_sockaddr_protocols.h"
53
54 #include "xlat/vsock_cids.h"
55 #include "xlat/vsock_flags.h"
56 #include "xlat/vsock_ports.h"
57
58 #include "xlat/qipcrtr_nodes.h"
59 #include "xlat/qipcrtr_ports.h"
60
61 #include "xlat/xdp_sockaddr_flags.h"
62
63 #include "xlat/mctp_addrs.h"
64 #include "xlat/mctp_nets.h"
65
66 #include "secontext.h"
67
68 #define SIZEOF_SA_FAMILY sizeof_field(struct sockaddr, sa_family)
69
70 struct sockaddr_rxrpc {
71 uint16_t srx_family;
72 uint16_t srx_service;
73 uint16_t transport_type;
74 uint16_t transport_len;
75 union {
76 uint16_t family;
77 struct sockaddr_in sin;
78 struct sockaddr_in6 sin6;
79 } transport;
80 };
81
82 #define IEEE802154_ADDR_LEN 8
83 struct ieee802154_addr_sa {
84 int addr_type;
85 uint16_t pan_id;
86 union {
87 uint8_t hwaddr[IEEE802154_ADDR_LEN];
88 uint16_t short_addr;
89 };
90 };
91
92
93 struct sockaddr_ieee802154 {
94 uint16_t family;
95 struct ieee802154_addr_sa addr;
96 };
97
98 #define IPX_NODE_LEN 6
99 struct sockaddr_ipx {
100 uint16_t sipx_family;
101 uint16_t sipx_port;
102 uint32_t sipx_network;
103 unsigned char sipx_node[IPX_NODE_LEN];
104 uint8_t sipx_type;
105 unsigned char sipx_zero;
106 };
107
108 static void
109 print_sockaddr_data_un(struct tcb *tcp, const void *const buf, const int addrlen)
110 {
111 const struct sockaddr_un *const sa_un = buf;
112 const int un_len = addrlen > (int) sizeof(*sa_un)
113 ? (int) sizeof(*sa_un) : addrlen;
114 const int path_len = un_len - SIZEOF_SA_FAMILY;
115
116 tprints_field_name("sun_path");
117 if (sa_un->sun_path[0]) {
118 print_quoted_string(sa_un->sun_path, path_len + 1,
119 QUOTE_0_TERMINATED);
120 selinux_printfilecon(tcp, sa_un->sun_path);
121 } else {
122 tprints_string("@");
123 print_quoted_string(sa_un->sun_path + 1, path_len - 1, 0);
124 }
125 }
126
127 bool
128 print_inet_addr(const int af,
129 const void *const addr,
130 const unsigned int len,
131 const char *const var_name)
132 {
133 char buf[INET6_ADDRSTRLEN];
134
135 switch (af) {
136 case AF_INET:
137 if (inet_ntop(af, addr, buf, sizeof(buf))) {
138 if (var_name)
139 tprints_field_name(var_name);
140
141 if (xlat_verbose(xlat_verbosity) != XLAT_STYLE_ABBREV)
142 print_quoted_string((const char*) addr,
143 len, QUOTE_FORCE_HEX);
144
145 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_RAW)
146 return true;
147
148 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
149 tprint_comment_begin();
150
151 tprints_arg_begin("inet_addr");
152 print_quoted_string(buf, sizeof(buf), QUOTE_0_TERMINATED);
153 tprint_arg_end();
154
155 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
156 tprint_comment_end();
157
158 return true;
159 }
160 break;
161 case AF_INET6:
162 if (inet_ntop(af, addr, buf, sizeof(buf))) {
163 if (xlat_verbose(xlat_verbosity) != XLAT_STYLE_ABBREV) {
164 if (var_name)
165 tprints_field_name(var_name);
166 print_quoted_string(addr, len, QUOTE_FORCE_HEX);
167 }
168
169 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_RAW)
170 return true;
171
172 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
173 tprint_comment_begin();
174
175 tprints_arg_begin("inet_pton");
176 print_xlat_ex(AF_INET6, "AF_INET6", XLAT_STYLE_ABBREV);
177
178 tprint_arg_next();
179 print_quoted_string(buf, sizeof(buf), QUOTE_0_TERMINATED);
180
181 if (var_name &&
182 (xlat_verbose(xlat_verbosity) == XLAT_STYLE_ABBREV)) {
183 tprint_arg_next();
184 tprintf_string("&%s", var_name);
185 }
186 tprint_arg_end();
187
188 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
189 tprint_comment_end();
190
191 return true;
192 }
193 break;
194 }
195
196 if (var_name)
197 tprints_field_name(var_name);
198 print_quoted_string(addr, len, QUOTE_FORCE_HEX);
199 return false;
200 }
201
202 bool
203 decode_inet_addr(struct tcb *const tcp,
204 const kernel_ulong_t addr,
205 const unsigned int len,
206 const int family,
207 const char *const var_name)
208 {
209 union {
210 struct in_addr a4;
211 struct in6_addr a6;
212 } addrbuf;
213 size_t size = 0;
214
215 switch (family) {
216 case AF_INET:
217 size = sizeof(addrbuf.a4);
218 break;
219 case AF_INET6:
220 size = sizeof(addrbuf.a6);
221 break;
222 }
223
224 if (!size || len < size) {
225 if (var_name)
226 tprints_field_name(var_name);
227 printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
228 return false;
229 }
230
231 if (umoven(tcp, addr, size, &addrbuf) < 0) {
232 if (var_name)
233 tprints_field_name(var_name);
234 printaddr(addr);
235 return false;
236 }
237
238 return print_inet_addr(family, &addrbuf, size, var_name);
239 }
240
241 static void
242 print_sockaddr_data_in(struct tcb *tcp, const void *const buf,
243 const int addrlen)
244 {
245 const struct sockaddr_in *const sa_in = buf;
246
247 PRINT_FIELD_NET_PORT(*sa_in, sin_port);
248 tprint_struct_next();
249 PRINT_FIELD_INET_ADDR(*sa_in, sin_addr, AF_INET);
250 }
251
252 #define SIN6_MIN_LEN offsetof(struct sockaddr_in6, sin6_scope_id)
253
254 static void
255 print_sockaddr_data_in6(struct tcb *tcp, const void *const buf,
256 const int addrlen)
257 {
258 const struct sockaddr_in6 *const sa_in6 = buf;
259
260 PRINT_FIELD_NET_PORT(*sa_in6, sin6_port);
261 tprint_struct_next();
262 tprints_field_name("sin6_flowinfo");
263 if (xlat_verbose(xlat_verbosity) != XLAT_STYLE_ABBREV)
264 print_quoted_string((const char*) &sa_in6->sin6_flowinfo,
265 sizeof(sa_in6->sin6_flowinfo),
266 QUOTE_FORCE_HEX);
267
268 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
269 tprint_comment_begin();
270
271 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE ||
272 xlat_verbose(xlat_verbosity) == XLAT_STYLE_ABBREV) {
273 tprints_arg_begin("htonl");
274 PRINT_VAL_U(ntohl(sa_in6->sin6_flowinfo));
275 tprint_arg_end();
276 }
277
278 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE)
279 tprint_comment_end();
280
281 tprint_struct_next();
282 PRINT_FIELD_INET_ADDR(*sa_in6, sin6_addr, AF_INET6);
283 if (addrlen <= (int) SIN6_MIN_LEN)
284 return;
285
286 #if defined IN6_IS_ADDR_LINKLOCAL && defined IN6_IS_ADDR_MC_LINKLOCAL
287 if (IN6_IS_ADDR_LINKLOCAL(&sa_in6->sin6_addr)
288 || IN6_IS_ADDR_MC_LINKLOCAL(&sa_in6->sin6_addr)) {
289 tprint_struct_next();
290 PRINT_FIELD_IFINDEX(*sa_in6, sin6_scope_id);
291 } else
292 #endif
293 {
294 tprint_struct_next();
295 PRINT_FIELD_U(*sa_in6, sin6_scope_id);
296 }
297 }
298
299 /**
300 * Check that we can print an AX.25 address in its native form, otherwise it
301 * makes sense to print it in raw also (or in raw only).
302 */
303 static enum xlat_style
304 check_ax25_address(const ax25_address *addr)
305 {
306 enum xlat_style ret = XLAT_STYLE_DEFAULT;
307 bool space_seen = false;
308 bool char_seen = false;
309
310 for (size_t i = 0; i < ARRAY_SIZE(addr->ax25_call) - 1; i++) {
311 unsigned char c = addr->ax25_call[i];
312
313 /* The lowest bit should be zero */
314 if (c & 1)
315 ret = XLAT_STYLE_VERBOSE;
316
317 c >>= 1;
318
319 if (c == ' ')
320 space_seen = true;
321 else
322 char_seen = true;
323
324 /* Sane address contains only numbers and uppercase letters */
325 if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && c != ' ')
326 ret = XLAT_STYLE_VERBOSE;
327 if (c != ' ' && space_seen)
328 ret = XLAT_STYLE_VERBOSE;
329
330 /* non-printable chars */
331 if (c < ' ' || c > 0x7e
332 /* characters used for printing comments */
333 || c == '*' || c == '/')
334 return XLAT_STYLE_RAW;
335 }
336
337 if (addr->ax25_call[ARRAY_SIZE(addr->ax25_call) - 1] & ~0x1e)
338 ret = XLAT_STYLE_VERBOSE;
339
340 if (!char_seen && addr->ax25_call[ARRAY_SIZE(addr->ax25_call) - 1])
341 ret = XLAT_STYLE_VERBOSE;
342
343 return ret;
344 }
345
346 /** Convert a (presumably) valid AX.25 to a string */
347 static const char *
348 ax25_addr2str(const ax25_address *addr)
349 {
350 static char buf[ARRAY_SIZE(addr->ax25_call) + sizeof("-15")];
351 char *p = buf;
352 size_t end;
353
354 for (end = ARRAY_SIZE(addr->ax25_call) - 1; end; end--)
355 if ((addr->ax25_call[end - 1] >> 1) != ' ')
356 break;
357
358 for (size_t i = 0; i < end; i++)
359 *p++ = ((unsigned char) addr->ax25_call[i]) >> 1;
360
361 *p++ = '-';
362
363 unsigned char ssid = (addr->ax25_call[ARRAY_SIZE(addr->ax25_call) - 1]
364 >> 1) & 0xf;
365
366 if (ssid > 9) {
367 *p++ = '1';
368 ssid -= 10;
369 }
370
371 *p++ = ssid + '0';
372 *p = '\0';
373
374 if (buf[0] == '-' && buf[1] == '0')
375 return "*";
376
377 return buf;
378 }
379
380 static void
381 print_ax25_addr_raw(const ax25_address *addr)
382 {
383 tprint_struct_begin();
384 PRINT_FIELD_HEX_ARRAY(*addr, ax25_call);
385 tprint_struct_end();
386 }
387
388 void
389 print_ax25_addr(const void /* ax25_address */ *addr_void)
390 {
391 const ax25_address *addr = addr_void;
392 enum xlat_style xs = check_ax25_address(addr);
393
394 if (xs == XLAT_STYLE_DEFAULT)
395 xs = xlat_verbose(xlat_verbosity);
396
397 if (xs != XLAT_STYLE_ABBREV)
398 print_ax25_addr_raw(addr);
399
400 if (xs == XLAT_STYLE_RAW)
401 return;
402
403 const char *addr_str = ax25_addr2str(addr);
404
405 (xs == XLAT_STYLE_VERBOSE ? tprints_comment : tprints_string)(addr_str);
406 }
407
408 static bool
409 print_ax25_array_member(struct tcb *const tcp, void *const elem_buf,
410 const size_t elem_size, void *const data)
411 {
412 print_ax25_addr(elem_buf);
413
414 return true;
415 }
416
417 static void
418 print_sockaddr_data_ax25(struct tcb *tcp, const void *const buf,
419 const int addrlen)
420 {
421 const struct full_sockaddr_ax25 *const sax25 = buf;
422 size_t addrlen_us = MAX(addrlen, 0);
423 bool full = sax25->fsa_ax25.sax25_ndigis ||
424 (addrlen_us > sizeof(struct sockaddr_ax25));
425
426 if (full) {
427 tprints_field_name("fsa_ax25");
428 tprint_struct_begin();
429 }
430
431 PRINT_FIELD_OBJ_PTR(sax25->fsa_ax25, sax25_call, print_ax25_addr);
432 tprint_struct_next();
433 PRINT_FIELD_D(sax25->fsa_ax25, sax25_ndigis);
434
435 if (!full)
436 return;
437
438 tprint_struct_end();
439
440 size_t has_digis = MIN((addrlen_us - sizeof(sax25->fsa_ax25))
441 / sizeof(sax25->fsa_digipeater[0]),
442 ARRAY_SIZE(sax25->fsa_digipeater));
443 size_t want_digis = MIN(
444 (unsigned int) MAX(sax25->fsa_ax25.sax25_ndigis, 0),
445 ARRAY_SIZE(sax25->fsa_digipeater));
446 size_t digis = MIN(has_digis, want_digis);
447
448 if (want_digis == 0)
449 goto digis_end;
450
451 tprint_struct_next();
452 tprints_field_name("fsa_digipeater");
453 print_local_array_ex(tcp, sax25->fsa_digipeater, digis,
454 sizeof(sax25->fsa_digipeater[0]),
455 print_ax25_array_member, NULL,
456 want_digis > has_digis ? PAF_ARRAY_TRUNCATED : 0,
457 NULL, NULL);
458
459 digis_end:
460 if (addrlen_us > (has_digis * sizeof(sax25->fsa_digipeater[0])
461 + sizeof(sax25->fsa_ax25))) {
462 tprint_struct_next();
463 tprint_more_data_follows();
464 }
465 }
466
467 static void
468 print_sockaddr_data_ipx(struct tcb *tcp, const void *const buf,
469 const int addrlen)
470 {
471 const struct sockaddr_ipx *const sa_ipx = buf;
472
473 PRINT_FIELD_NET_PORT(*sa_ipx, sipx_port);
474 tprint_struct_next();
475 tprints_field_name("sipx_network");
476 tprints_arg_begin("htonl");
477 PRINT_VAL_X(ntohl(sa_ipx->sipx_network));
478 tprint_arg_end();
479 tprint_struct_next();
480 PRINT_FIELD_VAL_ARRAY(*sa_ipx, sipx_node, PRINT_VAL_0X);
481 tprint_struct_next();
482 PRINT_FIELD_0X(*sa_ipx, sipx_type);
483 if (sa_ipx->sipx_zero) {
484 tprint_struct_next();
485 PRINT_FIELD_X(*sa_ipx, sipx_zero);
486 }
487 }
488
489 void
490 print_x25_addr(const void /* struct x25_address */ *addr_void)
491 {
492 const struct x25_address *addr = addr_void;
493
494 tprint_struct_begin();
495 PRINT_FIELD_CSTRING(*addr, x25_addr);
496 tprint_struct_end();
497 }
498
499 static void
500 print_sockaddr_data_x25(struct tcb *tcp, const void *const buf,
501 const int addrlen)
502 {
503 const struct sockaddr_x25 *const sa_x25 = buf;
504
505 PRINT_FIELD_OBJ_PTR(*sa_x25, sx25_addr, print_x25_addr);
506 }
507
508 static void
509 print_sockaddr_data_nl(struct tcb *tcp, const void *const buf, const int addrlen)
510 {
511 const struct sockaddr_nl *const sa_nl = buf;
512
513 if (sa_nl->nl_pad) {
514 PRINT_FIELD_X(*sa_nl, nl_pad);
515 tprint_struct_next();
516 }
517 PRINT_FIELD_TGID(*sa_nl, nl_pid, tcp);
518 tprint_struct_next();
519 PRINT_FIELD_0X(*sa_nl, nl_groups);
520 }
521
522 static void
523 print_sll_protocol(const struct sockaddr_ll *const sa_ll)
524 {
525 int x_style = xlat_verbose(xlat_verbosity);
526
527 tprints_field_name("sll_protocol");
528 if (x_style != XLAT_STYLE_ABBREV)
529 print_quoted_string((const char *) &sa_ll->sll_protocol,
530 sizeof(sa_ll->sll_protocol),
531 QUOTE_FORCE_HEX);
532
533 if (x_style == XLAT_STYLE_RAW)
534 return;
535
536 if (x_style == XLAT_STYLE_VERBOSE)
537 tprint_comment_begin();
538
539 tprints_arg_begin("htons");
540 printxval_ex(ethernet_protocols, ntohs(sa_ll->sll_protocol),
541 "ETH_P_???", XLAT_STYLE_ABBREV);
542 tprint_arg_end();
543
544 if (x_style == XLAT_STYLE_VERBOSE)
545 tprint_comment_end();
546 }
547
548 static void
549 print_sockaddr_data_ll(struct tcb *tcp, const void *const buf,
550 const int addrlen)
551 {
552 const struct sockaddr_ll *const sa_ll = buf;
553
554 print_sll_protocol(sa_ll);
555 tprint_struct_next();
556 PRINT_FIELD_IFINDEX(*sa_ll, sll_ifindex);
557 tprint_struct_next();
558 PRINT_FIELD_XVAL(*sa_ll, sll_hatype, arp_hardware_types, "ARPHRD_???");
559 tprint_struct_next();
560 PRINT_FIELD_XVAL(*sa_ll, sll_pkttype, af_packet_types, "PACKET_???");
561 tprint_struct_next();
562 PRINT_FIELD_U(*sa_ll, sll_halen);
563 if (sa_ll->sll_halen) {
564 const unsigned int oob_halen =
565 addrlen - offsetof(struct sockaddr_ll, sll_addr);
566
567 tprint_struct_next();
568 tprints_field_name("sll_addr");
569 tprint_array_begin();
570 for (unsigned int i = 0; i < sa_ll->sll_halen; ++i) {
571 if (i)
572 tprint_array_next();
573 if (i >= oob_halen) {
574 tprint_more_data_follows();
575 break;
576 }
577 PRINT_VAL_0X(sa_ll->sll_addr[i]);
578 }
579 tprint_array_end();
580 }
581 }
582
583 static void
584 print_sockaddr_data_raw(const void *const buf, const int addrlen)
585 {
586 const char *const data = buf + SIZEOF_SA_FAMILY;
587 const int datalen = addrlen - SIZEOF_SA_FAMILY;
588
589 tprints_field_name("sa_data");
590 print_quoted_string(data, datalen, 0);
591 }
592
593 static uint16_t
594 btohs(uint16_t val)
595 {
596 return is_bigendian ? (val << 8) | (val >> 8) : val;
597 }
598
599 static void
600 print_bluetooth_l2_psm(uint16_t psm)
601 {
602 const uint16_t psm_he = btohs(psm);
603 const char *psm_name = xlookup(bluetooth_l2_psm, psm_he);
604 const bool psm_str = psm_name || (psm_he >= L2CAP_PSM_LE_DYN_START
605 && psm_he <= L2CAP_PSM_LE_DYN_END)
606 || (psm_he >= L2CAP_PSM_DYN_START);
607
608 tprints_arg_begin("htobs");
609
610 if (xlat_verbose(xlat_verbosity) != XLAT_STYLE_ABBREV || !psm_str)
611 PRINT_VAL_X(psm_he);
612
613 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_RAW)
614 goto print_bluetooth_l2_psm_end;
615
616 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE || !psm_str)
617 tprint_comment_begin();
618
619 if (psm_name) {
620 tprints_string(psm_name);
621 } else if (psm_he >= L2CAP_PSM_LE_DYN_START
622 && psm_he <= L2CAP_PSM_LE_DYN_END) {
623 print_xlat(L2CAP_PSM_LE_DYN_START);
624 tprint_plus();
625 PRINT_VAL_U(psm_he - L2CAP_PSM_LE_DYN_START);
626 } else if (psm_he >= L2CAP_PSM_DYN_START) {
627 print_xlat(L2CAP_PSM_DYN_START);
628 tprint_plus();
629 PRINT_VAL_U(psm_he - L2CAP_PSM_DYN_START);
630 } else {
631 tprints_string("L2CAP_PSM_???");
632 }
633
634 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE || !psm_str)
635 tprint_comment_end();
636
637 print_bluetooth_l2_psm_end:
638 tprint_arg_end();
639 }
640
641 static void
642 print_bluetooth_l2_cid(uint16_t cid)
643 {
644 const uint16_t cid_he = btohs(cid);
645 const char *cid_name = xlookup(bluetooth_l2_cid, cid_he);
646 const bool cid_str = cid_name || (cid_he >= L2CAP_CID_DYN_START);
647
648 tprints_arg_begin("htobs");
649
650 if (xlat_verbose(xlat_verbosity) != XLAT_STYLE_ABBREV || !cid_str)
651 PRINT_VAL_X(cid_he);
652
653 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_RAW)
654 goto print_bluetooth_l2_cid_end;
655
656 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE || !cid_str)
657 tprint_comment_begin();
658
659 if (cid_name) {
660 tprints_string(cid_name);
661 } else if (cid_he >= L2CAP_CID_DYN_START) {
662 print_xlat(L2CAP_CID_DYN_START);
663 tprint_plus();
664 PRINT_VAL_U(cid_he - L2CAP_CID_DYN_START);
665 } else {
666 tprints_string("L2CAP_CID_???");
667 }
668
669 if (xlat_verbose(xlat_verbosity) == XLAT_STYLE_VERBOSE || !cid_str)
670 tprint_comment_end();
671
672 print_bluetooth_l2_cid_end:
673 tprint_arg_end();
674 }
675
676 static void
677 print_sockaddr_data_bt(struct tcb *tcp, const void *const buf,
678 const int addrlen)
679 {
680 struct sockaddr_hci {
681 /* sa_family_t */ uint16_t hci_family;
682 uint16_t hci_dev;
683 uint16_t hci_channel;
684 };
685
686 struct bdaddr {
687 uint8_t b[6];
688 } ATTRIBUTE_PACKED;
689
690 struct sockaddr_sco {
691 /* sa_family_t */ uint16_t sco_family;
692 struct bdaddr sco_bdaddr;
693 };
694
695 struct sockaddr_rc {
696 /* sa_family_t */ uint16_t rc_family;
697 struct bdaddr rc_bdaddr;
698 uint8_t rc_channel;
699 };
700
701 struct sockaddr_l2 {
702 /* sa_family_t */ uint16_t l2_family;
703 /* little endian */ uint16_t l2_psm;
704 struct bdaddr l2_bdaddr;
705 /* little endian */ uint16_t l2_cid;
706 uint8_t l2_bdaddr_type;
707 };
708
709 switch (addrlen) {
710 case offsetofend(struct sockaddr_hci, hci_dev):
711 case sizeof(struct sockaddr_hci): {
712 const struct sockaddr_hci *const hci = buf;
713 tprints_field_name("hci_dev");
714 tprints_arg_begin("htobs");
715 PRINT_VAL_U(btohs(hci->hci_dev));
716 tprint_arg_end();
717
718 /*
719 * hci_channel field has been introduced
720 * Linux commit in v2.6.38-rc1~476^2~14^2~3^2~43^2~9.
721 */
722 if (addrlen == sizeof(struct sockaddr_hci)) {
723 tprint_struct_next();
724 PRINT_FIELD_XVAL(*hci, hci_channel, hci_channels,
725 "HCI_CHANNEL_???");
726 }
727
728 break;
729 }
730 case sizeof(struct sockaddr_sco): {
731 const struct sockaddr_sco *const sco = buf;
732 print_mac_addr("sco_bdaddr=", sco->sco_bdaddr.b,
733 sizeof(sco->sco_bdaddr.b));
734 break;
735 }
736 case sizeof(struct sockaddr_rc): {
737 const struct sockaddr_rc *const rc = buf;
738 print_mac_addr("rc_bdaddr=", rc->rc_bdaddr.b,
739 sizeof(rc->rc_bdaddr.b));
740 tprint_struct_next();
741 PRINT_FIELD_U(*rc, rc_channel);
742 break;
743 }
744 case offsetof(struct sockaddr_l2, l2_bdaddr_type):
745 case sizeof(struct sockaddr_l2): {
746 const struct sockaddr_l2 *const l2 = buf;
747 PRINT_FIELD_OBJ_VAL(*l2, l2_psm, print_bluetooth_l2_psm);
748 print_mac_addr(", l2_bdaddr=", l2->l2_bdaddr.b,
749 sizeof(l2->l2_bdaddr.b));
750 tprint_struct_next();
751 PRINT_FIELD_OBJ_VAL(*l2, l2_cid, print_bluetooth_l2_cid);
752
753 if (addrlen == sizeof(struct sockaddr_l2)) {
754 tprint_struct_next();
755 PRINT_FIELD_XVAL(*l2, l2_bdaddr_type,
756 bdaddr_types, "BDADDR_???");
757 }
758
759 break;
760 }
761 default:
762 print_sockaddr_data_raw(buf, addrlen);
763 break;
764 }
765 }
766
767 static void
768 print_sockaddr_data_rxrpc(struct tcb *tcp, const void *const buf,
769 const int len)
770 {
771 const struct sockaddr_rxrpc *const sa = buf;
772
773 PRINT_FIELD_XVAL_VERBOSE(*sa, srx_service, rxrpc_services,
774 "???_SERVICE");
775 tprint_struct_next();
776 PRINT_FIELD_XVAL(*sa, transport_type, socktypes, "SOCK_???");
777 tprint_struct_next();
778 PRINT_FIELD_U(*sa, transport_len);
779 tprint_struct_next();
780 tprints_field_name("transport");
781 tprint_struct_begin();
782
783 const void *const transport_buf = (void *) &sa->transport
784 + sizeof(sa->transport.family);
785 const int transport_len = MIN(sa->transport_len,
786 len - offsetof(struct sockaddr_rxrpc,
787 transport.family));
788 const int transport_rest = MAX(0, transport_len
789 - (int) sizeof(sa->transport.family));
790
791 /* Only AF_INET and AF_INET6 are supported as RxRPC transports */
792 switch (sa->transport.family) {
793 case AF_INET:
794 tprints_field_name("sin");
795 tprint_struct_begin();
796 PRINT_FIELD_XVAL(sa->transport.sin, sin_family, addrfams,
797 "AF_???");
798 if (sa->transport_len >= sizeof(struct sockaddr_in)) {
799 tprint_struct_next();
800 print_sockaddr_data_in(tcp, &sa->transport,
801 transport_len);
802 } else if (transport_rest > 0) {
803 tprint_struct_next();
804 print_quoted_string(transport_buf, transport_rest, 0);
805 }
806 tprint_struct_end();
807 break;
808
809 case AF_INET6:
810 tprints_field_name("sin6");
811 tprint_struct_begin();
812 PRINT_FIELD_XVAL(sa->transport.sin6, sin6_family, addrfams,
813 "AF_???");
814 if (sa->transport_len >= SIN6_MIN_LEN) {
815 tprint_struct_next();
816 print_sockaddr_data_in6(tcp, &sa->transport,
817 transport_len);
818 } else if (transport_rest > 0) {
819 tprint_struct_next();
820 print_quoted_string(transport_buf, transport_rest, 0);
821 }
822 tprint_struct_end();
823 break;
824
825 default:
826 PRINT_FIELD_XVAL(sa->transport, family, addrfams, "AF_???");
827 if (transport_rest > 0) {
828 tprint_struct_next();
829 print_quoted_string(transport_buf, transport_rest, 0);
830 }
831 }
832
833 tprint_struct_end();
834 }
835
836 static void
837 print_sockaddr_data_ieee802154(struct tcb *tcp, const void *const buf,
838 const int len)
839 {
840 const struct sockaddr_ieee802154 *const sa = buf;
841
842 tprints_field_name("addr");
843 tprint_struct_begin();
844 PRINT_FIELD_XVAL_VERBOSE(sa->addr, addr_type, ieee802154_addr_types,
845 "IEEE802154_ADDR_???");
846 tprint_struct_next();
847 PRINT_FIELD_XVAL_VERBOSE(sa->addr, pan_id, ieee802154_pan_ids, NULL);
848 switch (sa->addr.addr_type) {
849 case IEEE802154_ADDR_NONE:
850 break;
851 case IEEE802154_ADDR_SHORT:
852 tprint_struct_next();
853 PRINT_FIELD_XVAL_VERBOSE(sa->addr, short_addr, ieee802154_addrs,
854 NULL);
855 break;
856 case IEEE802154_ADDR_LONG:
857 default:
858 tprint_struct_next();
859 PRINT_FIELD_HWADDR_SZ(sa->addr, hwaddr, sizeof(sa->addr.hwaddr),
860 ARPHRD_IEEE802154);
861 }
862 tprint_struct_end();
863 }
864
865 static void
866 print_sockaddr_data_alg(struct tcb *tcp, const void *const buf,
867 const int len)
868 {
869 const struct sockaddr_alg_new *const sa_alg = buf;
870
871 PRINT_FIELD_STRING(*sa_alg, salg_type, sizeof(sa_alg->salg_type),
872 QUOTE_0_TERMINATED | QUOTE_EXPECT_TRAILING_0);
873 tprint_struct_next();
874 PRINT_FIELD_FLAGS_VERBOSE(*sa_alg, salg_feat, alg_sockaddr_flags,
875 "CRYPTO_ALG_???");
876 tprint_struct_next();
877 PRINT_FIELD_FLAGS_VERBOSE(*sa_alg, salg_mask, alg_sockaddr_flags,
878 "CRYPTO_ALG_???");
879 tprint_struct_next();
880 PRINT_FIELD_STRING(*sa_alg, salg_name,
881 len - offsetof(struct sockaddr_alg_new, salg_name),
882 QUOTE_0_TERMINATED | QUOTE_EXPECT_TRAILING_0);
883 }
884
885 static void
886 print_sockaddr_data_nfc(struct tcb *tcp, const void *const buf,
887 const int addrlen)
888 {
889 const union {
890 struct {
891 uint16_t sa_family;
892 uint32_t dev_idx;
893 uint32_t target_idx;
894 uint32_t nfc_protocol;
895 uint8_t dsap;
896 uint8_t ssap;
897 char service_name[NFC_LLCP_MAX_SERVICE_NAME];
898 uint32_t service_name_len;
899 } nfc_32;
900 struct {
901 uint16_t sa_family;
902 uint32_t dev_idx;
903 uint32_t target_idx;
904 uint32_t nfc_protocol;
905 uint8_t dsap;
906 uint8_t ssap;
907 char service_name[NFC_LLCP_MAX_SERVICE_NAME];
908 uint64_t ATTRIBUTE_ALIGNED(8) service_name_len;
909 } nfc_64;
910 } *const sa_nfc = buf;
911
912 PRINT_FIELD_IFINDEX(sa_nfc->nfc_32, dev_idx);
913 tprint_struct_next();
914 PRINT_FIELD_X(sa_nfc->nfc_32, target_idx);
915 tprint_struct_next();
916 PRINT_FIELD_XVAL(sa_nfc->nfc_32, nfc_protocol, nfc_sockaddr_protocols,
917 "NFC_PROTO_???");
918
919 size_t sa_nfc_llcp_len = current_wordsize == 8 ? sizeof(sa_nfc->nfc_64)
920 : sizeof(sa_nfc->nfc_32);
921 if ((uint32_t) addrlen < sa_nfc_llcp_len)
922 {
923 if ((uint32_t) addrlen > sizeof(struct sockaddr_nfc)) {
924 tprint_struct_next();
925 tprint_more_data_follows();
926 }
927
928 return;
929 }
930
931 uint64_t snsz = current_wordsize == 8 ? sa_nfc->nfc_64.service_name_len
932 : sa_nfc->nfc_32.service_name_len;
933
934 tprint_struct_next();
935 PRINT_FIELD_XVAL_VERBOSE(sa_nfc->nfc_32, dsap, nfc_saps, NULL);
936 tprint_struct_next();
937 PRINT_FIELD_XVAL_VERBOSE(sa_nfc->nfc_32, ssap, nfc_saps, NULL);
938 tprint_struct_next();
939 PRINT_FIELD_STRING(sa_nfc->nfc_32, service_name,
940 MIN(sizeof(sa_nfc->nfc_32.service_name), snsz), 0);
941 tprint_struct_next();
942 tprints_field_name("service_name_len");
943 PRINT_VAL_U(snsz);
944 }
945
946 static void
947 print_sockaddr_data_vsock(struct tcb *tcp, const void *const buf,
948 const int addrlen)
949 {
950 const struct sockaddr_vm *const sa_vm = buf;
951
952 if (sa_vm->svm_reserved1) {
953 PRINT_FIELD_X(*sa_vm, svm_reserved1);
954 tprint_struct_next();
955 }
956 PRINT_FIELD_XVAL(*sa_vm, svm_cid, vsock_cids, NULL);
957 tprint_struct_next();
958 PRINT_FIELD_XVAL(*sa_vm, svm_port, vsock_ports, NULL);
959 tprint_struct_next();
960 PRINT_FIELD_FLAGS(*sa_vm, svm_flags, vsock_flags, "VMADDR_FLAG_???");
961 if (!IS_ARRAY_ZERO(sa_vm->svm_zero)) {
962 tprint_struct_next();
963 PRINT_FIELD_HEX_ARRAY(*sa_vm, svm_zero);
964 }
965 }
966
967 static void
968 print_sockaddr_data_qrtr(struct tcb *tcp, const void *const buf,
969 const int addrlen)
970 {
971 const struct sockaddr_qrtr *const sa_qrtr = buf;
972
973 PRINT_FIELD_XVAL(*sa_qrtr, sq_node, qipcrtr_nodes, NULL);
974 tprint_struct_next();
975 PRINT_FIELD_XVAL(*sa_qrtr, sq_port, qipcrtr_ports, NULL);
976 }
977
978 static void
979 print_sockaddr_data_xdp(struct tcb *tcp, const void *const buf,
980 const int addrlen)
981 {
982 const struct sockaddr_xdp *const sa_xdp = buf;
983
984 PRINT_FIELD_FLAGS(*sa_xdp, sxdp_flags, xdp_sockaddr_flags, "XDP_???");
985 tprint_struct_next();
986 PRINT_FIELD_IFINDEX(*sa_xdp, sxdp_ifindex);
987 tprint_struct_next();
988 PRINT_FIELD_U(*sa_xdp, sxdp_queue_id);
989
990 if (sa_xdp->sxdp_flags & XDP_SHARED_UMEM) {
991 tprint_struct_next();
992 PRINT_FIELD_FD(*sa_xdp, sxdp_shared_umem_fd, tcp);
993 } else if (sa_xdp->sxdp_shared_umem_fd) {
994 tprint_struct_next();
995 PRINT_FIELD_X(*sa_xdp, sxdp_shared_umem_fd);
996 }
997 }
998
999 static void
1000 print_sockaddr_data_mctp(struct tcb *tcp, const void *const buf,
1001 const int addrlen)
1002 {
1003 const struct sockaddr_mctp *const sa_mctp = buf;
1004
1005 if (sa_mctp->__smctp_pad0) {
1006 PRINT_FIELD_X(*sa_mctp, __smctp_pad0);
1007 tprint_struct_next();
1008 }
1009 PRINT_FIELD_XVAL(*sa_mctp, smctp_network, mctp_nets, NULL);
1010 tprint_struct_next();
1011 tprints_field_name("smctp_addr");
1012 tprint_struct_begin();
1013 PRINT_FIELD_XVAL(sa_mctp->smctp_addr, s_addr, mctp_addrs, NULL);
1014 tprint_struct_end();
1015 tprint_struct_next();
1016 PRINT_FIELD_X(*sa_mctp, smctp_type);
1017 tprint_struct_next();
1018 PRINT_FIELD_X(*sa_mctp, smctp_tag);
1019 if (sa_mctp->__smctp_pad1) {
1020 tprint_struct_next();
1021 PRINT_FIELD_X(*sa_mctp, __smctp_pad1);
1022 }
1023
1024 }
1025
1026 typedef void (* const sockaddr_printer)(struct tcb *tcp, const void *const, const int);
1027
1028 static const struct {
1029 const sockaddr_printer printer;
1030 const int min_len;
1031 } sa_printers[] = {
1032 [AF_UNIX] = { print_sockaddr_data_un, SIZEOF_SA_FAMILY + 1 },
1033 [AF_INET] = { print_sockaddr_data_in, sizeof(struct sockaddr_in) },
1034 [AF_AX25] = { print_sockaddr_data_ax25, sizeof(struct sockaddr_ax25) },
1035 [AF_IPX] = { print_sockaddr_data_ipx, sizeof(struct sockaddr_ipx) },
1036 [AF_X25] = { print_sockaddr_data_x25, sizeof(struct sockaddr_x25) },
1037 [AF_INET6] = { print_sockaddr_data_in6, SIN6_MIN_LEN },
1038 [AF_NETLINK] = { print_sockaddr_data_nl, sizeof(struct sockaddr_nl) },
1039 [AF_PACKET] = { print_sockaddr_data_ll, sizeof(struct sockaddr_ll) },
1040 [AF_BLUETOOTH] = { print_sockaddr_data_bt, SIZEOF_SA_FAMILY + 1 },
1041 [AF_RXRPC] = { print_sockaddr_data_rxrpc, sizeof(struct sockaddr_rxrpc) },
1042 [AF_IEEE802154] = { print_sockaddr_data_ieee802154, sizeof(struct sockaddr_ieee802154) },
1043 [AF_ALG] = { print_sockaddr_data_alg, sizeof(struct sockaddr_alg_new) + 1 },
1044 [AF_NFC] = { print_sockaddr_data_nfc, sizeof(struct sockaddr_nfc) },
1045 [AF_VSOCK] = { print_sockaddr_data_vsock, sizeof(struct sockaddr_vm) },
1046 /* AF_KCM does not support connect/bind calls on its sockets */
1047 [AF_QIPCRTR] = { print_sockaddr_data_qrtr, sizeof(struct sockaddr_qrtr) },
1048 /* AF_SMC doesn't have sockaddr (INET{,6} sockaddrs are used instead) */
1049 [AF_XDP] = { print_sockaddr_data_xdp, sizeof(struct sockaddr_xdp) },
1050 [AF_MCTP] = { print_sockaddr_data_mctp, sizeof(struct sockaddr_mctp) },
1051 };
1052
1053 void
1054 print_sockaddr(struct tcb *tcp, const void *const buf, const int addrlen)
1055 {
1056 const struct sockaddr *const sa = buf;
1057
1058 tprint_struct_begin();
1059 PRINT_FIELD_XVAL(*sa, sa_family, addrfams, "AF_???");
1060
1061 if (addrlen > (int) SIZEOF_SA_FAMILY) {
1062 tprint_struct_next();
1063
1064 if (sa->sa_family < ARRAY_SIZE(sa_printers)
1065 && sa_printers[sa->sa_family].printer
1066 && addrlen >= sa_printers[sa->sa_family].min_len) {
1067 sa_printers[sa->sa_family].printer(tcp, buf, addrlen);
1068 } else {
1069 print_sockaddr_data_raw(buf, addrlen);
1070 }
1071 }
1072
1073 tprint_struct_end();
1074 }
1075
1076 int
1077 decode_sockaddr(struct tcb *const tcp, const kernel_ulong_t addr, int addrlen)
1078 {
1079 if (addrlen < 2) {
1080 printaddr(addr);
1081 return -1;
1082 }
1083
1084 union {
1085 struct sockaddr sa;
1086 struct sockaddr_storage storage;
1087 char pad[sizeof(struct sockaddr_storage) + 1];
1088 } addrbuf;
1089
1090 if ((unsigned) addrlen > sizeof(addrbuf.storage))
1091 addrlen = sizeof(addrbuf.storage);
1092
1093 if (umoven_or_printaddr(tcp, addr, addrlen, addrbuf.pad))
1094 return -1;
1095
1096 memset(&addrbuf.pad[addrlen], 0, sizeof(addrbuf.pad) - addrlen);
1097
1098 print_sockaddr(tcp, &addrbuf, addrlen);
1099
1100 return addrbuf.sa.sa_family;
1101 }