granicus.if.org Git - strace/blob - netlink.c

   1 /*
   2  * Copyright (c) 2016 Fabien Siron <fabien.siron@epita.fr>
   3  * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
   4  * Copyright (c) 2016-2018 The strace developers.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  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.
  17  *
  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.
  28  */
  29
  30 #include "defs.h"
  31 #include "netlink.h"
  32 #include "nlattr.h"
  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_delete_flags.h"
  38 #include "xlat/netlink_flags.h"
  39 #include "xlat/netlink_get_flags.h"
  40 #include "xlat/netlink_new_flags.h"
  41 #include "xlat/netlink_protocols.h"
  42 #include "xlat/netlink_types.h"
  43 #include "xlat/nf_acct_msg_types.h"
  44 #include "xlat/nf_cthelper_msg_types.h"
  45 #include "xlat/nf_ctnetlink_exp_msg_types.h"
  46 #include "xlat/nf_ctnetlink_msg_types.h"
  47 #include "xlat/nf_cttimeout_msg_types.h"
  48 #include "xlat/nf_ipset_msg_types.h"
  49 #include "xlat/nf_nft_compat_msg_types.h"
  50 #include "xlat/nf_nftables_msg_types.h"
  51 #include "xlat/nf_osf_msg_types.h"
  52 #include "xlat/nf_queue_msg_types.h"
  53 #include "xlat/nf_ulog_msg_types.h"
  54 #include "xlat/nl_audit_types.h"
  55 #include "xlat/nl_crypto_types.h"
  56 #include "xlat/nl_netfilter_subsys_ids.h"
  57 #include "xlat/nl_selinux_types.h"
  58 #include "xlat/nl_sock_diag_types.h"
  59 #include "xlat/nl_xfrm_types.h"
  60 #include "xlat/nlmsgerr_attrs.h"
  61
  62 /*
  63  * Fetch a struct nlmsghdr from the given address.
  64  */
  65 static bool
  66 fetch_nlmsghdr(struct tcb *const tcp, struct nlmsghdr *const nlmsghdr,
  67                const kernel_ulong_t addr, const kernel_ulong_t len,
  68                const bool in_array)
  69 {
  70         if (len < sizeof(struct nlmsghdr)) {
  71                 printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
  72                 return false;
  73         }
  74
  75         if (tfetch_obj(tcp, addr, nlmsghdr))
  76                 return true;
  77
  78         if (in_array) {
  79                 tprints("...");
  80                 printaddr_comment(addr);
  81         } else {
  82                 printaddr(addr);
  83         }
  84
  85         return false;
  86 }
  87
  88 static int
  89 get_fd_nl_family(struct tcb *const tcp, const int fd)
  90 {
  91         const unsigned long inode = getfdinode(tcp, fd);
  92         if (!inode)
  93                 return -1;
  94
  95         const char *const details = get_sockaddr_by_inode(tcp, fd, inode);
  96         if (!details)
  97                 return -1;
  98
  99         const char *const nl_details = STR_STRIP_PREFIX(details, "NETLINK:[");
 100         if (nl_details == details)
 101                 return -1;
 102
 103         const struct xlat *xlats = netlink_protocols;
 104         for (; xlats->str; ++xlats) {
 105                 const char *name = STR_STRIP_PREFIX(xlats->str, "NETLINK_");
 106                 if (!strncmp(nl_details, name, strlen(name)))
 107                         return xlats->val;
 108         }
 109
 110         if (*nl_details >= '0' && *nl_details <= '9')
 111                 return atoi(nl_details);
 112
 113         return -1;
 114 }
 115
 116 static void
 117 decode_nlmsg_type_default(struct tcb *tcp, const struct xlat *const xlat,
 118                           const uint16_t type,
 119                           const char *const dflt)
 120 {
 121         printxval(xlat, type, dflt);
 122 }
 123
 124 static void
 125 decode_nlmsg_type_generic(struct tcb *tcp, const struct xlat *const xlat,
 126                           const uint16_t type,
 127                           const char *const dflt)
 128 {
 129         printxval(genl_families_xlat(tcp), type, dflt);
 130 }
 131
 132 static const struct {
 133         const struct xlat *const xlat;
 134         const char *const dflt;
 135 } nf_nlmsg_types[] = {
 136         [NFNL_SUBSYS_CTNETLINK] = {
 137                 nf_ctnetlink_msg_types,
 138                 "IPCTNL_MSG_CT_???"
 139         },
 140         [NFNL_SUBSYS_CTNETLINK_EXP] = {
 141                 nf_ctnetlink_exp_msg_types,
 142                 "IPCTNL_MSG_EXP_???"
 143         },
 144         [NFNL_SUBSYS_QUEUE] = { nf_queue_msg_types, "NFQNL_MSG_???" },
 145         [NFNL_SUBSYS_ULOG] = { nf_ulog_msg_types, "NFULNL_MSG_???" },
 146         [NFNL_SUBSYS_OSF] = { nf_osf_msg_types, "OSF_MSG_???" },
 147         [NFNL_SUBSYS_IPSET] = { nf_ipset_msg_types, "IPSET_CMD_???" },
 148         [NFNL_SUBSYS_ACCT] = { nf_acct_msg_types, "NFNL_MSG_ACCT_???" },
 149         [NFNL_SUBSYS_CTNETLINK_TIMEOUT] = {
 150                 nf_cttimeout_msg_types,
 151                 "IPCTNL_MSG_TIMEOUT_???"
 152         },
 153         [NFNL_SUBSYS_CTHELPER] = {
 154                 nf_cthelper_msg_types,
 155                 "NFNL_MSG_CTHELPER_???"
 156         },
 157         [NFNL_SUBSYS_NFTABLES] = { nf_nftables_msg_types, "NFT_MSG_???" },
 158         [NFNL_SUBSYS_NFT_COMPAT] = {
 159                 nf_nft_compat_msg_types,
 160                 "NFNL_MSG_COMPAT_???"
 161         }
 162 };
 163
 164 static void
 165 decode_nlmsg_type_netfilter(struct tcb *tcp, const struct xlat *const xlat,
 166                             const uint16_t type,
 167                             const char *const dflt)
 168 {
 169         /* Reserved control nfnetlink messages first. */
 170         const char *const text = xlookup(nl_netfilter_msg_types, type);
 171         if (text) {
 172                 print_xlat_ex(type, text, XLAT_STYLE_DEFAULT);
 173                 return;
 174         }
 175
 176         /*
 177          * Other netfilter message types are split
 178          * in two pieces: 8 bits subsystem and 8 bits type.
 179          */
 180         const uint8_t subsys_id = (uint8_t) (type >> 8);
 181         const uint8_t msg_type = (uint8_t) type;
 182
 183         printxval(xlat, subsys_id, dflt);
 184
 185         tprints("<<8|");
 186         if (subsys_id < ARRAY_SIZE(nf_nlmsg_types))
 187                 printxval(nf_nlmsg_types[subsys_id].xlat,
 188                           msg_type, nf_nlmsg_types[subsys_id].dflt);
 189         else
 190                 tprintf("%#x", msg_type);
 191 }
 192
 193 typedef void (*nlmsg_types_decoder_t)(struct tcb *, const struct xlat *,
 194                                       uint16_t type,
 195                                       const char *dflt);
 196
 197 static const struct {
 198         const nlmsg_types_decoder_t decoder;
 199         const struct xlat *const xlat;
 200         const char *const dflt;
 201 } nlmsg_types[] = {
 202         [NETLINK_AUDIT] = { NULL, nl_audit_types, "AUDIT_???" },
 203         [NETLINK_CRYPTO] = { NULL, nl_crypto_types, "CRYPTO_MSG_???" },
 204         [NETLINK_GENERIC] = {
 205                 decode_nlmsg_type_generic,
 206                 NULL,
 207                 "GENERIC_FAMILY_???"
 208         },
 209         [NETLINK_NETFILTER] = {
 210                 decode_nlmsg_type_netfilter,
 211                 nl_netfilter_subsys_ids,
 212                 "NFNL_SUBSYS_???"
 213         },
 214         [NETLINK_ROUTE] = { NULL, nl_route_types, "RTM_???" },
 215         [NETLINK_SELINUX] = { NULL, nl_selinux_types, "SELNL_MSG_???" },
 216         [NETLINK_SOCK_DIAG] = { NULL, nl_sock_diag_types, "SOCK_DIAG_???" },
 217         [NETLINK_XFRM] = { NULL, nl_xfrm_types, "XFRM_MSG_???" }
 218 };
 219
 220 /*
 221  * As all valid netlink families are positive integers, use unsigned int
 222  * for family here to filter out -1.
 223  */
 224 static void
 225 decode_nlmsg_type(struct tcb *tcp, const uint16_t type,
 226                   const unsigned int family)
 227 {
 228         nlmsg_types_decoder_t decoder = decode_nlmsg_type_default;
 229         const struct xlat *xlat = netlink_types;
 230         const char *dflt = "NLMSG_???";
 231
 232         /*
 233          * type < NLMSG_MIN_TYPE are reserved control messages
 234          * that need no family-specific decoding.
 235          */
 236         if (type >= NLMSG_MIN_TYPE && family < ARRAY_SIZE(nlmsg_types)) {
 237                 if (nlmsg_types[family].decoder)
 238                         decoder = nlmsg_types[family].decoder;
 239                 if (nlmsg_types[family].xlat)
 240                         xlat = nlmsg_types[family].xlat;
 241                 if (nlmsg_types[family].dflt)
 242                         dflt = nlmsg_types[family].dflt;
 243         }
 244
 245         decoder(tcp, xlat, type, dflt);
 246 }
 247
 248 static const struct xlat *
 249 decode_nlmsg_flags_crypto(const uint16_t type)
 250 {
 251         switch (type) {
 252         case CRYPTO_MSG_NEWALG:
 253                 return netlink_new_flags;
 254         case CRYPTO_MSG_DELALG:
 255         case CRYPTO_MSG_DELRNG:
 256                 return netlink_delete_flags;
 257         case CRYPTO_MSG_GETALG:
 258                 return netlink_get_flags;
 259         }
 260
 261         return NULL;
 262 }
 263
 264 static const struct xlat *
 265 decode_nlmsg_flags_netfilter(const uint16_t type)
 266 {
 267         const uint8_t subsys_id = (uint8_t) (type >> 8);
 268         const uint8_t msg_type = (uint8_t) type;
 269
 270         switch (subsys_id) {
 271         case NFNL_SUBSYS_CTNETLINK:
 272                 switch (msg_type) {
 273                 case IPCTNL_MSG_CT_NEW:
 274                         return netlink_new_flags;
 275                 case IPCTNL_MSG_CT_GET:
 276                 case IPCTNL_MSG_CT_GET_CTRZERO:
 277                 case IPCTNL_MSG_CT_GET_STATS_CPU:
 278                 case IPCTNL_MSG_CT_GET_STATS:
 279                 case IPCTNL_MSG_CT_GET_DYING:
 280                 case IPCTNL_MSG_CT_GET_UNCONFIRMED:
 281                         return netlink_get_flags;
 282                 case IPCTNL_MSG_CT_DELETE:
 283                         return netlink_delete_flags;
 284                 }
 285                 break;
 286         case NFNL_SUBSYS_CTNETLINK_EXP:
 287                 switch (msg_type) {
 288                 case IPCTNL_MSG_EXP_NEW:
 289                         return netlink_new_flags;
 290                 case IPCTNL_MSG_EXP_GET:
 291                 case IPCTNL_MSG_EXP_GET_STATS_CPU:
 292                         return netlink_get_flags;
 293                 case IPCTNL_MSG_EXP_DELETE:
 294                         return netlink_delete_flags;
 295                 }
 296                 break;
 297         case NFNL_SUBSYS_ACCT:
 298                 switch (msg_type) {
 299                 case NFNL_MSG_ACCT_NEW:
 300                         return netlink_new_flags;
 301                 case NFNL_MSG_ACCT_GET:
 302                 case NFNL_MSG_ACCT_GET_CTRZERO:
 303                         return netlink_get_flags;
 304                 case NFNL_MSG_ACCT_DEL:
 305                         return netlink_delete_flags;
 306                 }
 307                 break;
 308         case NFNL_SUBSYS_CTNETLINK_TIMEOUT:
 309                 switch (msg_type) {
 310                 case IPCTNL_MSG_TIMEOUT_NEW:
 311                         return netlink_new_flags;
 312                 case IPCTNL_MSG_TIMEOUT_GET:
 313                         return netlink_get_flags;
 314                 case IPCTNL_MSG_TIMEOUT_DELETE:
 315                         return netlink_delete_flags;
 316                 }
 317                 break;
 318         case NFNL_SUBSYS_CTHELPER:
 319                 switch (msg_type) {
 320                 case NFNL_MSG_CTHELPER_NEW:
 321                         return netlink_new_flags;
 322                 case NFNL_MSG_CTHELPER_GET:
 323                         return netlink_get_flags;
 324                 case NFNL_MSG_CTHELPER_DEL:
 325                         return netlink_delete_flags;
 326                 }
 327                 break;
 328         case NFNL_SUBSYS_NFTABLES:
 329                 switch (msg_type) {
 330                 case NFT_MSG_NEWTABLE:
 331                 case NFT_MSG_NEWCHAIN:
 332                 case NFT_MSG_NEWRULE:
 333                 case NFT_MSG_NEWSET:
 334                 case NFT_MSG_NEWSETELEM:
 335                 case NFT_MSG_NEWGEN:
 336                 case NFT_MSG_NEWOBJ:
 337                         return netlink_new_flags;
 338                 case NFT_MSG_GETTABLE:
 339                 case NFT_MSG_GETCHAIN:
 340                 case NFT_MSG_GETRULE:
 341                 case NFT_MSG_GETSET:
 342                 case NFT_MSG_GETSETELEM:
 343                 case NFT_MSG_GETGEN:
 344                 case NFT_MSG_GETOBJ:
 345                 case NFT_MSG_GETOBJ_RESET:
 346                         return netlink_get_flags;
 347                 case NFT_MSG_DELTABLE:
 348                 case NFT_MSG_DELCHAIN:
 349                 case NFT_MSG_DELRULE:
 350                 case NFT_MSG_DELSET:
 351                 case NFT_MSG_DELSETELEM:
 352                 case NFT_MSG_DELOBJ:
 353                         return netlink_delete_flags;
 354                 }
 355                 break;
 356         case NFNL_SUBSYS_NFT_COMPAT:
 357                 switch (msg_type) {
 358                 case NFNL_MSG_COMPAT_GET:
 359                         return netlink_get_flags;
 360                 }
 361                 break;
 362         }
 363
 364         return NULL;
 365 }
 366
 367 static const struct xlat *
 368 decode_nlmsg_flags_route(const uint16_t type)
 369 {
 370         /* RTM_DELACTION uses NLM_F_ROOT flags */
 371         if (type == RTM_DELACTION)
 372                 return netlink_get_flags;
 373         switch (type & 3) {
 374         case  0:
 375                 return netlink_new_flags;
 376         case  1:
 377                 return netlink_delete_flags;
 378         case  2:
 379                 return netlink_get_flags;
 380         }
 381
 382         return NULL;
 383 }
 384
 385 static const struct xlat *
 386 decode_nlmsg_flags_sock_diag(const uint16_t type)
 387 {
 388         return netlink_get_flags;
 389 }
 390
 391 static const struct xlat *
 392 decode_nlmsg_flags_xfrm(const uint16_t type)
 393 {
 394         switch (type) {
 395         case XFRM_MSG_NEWSA:
 396         case XFRM_MSG_NEWPOLICY:
 397         case XFRM_MSG_NEWAE:
 398         case XFRM_MSG_NEWSADINFO:
 399         case XFRM_MSG_NEWSPDINFO:
 400                 return netlink_new_flags;
 401         case XFRM_MSG_DELSA:
 402         case XFRM_MSG_DELPOLICY:
 403                 return netlink_delete_flags;
 404         case XFRM_MSG_GETSA:
 405         case XFRM_MSG_GETPOLICY:
 406         case XFRM_MSG_GETAE:
 407         case XFRM_MSG_GETSADINFO:
 408         case XFRM_MSG_GETSPDINFO:
 409                 return netlink_get_flags;
 410         }
 411
 412         return NULL;
 413 }
 414
 415 typedef const struct xlat *(*nlmsg_flags_decoder_t)(const uint16_t type);
 416
 417 static const nlmsg_flags_decoder_t nlmsg_flags[] = {
 418         [NETLINK_CRYPTO] = decode_nlmsg_flags_crypto,
 419         [NETLINK_NETFILTER] = decode_nlmsg_flags_netfilter,
 420         [NETLINK_ROUTE] = decode_nlmsg_flags_route,
 421         [NETLINK_SOCK_DIAG] = decode_nlmsg_flags_sock_diag,
 422         [NETLINK_XFRM] = decode_nlmsg_flags_xfrm
 423 };
 424
 425 /*
 426  * As all valid netlink families are positive integers, use unsigned int
 427  * for family here to filter out -1.
 428  */
 429 static void
 430 decode_nlmsg_flags(const uint16_t flags, const uint16_t type,
 431                    const unsigned int family)
 432 {
 433         const struct xlat *table = NULL;
 434
 435         if (type < NLMSG_MIN_TYPE) {
 436                 if (type == NLMSG_ERROR)
 437                         table = netlink_ack_flags;
 438         } else if (family < ARRAY_SIZE(nlmsg_flags) && nlmsg_flags[family])
 439                 table = nlmsg_flags[family](type);
 440
 441         printflags_ex(flags, "NLM_F_???", XLAT_STYLE_ABBREV,
 442                       netlink_flags, table, NULL);
 443 }
 444
 445 static void
 446 print_nlmsghdr(struct tcb *tcp,
 447                const int fd,
 448                const int family,
 449                const struct nlmsghdr *const nlmsghdr)
 450 {
 451         /* print the whole structure regardless of its nlmsg_len */
 452
 453         tprintf("{len=%u, type=", nlmsghdr->nlmsg_len);
 454
 455         decode_nlmsg_type(tcp, nlmsghdr->nlmsg_type, family);
 456
 457         tprints(", flags=");
 458         decode_nlmsg_flags(nlmsghdr->nlmsg_flags,
 459                            nlmsghdr->nlmsg_type, family);
 460
 461         tprintf(", seq=%u, pid=%u}", nlmsghdr->nlmsg_seq,
 462                 nlmsghdr->nlmsg_pid);
 463 }
 464
 465 static bool
 466 print_cookie(struct tcb *const tcp, void *const elem_buf,
 467              const size_t elem_size, void *const opaque_data)
 468 {
 469         tprintf("%" PRIu8, *(uint8_t *) elem_buf);
 470
 471         return true;
 472 }
 473
 474 static bool
 475 decode_nlmsgerr_attr_cookie(struct tcb *const tcp,
 476                             const kernel_ulong_t addr,
 477                             const unsigned int len,
 478                             const void *const opaque_data)
 479 {
 480         uint8_t cookie;
 481         const size_t nmemb = len / sizeof(cookie);
 482
 483         print_array(tcp, addr, nmemb, &cookie, sizeof(cookie),
 484                     tfetch_mem, print_cookie, 0);
 485
 486         return true;
 487 }
 488
 489 static const nla_decoder_t nlmsgerr_nla_decoders[] = {
 490         [NLMSGERR_ATTR_MSG]     = decode_nla_str,
 491         [NLMSGERR_ATTR_OFFS]    = decode_nla_u32,
 492         [NLMSGERR_ATTR_COOKIE]  = decode_nlmsgerr_attr_cookie
 493 };
 494
 495 static void
 496 decode_nlmsghdr_with_payload(struct tcb *const tcp,
 497                              const int fd,
 498                              const int family,
 499                              const struct nlmsghdr *const nlmsghdr,
 500                              const kernel_ulong_t addr,
 501                              const kernel_ulong_t len);
 502
 503 static void
 504 decode_nlmsgerr(struct tcb *const tcp,
 505                 const int fd,
 506                 const int family,
 507                 kernel_ulong_t addr,
 508                 unsigned int len,
 509                 const bool capped)
 510 {
 511         struct nlmsgerr err;
 512
 513         if (len < sizeof(err.error)) {
 514                 printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
 515                 return;
 516         }
 517
 518         if (umove_or_printaddr(tcp, addr, &err.error))
 519                 return;
 520
 521         tprints("{error=");
 522         if (err.error < 0 && (unsigned) -err.error < nerrnos) {
 523                 tprintf("-%s", errnoent[-err.error]);
 524         } else {
 525                 tprintf("%d", err.error);
 526         }
 527
 528         addr += offsetof(struct nlmsgerr, msg);
 529         len -= offsetof(struct nlmsgerr, msg);
 530
 531         if (len) {
 532                 tprints(", msg=");
 533                 if (fetch_nlmsghdr(tcp, &err.msg, addr, len, false)) {
 534                         unsigned int payload =
 535                                 capped ? sizeof(err.msg) : err.msg.nlmsg_len;
 536                         if (payload > len)
 537                                 payload = len;
 538
 539                         decode_nlmsghdr_with_payload(tcp, fd, family,
 540                                                      &err.msg, addr, payload);
 541                         if (len > payload) {
 542                                 tprints(", ");
 543                                 decode_nlattr(tcp, addr + payload,
 544                                               len - payload, nlmsgerr_attrs,
 545                                               "NLMSGERR_ATTR_???",
 546                                               nlmsgerr_nla_decoders,
 547                                               ARRAY_SIZE(nlmsgerr_nla_decoders),
 548                                               NULL);
 549                         }
 550                 }
 551         }
 552
 553         tprints("}");
 554 }
 555
 556 static const netlink_decoder_t netlink_decoders[] = {
 557 #ifdef HAVE_LINUX_CRYPTOUSER_H
 558         [NETLINK_CRYPTO] = decode_netlink_crypto,
 559 #endif
 560 #ifdef HAVE_LINUX_NETFILTER_NFNETLINK_H
 561         [NETLINK_NETFILTER] = decode_netlink_netfilter,
 562 #endif
 563         [NETLINK_ROUTE] = decode_netlink_route,
 564         [NETLINK_SELINUX] = decode_netlink_selinux,
 565         [NETLINK_SOCK_DIAG] = decode_netlink_sock_diag
 566 };
 567
 568 static void
 569 decode_payload(struct tcb *const tcp,
 570                const int fd,
 571                const int family,
 572                const struct nlmsghdr *const nlmsghdr,
 573                const kernel_ulong_t addr,
 574                const unsigned int len)
 575 {
 576         if (nlmsghdr->nlmsg_type == NLMSG_ERROR) {
 577                 decode_nlmsgerr(tcp, fd, family, addr, len,
 578                                 nlmsghdr->nlmsg_flags & NLM_F_CAPPED);
 579                 return;
 580         }
 581
 582         /*
 583          * While most of NLMSG_DONE messages indeed have payloads
 584          * containing just a single integer, there are few exceptions,
 585          * so pass payloads of NLMSG_DONE messages to family-specific
 586          * netlink payload decoders.
 587          *
 588          * Other types of reserved control messages need no family-specific
 589          * netlink payload decoding.
 590          */
 591         if ((nlmsghdr->nlmsg_type >= NLMSG_MIN_TYPE
 592             || nlmsghdr->nlmsg_type == NLMSG_DONE)
 593             && (unsigned int) family < ARRAY_SIZE(netlink_decoders)
 594             && netlink_decoders[family]
 595             && netlink_decoders[family](tcp, nlmsghdr, addr, len)) {
 596                 return;
 597         }
 598
 599         if (nlmsghdr->nlmsg_type == NLMSG_DONE && len == sizeof(int)) {
 600                 int num;
 601
 602                 if (!umove_or_printaddr(tcp, addr, &num))
 603                         tprintf("%d", num);
 604                 return;
 605         }
 606
 607         printstr_ex(tcp, addr, len, QUOTE_FORCE_HEX);
 608 }
 609
 610 static void
 611 decode_nlmsghdr_with_payload(struct tcb *const tcp,
 612                              const int fd,
 613                              const int family,
 614                              const struct nlmsghdr *const nlmsghdr,
 615                              const kernel_ulong_t addr,
 616                              const kernel_ulong_t len)
 617 {
 618         const unsigned int nlmsg_len = MIN(nlmsghdr->nlmsg_len, len);
 619
 620         if (nlmsg_len > NLMSG_HDRLEN)
 621                 tprints("{");
 622
 623         print_nlmsghdr(tcp, fd, family, nlmsghdr);
 624
 625         if (nlmsg_len > NLMSG_HDRLEN) {
 626                 tprints(", ");
 627                 decode_payload(tcp, fd, family, nlmsghdr, addr + NLMSG_HDRLEN,
 628                                                      nlmsg_len - NLMSG_HDRLEN);
 629                 tprints("}");
 630         }
 631 }
 632
 633 void
 634 decode_netlink(struct tcb *const tcp,
 635                const int fd,
 636                kernel_ulong_t addr,
 637                kernel_ulong_t len)
 638 {
 639         const int family = get_fd_nl_family(tcp, fd);
 640
 641         if (family == NETLINK_KOBJECT_UEVENT) {
 642                 decode_netlink_kobject_uevent(tcp, addr, len);
 643                 return;
 644         }
 645
 646         struct nlmsghdr nlmsghdr;
 647         bool is_array = false;
 648         unsigned int elt;
 649
 650         for (elt = 0; fetch_nlmsghdr(tcp, &nlmsghdr, addr, len, is_array);
 651              elt++) {
 652                 if (abbrev(tcp) && elt == max_strlen) {
 653                         tprints("...");
 654                         break;
 655                 }
 656
 657                 unsigned int nlmsg_len = NLMSG_ALIGN(nlmsghdr.nlmsg_len);
 658                 kernel_ulong_t next_addr = 0;
 659                 kernel_ulong_t next_len = 0;
 660
 661                 if (nlmsghdr.nlmsg_len >= NLMSG_HDRLEN) {
 662                         next_len = (len >= nlmsg_len) ? len - nlmsg_len : 0;
 663
 664                         if (next_len && addr + nlmsg_len > addr)
 665                                 next_addr = addr + nlmsg_len;
 666                 }
 667
 668                 if (!is_array && next_addr) {
 669                         tprints("[");
 670                         is_array = true;
 671                 }
 672
 673                 decode_nlmsghdr_with_payload(tcp, fd, family,
 674                                              &nlmsghdr, addr, len);
 675
 676                 if (!next_addr)
 677                         break;
 678
 679                 tprints(", ");
 680                 addr = next_addr;
 681                 len = next_len;
 682         }
 683
 684         if (is_array) {
 685                 tprints("]");
 686         }
 687 }