Merge branch 'collectd-5.7'
[collectd.git] / 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/libip6tc.h>
33 #include <libiptc/libiptc.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[] = {"Chain", "Chain6"};
67 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
68 enum protocol_version_e { IPV4, IPV6 };
69 typedef enum protocol_version_e protocol_version_t;
70
71 /*
72  * Each table/chain combo that will be queried goes into this list
73  */
74 #ifndef XT_TABLE_MAXNAMELEN
75 #define XT_TABLE_MAXNAMELEN 32
76 #endif
77 typedef struct {
78   protocol_version_t ip_version;
79   char table[XT_TABLE_MAXNAMELEN];
80   char chain[XT_TABLE_MAXNAMELEN];
81   union {
82     int num;
83     char *comment;
84   } rule;
85   enum { RTYPE_NUM, RTYPE_COMMENT, RTYPE_COMMENT_ALL } rule_type;
86   char name[64];
87 } ip_chain_t;
88
89 static ip_chain_t **chain_list = NULL;
90 static int chain_num = 0;
91
92 static int iptables_config(const char *key, const char *value) {
93   /* int ip_value; */
94   protocol_version_t ip_version = 0;
95
96   if (strcasecmp(key, "Chain") == 0)
97     ip_version = IPV4;
98   else if (strcasecmp(key, "Chain6") == 0)
99     ip_version = IPV6;
100   else
101     return (1);
102
103   ip_chain_t temp = {0};
104   ip_chain_t * final, **list;
105   char *table;
106   int table_len;
107   char *chain;
108   int chain_len;
109
110   char *value_copy;
111   char *fields[4];
112   int fields_num;
113
114   value_copy = strdup(value);
115   if (value_copy == NULL) {
116     char errbuf[1024];
117     ERROR("strdup failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
118     return (1);
119   }
120
121   /*
122    *  Time to fill the temp element
123    *  Examine value string, it should look like:
124    *  Chain[6] <table> <chain> [<comment|num> [name]]
125    */
126
127   /* set IPv4 or IPv6 */
128   temp.ip_version = ip_version;
129
130   /* Chain <table> <chain> [<comment|num> [name]] */
131   fields_num = strsplit(value_copy, fields, 4);
132   if (fields_num < 2) {
133     free(value_copy);
134     return (1);
135   }
136
137   table = fields[0];
138   chain = fields[1];
139
140   table_len = strlen(table) + 1;
141   if ((unsigned int)table_len > sizeof(temp.table)) {
142     ERROR("Table `%s' too long.", table);
143     free(value_copy);
144     return (1);
145   }
146   sstrncpy(temp.table, table, table_len);
147
148   chain_len = strlen(chain) + 1;
149   if ((unsigned int)chain_len > sizeof(temp.chain)) {
150     ERROR("Chain `%s' too long.", chain);
151     free(value_copy);
152     return (1);
153   }
154   sstrncpy(temp.chain, chain, chain_len);
155
156   if (fields_num >= 3) {
157     char *comment = fields[2];
158     int rule = atoi(comment);
159
160     if (rule) {
161       temp.rule.num = rule;
162       temp.rule_type = RTYPE_NUM;
163     } else {
164       temp.rule.comment = strdup(comment);
165       if (temp.rule.comment == NULL) {
166         free(value_copy);
167         return (1);
168       }
169       temp.rule_type = RTYPE_COMMENT;
170     }
171   } else {
172     temp.rule_type = RTYPE_COMMENT_ALL;
173   }
174
175   if (fields_num >= 4)
176     sstrncpy(temp.name, fields[3], sizeof(temp.name));
177
178   free(value_copy);
179   value_copy = NULL;
180   table = NULL;
181   chain = NULL;
182
183   list = realloc(chain_list, (chain_num + 1) * sizeof(ip_chain_t *));
184   if (list == NULL) {
185     char errbuf[1024];
186     ERROR("realloc failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
187     sfree(temp.rule.comment);
188     return (1);
189   }
190
191   chain_list = list;
192   final = malloc(sizeof(* final));
193   if (final == NULL) {
194     char errbuf[1024];
195     ERROR("malloc failed: %s", sstrerror(errno, errbuf, sizeof(errbuf)));
196     sfree(temp.rule.comment);
197     return (1);
198   }
199   memcpy(final, &temp, sizeof(temp));
200   chain_list[chain_num] = final;
201   chain_num++;
202
203   DEBUG("Chain #%i: table = %s; chain = %s;", chain_num, final->table,
204         final->chain);
205
206   return (0);
207 } /* int iptables_config */
208
209 static int submit6_match(const struct ip6t_entry_match *match,
210                          const struct ip6t_entry *entry,
211                          const ip_chain_t *chain, int rule_num) {
212   int status;
213   value_list_t vl = VALUE_LIST_INIT;
214
215   /* Select the rules to collect */
216   if (chain->rule_type == RTYPE_NUM) {
217     if (chain->rule.num != rule_num)
218       return (0);
219   } else {
220     if (strcmp(match->u.user.name, "comment") != 0)
221       return (0);
222     if ((chain->rule_type == RTYPE_COMMENT) &&
223         (strcmp(chain->rule.comment, (char *)match->data) != 0))
224       return (0);
225   }
226
227   sstrncpy(vl.plugin, "ip6tables", sizeof(vl.plugin));
228
229   status = ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
230                      chain->table, chain->chain);
231   if ((status < 1) || ((unsigned int)status >= sizeof(vl.plugin_instance)))
232     return (0);
233
234   if (chain->name[0] != '\0') {
235     sstrncpy(vl.type_instance, chain->name, sizeof(vl.type_instance));
236   } else {
237     if (chain->rule_type == RTYPE_NUM)
238       ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
239                 chain->rule.num);
240     else
241       sstrncpy(vl.type_instance, (char *)match->data, sizeof(vl.type_instance));
242   }
243
244   sstrncpy(vl.type, "ipt_bytes", sizeof(vl.type));
245   vl.values = &(value_t){.derive = (derive_t)entry->counters.bcnt};
246   vl.values_len = 1;
247   plugin_dispatch_values(&vl);
248
249   sstrncpy(vl.type, "ipt_packets", sizeof(vl.type));
250   vl.values = &(value_t){.derive = (derive_t)entry->counters.pcnt};
251   plugin_dispatch_values(&vl);
252
253   return (0);
254 } /* int submit6_match */
255
256 /* This needs to return `int' for IPT_MATCH_ITERATE to work. */
257 static int submit_match(const struct ipt_entry_match *match,
258                         const struct ipt_entry *entry, const ip_chain_t *chain,
259                         int rule_num) {
260   int status;
261   value_list_t vl = VALUE_LIST_INIT;
262
263   /* Select the rules to collect */
264   if (chain->rule_type == RTYPE_NUM) {
265     if (chain->rule.num != rule_num)
266       return (0);
267   } else {
268     if (strcmp(match->u.user.name, "comment") != 0)
269       return (0);
270     if ((chain->rule_type == RTYPE_COMMENT) &&
271         (strcmp(chain->rule.comment, (char *)match->data) != 0))
272       return (0);
273   }
274
275   sstrncpy(vl.plugin, "iptables", sizeof(vl.plugin));
276
277   status = ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s-%s",
278                      chain->table, chain->chain);
279   if ((status < 1) || ((unsigned int)status >= sizeof(vl.plugin_instance)))
280     return (0);
281
282   if (chain->name[0] != '\0') {
283     sstrncpy(vl.type_instance, chain->name, sizeof(vl.type_instance));
284   } else {
285     if (chain->rule_type == RTYPE_NUM)
286       ssnprintf(vl.type_instance, sizeof(vl.type_instance), "%i",
287                 chain->rule.num);
288     else
289       sstrncpy(vl.type_instance, (char *)match->data, sizeof(vl.type_instance));
290   }
291
292   sstrncpy(vl.type, "ipt_bytes", sizeof(vl.type));
293   vl.values = &(value_t){.derive = (derive_t)entry->counters.bcnt};
294   vl.values_len = 1;
295   plugin_dispatch_values(&vl);
296
297   sstrncpy(vl.type, "ipt_packets", sizeof(vl.type));
298   vl.values = &(value_t){.derive = (derive_t)entry->counters.pcnt};
299   plugin_dispatch_values(&vl);
300
301   return (0);
302 } /* int submit_match */
303
304 /* ipv6 submit_chain */
305 static void submit6_chain(ip6tc_handle_t *handle, ip_chain_t *chain) {
306   const struct ip6t_entry *entry;
307   int rule_num;
308
309   /* Find first rule for chain and use the iterate macro */
310   entry = ip6tc_first_rule(chain->chain, handle);
311   if (entry == NULL) {
312     DEBUG("ip6tc_first_rule failed: %s", ip6tc_strerror(errno));
313     return;
314   }
315
316   rule_num = 1;
317   while (entry) {
318     if (chain->rule_type == RTYPE_NUM) {
319       submit6_match(NULL, entry, chain, rule_num);
320     } else {
321       IP6T_MATCH_ITERATE(entry, submit6_match, entry, chain, rule_num);
322     }
323
324     entry = ip6tc_next_rule(entry, handle);
325     rule_num++;
326   } /* while (entry) */
327 }
328
329 /* ipv4 submit_chain */
330 static void submit_chain(iptc_handle_t *handle, ip_chain_t *chain) {
331   const struct ipt_entry *entry;
332   int rule_num;
333
334   /* Find first rule for chain and use the iterate macro */
335   entry = iptc_first_rule(chain->chain, handle);
336   if (entry == NULL) {
337     DEBUG("iptc_first_rule failed: %s", iptc_strerror(errno));
338     return;
339   }
340
341   rule_num = 1;
342   while (entry) {
343     if (chain->rule_type == RTYPE_NUM) {
344       submit_match(NULL, entry, chain, rule_num);
345     } else {
346       IPT_MATCH_ITERATE(entry, submit_match, entry, chain, rule_num);
347     }
348
349     entry = iptc_next_rule(entry, handle);
350     rule_num++;
351   } /* while (entry) */
352 }
353
354 static int iptables_read(void) {
355   int num_failures = 0;
356   ip_chain_t *chain;
357
358   /* Init the iptc handle structure and query the correct table */
359   for (int i = 0; i < chain_num; i++) {
360     chain = chain_list[i];
361
362     if (!chain) {
363       DEBUG("iptables plugin: chain == NULL");
364       continue;
365     }
366
367     if (chain->ip_version == IPV4) {
368 #ifdef HAVE_IPTC_HANDLE_T
369       iptc_handle_t _handle;
370       iptc_handle_t *handle = &_handle;
371
372       *handle = iptc_init(chain->table);
373 #else
374       iptc_handle_t *handle;
375       handle = iptc_init(chain->table);
376 #endif
377
378       if (!handle) {
379         ERROR("iptables plugin: iptc_init (%s) failed: %s", chain->table,
380               iptc_strerror(errno));
381         num_failures++;
382         continue;
383       }
384
385       submit_chain(handle, chain);
386       iptc_free(handle);
387     } else if (chain->ip_version == IPV6) {
388 #ifdef HAVE_IP6TC_HANDLE_T
389       ip6tc_handle_t _handle;
390       ip6tc_handle_t *handle = &_handle;
391
392       *handle = ip6tc_init(chain->table);
393 #else
394       ip6tc_handle_t *handle;
395       handle = ip6tc_init(chain->table);
396 #endif
397       if (!handle) {
398         ERROR("iptables plugin: ip6tc_init (%s) failed: %s", chain->table,
399               ip6tc_strerror(errno));
400         num_failures++;
401         continue;
402       }
403
404       submit6_chain(handle, chain);
405       ip6tc_free(handle);
406     } else
407       num_failures++;
408   } /* for (i = 0 .. chain_num) */
409
410   return ((num_failures < chain_num) ? 0 : -1);
411 } /* int iptables_read */
412
413 static int iptables_shutdown(void) {
414   for (int i = 0; i < chain_num; i++) {
415     if ((chain_list[i] != NULL) && (chain_list[i]->rule_type == RTYPE_COMMENT))
416       sfree(chain_list[i]->rule.comment);
417     sfree(chain_list[i]);
418   }
419   sfree(chain_list);
420
421   return (0);
422 } /* int iptables_shutdown */
423
424 static int iptables_init(void) {
425 #if defined(HAVE_SYS_CAPABILITY_H) && defined(CAP_NET_ADMIN)
426   if (check_capability(CAP_NET_ADMIN) != 0) {
427     if (getuid() == 0)
428       WARNING("iptables plugin: Running collectd as root, but the "
429               "CAP_NET_ADMIN capability is missing. The plugin's read "
430               "function will probably fail. Is your init system dropping "
431               "capabilities?");
432     else
433       WARNING("iptables plugin: collectd doesn't have the CAP_NET_ADMIN "
434               "capability. If you don't want to run collectd as root, try "
435               "running \"setcap cap_net_admin=ep\" on the collectd binary.");
436   }
437 #endif
438   return (0);
439 } /* int iptables_init */
440
441 void module_register(void) {
442   plugin_register_config("iptables", iptables_config, config_keys,
443                          config_keys_num);
444   plugin_register_init("iptables", iptables_init);
445   plugin_register_read("iptables", iptables_read);
446   plugin_register_shutdown("iptables", iptables_shutdown);
447 } /* void module_register */