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