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