Merge pull request #2711 from dago/kstat
[collectd.git] / src / daemon / common.c
1 /**
2  * collectd - src/common.c
3  * Copyright (C) 2005-2014  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  *   Niki W. Waibel <niki.waibel@gmx.net>
26  *   Sebastian Harl <sh at tokkee.org>
27  *   Michał Mirosław <mirq-linux at rere.qmqm.pl>
28 **/
29
30 #if HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include "collectd.h"
35
36 #include "common.h"
37 #include "plugin.h"
38 #include "utils_cache.h"
39
40 /* for getaddrinfo */
41 #include <netdb.h>
42 #include <sys/types.h>
43
44 #include <poll.h>
45
46 #if HAVE_NETINET_IN_H
47 #include <netinet/in.h>
48 #endif
49
50 #if HAVE_NETINET_TCP_H
51 #include <netinet/tcp.h>
52 #endif
53
54 /* for ntohl and htonl */
55 #if HAVE_ARPA_INET_H
56 #include <arpa/inet.h>
57 #endif
58
59 #if HAVE_CAPABILITY
60 #include <sys/capability.h>
61 #endif
62
63 #if HAVE_KSTAT_H
64 #include <kstat.h>
65 #endif
66
67 #ifdef HAVE_LIBKSTAT
68 extern kstat_ctl_t *kc;
69 #endif
70
71 /* AIX doesn't have MSG_DONTWAIT */
72 #ifndef MSG_DONTWAIT
73 #define MSG_DONTWAIT MSG_NONBLOCK
74 #endif
75
76 #if !HAVE_GETPWNAM_R
77 static pthread_mutex_t getpwnam_r_lock = PTHREAD_MUTEX_INITIALIZER;
78 #endif
79
80 #if !HAVE_STRERROR_R
81 static pthread_mutex_t strerror_r_lock = PTHREAD_MUTEX_INITIALIZER;
82 #endif
83
84 char *sstrncpy(char *dest, const char *src, size_t n) {
85   strncpy(dest, src, n);
86   dest[n - 1] = '\0';
87
88   return dest;
89 } /* char *sstrncpy */
90
91 char *ssnprintf_alloc(char const *format, ...) /* {{{ */
92 {
93   char static_buffer[1024] = "";
94   char *alloc_buffer;
95   size_t alloc_buffer_size;
96   int status;
97   va_list ap;
98
99   /* Try printing into the static buffer. In many cases it will be
100    * sufficiently large and we can simply return a strdup() of this
101    * buffer. */
102   va_start(ap, format);
103   status = vsnprintf(static_buffer, sizeof(static_buffer), format, ap);
104   va_end(ap);
105   if (status < 0)
106     return NULL;
107
108   /* "status" does not include the null byte. */
109   alloc_buffer_size = (size_t)(status + 1);
110   if (alloc_buffer_size <= sizeof(static_buffer))
111     return strdup(static_buffer);
112
113   /* Allocate a buffer large enough to hold the string. */
114   alloc_buffer = calloc(1, alloc_buffer_size);
115   if (alloc_buffer == NULL)
116     return NULL;
117
118   /* Print again into this new buffer. */
119   va_start(ap, format);
120   status = vsnprintf(alloc_buffer, alloc_buffer_size, format, ap);
121   va_end(ap);
122   if (status < 0) {
123     sfree(alloc_buffer);
124     return NULL;
125   }
126
127   return alloc_buffer;
128 } /* }}} char *ssnprintf_alloc */
129
130 char *sstrdup(const char *s) {
131   char *r;
132   size_t sz;
133
134   if (s == NULL)
135     return NULL;
136
137   /* Do not use `strdup' here, because it's not specified in POSIX. It's
138    * ``only'' an XSI extension. */
139   sz = strlen(s) + 1;
140   r = malloc(sz);
141   if (r == NULL) {
142     ERROR("sstrdup: Out of memory.");
143     exit(3);
144   }
145   memcpy(r, s, sz);
146
147   return r;
148 } /* char *sstrdup */
149
150 /* Even though Posix requires "strerror_r" to return an "int",
151  * some systems (e.g. the GNU libc) return a "char *" _and_
152  * ignore the second argument ... -tokkee */
153 char *sstrerror(int errnum, char *buf, size_t buflen) {
154   buf[0] = '\0';
155
156 #if !HAVE_STRERROR_R
157   {
158     char *temp;
159
160     pthread_mutex_lock(&strerror_r_lock);
161
162     temp = strerror(errnum);
163     sstrncpy(buf, temp, buflen);
164
165     pthread_mutex_unlock(&strerror_r_lock);
166   }
167 /* #endif !HAVE_STRERROR_R */
168
169 #elif STRERROR_R_CHAR_P
170   {
171     char *temp;
172     temp = strerror_r(errnum, buf, buflen);
173     if (buf[0] == '\0') {
174       if ((temp != NULL) && (temp != buf) && (temp[0] != '\0'))
175         sstrncpy(buf, temp, buflen);
176       else
177         sstrncpy(buf, "strerror_r did not return "
178                       "an error message",
179                  buflen);
180     }
181   }
182 /* #endif STRERROR_R_CHAR_P */
183
184 #else
185   if (strerror_r(errnum, buf, buflen) != 0) {
186     snprintf(buf, buflen, "Error #%i; "
187                           "Additionally, strerror_r failed.",
188              errnum);
189   }
190 #endif /* STRERROR_R_CHAR_P */
191
192   return buf;
193 } /* char *sstrerror */
194
195 void *smalloc(size_t size) {
196   void *r;
197
198   if ((r = malloc(size)) == NULL) {
199     ERROR("Not enough memory.");
200     exit(3);
201   }
202
203   return r;
204 } /* void *smalloc */
205
206 #if 0
207 void sfree (void **ptr)
208 {
209         if (ptr == NULL)
210                 return;
211
212         if (*ptr != NULL)
213                 free (*ptr);
214
215         *ptr = NULL;
216 }
217 #endif
218
219 int sread(int fd, void *buf, size_t count) {
220   char *ptr;
221   size_t nleft;
222   ssize_t status;
223
224   ptr = (char *)buf;
225   nleft = count;
226
227   while (nleft > 0) {
228     status = read(fd, (void *)ptr, nleft);
229
230     if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
231       continue;
232
233     if (status < 0)
234       return status;
235
236     if (status == 0) {
237       DEBUG("Received EOF from fd %i. ", fd);
238       return -1;
239     }
240
241     assert((0 > status) || (nleft >= (size_t)status));
242
243     nleft = nleft - ((size_t)status);
244     ptr = ptr + ((size_t)status);
245   }
246
247   return 0;
248 }
249
250 int swrite(int fd, const void *buf, size_t count) {
251   const char *ptr;
252   size_t nleft;
253   ssize_t status;
254   struct pollfd pfd;
255
256   ptr = (const char *)buf;
257   nleft = count;
258
259   if (fd < 0) {
260     errno = EINVAL;
261     return errno;
262   }
263
264   /* checking for closed peer connection */
265   pfd.fd = fd;
266   pfd.events = POLLIN | POLLHUP;
267   pfd.revents = 0;
268   if (poll(&pfd, 1, 0) > 0) {
269     char buffer[32];
270     if (recv(fd, buffer, sizeof(buffer), MSG_PEEK | MSG_DONTWAIT) == 0) {
271       /* if recv returns zero (even though poll() said there is data to be
272        * read), that means the connection has been closed */
273       errno = ECONNRESET;
274       return -1;
275     }
276   }
277
278   while (nleft > 0) {
279     status = write(fd, (const void *)ptr, nleft);
280
281     if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
282       continue;
283
284     if (status < 0)
285       return errno ? errno : status;
286
287     nleft = nleft - ((size_t)status);
288     ptr = ptr + ((size_t)status);
289   }
290
291   return 0;
292 }
293
294 int strsplit(char *string, char **fields, size_t size) {
295   size_t i;
296   char *ptr;
297   char *saveptr;
298
299   i = 0;
300   ptr = string;
301   saveptr = NULL;
302   while ((fields[i] = strtok_r(ptr, " \t\r\n", &saveptr)) != NULL) {
303     ptr = NULL;
304     i++;
305
306     if (i >= size)
307       break;
308   }
309
310   return (int)i;
311 }
312
313 int strjoin(char *buffer, size_t buffer_size, char **fields, size_t fields_num,
314             const char *sep) {
315   size_t avail = 0;
316   char *ptr = buffer;
317   size_t sep_len = 0;
318
319   size_t buffer_req = 0;
320
321   if (((fields_num != 0) && (fields == NULL)) ||
322       ((buffer_size != 0) && (buffer == NULL)))
323     return -EINVAL;
324
325   if (buffer != NULL)
326     buffer[0] = 0;
327
328   if (buffer_size != 0)
329     avail = buffer_size - 1;
330
331   if (sep != NULL)
332     sep_len = strlen(sep);
333
334   for (size_t i = 0; i < fields_num; i++) {
335     size_t field_len = strlen(fields[i]);
336
337     if (i != 0)
338       buffer_req += sep_len;
339     buffer_req += field_len;
340
341     if ((i != 0) && (sep_len > 0)) {
342       if (sep_len >= avail) {
343         /* prevent subsequent iterations from writing to the
344          * buffer. */
345         avail = 0;
346         continue;
347       }
348
349       memcpy(ptr, sep, sep_len);
350
351       ptr += sep_len;
352       avail -= sep_len;
353     }
354
355     if (field_len > avail)
356       field_len = avail;
357
358     memcpy(ptr, fields[i], field_len);
359     ptr += field_len;
360
361     avail -= field_len;
362     if (ptr != NULL)
363       *ptr = 0;
364   }
365
366   return (int)buffer_req;
367 }
368
369 int escape_string(char *buffer, size_t buffer_size) {
370   char *temp;
371   size_t j;
372
373   /* Check if we need to escape at all first */
374   temp = strpbrk(buffer, " \t\"\\");
375   if (temp == NULL)
376     return 0;
377
378   if (buffer_size < 3)
379     return EINVAL;
380
381   temp = calloc(1, buffer_size);
382   if (temp == NULL)
383     return ENOMEM;
384
385   temp[0] = '"';
386   j = 1;
387
388   for (size_t i = 0; i < buffer_size; i++) {
389     if (buffer[i] == 0) {
390       break;
391     } else if ((buffer[i] == '"') || (buffer[i] == '\\')) {
392       if (j > (buffer_size - 4))
393         break;
394       temp[j] = '\\';
395       temp[j + 1] = buffer[i];
396       j += 2;
397     } else {
398       if (j > (buffer_size - 3))
399         break;
400       temp[j] = buffer[i];
401       j++;
402     }
403   }
404
405   assert((j + 1) < buffer_size);
406   temp[j] = '"';
407   temp[j + 1] = 0;
408
409   sstrncpy(buffer, temp, buffer_size);
410   sfree(temp);
411   return 0;
412 } /* int escape_string */
413
414 int strunescape(char *buf, size_t buf_len) {
415   for (size_t i = 0; (i < buf_len) && (buf[i] != '\0'); ++i) {
416     if (buf[i] != '\\')
417       continue;
418
419     if (((i + 1) >= buf_len) || (buf[i + 1] == 0)) {
420       ERROR("string unescape: backslash found at end of string.");
421       /* Ensure null-byte at the end of the buffer. */
422       buf[i] = 0;
423       return -1;
424     }
425
426     switch (buf[i + 1]) {
427     case 't':
428       buf[i] = '\t';
429       break;
430     case 'n':
431       buf[i] = '\n';
432       break;
433     case 'r':
434       buf[i] = '\r';
435       break;
436     default:
437       buf[i] = buf[i + 1];
438       break;
439     }
440
441     /* Move everything after the position one position to the left.
442      * Add a null-byte as last character in the buffer. */
443     memmove(buf + i + 1, buf + i + 2, buf_len - i - 2);
444     buf[buf_len - 1] = 0;
445   }
446   return 0;
447 } /* int strunescape */
448
449 size_t strstripnewline(char *buffer) {
450   size_t buffer_len = strlen(buffer);
451
452   while (buffer_len > 0) {
453     if ((buffer[buffer_len - 1] != '\n') && (buffer[buffer_len - 1] != '\r'))
454       break;
455     buffer_len--;
456     buffer[buffer_len] = 0;
457   }
458
459   return buffer_len;
460 } /* size_t strstripnewline */
461
462 int escape_slashes(char *buffer, size_t buffer_size) {
463   size_t buffer_len;
464
465   buffer_len = strlen(buffer);
466
467   if (buffer_len <= 1) {
468     if (strcmp("/", buffer) == 0) {
469       if (buffer_size < 5)
470         return -1;
471       sstrncpy(buffer, "root", buffer_size);
472     }
473     return 0;
474   }
475
476   /* Move one to the left */
477   if (buffer[0] == '/') {
478     memmove(buffer, buffer + 1, buffer_len);
479     buffer_len--;
480   }
481
482   for (size_t i = 0; i < buffer_len; i++) {
483     if (buffer[i] == '/')
484       buffer[i] = '_';
485   }
486
487   return 0;
488 } /* int escape_slashes */
489
490 void replace_special(char *buffer, size_t buffer_size) {
491   for (size_t i = 0; i < buffer_size; i++) {
492     if (buffer[i] == 0)
493       return;
494     if ((!isalnum((int)buffer[i])) && (buffer[i] != '-'))
495       buffer[i] = '_';
496   }
497 } /* void replace_special */
498
499 int timeval_cmp(struct timeval tv0, struct timeval tv1, struct timeval *delta) {
500   struct timeval *larger;
501   struct timeval *smaller;
502
503   int status;
504
505   NORMALIZE_TIMEVAL(tv0);
506   NORMALIZE_TIMEVAL(tv1);
507
508   if ((tv0.tv_sec == tv1.tv_sec) && (tv0.tv_usec == tv1.tv_usec)) {
509     if (delta != NULL) {
510       delta->tv_sec = 0;
511       delta->tv_usec = 0;
512     }
513     return 0;
514   }
515
516   if ((tv0.tv_sec < tv1.tv_sec) ||
517       ((tv0.tv_sec == tv1.tv_sec) && (tv0.tv_usec < tv1.tv_usec))) {
518     larger = &tv1;
519     smaller = &tv0;
520     status = -1;
521   } else {
522     larger = &tv0;
523     smaller = &tv1;
524     status = 1;
525   }
526
527   if (delta != NULL) {
528     delta->tv_sec = larger->tv_sec - smaller->tv_sec;
529
530     if (smaller->tv_usec <= larger->tv_usec)
531       delta->tv_usec = larger->tv_usec - smaller->tv_usec;
532     else {
533       --delta->tv_sec;
534       delta->tv_usec = 1000000 + larger->tv_usec - smaller->tv_usec;
535     }
536   }
537
538   assert((delta == NULL) ||
539          ((0 <= delta->tv_usec) && (delta->tv_usec < 1000000)));
540
541   return status;
542 } /* int timeval_cmp */
543
544 int check_create_dir(const char *file_orig) {
545   struct stat statbuf;
546
547   char file_copy[512];
548   char dir[512];
549   int dir_len = 512;
550   char *fields[16];
551   int fields_num;
552   char *ptr;
553   char *saveptr;
554   int last_is_file = 1;
555   int path_is_absolute = 0;
556   size_t len;
557
558   /*
559    * Sanity checks first
560    */
561   if (file_orig == NULL)
562     return -1;
563
564   if ((len = strlen(file_orig)) < 1)
565     return -1;
566   else if (len >= sizeof(file_copy))
567     return -1;
568
569   /*
570    * If `file_orig' ends in a slash the last component is a directory,
571    * otherwise it's a file. Act accordingly..
572    */
573   if (file_orig[len - 1] == '/')
574     last_is_file = 0;
575   if (file_orig[0] == '/')
576     path_is_absolute = 1;
577
578   /*
579    * Create a copy for `strtok_r' to destroy
580    */
581   sstrncpy(file_copy, file_orig, sizeof(file_copy));
582
583   /*
584    * Break into components. This will eat up several slashes in a row and
585    * remove leading and trailing slashes..
586    */
587   ptr = file_copy;
588   saveptr = NULL;
589   fields_num = 0;
590   while ((fields[fields_num] = strtok_r(ptr, "/", &saveptr)) != NULL) {
591     ptr = NULL;
592     fields_num++;
593
594     if (fields_num >= 16)
595       break;
596   }
597
598   /*
599    * For each component, do..
600    */
601   for (int i = 0; i < (fields_num - last_is_file); i++) {
602     /*
603      * Do not create directories that start with a dot. This
604      * prevents `../../' attacks and other likely malicious
605      * behavior.
606      */
607     if (fields[i][0] == '.') {
608       ERROR("Cowardly refusing to create a directory that "
609             "begins with a `.' (dot): `%s'",
610             file_orig);
611       return -2;
612     }
613
614     /*
615      * Join the components together again
616      */
617     dir[0] = '/';
618     if (strjoin(dir + path_is_absolute, (size_t)(dir_len - path_is_absolute),
619                 fields, (size_t)(i + 1), "/") < 0) {
620       ERROR("strjoin failed: `%s', component #%i", file_orig, i);
621       return -1;
622     }
623
624     while (42) {
625       if ((stat(dir, &statbuf) == -1) && (lstat(dir, &statbuf) == -1)) {
626         if (errno == ENOENT) {
627           if (mkdir(dir, S_IRWXU | S_IRWXG | S_IRWXO) == 0)
628             break;
629
630           /* this might happen, if a different thread created
631            * the directory in the meantime
632            * => call stat() again to check for S_ISDIR() */
633           if (EEXIST == errno)
634             continue;
635
636           ERROR("check_create_dir: mkdir (%s): %s", dir, STRERRNO);
637           return -1;
638         } else {
639           ERROR("check_create_dir: stat (%s): %s", dir, STRERRNO);
640           return -1;
641         }
642       } else if (!S_ISDIR(statbuf.st_mode)) {
643         ERROR("check_create_dir: `%s' exists but is not "
644               "a directory!",
645               dir);
646         return -1;
647       }
648       break;
649     }
650   }
651
652   return 0;
653 } /* check_create_dir */
654
655 #ifdef HAVE_LIBKSTAT
656 int get_kstat(kstat_t **ksp_ptr, char *module, int instance, char *name) {
657   char ident[128];
658
659   *ksp_ptr = NULL;
660
661   if (kc == NULL)
662     return -1;
663
664   snprintf(ident, sizeof(ident), "%s,%i,%s", module, instance, name);
665
666   *ksp_ptr = kstat_lookup(kc, module, instance, name);
667   if (*ksp_ptr == NULL) {
668     ERROR("get_kstat: Cound not find kstat %s", ident);
669     return -1;
670   }
671
672   if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED) {
673     ERROR("get_kstat: kstat %s has wrong type", ident);
674     *ksp_ptr = NULL;
675     return -1;
676   }
677
678 #ifdef assert
679   assert(*ksp_ptr != NULL);
680   assert((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
681 #endif
682
683   if (kstat_read(kc, *ksp_ptr, NULL) == -1) {
684     ERROR("get_kstat: kstat %s could not be read", ident);
685     return -1;
686   }
687
688   if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED) {
689     ERROR("get_kstat: kstat %s has wrong type", ident);
690     return -1;
691   }
692
693   return 0;
694 }
695
696 long long get_kstat_value(kstat_t *ksp, char *name) {
697   kstat_named_t *kn;
698   long long retval = -1LL;
699
700   if (ksp == NULL) {
701     ERROR("get_kstat_value (\"%s\"): ksp is NULL.", name);
702     return -1LL;
703   } else if (ksp->ks_type != KSTAT_TYPE_NAMED) {
704     ERROR("get_kstat_value (\"%s\"): ksp->ks_type (%#x) "
705           "is not KSTAT_TYPE_NAMED (%#x).",
706           name, (unsigned int)ksp->ks_type, (unsigned int)KSTAT_TYPE_NAMED);
707     return -1LL;
708   }
709
710   if ((kn = (kstat_named_t *)kstat_data_lookup(ksp, name)) == NULL)
711     return -1LL;
712
713   if (kn->data_type == KSTAT_DATA_INT32)
714     retval = (long long)kn->value.i32;
715   else if (kn->data_type == KSTAT_DATA_UINT32)
716     retval = (long long)kn->value.ui32;
717   else if (kn->data_type == KSTAT_DATA_INT64)
718     retval =
719         (long long)kn->value.i64; /* According to ANSI C99 `long long' must hold
720                                      at least 64 bits */
721   else if (kn->data_type == KSTAT_DATA_UINT64)
722     retval = (long long)kn->value.ui64; /* XXX: Might overflow! */
723   else
724     WARNING("get_kstat_value: Not a numeric value: %s", name);
725
726   return retval;
727 }
728 #endif /* HAVE_LIBKSTAT */
729
730 #ifndef HAVE_HTONLL
731 unsigned long long ntohll(unsigned long long n) {
732 #if BYTE_ORDER == BIG_ENDIAN
733   return n;
734 #else
735   return (((unsigned long long)ntohl(n)) << 32) + ntohl(n >> 32);
736 #endif
737 } /* unsigned long long ntohll */
738
739 unsigned long long htonll(unsigned long long n) {
740 #if BYTE_ORDER == BIG_ENDIAN
741   return n;
742 #else
743   return (((unsigned long long)htonl(n)) << 32) + htonl(n >> 32);
744 #endif
745 } /* unsigned long long htonll */
746 #endif /* HAVE_HTONLL */
747
748 #if FP_LAYOUT_NEED_NOTHING
749 /* Well, we need nothing.. */
750 /* #endif FP_LAYOUT_NEED_NOTHING */
751
752 #elif FP_LAYOUT_NEED_ENDIANFLIP || FP_LAYOUT_NEED_INTSWAP
753 #if FP_LAYOUT_NEED_ENDIANFLIP
754 #define FP_CONVERT(A)                                                          \
755   ((((uint64_t)(A)&0xff00000000000000LL) >> 56) |                              \
756    (((uint64_t)(A)&0x00ff000000000000LL) >> 40) |                              \
757    (((uint64_t)(A)&0x0000ff0000000000LL) >> 24) |                              \
758    (((uint64_t)(A)&0x000000ff00000000LL) >> 8) |                               \
759    (((uint64_t)(A)&0x00000000ff000000LL) << 8) |                               \
760    (((uint64_t)(A)&0x0000000000ff0000LL) << 24) |                              \
761    (((uint64_t)(A)&0x000000000000ff00LL) << 40) |                              \
762    (((uint64_t)(A)&0x00000000000000ffLL) << 56))
763 #else
764 #define FP_CONVERT(A)                                                          \
765   ((((uint64_t)(A)&0xffffffff00000000LL) >> 32) |                              \
766    (((uint64_t)(A)&0x00000000ffffffffLL) << 32))
767 #endif
768
769 double ntohd(double d) {
770   union {
771     uint8_t byte[8];
772     uint64_t integer;
773     double floating;
774   } ret;
775
776   ret.floating = d;
777
778   /* NAN in x86 byte order */
779   if ((ret.byte[0] == 0x00) && (ret.byte[1] == 0x00) && (ret.byte[2] == 0x00) &&
780       (ret.byte[3] == 0x00) && (ret.byte[4] == 0x00) && (ret.byte[5] == 0x00) &&
781       (ret.byte[6] == 0xf8) && (ret.byte[7] == 0x7f)) {
782     return NAN;
783   } else {
784     uint64_t tmp;
785
786     tmp = ret.integer;
787     ret.integer = FP_CONVERT(tmp);
788     return ret.floating;
789   }
790 } /* double ntohd */
791
792 double htond(double d) {
793   union {
794     uint8_t byte[8];
795     uint64_t integer;
796     double floating;
797   } ret;
798
799   if (isnan(d)) {
800     ret.byte[0] = ret.byte[1] = ret.byte[2] = ret.byte[3] = 0x00;
801     ret.byte[4] = ret.byte[5] = 0x00;
802     ret.byte[6] = 0xf8;
803     ret.byte[7] = 0x7f;
804     return ret.floating;
805   } else {
806     uint64_t tmp;
807
808     ret.floating = d;
809     tmp = FP_CONVERT(ret.integer);
810     ret.integer = tmp;
811     return ret.floating;
812   }
813 } /* double htond */
814 #endif /* FP_LAYOUT_NEED_ENDIANFLIP || FP_LAYOUT_NEED_INTSWAP */
815
816 int format_name(char *ret, int ret_len, const char *hostname,
817                 const char *plugin, const char *plugin_instance,
818                 const char *type, const char *type_instance) {
819   char *buffer;
820   size_t buffer_size;
821
822   buffer = ret;
823   buffer_size = (size_t)ret_len;
824
825 #define APPEND(str)                                                            \
826   do {                                                                         \
827     size_t l = strlen(str);                                                    \
828     if (l >= buffer_size)                                                      \
829       return ENOBUFS;                                                          \
830     memcpy(buffer, (str), l);                                                  \
831     buffer += l;                                                               \
832     buffer_size -= l;                                                          \
833   } while (0)
834
835   assert(plugin != NULL);
836   assert(type != NULL);
837
838   APPEND(hostname);
839   APPEND("/");
840   APPEND(plugin);
841   if ((plugin_instance != NULL) && (plugin_instance[0] != 0)) {
842     APPEND("-");
843     APPEND(plugin_instance);
844   }
845   APPEND("/");
846   APPEND(type);
847   if ((type_instance != NULL) && (type_instance[0] != 0)) {
848     APPEND("-");
849     APPEND(type_instance);
850   }
851   assert(buffer_size > 0);
852   buffer[0] = 0;
853
854 #undef APPEND
855   return 0;
856 } /* int format_name */
857
858 int format_values(char *ret, size_t ret_len, /* {{{ */
859                   const data_set_t *ds, const value_list_t *vl,
860                   _Bool store_rates) {
861   size_t offset = 0;
862   int status;
863   gauge_t *rates = NULL;
864
865   assert(0 == strcmp(ds->type, vl->type));
866
867   memset(ret, 0, ret_len);
868
869 #define BUFFER_ADD(...)                                                        \
870   do {                                                                         \
871     status = snprintf(ret + offset, ret_len - offset, __VA_ARGS__);            \
872     if (status < 1) {                                                          \
873       sfree(rates);                                                            \
874       return -1;                                                               \
875     } else if (((size_t)status) >= (ret_len - offset)) {                       \
876       sfree(rates);                                                            \
877       return -1;                                                               \
878     } else                                                                     \
879       offset += ((size_t)status);                                              \
880   } while (0)
881
882   BUFFER_ADD("%.3f", CDTIME_T_TO_DOUBLE(vl->time));
883
884   for (size_t i = 0; i < ds->ds_num; i++) {
885     if (ds->ds[i].type == DS_TYPE_GAUGE)
886       BUFFER_ADD(":" GAUGE_FORMAT, vl->values[i].gauge);
887     else if (store_rates) {
888       if (rates == NULL)
889         rates = uc_get_rate(ds, vl);
890       if (rates == NULL) {
891         WARNING("format_values: uc_get_rate failed.");
892         return -1;
893       }
894       BUFFER_ADD(":" GAUGE_FORMAT, rates[i]);
895     } else if (ds->ds[i].type == DS_TYPE_COUNTER)
896       BUFFER_ADD(":%" PRIu64, (uint64_t)vl->values[i].counter);
897     else if (ds->ds[i].type == DS_TYPE_DERIVE)
898       BUFFER_ADD(":%" PRIi64, vl->values[i].derive);
899     else if (ds->ds[i].type == DS_TYPE_ABSOLUTE)
900       BUFFER_ADD(":%" PRIu64, vl->values[i].absolute);
901     else {
902       ERROR("format_values: Unknown data source type: %i", ds->ds[i].type);
903       sfree(rates);
904       return -1;
905     }
906   } /* for ds->ds_num */
907
908 #undef BUFFER_ADD
909
910   sfree(rates);
911   return 0;
912 } /* }}} int format_values */
913
914 int parse_identifier(char *str, char **ret_host, char **ret_plugin,
915                      char **ret_plugin_instance, char **ret_type,
916                      char **ret_type_instance, char *default_host) {
917   char *hostname = NULL;
918   char *plugin = NULL;
919   char *plugin_instance = NULL;
920   char *type = NULL;
921   char *type_instance = NULL;
922
923   hostname = str;
924   if (hostname == NULL)
925     return -1;
926
927   plugin = strchr(hostname, '/');
928   if (plugin == NULL)
929     return -1;
930   *plugin = '\0';
931   plugin++;
932
933   type = strchr(plugin, '/');
934   if (type == NULL) {
935     if (default_host == NULL)
936       return -1;
937     /* else: no host specified; use default */
938     type = plugin;
939     plugin = hostname;
940     hostname = default_host;
941   } else {
942     *type = '\0';
943     type++;
944   }
945
946   plugin_instance = strchr(plugin, '-');
947   if (plugin_instance != NULL) {
948     *plugin_instance = '\0';
949     plugin_instance++;
950   }
951
952   type_instance = strchr(type, '-');
953   if (type_instance != NULL) {
954     *type_instance = '\0';
955     type_instance++;
956   }
957
958   *ret_host = hostname;
959   *ret_plugin = plugin;
960   *ret_plugin_instance = plugin_instance;
961   *ret_type = type;
962   *ret_type_instance = type_instance;
963   return 0;
964 } /* int parse_identifier */
965
966 int parse_identifier_vl(const char *str, value_list_t *vl) /* {{{ */
967 {
968   char str_copy[6 * DATA_MAX_NAME_LEN];
969   char *host = NULL;
970   char *plugin = NULL;
971   char *plugin_instance = NULL;
972   char *type = NULL;
973   char *type_instance = NULL;
974   int status;
975
976   if ((str == NULL) || (vl == NULL))
977     return EINVAL;
978
979   sstrncpy(str_copy, str, sizeof(str_copy));
980
981   status = parse_identifier(str_copy, &host, &plugin, &plugin_instance, &type,
982                             &type_instance,
983                             /* default_host = */ NULL);
984   if (status != 0)
985     return status;
986
987   sstrncpy(vl->host, host, sizeof(vl->host));
988   sstrncpy(vl->plugin, plugin, sizeof(vl->plugin));
989   sstrncpy(vl->plugin_instance,
990            (plugin_instance != NULL) ? plugin_instance : "",
991            sizeof(vl->plugin_instance));
992   sstrncpy(vl->type, type, sizeof(vl->type));
993   sstrncpy(vl->type_instance, (type_instance != NULL) ? type_instance : "",
994            sizeof(vl->type_instance));
995
996   return 0;
997 } /* }}} int parse_identifier_vl */
998
999 int parse_value(const char *value_orig, value_t *ret_value, int ds_type) {
1000   char *value;
1001   char *endptr = NULL;
1002   size_t value_len;
1003
1004   if (value_orig == NULL)
1005     return EINVAL;
1006
1007   value = strdup(value_orig);
1008   if (value == NULL)
1009     return ENOMEM;
1010   value_len = strlen(value);
1011
1012   while ((value_len > 0) && isspace((int)value[value_len - 1])) {
1013     value[value_len - 1] = 0;
1014     value_len--;
1015   }
1016
1017   switch (ds_type) {
1018   case DS_TYPE_COUNTER:
1019     ret_value->counter = (counter_t)strtoull(value, &endptr, 0);
1020     break;
1021
1022   case DS_TYPE_GAUGE:
1023     ret_value->gauge = (gauge_t)strtod(value, &endptr);
1024     break;
1025
1026   case DS_TYPE_DERIVE:
1027     ret_value->derive = (derive_t)strtoll(value, &endptr, 0);
1028     break;
1029
1030   case DS_TYPE_ABSOLUTE:
1031     ret_value->absolute = (absolute_t)strtoull(value, &endptr, 0);
1032     break;
1033
1034   default:
1035     sfree(value);
1036     ERROR("parse_value: Invalid data source type: %i.", ds_type);
1037     return -1;
1038   }
1039
1040   if (value == endptr) {
1041     ERROR("parse_value: Failed to parse string as %s: \"%s\".",
1042           DS_TYPE_TO_STRING(ds_type), value);
1043     sfree(value);
1044     return -1;
1045   } else if ((NULL != endptr) && ('\0' != *endptr))
1046     INFO("parse_value: Ignoring trailing garbage \"%s\" after %s value. "
1047          "Input string was \"%s\".",
1048          endptr, DS_TYPE_TO_STRING(ds_type), value_orig);
1049
1050   sfree(value);
1051   return 0;
1052 } /* int parse_value */
1053
1054 int parse_values(char *buffer, value_list_t *vl, const data_set_t *ds) {
1055   size_t i;
1056   char *dummy;
1057   char *ptr;
1058   char *saveptr;
1059
1060   if ((buffer == NULL) || (vl == NULL) || (ds == NULL))
1061     return EINVAL;
1062
1063   i = 0;
1064   dummy = buffer;
1065   saveptr = NULL;
1066   vl->time = 0;
1067   while ((ptr = strtok_r(dummy, ":", &saveptr)) != NULL) {
1068     dummy = NULL;
1069
1070     if (i >= vl->values_len) {
1071       /* Make sure i is invalid. */
1072       i = 0;
1073       break;
1074     }
1075
1076     if (vl->time == 0) {
1077       if (strcmp("N", ptr) == 0)
1078         vl->time = cdtime();
1079       else {
1080         char *endptr = NULL;
1081         double tmp;
1082
1083         errno = 0;
1084         tmp = strtod(ptr, &endptr);
1085         if ((errno != 0)        /* Overflow */
1086             || (endptr == ptr)  /* Invalid string */
1087             || (endptr == NULL) /* This should not happen */
1088             || (*endptr != 0))  /* Trailing chars */
1089           return -1;
1090
1091         vl->time = DOUBLE_TO_CDTIME_T(tmp);
1092       }
1093
1094       continue;
1095     }
1096
1097     if ((strcmp("U", ptr) == 0) && (ds->ds[i].type == DS_TYPE_GAUGE))
1098       vl->values[i].gauge = NAN;
1099     else if (0 != parse_value(ptr, &vl->values[i], ds->ds[i].type))
1100       return -1;
1101
1102     i++;
1103   } /* while (strtok_r) */
1104
1105   if ((ptr != NULL) || (i == 0))
1106     return -1;
1107   return 0;
1108 } /* int parse_values */
1109
1110 int parse_value_file(char const *path, value_t *ret_value, int ds_type) {
1111   FILE *fh;
1112   char buffer[256];
1113
1114   fh = fopen(path, "r");
1115   if (fh == NULL)
1116     return -1;
1117
1118   if (fgets(buffer, sizeof(buffer), fh) == NULL) {
1119     fclose(fh);
1120     return -1;
1121   }
1122
1123   fclose(fh);
1124
1125   strstripnewline(buffer);
1126
1127   return parse_value(buffer, ret_value, ds_type);
1128 } /* int parse_value_file */
1129
1130 #if !HAVE_GETPWNAM_R
1131 int getpwnam_r(const char *name, struct passwd *pwbuf, char *buf, size_t buflen,
1132                struct passwd **pwbufp) {
1133   int status = 0;
1134   struct passwd *pw;
1135
1136   memset(pwbuf, '\0', sizeof(struct passwd));
1137
1138   pthread_mutex_lock(&getpwnam_r_lock);
1139
1140   do {
1141     pw = getpwnam(name);
1142     if (pw == NULL) {
1143       status = (errno != 0) ? errno : ENOENT;
1144       break;
1145     }
1146
1147 #define GETPWNAM_COPY_MEMBER(member)                                           \
1148   if (pw->member != NULL) {                                                    \
1149     int len = strlen(pw->member);                                              \
1150     if (len >= buflen) {                                                       \
1151       status = ENOMEM;                                                         \
1152       break;                                                                   \
1153     }                                                                          \
1154     sstrncpy(buf, pw->member, buflen);                                         \
1155     pwbuf->member = buf;                                                       \
1156     buf += (len + 1);                                                          \
1157     buflen -= (len + 1);                                                       \
1158   }
1159     GETPWNAM_COPY_MEMBER(pw_name);
1160     GETPWNAM_COPY_MEMBER(pw_passwd);
1161     GETPWNAM_COPY_MEMBER(pw_gecos);
1162     GETPWNAM_COPY_MEMBER(pw_dir);
1163     GETPWNAM_COPY_MEMBER(pw_shell);
1164
1165     pwbuf->pw_uid = pw->pw_uid;
1166     pwbuf->pw_gid = pw->pw_gid;
1167
1168     if (pwbufp != NULL)
1169       *pwbufp = pwbuf;
1170   } while (0);
1171
1172   pthread_mutex_unlock(&getpwnam_r_lock);
1173
1174   return status;
1175 } /* int getpwnam_r */
1176 #endif /* !HAVE_GETPWNAM_R */
1177
1178 int notification_init(notification_t *n, int severity, const char *message,
1179                       const char *host, const char *plugin,
1180                       const char *plugin_instance, const char *type,
1181                       const char *type_instance) {
1182   memset(n, '\0', sizeof(notification_t));
1183
1184   n->severity = severity;
1185
1186   if (message != NULL)
1187     sstrncpy(n->message, message, sizeof(n->message));
1188   if (host != NULL)
1189     sstrncpy(n->host, host, sizeof(n->host));
1190   if (plugin != NULL)
1191     sstrncpy(n->plugin, plugin, sizeof(n->plugin));
1192   if (plugin_instance != NULL)
1193     sstrncpy(n->plugin_instance, plugin_instance, sizeof(n->plugin_instance));
1194   if (type != NULL)
1195     sstrncpy(n->type, type, sizeof(n->type));
1196   if (type_instance != NULL)
1197     sstrncpy(n->type_instance, type_instance, sizeof(n->type_instance));
1198
1199   return 0;
1200 } /* int notification_init */
1201
1202 int walk_directory(const char *dir, dirwalk_callback_f callback,
1203                    void *user_data, int include_hidden) {
1204   struct dirent *ent;
1205   DIR *dh;
1206   int success;
1207   int failure;
1208
1209   success = 0;
1210   failure = 0;
1211
1212   if ((dh = opendir(dir)) == NULL) {
1213     ERROR("walk_directory: Cannot open '%s': %s", dir, STRERRNO);
1214     return -1;
1215   }
1216
1217   while ((ent = readdir(dh)) != NULL) {
1218     int status;
1219
1220     if (include_hidden) {
1221       if ((strcmp(".", ent->d_name) == 0) || (strcmp("..", ent->d_name) == 0))
1222         continue;
1223     } else /* if (!include_hidden) */
1224     {
1225       if (ent->d_name[0] == '.')
1226         continue;
1227     }
1228
1229     status = (*callback)(dir, ent->d_name, user_data);
1230     if (status != 0)
1231       failure++;
1232     else
1233       success++;
1234   }
1235
1236   closedir(dh);
1237
1238   if ((success == 0) && (failure > 0))
1239     return -1;
1240   return 0;
1241 }
1242
1243 ssize_t read_file_contents(const char *filename, char *buf, size_t bufsize) {
1244   FILE *fh;
1245   ssize_t ret;
1246
1247   fh = fopen(filename, "r");
1248   if (fh == NULL)
1249     return -1;
1250
1251   ret = (ssize_t)fread(buf, 1, bufsize, fh);
1252   if ((ret == 0) && (ferror(fh) != 0)) {
1253     ERROR("read_file_contents: Reading file \"%s\" failed.", filename);
1254     ret = -1;
1255   }
1256
1257   fclose(fh);
1258   return ret;
1259 }
1260
1261 counter_t counter_diff(counter_t old_value, counter_t new_value) {
1262   counter_t diff;
1263
1264   if (old_value > new_value) {
1265     if (old_value <= 4294967295U)
1266       diff = (4294967295U - old_value) + new_value + 1;
1267     else
1268       diff = (18446744073709551615ULL - old_value) + new_value + 1;
1269   } else {
1270     diff = new_value - old_value;
1271   }
1272
1273   return diff;
1274 } /* counter_t counter_diff */
1275
1276 int rate_to_value(value_t *ret_value, gauge_t rate, /* {{{ */
1277                   rate_to_value_state_t *state, int ds_type, cdtime_t t) {
1278   gauge_t delta_gauge;
1279   cdtime_t delta_t;
1280
1281   if (ds_type == DS_TYPE_GAUGE) {
1282     state->last_value.gauge = rate;
1283     state->last_time = t;
1284
1285     *ret_value = state->last_value;
1286     return 0;
1287   }
1288
1289   /* Counter and absolute can't handle negative rates. Reset "last time"
1290    * to zero, so that the next valid rate will re-initialize the
1291    * structure. */
1292   if ((rate < 0.0) &&
1293       ((ds_type == DS_TYPE_COUNTER) || (ds_type == DS_TYPE_ABSOLUTE))) {
1294     memset(state, 0, sizeof(*state));
1295     return EINVAL;
1296   }
1297
1298   /* Another invalid state: The time is not increasing. */
1299   if (t <= state->last_time) {
1300     memset(state, 0, sizeof(*state));
1301     return EINVAL;
1302   }
1303
1304   delta_t = t - state->last_time;
1305   delta_gauge = (rate * CDTIME_T_TO_DOUBLE(delta_t)) + state->residual;
1306
1307   /* Previous value is invalid. */
1308   if (state->last_time == 0) /* {{{ */
1309   {
1310     if (ds_type == DS_TYPE_DERIVE) {
1311       state->last_value.derive = (derive_t)rate;
1312       state->residual = rate - ((gauge_t)state->last_value.derive);
1313     } else if (ds_type == DS_TYPE_COUNTER) {
1314       state->last_value.counter = (counter_t)rate;
1315       state->residual = rate - ((gauge_t)state->last_value.counter);
1316     } else if (ds_type == DS_TYPE_ABSOLUTE) {
1317       state->last_value.absolute = (absolute_t)rate;
1318       state->residual = rate - ((gauge_t)state->last_value.absolute);
1319     } else {
1320       assert(23 == 42);
1321     }
1322
1323     state->last_time = t;
1324     return EAGAIN;
1325   } /* }}} */
1326
1327   if (ds_type == DS_TYPE_DERIVE) {
1328     derive_t delta_derive = (derive_t)delta_gauge;
1329
1330     state->last_value.derive += delta_derive;
1331     state->residual = delta_gauge - ((gauge_t)delta_derive);
1332   } else if (ds_type == DS_TYPE_COUNTER) {
1333     counter_t delta_counter = (counter_t)delta_gauge;
1334
1335     state->last_value.counter += delta_counter;
1336     state->residual = delta_gauge - ((gauge_t)delta_counter);
1337   } else if (ds_type == DS_TYPE_ABSOLUTE) {
1338     absolute_t delta_absolute = (absolute_t)delta_gauge;
1339
1340     state->last_value.absolute = delta_absolute;
1341     state->residual = delta_gauge - ((gauge_t)delta_absolute);
1342   } else {
1343     assert(23 == 42);
1344   }
1345
1346   state->last_time = t;
1347   *ret_value = state->last_value;
1348   return 0;
1349 } /* }}} value_t rate_to_value */
1350
1351 int value_to_rate(gauge_t *ret_rate, /* {{{ */
1352                   value_t value, int ds_type, cdtime_t t,
1353                   value_to_rate_state_t *state) {
1354   gauge_t interval;
1355
1356   /* Another invalid state: The time is not increasing. */
1357   if (t <= state->last_time) {
1358     memset(state, 0, sizeof(*state));
1359     return EINVAL;
1360   }
1361
1362   interval = CDTIME_T_TO_DOUBLE(t - state->last_time);
1363
1364   /* Previous value is invalid. */
1365   if (state->last_time == 0) {
1366     state->last_value = value;
1367     state->last_time = t;
1368     return EAGAIN;
1369   }
1370
1371   switch (ds_type) {
1372   case DS_TYPE_DERIVE: {
1373     derive_t diff = value.derive - state->last_value.derive;
1374     *ret_rate = ((gauge_t)diff) / ((gauge_t)interval);
1375     break;
1376   }
1377   case DS_TYPE_GAUGE: {
1378     *ret_rate = value.gauge;
1379     break;
1380   }
1381   case DS_TYPE_COUNTER: {
1382     counter_t diff = counter_diff(state->last_value.counter, value.counter);
1383     *ret_rate = ((gauge_t)diff) / ((gauge_t)interval);
1384     break;
1385   }
1386   case DS_TYPE_ABSOLUTE: {
1387     absolute_t diff = value.absolute;
1388     *ret_rate = ((gauge_t)diff) / ((gauge_t)interval);
1389     break;
1390   }
1391   default:
1392     return EINVAL;
1393   }
1394
1395   state->last_value = value;
1396   state->last_time = t;
1397   return 0;
1398 } /* }}} value_t rate_to_value */
1399
1400 int service_name_to_port_number(const char *service_name) {
1401   struct addrinfo *ai_list;
1402   int status;
1403   int service_number;
1404
1405   if (service_name == NULL)
1406     return -1;
1407
1408   struct addrinfo ai_hints = {.ai_family = AF_UNSPEC};
1409
1410   status = getaddrinfo(/* node = */ NULL, service_name, &ai_hints, &ai_list);
1411   if (status != 0) {
1412     ERROR("service_name_to_port_number: getaddrinfo failed: %s",
1413           gai_strerror(status));
1414     return -1;
1415   }
1416
1417   service_number = -1;
1418   for (struct addrinfo *ai_ptr = ai_list; ai_ptr != NULL;
1419        ai_ptr = ai_ptr->ai_next) {
1420     if (ai_ptr->ai_family == AF_INET) {
1421       struct sockaddr_in *sa;
1422
1423       sa = (void *)ai_ptr->ai_addr;
1424       service_number = (int)ntohs(sa->sin_port);
1425     } else if (ai_ptr->ai_family == AF_INET6) {
1426       struct sockaddr_in6 *sa;
1427
1428       sa = (void *)ai_ptr->ai_addr;
1429       service_number = (int)ntohs(sa->sin6_port);
1430     }
1431
1432     if ((service_number > 0) && (service_number <= 65535))
1433       break;
1434   }
1435
1436   freeaddrinfo(ai_list);
1437
1438   if ((service_number > 0) && (service_number <= 65535))
1439     return service_number;
1440   return -1;
1441 } /* int service_name_to_port_number */
1442
1443 void set_sock_opts(int sockfd) /* {{{ */
1444 {
1445   int status;
1446   int socktype;
1447
1448   status = getsockopt(sockfd, SOL_SOCKET, SO_TYPE, &socktype,
1449                       &(socklen_t){sizeof(socktype)});
1450   if (status != 0) {
1451     WARNING("set_sock_opts: failed to determine socket type");
1452     return;
1453   }
1454
1455   if (socktype == SOCK_STREAM) {
1456     status =
1457         setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &(int){1}, sizeof(int));
1458     if (status != 0)
1459       WARNING("set_sock_opts: failed to set socket keepalive flag");
1460
1461 #ifdef TCP_KEEPIDLE
1462     int tcp_keepidle = ((CDTIME_T_TO_MS(plugin_get_interval()) - 1) / 100 + 1);
1463     status = setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, &tcp_keepidle,
1464                         sizeof(tcp_keepidle));
1465     if (status != 0)
1466       WARNING("set_sock_opts: failed to set socket tcp keepalive time");
1467 #endif
1468
1469 #ifdef TCP_KEEPINTVL
1470     int tcp_keepintvl =
1471         ((CDTIME_T_TO_MS(plugin_get_interval()) - 1) / 1000 + 1);
1472     status = setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL, &tcp_keepintvl,
1473                         sizeof(tcp_keepintvl));
1474     if (status != 0)
1475       WARNING("set_sock_opts: failed to set socket tcp keepalive interval");
1476 #endif
1477   }
1478 } /* }}} void set_sock_opts */
1479
1480 int strtoderive(const char *string, derive_t *ret_value) /* {{{ */
1481 {
1482   derive_t tmp;
1483   char *endptr;
1484
1485   if ((string == NULL) || (ret_value == NULL))
1486     return EINVAL;
1487
1488   errno = 0;
1489   endptr = NULL;
1490   tmp = (derive_t)strtoll(string, &endptr, /* base = */ 0);
1491   if ((endptr == string) || (errno != 0))
1492     return -1;
1493
1494   *ret_value = tmp;
1495   return 0;
1496 } /* }}} int strtoderive */
1497
1498 int strtogauge(const char *string, gauge_t *ret_value) /* {{{ */
1499 {
1500   gauge_t tmp;
1501   char *endptr = NULL;
1502
1503   if ((string == NULL) || (ret_value == NULL))
1504     return EINVAL;
1505
1506   errno = 0;
1507   endptr = NULL;
1508   tmp = (gauge_t)strtod(string, &endptr);
1509   if (errno != 0)
1510     return errno;
1511   else if ((endptr == NULL) || (*endptr != 0))
1512     return EINVAL;
1513
1514   *ret_value = tmp;
1515   return 0;
1516 } /* }}} int strtogauge */
1517
1518 int strarray_add(char ***ret_array, size_t *ret_array_len,
1519                  char const *str) /* {{{ */
1520 {
1521   char **array;
1522   size_t array_len = *ret_array_len;
1523
1524   if (str == NULL)
1525     return EINVAL;
1526
1527   array = realloc(*ret_array, (array_len + 1) * sizeof(*array));
1528   if (array == NULL)
1529     return ENOMEM;
1530   *ret_array = array;
1531
1532   array[array_len] = strdup(str);
1533   if (array[array_len] == NULL)
1534     return ENOMEM;
1535
1536   array_len++;
1537   *ret_array_len = array_len;
1538   return 0;
1539 } /* }}} int strarray_add */
1540
1541 void strarray_free(char **array, size_t array_len) /* {{{ */
1542 {
1543   for (size_t i = 0; i < array_len; i++)
1544     sfree(array[i]);
1545   sfree(array);
1546 } /* }}} void strarray_free */
1547
1548 #if HAVE_CAPABILITY
1549 int check_capability(int arg) /* {{{ */
1550 {
1551   cap_value_t cap_value = (cap_value_t)arg;
1552   cap_t cap;
1553   cap_flag_value_t cap_flag_value;
1554
1555   if (!CAP_IS_SUPPORTED(cap_value))
1556     return -1;
1557
1558   if (!(cap = cap_get_proc())) {
1559     ERROR("check_capability: cap_get_proc failed.");
1560     return -1;
1561   }
1562
1563   if (cap_get_flag(cap, cap_value, CAP_EFFECTIVE, &cap_flag_value) < 0) {
1564     ERROR("check_capability: cap_get_flag failed.");
1565     cap_free(cap);
1566     return -1;
1567   }
1568   cap_free(cap);
1569
1570   return cap_flag_value != CAP_SET;
1571 } /* }}} int check_capability */
1572 #else
1573 int check_capability(__attribute__((unused)) int arg) /* {{{ */
1574 {
1575   WARNING("check_capability: unsupported capability implementation. "
1576           "Some plugin(s) may require elevated privileges to work properly.");
1577   return 0;
1578 } /* }}} int check_capability */
1579 #endif /* HAVE_CAPABILITY */