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.
31 #include <sys/socket.h>
32 #include <linux/audit.h>
33 #include <linux/netlink.h>
34 #include <linux/rtnetlink.h>
35 #include <linux/xfrm.h>
36 #include "xlat/netlink_flags.h"
37 #include "xlat/netlink_protocols.h"
38 #include "xlat/netlink_types.h"
39 #include "xlat/nl_audit_types.h"
40 #include "xlat/nl_netfilter_msg_types.h"
41 #include "xlat/nl_netfilter_subsys_ids.h"
42 #include "xlat/nl_route_types.h"
43 #include "xlat/nl_selinux_types.h"
44 #include "xlat/nl_sock_diag_types.h"
45 #include "xlat/nl_xfrm_types.h"
48 #define NLMSG_HDRLEN NLMSG_ALIGN(sizeof(struct nlmsghdr))
51 * Fetch a struct nlmsghdr from the given address.
54 fetch_nlmsghdr(struct tcb *const tcp, struct nlmsghdr *const nlmsghdr,
55 const kernel_ulong_t addr, const kernel_ulong_t len)
57 if (len < sizeof(struct nlmsghdr)) {
58 printstrn(tcp, addr, len);
62 if (umove_or_printaddr(tcp, addr, nlmsghdr))
70 NL_FAMILY_DEFAULT = -2
74 get_fd_nl_family(struct tcb *const tcp, const int fd)
76 const unsigned long inode = getfdinode(tcp, fd);
78 return NL_FAMILY_ERROR;
80 const char *const details = get_sockaddr_by_inode(tcp, fd, inode);
82 return NL_FAMILY_ERROR;
84 const char *const nl_details = STR_STRIP_PREFIX(details, "NETLINK:[");
85 if (nl_details == details)
86 return NL_FAMILY_ERROR;
88 const struct xlat *xlats = netlink_protocols;
89 for (; xlats->str; ++xlats) {
90 const char *name = STR_STRIP_PREFIX(xlats->str, "NETLINK_");
91 if (!strncmp(nl_details, name, strlen(name)))
95 if (*nl_details >= '0' && *nl_details <= '9')
96 return atoi(nl_details);
98 return NL_FAMILY_ERROR;
101 static const struct {
102 const struct xlat *const xlat;
103 const char *const dflt;
105 [NETLINK_AUDIT] = { nl_audit_types, "AUDIT_???" },
106 [NETLINK_NETFILTER] = { nl_netfilter_subsys_ids, "NFNL_SUBSYS_???" },
107 [NETLINK_ROUTE] = { nl_route_types, "RTM_???" },
108 [NETLINK_SELINUX] = { nl_selinux_types, "SELNL_MSG_???" },
109 [NETLINK_SOCK_DIAG] = { nl_sock_diag_types, "SOCK_DIAG_???" },
110 [NETLINK_XFRM] = { nl_xfrm_types, "XFRM_MSG_???" }
114 * As all valid netlink families are positive integers, use unsigned int
115 * for family here to filter out NL_FAMILY_ERROR and NL_FAMILY_DEFAULT.
118 decode_nlmsg_type(const uint16_t type, const unsigned int family)
120 if (family < ARRAY_SIZE(nlmsg_types)
121 && nlmsg_types[family].xlat) {
122 if (family == NETLINK_NETFILTER) {
123 /* Reserved control nfnetlink messages first. */
124 const char *text = xlookup(nl_netfilter_msg_types,
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(nlmsg_types[family].xlat, subsys_id,
139 nlmsg_types[family].dflt);
142 * The type is subsystem specific,
143 * print it in numeric format for now.
145 tprintf("<<8|%#x", msg_type);
147 printxval(nlmsg_types[family].xlat, type,
148 nlmsg_types[family].dflt);
151 printxval(netlink_types, type, "NLMSG_???");
156 print_nlmsghdr(struct tcb *tcp,
159 const struct nlmsghdr *const nlmsghdr)
161 /* print the whole structure regardless of its nlmsg_len */
163 tprintf("{len=%u, type=", nlmsghdr->nlmsg_len);
165 const int hdr_family = (nlmsghdr->nlmsg_type < NLMSG_MIN_TYPE)
167 : (family != NL_FAMILY_DEFAULT
168 ? family : get_fd_nl_family(tcp, fd));
170 decode_nlmsg_type(nlmsghdr->nlmsg_type, hdr_family);
173 printflags(netlink_flags, nlmsghdr->nlmsg_flags, "NLM_F_???");
175 tprintf(", seq=%u, pid=%u}", nlmsghdr->nlmsg_seq,
176 nlmsghdr->nlmsg_pid);
178 return family != NL_FAMILY_DEFAULT ? family : hdr_family;
182 decode_nlmsghdr_with_payload(struct tcb *const tcp,
185 const struct nlmsghdr *const nlmsghdr,
186 const kernel_ulong_t addr,
187 const kernel_ulong_t len);
190 decode_nlmsgerr(struct tcb *const tcp,
198 if (len < sizeof(err.error)) {
199 printstrn(tcp, addr, len);
203 if (umove_or_printaddr(tcp, addr, &err.error))
207 if (err.error < 0 && (unsigned) -err.error < nerrnos) {
208 tprintf("-%s", errnoent[-err.error]);
210 tprintf("%d", err.error);
213 addr += offsetof(struct nlmsgerr, msg);
214 len -= offsetof(struct nlmsgerr, msg);
218 if (fetch_nlmsghdr(tcp, &err.msg, addr, len)) {
219 decode_nlmsghdr_with_payload(tcp, fd, family,
220 &err.msg, addr, len);
228 decode_payload(struct tcb *const tcp,
231 const struct nlmsghdr *const nlmsghdr,
232 const kernel_ulong_t addr,
233 const kernel_ulong_t len)
235 if (nlmsghdr->nlmsg_type == NLMSG_ERROR) {
236 decode_nlmsgerr(tcp, fd, family, addr, len);
238 } else if (nlmsghdr->nlmsg_type == NLMSG_DONE && len == sizeof(int)) {
241 if (!umove_or_printaddr(tcp, addr, &num))
246 printstrn(tcp, addr, len);
250 decode_nlmsghdr_with_payload(struct tcb *const tcp,
253 const struct nlmsghdr *const nlmsghdr,
254 const kernel_ulong_t addr,
255 const kernel_ulong_t len)
259 family = print_nlmsghdr(tcp, fd, family, nlmsghdr);
261 unsigned int nlmsg_len =
262 nlmsghdr->nlmsg_len > len ? len : nlmsghdr->nlmsg_len;
263 if (nlmsg_len > NLMSG_HDRLEN) {
265 decode_payload(tcp, fd, family, nlmsghdr, addr + NLMSG_HDRLEN,
266 nlmsg_len - NLMSG_HDRLEN);
273 decode_netlink(struct tcb *const tcp,
278 struct nlmsghdr nlmsghdr;
279 bool print_array = false;
282 for (elt = 0; fetch_nlmsghdr(tcp, &nlmsghdr, addr, len); elt++) {
283 if (abbrev(tcp) && elt == max_strlen) {
288 unsigned int nlmsg_len = NLMSG_ALIGN(nlmsghdr.nlmsg_len);
289 kernel_ulong_t next_addr = 0;
290 kernel_ulong_t next_len = 0;
292 if (nlmsghdr.nlmsg_len >= NLMSG_HDRLEN) {
293 next_len = (len >= nlmsg_len) ? len - nlmsg_len : 0;
295 if (next_len && addr + nlmsg_len > addr)
296 next_addr = addr + nlmsg_len;
299 if (!print_array && next_addr) {
304 decode_nlmsghdr_with_payload(tcp, fd, NL_FAMILY_DEFAULT,
305 &nlmsghdr, addr, len);