1 /**
2 * collectd - src/common.c
3 * Copyright (C) 2005,2006 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 extern int operating_mode;
34 #ifdef HAVE_LIBKSTAT
35 extern kstat_ctl_t *kc;
36 #endif
38 #ifdef HAVE_LIBRRD
39 #if 0
40 static char *rra_def[] =
41 {
42 "RRA:AVERAGE:0.0:1:1500",
43 "RRA:AVERAGE:0.2:6:1500",
44 "RRA:AVERAGE:0.1:180:1680",
45 "RRA:AVERAGE:0.1:2160:1520",
46 "RRA:MIN:0.0:1:1500",
47 "RRA:MIN:0.2:6:1500",
48 "RRA:MIN:0.1:180:1680",
49 "RRA:MIN:0.1:2160:1520",
50 "RRA:MAX:0.0:1:1500",
51 "RRA:MAX:0.2:6:1500",
52 "RRA:MAX:0.1:180:1680",
53 "RRA:MAX:0.1:2160:1520",
54 NULL
55 };
56 static int rra_num = 12;
57 #endif
59 static int rra_timespans[] =
60 {
61 3600,
62 86400,
63 604800,
64 2678400,
65 31622400,
66 0
67 };
68 static int rra_timespans_num = 5;
70 static char *rra_types[] =
71 {
72 "AVERAGE",
73 "MIN",
74 "MAX",
75 NULL
76 };
77 static int rra_types_num = 3;
78 #endif /* HAVE_LIBRRD */
80 void sstrncpy (char *d, const char *s, int len)
81 {
82 strncpy (d, s, len);
83 d[len - 1] = '\0';
84 }
86 char *sstrdup (const char *s)
87 {
88 char *r;
90 if (s == NULL)
91 return (NULL);
93 if((r = strdup (s)) == NULL)
94 {
95 DBG ("Not enough memory.");
96 exit(3);
97 }
99 return (r);
100 }
102 void *smalloc (size_t size)
103 {
104 void *r;
106 if ((r = malloc (size)) == NULL)
107 {
108 DBG("Not enough memory.");
109 exit(3);
110 }
112 return r;
113 }
115 #if 0
116 void sfree (void **ptr)
117 {
118 if (ptr == NULL)
119 return;
121 if (*ptr != NULL)
122 free (*ptr);
124 *ptr = NULL;
125 }
126 #endif
128 int strsplit (char *string, char **fields, size_t size)
129 {
130 size_t i;
131 char *ptr;
133 i = 0;
134 ptr = string;
135 while ((fields[i] = strtok (ptr, " \t")) != NULL)
136 {
137 ptr = NULL;
138 i++;
140 if (i >= size)
141 break;
142 }
144 return (i);
145 }
147 int strjoin (char *dst, size_t dst_len,
148 char **fields, size_t fields_num,
149 const char *sep)
150 {
151 int field_len;
152 int sep_len;
153 int i;
155 memset (dst, '\0', dst_len);
157 if (fields_num <= 0)
158 return (-1);
160 sep_len = 0;
161 if (sep != NULL)
162 sep_len = strlen (sep);
164 for (i = 0; i < fields_num; i++)
165 {
166 if ((i > 0) && (sep_len > 0))
167 {
168 if (dst_len <= sep_len)
169 return (-1);
171 strncat (dst, sep, dst_len);
172 dst_len -= sep_len;
173 }
175 field_len = strlen (fields[i]);
177 if (dst_len <= field_len)
178 return (-1);
180 strncat (dst, fields[i], dst_len);
181 dst_len -= field_len;
182 }
184 return (strlen (dst));
185 }
187 int strsubstitute (char *str, char c_from, char c_to)
188 {
189 int ret;
191 if (str == NULL)
192 return (-1);
194 ret = 0;
195 while (*str != '\0')
196 {
197 if (*str == c_from)
198 {
199 *str = c_to;
200 ret++;
201 }
202 str++;
203 }
205 return (ret);
206 }
208 int escape_slashes (char *buf, int buf_len)
209 {
210 int i;
212 if (strcmp (buf, "/") == 0)
213 {
214 if (buf_len < 5)
215 return (-1);
217 strncpy (buf, "root", buf_len);
218 return (0);
219 }
221 /* Move one to the left */
222 memmove (buf, buf + 1, buf_len - 1);
224 for (i = 0; i < buf_len - 1; i++)
225 {
226 if (buf[i] == '\0')
227 break;
228 else if (buf[i] == '/')
229 buf[i] = '_';
230 }
231 buf[i] = '\0';
233 return (0);
234 }
236 int timeval_sub_timespec (struct timeval *tv0, struct timeval *tv1, struct timespec *ret)
237 {
238 if ((tv0 == NULL) || (tv1 == NULL) || (ret == NULL))
239 return (-2);
241 if ((tv0->tv_sec < tv1->tv_sec)
242 || ((tv0->tv_sec == tv1->tv_sec) && (tv0->tv_usec < tv1->tv_usec)))
243 return (-1);
245 ret->tv_sec = tv0->tv_sec - tv1->tv_sec;
246 ret->tv_nsec = 1000 * ((long) (tv0->tv_usec - tv1->tv_usec));
248 if (ret->tv_nsec < 0)
249 {
250 assert (ret->tv_sec > 0);
252 ret->tv_nsec += 1000000000;
253 ret->tv_sec -= 1;
254 }
256 return (0);
257 }
259 static int check_create_dir (const char *file_orig)
260 {
261 struct stat statbuf;
263 char file_copy[512];
264 char dir[512];
265 int dir_len = 512;
266 char *fields[16];
267 int fields_num;
268 char *ptr;
269 int last_is_file = 1;
270 int len;
271 int i;
273 /*
274 * Sanity checks first
275 */
276 if (file_orig == NULL)
277 return (-1);
279 if ((len = strlen (file_orig)) < 1)
280 return (-1);
281 else if (len >= 512)
282 return (-1);
284 /*
285 * If `file_orig' ends in a slash the last component is a directory,
286 * otherwise it's a file. Act accordingly..
287 */
288 if (file_orig[len - 1] == '/')
289 last_is_file = 0;
291 /*
292 * Create a copy for `strtok' to destroy
293 */
294 strncpy (file_copy, file_orig, 512);
295 file_copy[511] = '\0';
297 /*
298 * Break into components. This will eat up several slashes in a row and
299 * remove leading and trailing slashes..
300 */
301 ptr = file_copy;
302 fields_num = 0;
303 while ((fields[fields_num] = strtok (ptr, "/")) != NULL)
304 {
305 ptr = NULL;
306 fields_num++;
308 if (fields_num >= 16)
309 break;
310 }
312 /*
313 * For each component, do..
314 */
315 for (i = 0; i < (fields_num - last_is_file); i++)
316 {
317 /*
318 * Do not create directories that start with a dot. This
319 * prevents `../../' attacks and other likely malicious
320 * behavior.
321 */
322 if (fields[i][0] == '.')
323 {
324 syslog (LOG_ERR, "Cowardly refusing to create a directory that begins with a `.' (dot): `%s'", file_orig);
325 return (-2);
326 }
328 /*
329 * Join the components together again
330 */
331 if (strjoin (dir, dir_len, fields, i + 1, "/") < 0)
332 {
333 syslog (LOG_ERR, "strjoin failed: `%s', component #%i", file_orig, i);
334 return (-1);
335 }
337 if (stat (dir, &statbuf) == -1)
338 {
339 if (errno == ENOENT)
340 {
341 if (mkdir (dir, 0755) == -1)
342 {
343 syslog (LOG_ERR, "mkdir (%s): %s", dir, strerror (errno));
344 return (-1);
345 }
346 }
347 else
348 {
349 syslog (LOG_ERR, "stat (%s): %s", dir, strerror (errno));
350 return (-1);
351 }
352 }
353 else if (!S_ISDIR (statbuf.st_mode))
354 {
355 syslog (LOG_ERR, "stat (%s): Not a directory!", dir);
356 return (-1);
357 }
358 }
360 return (0);
361 }
363 /* * * * *
364 * Magic *
365 * * * * */
366 #if HAVE_LIBRRD
367 static int rra_get (char ***ret)
368 {
369 static char **rra_def = NULL;
370 static int rra_num = 0;
372 int rra_max = rra_timespans_num * rra_types_num;
374 int step;
375 int rows;
376 int span;
378 int cdp_num;
379 int cdp_len;
380 int i, j;
382 char buffer[64];
384 if ((rra_num != 0) && (rra_def != NULL))
385 {
386 *ret = rra_def;
387 return (rra_num);
388 }
390 if ((rra_def = (char **) malloc ((rra_max + 1) * sizeof (char *))) == NULL)
391 return (-1);
392 memset (rra_def, '\0', (rra_max + 1) * sizeof (char *));
394 step = atoi (COLLECTD_STEP);
395 rows = atoi (COLLECTD_ROWS);
397 if ((step <= 0) || (rows <= 0))
398 {
399 *ret = NULL;
400 return (-1);
401 }
403 cdp_len = 0;
404 for (i = 0; i < rra_timespans_num; i++)
405 {
406 span = rra_timespans[i];
408 if ((span / step) < rows)
409 continue;
411 if (cdp_len == 0)
412 cdp_len = 1;
413 else
414 cdp_len = (int) floor (((double) span) / ((double) (rows * step)));
416 cdp_num = (int) ceil (((double) span) / ((double) (cdp_len * step)));
418 for (j = 0; j < rra_types_num; j++)
419 {
420 if (rra_num >= rra_max)
421 break;
423 if (snprintf (buffer, sizeof(buffer), "RRA:%s:%3.1f:%u:%u",
424 rra_types[j], COLLECTD_XFF,
425 cdp_len, cdp_num) >= sizeof (buffer))
426 {
427 syslog (LOG_ERR, "rra_get: Buffer would have been truncated.");
428 continue;
429 }
431 rra_def[rra_num++] = sstrdup (buffer);
432 }
433 }
435 #if COLLECT_DEBUG
436 DBG ("rra_num = %i", rra_num);
437 for (i = 0; i < rra_num; i++)
438 DBG (" %s", rra_def[i]);
439 #endif
441 *ret = rra_def;
442 return (rra_num);
443 }
444 #endif /* HAVE_LIBRRD */
446 static int log_create_file (char *filename, char **ds_def, int ds_num)
447 {
448 FILE *log;
449 int i;
451 if (check_create_dir (filename))
452 return (-1);
454 log = fopen (filename, "w");
455 if (log == NULL)
456 {
457 syslog (LOG_WARNING, "Failed to create %s: %s", filename,
458 strerror(errno));
459 return (-1);
460 }
462 fprintf (log, "epoch");
463 for (i = 0; i < ds_num; i++)
464 {
465 char *name;
466 char *tmp;
468 name = strchr (ds_def[i], ':');
469 if (name == NULL)
470 {
471 syslog (LOG_WARNING, "Invalid DS definition '%s' for %s",
472 ds_def[i], filename);
473 fclose(log);
474 remove(filename);
475 return (-1);
476 }
478 name += 1;
479 tmp = strchr (name, ':');
480 if (tmp == NULL)
481 {
482 syslog (LOG_WARNING, "Invalid DS definition '%s' for %s",
483 ds_def[i], filename);
484 fclose(log);
485 remove(filename);
486 return (-1);
487 }
489 /* The `%.*s' is needed because there is no null-byte behind
490 * the name. */
491 fprintf(log, ",%.*s", (int) (tmp - name), name);
492 }
493 fprintf(log, "\n");
494 fclose(log);
496 return 0;
497 }
499 static int log_update_file (char *host, char *file, char *values,
500 char **ds_def, int ds_num)
501 {
502 char *tmp;
503 FILE *fp;
504 struct stat statbuf;
505 char full_file[1024];
507 /* Cook the values a bit: Substitute colons with commas */
508 strsubstitute (values, ':', ',');
510 /* host == NULL => local mode */
511 if (host != NULL)
512 {
513 if (snprintf (full_file, 1024, "%s/%s", host, file) >= 1024)
514 return (-1);
515 }
516 else
517 {
518 if (snprintf (full_file, 1024, "%s", file) >= 1024)
519 return (-1);
520 }
522 strncpy (full_file, file, 1024);
524 tmp = full_file + strlen (full_file) - 4;
525 assert ((tmp != NULL) && (tmp > full_file));
527 /* Change the filename for logfiles. */
528 if (strncmp (tmp, ".rrd", 4) == 0)
529 {
530 time_t now;
531 struct tm *tm;
533 /* TODO: Find a way to minimize the calls to `localtime', since
534 * they are pretty expensive.. */
535 now = time (NULL);
536 tm = localtime (&now);
538 strftime (tmp, 1024 - (tmp - full_file), "-%Y-%m-%d", tm);
540 /* `localtime(3)' returns a pointer to static data,
541 * therefore the pointer may not be free'd. */
542 }
543 else
544 DBG ("The filename ends with `%s' which is unexpected.", tmp);
546 if (stat (full_file, &statbuf) == -1)
547 {
548 if (errno == ENOENT)
549 {
550 if (log_create_file (full_file, ds_def, ds_num))
551 return (-1);
552 }
553 else
554 {
555 syslog (LOG_ERR, "stat %s: %s", full_file, strerror (errno));
556 return (-1);
557 }
558 }
559 else if (!S_ISREG (statbuf.st_mode))
560 {
561 syslog (LOG_ERR, "stat %s: Not a regular file!", full_file);
562 return (-1);
563 }
566 fp = fopen (full_file, "a");
567 if (fp == NULL)
568 {
569 syslog (LOG_WARNING, "Failed to append to %s: %s", full_file,
570 strerror(errno));
571 return (-1);
572 }
573 fprintf(fp, "%s\n", values);
574 fclose(fp);
576 return (0);
577 } /* int log_update_file */
579 #if HAVE_LIBRRD
580 static int rrd_create_file (char *filename, char **ds_def, int ds_num)
581 {
582 char **argv;
583 int argc;
584 char **rra_def;
585 int rra_num;
586 int i, j;
587 int status = 0;
589 if (check_create_dir (filename))
590 return (-1);
592 if ((rra_num = rra_get (&rra_def)) < 1)
593 {
594 syslog (LOG_ERR, "rra_create failed: Could not calculate RRAs");
595 return (-1);
596 }
598 argc = ds_num + rra_num + 4;
600 if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
601 {
602 syslog (LOG_ERR, "rrd_create failed: %s", strerror (errno));
603 return (-1);
604 }
606 argv[0] = "create";
607 argv[1] = filename;
608 argv[2] = "-s";
609 argv[3] = COLLECTD_STEP;
611 j = 4;
612 for (i = 0; i < ds_num; i++)
613 argv[j++] = ds_def[i];
614 for (i = 0; i < rra_num; i++)
615 argv[j++] = rra_def[i];
616 argv[j] = NULL;
618 optind = 0; /* bug in librrd? */
619 rrd_clear_error ();
620 if (rrd_create (argc, argv) == -1)
621 {
622 syslog (LOG_ERR, "rrd_create failed: %s: %s", filename, rrd_get_error ());
623 status = -1;
624 }
626 free (argv);
628 return (status);
629 }
630 #endif /* HAVE_LIBRRD */
632 int rrd_update_file (char *host, char *file, char *values,
633 char **ds_def, int ds_num)
634 {
635 #if HAVE_LIBRRD
636 struct stat statbuf;
637 char full_file[1024];
638 char *argv[4] = { "update", full_file, values, NULL };
639 #endif /* HAVE_LIBRRD */
641 /* I'd rather have a function `common_update_file' to make this
642 * decission, but for that we'd need to touch all plugins.. */
643 if (operating_mode == MODE_LOG)
644 return (log_update_file (host, file, values,
645 ds_def, ds_num));
647 #if HAVE_LIBRRD
648 /* host == NULL => local mode */
649 if (host != NULL)
650 {
651 if (snprintf (full_file, 1024, "%s/%s", host, file) >= 1024)
652 return (-1);
653 }
654 else
655 {
656 if (snprintf (full_file, 1024, "%s", file) >= 1024)
657 return (-1);
658 }
660 if (stat (full_file, &statbuf) == -1)
661 {
662 if (errno == ENOENT)
663 {
664 if (rrd_create_file (full_file, ds_def, ds_num))
665 return (-1);
666 }
667 else
668 {
669 syslog (LOG_ERR, "stat %s: %s", full_file, strerror (errno));
670 return (-1);
671 }
672 }
673 else if (!S_ISREG (statbuf.st_mode))
674 {
675 syslog (LOG_ERR, "stat %s: Not a regular file!", full_file);
676 return (-1);
677 }
679 optind = 0; /* bug in librrd? */
680 rrd_clear_error ();
681 if (rrd_update (3, argv) == -1)
682 {
683 syslog (LOG_WARNING, "rrd_update failed: %s: %s", full_file, rrd_get_error ());
684 return (-1);
685 }
686 return (0);
687 /* #endif HAVE_LIBRRD */
689 #else
690 syslog (LOG_ERR, "`rrd_update_file' was called, but collectd isn't linked against librrd!");
691 return (-1);
692 #endif
693 }
695 #ifdef HAVE_LIBKSTAT
696 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
697 {
698 char ident[128];
700 if (kc == NULL)
701 return (-1);
703 snprintf (ident, 128, "%s,%i,%s", module, instance, name);
704 ident[127] = '\0';
706 if (*ksp_ptr == NULL)
707 {
708 if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL)
709 {
710 syslog (LOG_ERR, "Cound not find kstat %s", ident);
711 return (-1);
712 }
714 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
715 {
716 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
717 *ksp_ptr = NULL;
718 return (-1);
719 }
720 }
722 #ifdef assert
723 assert (*ksp_ptr != NULL);
724 assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
725 #endif
727 if (kstat_read (kc, *ksp_ptr, NULL) == -1)
728 {
729 syslog (LOG_WARNING, "kstat %s could not be read", ident);
730 return (-1);
731 }
733 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
734 {
735 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
736 return (-1);
737 }
739 return (0);
740 }
742 long long get_kstat_value (kstat_t *ksp, char *name)
743 {
744 kstat_named_t *kn;
745 long long retval = -1LL;
747 #ifdef assert
748 assert (ksp != NULL);
749 assert (ksp->ks_type == KSTAT_TYPE_NAMED);
750 #else
751 if (ksp == NULL)
752 {
753 fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__);
754 return (-1LL);
755 }
756 else if (ksp->ks_type != KSTAT_TYPE_NAMED)
757 {
758 fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__);
759 return (-1LL);
760 }
761 #endif
763 if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
764 return (retval);
766 if (kn->data_type == KSTAT_DATA_INT32)
767 retval = (long long) kn->value.i32;
768 else if (kn->data_type == KSTAT_DATA_UINT32)
769 retval = (long long) kn->value.ui32;
770 else if (kn->data_type == KSTAT_DATA_INT64)
771 retval = (long long) kn->value.i64; /* According to ANSI C99 `long long' must hold at least 64 bits */
772 else if (kn->data_type == KSTAT_DATA_UINT64)
773 retval = (long long) kn->value.ui64; /* XXX: Might overflow! */
774 else
775 syslog (LOG_WARNING, "get_kstat_value: Not a numeric value: %s", name);
777 return (retval);
778 }
779 #endif /* HAVE_LIBKSTAT */