wireless plugin: fix implicit conversion warning
[collectd.git] / src / collectd-nagios.c
1 /**
2  * collectd-nagios - src/collectd-nagios.c
3  * Copyright (C) 2008-2010  Florian octo Forster
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Florian octo Forster <octo at collectd.org>
25  **/
26
27 #if HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #if !defined(__GNUC__) || !__GNUC__
32 #define __attribute__(x) /**/
33 #endif
34
35 #include <assert.h>
36 #include <errno.h>
37 #include <stdbool.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <strings.h>
42 #include <unistd.h>
43
44 #if NAN_STATIC_DEFAULT
45 #include <math.h>
46 /* #endif NAN_STATIC_DEFAULT*/
47 #elif NAN_STATIC_ISOC
48 #ifndef __USE_ISOC99
49 #define DISABLE_ISOC99 1
50 #define __USE_ISOC99 1
51 #endif /* !defined(__USE_ISOC99) */
52 #include <math.h>
53 #if DISABLE_ISOC99
54 #undef DISABLE_ISOC99
55 #undef __USE_ISOC99
56 #endif /* DISABLE_ISOC99 */
57 /* #endif NAN_STATIC_ISOC */
58 #elif NAN_ZERO_ZERO
59 #include <math.h>
60 #ifdef NAN
61 #undef NAN
62 #endif
63 #define NAN (0.0 / 0.0)
64 #ifndef isnan
65 #define isnan(f) ((f) != (f))
66 #endif /* !defined(isnan) */
67 #ifndef isfinite
68 #define isfinite(f) (((f) - (f)) == 0.0)
69 #endif
70 #ifndef isinf
71 #define isinf(f) (!isfinite(f) && !isnan(f))
72 #endif
73 #endif /* NAN_ZERO_ZERO */
74
75 #include "collectd/client.h"
76
77 #define RET_OKAY 0
78 #define RET_WARNING 1
79 #define RET_CRITICAL 2
80 #define RET_UNKNOWN 3
81
82 #define CON_NONE 0
83 #define CON_AVERAGE 1
84 #define CON_SUM 2
85 #define CON_PERCENTAGE 3
86
87 struct range_s {
88   double min;
89   double max;
90   int invert;
91 };
92 typedef struct range_s range_t;
93
94 extern char *optarg;
95 extern int optind, opterr, optopt;
96
97 static char *socket_file_g;
98 static char *value_string_g;
99 static char *hostname_g;
100
101 static range_t range_critical_g;
102 static range_t range_warning_g;
103 static int consolitation_g = CON_NONE;
104 static bool nan_is_error_g;
105
106 static char **match_ds_g;
107 static size_t match_ds_num_g;
108
109 /* `strdup' is an XSI extension. I don't want to pull in all of XSI just for
110  * that, so here's an own implementation.. It's easy enough. The GCC attributes
111  * are supposed to get good performance..  -octo */
112 __attribute__((malloc, nonnull(1))) static char *
113 cn_strdup(const char *str) /* {{{ */
114 {
115   size_t strsize;
116   char *ret;
117
118   strsize = strlen(str) + 1;
119   ret = (char *)malloc(strsize);
120   if (ret != NULL)
121     memcpy(ret, str, strsize);
122   return ret;
123 } /* }}} char *cn_strdup */
124
125 static int filter_ds(size_t *values_num, double **values,
126                      char ***values_names) {
127   gauge_t *new_values;
128   char **new_names;
129
130   if (match_ds_g == NULL)
131     return RET_OKAY;
132
133   new_values = (gauge_t *)calloc(match_ds_num_g, sizeof(*new_values));
134   if (new_values == NULL) {
135     fprintf(stderr, "calloc failed: %s\n", strerror(errno));
136     return RET_UNKNOWN;
137   }
138
139   new_names = (char **)calloc(match_ds_num_g, sizeof(*new_names));
140   if (new_names == NULL) {
141     fprintf(stderr, "calloc failed: %s\n", strerror(errno));
142     free(new_values);
143     return RET_UNKNOWN;
144   }
145
146   for (size_t i = 0; i < match_ds_num_g; i++) {
147     size_t j;
148
149     /* match_ds_g keeps pointers into argv but the names will be freed */
150     new_names[i] = cn_strdup(match_ds_g[i]);
151     if (new_names[i] == NULL) {
152       fprintf(stderr, "cn_strdup failed: %s\n", strerror(errno));
153       free(new_values);
154       for (j = 0; j < i; j++)
155         free(new_names[j]);
156       free(new_names);
157       return RET_UNKNOWN;
158     }
159
160     for (j = 0; j < *values_num; j++)
161       if (strcasecmp(new_names[i], (*values_names)[j]) == 0)
162         break;
163
164     if (j == *values_num) {
165       printf("ERROR: DS `%s' is not available.\n", new_names[i]);
166       free(new_values);
167       for (j = 0; j <= i; j++)
168         free(new_names[j]);
169       free(new_names);
170       return RET_CRITICAL;
171     }
172
173     new_values[i] = (*values)[j];
174   }
175
176   free(*values);
177   for (size_t i = 0; i < *values_num; i++)
178     free((*values_names)[i]);
179   free(*values_names);
180
181   *values = new_values;
182   *values_names = new_names;
183   *values_num = match_ds_num_g;
184   return RET_OKAY;
185 } /* int filter_ds */
186
187 static void parse_range(char *string, range_t *range) {
188   char *min_ptr;
189   char *max_ptr;
190
191   if (*string == '@') {
192     range->invert = 1;
193     string++;
194   }
195
196   max_ptr = strchr(string, ':');
197   if (max_ptr == NULL) {
198     min_ptr = NULL;
199     max_ptr = string;
200   } else {
201     min_ptr = string;
202     *max_ptr = '\0';
203     max_ptr++;
204   }
205
206   assert(max_ptr != NULL);
207
208   /* `10' == `0:10' */
209   if (min_ptr == NULL)
210     range->min = 0.0;
211   /* :10 == ~:10 == -inf:10 */
212   else if ((*min_ptr == '\0') || (*min_ptr == '~'))
213     range->min = NAN;
214   else
215     range->min = atof(min_ptr);
216
217   if ((*max_ptr == '\0') || (*max_ptr == '~'))
218     range->max = NAN;
219   else
220     range->max = atof(max_ptr);
221 } /* void parse_range */
222
223 static int match_range(range_t *range, double value) {
224   int ret = 0;
225
226   if (!isnan(range->min) && (range->min > value))
227     ret = 1;
228   if (!isnan(range->max) && (range->max < value))
229     ret = 1;
230
231   return ((ret - range->invert) == 0) ? 0 : 1;
232 } /* int match_range */
233
234 __attribute__((noreturn)) static void usage(const char *name) {
235   fprintf(stderr,
236           "Usage: %s <-s socket> <-n value_spec> <-H hostname> [options]\n"
237           "\n"
238           "Valid options are:\n"
239           "  -s <socket>    Path to collectd's UNIX-socket.\n"
240           "  -n <v_spec>    Value specification to get from collectd.\n"
241           "                 Format: `plugin-instance/type-instance'\n"
242           "  -d <ds>        Select the DS to examine. May be repeated to "
243           "examine multiple\n"
244           "                 DSes. By default all DSes are used.\n"
245           "  -g <consol>    Method to use to consolidate several DSes.\n"
246           "                 See below for a list of valid arguments.\n"
247           "  -H <host>      Hostname to query the values for.\n"
248           "  -c <range>     Critical range\n"
249           "  -w <range>     Warning range\n"
250           "  -m             Treat \"Not a Number\" (NaN) as critical (default: "
251           "warning)\n"
252           "\n"
253           "Consolidation functions:\n"
254           "  none:          Apply the warning- and critical-ranges to each "
255           "data-source\n"
256           "                 individually.\n"
257           "  average:       Calculate the average of all matching DSes and "
258           "apply the\n"
259           "                 warning- and critical-ranges to the calculated "
260           "average.\n"
261           "  sum:           Apply the ranges to the sum of all DSes.\n"
262           "  percentage:    Apply the ranges to the ratio (in percent) of the "
263           "first value\n"
264           "                 and the sum of all values."
265           "\n",
266           name);
267   exit(1);
268 } /* void usage */
269
270 static int do_listval(lcc_connection_t *connection) {
271   lcc_identifier_t *ret_ident = NULL;
272   size_t ret_ident_num = 0;
273
274   char *hostname = NULL;
275
276   int status;
277
278   status = lcc_listval(connection, &ret_ident, &ret_ident_num);
279   if (status != 0) {
280     printf("UNKNOWN: %s\n", lcc_strerror(connection));
281     if (ret_ident != NULL)
282       free(ret_ident);
283     return RET_UNKNOWN;
284   }
285
286   status = lcc_sort_identifiers(connection, ret_ident, ret_ident_num);
287   if (status != 0) {
288     printf("UNKNOWN: %s\n", lcc_strerror(connection));
289     if (ret_ident != NULL)
290       free(ret_ident);
291     return RET_UNKNOWN;
292   }
293
294   for (size_t i = 0; i < ret_ident_num; ++i) {
295     char id[1024];
296
297     if ((hostname_g != NULL) && (strcasecmp(hostname_g, ret_ident[i].host)))
298       continue;
299
300     if ((hostname == NULL) || strcasecmp(hostname, ret_ident[i].host)) {
301       free(hostname);
302       hostname = strdup(ret_ident[i].host);
303       printf("Host: %s\n", hostname);
304     }
305
306     /* empty hostname; not to be printed again */
307     ret_ident[i].host[0] = '\0';
308
309     status =
310         lcc_identifier_to_string(connection, id, sizeof(id), ret_ident + i);
311     if (status != 0) {
312       printf("ERROR: listval: Failed to convert returned "
313              "identifier to a string: %s\n",
314              lcc_strerror(connection));
315       free(hostname);
316       hostname = NULL;
317       continue;
318     }
319
320     /* skip over the (empty) hostname and following '/' */
321     printf("\t%s\n", id + 1);
322   }
323
324   free(ret_ident);
325   free(hostname);
326   return RET_OKAY;
327 } /* int do_listval */
328
329 static int do_check_con_none(size_t values_num, double *values,
330                              char **values_names) {
331   int num_critical = 0;
332   int num_warning = 0;
333   int num_okay = 0;
334   const char *status_str = "UNKNOWN";
335   int status_code = RET_UNKNOWN;
336
337   for (size_t i = 0; i < values_num; i++) {
338     if (isnan(values[i])) {
339       if (nan_is_error_g)
340         num_critical++;
341       else
342         num_warning++;
343     } else if (match_range(&range_critical_g, values[i]) != 0)
344       num_critical++;
345     else if (match_range(&range_warning_g, values[i]) != 0)
346       num_warning++;
347     else
348       num_okay++;
349   }
350
351   if ((num_critical == 0) && (num_warning == 0) && (num_okay == 0)) {
352     printf("WARNING: No defined values found\n");
353     return RET_WARNING;
354   } else if ((num_critical == 0) && (num_warning == 0)) {
355     status_str = "OKAY";
356     status_code = RET_OKAY;
357   } else if (num_critical == 0) {
358     status_str = "WARNING";
359     status_code = RET_WARNING;
360   } else {
361     status_str = "CRITICAL";
362     status_code = RET_CRITICAL;
363   }
364
365   printf("%s: %i critical, %i warning, %i okay", status_str, num_critical,
366          num_warning, num_okay);
367   if (values_num > 0) {
368     printf(" |");
369     for (size_t i = 0; i < values_num; i++)
370       printf(" %s=%f;;;;", values_names[i], values[i]);
371   }
372   printf("\n");
373
374   return status_code;
375 } /* int do_check_con_none */
376
377 static int do_check_con_average(size_t values_num, double *values,
378                                 char **values_names) {
379   double total;
380   int total_num;
381   double average;
382   const char *status_str = "UNKNOWN";
383   int status_code = RET_UNKNOWN;
384
385   total = 0.0;
386   total_num = 0;
387   for (size_t i = 0; i < values_num; i++) {
388     if (isnan(values[i])) {
389       if (!nan_is_error_g)
390         continue;
391
392       printf("CRITICAL: Data source \"%s\" is NaN\n", values_names[i]);
393       return RET_CRITICAL;
394     }
395
396     total += values[i];
397     total_num++;
398   }
399
400   if (total_num == 0) {
401     printf("WARNING: No defined values found\n");
402     return RET_WARNING;
403   }
404
405   average = total / total_num;
406
407   if (match_range(&range_critical_g, average) != 0) {
408     status_str = "CRITICAL";
409     status_code = RET_CRITICAL;
410   } else if (match_range(&range_warning_g, average) != 0) {
411     status_str = "WARNING";
412     status_code = RET_WARNING;
413   } else {
414     status_str = "OKAY";
415     status_code = RET_OKAY;
416   }
417
418   printf("%s: %g average |", status_str, average);
419   for (size_t i = 0; i < values_num; i++)
420     printf(" %s=%f;;;;", values_names[i], values[i]);
421   printf("\n");
422
423   return status_code;
424 } /* int do_check_con_average */
425
426 static int do_check_con_sum(size_t values_num, double *values,
427                             char **values_names) {
428   double total;
429   int total_num;
430   const char *status_str = "UNKNOWN";
431   int status_code = RET_UNKNOWN;
432
433   total = 0.0;
434   total_num = 0;
435   for (size_t i = 0; i < values_num; i++) {
436     if (isnan(values[i])) {
437       if (!nan_is_error_g)
438         continue;
439
440       printf("CRITICAL: Data source \"%s\" is NaN\n", values_names[i]);
441       return RET_CRITICAL;
442     }
443
444     total += values[i];
445     total_num++;
446   }
447
448   if (total_num == 0) {
449     printf("WARNING: No defined values found\n");
450     return RET_WARNING;
451   }
452
453   if (match_range(&range_critical_g, total) != 0) {
454     status_str = "CRITICAL";
455     status_code = RET_CRITICAL;
456   } else if (match_range(&range_warning_g, total) != 0) {
457     status_str = "WARNING";
458     status_code = RET_WARNING;
459   } else {
460     status_str = "OKAY";
461     status_code = RET_OKAY;
462   }
463
464   printf("%s: %g sum |", status_str, total);
465   for (size_t i = 0; i < values_num; i++)
466     printf(" %s=%f;;;;", values_names[i], values[i]);
467   printf("\n");
468
469   return status_code;
470 } /* int do_check_con_sum */
471
472 static int do_check_con_percentage(size_t values_num, double *values,
473                                    char **values_names) {
474   double sum = 0.0;
475   double percentage;
476
477   const char *status_str = "UNKNOWN";
478   int status_code = RET_UNKNOWN;
479
480   if ((values_num < 1) || (isnan(values[0]))) {
481     printf("WARNING: The first value is not defined\n");
482     return RET_WARNING;
483   }
484
485   for (size_t i = 0; i < values_num; i++) {
486     if (isnan(values[i])) {
487       if (!nan_is_error_g)
488         continue;
489
490       printf("CRITICAL: Data source \"%s\" is NaN\n", values_names[i]);
491       return RET_CRITICAL;
492     }
493
494     sum += values[i];
495   }
496
497   if (sum == 0.0) {
498     printf("WARNING: Values sum up to zero\n");
499     return RET_WARNING;
500   }
501
502   percentage = 100.0 * values[0] / sum;
503
504   if (match_range(&range_critical_g, percentage) != 0) {
505     status_str = "CRITICAL";
506     status_code = RET_CRITICAL;
507   } else if (match_range(&range_warning_g, percentage) != 0) {
508     status_str = "WARNING";
509     status_code = RET_WARNING;
510   } else {
511     status_str = "OKAY";
512     status_code = RET_OKAY;
513   }
514
515   printf("%s: %lf percent |", status_str, percentage);
516   for (size_t i = 0; i < values_num; i++)
517     printf(" %s=%lf;;;;", values_names[i], values[i]);
518   return status_code;
519 } /* int do_check_con_percentage */
520
521 static int do_check(lcc_connection_t *connection) {
522   gauge_t *values;
523   char **values_names;
524   size_t values_num;
525   char ident_str[1024];
526   lcc_identifier_t ident;
527   int status;
528
529   snprintf(ident_str, sizeof(ident_str), "%s/%s", hostname_g, value_string_g);
530   ident_str[sizeof(ident_str) - 1] = 0;
531
532   status = lcc_string_to_identifier(connection, &ident, ident_str);
533   if (status != 0) {
534     printf("ERROR: Creating an identifier failed: %s.\n",
535            lcc_strerror(connection));
536     LCC_DESTROY(connection);
537     return RET_CRITICAL;
538   }
539
540   status = lcc_getval(connection, &ident, &values_num, &values, &values_names);
541   if (status != 0) {
542     printf("ERROR: Retrieving values from the daemon failed: %s.\n",
543            lcc_strerror(connection));
544     LCC_DESTROY(connection);
545     return RET_CRITICAL;
546   }
547
548   LCC_DESTROY(connection);
549
550   status = filter_ds(&values_num, &values, &values_names);
551   if (status != RET_OKAY)
552     return status;
553
554   status = RET_UNKNOWN;
555   if (consolitation_g == CON_NONE)
556     status = do_check_con_none(values_num, values, values_names);
557   else if (consolitation_g == CON_AVERAGE)
558     status = do_check_con_average(values_num, values, values_names);
559   else if (consolitation_g == CON_SUM)
560     status = do_check_con_sum(values_num, values, values_names);
561   else if (consolitation_g == CON_PERCENTAGE)
562     status = do_check_con_percentage(values_num, values, values_names);
563
564   free(values);
565   if (values_names != NULL)
566     for (size_t i = 0; i < values_num; i++)
567       free(values_names[i]);
568   free(values_names);
569
570   return status;
571 } /* int do_check */
572
573 int main(int argc, char **argv) {
574   char address[1024];
575   lcc_connection_t *connection;
576
577   int status;
578
579   range_critical_g.min = NAN;
580   range_critical_g.max = NAN;
581   range_critical_g.invert = 0;
582
583   range_warning_g.min = NAN;
584   range_warning_g.max = NAN;
585   range_warning_g.invert = 0;
586
587   while (42) {
588     int c;
589
590     c = getopt(argc, argv, "w:c:s:n:H:g:d:hm");
591     if (c < 0)
592       break;
593
594     switch (c) {
595     case 'c':
596       parse_range(optarg, &range_critical_g);
597       break;
598     case 'w':
599       parse_range(optarg, &range_warning_g);
600       break;
601     case 's':
602       socket_file_g = optarg;
603       break;
604     case 'n':
605       value_string_g = optarg;
606       break;
607     case 'H':
608       hostname_g = optarg;
609       break;
610     case 'g':
611       if (strcasecmp(optarg, "none") == 0)
612         consolitation_g = CON_NONE;
613       else if (strcasecmp(optarg, "average") == 0)
614         consolitation_g = CON_AVERAGE;
615       else if (strcasecmp(optarg, "sum") == 0)
616         consolitation_g = CON_SUM;
617       else if (strcasecmp(optarg, "percentage") == 0)
618         consolitation_g = CON_PERCENTAGE;
619       else {
620         fprintf(stderr, "Unknown consolidation function `%s'.\n", optarg);
621         usage(argv[0]);
622       }
623       break;
624     case 'd': {
625       char **tmp;
626       tmp = realloc(match_ds_g, (match_ds_num_g + 1) * sizeof(char *));
627       if (tmp == NULL) {
628         fprintf(stderr, "realloc failed: %s\n", strerror(errno));
629         return RET_UNKNOWN;
630       }
631       match_ds_g = tmp;
632       match_ds_g[match_ds_num_g] = cn_strdup(optarg);
633       if (match_ds_g[match_ds_num_g] == NULL) {
634         fprintf(stderr, "cn_strdup failed: %s\n", strerror(errno));
635         return RET_UNKNOWN;
636       }
637       match_ds_num_g++;
638       break;
639     }
640     case 'm':
641       nan_is_error_g = true;
642       break;
643     default:
644       usage(argv[0]);
645     } /* switch (c) */
646   }
647
648   if ((socket_file_g == NULL) || (value_string_g == NULL) ||
649       ((hostname_g == NULL) && (strcasecmp(value_string_g, "LIST")))) {
650     fprintf(stderr, "Missing required arguments.\n");
651     usage(argv[0]);
652   }
653
654   snprintf(address, sizeof(address), "unix:%s", socket_file_g);
655   address[sizeof(address) - 1] = 0;
656
657   connection = NULL;
658   status = lcc_connect(address, &connection);
659   if (status != 0) {
660     printf("ERROR: Connecting to daemon at %s failed.\n", socket_file_g);
661     return RET_CRITICAL;
662   }
663
664   if (0 == strcasecmp(value_string_g, "LIST"))
665     return do_listval(connection);
666
667   return do_check(connection);
668 } /* int main */