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