src/utils_ovs.c: Initialize pdb->sock to -1 earlier.
[collectd.git] / src / openvpn.c
1 /**
2  * collectd - src/openvpn.c
3  * Copyright (C) 2008       Doug MacEachern
4  * Copyright (C) 2009,2010  Florian octo Forster
5  * Copyright (C) 2009       Marco Chiappero
6  * Copyright (C) 2009       Fabian Schuh
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  *   Doug MacEachern <dougm at hyperic.com>
23  *   Florian octo Forster <octo at collectd.org>
24  *   Marco Chiappero <marco at absence.it>
25  *   Fabian Schuh <mail at xeroc.org>
26  *   Pavel Rochnyak <pavel2000 ngs.ru>
27  **/
28
29 #include "collectd.h"
30
31 #include "common.h"
32 #include "plugin.h"
33
34 /**
35  * There is two main kinds of OpenVPN status file:
36  * - for 'single' mode (point-to-point or client mode)
37  * - for 'multi' mode  (server with multiple clients)
38  *
39  * For 'multi' there is 3 versions of status file format:
40  * - version 1 - First version of status file: without line type tokens,
41  *   comma delimited for easy machine parsing. Currently used by default.
42  *   Added in openvpn-2.0-beta3.
43  * - version 2 - with line type tokens, with 'HEADER' line type, uses comma
44  *   as a delimiter.
45  *   Added in openvpn-2.0-beta15.
46  * - version 3 - The only difference from version 2 is delimiter: in version 3
47  *   tabs are used instead of commas. Set of fields is the same.
48  *   Added in openvpn-2.1_rc14.
49  *
50  * For versions 2/3 there may be different sets of fields in different
51  * OpenVPN versions.
52  *
53  * Versions 2.0, 2.1, 2.2:
54  * Common Name,Real Address,Virtual Address,
55  * Bytes Received,Bytes Sent,Connected Since,Connected Since (time_t)
56  *
57  * Version 2.3:
58  * Common Name,Real Address,Virtual Address,
59  * Bytes Received,Bytes Sent,Connected Since,Connected Since (time_t),Username
60  *
61  * Version 2.4:
62  * Common Name,Real Address,Virtual Address,Virtual IPv6 Address,
63  * Bytes Received,Bytes Sent,Connected Since,Connected Since (time_t),Username,
64  * Client ID,Peer ID
65  *
66  * Current Collectd code tries to handle changes in this field set,
67  * if they are backward-compatible.
68  **/
69
70 #define TITLE_SINGLE "OpenVPN STATISTICS\n"
71 #define TITLE_V1 "OpenVPN CLIENT LIST\n"
72 #define TITLE_V2 "TITLE"
73
74 #define V1HEADER                                                               \
75   "Common Name,Real Address,Bytes Received,Bytes Sent,Connected Since\n"
76
77 struct vpn_status_s {
78   char *file;
79   char *name;
80 };
81 typedef struct vpn_status_s vpn_status_t;
82
83 static _Bool new_naming_schema = 0;
84 static _Bool collect_compression = 1;
85 static _Bool collect_user_count = 0;
86 static _Bool collect_individual_users = 1;
87
88 static const char *config_keys[] = {
89     "StatusFile",           "Compression", /* old, deprecated name */
90     "ImprovedNamingSchema", "CollectCompression",
91     "CollectUserCount",     "CollectIndividualUsers"};
92 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
93
94 /* Helper function
95  * copy-n-pasted from common.c - changed delim to ",\t"  */
96 static int openvpn_strsplit(char *string, char **fields, size_t size) {
97   size_t i = 0;
98   char *ptr = string;
99   char *saveptr = NULL;
100
101   while ((fields[i] = strtok_r(ptr, ",\t", &saveptr)) != NULL) {
102     ptr = NULL;
103     i++;
104
105     if (i >= size)
106       break;
107   }
108
109   return i;
110 } /* int openvpn_strsplit */
111
112 static void openvpn_free(void *arg) {
113   vpn_status_t *st = arg;
114
115   sfree(st->file);
116   sfree(st);
117 } /* void openvpn_free */
118
119 /* dispatches number of users */
120 static void numusers_submit(const char *pinst, const char *tinst,
121                             gauge_t value) {
122   value_list_t vl = VALUE_LIST_INIT;
123
124   vl.values = &(value_t){.gauge = value};
125   vl.values_len = 1;
126   sstrncpy(vl.plugin, "openvpn", sizeof(vl.plugin));
127   sstrncpy(vl.type, "users", sizeof(vl.type));
128   if (pinst != NULL)
129     sstrncpy(vl.plugin_instance, pinst, sizeof(vl.plugin_instance));
130   if (tinst != NULL)
131     sstrncpy(vl.type_instance, tinst, sizeof(vl.type_instance));
132
133   plugin_dispatch_values(&vl);
134 } /* void numusers_submit */
135
136 /* dispatches stats about traffic (TCP or UDP) generated by the tunnel
137  * per single endpoint */
138 static void iostats_submit(const char *pinst, const char *tinst, derive_t rx,
139                            derive_t tx) {
140   value_list_t vl = VALUE_LIST_INIT;
141   value_t values[] = {
142       {.derive = rx}, {.derive = tx},
143   };
144
145   /* NOTE ON THE NEW NAMING SCHEMA:
146    *       using plugin_instance to identify each vpn config (and
147    *       status) file; using type_instance to identify the endpoint
148    *       host when in multimode, traffic or overhead when in single.
149    */
150
151   vl.values = values;
152   vl.values_len = STATIC_ARRAY_SIZE(values);
153   sstrncpy(vl.plugin, "openvpn", sizeof(vl.plugin));
154   if (pinst != NULL)
155     sstrncpy(vl.plugin_instance, pinst, sizeof(vl.plugin_instance));
156   sstrncpy(vl.type, "if_octets", sizeof(vl.type));
157   if (tinst != NULL)
158     sstrncpy(vl.type_instance, tinst, sizeof(vl.type_instance));
159
160   plugin_dispatch_values(&vl);
161 } /* void traffic_submit */
162
163 /* dispatches stats about data compression shown when in single mode */
164 static void compression_submit(const char *pinst, const char *tinst,
165                                derive_t uncompressed, derive_t compressed) {
166   value_list_t vl = VALUE_LIST_INIT;
167   value_t values[] = {
168       {.derive = uncompressed}, {.derive = compressed},
169   };
170
171   vl.values = values;
172   vl.values_len = STATIC_ARRAY_SIZE(values);
173   sstrncpy(vl.plugin, "openvpn", sizeof(vl.plugin));
174   if (pinst != NULL)
175     sstrncpy(vl.plugin_instance, pinst, sizeof(vl.plugin_instance));
176   sstrncpy(vl.type, "compression", sizeof(vl.type));
177   if (tinst != NULL)
178     sstrncpy(vl.type_instance, tinst, sizeof(vl.type_instance));
179
180   plugin_dispatch_values(&vl);
181 } /* void compression_submit */
182
183 static int single_read(const char *name, FILE *fh) {
184   char buffer[1024];
185   char *fields[4];
186   const int max_fields = STATIC_ARRAY_SIZE(fields);
187
188   derive_t link_rx = 0, link_tx = 0;
189   derive_t tun_rx = 0, tun_tx = 0;
190   derive_t pre_compress = 0, post_compress = 0;
191   derive_t pre_decompress = 0, post_decompress = 0;
192
193   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
194     int fields_num = openvpn_strsplit(buffer, fields, max_fields);
195
196     /* status file is generated by openvpn/sig.c:print_status()
197      * http://svn.openvpn.net/projects/openvpn/trunk/openvpn/sig.c
198      *
199      * The line we're expecting has 2 fields. We ignore all lines
200      *  with more or less fields.
201      */
202     if (fields_num != 2) {
203       continue;
204     }
205
206     if (strcmp(fields[0], "TUN/TAP read bytes") == 0) {
207       /* read from the system and sent over the tunnel */
208       tun_tx = atoll(fields[1]);
209     } else if (strcmp(fields[0], "TUN/TAP write bytes") == 0) {
210       /* read from the tunnel and written in the system */
211       tun_rx = atoll(fields[1]);
212     } else if (strcmp(fields[0], "TCP/UDP read bytes") == 0) {
213       link_rx = atoll(fields[1]);
214     } else if (strcmp(fields[0], "TCP/UDP write bytes") == 0) {
215       link_tx = atoll(fields[1]);
216     } else if (strcmp(fields[0], "pre-compress bytes") == 0) {
217       pre_compress = atoll(fields[1]);
218     } else if (strcmp(fields[0], "post-compress bytes") == 0) {
219       post_compress = atoll(fields[1]);
220     } else if (strcmp(fields[0], "pre-decompress bytes") == 0) {
221       pre_decompress = atoll(fields[1]);
222     } else if (strcmp(fields[0], "post-decompress bytes") == 0) {
223       post_decompress = atoll(fields[1]);
224     }
225   }
226
227   iostats_submit(name, "traffic", link_rx, link_tx);
228
229   /* we need to force this order to avoid negative values with these unsigned */
230   derive_t overhead_rx =
231       (((link_rx - pre_decompress) + post_decompress) - tun_rx);
232   derive_t overhead_tx = (((link_tx - post_compress) + pre_compress) - tun_tx);
233
234   iostats_submit(name, "overhead", overhead_rx, overhead_tx);
235
236   if (collect_compression) {
237     compression_submit(name, "data_in", post_decompress, pre_decompress);
238     compression_submit(name, "data_out", pre_compress, post_compress);
239   }
240
241   return 0;
242 } /* int single_read */
243
244 /* for reading status version 1 */
245 static int multi1_read(const char *name, FILE *fh) {
246   char buffer[1024];
247   char *fields[10];
248   const int max_fields = STATIC_ARRAY_SIZE(fields);
249   long long sum_users = 0;
250   _Bool found_header = 0;
251
252   /* read the file until the "ROUTING TABLE" line is found (no more info after)
253    */
254   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
255     if (strcmp(buffer, "ROUTING TABLE\n") == 0)
256       break;
257
258     if (strcmp(buffer, V1HEADER) == 0) {
259       found_header = 1;
260       continue;
261     }
262
263     /* skip the first lines until the client list section is found */
264     if (found_header == 0)
265       /* we can't start reading data until this string is found */
266       continue;
267
268     int fields_num = openvpn_strsplit(buffer, fields, max_fields);
269     if (fields_num < 4)
270       continue;
271
272     if (collect_user_count)
273     /* If so, sum all users, ignore the individuals*/
274     {
275       sum_users += 1;
276     }
277     if (collect_individual_users) {
278       if (new_naming_schema) {
279         iostats_submit(name,              /* vpn instance */
280                        fields[0],         /* "Common Name" */
281                        atoll(fields[2]),  /* "Bytes Received" */
282                        atoll(fields[3])); /* "Bytes Sent" */
283       } else {
284         iostats_submit(fields[0],         /* "Common Name" */
285                        NULL,              /* unused when in multimode */
286                        atoll(fields[2]),  /* "Bytes Received" */
287                        atoll(fields[3])); /* "Bytes Sent" */
288       }
289     }
290   }
291
292   if (ferror(fh))
293     return -1;
294
295   if (found_header == 0) {
296     NOTICE("openvpn plugin: Unknown file format in instance %s, please "
297            "report this as bug. Make sure to include "
298            "your status file, so the plugin can "
299            "be adapted.",
300            name);
301     return -1;
302   }
303
304   if (collect_user_count)
305     numusers_submit(name, name, sum_users);
306
307   return 0;
308 } /* int multi1_read */
309
310 /* for reading status version 2 / version 3
311  * status file is generated by openvpn/multi.c:multi_print_status()
312  * http://svn.openvpn.net/projects/openvpn/trunk/openvpn/multi.c
313  */
314 static int multi2_read(const char *name, FILE *fh) {
315   char buffer[1024];
316   /* OpenVPN-2.4 has 11 fields of data + 2 fields for "HEADER" and "CLIENT_LIST"
317    * So, set array size to 20 elements, to support future extensions.
318    */
319   char *fields[20];
320   const int max_fields = STATIC_ARRAY_SIZE(fields);
321   long long sum_users = 0;
322
323   _Bool found_header = 0;
324   int idx_cname = 0;
325   int idx_bytes_recv = 0;
326   int idx_bytes_sent = 0;
327   int columns = 0;
328
329   while (fgets(buffer, sizeof(buffer), fh) != NULL) {
330     int fields_num = openvpn_strsplit(buffer, fields, max_fields);
331
332     /* Try to find section header */
333     if (found_header == 0) {
334       if (fields_num < 2)
335         continue;
336       if (strcmp(fields[0], "HEADER") != 0)
337         continue;
338       if (strcmp(fields[1], "CLIENT_LIST") != 0)
339         continue;
340
341       for (int i = 2; i < fields_num; i++) {
342         if (strcmp(fields[i], "Common Name") == 0) {
343           idx_cname = i - 1;
344         } else if (strcmp(fields[i], "Bytes Received") == 0) {
345           idx_bytes_recv = i - 1;
346         } else if (strcmp(fields[i], "Bytes Sent") == 0) {
347           idx_bytes_sent = i - 1;
348         }
349       }
350
351       DEBUG("openvpn plugin: found MULTI v2/v3 HEADER. "
352             "Column idx: cname: %d, bytes_recv: %d, bytes_sent: %d",
353             idx_cname, idx_bytes_recv, idx_bytes_sent);
354
355       if (idx_cname == 0 || idx_bytes_recv == 0 || idx_bytes_sent == 0)
356         break;
357
358       /* Data row has 1 field ("HEADER") less than header row */
359       columns = fields_num - 1;
360
361       found_header = 1;
362       continue;
363     }
364
365     /* Header already found. Check if the line is the section data.
366      * If no match, then section was finished and there is no more data.
367      * Empty section is OK too.
368      */
369     if (fields_num == 0 || strcmp(fields[0], "CLIENT_LIST") != 0)
370       break;
371
372     /* Check if the data line fields count matches header line. */
373     if (fields_num != columns) {
374       ERROR("openvpn plugin: File format error in instance %s: Fields count "
375             "mismatch.",
376             name);
377       return -1;
378     }
379
380     DEBUG("openvpn plugin: found MULTI v2/v3 CLIENT_LIST. "
381           "Columns: cname: %s, bytes_recv: %s, bytes_sent: %s",
382           fields[idx_cname], fields[idx_bytes_recv], fields[idx_bytes_sent]);
383
384     if (collect_user_count)
385       sum_users += 1;
386
387     if (collect_individual_users) {
388       if (new_naming_schema) {
389         /* plugin inst = file name, type inst = fields[1] */
390         iostats_submit(name,                           /* vpn instance     */
391                        fields[idx_cname],              /* "Common Name"    */
392                        atoll(fields[idx_bytes_recv]),  /* "Bytes Received" */
393                        atoll(fields[idx_bytes_sent])); /* "Bytes Sent"     */
394       } else {
395         /* plugin inst = fields[idx_cname], type inst = "" */
396         iostats_submit(fields[idx_cname], /*              "Common Name"    */
397                        NULL,              /* unused when in multimode      */
398                        atoll(fields[idx_bytes_recv]),  /* "Bytes Received" */
399                        atoll(fields[idx_bytes_sent])); /* "Bytes Sent"     */
400       }
401     }
402   }
403
404   if (ferror(fh))
405     return -1;
406
407   if (found_header == 0) {
408     NOTICE("openvpn plugin: Unknown file format in instance %s, please "
409            "report this as bug. Make sure to include "
410            "your status file, so the plugin can "
411            "be adapted.",
412            name);
413     return -1;
414   }
415
416   if (collect_user_count) {
417     numusers_submit(name, name, sum_users);
418   }
419
420   return 0;
421 } /* int multi2_read */
422
423 /* read callback */
424 static int openvpn_read(user_data_t *user_data) {
425   char buffer[1024];
426   int read = 0;
427
428   vpn_status_t *st = user_data->data;
429
430   FILE *fh = fopen(st->file, "r");
431   if (fh == NULL) {
432     char errbuf[1024];
433     WARNING("openvpn plugin: fopen(%s) failed: %s", st->file,
434             sstrerror(errno, errbuf, sizeof(errbuf)));
435
436     return -1;
437   }
438
439   // Try to detect file format by its first line
440   if ((fgets(buffer, sizeof(buffer), fh)) == NULL) {
441     WARNING("openvpn plugin: failed to get data from: %s", st->file);
442     fclose(fh);
443     return -1;
444   }
445
446   if (strcmp(buffer, TITLE_SINGLE) == 0) { // OpenVPN STATISTICS
447     DEBUG("openvpn plugin: found status file SINGLE");
448     read = single_read(st->name, fh);
449   } else if (strcmp(buffer, TITLE_V1) == 0) { // OpenVPN CLIENT LIST
450     DEBUG("openvpn plugin: found status file MULTI version 1");
451     read = multi1_read(st->name, fh);
452   } else if (strncmp(buffer, TITLE_V2, strlen(TITLE_V2)) == 0) { // TITLE
453     DEBUG("openvpn plugin: found status file MULTI version 2/3");
454     read = multi2_read(st->name, fh);
455   } else {
456     NOTICE("openvpn plugin: %s: Unknown file format, please "
457            "report this as bug. Make sure to include "
458            "your status file, so the plugin can "
459            "be adapted.",
460            st->file);
461     read = -1;
462   }
463   fclose(fh);
464   return read;
465 } /* int openvpn_read */
466
467 static int openvpn_config(const char *key, const char *value) {
468   if (strcasecmp("StatusFile", key) == 0) {
469     char callback_name[3 * DATA_MAX_NAME_LEN];
470     char *status_name;
471
472     char *status_file = strdup(value);
473     if (status_file == NULL) {
474       char errbuf[1024];
475       ERROR("openvpn plugin: strdup failed: %s",
476             sstrerror(errno, errbuf, sizeof(errbuf)));
477       return 1;
478     }
479
480     /* it determines the file name as string starting at location filename + 1
481      */
482     char *filename = strrchr(status_file, (int)'/');
483     if (filename == NULL) {
484       /* status_file is already the file name only */
485       status_name = status_file;
486     } else {
487       /* doesn't waste memory, uses status_file starting at filename + 1 */
488       status_name = filename + 1;
489     }
490
491     /* create a new vpn element */
492     vpn_status_t *instance = calloc(1, sizeof(*instance));
493     if (instance == NULL) {
494       char errbuf[1024];
495       ERROR("openvpn plugin: malloc failed: %s",
496             sstrerror(errno, errbuf, sizeof(errbuf)));
497       sfree(status_file);
498       return 1;
499     }
500     instance->file = status_file;
501     instance->name = status_name;
502
503     snprintf(callback_name, sizeof(callback_name), "openvpn/%s", status_name);
504
505     int status = plugin_register_complex_read(
506         /* group = */ "openvpn",
507         /* name      = */ callback_name,
508         /* callback  = */ openvpn_read,
509         /* interval  = */ 0,
510         &(user_data_t){
511             .data = instance, .free_func = openvpn_free,
512         });
513
514     if (status == EINVAL) {
515       WARNING("openvpn plugin: status filename \"%s\" "
516               "already used, please choose a "
517               "different one.",
518               status_name);
519       return -1;
520     }
521
522     DEBUG("openvpn plugin: status file \"%s\" added", instance->file);
523   } /* if (strcasecmp ("StatusFile", key) == 0) */
524   else if ((strcasecmp("CollectCompression", key) == 0) ||
525            (strcasecmp("Compression", key) == 0)) /* old, deprecated name */
526   {
527     if (IS_FALSE(value))
528       collect_compression = 0;
529     else
530       collect_compression = 1;
531   } /* if (strcasecmp ("CollectCompression", key) == 0) */
532   else if (strcasecmp("ImprovedNamingSchema", key) == 0) {
533     if (IS_TRUE(value)) {
534       DEBUG("openvpn plugin: using the new naming schema");
535       new_naming_schema = 1;
536     } else {
537       new_naming_schema = 0;
538     }
539   } /* if (strcasecmp ("ImprovedNamingSchema", key) == 0) */
540   else if (strcasecmp("CollectUserCount", key) == 0) {
541     if (IS_TRUE(value))
542       collect_user_count = 1;
543     else
544       collect_user_count = 0;
545   } /* if (strcasecmp("CollectUserCount", key) == 0) */
546   else if (strcasecmp("CollectIndividualUsers", key) == 0) {
547     if (IS_FALSE(value))
548       collect_individual_users = 0;
549     else
550       collect_individual_users = 1;
551   } /* if (strcasecmp("CollectIndividualUsers", key) == 0) */
552   else {
553     return -1;
554   }
555
556   return 0;
557 } /* int openvpn_config */
558
559 static int openvpn_init(void) {
560   if (!collect_individual_users && !collect_compression &&
561       !collect_user_count) {
562     WARNING("OpenVPN plugin: Neither `CollectIndividualUsers', "
563             "`CollectCompression', nor `CollectUserCount' is true. There's no "
564             "data left to collect.");
565     return -1;
566   }
567
568   return 0;
569 } /* int openvpn_init */
570
571 void module_register(void) {
572   plugin_register_config("openvpn", openvpn_config, config_keys,
573                          config_keys_num);
574   plugin_register_init("openvpn", openvpn_init);
575 } /* void module_register */