]> granicus.if.org Git - strace/blobdiff - netlink.c
nlattr: add unsigned int decoders that print in hex form
[strace] / netlink.c
index 2f346735c40accfa2f4cad35a8f63276229f331d..8a30483c39c45664e977511b2c89fc4ceff78483 100644 (file)
--- a/netlink.c
+++ b/netlink.c
@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2016 Fabien Siron <fabien.siron@epita.fr>
  * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
- * Copyright (c) 2016-2017 The strace developers.
+ * Copyright (c) 2016-2018 The strace developers.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #include <linux/rtnetlink.h>
 #include <linux/xfrm.h>
 #include "xlat/netlink_ack_flags.h"
+#include "xlat/netlink_delete_flags.h"
 #include "xlat/netlink_flags.h"
 #include "xlat/netlink_get_flags.h"
 #include "xlat/netlink_new_flags.h"
 #include "xlat/netlink_protocols.h"
 #include "xlat/netlink_types.h"
+#include "xlat/nf_acct_msg_types.h"
+#include "xlat/nf_cthelper_msg_types.h"
+#include "xlat/nf_ctnetlink_exp_msg_types.h"
+#include "xlat/nf_ctnetlink_msg_types.h"
+#include "xlat/nf_cttimeout_msg_types.h"
+#include "xlat/nf_ipset_msg_types.h"
+#include "xlat/nf_nft_compat_msg_types.h"
+#include "xlat/nf_nftables_msg_types.h"
+#include "xlat/nf_osf_msg_types.h"
+#include "xlat/nf_queue_msg_types.h"
+#include "xlat/nf_ulog_msg_types.h"
 #include "xlat/nl_audit_types.h"
 #include "xlat/nl_crypto_types.h"
-#include "xlat/nl_netfilter_msg_types.h"
 #include "xlat/nl_netfilter_subsys_ids.h"
-#include "xlat/nl_route_types.h"
 #include "xlat/nl_selinux_types.h"
 #include "xlat/nl_sock_diag_types.h"
 #include "xlat/nl_xfrm_types.h"
  */
 static bool
 fetch_nlmsghdr(struct tcb *const tcp, struct nlmsghdr *const nlmsghdr,
-              const kernel_ulong_t addr, const kernel_ulong_t len)
+              const kernel_ulong_t addr, const kernel_ulong_t len,
+              const bool in_array)
 {
        if (len < sizeof(struct nlmsghdr)) {
                printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
                return false;
        }
 
-       if (umove_or_printaddr(tcp, addr, nlmsghdr))
-               return false;
+       if (tfetch_obj(tcp, addr, nlmsghdr))
+               return true;
 
-       return true;
+       if (in_array) {
+               tprints("...");
+               printaddr_comment(addr);
+       } else {
+               printaddr(addr);
+       }
+
+       return false;
 }
 
 static int
@@ -96,7 +114,7 @@ get_fd_nl_family(struct tcb *const tcp, const int fd)
 }
 
 static void
-decode_nlmsg_type_default(const struct xlat *const xlat,
+decode_nlmsg_type_default(struct tcb *tcp, const struct xlat *const xlat,
                          const uint16_t type,
                          const char *const dflt)
 {
@@ -104,22 +122,54 @@ decode_nlmsg_type_default(const struct xlat *const xlat,
 }
 
 static void
-decode_nlmsg_type_generic(const struct xlat *const xlat,
+decode_nlmsg_type_generic(struct tcb *tcp, const struct xlat *const xlat,
                          const uint16_t type,
                          const char *const dflt)
 {
-       printxval(genl_families_xlat(), type, dflt);
+       printxval(genl_families_xlat(tcp), type, dflt);
 }
 
+static const struct {
+       const struct xlat *const xlat;
+       const char *const dflt;
+} nf_nlmsg_types[] = {
+       [NFNL_SUBSYS_CTNETLINK] = {
+               nf_ctnetlink_msg_types,
+               "IPCTNL_MSG_CT_???"
+       },
+       [NFNL_SUBSYS_CTNETLINK_EXP] = {
+               nf_ctnetlink_exp_msg_types,
+               "IPCTNL_MSG_EXP_???"
+       },
+       [NFNL_SUBSYS_QUEUE] = { nf_queue_msg_types, "NFQNL_MSG_???" },
+       [NFNL_SUBSYS_ULOG] = { nf_ulog_msg_types, "NFULNL_MSG_???" },
+       [NFNL_SUBSYS_OSF] = { nf_osf_msg_types, "OSF_MSG_???" },
+       [NFNL_SUBSYS_IPSET] = { nf_ipset_msg_types, "IPSET_CMD_???" },
+       [NFNL_SUBSYS_ACCT] = { nf_acct_msg_types, "NFNL_MSG_ACCT_???" },
+       [NFNL_SUBSYS_CTNETLINK_TIMEOUT] = {
+               nf_cttimeout_msg_types,
+               "IPCTNL_MSG_TIMEOUT_???"
+       },
+       [NFNL_SUBSYS_CTHELPER] = {
+               nf_cthelper_msg_types,
+               "NFNL_MSG_CTHELPER_???"
+       },
+       [NFNL_SUBSYS_NFTABLES] = { nf_nftables_msg_types, "NFT_MSG_???" },
+       [NFNL_SUBSYS_NFT_COMPAT] = {
+               nf_nft_compat_msg_types,
+               "NFNL_MSG_COMPAT_???"
+       }
+};
+
 static void
-decode_nlmsg_type_netfilter(const struct xlat *const xlat,
+decode_nlmsg_type_netfilter(struct tcb *tcp, const struct xlat *const xlat,
                            const uint16_t type,
                            const char *const dflt)
 {
        /* Reserved control nfnetlink messages first. */
        const char *const text = xlookup(nl_netfilter_msg_types, type);
        if (text) {
-               tprints(text);
+               print_xlat_ex(type, text, XLAT_STYLE_DEFAULT);
                return;
        }
 
@@ -132,14 +182,15 @@ decode_nlmsg_type_netfilter(const struct xlat *const xlat,
 
        printxval(xlat, subsys_id, dflt);
 
-       /*
-        * The type is subsystem specific,
-        * print it in numeric format for now.
-        */
-       tprintf("<<8|%#x", msg_type);
+       tprints("<<8|");
+       if (subsys_id < ARRAY_SIZE(nf_nlmsg_types))
+               printxval(nf_nlmsg_types[subsys_id].xlat,
+                         msg_type, nf_nlmsg_types[subsys_id].dflt);
+       else
+               tprintf("%#x", msg_type);
 }
 
-typedef void (*nlmsg_types_decoder_t)(const struct xlat *,
+typedef void (*nlmsg_types_decoder_t)(struct tcb *, const struct xlat *,
                                      uint16_t type,
                                      const char *dflt);
 
@@ -171,7 +222,8 @@ static const struct {
  * for family here to filter out -1.
  */
 static void
-decode_nlmsg_type(const uint16_t type, const unsigned int family)
+decode_nlmsg_type(struct tcb *tcp, const uint16_t type,
+                 const unsigned int family)
 {
        nlmsg_types_decoder_t decoder = decode_nlmsg_type_default;
        const struct xlat *xlat = netlink_types;
@@ -190,71 +242,204 @@ decode_nlmsg_type(const uint16_t type, const unsigned int family)
                        dflt = nlmsg_types[family].dflt;
        }
 
-       decoder(xlat, type, dflt);
+       decoder(tcp, xlat, type, dflt);
 }
 
-static void
-decode_nlmsg_flags(const uint16_t flags, const uint16_t type, const int family)
+static const struct xlat *
+decode_nlmsg_flags_crypto(const uint16_t type)
 {
-       const struct xlat *table = NULL;
-
-       if (type < NLMSG_MIN_TYPE) {
-               if (type == NLMSG_ERROR)
-                       table = netlink_ack_flags;
-               goto end;
+       switch (type) {
+       case CRYPTO_MSG_NEWALG:
+               return netlink_new_flags;
+       case CRYPTO_MSG_DELALG:
+       case CRYPTO_MSG_DELRNG:
+               return netlink_delete_flags;
+       case CRYPTO_MSG_GETALG:
+               return netlink_get_flags;
        }
 
-       switch (family) {
-       case NETLINK_CRYPTO:
-               switch (type) {
-               case CRYPTO_MSG_NEWALG:
-                       table = netlink_new_flags;
-                       break;
-               case CRYPTO_MSG_GETALG:
-                       table = netlink_get_flags;
-                       break;
+       return NULL;
+}
+
+static const struct xlat *
+decode_nlmsg_flags_netfilter(const uint16_t type)
+{
+       const uint8_t subsys_id = (uint8_t) (type >> 8);
+       const uint8_t msg_type = (uint8_t) type;
+
+       switch (subsys_id) {
+       case NFNL_SUBSYS_CTNETLINK:
+               switch (msg_type) {
+               case IPCTNL_MSG_CT_NEW:
+                       return netlink_new_flags;
+               case IPCTNL_MSG_CT_GET:
+               case IPCTNL_MSG_CT_GET_CTRZERO:
+               case IPCTNL_MSG_CT_GET_STATS_CPU:
+               case IPCTNL_MSG_CT_GET_STATS:
+               case IPCTNL_MSG_CT_GET_DYING:
+               case IPCTNL_MSG_CT_GET_UNCONFIRMED:
+                       return netlink_get_flags;
+               case IPCTNL_MSG_CT_DELETE:
+                       return netlink_delete_flags;
                }
                break;
-       case NETLINK_SOCK_DIAG:
-               table = netlink_get_flags;
+       case NFNL_SUBSYS_CTNETLINK_EXP:
+               switch (msg_type) {
+               case IPCTNL_MSG_EXP_NEW:
+                       return netlink_new_flags;
+               case IPCTNL_MSG_EXP_GET:
+               case IPCTNL_MSG_EXP_GET_STATS_CPU:
+                       return netlink_get_flags;
+               case IPCTNL_MSG_EXP_DELETE:
+                       return netlink_delete_flags;
+               }
                break;
-       case NETLINK_ROUTE:
-               if (type == RTM_DELACTION) {
-                       table = netlink_get_flags;
-                       break;
+       case NFNL_SUBSYS_ACCT:
+               switch (msg_type) {
+               case NFNL_MSG_ACCT_NEW:
+                       return netlink_new_flags;
+               case NFNL_MSG_ACCT_GET:
+               case NFNL_MSG_ACCT_GET_CTRZERO:
+                       return netlink_get_flags;
+               case NFNL_MSG_ACCT_DEL:
+                       return netlink_delete_flags;
                }
-               switch (type & 3) {
-               case  0:
-                       table = netlink_new_flags;
-                       break;
-               case  2:
-                       table = netlink_get_flags;
-                       break;
+               break;
+       case NFNL_SUBSYS_CTNETLINK_TIMEOUT:
+               switch (msg_type) {
+               case IPCTNL_MSG_TIMEOUT_NEW:
+                       return netlink_new_flags;
+               case IPCTNL_MSG_TIMEOUT_GET:
+                       return netlink_get_flags;
+               case IPCTNL_MSG_TIMEOUT_DELETE:
+                       return netlink_delete_flags;
                }
                break;
-       case NETLINK_XFRM:
-               switch (type) {
-               case XFRM_MSG_NEWSA:
-               case XFRM_MSG_NEWPOLICY:
-               case XFRM_MSG_NEWAE:
-               case XFRM_MSG_NEWSADINFO:
-               case XFRM_MSG_NEWSPDINFO:
-                       table = netlink_new_flags;
-                       break;
-
-               case XFRM_MSG_GETSA:
-               case XFRM_MSG_GETPOLICY:
-               case XFRM_MSG_GETAE:
-               case XFRM_MSG_GETSADINFO:
-               case XFRM_MSG_GETSPDINFO:
-                       table = netlink_get_flags;
-                       break;
+       case NFNL_SUBSYS_CTHELPER:
+               switch (msg_type) {
+               case NFNL_MSG_CTHELPER_NEW:
+                       return netlink_new_flags;
+               case NFNL_MSG_CTHELPER_GET:
+                       return netlink_get_flags;
+               case NFNL_MSG_CTHELPER_DEL:
+                       return netlink_delete_flags;
+               }
+               break;
+       case NFNL_SUBSYS_NFTABLES:
+               switch (msg_type) {
+               case NFT_MSG_NEWTABLE:
+               case NFT_MSG_NEWCHAIN:
+               case NFT_MSG_NEWRULE:
+               case NFT_MSG_NEWSET:
+               case NFT_MSG_NEWSETELEM:
+               case NFT_MSG_NEWGEN:
+               case NFT_MSG_NEWOBJ:
+                       return netlink_new_flags;
+               case NFT_MSG_GETTABLE:
+               case NFT_MSG_GETCHAIN:
+               case NFT_MSG_GETRULE:
+               case NFT_MSG_GETSET:
+               case NFT_MSG_GETSETELEM:
+               case NFT_MSG_GETGEN:
+               case NFT_MSG_GETOBJ:
+               case NFT_MSG_GETOBJ_RESET:
+                       return netlink_get_flags;
+               case NFT_MSG_DELTABLE:
+               case NFT_MSG_DELCHAIN:
+               case NFT_MSG_DELRULE:
+               case NFT_MSG_DELSET:
+               case NFT_MSG_DELSETELEM:
+               case NFT_MSG_DELOBJ:
+                       return netlink_delete_flags;
+               }
+               break;
+       case NFNL_SUBSYS_NFT_COMPAT:
+               switch (msg_type) {
+               case NFNL_MSG_COMPAT_GET:
+                       return netlink_get_flags;
                }
                break;
        }
 
-end:
-       printflags_ex(flags, "NLM_F_???", netlink_flags, table, NULL);
+       return NULL;
+}
+
+static const struct xlat *
+decode_nlmsg_flags_route(const uint16_t type)
+{
+       /* RTM_DELACTION uses NLM_F_ROOT flags */
+       if (type == RTM_DELACTION)
+               return netlink_get_flags;
+       switch (type & 3) {
+       case  0:
+               return netlink_new_flags;
+       case  1:
+               return netlink_delete_flags;
+       case  2:
+               return netlink_get_flags;
+       }
+
+       return NULL;
+}
+
+static const struct xlat *
+decode_nlmsg_flags_sock_diag(const uint16_t type)
+{
+       return netlink_get_flags;
+}
+
+static const struct xlat *
+decode_nlmsg_flags_xfrm(const uint16_t type)
+{
+       switch (type) {
+       case XFRM_MSG_NEWSA:
+       case XFRM_MSG_NEWPOLICY:
+       case XFRM_MSG_NEWAE:
+       case XFRM_MSG_NEWSADINFO:
+       case XFRM_MSG_NEWSPDINFO:
+               return netlink_new_flags;
+       case XFRM_MSG_DELSA:
+       case XFRM_MSG_DELPOLICY:
+               return netlink_delete_flags;
+       case XFRM_MSG_GETSA:
+       case XFRM_MSG_GETPOLICY:
+       case XFRM_MSG_GETAE:
+       case XFRM_MSG_GETSADINFO:
+       case XFRM_MSG_GETSPDINFO:
+               return netlink_get_flags;
+       }
+
+       return NULL;
+}
+
+typedef const struct xlat *(*nlmsg_flags_decoder_t)(const uint16_t type);
+
+static const nlmsg_flags_decoder_t nlmsg_flags[] = {
+       [NETLINK_CRYPTO] = decode_nlmsg_flags_crypto,
+       [NETLINK_NETFILTER] = decode_nlmsg_flags_netfilter,
+       [NETLINK_ROUTE] = decode_nlmsg_flags_route,
+       [NETLINK_SOCK_DIAG] = decode_nlmsg_flags_sock_diag,
+       [NETLINK_XFRM] = decode_nlmsg_flags_xfrm
+};
+
+/*
+ * As all valid netlink families are positive integers, use unsigned int
+ * for family here to filter out -1.
+ */
+static void
+decode_nlmsg_flags(const uint16_t flags, const uint16_t type,
+                  const unsigned int family)
+{
+       const struct xlat *table = NULL;
+
+       if (type < NLMSG_MIN_TYPE) {
+               if (type == NLMSG_ERROR)
+                       table = netlink_ack_flags;
+       } else if (family < ARRAY_SIZE(nlmsg_flags) && nlmsg_flags[family])
+               table = nlmsg_flags[family](type);
+
+       printflags_ex(flags, "NLM_F_???", XLAT_STYLE_ABBREV,
+                     netlink_flags, table, NULL);
 }
 
 static void
@@ -267,7 +452,7 @@ print_nlmsghdr(struct tcb *tcp,
 
        tprintf("{len=%u, type=", nlmsghdr->nlmsg_len);
 
-       decode_nlmsg_type(nlmsghdr->nlmsg_type, family);
+       decode_nlmsg_type(tcp, nlmsghdr->nlmsg_type, family);
 
        tprints(", flags=");
        decode_nlmsg_flags(nlmsghdr->nlmsg_flags,
@@ -296,7 +481,7 @@ decode_nlmsgerr_attr_cookie(struct tcb *const tcp,
        const size_t nmemb = len / sizeof(cookie);
 
        print_array(tcp, addr, nmemb, &cookie, sizeof(cookie),
-                   umoven_or_printaddr, print_cookie, 0);
+                   tfetch_mem, print_cookie, 0);
 
        return true;
 }
@@ -345,7 +530,7 @@ decode_nlmsgerr(struct tcb *const tcp,
 
        if (len) {
                tprints(", msg=");
-               if (fetch_nlmsghdr(tcp, &err.msg, addr, len)) {
+               if (fetch_nlmsghdr(tcp, &err.msg, addr, len, false)) {
                        unsigned int payload =
                                capped ? sizeof(err.msg) : err.msg.nlmsg_len;
                        if (payload > len)
@@ -372,6 +557,10 @@ static const netlink_decoder_t netlink_decoders[] = {
 #ifdef HAVE_LINUX_CRYPTOUSER_H
        [NETLINK_CRYPTO] = decode_netlink_crypto,
 #endif
+#ifdef HAVE_LINUX_NETFILTER_NFNETLINK_H
+       [NETLINK_NETFILTER] = decode_netlink_netfilter,
+#endif
+       [NETLINK_ROUTE] = decode_netlink_route,
        [NETLINK_SELINUX] = decode_netlink_selinux,
        [NETLINK_SOCK_DIAG] = decode_netlink_sock_diag
 };
@@ -426,8 +615,7 @@ decode_nlmsghdr_with_payload(struct tcb *const tcp,
                             const kernel_ulong_t addr,
                             const kernel_ulong_t len)
 {
-       const unsigned int nlmsg_len =
-               nlmsghdr->nlmsg_len > len ? len : nlmsghdr->nlmsg_len;
+       const unsigned int nlmsg_len = MIN(nlmsghdr->nlmsg_len, len);
 
        if (nlmsg_len > NLMSG_HDRLEN)
                tprints("{");
@@ -451,15 +639,16 @@ decode_netlink(struct tcb *const tcp,
        const int family = get_fd_nl_family(tcp, fd);
 
        if (family == NETLINK_KOBJECT_UEVENT) {
-               printstrn(tcp, addr, len);
+               decode_netlink_kobject_uevent(tcp, addr, len);
                return;
        }
 
        struct nlmsghdr nlmsghdr;
-       bool print_array = false;
+       bool is_array = false;
        unsigned int elt;
 
-       for (elt = 0; fetch_nlmsghdr(tcp, &nlmsghdr, addr, len); elt++) {
+       for (elt = 0; fetch_nlmsghdr(tcp, &nlmsghdr, addr, len, is_array);
+            elt++) {
                if (abbrev(tcp) && elt == max_strlen) {
                        tprints("...");
                        break;
@@ -476,9 +665,9 @@ decode_netlink(struct tcb *const tcp,
                                next_addr = addr + nlmsg_len;
                }
 
-               if (!print_array && next_addr) {
+               if (!is_array && next_addr) {
                        tprints("[");
-                       print_array = true;
+                       is_array = true;
                }
 
                decode_nlmsghdr_with_payload(tcp, fd, family,
@@ -492,7 +681,7 @@ decode_netlink(struct tcb *const tcp,
                len = next_len;
        }
 
-       if (print_array) {
+       if (is_array) {
                tprints("]");
        }
 }