2 * Copyright (c) 2016 Fabien Siron <fabien.siron@epita.fr>
3 * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
4 * Copyright (c) 2016-2017 The strace developers.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include <linux/audit.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/xfrm.h>
36 #include "xlat/netlink_ack_flags.h"
37 #include "xlat/netlink_flags.h"
38 #include "xlat/netlink_get_flags.h"
39 #include "xlat/netlink_new_flags.h"
40 #include "xlat/netlink_protocols.h"
41 #include "xlat/netlink_types.h"
42 #include "xlat/nl_audit_types.h"
43 #include "xlat/nl_crypto_types.h"
44 #include "xlat/nl_netfilter_msg_types.h"
45 #include "xlat/nl_netfilter_subsys_ids.h"
46 #include "xlat/nl_route_types.h"
47 #include "xlat/nl_selinux_types.h"
48 #include "xlat/nl_sock_diag_types.h"
49 #include "xlat/nl_xfrm_types.h"
50 #include "xlat/nlmsgerr_attrs.h"
53 * Fetch a struct nlmsghdr from the given address.
56 fetch_nlmsghdr(struct tcb *const tcp, struct nlmsghdr *const nlmsghdr,
57 const kernel_ulong_t addr, const kernel_ulong_t len)
59 if (len < sizeof(struct nlmsghdr)) {
60 printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
64 if (umove_or_printaddr(tcp, addr, nlmsghdr))
72 NL_FAMILY_DEFAULT = -2
76 get_fd_nl_family(struct tcb *const tcp, const int fd)
78 const unsigned long inode = getfdinode(tcp, fd);
80 return NL_FAMILY_ERROR;
82 const char *const details = get_sockaddr_by_inode(tcp, fd, inode);
84 return NL_FAMILY_ERROR;
86 const char *const nl_details = STR_STRIP_PREFIX(details, "NETLINK:[");
87 if (nl_details == details)
88 return NL_FAMILY_ERROR;
90 const struct xlat *xlats = netlink_protocols;
91 for (; xlats->str; ++xlats) {
92 const char *name = STR_STRIP_PREFIX(xlats->str, "NETLINK_");
93 if (!strncmp(nl_details, name, strlen(name)))
97 if (*nl_details >= '0' && *nl_details <= '9')
98 return atoi(nl_details);
100 return NL_FAMILY_ERROR;
104 decode_nlmsg_type_default(const struct xlat *const xlat,
106 const char *const dflt)
108 printxval(xlat, type, dflt);
112 decode_nlmsg_type_generic(const struct xlat *const xlat,
114 const char *const dflt)
116 printxval(genl_families_xlat(), type, dflt);
120 decode_nlmsg_type_netfilter(const struct xlat *const xlat,
122 const char *const dflt)
124 /* Reserved control nfnetlink messages first. */
125 const char *const text = xlookup(nl_netfilter_msg_types, type);
132 * Other netfilter message types are split
133 * in two pieces: 8 bits subsystem and 8 bits type.
135 const uint8_t subsys_id = (uint8_t) (type >> 8);
136 const uint8_t msg_type = (uint8_t) type;
138 printxval(xlat, subsys_id, dflt);
141 * The type is subsystem specific,
142 * print it in numeric format for now.
144 tprintf("<<8|%#x", msg_type);
147 typedef void (*nlmsg_types_decoder_t)(const struct xlat *,
151 static const struct {
152 const nlmsg_types_decoder_t decoder;
153 const struct xlat *const xlat;
154 const char *const dflt;
156 [NETLINK_AUDIT] = { NULL, nl_audit_types, "AUDIT_???" },
157 [NETLINK_CRYPTO] = { NULL, nl_crypto_types, "CRYPTO_MSG_???" },
158 [NETLINK_GENERIC] = {
159 decode_nlmsg_type_generic,
163 [NETLINK_NETFILTER] = {
164 decode_nlmsg_type_netfilter,
165 nl_netfilter_subsys_ids,
168 [NETLINK_ROUTE] = { NULL, nl_route_types, "RTM_???" },
169 [NETLINK_SELINUX] = { NULL, nl_selinux_types, "SELNL_MSG_???" },
170 [NETLINK_SOCK_DIAG] = { NULL, nl_sock_diag_types, "SOCK_DIAG_???" },
171 [NETLINK_XFRM] = { NULL, nl_xfrm_types, "XFRM_MSG_???" }
175 * As all valid netlink families are positive integers, use unsigned int
176 * for family here to filter out NL_FAMILY_ERROR and NL_FAMILY_DEFAULT.
179 decode_nlmsg_type(const uint16_t type, const unsigned int family)
181 nlmsg_types_decoder_t decoder = decode_nlmsg_type_default;
182 const struct xlat *xlat = netlink_types;
183 const char *dflt = "NLMSG_???";
185 if (type != NLMSG_DONE && family < ARRAY_SIZE(nlmsg_types)) {
186 if (nlmsg_types[family].decoder)
187 decoder = nlmsg_types[family].decoder;
188 if (nlmsg_types[family].xlat)
189 xlat = nlmsg_types[family].xlat;
190 if (nlmsg_types[family].dflt)
191 dflt = nlmsg_types[family].dflt;
194 decoder(xlat, type, dflt);
198 decode_nlmsg_flags(const uint16_t flags, const uint16_t type, const int family)
200 const struct xlat *table = NULL;
202 if (type < NLMSG_MIN_TYPE) {
203 if (type == NLMSG_ERROR)
204 table = netlink_ack_flags;
211 case CRYPTO_MSG_NEWALG:
212 table = netlink_new_flags;
214 case CRYPTO_MSG_GETALG:
215 table = netlink_get_flags;
219 case NETLINK_SOCK_DIAG:
220 table = netlink_get_flags;
223 if (type == RTM_DELACTION) {
224 table = netlink_get_flags;
229 table = netlink_new_flags;
232 table = netlink_get_flags;
239 case XFRM_MSG_NEWPOLICY:
241 case XFRM_MSG_NEWSADINFO:
242 case XFRM_MSG_NEWSPDINFO:
243 table = netlink_new_flags;
247 case XFRM_MSG_GETPOLICY:
249 case XFRM_MSG_GETSADINFO:
250 case XFRM_MSG_GETSPDINFO:
251 table = netlink_get_flags;
258 printflags_ex(flags, "NLM_F_???", netlink_flags, table, NULL);
262 print_nlmsghdr(struct tcb *tcp,
265 const struct nlmsghdr *const nlmsghdr)
267 /* print the whole structure regardless of its nlmsg_len */
269 tprintf("{len=%u, type=", nlmsghdr->nlmsg_len);
271 const int hdr_family = (nlmsghdr->nlmsg_type < NLMSG_MIN_TYPE
272 && nlmsghdr->nlmsg_type != NLMSG_DONE)
274 : (family != NL_FAMILY_DEFAULT
275 ? family : get_fd_nl_family(tcp, fd));
277 decode_nlmsg_type(nlmsghdr->nlmsg_type, hdr_family);
280 decode_nlmsg_flags(nlmsghdr->nlmsg_flags,
281 nlmsghdr->nlmsg_type, hdr_family);
283 tprintf(", seq=%u, pid=%u}", nlmsghdr->nlmsg_seq,
284 nlmsghdr->nlmsg_pid);
286 return family != NL_FAMILY_DEFAULT ? family : hdr_family;
290 print_cookie(struct tcb *const tcp,
291 void *const elem_buf,
292 const size_t elem_size,
293 void *const opaque_data)
295 tprintf("%" PRIu8, *(uint8_t *) elem_buf);
301 decode_nlmsgerr_attr_cookie(struct tcb *const tcp,
302 const kernel_ulong_t addr,
303 const unsigned int len,
304 const void *const opaque_data)
307 const size_t nmemb = len / sizeof(cookie);
309 print_array(tcp, addr, nmemb, &cookie, sizeof(cookie),
310 umoven_or_printaddr, print_cookie, 0);
315 static const nla_decoder_t nlmsgerr_nla_decoders[] = {
316 [NLMSGERR_ATTR_MSG] = decode_nla_str,
317 [NLMSGERR_ATTR_OFFS] = decode_nla_u32,
318 [NLMSGERR_ATTR_COOKIE] = decode_nlmsgerr_attr_cookie
322 decode_nlmsghdr_with_payload(struct tcb *const tcp,
325 const struct nlmsghdr *const nlmsghdr,
326 const kernel_ulong_t addr,
327 const kernel_ulong_t len);
330 decode_nlmsgerr(struct tcb *const tcp,
339 if (len < sizeof(err.error)) {
340 printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
344 if (umove_or_printaddr(tcp, addr, &err.error))
348 if (err.error < 0 && (unsigned) -err.error < nerrnos) {
349 tprintf("-%s", errnoent[-err.error]);
351 tprintf("%d", err.error);
354 addr += offsetof(struct nlmsgerr, msg);
355 len -= offsetof(struct nlmsgerr, msg);
359 if (fetch_nlmsghdr(tcp, &err.msg, addr, len)) {
360 unsigned int payload =
361 capped ? sizeof(err.msg) : err.msg.nlmsg_len;
365 decode_nlmsghdr_with_payload(tcp, fd, family,
366 &err.msg, addr, payload);
369 decode_nlattr(tcp, addr + payload,
370 len - payload, nlmsgerr_attrs,
372 nlmsgerr_nla_decoders,
373 ARRAY_SIZE(nlmsgerr_nla_decoders),
382 static const netlink_decoder_t netlink_decoders[] = {
383 #ifdef HAVE_LINUX_CRYPTOUSER_H
384 [NETLINK_CRYPTO] = decode_netlink_crypto,
386 [NETLINK_SELINUX] = decode_netlink_selinux,
387 [NETLINK_SOCK_DIAG] = decode_netlink_sock_diag
391 decode_payload(struct tcb *const tcp,
394 const struct nlmsghdr *const nlmsghdr,
395 const kernel_ulong_t addr,
396 const unsigned int len)
398 if (nlmsghdr->nlmsg_type == NLMSG_ERROR) {
399 decode_nlmsgerr(tcp, fd, family, addr, len,
400 nlmsghdr->nlmsg_flags & NLM_F_CAPPED);
404 if ((unsigned int) family < ARRAY_SIZE(netlink_decoders)
405 && netlink_decoders[family]
406 && netlink_decoders[family](tcp, nlmsghdr, addr, len)) {
410 if (nlmsghdr->nlmsg_type == NLMSG_DONE && len == sizeof(int)) {
413 if (!umove_or_printaddr(tcp, addr, &num))
418 printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
422 decode_nlmsghdr_with_payload(struct tcb *const tcp,
425 const struct nlmsghdr *const nlmsghdr,
426 const kernel_ulong_t addr,
427 const kernel_ulong_t len)
429 const unsigned int nlmsg_len =
430 nlmsghdr->nlmsg_len > len ? len : nlmsghdr->nlmsg_len;
432 if (nlmsg_len > NLMSG_HDRLEN)
435 family = print_nlmsghdr(tcp, fd, family, nlmsghdr);
437 if (nlmsg_len > NLMSG_HDRLEN) {
439 decode_payload(tcp, fd, family, nlmsghdr, addr + NLMSG_HDRLEN,
440 nlmsg_len - NLMSG_HDRLEN);
446 decode_netlink(struct tcb *const tcp,
451 struct nlmsghdr nlmsghdr;
452 bool print_array = false;
455 for (elt = 0; fetch_nlmsghdr(tcp, &nlmsghdr, addr, len); elt++) {
456 if (abbrev(tcp) && elt == max_strlen) {
461 unsigned int nlmsg_len = NLMSG_ALIGN(nlmsghdr.nlmsg_len);
462 kernel_ulong_t next_addr = 0;
463 kernel_ulong_t next_len = 0;
465 if (nlmsghdr.nlmsg_len >= NLMSG_HDRLEN) {
466 next_len = (len >= nlmsg_len) ? len - nlmsg_len : 0;
468 if (next_len && addr + nlmsg_len > addr)
469 next_addr = addr + nlmsg_len;
472 if (!print_array && next_addr) {
477 decode_nlmsghdr_with_payload(tcp, fd, NL_FAMILY_DEFAULT,
478 &nlmsghdr, addr, len);