Collectd::Unixsock: Add support for the “GETTHRESHOLD” command.
[collectd.git] / src / ping.c
1 /**
2  * collectd - src/ping.c
3  * Copyright (C) 2005-2009  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  **/
21
22 #include "collectd.h"
23 #include "common.h"
24 #include "plugin.h"
25 #include "configfile.h"
26
27 #include <pthread.h>
28 #include <netinet/in.h>
29 #if HAVE_NETDB_H
30 # include <netdb.h> /* NI_MAXHOST */
31 #endif
32
33 #include <oping.h>
34
35 #ifndef NI_MAXHOST
36 # define NI_MAXHOST 1025
37 #endif
38
39 /*
40  * Private data types
41  */
42 struct hostlist_s
43 {
44   char *host;
45
46   uint32_t pkg_sent;
47   uint32_t pkg_recv;
48
49   double latency_total;
50   double latency_squared;
51
52   struct hostlist_s *next;
53 };
54 typedef struct hostlist_s hostlist_t;
55
56 /*
57  * Private variables
58  */
59 static hostlist_t *hostlist_head = NULL;
60
61 static int    ping_ttl = PING_DEF_TTL;
62 static double ping_interval = 1.0;
63 static double ping_timeout = 0.9;
64
65 static int             ping_thread_loop = 0;
66 static int             ping_thread_error = 0;
67 static pthread_t       ping_thread_id;
68 static pthread_mutex_t ping_lock = PTHREAD_MUTEX_INITIALIZER;
69 static pthread_cond_t  ping_cond = PTHREAD_COND_INITIALIZER;
70
71 static const char *config_keys[] =
72 {
73   "Host",
74   "TTL",
75   "Interval",
76   "Timeout"
77 };
78 static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
79
80 /*
81  * Private functions
82  */
83 /* Assure that `ts->tv_nsec' is in the range 0 .. 999999999 */
84 static void time_normalize (struct timespec *ts) /* {{{ */
85 {
86   while (ts->tv_nsec < 0)
87   {
88     if (ts->tv_sec == 0)
89     {
90       ts->tv_nsec = 0;
91       return;
92     }
93
94     ts->tv_sec  -= 1;
95     ts->tv_nsec += 1000000000;
96   }
97
98   while (ts->tv_nsec >= 1000000000)
99   {
100     ts->tv_sec  += 1;
101     ts->tv_nsec -= 1000000000;
102   }
103 } /* }}} void time_normalize */
104
105 /* Add `ts_int' to `tv_begin' and store the result in `ts_dest'. If the result
106  * is larger than `tv_end', copy `tv_end' to `ts_dest' instead. */
107 static void time_calc (struct timespec *ts_dest, /* {{{ */
108     const struct timespec *ts_int,
109     const struct timeval  *tv_begin,
110     const struct timeval  *tv_end)
111 {
112   ts_dest->tv_sec = tv_begin->tv_sec + ts_int->tv_sec;
113   ts_dest->tv_nsec = (tv_begin->tv_usec * 1000) + ts_int->tv_nsec;
114   time_normalize (ts_dest);
115
116   /* Assure that `(begin + interval) > end'.
117    * This may seem overly complicated, but `tv_sec' is of type `time_t'
118    * which may be `unsigned. *sigh* */
119   if ((tv_end->tv_sec > ts_dest->tv_sec)
120       || ((tv_end->tv_sec == ts_dest->tv_sec)
121         && ((tv_end->tv_usec * 1000) > ts_dest->tv_nsec)))
122   {
123     ts_dest->tv_sec = tv_end->tv_sec;
124     ts_dest->tv_nsec = 1000 * tv_end->tv_usec;
125   }
126
127   time_normalize (ts_dest);
128 } /* }}} void time_calc */
129
130 static void *ping_thread (void *arg) /* {{{ */
131 {
132   static pingobj_t *pingobj = NULL;
133
134   struct timeval  tv_begin;
135   struct timeval  tv_end;
136   struct timespec ts_wait;
137   struct timespec ts_int;
138
139   hostlist_t *hl;
140   int status;
141
142   pthread_mutex_lock (&ping_lock);
143
144   pingobj = ping_construct ();
145   if (pingobj == NULL)
146   {
147     ERROR ("ping plugin: ping_construct failed.");
148     ping_thread_error = 1;
149     pthread_mutex_unlock (&ping_lock);
150     return ((void *) -1);
151   }
152
153   ping_setopt (pingobj, PING_OPT_TIMEOUT, (void *) &ping_timeout);
154   ping_setopt (pingobj, PING_OPT_TTL, (void *) &ping_ttl);
155
156   /* Add all the hosts to the ping object. */
157   status = 0;
158   for (hl = hostlist_head; hl != NULL; hl = hl->next)
159   {
160     int tmp_status;
161     tmp_status = ping_host_add (pingobj, hl->host);
162     if (tmp_status != 0)
163       WARNING ("ping plugin: ping_host_add (%s) failed.", hl->host);
164     else
165       status++;
166   }
167
168   if (status == 0)
169   {
170     ERROR ("ping plugin: No host could be added to ping object. Giving up.");
171     ping_thread_error = 1;
172     pthread_mutex_unlock (&ping_lock);
173     return ((void *) -1);
174   }
175
176   /* Set up `ts_int' */
177   {
178     double temp_sec;
179     double temp_nsec;
180
181     temp_nsec = modf (ping_interval, &temp_sec);
182     ts_int.tv_sec  = (time_t) temp_sec;
183     ts_int.tv_nsec = (long) (temp_nsec * 1000000000L);
184   }
185
186   while (ping_thread_loop > 0)
187   {
188     pingobj_iter_t *iter;
189     int status;
190
191     if (gettimeofday (&tv_begin, NULL) < 0)
192     {
193       ERROR ("ping plugin: gettimeofday failed");
194       ping_thread_error = 1;
195       break;
196     }
197
198     pthread_mutex_unlock (&ping_lock);
199
200     status = ping_send (pingobj);
201     if (status < 0)
202     {
203       ERROR ("ping plugin: ping_send failed: %s", ping_get_error (pingobj));
204       pthread_mutex_lock (&ping_lock);
205       ping_thread_error = 1;
206       break;
207     }
208
209     pthread_mutex_lock (&ping_lock);
210
211     if (ping_thread_loop <= 0)
212       break;
213
214     for (iter = ping_iterator_get (pingobj);
215         iter != NULL;
216         iter = ping_iterator_next (iter))
217     { /* {{{ */
218       char userhost[NI_MAXHOST];
219       double latency;
220       size_t param_size;
221
222       param_size = sizeof (userhost);
223       status = ping_iterator_get_info (iter,
224 #ifdef PING_INFO_USERNAME
225           PING_INFO_USERNAME,
226 #else
227           PING_INFO_HOSTNAME,
228 #endif
229           userhost, &param_size);
230       if (status != 0)
231       {
232         WARNING ("ping plugin: ping_iterator_get_info failed: %s",
233             ping_get_error (pingobj));
234         continue;
235       }
236
237       for (hl = hostlist_head; hl != NULL; hl = hl->next)
238         if (strcmp (userhost, hl->host) == 0)
239           break;
240
241       if (hl == NULL)
242       {
243         WARNING ("ping plugin: Cannot find host %s.", userhost);
244         continue;
245       }
246
247       param_size = sizeof (latency);
248       status = ping_iterator_get_info (iter, PING_INFO_LATENCY,
249           (void *) &latency, &param_size);
250       if (status != 0)
251       {
252         WARNING ("ping plugin: ping_iterator_get_info failed: %s",
253             ping_get_error (pingobj));
254         continue;
255       }
256
257       hl->pkg_sent++;
258       if (latency >= 0.0)
259       {
260         hl->pkg_recv++;
261         hl->latency_total += latency;
262         hl->latency_squared += (latency * latency);
263       }
264     } /* }}} for (iter) */
265
266     if (gettimeofday (&tv_end, NULL) < 0)
267     {
268       ERROR ("ping plugin: gettimeofday failed");
269       ping_thread_error = 1;
270       break;
271     }
272
273     /* Calculate the absolute time until which to wait and store it in
274      * `ts_wait'. */
275     time_calc (&ts_wait, &ts_int, &tv_begin, &tv_end);
276
277     status = pthread_cond_timedwait (&ping_cond, &ping_lock, &ts_wait);
278     if (ping_thread_loop <= 0)
279       break;
280   } /* while (ping_thread_loop > 0) */
281
282   pthread_mutex_unlock (&ping_lock);
283   ping_destroy (pingobj);
284
285   return ((void *) 0);
286 } /* }}} void *ping_thread */
287
288 static int start_thread (void) /* {{{ */
289 {
290   int status;
291
292   pthread_mutex_lock (&ping_lock);
293
294   if (ping_thread_loop != 0)
295   {
296     pthread_mutex_unlock (&ping_lock);
297     return (-1);
298   }
299
300   ping_thread_loop = 1;
301   ping_thread_error = 0;
302   status = pthread_create (&ping_thread_id, /* attr = */ NULL,
303       ping_thread, /* arg = */ (void *) 0);
304   if (status != 0)
305   {
306     ping_thread_loop = 0;
307     ERROR ("ping plugin: Starting thread failed.");
308     pthread_mutex_unlock (&ping_lock);
309     return (-1);
310   }
311     
312   pthread_mutex_unlock (&ping_lock);
313   return (0);
314 } /* }}} int start_thread */
315
316 static int stop_thread (void) /* {{{ */
317 {
318   int status;
319
320   pthread_mutex_lock (&ping_lock);
321
322   if (ping_thread_loop == 0)
323   {
324     pthread_mutex_unlock (&ping_lock);
325     return (-1);
326   }
327
328   ping_thread_loop = 0;
329   pthread_cond_broadcast (&ping_cond);
330   pthread_mutex_unlock (&ping_lock);
331
332   status = pthread_join (ping_thread_id, /* return = */ NULL);
333   if (status != 0)
334   {
335     ERROR ("ping plugin: Stopping thread failed.");
336     status = -1;
337   }
338
339   memset (&ping_thread_id, 0, sizeof (ping_thread_id));
340   ping_thread_error = 0;
341
342   return (status);
343 } /* }}} int stop_thread */
344
345 static int ping_init (void) /* {{{ */
346 {
347   if (hostlist_head == NULL)
348   {
349     NOTICE ("ping plugin: No hosts have been configured.");
350     return (-1);
351   }
352
353   if (ping_timeout > ping_interval)
354   {
355     ping_timeout = 0.9 * ping_interval;
356     WARNING ("ping plugin: Timeout is greater than interval. "
357         "Will use a timeout of %gs.", ping_timeout);
358   }
359
360   if (start_thread () != 0)
361     return (-1);
362
363   return (0);
364 } /* }}} int ping_init */
365
366 static int ping_config (const char *key, const char *value) /* {{{ */
367 {
368   if (strcasecmp (key, "Host") == 0)
369   {
370     hostlist_t *hl;
371     char *host;
372
373     hl = (hostlist_t *) malloc (sizeof (hostlist_t));
374     if (hl == NULL)
375     {
376       char errbuf[1024];
377       ERROR ("ping plugin: malloc failed: %s",
378           sstrerror (errno, errbuf, sizeof (errbuf)));
379       return (1);
380     }
381
382     host = strdup (value);
383     if (host == NULL)
384     {
385       char errbuf[1024];
386       sfree (hl);
387       ERROR ("ping plugin: strdup failed: %s",
388           sstrerror (errno, errbuf, sizeof (errbuf)));
389       return (1);
390     }
391
392     hl->host = host;
393     hl->pkg_sent = 0;
394     hl->pkg_recv = 0;
395     hl->latency_total = 0.0;
396     hl->latency_squared = 0.0;
397     hl->next = hostlist_head;
398     hostlist_head = hl;
399   }
400   else if (strcasecmp (key, "TTL") == 0)
401   {
402     int ttl = atoi (value);
403     if ((ttl > 0) && (ttl <= 255))
404       ping_ttl = ttl;
405     else
406       WARNING ("ping plugin: Ignoring invalid TTL %i.", ttl);
407   }
408   else if (strcasecmp (key, "Interval") == 0)
409   {
410     double tmp;
411
412     tmp = atof (value);
413     if (tmp > 0.0)
414       ping_interval = tmp;
415     else
416       WARNING ("ping plugin: Ignoring invalid interval %g (%s)",
417           tmp, value);
418   }
419   else if (strcasecmp (key, "Timeout") == 0)
420   {
421     double tmp;
422
423     tmp = atof (value);
424     if (tmp > 0.0)
425       ping_timeout = tmp;
426     else
427       WARNING ("ping plugin: Ignoring invalid timeout %g (%s)",
428           tmp, value);
429   }
430   else
431   {
432     return (-1);
433   }
434
435   return (0);
436 } /* }}} int ping_config */
437
438 static void submit (const char *host, const char *type, /* {{{ */
439     gauge_t value)
440 {
441   value_t values[1];
442   value_list_t vl = VALUE_LIST_INIT;
443
444   values[0].gauge = value;
445
446   vl.values = values;
447   vl.values_len = 1;
448   sstrncpy (vl.host, hostname_g, sizeof (vl.host));
449   sstrncpy (vl.plugin, "ping", sizeof (vl.plugin));
450   sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
451   sstrncpy (vl.type_instance, host, sizeof (vl.type_instance));
452   sstrncpy (vl.type, type, sizeof (vl.type));
453
454   plugin_dispatch_values (&vl);
455 } /* }}} void ping_submit */
456
457 static int ping_read (void) /* {{{ */
458 {
459   hostlist_t *hl;
460
461   if (ping_thread_error != 0)
462   {
463     ERROR ("ping plugin: The ping thread had a problem. Restarting it.");
464
465     stop_thread ();
466
467     for (hl = hostlist_head; hl != NULL; hl = hl->next)
468     {
469       hl->pkg_sent = 0;
470       hl->pkg_recv = 0;
471       hl->latency_total = 0.0;
472       hl->latency_squared = 0.0;
473     }
474
475     start_thread ();
476
477     return (-1);
478   } /* if (ping_thread_error != 0) */
479
480   for (hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
481   {
482     uint32_t pkg_sent;
483     uint32_t pkg_recv;
484     double latency_total;
485     double latency_squared;
486
487     double latency_average;
488     double latency_stddev;
489
490     double droprate;
491
492     /* Locking here works, because the structure of the linked list is only
493      * changed during configure and shutdown. */
494     pthread_mutex_lock (&ping_lock);
495
496     pkg_sent = hl->pkg_sent;
497     pkg_recv = hl->pkg_recv;
498     latency_total = hl->latency_total;
499     latency_squared = hl->latency_squared;
500
501     hl->pkg_sent = 0;
502     hl->pkg_recv = 0;
503     hl->latency_total = 0.0;
504     hl->latency_squared = 0.0;
505
506     pthread_mutex_unlock (&ping_lock);
507
508     /* This e. g. happens when starting up. */
509     if (pkg_sent == 0)
510     {
511       DEBUG ("ping plugin: No packages for host %s have been sent.",
512           hl->host);
513       continue;
514     }
515
516     /* Calculate average. Beware of division by zero. */
517     if (pkg_recv == 0)
518       latency_average = NAN;
519     else
520       latency_average = latency_total / ((double) pkg_recv);
521
522     /* Calculate standard deviation. Beware even more of division by zero. */
523     if (pkg_recv == 0)
524       latency_stddev = NAN;
525     else if (pkg_recv == 1)
526       latency_stddev = 0.0;
527     else
528       latency_stddev = sqrt (((((double) pkg_recv) * latency_squared)
529           - (latency_total * latency_total))
530           / ((double) (pkg_recv * (pkg_recv - 1))));
531
532     /* Calculate drop rate. */
533     droprate = ((double) (pkg_sent - pkg_recv)) / ((double) pkg_sent);
534
535     submit (hl->host, "ping", latency_average);
536     submit (hl->host, "ping_stddev", latency_stddev);
537     submit (hl->host, "ping_droprate", droprate);
538   } /* }}} for (hl = hostlist_head; hl != NULL; hl = hl->next) */
539
540   return (0);
541 } /* }}} int ping_read */
542
543 static int ping_shutdown (void) /* {{{ */
544 {
545   hostlist_t *hl;
546
547   INFO ("ping plugin: Shutting down thread.");
548   if (stop_thread () < 0)
549     return (-1);
550
551   hl = hostlist_head;
552   while (hl != NULL)
553   {
554     hostlist_t *hl_next;
555
556     hl_next = hl->next;
557
558     sfree (hl->host);
559     sfree (hl);
560
561     hl = hl_next;
562   }
563
564   return (0);
565 } /* }}} int ping_shutdown */
566
567 void module_register (void)
568 {
569   plugin_register_config ("ping", ping_config,
570       config_keys, config_keys_num);
571   plugin_register_init ("ping", ping_init);
572   plugin_register_read ("ping", ping_read);
573   plugin_register_shutdown ("ping", ping_shutdown);
574 } /* void module_register */
575
576 /* vim: set sw=2 sts=2 et fdm=marker : */