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