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