src/common.c

   1 /**
   2  * collectd - src/common.c
   3  * Copyright (C) 2005-2007  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Florian octo Forster <octo at verplant.org>
  20  *   Niki W. Waibel <niki.waibel@gmx.net>
  21 **/
  22
  23 #include "common.h"
  24 #include "plugin.h"
  25
  26 #ifdef HAVE_MATH_H
  27 #  include <math.h>
  28 #endif
  29
  30 /* for ntohl and htonl */
  31 #if HAVE_ARPA_INET_H
  32 # include <arpa/inet.h>
  33 #endif
  34
  35 #ifdef HAVE_LIBKSTAT
  36 extern kstat_ctl_t *kc;
  37 #endif
  38
  39 void sstrncpy (char *d, const char *s, int len)
  40 {
  41         strncpy (d, s, len);
  42         d[len - 1] = '\0';
  43 }
  44
  45 char *sstrdup (const char *s)
  46 {
  47         char *r;
  48
  49         if (s == NULL)
  50                 return (NULL);
  51
  52         if((r = strdup (s)) == NULL)
  53         {
  54                 DEBUG ("Not enough memory.");
  55                 exit(3);
  56         }
  57
  58         return (r);
  59 }
  60
  61 /* Don't use the return value of `strerror_r', because the GNU-people got
  62  * inventive there.. -octo */
  63 char *sstrerror (int errnum, char *buf, size_t buflen)
  64 {
  65         buf[0] = '\0';
  66         strerror_r (errnum, buf, buflen);
  67         return (buf);
  68 } /* char *sstrerror */
  69
  70 void *smalloc (size_t size)
  71 {
  72         void *r;
  73
  74         if ((r = malloc (size)) == NULL)
  75         {
  76                 DEBUG("Not enough memory.");
  77                 exit(3);
  78         }
  79
  80         return r;
  81 }
  82
  83 #if 0
  84 void sfree (void **ptr)
  85 {
  86         if (ptr == NULL)
  87                 return;
  88
  89         if (*ptr != NULL)
  90                 free (*ptr);
  91
  92         *ptr = NULL;
  93 }
  94 #endif
  95
  96 ssize_t sread (int fd, void *buf, size_t count)
  97 {
  98         char    *ptr;
  99         size_t   nleft;
 100         ssize_t  status;
 101
 102         ptr   = (char *) buf;
 103         nleft = count;
 104
 105         while (nleft > 0)
 106         {
 107                 status = read (fd, (void *) ptr, nleft);
 108
 109                 if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
 110                         continue;
 111
 112                 if (status < 0)
 113                         return (status);
 114
 115                 if (status == 0)
 116                 {
 117                         DEBUG ("Received EOF from fd %i. "
 118                                         "Closing fd and returning error.",
 119                                         fd);
 120                         close (fd);
 121                         return (-1);
 122                 }
 123
 124                 assert (nleft >= status);
 125
 126                 nleft = nleft - status;
 127                 ptr   = ptr   + status;
 128         }
 129
 130         return (0);
 131 }
 132
 133
 134 ssize_t swrite (int fd, const void *buf, size_t count)
 135 {
 136         const char *ptr;
 137         size_t      nleft;
 138         ssize_t     status;
 139
 140         ptr   = (const char *) buf;
 141         nleft = count;
 142
 143         while (nleft > 0)
 144         {
 145                 status = write (fd, (const void *) ptr, nleft);
 146
 147                 if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
 148                         continue;
 149
 150                 if (status < 0)
 151                         return (status);
 152
 153                 nleft = nleft - status;
 154                 ptr   = ptr   + status;
 155         }
 156
 157         return (0);
 158 }
 159
 160 int strsplit (char *string, char **fields, size_t size)
 161 {
 162         size_t i;
 163         char *ptr;
 164         char *saveptr;
 165
 166         i = 0;
 167         ptr = string;
 168         saveptr = NULL;
 169         while ((fields[i] = strtok_r (ptr, " \t", &saveptr)) != NULL)
 170         {
 171                 ptr = NULL;
 172                 i++;
 173
 174                 if (i >= size)
 175                         break;
 176         }
 177
 178         return (i);
 179 }
 180
 181 int strjoin (char *dst, size_t dst_len,
 182                 char **fields, size_t fields_num,
 183                 const char *sep)
 184 {
 185         int field_len;
 186         int sep_len;
 187         int i;
 188
 189         memset (dst, '\0', dst_len);
 190
 191         if (fields_num <= 0)
 192                 return (-1);
 193
 194         sep_len = 0;
 195         if (sep != NULL)
 196                 sep_len = strlen (sep);
 197
 198         for (i = 0; i < fields_num; i++)
 199         {
 200                 if ((i > 0) && (sep_len > 0))
 201                 {
 202                         if (dst_len <= sep_len)
 203                                 return (-1);
 204
 205                         strncat (dst, sep, dst_len);
 206                         dst_len -= sep_len;
 207                 }
 208
 209                 field_len = strlen (fields[i]);
 210
 211                 if (dst_len <= field_len)
 212                         return (-1);
 213
 214                 strncat (dst, fields[i], dst_len);
 215                 dst_len -= field_len;
 216         }
 217
 218         return (strlen (dst));
 219 }
 220
 221 int strsubstitute (char *str, char c_from, char c_to)
 222 {
 223         int ret;
 224
 225         if (str == NULL)
 226                 return (-1);
 227
 228         ret = 0;
 229         while (*str != '\0')
 230         {
 231                 if (*str == c_from)
 232                 {
 233                         *str = c_to;
 234                         ret++;
 235                 }
 236                 str++;
 237         }
 238
 239         return (ret);
 240 }
 241
 242 int escape_slashes (char *buf, int buf_len)
 243 {
 244         int i;
 245
 246         if (strcmp (buf, "/") == 0)
 247         {
 248                 if (buf_len < 5)
 249                         return (-1);
 250
 251                 strncpy (buf, "root", buf_len);
 252                 return (0);
 253         }
 254
 255         /* Move one to the left */
 256         memmove (buf, buf + 1, buf_len - 1);
 257
 258         for (i = 0; i < buf_len - 1; i++)
 259         {
 260                 if (buf[i] == '\0')
 261                         break;
 262                 else if (buf[i] == '/')
 263                         buf[i] = '_';
 264         }
 265         buf[i] = '\0';
 266
 267         return (0);
 268 }
 269
 270 int timeval_sub_timespec (struct timeval *tv0, struct timeval *tv1, struct timespec *ret)
 271 {
 272         if ((tv0 == NULL) || (tv1 == NULL) || (ret == NULL))
 273                 return (-2);
 274
 275         if ((tv0->tv_sec < tv1->tv_sec)
 276                         || ((tv0->tv_sec == tv1->tv_sec) && (tv0->tv_usec < tv1->tv_usec)))
 277                 return (-1);
 278
 279         ret->tv_sec  = tv0->tv_sec - tv1->tv_sec;
 280         ret->tv_nsec = 1000 * ((long) (tv0->tv_usec - tv1->tv_usec));
 281
 282         if (ret->tv_nsec < 0)
 283         {
 284                 assert (ret->tv_sec > 0);
 285
 286                 ret->tv_nsec += 1000000000;
 287                 ret->tv_sec  -= 1;
 288         }
 289
 290         return (0);
 291 }
 292
 293 int check_create_dir (const char *file_orig)
 294 {
 295         struct stat statbuf;
 296
 297         char  file_copy[512];
 298         char  dir[512];
 299         int   dir_len = 512;
 300         char *fields[16];
 301         int   fields_num;
 302         char *ptr;
 303         char *saveptr;
 304         int   last_is_file = 1;
 305         int   path_is_absolute = 0;
 306         int   len;
 307         int   i;
 308
 309         /*
 310          * Sanity checks first
 311          */
 312         if (file_orig == NULL)
 313                 return (-1);
 314
 315         if ((len = strlen (file_orig)) < 1)
 316                 return (-1);
 317         else if (len >= 512)
 318                 return (-1);
 319
 320         /*
 321          * If `file_orig' ends in a slash the last component is a directory,
 322          * otherwise it's a file. Act accordingly..
 323          */
 324         if (file_orig[len - 1] == '/')
 325                 last_is_file = 0;
 326         if (file_orig[0] == '/')
 327                 path_is_absolute = 1;
 328
 329         /*
 330          * Create a copy for `strtok_r' to destroy
 331          */
 332         strncpy (file_copy, file_orig, 512);
 333         file_copy[511] = '\0';
 334
 335         /*
 336          * Break into components. This will eat up several slashes in a row and
 337          * remove leading and trailing slashes..
 338          */
 339         ptr = file_copy;
 340         saveptr = NULL;
 341         fields_num = 0;
 342         while ((fields[fields_num] = strtok_r (ptr, "/", &saveptr)) != NULL)
 343         {
 344                 ptr = NULL;
 345                 fields_num++;
 346
 347                 if (fields_num >= 16)
 348                         break;
 349         }
 350
 351         /*
 352          * For each component, do..
 353          */
 354         for (i = 0; i < (fields_num - last_is_file); i++)
 355         {
 356                 /*
 357                  * Do not create directories that start with a dot. This
 358                  * prevents `../../' attacks and other likely malicious
 359                  * behavior.
 360                  */
 361                 if (fields[i][0] == '.')
 362                 {
 363                         ERROR ("Cowardly refusing to create a directory that begins with a `.' (dot): `%s'", file_orig);
 364                         return (-2);
 365                 }
 366
 367                 /*
 368                  * Join the components together again
 369                  */
 370                 dir[0] = '/';
 371                 if (strjoin (dir + path_is_absolute, dir_len - path_is_absolute,
 372                                         fields, i + 1, "/") < 0)
 373                 {
 374                         ERROR ("strjoin failed: `%s', component #%i", file_orig, i);
 375                         return (-1);
 376                 }
 377
 378                 if (stat (dir, &statbuf) == -1)
 379                 {
 380                         if (errno == ENOENT)
 381                         {
 382                                 if (mkdir (dir, 0755) == -1)
 383                                 {
 384                                         char errbuf[1024];
 385                                         ERROR ("mkdir (%s): %s", dir,
 386                                                         sstrerror (errno,
 387                                                                 errbuf, sizeof (errbuf)));
 388                                         return (-1);
 389                                 }
 390                         }
 391                         else
 392                         {
 393                                 char errbuf[1024];
 394                                 ERROR ("stat (%s): %s", dir,
 395                                                 sstrerror (errno, errbuf,
 396                                                         sizeof (errbuf)));
 397                                 return (-1);
 398                         }
 399                 }
 400                 else if (!S_ISDIR (statbuf.st_mode))
 401                 {
 402                         ERROR ("stat (%s): Not a directory!", dir);
 403                         return (-1);
 404                 }
 405         }
 406
 407         return (0);
 408 }
 409
 410 #ifdef HAVE_LIBKSTAT
 411 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
 412 {
 413         char ident[128];
 414
 415         if (kc == NULL)
 416                 return (-1);
 417
 418         snprintf (ident, 128, "%s,%i,%s", module, instance, name);
 419         ident[127] = '\0';
 420
 421         if (*ksp_ptr == NULL)
 422         {
 423                 if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL)
 424                 {
 425                         ERROR ("Cound not find kstat %s", ident);
 426                         return (-1);
 427                 }
 428
 429                 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
 430                 {
 431                         WARNING ("kstat %s has wrong type", ident);
 432                         *ksp_ptr = NULL;
 433                         return (-1);
 434                 }
 435         }
 436
 437 #ifdef assert
 438         assert (*ksp_ptr != NULL);
 439         assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
 440 #endif
 441
 442         if (kstat_read (kc, *ksp_ptr, NULL) == -1)
 443         {
 444                 WARNING ("kstat %s could not be read", ident);
 445                 return (-1);
 446         }
 447
 448         if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
 449         {
 450                 WARNING ("kstat %s has wrong type", ident);
 451                 return (-1);
 452         }
 453
 454         return (0);
 455 }
 456
 457 long long get_kstat_value (kstat_t *ksp, char *name)
 458 {
 459         kstat_named_t *kn;
 460         long long retval = -1LL;
 461
 462 #ifdef assert
 463         assert (ksp != NULL);
 464         assert (ksp->ks_type == KSTAT_TYPE_NAMED);
 465 #else
 466         if (ksp == NULL)
 467         {
 468                 fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__);
 469                 return (-1LL);
 470         }
 471         else if (ksp->ks_type != KSTAT_TYPE_NAMED)
 472         {
 473                 fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__);
 474                 return (-1LL);
 475         }
 476 #endif
 477
 478         if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
 479                 return (retval);
 480
 481         if (kn->data_type == KSTAT_DATA_INT32)
 482                 retval = (long long) kn->value.i32;
 483         else if (kn->data_type == KSTAT_DATA_UINT32)
 484                 retval = (long long) kn->value.ui32;
 485         else if (kn->data_type == KSTAT_DATA_INT64)
 486                 retval = (long long) kn->value.i64; /* According to ANSI C99 `long long' must hold at least 64 bits */
 487         else if (kn->data_type == KSTAT_DATA_UINT64)
 488                 retval = (long long) kn->value.ui64; /* XXX: Might overflow! */
 489         else
 490                 WARNING ("get_kstat_value: Not a numeric value: %s", name);
 491
 492         return (retval);
 493 }
 494 #endif /* HAVE_LIBKSTAT */
 495
 496 unsigned long long ntohll (unsigned long long n)
 497 {
 498 #if __BYTE_ORDER == __BIG_ENDIAN
 499         return (n);
 500 #else
 501         return (((unsigned long long) ntohl (n)) << 32) + ntohl (n >> 32);
 502 #endif
 503 } /* unsigned long long ntohll */
 504
 505 unsigned long long htonll (unsigned long long n)
 506 {
 507 #if __BYTE_ORDER == __BIG_ENDIAN
 508         return (n);
 509 #else
 510         return (((unsigned long long) htonl (n)) << 32) + htonl (n >> 32);
 511 #endif
 512 } /* unsigned long long htonll */
 513
 514 int format_name (char *ret, int ret_len,
 515                 const char *hostname,
 516                 const char *plugin, const char *plugin_instance,
 517                 const char *type, const char *type_instance)
 518 {
 519         int  status;
 520
 521         assert (plugin != NULL);
 522         assert (type != NULL);
 523
 524         if ((plugin_instance == NULL) || (strlen (plugin_instance) == 0))
 525         {
 526                 if ((type_instance == NULL) || (strlen (type_instance) == 0))
 527                         status = snprintf (ret, ret_len, "%s/%s/%s",
 528                                         hostname, plugin, type);
 529                 else
 530                         status = snprintf (ret, ret_len, "%s/%s/%s-%s",
 531                                         hostname, plugin, type,
 532                                         type_instance);
 533         }
 534         else
 535         {
 536                 if ((type_instance == NULL) || (strlen (type_instance) == 0))
 537                         status = snprintf (ret, ret_len, "%s/%s-%s/%s",
 538                                         hostname, plugin, plugin_instance,
 539                                         type);
 540                 else
 541                         status = snprintf (ret, ret_len, "%s/%s-%s/%s-%s",
 542                                         hostname, plugin, plugin_instance,
 543                                         type, type_instance);
 544         }
 545
 546         if ((status < 1) || (status >= ret_len))
 547                 return (-1);
 548         return (0);
 549 } /* int format_name */