72cc5589d42bd2b16697e7ea037f28b31e8296d7
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 **/
25 #include "common.h"
26 #include "utils_debug.h"
28 #ifdef HAVE_MATH_H
29 # include <math.h>
30 #endif
32 #ifdef HAVE_LIBKSTAT
33 extern kstat_ctl_t *kc;
34 #endif
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
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;
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 */
78 void sstrncpy (char *d, const char *s, int len)
79 {
80 strncpy (d, s, len);
81 d[len - 1] = '\0';
82 }
84 char *sstrdup (const char *s)
85 {
86 char *r;
88 if (s == NULL)
89 return (NULL);
91 if((r = strdup (s)) == NULL)
92 {
93 DBG ("Not enough memory.");
94 exit(3);
95 }
97 return (r);
98 }
100 void *smalloc (size_t size)
101 {
102 void *r;
104 if ((r = malloc (size)) == NULL)
105 {
106 DBG("Not enough memory.");
107 exit(3);
108 }
110 return r;
111 }
113 #if 0
114 void sfree (void **ptr)
115 {
116 if (ptr == NULL)
117 return;
119 if (*ptr != NULL)
120 free (*ptr);
122 *ptr = NULL;
123 }
124 #endif
126 int strsplit (char *string, char **fields, size_t size)
127 {
128 size_t i;
129 char *ptr;
131 i = 0;
132 ptr = string;
133 while ((fields[i] = strtok (ptr, " \t")) != NULL)
134 {
135 ptr = NULL;
136 i++;
138 if (i >= size)
139 break;
140 }
142 return (i);
143 }
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;
153 memset (dst, '\0', dst_len);
155 if (fields_num <= 0)
156 return (-1);
158 sep_len = 0;
159 if (sep != NULL)
160 sep_len = strlen (sep);
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);
169 strncat (dst, sep, dst_len);
170 dst_len -= sep_len;
171 }
173 field_len = strlen (fields[i]);
175 if (dst_len <= field_len)
176 return (-1);
178 strncat (dst, fields[i], dst_len);
179 dst_len -= field_len;
180 }
182 return (strlen (dst));
183 }
185 int escape_slashes (char *buf, int buf_len)
186 {
187 int i;
189 if (strcmp (buf, "/") == 0)
190 {
191 if (buf_len < 5)
192 return (-1);
194 strncpy (buf, "root", buf_len);
195 return (0);
196 }
198 /* Move one to the left */
199 memmove (buf, buf + 1, buf_len - 1);
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';
210 return (0);
211 }
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);
218 if ((tv0->tv_sec < tv1->tv_sec)
219 || ((tv0->tv_sec == tv1->tv_sec) && (tv0->tv_usec < tv1->tv_usec)))
220 return (-1);
222 ret->tv_sec = tv0->tv_sec - tv1->tv_sec;
223 ret->tv_nsec = 1000 * ((long) (tv0->tv_usec - tv1->tv_usec));
225 if (ret->tv_nsec < 0)
226 {
227 assert (ret->tv_sec > 0);
229 ret->tv_nsec += 1000000000;
230 ret->tv_sec -= 1;
231 }
233 return (0);
234 }
236 #ifdef HAVE_LIBRRD
237 int check_create_dir (const char *file_orig)
238 {
239 struct stat statbuf;
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;
251 /*
252 * Sanity checks first
253 */
254 if (file_orig == NULL)
255 return (-1);
257 if ((len = strlen (file_orig)) < 1)
258 return (-1);
259 else if (len >= 512)
260 return (-1);
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;
269 /*
270 * Create a copy for `strtok' to destroy
271 */
272 strncpy (file_copy, file_orig, 512);
273 file_copy[511] = '\0';
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++;
286 if (fields_num >= 16)
287 break;
288 }
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 }
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 }
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 }
338 return (0);
339 }
341 /* * * * *
342 * Magic *
343 * * * * */
344 int rra_get (char ***ret)
345 {
346 static char **rra_def = NULL;
347 static int rra_num = 0;
349 int rra_max = rra_timespans_num * rra_types_num;
351 int step;
352 int rows;
353 int span;
355 int cdp_num;
356 int cdp_len;
357 int i, j;
359 char buffer[64];
361 if ((rra_num != 0) && (rra_def != NULL))
362 {
363 *ret = rra_def;
364 return (rra_num);
365 }
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 *));
371 step = atoi (COLLECTD_STEP);
372 rows = atoi (COLLECTD_ROWS);
374 if ((step <= 0) || (rows <= 0))
375 {
376 *ret = NULL;
377 return (-1);
378 }
380 cdp_len = 0;
381 for (i = 0; i < rra_timespans_num; i++)
382 {
383 span = rra_timespans[i];
385 if ((span / step) < rows)
386 continue;
388 if (cdp_len == 0)
389 cdp_len = 1;
390 else
391 cdp_len = (int) floor (((double) span) / ((double) (rows * step)));
393 cdp_num = (int) ceil (((double) span) / ((double) (cdp_len * step)));
395 for (j = 0; j < rra_types_num; j++)
396 {
397 if (rra_num >= rra_max)
398 break;
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 }
408 rra_def[rra_num++] = sstrdup (buffer);
409 }
410 }
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
418 *ret = rra_def;
419 return (rra_num);
420 }
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;
431 if (check_create_dir (filename))
432 return (-1);
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 }
440 argc = ds_num + rra_num + 4;
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 }
448 argv[0] = "create";
449 argv[1] = filename;
450 argv[2] = "-s";
451 argv[3] = COLLECTD_STEP;
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;
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 }
468 free (argv);
470 return (status);
471 }
472 #endif /* HAVE_LIBRRD */
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 };
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 }
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 }
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 */
522 return (0);
523 }
525 #ifdef HAVE_LIBKSTAT
526 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
527 {
528 char ident[128];
530 if (kc == NULL)
531 return (-1);
533 snprintf (ident, 128, "%s,%i,%s", module, instance, name);
534 ident[127] = '\0';
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 }
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 }
552 #ifdef assert
553 assert (*ksp_ptr != NULL);
554 assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
555 #endif
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 }
563 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
564 {
565 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
566 return (-1);
567 }
569 return (0);
570 }
572 long long get_kstat_value (kstat_t *ksp, char *name)
573 {
574 kstat_named_t *kn;
575 long long retval = -1LL;
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
593 if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
594 return (retval);
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);
607 return (retval);
608 }
609 #endif /* HAVE_LIBKSTAT */