4d93f4aa2764f5394c2336a3db889ebecc87d24c
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_LIBKSTAT
29 extern kstat_ctl_t *kc;
30 #endif
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 */
49 void
50 sstrncpy(char *d, const char *s, int len)
51 {
52 strncpy(d, s, len);
53 d[len - 1] = 0;
54 }
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 }
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 }
78 int strsplit (char *string, char **fields, size_t size)
79 {
80 size_t i;
81 char *ptr;
83 i = 0;
84 ptr = string;
85 while ((fields[i] = strtok (ptr, " \t")) != NULL)
86 {
87 ptr = NULL;
88 i++;
90 if (i >= size)
91 break;
92 }
94 return (i);
95 }
97 int strjoin (char *dst, size_t dst_len,
98 char **fields, size_t fields_num,
99 const char *sep)
100 {
101 int field_len;
102 int sep_len;
103 int i;
105 memset (dst, '\0', dst_len);
107 if (fields_num <= 0)
108 return (-1);
110 sep_len = 0;
111 if (sep != NULL)
112 sep_len = strlen (sep);
114 for (i = 0; i < fields_num; i++)
115 {
116 if ((i > 0) && (sep_len > 0))
117 {
118 if (dst_len <= sep_len)
119 return (-1);
121 strncat (dst, sep, dst_len);
122 dst_len -= sep_len;
123 }
125 field_len = strlen (fields[i]);
127 if (dst_len <= field_len)
128 return (-1);
130 strncat (dst, fields[i], dst_len);
131 dst_len -= field_len;
132 }
134 return (strlen (dst));
135 }
137 int escape_slashes (char *buf, int buf_len)
138 {
139 int i;
141 if (strcmp (buf, "/") == 0)
142 {
143 if (buf_len < 5)
144 return (-1);
146 strncpy (buf, "root", buf_len);
147 return (0);
148 }
150 /* Move one to the left */
151 memmove (buf, buf + 1, buf_len - 1);
153 for (i = 0; i < buf_len - 1; i++)
154 {
155 if (buf[i] == '\0')
156 break;
157 else if (buf[i] == '/')
158 buf[i] = '_';
159 }
160 buf[i] = '\0';
162 return (0);
163 }
165 #ifdef HAVE_LIBRRD
166 int check_create_dir (const char *file_orig)
167 {
168 struct stat statbuf;
170 char file_copy[512];
171 char dir[512];
172 int dir_len = 512;
173 char *fields[16];
174 int fields_num;
175 char *ptr;
176 int last_is_file = 1;
177 int len;
178 int i;
180 /*
181 * Sanity checks first
182 */
183 if (file_orig == NULL)
184 return (-1);
186 if ((len = strlen (file_orig)) < 1)
187 return (-1);
188 else if (len >= 512)
189 return (-1);
191 /*
192 * If `file_orig' ends in a slash the last component is a directory,
193 * otherwise it's a file. Act accordingly..
194 */
195 if (file_orig[len - 1] == '/')
196 last_is_file = 0;
198 /*
199 * Create a copy for `strtok' to destroy
200 */
201 strncpy (file_copy, file_orig, 512);
202 file_copy[511] = '\0';
204 /*
205 * Break into components. This will eat up several slashes in a row and
206 * remove leading and trailing slashes..
207 */
208 ptr = file_copy;
209 fields_num = 0;
210 while ((fields[fields_num] = strtok (ptr, "/")) != NULL)
211 {
212 ptr = NULL;
213 fields_num++;
215 if (fields_num >= 16)
216 break;
217 }
219 /*
220 * For each component, do..
221 */
222 for (i = 0; i < (fields_num - last_is_file); i++)
223 {
224 /*
225 * Do not create directories that start with a dot. This
226 * prevents `../../' attacks and other likely malicious
227 * behavior.
228 */
229 if (fields[i][0] == '.')
230 {
231 syslog (LOG_ERR, "Cowardly refusing to create a directory that begins with a `.' (dot): `%s'", file_orig);
232 return (-2);
233 }
235 /*
236 * Join the components together again
237 */
238 if (strjoin (dir, dir_len, fields, i + 1, "/") < 0)
239 {
240 syslog (LOG_ERR, "strjoin failed: `%s', component #%i", file_orig, i);
241 return (-1);
242 }
244 if (stat (dir, &statbuf) == -1)
245 {
246 if (errno == ENOENT)
247 {
248 if (mkdir (dir, 0755) == -1)
249 {
250 syslog (LOG_ERR, "mkdir (%s): %s", dir, strerror (errno));
251 return (-1);
252 }
253 }
254 else
255 {
256 syslog (LOG_ERR, "stat (%s): %s", dir, strerror (errno));
257 return (-1);
258 }
259 }
260 else if (!S_ISDIR (statbuf.st_mode))
261 {
262 syslog (LOG_ERR, "stat (%s): Not a directory!", dir);
263 return (-1);
264 }
265 }
267 return (0);
268 }
270 int rrd_create_file (char *filename, char **ds_def, int ds_num)
271 {
272 char **argv;
273 int argc;
274 int i, j;
275 int status = 0;
277 if (check_create_dir (filename))
278 return (-1);
280 argc = ds_num + rra_num + 4;
282 if ((argv = (char **) malloc (sizeof (char *) * (argc + 1))) == NULL)
283 {
284 syslog (LOG_ERR, "rrd_create failed: %s", strerror (errno));
285 return (-1);
286 }
288 argv[0] = "create";
289 argv[1] = filename;
290 argv[2] = "-s";
291 argv[3] = "10";
293 j = 4;
294 for (i = 0; i < ds_num; i++)
295 argv[j++] = ds_def[i];
296 for (i = 0; i < rra_num; i++)
297 argv[j++] = rra_def[i];
298 argv[j] = NULL;
300 optind = 0; /* bug in librrd? */
301 rrd_clear_error ();
302 if (rrd_create (argc, argv) == -1)
303 {
304 syslog (LOG_ERR, "rrd_create failed: %s: %s", filename, rrd_get_error ());
305 status = -1;
306 }
308 free (argv);
310 return (status);
311 }
312 #endif /* HAVE_LIBRRD */
314 int rrd_update_file (char *host, char *file, char *values,
315 char **ds_def, int ds_num)
316 {
317 #ifdef HAVE_LIBRRD
318 struct stat statbuf;
319 char full_file[1024];
320 char *argv[4] = { "update", full_file, values, NULL };
322 /* host == NULL => local mode */
323 if (host != NULL)
324 {
325 if (snprintf (full_file, 1024, "%s/%s", host, file) >= 1024)
326 return (-1);
327 }
328 else
329 {
330 if (snprintf (full_file, 1024, "%s", file) >= 1024)
331 return (-1);
332 }
334 if (stat (full_file, &statbuf) == -1)
335 {
336 if (errno == ENOENT)
337 {
338 if (rrd_create_file (full_file, ds_def, ds_num))
339 return (-1);
340 }
341 else
342 {
343 syslog (LOG_ERR, "stat %s: %s", full_file, strerror (errno));
344 return (-1);
345 }
346 }
347 else if (!S_ISREG (statbuf.st_mode))
348 {
349 syslog (LOG_ERR, "stat %s: Not a regular file!", full_file);
350 return (-1);
351 }
353 optind = 0; /* bug in librrd? */
354 rrd_clear_error ();
355 if (rrd_update (3, argv) == -1)
356 {
357 syslog (LOG_WARNING, "rrd_update failed: %s: %s", full_file, rrd_get_error ());
358 return (-1);
359 }
360 #endif /* HAVE_LIBRRD */
362 return (0);
363 }
365 #ifdef HAVE_LIBKSTAT
366 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
367 {
368 char ident[128];
370 if (kc == NULL)
371 return (-1);
373 snprintf (ident, 128, "%s,%i,%s", module, instance, name);
374 ident[127] = '\0';
376 if (*ksp_ptr == NULL)
377 {
378 if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL)
379 {
380 syslog (LOG_ERR, "Cound not find kstat %s", ident);
381 return (-1);
382 }
384 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
385 {
386 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
387 *ksp_ptr = NULL;
388 return (-1);
389 }
390 }
392 #ifdef assert
393 assert (*ksp_ptr != NULL);
394 assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
395 #endif
397 if (kstat_read (kc, *ksp_ptr, NULL) == -1)
398 {
399 syslog (LOG_WARNING, "kstat %s could not be read", ident);
400 return (-1);
401 }
403 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
404 {
405 syslog (LOG_WARNING, "kstat %s has wrong type", ident);
406 return (-1);
407 }
409 return (0);
410 }
412 long long get_kstat_value (kstat_t *ksp, char *name)
413 {
414 kstat_named_t *kn;
415 long long retval = -1LL;
417 #ifdef assert
418 assert (ksp != NULL);
419 assert (ksp->ks_type == KSTAT_TYPE_NAMED);
420 #else
421 if (ksp == NULL)
422 {
423 fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__);
424 return (-1LL);
425 }
426 else if (ksp->ks_type != KSTAT_TYPE_NAMED)
427 {
428 fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__);
429 return (-1LL);
430 }
431 #endif
433 if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
434 return (retval);
436 if (kn->data_type == KSTAT_DATA_INT32)
437 retval = (long long) kn->value.i32;
438 else if (kn->data_type == KSTAT_DATA_UINT32)
439 retval = (long long) kn->value.ui32;
440 else if (kn->data_type == KSTAT_DATA_INT64)
441 retval = (long long) kn->value.i64; /* According to ANSI C99 `long long' must hold at least 64 bits */
442 else if (kn->data_type == KSTAT_DATA_UINT64)
443 retval = (long long) kn->value.ui64; /* XXX: Might overflow! */
444 else
445 syslog (LOG_WARNING, "get_kstat_value: Not a numeric value: %s", name);
447 return (retval);
448 }
449 #endif /* HAVE_LIBKSTAT */