1 /**
2 * collectd-nagios - src/collectd-nagios.c
3 * Copyright (C) 2008 Florian octo Forster
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; only version 2 of the License is applicable.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 *
18 * Authors:
19 * Florian octo Forster <octo at verplant.org>
20 **/
22 /* Set to C99 and POSIX code */
23 #ifndef _ISOC99_SOURCE
24 # define _ISOC99_SOURCE
25 #endif
26 #ifndef _POSIX_SOURCE
27 # define _POSIX_SOURCE
28 #endif
29 #ifndef _POSIX_C_SOURCE
30 # define _POSIX_C_SOURCE 200112L
31 #endif
32 #ifndef _REENTRANT
33 # define _REENTRANT
34 #endif
36 /* Disable non-standard extensions */
37 #ifdef _BSD_SOURCE
38 # undef _BSD_SOURCE
39 #endif
40 #ifdef _SVID_SOURCE
41 # undef _SVID_SOURCE
42 #endif
43 #ifdef _GNU_SOURCE
44 # undef _GNU_SOURCE
45 #endif
47 #if !defined(__GNUC__) || !__GNUC__
48 # define __attribute__(x) /**/
49 #endif
51 #include "config.h"
53 #include <stdlib.h>
54 #include <unistd.h>
55 #include <stdio.h>
56 #include <errno.h>
57 #include <string.h>
58 #include <strings.h>
59 #include <assert.h>
61 #include <sys/socket.h>
62 #include <sys/un.h>
64 #include "libcollectdclient/client.h"
66 /*
67 * This is copied directly from collectd.h. Make changes there!
68 */
69 #if NAN_STATIC_DEFAULT
70 # include <math.h>
71 /* #endif NAN_STATIC_DEFAULT*/
72 #elif NAN_STATIC_ISOC
73 # ifndef __USE_ISOC99
74 # define DISABLE_ISOC99 1
75 # define __USE_ISOC99 1
76 # endif /* !defined(__USE_ISOC99) */
77 # include <math.h>
78 # if DISABLE_ISOC99
79 # undef DISABLE_ISOC99
80 # undef __USE_ISOC99
81 # endif /* DISABLE_ISOC99 */
82 /* #endif NAN_STATIC_ISOC */
83 #elif NAN_ZERO_ZERO
84 # include <math.h>
85 # ifdef NAN
86 # undef NAN
87 # endif
88 # define NAN (0.0 / 0.0)
89 # ifndef isnan
90 # define isnan(f) ((f) != (f))
91 # endif /* !defined(isnan) */
92 #endif /* NAN_ZERO_ZERO */
94 #define RET_OKAY 0
95 #define RET_WARNING 1
96 #define RET_CRITICAL 2
97 #define RET_UNKNOWN 3
99 #define CON_NONE 0
100 #define CON_AVERAGE 1
101 #define CON_SUM 2
102 #define CON_PERCENTAGE 3
104 struct range_s
105 {
106 double min;
107 double max;
108 int invert;
109 };
110 typedef struct range_s range_t;
112 extern char *optarg;
113 extern int optind, opterr, optopt;
115 static char *socket_file_g = NULL;
116 static char *value_string_g = NULL;
117 static char *hostname_g = NULL;
119 static range_t range_critical_g;
120 static range_t range_warning_g;
121 static int consolitation_g = CON_NONE;
123 static char **match_ds_g = NULL;
124 static int match_ds_num_g = 0;
126 /* `strdup' is an XSI extension. I don't want to pull in all of XSI just for
127 * that, so here's an own implementation.. It's easy enough. The GCC attributes
128 * are supposed to get good performance.. -octo */
129 __attribute__((malloc, nonnull (1)))
130 static char *cn_strdup (const char *str) /* {{{ */
131 {
132 size_t strsize;
133 char *ret;
135 strsize = strlen (str) + 1;
136 ret = (char *) malloc (strsize);
137 if (ret != NULL)
138 memcpy (ret, str, strsize);
139 return (ret);
140 } /* }}} char *cn_strdup */
142 static int filter_ds (size_t *values_num,
143 double **values, char ***values_names)
144 {
145 gauge_t *new_values;
146 char **new_names;
148 size_t i;
150 if (match_ds_g == NULL)
151 return (RET_OKAY);
153 new_values = (gauge_t *)calloc (match_ds_num_g, sizeof (*new_values));
154 if (new_values == NULL)
155 {
156 fprintf (stderr, "malloc failed: %s\n", strerror (errno));
157 return (RET_UNKNOWN);
158 }
160 new_names = (char **)calloc (match_ds_num_g, sizeof (*new_names));
161 if (new_names == NULL)
162 {
163 fprintf (stderr, "malloc failed: %s\n", strerror (errno));
164 free (new_values);
165 return (RET_UNKNOWN);
166 }
168 for (i = 0; i < match_ds_num_g; i++)
169 {
170 size_t j;
172 /* match_ds_g keeps pointers into argv but the names will be freed */
173 new_names[i] = cn_strdup (match_ds_g[i]);
174 if (new_names[i] == NULL)
175 {
176 fprintf (stderr, "cn_strdup failed: %s\n", strerror (errno));
177 free (new_values);
178 for (j = 0; j < i; j++)
179 free (new_names[j]);
180 free (new_names);
181 return (RET_UNKNOWN);
182 }
184 for (j = 0; j < *values_num; j++)
185 if (strcasecmp (new_names[i], (*values_names)[j]) == 0)
186 break;
188 if (j == *values_num)
189 {
190 printf ("ERROR: DS `%s' is not available.\n", new_names[i]);
191 free (new_values);
192 for (j = 0; j <= i; j++)
193 free (new_names[j]);
194 free (new_names);
195 return (RET_CRITICAL);
196 }
198 new_values[i] = (*values)[j];
199 }
201 free (*values);
202 for (i = 0; i < *values_num; i++)
203 free ((*values_names)[i]);
204 free (*values_names);
206 *values = new_values;
207 *values_names = new_names;
208 *values_num = match_ds_num_g;
209 return (RET_OKAY);
210 } /* int filter_ds */
212 static void parse_range (char *string, range_t *range)
213 {
214 char *min_ptr;
215 char *max_ptr;
217 if (*string == '@')
218 {
219 range->invert = 1;
220 string++;
221 }
223 max_ptr = strchr (string, ':');
224 if (max_ptr == NULL)
225 {
226 min_ptr = NULL;
227 max_ptr = string;
228 }
229 else
230 {
231 min_ptr = string;
232 *max_ptr = '\0';
233 max_ptr++;
234 }
236 assert (max_ptr != NULL);
238 /* `10' == `0:10' */
239 if (min_ptr == NULL)
240 range->min = 0.0;
241 /* :10 == ~:10 == -inf:10 */
242 else if ((*min_ptr == '\0') || (*min_ptr == '~'))
243 range->min = NAN;
244 else
245 range->min = atof (min_ptr);
247 if ((*max_ptr == '\0') || (*max_ptr == '~'))
248 range->max = NAN;
249 else
250 range->max = atof (max_ptr);
251 } /* void parse_range */
253 static int match_range (range_t *range, double value)
254 {
255 int ret = 0;
257 if (!isnan (range->min) && (range->min > value))
258 ret = 1;
259 if (!isnan (range->max) && (range->max < value))
260 ret = 1;
262 return (((ret - range->invert) == 0) ? 0 : 1);
263 } /* int match_range */
265 static void usage (const char *name)
266 {
267 fprintf (stderr, "Usage: %s <-s socket> <-n value_spec> <-H hostname> [options]\n"
268 "\n"
269 "Valid options are:\n"
270 " -s <socket> Path to collectd's UNIX-socket.\n"
271 " -n <v_spec> Value specification to get from collectd.\n"
272 " Format: `plugin-instance/type-instance'\n"
273 " -d <ds> Select the DS to examine. May be repeated to examine multiple\n"
274 " DSes. By default all DSes are used.\n"
275 " -g <consol> Method to use to consolidate several DSes.\n"
276 " Valid arguments are `none', `average' and `sum'\n"
277 " -H <host> Hostname to query the values for.\n"
278 " -c <range> Critical range\n"
279 " -w <range> Warning range\n"
280 "\n"
281 "Consolidation functions:\n"
282 " none: Apply the warning- and critical-ranges to each data-source\n"
283 " individually.\n"
284 " average: Calculate the average of all matching DSes and apply the\n"
285 " warning- and critical-ranges to the calculated average.\n"
286 " sum: Apply the ranges to the sum of all DSes.\n"
287 "\n", name);
288 exit (1);
289 } /* void usage */
291 static int do_check_con_none (size_t values_num,
292 double *values, char **values_names)
293 {
294 int num_critical = 0;
295 int num_warning = 0;
296 int num_okay = 0;
297 const char *status_str = "UNKNOWN";
298 int status_code = RET_UNKNOWN;
299 int i;
301 for (i = 0; i < values_num; i++)
302 {
303 if (isnan (values[i]))
304 num_warning++;
305 else if (match_range (&range_critical_g, values[i]) != 0)
306 num_critical++;
307 else if (match_range (&range_warning_g, values[i]) != 0)
308 num_warning++;
309 else
310 num_okay++;
311 }
313 if ((num_critical == 0) && (num_warning == 0) && (num_okay == 0))
314 {
315 printf ("WARNING: No defined values found\n");
316 return (RET_WARNING);
317 }
318 else if ((num_critical == 0) && (num_warning == 0))
319 {
320 status_str = "OKAY";
321 status_code = RET_OKAY;
322 }
323 else if (num_critical == 0)
324 {
325 status_str = "WARNING";
326 status_code = RET_WARNING;
327 }
328 else
329 {
330 status_str = "CRITICAL";
331 status_code = RET_CRITICAL;
332 }
334 printf ("%s: %i critical, %i warning, %i okay", status_str,
335 num_critical, num_warning, num_okay);
336 if (values_num > 0)
337 {
338 printf (" |");
339 for (i = 0; i < values_num; i++)
340 printf (" %s=%g;;;;", values_names[i], values[i]);
341 }
342 printf ("\n");
344 return (status_code);
345 } /* int do_check_con_none */
347 static int do_check_con_average (size_t values_num,
348 double *values, char **values_names)
349 {
350 int i;
351 double total;
352 int total_num;
353 double average;
354 const char *status_str = "UNKNOWN";
355 int status_code = RET_UNKNOWN;
357 total = 0.0;
358 total_num = 0;
359 for (i = 0; i < values_num; i++)
360 {
361 if (!isnan (values[i]))
362 {
363 total += values[i];
364 total_num++;
365 }
366 }
368 if (total_num == 0)
369 {
370 printf ("WARNING: No defined values found\n");
371 return (RET_WARNING);
372 }
374 average = total / total_num;
376 if (match_range (&range_critical_g, average) != 0)
377 {
378 status_str = "CRITICAL";
379 status_code = RET_CRITICAL;
380 }
381 else if (match_range (&range_warning_g, average) != 0)
382 {
383 status_str = "WARNING";
384 status_code = RET_WARNING;
385 }
386 else
387 {
388 status_str = "OKAY";
389 status_code = RET_OKAY;
390 }
392 printf ("%s: %g average |", status_str, average);
393 for (i = 0; i < values_num; i++)
394 printf (" %s=%g;;;;", values_names[i], values[i]);
395 printf ("\n");
397 return (status_code);
398 } /* int do_check_con_average */
400 static int do_check_con_sum (size_t values_num,
401 double *values, char **values_names)
402 {
403 int i;
404 double total;
405 int total_num;
406 const char *status_str = "UNKNOWN";
407 int status_code = RET_UNKNOWN;
409 total = 0.0;
410 total_num = 0;
411 for (i = 0; i < values_num; i++)
412 {
413 if (!isnan (values[i]))
414 {
415 total += values[i];
416 total_num++;
417 }
418 }
420 if (total_num == 0)
421 {
422 printf ("WARNING: No defined values found\n");
423 return (RET_WARNING);
424 }
426 if (match_range (&range_critical_g, total) != 0)
427 {
428 status_str = "CRITICAL";
429 status_code = RET_CRITICAL;
430 }
431 else if (match_range (&range_warning_g, total) != 0)
432 {
433 status_str = "WARNING";
434 status_code = RET_WARNING;
435 }
436 else
437 {
438 status_str = "OKAY";
439 status_code = RET_OKAY;
440 }
442 printf ("%s: %g sum |", status_str, total);
443 for (i = 0; i < values_num; i++)
444 printf (" %s=%g;;;;", values_names[i], values[i]);
445 printf ("\n");
447 return (status_code);
448 } /* int do_check_con_sum */
450 static int do_check_con_percentage (size_t values_num,
451 double *values, char **values_names)
452 {
453 int i;
454 double sum = 0.0;
455 double percentage;
457 const char *status_str = "UNKNOWN";
458 int status_code = RET_UNKNOWN;
460 if ((values_num < 1) || (isnan (values[0])))
461 {
462 printf ("WARNING: The first value is not defined\n");
463 return (RET_WARNING);
464 }
466 for (i = 0; i < values_num; i++)
467 if (!isnan (values[i]))
468 sum += values[i];
470 if (sum == 0.0)
471 {
472 printf ("WARNING: Values sum up to zero\n");
473 return (RET_WARNING);
474 }
476 percentage = 100.0 * values[0] / sum;
478 if (match_range (&range_critical_g, percentage) != 0)
479 {
480 status_str = "CRITICAL";
481 status_code = RET_CRITICAL;
482 }
483 else if (match_range (&range_warning_g, percentage) != 0)
484 {
485 status_str = "WARNING";
486 status_code = RET_WARNING;
487 }
488 else
489 {
490 status_str = "OKAY";
491 status_code = RET_OKAY;
492 }
494 printf ("%s: %lf percent |", status_str, percentage);
495 for (i = 0; i < values_num; i++)
496 printf (" %s=%lf;;;;", values_names[i], values[i]);
497 return (status_code);
498 } /* int do_check_con_percentage */
500 static int do_check (void)
501 {
502 lcc_connection_t *connection;
503 gauge_t *values;
504 char **values_names;
505 size_t values_num;
506 char address[1024];
507 char ident_str[1024];
508 lcc_identifier_t ident;
509 size_t i;
510 int status;
512 snprintf (address, sizeof (address), "unix:%s", socket_file_g);
513 address[sizeof (address) - 1] = 0;
515 snprintf (ident_str, sizeof (ident_str), "%s/%s",
516 hostname_g, value_string_g);
517 ident_str[sizeof (ident_str) - 1] = 0;
519 connection = NULL;
520 status = lcc_connect (address, &connection);
521 if (status != 0)
522 {
523 printf ("ERROR: Connecting to daemon at %s failed.\n",
524 socket_file_g);
525 return (RET_CRITICAL);
526 }
528 memset (&ident, 0, sizeof (ident));
529 status = lcc_string_to_identifier (connection, &ident, ident_str);
530 if (status != 0)
531 {
532 printf ("ERROR: Creating an identifier failed: %s.\n",
533 lcc_strerror (connection));
534 LCC_DESTROY (connection);
535 return (RET_CRITICAL);
536 }
538 status = lcc_getval (connection, &ident,
539 &values_num, &values, &values_names);
540 if (status != 0)
541 {
542 printf ("ERROR: Retrieving values from the daemon failed: %s.\n",
543 lcc_strerror (connection));
544 LCC_DESTROY (connection);
545 return (RET_CRITICAL);
546 }
548 LCC_DESTROY (connection);
550 status = filter_ds (&values_num, &values, &values_names);
551 if (status != RET_OKAY)
552 return (status);
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);
564 free (values);
565 if (values_names != NULL)
566 for (i = 0; i < values_num; i++)
567 free (values_names[i]);
568 free (values_names);
570 return (status);
571 } /* int do_check */
573 int main (int argc, char **argv)
574 {
575 range_critical_g.min = NAN;
576 range_critical_g.max = NAN;
577 range_critical_g.invert = 0;
579 range_warning_g.min = NAN;
580 range_warning_g.max = NAN;
581 range_warning_g.invert = 0;
583 while (42)
584 {
585 int c;
587 c = getopt (argc, argv, "w:c:s:n:H:g:d:h");
588 if (c < 0)
589 break;
591 switch (c)
592 {
593 case 'c':
594 parse_range (optarg, &range_critical_g);
595 break;
596 case 'w':
597 parse_range (optarg, &range_warning_g);
598 break;
599 case 's':
600 socket_file_g = optarg;
601 break;
602 case 'n':
603 value_string_g = optarg;
604 break;
605 case 'H':
606 hostname_g = optarg;
607 break;
608 case 'g':
609 if (strcasecmp (optarg, "none") == 0)
610 consolitation_g = CON_NONE;
611 else if (strcasecmp (optarg, "average") == 0)
612 consolitation_g = CON_AVERAGE;
613 else if (strcasecmp (optarg, "sum") == 0)
614 consolitation_g = CON_SUM;
615 else if (strcasecmp (optarg, "percentage") == 0)
616 consolitation_g = CON_PERCENTAGE;
617 else
618 usage (argv[0]);
619 break;
620 case 'd':
621 {
622 char **tmp;
623 tmp = (char **) realloc (match_ds_g,
624 (match_ds_num_g + 1)
625 * sizeof (char *));
626 if (tmp == NULL)
627 {
628 fprintf (stderr, "realloc failed: %s\n",
629 strerror (errno));
630 return (RET_UNKNOWN);
631 }
632 match_ds_g = tmp;
633 match_ds_g[match_ds_num_g] = cn_strdup (optarg);
634 if (match_ds_g[match_ds_num_g] == NULL)
635 {
636 fprintf (stderr, "cn_strdup failed: %s\n",
637 strerror (errno));
638 return (RET_UNKNOWN);
639 }
640 match_ds_num_g++;
641 break;
642 }
643 default:
644 usage (argv[0]);
645 } /* switch (c) */
646 }
648 if ((socket_file_g == NULL) || (value_string_g == NULL)
649 || (hostname_g == NULL))
650 usage (argv[0]);
652 return (do_check ());
653 } /* int main */