1 /**
2 * collectd - src/ping.c
3 * Copyright (C) 2005-2012 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 **/
27 #include "collectd.h"
29 #include "common.h"
30 #include "plugin.h"
31 #include "utils_complain.h"
33 #include <netinet/in.h>
34 #if HAVE_NETDB_H
35 #include <netdb.h> /* NI_MAXHOST */
36 #endif
38 #ifdef HAVE_SYS_CAPABILITY_H
39 #include <sys/capability.h>
40 #endif
42 #include <oping.h>
44 #ifndef NI_MAXHOST
45 #define NI_MAXHOST 1025
46 #endif
48 #if defined(OPING_VERSION) && (OPING_VERSION >= 1003000)
49 #define HAVE_OPING_1_3
50 #endif
52 /*
53 * Private data types
54 */
55 struct hostlist_s {
56 char *host;
58 uint32_t pkg_sent;
59 uint32_t pkg_recv;
60 uint32_t pkg_missed;
62 double latency_total;
63 double latency_squared;
65 struct hostlist_s *next;
66 };
67 typedef struct hostlist_s hostlist_t;
69 /*
70 * Private variables
71 */
72 static hostlist_t *hostlist_head = NULL;
74 static char *ping_source = NULL;
75 #ifdef HAVE_OPING_1_3
76 static char *ping_device = NULL;
77 #endif
78 static char *ping_data = NULL;
79 static int ping_ttl = PING_DEF_TTL;
80 static double ping_interval = 1.0;
81 static double ping_timeout = 0.9;
82 static int ping_max_missed = -1;
84 static int ping_thread_loop = 0;
85 static int ping_thread_error = 0;
86 static pthread_t ping_thread_id;
87 static pthread_mutex_t ping_lock = PTHREAD_MUTEX_INITIALIZER;
88 static pthread_cond_t ping_cond = PTHREAD_COND_INITIALIZER;
90 static const char *config_keys[] = {"Host", "SourceAddress",
91 #ifdef HAVE_OPING_1_3
92 "Device",
93 #endif
94 "Size", "TTL", "Interval",
95 "Timeout", "MaxMissed"};
96 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
98 /*
99 * Private functions
100 */
101 /* Assure that `ts->tv_nsec' is in the range 0 .. 999999999 */
102 static void time_normalize(struct timespec *ts) /* {{{ */
103 {
104 while (ts->tv_nsec < 0) {
105 if (ts->tv_sec == 0) {
106 ts->tv_nsec = 0;
107 return;
108 }
110 ts->tv_sec -= 1;
111 ts->tv_nsec += 1000000000;
112 }
114 while (ts->tv_nsec >= 1000000000) {
115 ts->tv_sec += 1;
116 ts->tv_nsec -= 1000000000;
117 }
118 } /* }}} void time_normalize */
120 /* Add `ts_int' to `tv_begin' and store the result in `ts_dest'. If the result
121 * is larger than `tv_end', copy `tv_end' to `ts_dest' instead. */
122 static void time_calc(struct timespec *ts_dest, /* {{{ */
123 const struct timespec *ts_int,
124 const struct timeval *tv_begin,
125 const struct timeval *tv_end) {
126 ts_dest->tv_sec = tv_begin->tv_sec + ts_int->tv_sec;
127 ts_dest->tv_nsec = (tv_begin->tv_usec * 1000) + ts_int->tv_nsec;
128 time_normalize(ts_dest);
130 /* Assure that `(begin + interval) > end'.
131 * This may seem overly complicated, but `tv_sec' is of type `time_t'
132 * which may be `unsigned. *sigh* */
133 if ((tv_end->tv_sec > ts_dest->tv_sec) ||
134 ((tv_end->tv_sec == ts_dest->tv_sec) &&
135 ((tv_end->tv_usec * 1000) > ts_dest->tv_nsec))) {
136 ts_dest->tv_sec = tv_end->tv_sec;
137 ts_dest->tv_nsec = 1000 * tv_end->tv_usec;
138 }
140 time_normalize(ts_dest);
141 } /* }}} void time_calc */
143 static int ping_dispatch_all(pingobj_t *pingobj) /* {{{ */
144 {
145 hostlist_t *hl;
146 int status;
148 for (pingobj_iter_t *iter = ping_iterator_get(pingobj); iter != NULL;
149 iter = ping_iterator_next(iter)) { /* {{{ */
150 char userhost[NI_MAXHOST];
151 double latency;
152 size_t param_size;
154 param_size = sizeof(userhost);
155 status = ping_iterator_get_info(iter,
156 #ifdef PING_INFO_USERNAME
157 PING_INFO_USERNAME,
158 #else
159 PING_INFO_HOSTNAME,
160 #endif
161 userhost, ¶m_size);
162 if (status != 0) {
163 WARNING("ping plugin: ping_iterator_get_info failed: %s",
164 ping_get_error(pingobj));
165 continue;
166 }
168 for (hl = hostlist_head; hl != NULL; hl = hl->next)
169 if (strcmp(userhost, hl->host) == 0)
170 break;
172 if (hl == NULL) {
173 WARNING("ping plugin: Cannot find host %s.", userhost);
174 continue;
175 }
177 param_size = sizeof(latency);
178 status = ping_iterator_get_info(iter, PING_INFO_LATENCY, (void *)&latency,
179 ¶m_size);
180 if (status != 0) {
181 WARNING("ping plugin: ping_iterator_get_info failed: %s",
182 ping_get_error(pingobj));
183 continue;
184 }
186 hl->pkg_sent++;
187 if (latency >= 0.0) {
188 hl->pkg_recv++;
189 hl->latency_total += latency;
190 hl->latency_squared += (latency * latency);
192 /* reset missed packages counter */
193 hl->pkg_missed = 0;
194 } else
195 hl->pkg_missed++;
197 /* if the host did not answer our last N packages, trigger a resolv. */
198 if ((ping_max_missed >= 0) &&
199 (hl->pkg_missed >= ((uint32_t)ping_max_missed))) { /* {{{ */
200 /* we reset the missed package counter here, since we only want to
201 * trigger a resolv every N packages and not every package _AFTER_ N
202 * missed packages */
203 hl->pkg_missed = 0;
205 WARNING("ping plugin: host %s has not answered %d PING requests,"
206 " triggering resolve",
207 hl->host, ping_max_missed);
209 /* we trigger the resolv simply be removeing and adding the host to our
210 * ping object */
211 status = ping_host_remove(pingobj, hl->host);
212 if (status != 0) {
213 WARNING("ping plugin: ping_host_remove (%s) failed.", hl->host);
214 } else {
215 status = ping_host_add(pingobj, hl->host);
216 if (status != 0)
217 ERROR("ping plugin: ping_host_add (%s) failed.", hl->host);
218 }
219 } /* }}} ping_max_missed */
220 } /* }}} for (iter) */
222 return (0);
223 } /* }}} int ping_dispatch_all */
225 static void *ping_thread(void *arg) /* {{{ */
226 {
227 pingobj_t *pingobj = NULL;
229 struct timeval tv_begin;
230 struct timeval tv_end;
231 struct timespec ts_wait;
232 struct timespec ts_int;
234 int count;
236 c_complain_t complaint = C_COMPLAIN_INIT_STATIC;
238 pthread_mutex_lock(&ping_lock);
240 pingobj = ping_construct();
241 if (pingobj == NULL) {
242 ERROR("ping plugin: ping_construct failed.");
243 ping_thread_error = 1;
244 pthread_mutex_unlock(&ping_lock);
245 return ((void *)-1);
246 }
248 if (ping_source != NULL)
249 if (ping_setopt(pingobj, PING_OPT_SOURCE, (void *)ping_source) != 0)
250 ERROR("ping plugin: Failed to set source address: %s",
251 ping_get_error(pingobj));
253 #ifdef HAVE_OPING_1_3
254 if (ping_device != NULL)
255 if (ping_setopt(pingobj, PING_OPT_DEVICE, (void *)ping_device) != 0)
256 ERROR("ping plugin: Failed to set device: %s", ping_get_error(pingobj));
257 #endif
259 ping_setopt(pingobj, PING_OPT_TIMEOUT, (void *)&ping_timeout);
260 ping_setopt(pingobj, PING_OPT_TTL, (void *)&ping_ttl);
262 if (ping_data != NULL)
263 ping_setopt(pingobj, PING_OPT_DATA, (void *)ping_data);
265 /* Add all the hosts to the ping object. */
266 count = 0;
267 for (hostlist_t *hl = hostlist_head; hl != NULL; hl = hl->next) {
268 int tmp_status;
269 tmp_status = ping_host_add(pingobj, hl->host);
270 if (tmp_status != 0)
271 WARNING("ping plugin: ping_host_add (%s) failed: %s", hl->host,
272 ping_get_error(pingobj));
273 else
274 count++;
275 }
277 if (count == 0) {
278 ERROR("ping plugin: No host could be added to ping object. Giving up.");
279 ping_thread_error = 1;
280 pthread_mutex_unlock(&ping_lock);
281 return ((void *)-1);
282 }
284 /* Set up `ts_int' */
285 {
286 double temp_sec;
287 double temp_nsec;
289 temp_nsec = modf(ping_interval, &temp_sec);
290 ts_int.tv_sec = (time_t)temp_sec;
291 ts_int.tv_nsec = (long)(temp_nsec * 1000000000L);
292 }
294 while (ping_thread_loop > 0) {
295 int status;
296 _Bool send_successful = 0;
298 if (gettimeofday(&tv_begin, NULL) < 0) {
299 char errbuf[1024];
300 ERROR("ping plugin: gettimeofday failed: %s",
301 sstrerror(errno, errbuf, sizeof(errbuf)));
302 ping_thread_error = 1;
303 break;
304 }
306 pthread_mutex_unlock(&ping_lock);
308 status = ping_send(pingobj);
309 if (status < 0) {
310 c_complain(LOG_ERR, &complaint, "ping plugin: ping_send failed: %s",
311 ping_get_error(pingobj));
312 } else {
313 c_release(LOG_NOTICE, &complaint, "ping plugin: ping_send succeeded.");
314 send_successful = 1;
315 }
317 pthread_mutex_lock(&ping_lock);
319 if (ping_thread_loop <= 0)
320 break;
322 if (send_successful)
323 (void)ping_dispatch_all(pingobj);
325 if (gettimeofday(&tv_end, NULL) < 0) {
326 char errbuf[1024];
327 ERROR("ping plugin: gettimeofday failed: %s",
328 sstrerror(errno, errbuf, sizeof(errbuf)));
329 ping_thread_error = 1;
330 break;
331 }
333 /* Calculate the absolute time until which to wait and store it in
334 * `ts_wait'. */
335 time_calc(&ts_wait, &ts_int, &tv_begin, &tv_end);
337 pthread_cond_timedwait(&ping_cond, &ping_lock, &ts_wait);
338 if (ping_thread_loop <= 0)
339 break;
340 } /* while (ping_thread_loop > 0) */
342 pthread_mutex_unlock(&ping_lock);
343 ping_destroy(pingobj);
345 return ((void *)0);
346 } /* }}} void *ping_thread */
348 static int start_thread(void) /* {{{ */
349 {
350 int status;
352 pthread_mutex_lock(&ping_lock);
354 if (ping_thread_loop != 0) {
355 pthread_mutex_unlock(&ping_lock);
356 return (0);
357 }
359 ping_thread_loop = 1;
360 ping_thread_error = 0;
361 status = plugin_thread_create(&ping_thread_id, /* attr = */ NULL, ping_thread,
362 /* arg = */ (void *)0);
363 if (status != 0) {
364 ping_thread_loop = 0;
365 ERROR("ping plugin: Starting thread failed.");
366 pthread_mutex_unlock(&ping_lock);
367 return (-1);
368 }
370 pthread_mutex_unlock(&ping_lock);
371 return (0);
372 } /* }}} int start_thread */
374 static int stop_thread(void) /* {{{ */
375 {
376 int status;
378 pthread_mutex_lock(&ping_lock);
380 if (ping_thread_loop == 0) {
381 pthread_mutex_unlock(&ping_lock);
382 return (-1);
383 }
385 ping_thread_loop = 0;
386 pthread_cond_broadcast(&ping_cond);
387 pthread_mutex_unlock(&ping_lock);
389 status = pthread_join(ping_thread_id, /* return = */ NULL);
390 if (status != 0) {
391 ERROR("ping plugin: Stopping thread failed.");
392 status = -1;
393 }
395 pthread_mutex_lock(&ping_lock);
396 memset(&ping_thread_id, 0, sizeof(ping_thread_id));
397 ping_thread_error = 0;
398 pthread_mutex_unlock(&ping_lock);
400 return (status);
401 } /* }}} int stop_thread */
403 static int ping_init(void) /* {{{ */
404 {
405 if (hostlist_head == NULL) {
406 NOTICE("ping plugin: No hosts have been configured.");
407 return (-1);
408 }
410 if (ping_timeout > ping_interval) {
411 ping_timeout = 0.9 * ping_interval;
412 WARNING("ping plugin: Timeout is greater than interval. "
413 "Will use a timeout of %gs.",
414 ping_timeout);
415 }
417 #if defined(HAVE_SYS_CAPABILITY_H) && defined(CAP_NET_RAW)
418 if (check_capability(CAP_NET_RAW) != 0) {
419 if (getuid() == 0)
420 WARNING("ping plugin: Running collectd as root, but the CAP_NET_RAW "
421 "capability is missing. The plugin's read function will probably "
422 "fail. Is your init system dropping capabilities?");
423 else
424 WARNING("ping plugin: collectd doesn't have the CAP_NET_RAW capability. "
425 "If you don't want to run collectd as root, try running \"setcap "
426 "cap_net_raw=ep\" on the collectd binary.");
427 }
428 #endif
430 return (start_thread());
431 } /* }}} int ping_init */
433 static int config_set_string(const char *name, /* {{{ */
434 char **var, const char *value) {
435 char *tmp;
437 tmp = strdup(value);
438 if (tmp == NULL) {
439 char errbuf[1024];
440 ERROR("ping plugin: Setting `%s' to `%s' failed: strdup failed: %s", name,
441 value, sstrerror(errno, errbuf, sizeof(errbuf)));
442 return (1);
443 }
445 if (*var != NULL)
446 free(*var);
447 *var = tmp;
448 return (0);
449 } /* }}} int config_set_string */
451 static int ping_config(const char *key, const char *value) /* {{{ */
452 {
453 if (strcasecmp(key, "Host") == 0) {
454 hostlist_t *hl;
455 char *host;
457 hl = malloc(sizeof(*hl));
458 if (hl == NULL) {
459 char errbuf[1024];
460 ERROR("ping plugin: malloc failed: %s",
461 sstrerror(errno, errbuf, sizeof(errbuf)));
462 return (1);
463 }
465 host = strdup(value);
466 if (host == NULL) {
467 char errbuf[1024];
468 sfree(hl);
469 ERROR("ping plugin: strdup failed: %s",
470 sstrerror(errno, errbuf, sizeof(errbuf)));
471 return (1);
472 }
474 hl->host = host;
475 hl->pkg_sent = 0;
476 hl->pkg_recv = 0;
477 hl->pkg_missed = 0;
478 hl->latency_total = 0.0;
479 hl->latency_squared = 0.0;
480 hl->next = hostlist_head;
481 hostlist_head = hl;
482 } else if (strcasecmp(key, "SourceAddress") == 0) {
483 int status = config_set_string(key, &ping_source, value);
484 if (status != 0)
485 return (status);
486 }
487 #ifdef HAVE_OPING_1_3
488 else if (strcasecmp(key, "Device") == 0) {
489 int status = config_set_string(key, &ping_device, value);
490 if (status != 0)
491 return (status);
492 }
493 #endif
494 else if (strcasecmp(key, "TTL") == 0) {
495 int ttl = atoi(value);
496 if ((ttl > 0) && (ttl <= 255))
497 ping_ttl = ttl;
498 else
499 WARNING("ping plugin: Ignoring invalid TTL %i.", ttl);
500 } else if (strcasecmp(key, "Interval") == 0) {
501 double tmp;
503 tmp = atof(value);
504 if (tmp > 0.0)
505 ping_interval = tmp;
506 else
507 WARNING("ping plugin: Ignoring invalid interval %g (%s)", tmp, value);
508 } else if (strcasecmp(key, "Size") == 0) {
509 size_t size = (size_t)atoi(value);
511 /* Max IP packet size - (IPv6 + ICMP) = 65535 - (40 + 8) = 65487 */
512 if (size <= 65487) {
513 sfree(ping_data);
514 ping_data = malloc(size + 1);
515 if (ping_data == NULL) {
516 ERROR("ping plugin: malloc failed.");
517 return (1);
518 }
520 /* Note: By default oping is using constant string
521 * "liboping -- ICMP ping library <http://octo.it/liboping/>"
522 * which is exactly 56 bytes.
523 *
524 * Optimally we would follow the ping(1) behaviour, but we
525 * cannot use byte 00 or start data payload at exactly same
526 * location, due to oping library limitations. */
527 for (size_t i = 0; i < size; i++) /* {{{ */
528 {
529 /* This restricts data pattern to be only composed of easily
530 * printable characters, and not NUL character. */
531 ping_data[i] = ('0' + i % 64);
532 } /* }}} for (i = 0; i < size; i++) */
533 ping_data[size] = 0;
534 } else
535 WARNING("ping plugin: Ignoring invalid Size %zu.", size);
536 } else if (strcasecmp(key, "Timeout") == 0) {
537 double tmp;
539 tmp = atof(value);
540 if (tmp > 0.0)
541 ping_timeout = tmp;
542 else
543 WARNING("ping plugin: Ignoring invalid timeout %g (%s)", tmp, value);
544 } else if (strcasecmp(key, "MaxMissed") == 0) {
545 ping_max_missed = atoi(value);
546 if (ping_max_missed < 0)
547 INFO("ping plugin: MaxMissed < 0, disabled re-resolving of hosts");
548 } else {
549 return (-1);
550 }
552 return (0);
553 } /* }}} int ping_config */
555 static void submit(const char *host, const char *type, /* {{{ */
556 gauge_t value) {
557 value_t values[1];
558 value_list_t vl = VALUE_LIST_INIT;
560 values[0].gauge = value;
562 vl.values = values;
563 vl.values_len = 1;
564 sstrncpy(vl.host, hostname_g, sizeof(vl.host));
565 sstrncpy(vl.plugin, "ping", sizeof(vl.plugin));
566 sstrncpy(vl.plugin_instance, "", sizeof(vl.plugin_instance));
567 sstrncpy(vl.type_instance, host, sizeof(vl.type_instance));
568 sstrncpy(vl.type, type, sizeof(vl.type));
570 plugin_dispatch_values(&vl);
571 } /* }}} void ping_submit */
573 static int ping_read(void) /* {{{ */
574 {
575 if (ping_thread_error != 0) {
576 ERROR("ping plugin: The ping thread had a problem. Restarting it.");
578 stop_thread();
580 for (hostlist_t *hl = hostlist_head; hl != NULL; hl = hl->next) {
581 hl->pkg_sent = 0;
582 hl->pkg_recv = 0;
583 hl->latency_total = 0.0;
584 hl->latency_squared = 0.0;
585 }
587 start_thread();
589 return (-1);
590 } /* if (ping_thread_error != 0) */
592 for (hostlist_t *hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
593 {
594 uint32_t pkg_sent;
595 uint32_t pkg_recv;
596 double latency_total;
597 double latency_squared;
599 double latency_average;
600 double latency_stddev;
602 double droprate;
604 /* Locking here works, because the structure of the linked list is only
605 * changed during configure and shutdown. */
606 pthread_mutex_lock(&ping_lock);
608 pkg_sent = hl->pkg_sent;
609 pkg_recv = hl->pkg_recv;
610 latency_total = hl->latency_total;
611 latency_squared = hl->latency_squared;
613 hl->pkg_sent = 0;
614 hl->pkg_recv = 0;
615 hl->latency_total = 0.0;
616 hl->latency_squared = 0.0;
618 pthread_mutex_unlock(&ping_lock);
620 /* This e. g. happens when starting up. */
621 if (pkg_sent == 0) {
622 DEBUG("ping plugin: No packages for host %s have been sent.", hl->host);
623 continue;
624 }
626 /* Calculate average. Beware of division by zero. */
627 if (pkg_recv == 0)
628 latency_average = NAN;
629 else
630 latency_average = latency_total / ((double)pkg_recv);
632 /* Calculate standard deviation. Beware even more of division by zero. */
633 if (pkg_recv == 0)
634 latency_stddev = NAN;
635 else if (pkg_recv == 1)
636 latency_stddev = 0.0;
637 else
638 latency_stddev = sqrt(((((double)pkg_recv) * latency_squared) -
639 (latency_total * latency_total)) /
640 ((double)(pkg_recv * (pkg_recv - 1))));
642 /* Calculate drop rate. */
643 droprate = ((double)(pkg_sent - pkg_recv)) / ((double)pkg_sent);
645 submit(hl->host, "ping", latency_average);
646 submit(hl->host, "ping_stddev", latency_stddev);
647 submit(hl->host, "ping_droprate", droprate);
648 } /* }}} for (hl = hostlist_head; hl != NULL; hl = hl->next) */
650 return (0);
651 } /* }}} int ping_read */
653 static int ping_shutdown(void) /* {{{ */
654 {
655 hostlist_t *hl;
657 INFO("ping plugin: Shutting down thread.");
658 if (stop_thread() < 0)
659 return (-1);
661 hl = hostlist_head;
662 while (hl != NULL) {
663 hostlist_t *hl_next;
665 hl_next = hl->next;
667 sfree(hl->host);
668 sfree(hl);
670 hl = hl_next;
671 }
673 if (ping_data != NULL) {
674 free(ping_data);
675 ping_data = NULL;
676 }
678 return (0);
679 } /* }}} int ping_shutdown */
681 void module_register(void) {
682 plugin_register_config("ping", ping_config, config_keys, config_keys_num);
683 plugin_register_init("ping", ping_init);
684 plugin_register_read("ping", ping_read);
685 plugin_register_shutdown("ping", ping_shutdown);
686 } /* void module_register */
688 /* vim: set sw=2 sts=2 et fdm=marker : */