src/netlink.c

   1 /**
   2  * collectd - src/netlink.c
   3  * Copyright (C) 2007-2010  Florian octo Forster
   4  * Copyright (C) 2008-2012  Sebastian Harl
   5  * Copyright (C) 2013       Andreas Henriksson
   6  * Copyright (C) 2013       Marc Fournier
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; only version 2 of the License is applicable.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  20  *
  21  * Authors:
  22  *   Florian octo Forster <octo at collectd.org>
  23  *   Sebastian Harl <sh at tokkee.org>
  24  *   Andreas Henriksson <andreas at fatal.se>
  25  *   Marc Fournier <marc.fournier at camptocamp.com>
  26  **/
  27
  28 #include "collectd.h"
  29
  30 #include "common.h"
  31 #include "plugin.h"
  32
  33 #include <asm/types.h>
  34
  35 #include <linux/netlink.h>
  36 #include <linux/rtnetlink.h>
  37 #if HAVE_LINUX_GEN_STATS_H
  38 #include <linux/gen_stats.h>
  39 #endif
  40 #if HAVE_LINUX_PKT_SCHED_H
  41 #include <linux/pkt_sched.h>
  42 #endif
  43
  44 #include <libmnl/libmnl.h>
  45
  46 struct ir_link_stats_storage_s {
  47
  48   uint64_t rx_packets;
  49   uint64_t tx_packets;
  50   uint64_t rx_bytes;
  51   uint64_t tx_bytes;
  52   uint64_t rx_errors;
  53   uint64_t tx_errors;
  54
  55   uint64_t rx_dropped;
  56   uint64_t tx_dropped;
  57   uint64_t multicast;
  58   uint64_t collisions;
  59
  60   uint64_t rx_length_errors;
  61   uint64_t rx_over_errors;
  62   uint64_t rx_crc_errors;
  63   uint64_t rx_frame_errors;
  64   uint64_t rx_fifo_errors;
  65   uint64_t rx_missed_errors;
  66
  67   uint64_t tx_aborted_errors;
  68   uint64_t tx_carrier_errors;
  69   uint64_t tx_fifo_errors;
  70   uint64_t tx_heartbeat_errors;
  71   uint64_t tx_window_errors;
  72 };
  73
  74 union ir_link_stats_u {
  75   struct rtnl_link_stats *stats32;
  76 #ifdef HAVE_RTNL_LINK_STATS64
  77   struct rtnl_link_stats64 *stats64;
  78 #endif
  79 };
  80
  81 typedef struct ir_ignorelist_s {
  82   char *device;
  83   char *type;
  84   char *inst;
  85   struct ir_ignorelist_s *next;
  86 } ir_ignorelist_t;
  87
  88 struct qos_stats {
  89   struct gnet_stats_basic *bs;
  90   struct gnet_stats_queue *qs;
  91 };
  92
  93 static int ir_ignorelist_invert = 1;
  94 static ir_ignorelist_t *ir_ignorelist_head = NULL;
  95
  96 static struct mnl_socket *nl;
  97
  98 static char **iflist = NULL;
  99 static size_t iflist_len = 0;
 100
 101 static const char *config_keys[] = {"Interface", "VerboseInterface",
 102                                     "QDisc",     "Class",
 103                                     "Filter",    "IgnoreSelected"};
 104 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
 105
 106 static int add_ignorelist(const char *dev, const char *type, const char *inst) {
 107   ir_ignorelist_t *entry;
 108
 109   entry = calloc(1, sizeof(*entry));
 110   if (entry == NULL)
 111     return -1;
 112
 113   if (strcasecmp(dev, "All") != 0) {
 114     entry->device = strdup(dev);
 115     if (entry->device == NULL) {
 116       sfree(entry);
 117       return -1;
 118     }
 119   }
 120
 121   entry->type = strdup(type);
 122   if (entry->type == NULL) {
 123     sfree(entry->device);
 124     sfree(entry);
 125     return -1;
 126   }
 127
 128   if (inst != NULL) {
 129     entry->inst = strdup(inst);
 130     if (entry->inst == NULL) {
 131       sfree(entry->type);
 132       sfree(entry->device);
 133       sfree(entry);
 134       return -1;
 135     }
 136   }
 137
 138   entry->next = ir_ignorelist_head;
 139   ir_ignorelist_head = entry;
 140
 141   return 0;
 142 } /* int add_ignorelist */
 143
 144 /*
 145  * Checks wether a data set should be ignored. Returns `true' is the value
 146  * should be ignored, `false' otherwise.
 147  */
 148 static int check_ignorelist(const char *dev, const char *type,
 149                             const char *type_instance) {
 150   assert((dev != NULL) && (type != NULL));
 151
 152   if (ir_ignorelist_head == NULL)
 153     return ir_ignorelist_invert ? 0 : 1;
 154
 155   for (ir_ignorelist_t *i = ir_ignorelist_head; i != NULL; i = i->next) {
 156     /* i->device == NULL  =>  match all devices */
 157     if ((i->device != NULL) && (strcasecmp(i->device, dev) != 0))
 158       continue;
 159
 160     if (strcasecmp(i->type, type) != 0)
 161       continue;
 162
 163     if ((i->inst != NULL) && (type_instance != NULL) &&
 164         (strcasecmp(i->inst, type_instance) != 0))
 165       continue;
 166
 167     DEBUG("netlink plugin: check_ignorelist: "
 168           "(dev = %s; type = %s; inst = %s) matched "
 169           "(dev = %s; type = %s; inst = %s)",
 170           dev, type, type_instance == NULL ? "(nil)" : type_instance,
 171           i->device == NULL ? "(nil)" : i->device, i->type,
 172           i->inst == NULL ? "(nil)" : i->inst);
 173
 174     return ir_ignorelist_invert ? 0 : 1;
 175   } /* for i */
 176
 177   return ir_ignorelist_invert;
 178 } /* int check_ignorelist */
 179
 180 static void submit_one(const char *dev, const char *type,
 181                        const char *type_instance, derive_t value) {
 182   value_list_t vl = VALUE_LIST_INIT;
 183
 184   vl.values = &(value_t){.derive = value};
 185   vl.values_len = 1;
 186   sstrncpy(vl.plugin, "netlink", sizeof(vl.plugin));
 187   sstrncpy(vl.plugin_instance, dev, sizeof(vl.plugin_instance));
 188   sstrncpy(vl.type, type, sizeof(vl.type));
 189
 190   if (type_instance != NULL)
 191     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
 192
 193   plugin_dispatch_values(&vl);
 194 } /* void submit_one */
 195
 196 static void submit_two(const char *dev, const char *type,
 197                        const char *type_instance, derive_t rx, derive_t tx) {
 198   value_list_t vl = VALUE_LIST_INIT;
 199   value_t values[] = {
 200       {.derive = rx}, {.derive = tx},
 201   };
 202
 203   vl.values = values;
 204   vl.values_len = STATIC_ARRAY_SIZE(values);
 205   sstrncpy(vl.plugin, "netlink", sizeof(vl.plugin));
 206   sstrncpy(vl.plugin_instance, dev, sizeof(vl.plugin_instance));
 207   sstrncpy(vl.type, type, sizeof(vl.type));
 208
 209   if (type_instance != NULL)
 210     sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
 211
 212   plugin_dispatch_values(&vl);
 213 } /* void submit_two */
 214
 215 static int update_iflist(struct ifinfomsg *msg, const char *dev) {
 216   /* Update the `iflist'. It's used to know which interfaces exist and query
 217    * them later for qdiscs and classes. */
 218   if ((msg->ifi_index >= 0) && ((size_t)msg->ifi_index >= iflist_len)) {
 219     char **temp;
 220
 221     temp = realloc(iflist, (msg->ifi_index + 1) * sizeof(char *));
 222     if (temp == NULL) {
 223       ERROR("netlink plugin: update_iflist: realloc failed.");
 224       return -1;
 225     }
 226
 227     memset(temp + iflist_len, '\0',
 228            (msg->ifi_index + 1 - iflist_len) * sizeof(char *));
 229     iflist = temp;
 230     iflist_len = msg->ifi_index + 1;
 231   }
 232   if ((iflist[msg->ifi_index] == NULL) ||
 233       (strcmp(iflist[msg->ifi_index], dev) != 0)) {
 234     sfree(iflist[msg->ifi_index]);
 235     iflist[msg->ifi_index] = strdup(dev);
 236   }
 237
 238   return 0;
 239 } /* int update_iflist */
 240
 241 static void check_ignorelist_and_submit(const char *dev,
 242                                         struct ir_link_stats_storage_s *stats) {
 243
 244   if (check_ignorelist(dev, "interface", NULL) == 0) {
 245     submit_two(dev, "if_octets", NULL, stats->rx_bytes, stats->tx_bytes);
 246     submit_two(dev, "if_packets", NULL, stats->rx_packets, stats->tx_packets);
 247     submit_two(dev, "if_errors", NULL, stats->rx_errors, stats->tx_errors);
 248   } else {
 249     DEBUG("netlink plugin: Ignoring %s/interface.", dev);
 250   }
 251
 252   if (check_ignorelist(dev, "if_detail", NULL) == 0) {
 253     submit_two(dev, "if_dropped", NULL, stats->rx_dropped, stats->tx_dropped);
 254     submit_one(dev, "if_multicast", NULL, stats->multicast);
 255     submit_one(dev, "if_collisions", NULL, stats->collisions);
 256
 257     submit_one(dev, "if_rx_errors", "length", stats->rx_length_errors);
 258     submit_one(dev, "if_rx_errors", "over", stats->rx_over_errors);
 259     submit_one(dev, "if_rx_errors", "crc", stats->rx_crc_errors);
 260     submit_one(dev, "if_rx_errors", "frame", stats->rx_frame_errors);
 261     submit_one(dev, "if_rx_errors", "fifo", stats->rx_fifo_errors);
 262     submit_one(dev, "if_rx_errors", "missed", stats->rx_missed_errors);
 263
 264     submit_one(dev, "if_tx_errors", "aborted", stats->tx_aborted_errors);
 265     submit_one(dev, "if_tx_errors", "carrier", stats->tx_carrier_errors);
 266     submit_one(dev, "if_tx_errors", "fifo", stats->tx_fifo_errors);
 267     submit_one(dev, "if_tx_errors", "heartbeat", stats->tx_heartbeat_errors);
 268     submit_one(dev, "if_tx_errors", "window", stats->tx_window_errors);
 269   } else {
 270     DEBUG("netlink plugin: Ignoring %s/if_detail.", dev);
 271   }
 272
 273 } /* void check_ignorelist_and_submit */
 274
 275 #define COPY_RTNL_LINK_VALUE(dst_stats, src_stats, value_name)                 \
 276   (dst_stats)->value_name = (src_stats)->value_name
 277
 278 #define COPY_RTNL_LINK_STATS(dst_stats, src_stats)                             \
 279   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_packets);                      \
 280   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_packets);                      \
 281   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_bytes);                        \
 282   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_bytes);                        \
 283   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_errors);                       \
 284   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_errors);                       \
 285   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_dropped);                      \
 286   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_dropped);                      \
 287   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, multicast);                       \
 288   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, collisions);                      \
 289   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_length_errors);                \
 290   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_over_errors);                  \
 291   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_crc_errors);                   \
 292   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_frame_errors);                 \
 293   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_fifo_errors);                  \
 294   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, rx_missed_errors);                \
 295   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_aborted_errors);               \
 296   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_carrier_errors);               \
 297   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_fifo_errors);                  \
 298   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_heartbeat_errors);             \
 299   COPY_RTNL_LINK_VALUE(dst_stats, src_stats, tx_window_errors)
 300
 301 #ifdef HAVE_RTNL_LINK_STATS64
 302 static void check_ignorelist_and_submit64(const char *dev,
 303                                           struct rtnl_link_stats64 *stats) {
 304   struct ir_link_stats_storage_s s;
 305
 306   COPY_RTNL_LINK_STATS(&s, stats);
 307
 308   check_ignorelist_and_submit(dev, &s);
 309 }
 310 #endif
 311
 312 static void check_ignorelist_and_submit32(const char *dev,
 313                                           struct rtnl_link_stats *stats) {
 314   struct ir_link_stats_storage_s s;
 315
 316   COPY_RTNL_LINK_STATS(&s, stats);
 317
 318   check_ignorelist_and_submit(dev, &s);
 319 }
 320
 321 static int link_filter_cb(const struct nlmsghdr *nlh,
 322                           void *args __attribute__((unused))) {
 323   struct ifinfomsg *ifm = mnl_nlmsg_get_payload(nlh);
 324   struct nlattr *attr;
 325   const char *dev = NULL;
 326   union ir_link_stats_u stats;
 327
 328   if (nlh->nlmsg_type != RTM_NEWLINK) {
 329     ERROR("netlink plugin: link_filter_cb: Don't know how to handle type %i.",
 330           nlh->nlmsg_type);
 331     return MNL_CB_ERROR;
 332   }
 333
 334   /* Scan attribute list for device name. */
 335   mnl_attr_for_each(attr, nlh, sizeof(*ifm)) {
 336     if (mnl_attr_get_type(attr) != IFLA_IFNAME)
 337       continue;
 338
 339     if (mnl_attr_validate(attr, MNL_TYPE_STRING) < 0) {
 340       ERROR("netlink plugin: link_filter_cb: IFLA_IFNAME mnl_attr_validate "
 341             "failed.");
 342       return MNL_CB_ERROR;
 343     }
 344
 345     dev = mnl_attr_get_str(attr);
 346     if (update_iflist(ifm, dev) < 0)
 347       return MNL_CB_ERROR;
 348     break;
 349   }
 350
 351   if (dev == NULL) {
 352     ERROR("netlink plugin: link_filter_cb: dev == NULL");
 353     return MNL_CB_ERROR;
 354   }
 355 #ifdef HAVE_RTNL_LINK_STATS64
 356   mnl_attr_for_each(attr, nlh, sizeof(*ifm)) {
 357     if (mnl_attr_get_type(attr) != IFLA_STATS64)
 358       continue;
 359
 360     if (mnl_attr_validate2(attr, MNL_TYPE_UNSPEC, sizeof(*stats.stats64)) < 0) {
 361       char errbuf[1024];
 362       ERROR("netlink plugin: link_filter_cb: IFLA_STATS64 mnl_attr_validate2 "
 363             "failed: %s",
 364             sstrerror(errno, errbuf, sizeof(errbuf)));
 365       return MNL_CB_ERROR;
 366     }
 367     stats.stats64 = mnl_attr_get_payload(attr);
 368
 369     check_ignorelist_and_submit64(dev, stats.stats64);
 370
 371     return MNL_CB_OK;
 372   }
 373 #endif
 374   mnl_attr_for_each(attr, nlh, sizeof(*ifm)) {
 375     if (mnl_attr_get_type(attr) != IFLA_STATS)
 376       continue;
 377
 378     if (mnl_attr_validate2(attr, MNL_TYPE_UNSPEC, sizeof(*stats.stats32)) < 0) {
 379       char errbuf[1024];
 380       ERROR("netlink plugin: link_filter_cb: IFLA_STATS mnl_attr_validate2 "
 381             "failed: %s",
 382             sstrerror(errno, errbuf, sizeof(errbuf)));
 383       return MNL_CB_ERROR;
 384     }
 385     stats.stats32 = mnl_attr_get_payload(attr);
 386
 387     check_ignorelist_and_submit32(dev, stats.stats32);
 388
 389     return MNL_CB_OK;
 390   }
 391
 392   DEBUG("netlink plugin: link_filter: No statistics for interface %s.", dev);
 393   return MNL_CB_OK;
 394
 395 } /* int link_filter_cb */
 396
 397 #if HAVE_TCA_STATS2
 398 static int qos_attr_cb(const struct nlattr *attr, void *data) {
 399   struct qos_stats *q_stats = (struct qos_stats *)data;
 400
 401   /* skip unsupported attribute in user-space */
 402   if (mnl_attr_type_valid(attr, TCA_STATS_MAX) < 0)
 403     return MNL_CB_OK;
 404
 405   if (mnl_attr_get_type(attr) == TCA_STATS_BASIC) {
 406     if (mnl_attr_validate2(attr, MNL_TYPE_UNSPEC, sizeof(*q_stats->bs)) < 0) {
 407       char errbuf[1024];
 408       ERROR("netlink plugin: qos_attr_cb: TCA_STATS_BASIC mnl_attr_validate2 "
 409             "failed: %s",
 410             sstrerror(errno, errbuf, sizeof(errbuf)));
 411       return MNL_CB_ERROR;
 412     }
 413     q_stats->bs = mnl_attr_get_payload(attr);
 414     return MNL_CB_OK;
 415   }
 416
 417   if (mnl_attr_get_type(attr) == TCA_STATS_QUEUE) {
 418     if (mnl_attr_validate2(attr, MNL_TYPE_UNSPEC, sizeof(*q_stats->qs)) < 0) {
 419       ERROR("netlink plugin: qos_attr_cb: TCA_STATS_QUEUE mnl_attr_validate2 "
 420             "failed.");
 421       return MNL_CB_ERROR;
 422     }
 423     q_stats->qs = mnl_attr_get_payload(attr);
 424     return MNL_CB_OK;
 425   }
 426
 427   return MNL_CB_OK;
 428 } /* qos_attr_cb */
 429 #endif
 430
 431 static int qos_filter_cb(const struct nlmsghdr *nlh, void *args) {
 432   struct tcmsg *tm = mnl_nlmsg_get_payload(nlh);
 433   struct nlattr *attr;
 434
 435   int wanted_ifindex = *((int *)args);
 436
 437   const char *dev;
 438   const char *kind = NULL;
 439
 440   /* char *type_instance; */
 441   const char *tc_type;
 442   char tc_inst[DATA_MAX_NAME_LEN];
 443
 444   _Bool stats_submitted = 0;
 445
 446   if (nlh->nlmsg_type == RTM_NEWQDISC)
 447     tc_type = "qdisc";
 448   else if (nlh->nlmsg_type == RTM_NEWTCLASS)
 449     tc_type = "class";
 450   else if (nlh->nlmsg_type == RTM_NEWTFILTER)
 451     tc_type = "filter";
 452   else {
 453     ERROR("netlink plugin: qos_filter_cb: Don't know how to handle type %i.",
 454           nlh->nlmsg_type);
 455     return MNL_CB_ERROR;
 456   }
 457
 458   if (tm->tcm_ifindex != wanted_ifindex) {
 459     DEBUG("netlink plugin: qos_filter_cb: Got %s for interface #%i, "
 460           "but expected #%i.",
 461           tc_type, tm->tcm_ifindex, wanted_ifindex);
 462     return MNL_CB_OK;
 463   }
 464
 465   if ((tm->tcm_ifindex >= 0) && ((size_t)tm->tcm_ifindex >= iflist_len)) {
 466     ERROR("netlink plugin: qos_filter_cb: tm->tcm_ifindex = %i "
 467           ">= iflist_len = %zu",
 468           tm->tcm_ifindex, iflist_len);
 469     return MNL_CB_ERROR;
 470   }
 471
 472   dev = iflist[tm->tcm_ifindex];
 473   if (dev == NULL) {
 474     ERROR("netlink plugin: qos_filter_cb: iflist[%i] == NULL", tm->tcm_ifindex);
 475     return MNL_CB_ERROR;
 476   }
 477
 478   mnl_attr_for_each(attr, nlh, sizeof(*tm)) {
 479     if (mnl_attr_get_type(attr) != TCA_KIND)
 480       continue;
 481
 482     if (mnl_attr_validate(attr, MNL_TYPE_STRING) < 0) {
 483       ERROR(
 484           "netlink plugin: qos_filter_cb: TCA_KIND mnl_attr_validate failed.");
 485       return MNL_CB_ERROR;
 486     }
 487
 488     kind = mnl_attr_get_str(attr);
 489     break;
 490   }
 491
 492   if (kind == NULL) {
 493     ERROR("netlink plugin: qos_filter_cb: kind == NULL");
 494     return -1;
 495   }
 496
 497   { /* The ID */
 498     uint32_t numberic_id;
 499
 500     numberic_id = tm->tcm_handle;
 501     if (strcmp(tc_type, "filter") == 0)
 502       numberic_id = tm->tcm_parent;
 503
 504     snprintf(tc_inst, sizeof(tc_inst), "%s-%x:%x", kind, numberic_id >> 16,
 505              numberic_id & 0x0000FFFF);
 506   }
 507
 508   DEBUG("netlink plugin: qos_filter_cb: got %s for %s (%i).", tc_type, dev,
 509         tm->tcm_ifindex);
 510
 511   if (check_ignorelist(dev, tc_type, tc_inst))
 512     return MNL_CB_OK;
 513
 514 #if HAVE_TCA_STATS2
 515   mnl_attr_for_each(attr, nlh, sizeof(*tm)) {
 516     struct qos_stats q_stats;
 517
 518     memset(&q_stats, 0x0, sizeof(q_stats));
 519
 520     if (mnl_attr_get_type(attr) != TCA_STATS2)
 521       continue;
 522
 523     if (mnl_attr_validate(attr, MNL_TYPE_NESTED) < 0) {
 524       ERROR("netlink plugin: qos_filter_cb: TCA_STATS2 mnl_attr_validate "
 525             "failed.");
 526       return MNL_CB_ERROR;
 527     }
 528
 529     mnl_attr_parse_nested(attr, qos_attr_cb, &q_stats);
 530
 531     if (q_stats.bs != NULL || q_stats.qs != NULL) {
 532       char type_instance[DATA_MAX_NAME_LEN];
 533
 534       stats_submitted = 1;
 535
 536       snprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type, tc_inst);
 537
 538       if (q_stats.bs != NULL) {
 539         submit_one(dev, "ipt_bytes", type_instance, q_stats.bs->bytes);
 540         submit_one(dev, "ipt_packets", type_instance, q_stats.bs->packets);
 541       }
 542       if (q_stats.qs != NULL) {
 543         submit_one(dev, "if_tx_dropped", type_instance, q_stats.qs->drops);
 544       }
 545     }
 546
 547     break;
 548   }
 549 #endif /* TCA_STATS2 */
 550
 551 #if HAVE_TCA_STATS
 552   mnl_attr_for_each(attr, nlh, sizeof(*tm)) {
 553     struct tc_stats *ts = NULL;
 554
 555     if (mnl_attr_get_type(attr) != TCA_STATS)
 556       continue;
 557
 558     if (mnl_attr_validate2(attr, MNL_TYPE_UNSPEC, sizeof(*ts)) < 0) {
 559       char errbuf[1024];
 560       ERROR("netlink plugin: qos_filter_cb: TCA_STATS mnl_attr_validate2 "
 561             "failed: %s",
 562             sstrerror(errno, errbuf, sizeof(errbuf)));
 563       return MNL_CB_ERROR;
 564     }
 565     ts = mnl_attr_get_payload(attr);
 566
 567     if (!stats_submitted && ts != NULL) {
 568       char type_instance[DATA_MAX_NAME_LEN];
 569
 570       snprintf(type_instance, sizeof(type_instance), "%s-%s", tc_type, tc_inst);
 571
 572       submit_one(dev, "ipt_bytes", type_instance, ts->bytes);
 573       submit_one(dev, "ipt_packets", type_instance, ts->packets);
 574     }
 575
 576     break;
 577   }
 578
 579 #endif /* TCA_STATS */
 580
 581 #if !(HAVE_TCA_STATS && HAVE_TCA_STATS2)
 582   DEBUG("netlink plugin: qos_filter_cb: Have neither TCA_STATS2 nor "
 583         "TCA_STATS.");
 584 #endif
 585
 586   return MNL_CB_OK;
 587 } /* int qos_filter_cb */
 588
 589 static int ir_config(const char *key, const char *value) {
 590   char *new_val;
 591   char *fields[8];
 592   int fields_num;
 593   int status = 1;
 594
 595   new_val = strdup(value);
 596   if (new_val == NULL)
 597     return -1;
 598
 599   fields_num = strsplit(new_val, fields, STATIC_ARRAY_SIZE(fields));
 600   if ((fields_num < 1) || (fields_num > 8)) {
 601     sfree(new_val);
 602     return -1;
 603   }
 604
 605   if ((strcasecmp(key, "Interface") == 0) ||
 606       (strcasecmp(key, "VerboseInterface") == 0)) {
 607     if (fields_num != 1) {
 608       ERROR("netlink plugin: Invalid number of fields for option "
 609             "`%s'. Got %i, expected 1.",
 610             key, fields_num);
 611       status = -1;
 612     } else {
 613       add_ignorelist(fields[0], "interface", NULL);
 614       if (strcasecmp(key, "VerboseInterface") == 0)
 615         add_ignorelist(fields[0], "if_detail", NULL);
 616       status = 0;
 617     }
 618   } else if ((strcasecmp(key, "QDisc") == 0) ||
 619              (strcasecmp(key, "Class") == 0) ||
 620              (strcasecmp(key, "Filter") == 0)) {
 621     if ((fields_num < 1) || (fields_num > 2)) {
 622       ERROR("netlink plugin: Invalid number of fields for option "
 623             "`%s'. Got %i, expected 1 or 2.",
 624             key, fields_num);
 625       return -1;
 626     } else {
 627       add_ignorelist(fields[0], key, (fields_num == 2) ? fields[1] : NULL);
 628       status = 0;
 629     }
 630   } else if (strcasecmp(key, "IgnoreSelected") == 0) {
 631     if (fields_num != 1) {
 632       ERROR("netlink plugin: Invalid number of fields for option "
 633             "`IgnoreSelected'. Got %i, expected 1.",
 634             fields_num);
 635       status = -1;
 636     } else {
 637       if (IS_TRUE(fields[0]))
 638         ir_ignorelist_invert = 0;
 639       else
 640         ir_ignorelist_invert = 1;
 641       status = 0;
 642     }
 643   }
 644
 645   sfree(new_val);
 646
 647   return status;
 648 } /* int ir_config */
 649
 650 static int ir_init(void) {
 651   nl = mnl_socket_open(NETLINK_ROUTE);
 652   if (nl == NULL) {
 653     ERROR("netlink plugin: ir_init: mnl_socket_open failed.");
 654     return -1;
 655   }
 656
 657   if (mnl_socket_bind(nl, 0, MNL_SOCKET_AUTOPID) < 0) {
 658     ERROR("netlink plugin: ir_init: mnl_socket_bind failed.");
 659     return -1;
 660   }
 661
 662   return 0;
 663 } /* int ir_init */
 664
 665 static int ir_read(void) {
 666   char buf[MNL_SOCKET_BUFFER_SIZE];
 667   struct nlmsghdr *nlh;
 668   struct rtgenmsg *rt;
 669   int ret;
 670   unsigned int seq, portid;
 671
 672   static const int type_id[] = {RTM_GETQDISC, RTM_GETTCLASS, RTM_GETTFILTER};
 673   static const char *type_name[] = {"qdisc", "class", "filter"};
 674
 675   portid = mnl_socket_get_portid(nl);
 676
 677   nlh = mnl_nlmsg_put_header(buf);
 678   nlh->nlmsg_type = RTM_GETLINK;
 679   nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
 680   nlh->nlmsg_seq = seq = time(NULL);
 681   rt = mnl_nlmsg_put_extra_header(nlh, sizeof(*rt));
 682   rt->rtgen_family = AF_PACKET;
 683
 684   if (mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) {
 685     ERROR("netlink plugin: ir_read: rtnl_wilddump_request failed.");
 686     return -1;
 687   }
 688
 689   ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));
 690   while (ret > 0) {
 691     ret = mnl_cb_run(buf, ret, seq, portid, link_filter_cb, NULL);
 692     if (ret <= MNL_CB_STOP)
 693       break;
 694     ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));
 695   }
 696   if (ret < 0) {
 697     char errbuf[1024];
 698     ERROR("netlink plugin: ir_read: mnl_socket_recvfrom failed: %s",
 699           sstrerror(errno, errbuf, sizeof(errbuf)));
 700     return (-1);
 701   }
 702
 703   /* `link_filter_cb' will update `iflist' which is used here to iterate
 704    * over all interfaces. */
 705   for (size_t ifindex = 1; ifindex < iflist_len; ifindex++) {
 706     struct tcmsg *tm;
 707
 708     if (iflist[ifindex] == NULL)
 709       continue;
 710
 711     for (size_t type_index = 0; type_index < STATIC_ARRAY_SIZE(type_id);
 712          type_index++) {
 713       if (check_ignorelist(iflist[ifindex], type_name[type_index], NULL)) {
 714         DEBUG("netlink plugin: ir_read: check_ignorelist (%s, %s, (nil)) "
 715               "== TRUE",
 716               iflist[ifindex], type_name[type_index]);
 717         continue;
 718       }
 719
 720       DEBUG("netlink plugin: ir_read: querying %s from %s (%zu).",
 721             type_name[type_index], iflist[ifindex], ifindex);
 722
 723       nlh = mnl_nlmsg_put_header(buf);
 724       nlh->nlmsg_type = type_id[type_index];
 725       nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
 726       nlh->nlmsg_seq = seq = time(NULL);
 727       tm = mnl_nlmsg_put_extra_header(nlh, sizeof(*tm));
 728       tm->tcm_family = AF_PACKET;
 729       tm->tcm_ifindex = ifindex;
 730
 731       if (mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) {
 732         ERROR("netlink plugin: ir_read: mnl_socket_sendto failed.");
 733         continue;
 734       }
 735
 736       ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));
 737       while (ret > 0) {
 738         ret = mnl_cb_run(buf, ret, seq, portid, qos_filter_cb, &ifindex);
 739         if (ret <= MNL_CB_STOP)
 740           break;
 741         ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));
 742       }
 743       if (ret < 0) {
 744         char errbuf[1024];
 745         ERROR("netlink plugin: ir_read: mnl_socket_recvfrom failed: %s",
 746               sstrerror(errno, errbuf, sizeof(errbuf)));
 747         continue;
 748       }
 749     } /* for (type_index) */
 750   }   /* for (if_index) */
 751
 752   return 0;
 753 } /* int ir_read */
 754
 755 static int ir_shutdown(void) {
 756   if (nl) {
 757     mnl_socket_close(nl);
 758     nl = NULL;
 759   }
 760
 761   return 0;
 762 } /* int ir_shutdown */
 763
 764 void module_register(void) {
 765   plugin_register_config("netlink", ir_config, config_keys, config_keys_num);
 766   plugin_register_init("netlink", ir_init);
 767   plugin_register_read("netlink", ir_read);
 768   plugin_register_shutdown("netlink", ir_shutdown);
 769 } /* void module_register */