56ae326a810eada2c828e292f58d0f15c5e673b3
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 extern int operating_mode;
30 #ifdef HAVE_LIBKSTAT
31 extern kstat_ctl_t *kc;
32 #endif
34 #ifdef HAVE_LIBRRD
35 static char *rra_def[] =
36 {
37 "RRA:AVERAGE:0.2:6:1500",
38 "RRA:AVERAGE:0.1:180:1680",
39 "RRA:AVERAGE:0.1:2160:1520",
40 "RRA:MIN:0.2:6:1500",
41 "RRA:MIN:0.1:180:1680",
42 "RRA:MIN:0.1:2160:1520",
43 "RRA:MAX:0.2:6:1500",
44 "RRA:MAX:0.1:180:1680",
45 "RRA:MAX:0.1:2160:1520",
46 NULL
47 };
48 static int rra_num = 9;
49 #endif /* HAVE_LIBRRD */
51 void sstrncpy (char *d, const char *s, int len)
52 {
53 strncpy (d, s, len);
54 d[len - 1] = '\0';
55 }
57 char *sstrdup (const char *s)
58 {
59 char *r;
61 if (s == NULL)
62 return (NULL);
64 if((r = strdup (s)) == NULL)
65 {
66 DBG ("Not enough memory.");
67 exit(3);
68 }
70 return (r);
71 }
73 void *smalloc (size_t size)
74 {
75 void *r;
77 if ((r = malloc (size)) == NULL)
78 {
79 DBG("Not enough memory.");
80 exit(3);
81 }
83 return r;
84 }
86 #if 0
87 void sfree (void **ptr)
88 {
89 if (ptr == NULL)
90 return;
92 if (*ptr != NULL)
93 free (*ptr);
95 *ptr = NULL;
96 }
97 #endif
99 int strsplit (char *string, char **fields, size_t size)
100 {
101 size_t i;
102 char *ptr;
104 i = 0;
105 ptr = string;
106 while ((fields[i] = strtok (ptr, " \t")) != NULL)
107 {
108 ptr = NULL;
109 i++;
111 if (i >= size)
112 break;
113 }
115 return (i);
116 }
118 int strjoin (char *dst, size_t dst_len,
119 char **fields, size_t fields_num,
120 const char *sep)
121 {
122 int field_len;
123 int sep_len;
124 int i;
126 memset (dst, '\0', dst_len);
128 if (fields_num <= 0)
129 return (-1);
131 sep_len = 0;
132 if (sep != NULL)
133 sep_len = strlen (sep);
135 for (i = 0; i < fields_num; i++)
136 {
137 if ((i > 0) && (sep_len > 0))
138 {
139 if (dst_len <= sep_len)
140 return (-1);
142 strncat (dst, sep, dst_len);
143 dst_len -= sep_len;
144 }
146 field_len = strlen (fields[i]);
148 if (dst_len <= field_len)
149 return (-1);
151 strncat (dst, fields[i], dst_len);
152 dst_len -= field_len;
153 }
155 return (strlen (dst));
156 }
158 int strsubstitute (char *str, char c_from, char c_to)
159 {
160 int ret;
162 if (str == NULL)
163 return (-1);
165 ret = 0;
166 while (*str != '\0')
167 {
168 if (*str == c_from)
169 {
170 *str = c_to;
171 ret++;
172 }
173 str++;
174 }
176 return (ret);
177 }
179 int escape_slashes (char *buf, int buf_len)
180 {
181 int i;
183 if (strcmp (buf, "/") == 0)
184 {
185 if (buf_len < 5)
186 return (-1);
188 strncpy (buf, "root", buf_len);
189 return (0);
190 }
192 /* Move one to the left */
193 memmove (buf, buf + 1, buf_len - 1);
195 for (i = 0; i < buf_len - 1; i++)
196 {
197 if (buf[i] == '\0')
198 break;
199 else if (buf[i] == '/')
200 buf[i] = '_';
201 }
202 buf[i] = '\0';
204 return (0);
205 }
207 static int check_create_dir (const char *file_orig)
208 {
209 struct stat statbuf;
211 char file_copy[512];
212 char dir[512];
213 int dir_len = 512;
214 char *fields[16];
215 int fields_num;
216 char *ptr;
217 int last_is_file = 1;
218 int len;
219 int i;
221 /*
222 * Sanity checks first
223 */
224 if (file_orig == NULL)
225 return (-1);
227 if ((len = strlen (file_orig)) < 1)
228 return (-1);
229 else if (len >= 512)
230 return (-1);
232 /*
233 * If `file_orig' ends in a slash the last component is a directory,
234 * otherwise it's a file. Act accordingly..
235 */
236 if (file_orig[len - 1] == '/')
237 last_is_file = 0;
239 /*
240 * Create a copy for `strtok' to destroy
241 */
242 strncpy (file_copy, file_orig, 512);
243 file_copy[511] = '\0';
245 /*
246 * Break into components. This will eat up several slashes in a row and
247 * remove leading and trailing slashes..
248 */
249 ptr = file_copy;
250 fields_num = 0;
251 while ((fields[fields_num] = strtok (ptr, "/")) != NULL)
252 {
253 ptr = NULL;
254 fields_num++;
256 if (fields_num >= 16)
257 break;
258 }
260 /*
261 * For each component, do..
262 */
263 for (i = 0; i < (fields_num - last_is_file); i++)
264 {
265 /*
266 * Do not create directories that start with a dot. This
267 * prevents `../../' attacks and other likely malicious
268 * behavior.
269 */
270 if (fields[i][0] == '.')
271 {
272 syslog (LOG_ERR, "Cowardly refusing to create a directory that begins with a `.' (dot): `%s'", file_orig);
273 return (-2);
274 }
276 /*
277 * Join the components together again
278 */
279 if (strjoin (dir, dir_len, fields, i + 1, "/") < 0)
280 {
281 syslog (LOG_ERR, "strjoin failed: `%s', component #%i", file_orig, i);
282 return (-1);
283 }
285 if (stat (dir, &statbuf) == -1)
286 {
287 if (errno == ENOENT)
288 {
289 if (mkdir (dir, 0755) == -1)
290 {
291 syslog (LOG_ERR, "mkdir (%s): %s", dir, strerror (errno));
292 return (-1);
293 }
294 }
295 else
296 {
297 syslog (LOG_ERR, "stat (%s): %s", dir, strerror (errno));
298 return (-1);
299 }
300 }
301 else if (!S_ISDIR (statbuf.st_mode))
302 {
303 syslog (LOG_ERR, "stat (%s): Not a directory!", dir);
304 return (-1);
305 }
306 }
308 return (0);
309 }
311 static int log_create_file (char *filename, char **ds_def, int ds_num)
312 {
313 FILE *log;
314 int i;
316 log = fopen (filename, "w");
317 if (log == NULL)
318 {
319 syslog (LOG_WARNING, "Failed to create %s: %s", filename,
320 strerror(errno));
321 return (-1);
322 }
324 fprintf (log, "epoch");
325 for (i = 0; i < ds_num; i++)
326 {
327 char *name;
328 char *tmp;
330 name = strchr (ds_def[i], ':');
331 if (name == NULL)
332 {
333 syslog (LOG_WARNING, "Invalid DS definition '%s' for %s",
334 ds_def[i], filename);
335 fclose(log);
336 remove(filename);
337 return (-1);
338 }
340 name += 1;
341 tmp = strchr (name, ':');
342 if (tmp == NULL)
343 {
344 syslog (LOG_WARNING, "Invalid DS definition '%s' for %s",
345 ds_def[i], filename);
346 fclose(log);
347 remove(filename);
348 return (-1);
349 }
351 /* The `%.*s' is needed because there is no null-byte behind
352 * the name. */
353 fprintf(log, ",%.*s", (tmp - name), name);
354 }
355 fprintf(log, "\n");
356 fclose(log);
358 return 0;
359 }
361 static int log_update_file (char *host, char *file, char *values,
362 char **ds_def, int ds_num)
363 {
364 char *tmp;
365 FILE *fp;
366 struct stat statbuf;
367 char full_file[1024];
369 /* Cook the values a bit: Substitute colons with commas */
370 strsubstitute (values, ':', ',');
372 /* host == NULL => local mode */
373 if (host != NULL)
374 {
375 if (snprintf (full_file, 1024, "%s/%s", host, file) >= 1024)
376 return (-1);
377 }
378 else
379 {
380 if (snprintf (full_file, 1024, "%s", file) >= 1024)
381 return (-1);
382 }
384 strncpy (full_file, file, 1024);
386 tmp = full_file + strlen (full_file) - 4;
387 assert (tmp > 0);
389 /* Change the filename for logfiles. */
390 if (strncmp (tmp, ".rrd", 4) == 0)
391 {
392 time_t now;
393 struct tm *tm;
395 /* TODO: Find a way to minimize the calls to `localtime', since
396 * they are pretty expensive.. */
397 now = time (NULL);
398 tm = localtime (&now);
400 strftime (tmp, 1024 - (tmp - full_file), "-%Y-%m-%d", tm);
402 /* `localtime(3)' returns a pointer to static data,
403 * therefore the pointer may not be free'd. */
404 }
405 else
406 DBG ("The filename ends with `%s' which is unexpected.", tmp);
408 if (stat (full_file, &statbuf) == -1)
409 {
410 if (errno == ENOENT)
411 {
412 if (log_create_file (full_file, ds_def, ds_num))
413 return (-1);
414 }
415 else
416 {
417 syslog (LOG_ERR, "stat %s: %s", full_file, strerror (errno));
418 return (-1);
419 }
420 }
421 else if (!S_ISREG (statbuf.st_mode))
422 {
423 syslog (LOG_ERR, "stat %s: Not a regular file!", full_file);
424 return (-1);
425 }
428 fp = fopen (full_file, "a");
429 if (fp == NULL)
430 {
431 syslog (LOG_WARNING, "Failed to append to %s: %s", full_file,
432 strerror(errno));
433 return (-1);
434 }
435 fprintf(fp, "%s\n", values);
436 fclose(fp);
438 return (0);
439 } /* int log_update_file */
441 #if HAVE_LIBRRD
442 static int rrd_create_file (char *filename, char **ds_def, int ds_num)
443 {
444 char **argv;
445 int argc;
446 int i, j;
447 int status = 0;
449 if (check_create_dir (filename))
450 return (-1);
452 argc = ds_num + rra_num + 4;
454 if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
455 {
456 syslog (LOG_ERR, "rrd_create failed: %s", strerror (errno));
457 return (-1);
458 }
460 argv[0] = "create";
461 argv[1] = filename;
462 argv[2] = "-s";
463 argv[3] = "10";
465 j = 4;
466 for (i = 0; i < ds_num; i++)
467 argv[j++] = ds_def[i];
468 for (i = 0; i < rra_num; i++)
469 argv[j++] = rra_def[i];
470 argv[j] = NULL;
472 optind = 0; /* bug in librrd? */
473 rrd_clear_error ();
474 if (rrd_create (argc, argv) == -1)
475 {
476 syslog (LOG_ERR, "rrd_create failed: %s: %s", filename, rrd_get_error ());
477 status = -1;
478 }
480 free (argv);
482 return (status);
483 }
484 #endif /* HAVE_LIBRRD */
486 int rrd_update_file (char *host, char *file, char *values,
487 char **ds_def, int ds_num)
488 {
489 #if HAVE_LIBRRD
490 struct stat statbuf;
491 char full_file[1024];
492 char *argv[4] = { "update", full_file, values, NULL };
493 #endif /* HAVE_LIBRRD */
495 /* I'd rather have a function `common_update_file' to make this
496 * decission, but for that we'd need to touch all plugins.. */
497 if (operating_mode == MODE_LOG)
498 return (log_update_file (host, file, values,
499 ds_def, ds_num));
501 #if HAVE_LIBRRD
502 /* host == NULL => local mode */
503 if (host != NULL)
504 {
505 if (snprintf (full_file, 1024, "%s/%s", host, file) >= 1024)
506 return (-1);
507 }
508 else
509 {
510 if (snprintf (full_file, 1024, "%s", file) >= 1024)
511 return (-1);
512 }
514 if (stat (full_file, &statbuf) == -1)
515 {
516 if (errno == ENOENT)
517 {
518 if (rrd_create_file (full_file, ds_def, ds_num))
519 return (-1);
520 }
521 else
522 {
523 syslog (LOG_ERR, "stat %s: %s", full_file, strerror (errno));
524 return (-1);
525 }
526 }
527 else if (!S_ISREG (statbuf.st_mode))
528 {
529 syslog (LOG_ERR, "stat %s: Not a regular file!", full_file);
530 return (-1);
531 }
533 optind = 0; /* bug in librrd? */
534 rrd_clear_error ();
535 if (rrd_update (3, argv) == -1)
536 {
537 syslog (LOG_WARNING, "rrd_update failed: %s: %s", full_file, rrd_get_error ());
538 return (-1);
539 }
540 return (0);
541 /* #endif HAVE_LIBRRD */
543 #else
544 syslog (LOG_ERR, "`rrd_update_file' was called, but collectd isn't linked against librrd!");
545 return (-1);
546 #endif
547 }
549 #ifdef HAVE_LIBKSTAT
550 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
551 {
552 char ident[128];
554 if (kc == NULL)
555 return (-1);
557 snprintf (ident, 128, "%s,%i,%s", module, instance, name);
558 ident[127] = '\0';
560 if (*ksp_ptr == NULL)
561 {
562 if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL)
563 {
564 syslog (LOG_ERR, "Cound not find kstat %s", ident);
565 return (-1);
566 }
568 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
569 {
570 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
571 *ksp_ptr = NULL;
572 return (-1);
573 }
574 }
576 #ifdef assert
577 assert (*ksp_ptr != NULL);
578 assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
579 #endif
581 if (kstat_read (kc, *ksp_ptr, NULL) == -1)
582 {
583 syslog (LOG_WARNING, "kstat %s could not be read", ident);
584 return (-1);
585 }
587 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
588 {
589 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
590 return (-1);
591 }
593 return (0);
594 }
596 long long get_kstat_value (kstat_t *ksp, char *name)
597 {
598 kstat_named_t *kn;
599 long long retval = -1LL;
601 #ifdef assert
602 assert (ksp != NULL);
603 assert (ksp->ks_type == KSTAT_TYPE_NAMED);
604 #else
605 if (ksp == NULL)
606 {
607 fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__);
608 return (-1LL);
609 }
610 else if (ksp->ks_type != KSTAT_TYPE_NAMED)
611 {
612 fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__);
613 return (-1LL);
614 }
615 #endif
617 if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
618 return (retval);
620 if (kn->data_type == KSTAT_DATA_INT32)
621 retval = (long long) kn->value.i32;
622 else if (kn->data_type == KSTAT_DATA_UINT32)
623 retval = (long long) kn->value.ui32;
624 else if (kn->data_type == KSTAT_DATA_INT64)
625 retval = (long long) kn->value.i64; /* According to ANSI C99 `long long' must hold at least 64 bits */
626 else if (kn->data_type == KSTAT_DATA_UINT64)
627 retval = (long long) kn->value.ui64; /* XXX: Might overflow! */
628 else
629 syslog (LOG_WARNING, "get_kstat_value: Not a numeric value: %s", name);
631 return (retval);
632 }
633 #endif /* HAVE_LIBKSTAT */