src/iptables.c

   1 /**
   2  * collectd - src/iptables.c
   3  * Copyright (C) 2007       Sjoerd van der Berg
   4  * Copyright (C) 2007-2010  Florian octo Forster
   5  * Copyright (C) 2009       Marco Chiappero
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2 of the License, or (at your
  10  * option) any later version.
  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  *  Sjoerd van der Berg <harekiet at users.sourceforge.net>
  23  *  Florian Forster <octo at collectd.org>
  24  *  Marco Chiappero <marco at absence.it>
  25  **/
  26
  27 #include "collectd.h"
  28
  29 #include "common.h"
  30 #include "plugin.h"
  31
  32 #include <libiptc/libiptc.h>
  33 #include <libiptc/libip6tc.h>
  34
  35 #ifdef HAVE_SYS_CAPABILITY_H
  36 # include <sys/capability.h>
  37 #endif
  38
  39 /*
  40  * iptc_handle_t was available before libiptc was officially available as a
  41  * shared library. Note, that when the shared lib was introduced, the API and
  42  * ABI have changed slightly:
  43  * 'iptc_handle_t' used to be 'struct iptc_handle *' and most functions used
  44  * 'iptc_handle_t *' as an argument. Now, most functions use 'struct
  45  * iptc_handle *' (thus removing one level of pointer indirection).
  46  *
  47  * HAVE_IPTC_HANDLE_T is used to determine which API ought to be used. While
  48  * this is somewhat hacky, I didn't find better way to solve that :-/
  49  * -tokkee
  50  */
  51 #ifndef HAVE_IPTC_HANDLE_T
  52 typedef struct iptc_handle iptc_handle_t;
  53 #endif
  54 #ifndef HAVE_IP6TC_HANDLE_T
  55 typedef struct ip6tc_handle ip6tc_handle_t;
  56 #endif
  57
  58 /*
  59  * (Module-)Global variables
  60  */
  61
  62 /*
  63  * Config format should be `Chain table chainname',
  64  * e. g. `Chain mangle incoming'
  65  */
  66 static const char *config_keys[] =
  67 {
  68     "Chain",
  69     "Chain6"
  70 };
  71 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
  72 enum protocol_version_e
  73 {
  74     IPV4,
  75     IPV6
  76 };
  77 typedef enum protocol_version_e protocol_version_t;
  78
  79 /*
  80  * Each table/chain combo that will be queried goes into this list
  81  */
  82 #ifndef XT_TABLE_MAXNAMELEN
  83 # define XT_TABLE_MAXNAMELEN 32
  84 #endif
  85 typedef struct {
  86     protocol_version_t ip_version;
  87     char table[XT_TABLE_MAXNAMELEN];
  88     char chain[XT_TABLE_MAXNAMELEN];
  89     union
  90     {
  91         int   num;
  92         char *comment;
  93     } rule;
  94     enum
  95     {
  96         RTYPE_NUM,
  97         RTYPE_COMMENT,
  98         RTYPE_COMMENT_ALL
  99     } rule_type;
 100     char name[64];
 101 } ip_chain_t;
 102
 103 static ip_chain_t **chain_list = NULL;
 104 static int chain_num = 0;
 105
 106 static int iptables_config (const char *key, const char *value)
 107 {
 108     /* int ip_value; */
 109     protocol_version_t ip_version = 0;
 110
 111     if (strcasecmp (key, "Chain") == 0)
 112         ip_version = IPV4;
 113     else if (strcasecmp (key, "Chain6") == 0)
 114         ip_version = IPV6;
 115     else
 116         return (1);
 117
 118     ip_chain_t  temp = { 0 };
 119     ip_chain_t *final, **list;
 120     char *table;
 121     int   table_len;
 122     char *chain;
 123     int   chain_len;
 124
 125     char *value_copy;
 126     char *fields[4];
 127     int   fields_num;
 128
 129     value_copy = strdup (value);
 130     if (value_copy == NULL)
 131     {
 132         char errbuf[1024];
 133         ERROR ("strdup failed: %s",
 134                 sstrerror (errno, errbuf, sizeof (errbuf)));
 135         return (1);
 136     }
 137
 138     /*
 139      *  Time to fill the temp element
 140      *  Examine value string, it should look like:
 141      *  Chain[6] <table> <chain> [<comment|num> [name]]
 142      */
 143
 144     /* set IPv4 or IPv6 */
 145     temp.ip_version = ip_version;
 146
 147     /* Chain <table> <chain> [<comment|num> [name]] */
 148     fields_num = strsplit (value_copy, fields, 4);
 149     if (fields_num < 2)
 150     {
 151         free (value_copy);
 152         return (1);
 153     }
 154
 155     table = fields[0];
 156     chain = fields[1];
 157
 158     table_len = strlen (table) + 1;
 159     if ((unsigned int)table_len > sizeof(temp.table))
 160     {
 161         ERROR ("Table `%s' too long.", table);
 162         free (value_copy);
 163         return (1);
 164     }
 165     sstrncpy (temp.table, table, table_len);
 166
 167     chain_len = strlen (chain) + 1;
 168     if ((unsigned int)chain_len > sizeof(temp.chain))
 169     {
 170         ERROR ("Chain `%s' too long.", chain);
 171         free (value_copy);
 172         return (1);
 173     }
 174     sstrncpy (temp.chain, chain, chain_len);
 175
 176     if (fields_num >= 3)
 177     {
 178         char *comment = fields[2];
 179         int   rule = atoi (comment);
 180
 181         if (rule)
 182         {
 183             temp.rule.num = rule;
 184             temp.rule_type = RTYPE_NUM;
 185         }
 186         else
 187         {
 188             temp.rule.comment = strdup (comment);
 189             if (temp.rule.comment == NULL)
 190             {
 191                 free (value_copy);
 192                 return (1);
 193             }
 194             temp.rule_type = RTYPE_COMMENT;
 195         }
 196     }
 197     else
 198     {
 199         temp.rule_type = RTYPE_COMMENT_ALL;
 200     }
 201
 202     if (fields_num >= 4)
 203         sstrncpy (temp.name, fields[3], sizeof (temp.name));
 204
 205     free (value_copy);
 206     value_copy = NULL;
 207     table = NULL;
 208     chain = NULL;
 209
 210     list = realloc (chain_list, (chain_num + 1) * sizeof (ip_chain_t *));
 211     if (list == NULL)
 212     {
 213         char errbuf[1024];
 214         ERROR ("realloc failed: %s",
 215                 sstrerror (errno, errbuf, sizeof (errbuf)));
 216         sfree (temp.rule.comment);
 217         return (1);
 218     }
 219
 220     chain_list = list;
 221     final = malloc(sizeof (*final));
 222     if (final == NULL)
 223     {
 224         char errbuf[1024];
 225         ERROR ("malloc failed: %s",
 226                 sstrerror (errno, errbuf, sizeof (errbuf)));
 227         sfree (temp.rule.comment);
 228         return (1);
 229     }
 230     memcpy (final, &temp, sizeof (temp));
 231     chain_list[chain_num] = final;
 232     chain_num++;
 233
 234     DEBUG ("Chain #%i: table = %s; chain = %s;", chain_num, final->table, final->chain);
 235
 236     return (0);
 237 } /* int iptables_config */
 238
 239 static int submit6_match (const struct ip6t_entry_match *match,
 240                           const struct ip6t_entry *entry,
 241                           const ip_chain_t *chain,
 242                           int rule_num)
 243 {
 244     int status;
 245     value_t values[1];
 246     value_list_t vl = VALUE_LIST_INIT;
 247
 248     /* Select the rules to collect */
 249     if (chain->rule_type == RTYPE_NUM)
 250     {
 251         if (chain->rule.num != rule_num)
 252             return (0);
 253     }
 254     else
 255     {
 256         if (strcmp (match->u.user.name, "comment") != 0)
 257             return (0);
 258         if ((chain->rule_type == RTYPE_COMMENT)
 259              && (strcmp (chain->rule.comment, (char *) match->data) != 0))
 260             return (0);
 261     }
 262
 263     vl.values = values;
 264     vl.values_len = 1;
 265     sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 266     sstrncpy (vl.plugin, "ip6tables", sizeof (vl.plugin));
 267
 268     status = ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
 269                         "%s-%s", chain->table, chain->chain);
 270     if ((status < 1) || ((unsigned int)status >= sizeof (vl.plugin_instance)))
 271         return (0);
 272
 273     if (chain->name[0] != '\0')
 274     {
 275         sstrncpy (vl.type_instance, chain->name, sizeof (vl.type_instance));
 276     }
 277     else
 278     {
 279         if (chain->rule_type == RTYPE_NUM)
 280             ssnprintf (vl.type_instance, sizeof (vl.type_instance),
 281                        "%i", chain->rule.num);
 282         else
 283             sstrncpy (vl.type_instance, (char *) match->data,
 284                       sizeof (vl.type_instance));
 285     }
 286
 287     sstrncpy (vl.type, "ipt_bytes", sizeof (vl.type));
 288     values[0].derive = (derive_t) entry->counters.bcnt;
 289     plugin_dispatch_values (&vl);
 290
 291     sstrncpy (vl.type, "ipt_packets", sizeof (vl.type));
 292     values[0].derive = (derive_t) entry->counters.pcnt;
 293     plugin_dispatch_values (&vl);
 294
 295     return (0);
 296 } /* int submit_match */
 297
 298
 299 /* This needs to return `int' for IPT_MATCH_ITERATE to work. */
 300 static int submit_match (const struct ipt_entry_match *match,
 301                          const struct ipt_entry *entry,
 302                          const ip_chain_t *chain,
 303                          int rule_num)
 304 {
 305     int status;
 306     value_t values[1];
 307     value_list_t vl = VALUE_LIST_INIT;
 308
 309     /* Select the rules to collect */
 310     if (chain->rule_type == RTYPE_NUM)
 311     {
 312         if (chain->rule.num != rule_num)
 313             return (0);
 314     }
 315     else
 316     {
 317         if (strcmp (match->u.user.name, "comment") != 0)
 318             return (0);
 319         if ((chain->rule_type == RTYPE_COMMENT)
 320              && (strcmp (chain->rule.comment, (char *) match->data) != 0))
 321             return (0);
 322     }
 323
 324     vl.values = values;
 325     vl.values_len = 1;
 326     sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 327     sstrncpy (vl.plugin, "iptables", sizeof (vl.plugin));
 328
 329     status = ssnprintf (vl.plugin_instance, sizeof (vl.plugin_instance),
 330                         "%s-%s", chain->table, chain->chain);
 331     if ((status < 1) || ((unsigned int)status >= sizeof (vl.plugin_instance)))
 332         return (0);
 333
 334     if (chain->name[0] != '\0')
 335     {
 336         sstrncpy (vl.type_instance, chain->name, sizeof (vl.type_instance));
 337     }
 338     else
 339     {
 340         if (chain->rule_type == RTYPE_NUM)
 341             ssnprintf (vl.type_instance, sizeof (vl.type_instance),
 342                        "%i", chain->rule.num);
 343         else
 344             sstrncpy (vl.type_instance, (char *) match->data,
 345                       sizeof (vl.type_instance));
 346     }
 347
 348     sstrncpy (vl.type, "ipt_bytes", sizeof (vl.type));
 349     values[0].derive = (derive_t) entry->counters.bcnt;
 350     plugin_dispatch_values (&vl);
 351
 352     sstrncpy (vl.type, "ipt_packets", sizeof (vl.type));
 353     values[0].derive = (derive_t) entry->counters.pcnt;
 354     plugin_dispatch_values (&vl);
 355
 356     return (0);
 357 } /* int submit_match */
 358
 359
 360 /* ipv6 submit_chain */
 361 static void submit6_chain (ip6tc_handle_t *handle, ip_chain_t *chain)
 362 {
 363     const struct ip6t_entry *entry;
 364     int rule_num;
 365
 366     /* Find first rule for chain and use the iterate macro */
 367     entry = ip6tc_first_rule( chain->chain, handle );
 368     if (entry == NULL)
 369     {
 370         DEBUG ("ip6tc_first_rule failed: %s", ip6tc_strerror (errno));
 371         return;
 372     }
 373
 374     rule_num = 1;
 375     while (entry)
 376     {
 377         if (chain->rule_type == RTYPE_NUM)
 378         {
 379             submit6_match (NULL, entry, chain, rule_num);
 380         }
 381         else
 382         {
 383             IP6T_MATCH_ITERATE( entry, submit6_match, entry, chain, rule_num );
 384         }
 385
 386         entry = ip6tc_next_rule( entry, handle );
 387         rule_num++;
 388     } /* while (entry) */
 389 }
 390
 391
 392 /* ipv4 submit_chain */
 393 static void submit_chain (iptc_handle_t *handle, ip_chain_t *chain)
 394 {
 395     const struct ipt_entry *entry;
 396     int rule_num;
 397
 398     /* Find first rule for chain and use the iterate macro */
 399     entry = iptc_first_rule( chain->chain, handle );
 400     if (entry == NULL)
 401     {
 402         DEBUG ("iptc_first_rule failed: %s", iptc_strerror (errno));
 403         return;
 404     }
 405
 406     rule_num = 1;
 407     while (entry)
 408     {
 409         if (chain->rule_type == RTYPE_NUM)
 410         {
 411             submit_match (NULL, entry, chain, rule_num);
 412         }
 413         else
 414         {
 415             IPT_MATCH_ITERATE( entry, submit_match, entry, chain, rule_num );
 416         }
 417
 418         entry = iptc_next_rule( entry, handle );
 419         rule_num++;
 420     } /* while (entry) */
 421 }
 422
 423
 424 static int iptables_read (void)
 425 {
 426     int num_failures = 0;
 427     ip_chain_t *chain;
 428
 429     /* Init the iptc handle structure and query the correct table */
 430     for (int i = 0; i < chain_num; i++)
 431     {
 432         chain = chain_list[i];
 433
 434         if (!chain)
 435         {
 436             DEBUG ("iptables plugin: chain == NULL");
 437             continue;
 438         }
 439
 440         if ( chain->ip_version == IPV4 )
 441         {
 442 #ifdef HAVE_IPTC_HANDLE_T
 443             iptc_handle_t _handle;
 444             iptc_handle_t *handle = &_handle;
 445
 446             *handle = iptc_init (chain->table);
 447 #else
 448             iptc_handle_t *handle;
 449             handle = iptc_init (chain->table);
 450 #endif
 451
 452             if (!handle)
 453             {
 454                 ERROR ("iptables plugin: iptc_init (%s) failed: %s",
 455                         chain->table, iptc_strerror (errno));
 456                 num_failures++;
 457                 continue;
 458             }
 459
 460             submit_chain (handle, chain);
 461             iptc_free (handle);
 462         }
 463         else if ( chain->ip_version == IPV6 )
 464         {
 465 #ifdef HAVE_IP6TC_HANDLE_T
 466             ip6tc_handle_t _handle;
 467             ip6tc_handle_t *handle = &_handle;
 468
 469             *handle = ip6tc_init (chain->table);
 470 #else
 471             ip6tc_handle_t *handle;
 472             handle = ip6tc_init (chain->table);
 473 #endif
 474             if (!handle)
 475             {
 476                 ERROR ("iptables plugin: ip6tc_init (%s) failed: %s",
 477                         chain->table, ip6tc_strerror (errno));
 478                 num_failures++;
 479                 continue;
 480             }
 481
 482             submit6_chain (handle, chain);
 483             ip6tc_free (handle);
 484         }
 485         else
 486             num_failures++;
 487     } /* for (i = 0 .. chain_num) */
 488
 489     return ((num_failures < chain_num) ? 0 : -1);
 490 } /* int iptables_read */
 491
 492 static int iptables_shutdown (void)
 493 {
 494     for (int i = 0; i < chain_num; i++)
 495     {
 496         if ((chain_list[i] != NULL) && (chain_list[i]->rule_type == RTYPE_COMMENT))
 497             sfree (chain_list[i]->rule.comment);
 498         sfree (chain_list[i]);
 499     }
 500     sfree (chain_list);
 501
 502     return (0);
 503 } /* int iptables_shutdown */
 504
 505 static int iptables_init (void)
 506 {
 507 #if defined(HAVE_SYS_CAPABILITY_H) && defined(CAP_NET_ADMIN)
 508     if (check_capability (CAP_NET_ADMIN) != 0)
 509     {
 510         if (getuid () == 0)
 511             WARNING ("iptables plugin: Running collectd as root, but the "
 512                   "CAP_NET_ADMIN capability is missing. The plugin's read "
 513                   "function will probably fail. Is your init system dropping "
 514                   "capabilities?");
 515         else
 516             WARNING ("iptables plugin: collectd doesn't have the CAP_NET_ADMIN "
 517                   "capability. If you don't want to run collectd as root, try "
 518                   "running \"setcap cap_net_admin=ep\" on the collectd binary.");
 519     }
 520 #endif
 521     return (0);
 522 } /* int iptables_init */
 523
 524 void module_register (void)
 525 {
 526     plugin_register_config ("iptables", iptables_config,
 527                              config_keys, config_keys_num);
 528     plugin_register_init ("iptables", iptables_init);
 529     plugin_register_read ("iptables", iptables_read);
 530     plugin_register_shutdown ("iptables", iptables_shutdown);
 531 } /* void module_register */
 532