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_LIBKSTAT
  29 extern kstat_ctl_t *kc;
  30 #endif
  31
  32 #ifdef HAVE_LIBRRD
  33 static char *rra_def[] =
  34 {
  35                 "RRA:AVERAGE:0.2:6:1500",
  36                 "RRA:AVERAGE:0.1:180:1680",
  37                 "RRA:AVERAGE:0.1:2160:1520",
  38                 "RRA:MIN:0.2:6:1500",
  39                 "RRA:MIN:0.1:180:1680",
  40                 "RRA:MIN:0.1:2160:1520",
  41                 "RRA:MAX:0.2:6:1500",
  42                 "RRA:MAX:0.1:180:1680",
  43                 "RRA:MAX:0.1:2160:1520",
  44                 NULL
  45 };
  46 static int rra_num = 9;
  47 #endif /* HAVE_LIBRRD */
  48
  49 void
  50 sstrncpy(char *d, const char *s, int len)
  51 {
  52         strncpy(d, s, len);
  53         d[len - 1] = 0;
  54 }
  55
  56 char *
  57 sstrdup(const char *s)
  58 {
  59         char *r = strdup(s);
  60         if(r == NULL) {
  61                 DBG("Not enough memory.");
  62                 exit(3);
  63         }
  64         return r;
  65 }
  66
  67 void *
  68 smalloc(size_t size)
  69 {
  70         void *r = malloc(size);
  71         if(r == NULL) {
  72                 DBG("Not enough memory.");
  73                 exit(3);
  74         }
  75         return r;
  76 }
  77
  78 int strsplit (char *string, char **fields, size_t size)
  79 {
  80         size_t i;
  81         char *ptr;
  82
  83         i = 0;
  84         ptr = string;
  85         while ((fields[i] = strtok (ptr, " \t")) != NULL)
  86         {
  87                 ptr = NULL;
  88                 i++;
  89
  90                 if (i >= size)
  91                         break;
  92         }
  93
  94         return (i);
  95 }
  96
  97 #ifdef HAVE_LIBRRD
  98 int check_create_dir (char *dir)
  99 {
 100         struct stat statbuf;
 101
 102         if (stat (dir, &statbuf) == -1)
 103         {
 104                 if (errno == ENOENT)
 105                 {
 106                         if (mkdir (dir, 0755) == -1)
 107                         {
 108                                 syslog (LOG_ERR, "mkdir (%s): %s", dir, strerror (errno));
 109                                 return (-1);
 110                         }
 111                 }
 112                 else
 113                 {
 114                         syslog (LOG_ERR, "stat (%s): %s", dir, strerror (errno));
 115                         return (-1);
 116                 }
 117         }
 118         else if (!S_ISDIR (statbuf.st_mode))
 119         {
 120                 syslog (LOG_ERR, "stat %s: Not a directory!", dir);
 121                 return (-1);
 122         }
 123
 124         return (0);
 125 }
 126
 127 int rrd_create_file (char *filename, char **ds_def, int ds_num)
 128 {
 129         char **argv;
 130         int argc;
 131         int i, j;
 132         int status = 0;
 133
 134         argc = ds_num + rra_num + 4;
 135
 136         if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
 137         {
 138                 syslog (LOG_ERR, "rrd_create failed: %s", strerror (errno));
 139                 return (-1);
 140         }
 141
 142         argv[0] = "create";
 143         argv[1] = filename;
 144         argv[2] = "-s";
 145         argv[3] = "10";
 146
 147         j = 4;
 148         for (i = 0; i < ds_num; i++)
 149                 argv[j++] = ds_def[i];
 150         for (i = 0; i < rra_num; i++)
 151                 argv[j++] = rra_def[i];
 152         argv[j] = NULL;
 153
 154         optind = 0; /* bug in librrd? */
 155         rrd_clear_error ();
 156         if (rrd_create (argc, argv) == -1)
 157         {
 158                 syslog (LOG_ERR, "rrd_create failed: %s: %s", filename, rrd_get_error ());
 159                 status = -1;
 160         }
 161
 162         free (argv);
 163
 164         return (status);
 165 }
 166 #endif /* HAVE_LIBRRD */
 167
 168 int rrd_update_file (char *host, char *file, char *values,
 169                 char **ds_def, int ds_num)
 170 {
 171 #ifdef HAVE_LIBRRD
 172         struct stat statbuf;
 173         char full_file[1024];
 174         char *argv[4] = { "update", full_file, values, NULL };
 175
 176         /* host == NULL => local mode */
 177         if (host != NULL)
 178         {
 179                 if (check_create_dir (host))
 180                         return (-1);
 181
 182                 if (snprintf (full_file, 1024, "%s/%s", host, file) >= 1024)
 183                         return (-1);
 184         }
 185         else
 186         {
 187                 if (snprintf (full_file, 1024, "%s", file) >= 1024)
 188                         return (-1);
 189         }
 190
 191         if (stat (full_file, &statbuf) == -1)
 192         {
 193                 if (errno == ENOENT)
 194                 {
 195                         if (rrd_create_file (full_file, ds_def, ds_num))
 196                                 return (-1);
 197                 }
 198                 else
 199                 {
 200                         syslog (LOG_ERR, "stat %s: %s", full_file, strerror (errno));
 201                         return (-1);
 202                 }
 203         }
 204         else if (!S_ISREG (statbuf.st_mode))
 205         {
 206                 syslog (LOG_ERR, "stat %s: Not a regular file!", full_file);
 207                 return (-1);
 208         }
 209
 210         optind = 0; /* bug in librrd? */
 211         rrd_clear_error ();
 212         if (rrd_update (3, argv) == -1)
 213         {
 214                 syslog (LOG_WARNING, "rrd_update failed: %s: %s", full_file, rrd_get_error ());
 215                 return (-1);
 216         }
 217 #endif /* HAVE_LIBRRD */
 218
 219         return (0);
 220 }
 221
 222 #ifdef HAVE_LIBKSTAT
 223 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
 224 {
 225         char ident[128];
 226
 227         if (kc == NULL)
 228                 return (-1);
 229
 230         snprintf (ident, 128, "%s,%i,%s", module, instance, name);
 231         ident[127] = '\0';
 232
 233         if (*ksp_ptr == NULL)
 234         {
 235                 if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL)
 236                 {
 237                         syslog (LOG_ERR, "Cound not find kstat %s", ident);
 238                         return (-1);
 239                 }
 240
 241                 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
 242                 {
 243                         syslog (LOG_WARNING, "kstat %s has wrong type", ident);
 244                         *ksp_ptr = NULL;
 245                         return (-1);
 246                 }
 247         }
 248
 249 #ifdef assert
 250         assert (*ksp_ptr != NULL);
 251         assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
 252 #endif
 253
 254         if (kstat_read (kc, *ksp_ptr, NULL) == -1)
 255         {
 256                 syslog (LOG_WARNING, "kstat %s could not be read", ident);
 257                 return (-1);
 258         }
 259
 260         if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
 261         {
 262                 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
 263                 return (-1);
 264         }
 265
 266         return (0);
 267 }
 268
 269 long long get_kstat_value (kstat_t *ksp, char *name)
 270 {
 271         kstat_named_t *kn;
 272         long long retval = -1LL;
 273
 274 #ifdef assert
 275         assert (ksp != NULL);
 276         assert (ksp->ks_type == KSTAT_TYPE_NAMED);
 277 #else
 278         if (ksp == NULL)
 279         {
 280                 fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__);
 281                 return (-1LL);
 282         }
 283         else if (ksp->ks_type != KSTAT_TYPE_NAMED)
 284         {
 285                 fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__);
 286                 return (-1LL);
 287         }
 288 #endif
 289
 290         if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
 291                 return (retval);
 292
 293         if (kn->data_type == KSTAT_DATA_INT32)
 294                 retval = (long long) kn->value.i32;
 295         else if (kn->data_type == KSTAT_DATA_UINT32)
 296                 retval = (long long) kn->value.ui32;
 297         else if (kn->data_type == KSTAT_DATA_INT64)
 298                 retval = (long long) kn->value.i64; /* According to ANSI C99 `long long' must hold at least 64 bits */
 299         else if (kn->data_type == KSTAT_DATA_UINT64)
 300                 retval = (long long) kn->value.ui64; /* XXX: Might overflow! */
 301         else
 302                 syslog (LOG_WARNING, "get_kstat_value: Not a numeric value: %s", name);
 303
 304         return (retval);
 305 }
 306 #endif /* HAVE_LIBKSTAT */