src/common.c

   1 /**
   2  * collectd - src/common.c
   3  * Copyright (C) 2005  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/
   6  * or modify it under the terms of the GNU General Public Li-
   7  * cence as published by the Free Software Foundation; either
   8  * version 2 of the Licence, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be use-
  11  * ful, but WITHOUT ANY WARRANTY; without even the implied war-
  12  * ranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public Licence for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * Licence along with this program; if not, write to the Free
  17  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  18  * USA.
  19  *
  20  * Authors:
  21  *   Florian octo Forster <octo at verplant.org>
  22  *   Niki W. Waibel <niki.waibel@gmx.net>
  23 **/
  24
  25 #include "common.h"
  26 #include "utils_debug.h"
  27
  28 #ifdef HAVE_MATH_H
  29 #  include <math.h>
  30 #endif
  31
  32 #ifdef HAVE_LIBKSTAT
  33 extern kstat_ctl_t *kc;
  34 #endif
  35
  36 #ifdef HAVE_LIBRRD
  37 #if 0
  38 static char *rra_def[] =
  39 {
  40                 "RRA:AVERAGE:0.0:1:1500",
  41                 "RRA:AVERAGE:0.2:6:1500",
  42                 "RRA:AVERAGE:0.1:180:1680",
  43                 "RRA:AVERAGE:0.1:2160:1520",
  44                 "RRA:MIN:0.0:1:1500",
  45                 "RRA:MIN:0.2:6:1500",
  46                 "RRA:MIN:0.1:180:1680",
  47                 "RRA:MIN:0.1:2160:1520",
  48                 "RRA:MAX:0.0:1:1500",
  49                 "RRA:MAX:0.2:6:1500",
  50                 "RRA:MAX:0.1:180:1680",
  51                 "RRA:MAX:0.1:2160:1520",
  52                 NULL
  53 };
  54 static int rra_num = 12;
  55 #endif
  56
  57 static int rra_timespans[] =
  58 {
  59         3600,
  60         86400,
  61         604800,
  62         2678400,
  63         31622400,
  64         0
  65 };
  66 static int rra_timespans_num = 5;
  67
  68 static char *rra_types[] =
  69 {
  70         "AVERAGE",
  71         "MIN",
  72         "MAX",
  73         NULL
  74 };
  75 static int rra_types_num = 3;
  76 #endif /* HAVE_LIBRRD */
  77
  78 void sstrncpy (char *d, const char *s, int len)
  79 {
  80         strncpy (d, s, len);
  81         d[len - 1] = '\0';
  82 }
  83
  84 char *sstrdup (const char *s)
  85 {
  86         char *r;
  87
  88         if (s == NULL)
  89                 return (NULL);
  90
  91         if((r = strdup (s)) == NULL)
  92         {
  93                 DBG ("Not enough memory.");
  94                 exit(3);
  95         }
  96
  97         return (r);
  98 }
  99
 100 void *smalloc (size_t size)
 101 {
 102         void *r;
 103
 104         if ((r = malloc (size)) == NULL)
 105         {
 106                 DBG("Not enough memory.");
 107                 exit(3);
 108         }
 109
 110         return r;
 111 }
 112
 113 #if 0
 114 void sfree (void **ptr)
 115 {
 116         if (ptr == NULL)
 117                 return;
 118
 119         if (*ptr != NULL)
 120                 free (*ptr);
 121
 122         *ptr = NULL;
 123 }
 124 #endif
 125
 126 int strsplit (char *string, char **fields, size_t size)
 127 {
 128         size_t i;
 129         char *ptr;
 130
 131         i = 0;
 132         ptr = string;
 133         while ((fields[i] = strtok (ptr, " \t")) != NULL)
 134         {
 135                 ptr = NULL;
 136                 i++;
 137
 138                 if (i >= size)
 139                         break;
 140         }
 141
 142         return (i);
 143 }
 144
 145 int strjoin (char *dst, size_t dst_len,
 146                 char **fields, size_t fields_num,
 147                 const char *sep)
 148 {
 149         int field_len;
 150         int sep_len;
 151         int i;
 152
 153         memset (dst, '\0', dst_len);
 154
 155         if (fields_num <= 0)
 156                 return (-1);
 157
 158         sep_len = 0;
 159         if (sep != NULL)
 160                 sep_len = strlen (sep);
 161
 162         for (i = 0; i < fields_num; i++)
 163         {
 164                 if ((i > 0) && (sep_len > 0))
 165                 {
 166                         if (dst_len <= sep_len)
 167                                 return (-1);
 168
 169                         strncat (dst, sep, dst_len);
 170                         dst_len -= sep_len;
 171                 }
 172
 173                 field_len = strlen (fields[i]);
 174
 175                 if (dst_len <= field_len)
 176                         return (-1);
 177
 178                 strncat (dst, fields[i], dst_len);
 179                 dst_len -= field_len;
 180         }
 181
 182         return (strlen (dst));
 183 }
 184
 185 int escape_slashes (char *buf, int buf_len)
 186 {
 187         int i;
 188
 189         if (strcmp (buf, "/") == 0)
 190         {
 191                 if (buf_len < 5)
 192                         return (-1);
 193
 194                 strncpy (buf, "root", buf_len);
 195                 return (0);
 196         }
 197
 198         /* Move one to the left */
 199         memmove (buf, buf + 1, buf_len - 1);
 200
 201         for (i = 0; i < buf_len - 1; i++)
 202         {
 203                 if (buf[i] == '\0')
 204                         break;
 205                 else if (buf[i] == '/')
 206                         buf[i] = '_';
 207         }
 208         buf[i] = '\0';
 209
 210         return (0);
 211 }
 212
 213 int timeval_sub_timespec (struct timeval *tv0, struct timeval *tv1, struct timespec *ret)
 214 {
 215         if ((tv0 == NULL) || (tv1 == NULL) || (ret == NULL))
 216                 return (-2);
 217
 218         if ((tv0->tv_sec < tv1->tv_sec)
 219                         || ((tv0->tv_sec == tv1->tv_sec) && (tv0->tv_usec < tv1->tv_usec)))
 220                 return (-1);
 221
 222         ret->tv_sec  = tv0->tv_sec - tv1->tv_sec;
 223         ret->tv_nsec = 1000 * ((long) (tv0->tv_usec - tv1->tv_usec));
 224
 225         if (ret->tv_nsec < 0)
 226         {
 227                 assert (ret->tv_sec > 0);
 228
 229                 ret->tv_nsec += 1000000000;
 230                 ret->tv_sec  -= 1;
 231         }
 232
 233         return (0);
 234 }
 235
 236 #ifdef HAVE_LIBRRD
 237 int check_create_dir (const char *file_orig)
 238 {
 239         struct stat statbuf;
 240
 241         char  file_copy[512];
 242         char  dir[512];
 243         int   dir_len = 512;
 244         char *fields[16];
 245         int   fields_num;
 246         char *ptr;
 247         int   last_is_file = 1;
 248         int   len;
 249         int   i;
 250
 251         /*
 252          * Sanity checks first
 253          */
 254         if (file_orig == NULL)
 255                 return (-1);
 256
 257         if ((len = strlen (file_orig)) < 1)
 258                 return (-1);
 259         else if (len >= 512)
 260                 return (-1);
 261
 262         /*
 263          * If `file_orig' ends in a slash the last component is a directory,
 264          * otherwise it's a file. Act accordingly..
 265          */
 266         if (file_orig[len - 1] == '/')
 267                 last_is_file = 0;
 268
 269         /*
 270          * Create a copy for `strtok' to destroy
 271          */
 272         strncpy (file_copy, file_orig, 512);
 273         file_copy[511] = '\0';
 274
 275         /*
 276          * Break into components. This will eat up several slashes in a row and
 277          * remove leading and trailing slashes..
 278          */
 279         ptr = file_copy;
 280         fields_num = 0;
 281         while ((fields[fields_num] = strtok (ptr, "/")) != NULL)
 282         {
 283                 ptr = NULL;
 284                 fields_num++;
 285
 286                 if (fields_num >= 16)
 287                         break;
 288         }
 289
 290         /*
 291          * For each component, do..
 292          */
 293         for (i = 0; i < (fields_num - last_is_file); i++)
 294         {
 295                 /*
 296                  * Do not create directories that start with a dot. This
 297                  * prevents `../../' attacks and other likely malicious
 298                  * behavior.
 299                  */
 300                 if (fields[i][0] == '.')
 301                 {
 302                         syslog (LOG_ERR, "Cowardly refusing to create a directory that begins with a `.' (dot): `%s'", file_orig);
 303                         return (-2);
 304                 }
 305
 306                 /*
 307                  * Join the components together again
 308                  */
 309                 if (strjoin (dir, dir_len, fields, i + 1, "/") < 0)
 310                 {
 311                         syslog (LOG_ERR, "strjoin failed: `%s', component #%i", file_orig, i);
 312                         return (-1);
 313                 }
 314
 315                 if (stat (dir, &statbuf) == -1)
 316                 {
 317                         if (errno == ENOENT)
 318                         {
 319                                 if (mkdir (dir, 0755) == -1)
 320                                 {
 321                                         syslog (LOG_ERR, "mkdir (%s): %s", dir, strerror (errno));
 322                                         return (-1);
 323                                 }
 324                         }
 325                         else
 326                         {
 327                                 syslog (LOG_ERR, "stat (%s): %s", dir, strerror (errno));
 328                                 return (-1);
 329                         }
 330                 }
 331                 else if (!S_ISDIR (statbuf.st_mode))
 332                 {
 333                         syslog (LOG_ERR, "stat (%s): Not a directory!", dir);
 334                         return (-1);
 335                 }
 336         }
 337
 338         return (0);
 339 }
 340
 341 /* * * * *
 342  * Magic *
 343  * * * * */
 344 int rra_get (char ***ret)
 345 {
 346         static char **rra_def = NULL;
 347         static int rra_num = 0;
 348
 349         int rra_max = rra_timespans_num * rra_types_num;
 350
 351         int step;
 352         int rows;
 353         int span;
 354
 355         int cdp_num;
 356         int cdp_len;
 357         int i, j;
 358
 359         char buffer[64];
 360
 361         if ((rra_num != 0) && (rra_def != NULL))
 362         {
 363                 *ret = rra_def;
 364                 return (rra_num);
 365         }
 366
 367         if ((rra_def = (char **) malloc ((rra_max + 1) * sizeof (char *))) == NULL)
 368                 return (-1);
 369         memset (rra_def, '\0', (rra_max + 1) * sizeof (char *));
 370
 371         step = atoi (COLLECTD_STEP);
 372         rows = atoi (COLLECTD_ROWS);
 373
 374         if ((step <= 0) || (rows <= 0))
 375         {
 376                 *ret = NULL;
 377                 return (-1);
 378         }
 379
 380         cdp_len = 0;
 381         for (i = 0; i < rra_timespans_num; i++)
 382         {
 383                 span = rra_timespans[i];
 384
 385                 if ((span / step) < rows)
 386                         continue;
 387
 388                 if (cdp_len == 0)
 389                         cdp_len = 1;
 390                 else
 391                         cdp_len = (int) floor (((double) span) / ((double) (rows * step)));
 392
 393                 cdp_num = (int) ceil (((double) span) / ((double) (cdp_len * step)));
 394
 395                 for (j = 0; j < rra_types_num; j++)
 396                 {
 397                         if (rra_num >= rra_max)
 398                                 break;
 399
 400                         if (snprintf (buffer, sizeof(buffer), "RRA:%s:%3.1f:%u:%u",
 401                                                 rra_types[j], COLLECTD_XFF,
 402                                                 cdp_len, cdp_num) >= sizeof (buffer))
 403                         {
 404                                 syslog (LOG_ERR, "rra_get: Buffer would have been truncated.");
 405                                 continue;
 406                         }
 407
 408                         rra_def[rra_num++] = sstrdup (buffer);
 409                 }
 410         }
 411
 412 #if COLLECT_DEBUG
 413         DBG ("rra_num = %i", rra_num);
 414         for (i = 0; i < rra_num; i++)
 415                 DBG ("  %s", rra_def[i]);
 416 #endif
 417
 418         *ret = rra_def;
 419         return (rra_num);
 420 }
 421
 422 int rrd_create_file (char *filename, char **ds_def, int ds_num)
 423 {
 424         char **argv;
 425         int argc;
 426         char **rra_def;
 427         int rra_num;
 428         int i, j;
 429         int status = 0;
 430
 431         if (check_create_dir (filename))
 432                 return (-1);
 433
 434         if ((rra_num = rra_get (&rra_def)) < 1)
 435         {
 436                 syslog (LOG_ERR, "rra_create failed: Could not calculate RRAs");
 437                 return (-1);
 438         }
 439
 440         argc = ds_num + rra_num + 4;
 441
 442         if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
 443         {
 444                 syslog (LOG_ERR, "rrd_create failed: %s", strerror (errno));
 445                 return (-1);
 446         }
 447
 448         argv[0] = "create";
 449         argv[1] = filename;
 450         argv[2] = "-s";
 451         argv[3] = COLLECTD_STEP;
 452
 453         j = 4;
 454         for (i = 0; i < ds_num; i++)
 455                 argv[j++] = ds_def[i];
 456         for (i = 0; i < rra_num; i++)
 457                 argv[j++] = rra_def[i];
 458         argv[j] = NULL;
 459
 460         optind = 0; /* bug in librrd? */
 461         rrd_clear_error ();
 462         if (rrd_create (argc, argv) == -1)
 463         {
 464                 syslog (LOG_ERR, "rrd_create failed: %s: %s", filename, rrd_get_error ());
 465                 status = -1;
 466         }
 467
 468         free (argv);
 469
 470         return (status);
 471 }
 472 #endif /* HAVE_LIBRRD */
 473
 474 int rrd_update_file (char *host, char *file, char *values,
 475                 char **ds_def, int ds_num)
 476 {
 477 #ifdef HAVE_LIBRRD
 478         struct stat statbuf;
 479         char full_file[1024];
 480         char *argv[4] = { "update", full_file, values, NULL };
 481
 482         /* host == NULL => local mode */
 483         if (host != NULL)
 484         {
 485                 if (snprintf (full_file, 1024, "%s/%s", host, file) >= 1024)
 486                         return (-1);
 487         }
 488         else
 489         {
 490                 if (snprintf (full_file, 1024, "%s", file) >= 1024)
 491                         return (-1);
 492         }
 493
 494         if (stat (full_file, &statbuf) == -1)
 495         {
 496                 if (errno == ENOENT)
 497                 {
 498                         if (rrd_create_file (full_file, ds_def, ds_num))
 499                                 return (-1);
 500                 }
 501                 else
 502                 {
 503                         syslog (LOG_ERR, "stat %s: %s", full_file, strerror (errno));
 504                         return (-1);
 505                 }
 506         }
 507         else if (!S_ISREG (statbuf.st_mode))
 508         {
 509                 syslog (LOG_ERR, "stat %s: Not a regular file!", full_file);
 510                 return (-1);
 511         }
 512
 513         optind = 0; /* bug in librrd? */
 514         rrd_clear_error ();
 515         if (rrd_update (3, argv) == -1)
 516         {
 517                 syslog (LOG_WARNING, "rrd_update failed: %s: %s", full_file, rrd_get_error ());
 518                 return (-1);
 519         }
 520 #endif /* HAVE_LIBRRD */
 521
 522         return (0);
 523 }
 524
 525 #ifdef HAVE_LIBKSTAT
 526 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
 527 {
 528         char ident[128];
 529
 530         if (kc == NULL)
 531                 return (-1);
 532
 533         snprintf (ident, 128, "%s,%i,%s", module, instance, name);
 534         ident[127] = '\0';
 535
 536         if (*ksp_ptr == NULL)
 537         {
 538                 if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL)
 539                 {
 540                         syslog (LOG_ERR, "Cound not find kstat %s", ident);
 541                         return (-1);
 542                 }
 543
 544                 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
 545                 {
 546                         syslog (LOG_WARNING, "kstat %s has wrong type", ident);
 547                         *ksp_ptr = NULL;
 548                         return (-1);
 549                 }
 550         }
 551
 552 #ifdef assert
 553         assert (*ksp_ptr != NULL);
 554         assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
 555 #endif
 556
 557         if (kstat_read (kc, *ksp_ptr, NULL) == -1)
 558         {
 559                 syslog (LOG_WARNING, "kstat %s could not be read", ident);
 560                 return (-1);
 561         }
 562
 563         if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
 564         {
 565                 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
 566                 return (-1);
 567         }
 568
 569         return (0);
 570 }
 571
 572 long long get_kstat_value (kstat_t *ksp, char *name)
 573 {
 574         kstat_named_t *kn;
 575         long long retval = -1LL;
 576
 577 #ifdef assert
 578         assert (ksp != NULL);
 579         assert (ksp->ks_type == KSTAT_TYPE_NAMED);
 580 #else
 581         if (ksp == NULL)
 582         {
 583                 fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__);
 584                 return (-1LL);
 585         }
 586         else if (ksp->ks_type != KSTAT_TYPE_NAMED)
 587         {
 588                 fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__);
 589                 return (-1LL);
 590         }
 591 #endif
 592
 593         if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
 594                 return (retval);
 595
 596         if (kn->data_type == KSTAT_DATA_INT32)
 597                 retval = (long long) kn->value.i32;
 598         else if (kn->data_type == KSTAT_DATA_UINT32)
 599                 retval = (long long) kn->value.ui32;
 600         else if (kn->data_type == KSTAT_DATA_INT64)
 601                 retval = (long long) kn->value.i64; /* According to ANSI C99 `long long' must hold at least 64 bits */
 602         else if (kn->data_type == KSTAT_DATA_UINT64)
 603                 retval = (long long) kn->value.ui64; /* XXX: Might overflow! */
 604         else
 605                 syslog (LOG_WARNING, "get_kstat_value: Not a numeric value: %s", name);
 606
 607         return (retval);
 608 }
 609 #endif /* HAVE_LIBKSTAT */