967a82af42c930fa01992df78774bf45d0f7945c
1 /**
2 * collectd - src/common.c
3 * Copyright (C) 2005-2007 Florian octo Forster
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; only version 2 of the License is applicable.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 *
18 * Authors:
19 * Florian octo Forster <octo at verplant.org>
20 * Niki W. Waibel <niki.waibel@gmx.net>
21 **/
23 #include "common.h"
24 #include "plugin.h"
26 #ifdef HAVE_MATH_H
27 # include <math.h>
28 #endif
30 /* for ntohl and htonl */
31 #if HAVE_ARPA_INET_H
32 # include <arpa/inet.h>
33 #endif
35 #ifdef HAVE_LIBKSTAT
36 extern kstat_ctl_t *kc;
37 #endif
39 void sstrncpy (char *d, const char *s, int len)
40 {
41 strncpy (d, s, len);
42 d[len - 1] = '\0';
43 }
45 char *sstrdup (const char *s)
46 {
47 char *r;
49 if (s == NULL)
50 return (NULL);
52 if((r = strdup (s)) == NULL)
53 {
54 DEBUG ("Not enough memory.");
55 exit(3);
56 }
58 return (r);
59 }
61 /* Don't use the return value of `strerror_r', because the GNU-people got
62 * inventive there.. -octo */
63 char *sstrerror (int errnum, char *buf, size_t buflen)
64 {
65 buf[0] = '\0';
66 strerror_r (errnum, buf, buflen);
67 return (buf);
68 } /* char *sstrerror */
70 void *smalloc (size_t size)
71 {
72 void *r;
74 if ((r = malloc (size)) == NULL)
75 {
76 DEBUG("Not enough memory.");
77 exit(3);
78 }
80 return r;
81 }
83 #if 0
84 void sfree (void **ptr)
85 {
86 if (ptr == NULL)
87 return;
89 if (*ptr != NULL)
90 free (*ptr);
92 *ptr = NULL;
93 }
94 #endif
96 ssize_t sread (int fd, void *buf, size_t count)
97 {
98 char *ptr;
99 size_t nleft;
100 ssize_t status;
102 ptr = (char *) buf;
103 nleft = count;
105 while (nleft > 0)
106 {
107 status = read (fd, (void *) ptr, nleft);
109 if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
110 continue;
112 if (status < 0)
113 return (status);
115 if (status == 0)
116 {
117 DEBUG ("Received EOF from fd %i. "
118 "Closing fd and returning error.",
119 fd);
120 close (fd);
121 return (-1);
122 }
124 assert (nleft >= status);
126 nleft = nleft - status;
127 ptr = ptr + status;
128 }
130 return (0);
131 }
134 ssize_t swrite (int fd, const void *buf, size_t count)
135 {
136 const char *ptr;
137 size_t nleft;
138 ssize_t status;
140 ptr = (const char *) buf;
141 nleft = count;
143 while (nleft > 0)
144 {
145 status = write (fd, (const void *) ptr, nleft);
147 if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
148 continue;
150 if (status < 0)
151 return (status);
153 nleft = nleft - status;
154 ptr = ptr + status;
155 }
157 return (0);
158 }
160 int strsplit (char *string, char **fields, size_t size)
161 {
162 size_t i;
163 char *ptr;
164 char *saveptr;
166 i = 0;
167 ptr = string;
168 saveptr = NULL;
169 while ((fields[i] = strtok_r (ptr, " \t", &saveptr)) != NULL)
170 {
171 ptr = NULL;
172 i++;
174 if (i >= size)
175 break;
176 }
178 return (i);
179 }
181 int strjoin (char *dst, size_t dst_len,
182 char **fields, size_t fields_num,
183 const char *sep)
184 {
185 int field_len;
186 int sep_len;
187 int i;
189 memset (dst, '\0', dst_len);
191 if (fields_num <= 0)
192 return (-1);
194 sep_len = 0;
195 if (sep != NULL)
196 sep_len = strlen (sep);
198 for (i = 0; i < fields_num; i++)
199 {
200 if ((i > 0) && (sep_len > 0))
201 {
202 if (dst_len <= sep_len)
203 return (-1);
205 strncat (dst, sep, dst_len);
206 dst_len -= sep_len;
207 }
209 field_len = strlen (fields[i]);
211 if (dst_len <= field_len)
212 return (-1);
214 strncat (dst, fields[i], dst_len);
215 dst_len -= field_len;
216 }
218 return (strlen (dst));
219 }
221 int strsubstitute (char *str, char c_from, char c_to)
222 {
223 int ret;
225 if (str == NULL)
226 return (-1);
228 ret = 0;
229 while (*str != '\0')
230 {
231 if (*str == c_from)
232 {
233 *str = c_to;
234 ret++;
235 }
236 str++;
237 }
239 return (ret);
240 }
242 int escape_slashes (char *buf, int buf_len)
243 {
244 int i;
246 if (strcmp (buf, "/") == 0)
247 {
248 if (buf_len < 5)
249 return (-1);
251 strncpy (buf, "root", buf_len);
252 return (0);
253 }
255 /* Move one to the left */
256 memmove (buf, buf + 1, buf_len - 1);
258 for (i = 0; i < buf_len - 1; i++)
259 {
260 if (buf[i] == '\0')
261 break;
262 else if (buf[i] == '/')
263 buf[i] = '_';
264 }
265 buf[i] = '\0';
267 return (0);
268 }
270 int timeval_sub_timespec (struct timeval *tv0, struct timeval *tv1, struct timespec *ret)
271 {
272 if ((tv0 == NULL) || (tv1 == NULL) || (ret == NULL))
273 return (-2);
275 if ((tv0->tv_sec < tv1->tv_sec)
276 || ((tv0->tv_sec == tv1->tv_sec) && (tv0->tv_usec < tv1->tv_usec)))
277 return (-1);
279 ret->tv_sec = tv0->tv_sec - tv1->tv_sec;
280 ret->tv_nsec = 1000 * ((long) (tv0->tv_usec - tv1->tv_usec));
282 if (ret->tv_nsec < 0)
283 {
284 assert (ret->tv_sec > 0);
286 ret->tv_nsec += 1000000000;
287 ret->tv_sec -= 1;
288 }
290 return (0);
291 }
293 int check_create_dir (const char *file_orig)
294 {
295 struct stat statbuf;
297 char file_copy[512];
298 char dir[512];
299 int dir_len = 512;
300 char *fields[16];
301 int fields_num;
302 char *ptr;
303 char *saveptr;
304 int last_is_file = 1;
305 int path_is_absolute = 0;
306 int len;
307 int i;
309 /*
310 * Sanity checks first
311 */
312 if (file_orig == NULL)
313 return (-1);
315 if ((len = strlen (file_orig)) < 1)
316 return (-1);
317 else if (len >= 512)
318 return (-1);
320 /*
321 * If `file_orig' ends in a slash the last component is a directory,
322 * otherwise it's a file. Act accordingly..
323 */
324 if (file_orig[len - 1] == '/')
325 last_is_file = 0;
326 if (file_orig[0] == '/')
327 path_is_absolute = 1;
329 /*
330 * Create a copy for `strtok_r' to destroy
331 */
332 strncpy (file_copy, file_orig, 512);
333 file_copy[511] = '\0';
335 /*
336 * Break into components. This will eat up several slashes in a row and
337 * remove leading and trailing slashes..
338 */
339 ptr = file_copy;
340 saveptr = NULL;
341 fields_num = 0;
342 while ((fields[fields_num] = strtok_r (ptr, "/", &saveptr)) != NULL)
343 {
344 ptr = NULL;
345 fields_num++;
347 if (fields_num >= 16)
348 break;
349 }
351 /*
352 * For each component, do..
353 */
354 for (i = 0; i < (fields_num - last_is_file); i++)
355 {
356 /*
357 * Do not create directories that start with a dot. This
358 * prevents `../../' attacks and other likely malicious
359 * behavior.
360 */
361 if (fields[i][0] == '.')
362 {
363 ERROR ("Cowardly refusing to create a directory that begins with a `.' (dot): `%s'", file_orig);
364 return (-2);
365 }
367 /*
368 * Join the components together again
369 */
370 dir[0] = '/';
371 if (strjoin (dir + path_is_absolute, dir_len - path_is_absolute,
372 fields, i + 1, "/") < 0)
373 {
374 ERROR ("strjoin failed: `%s', component #%i", file_orig, i);
375 return (-1);
376 }
378 if (stat (dir, &statbuf) == -1)
379 {
380 if (errno == ENOENT)
381 {
382 if (mkdir (dir, 0755) == -1)
383 {
384 char errbuf[1024];
385 ERROR ("mkdir (%s): %s", dir,
386 sstrerror (errno,
387 errbuf, sizeof (errbuf)));
388 return (-1);
389 }
390 }
391 else
392 {
393 char errbuf[1024];
394 ERROR ("stat (%s): %s", dir,
395 sstrerror (errno, errbuf,
396 sizeof (errbuf)));
397 return (-1);
398 }
399 }
400 else if (!S_ISDIR (statbuf.st_mode))
401 {
402 ERROR ("stat (%s): Not a directory!", dir);
403 return (-1);
404 }
405 }
407 return (0);
408 }
410 #ifdef HAVE_LIBKSTAT
411 int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name)
412 {
413 char ident[128];
415 if (kc == NULL)
416 return (-1);
418 snprintf (ident, 128, "%s,%i,%s", module, instance, name);
419 ident[127] = '\0';
421 if (*ksp_ptr == NULL)
422 {
423 if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL)
424 {
425 ERROR ("Cound not find kstat %s", ident);
426 return (-1);
427 }
429 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
430 {
431 WARNING ("kstat %s has wrong type", ident);
432 *ksp_ptr = NULL;
433 return (-1);
434 }
435 }
437 #ifdef assert
438 assert (*ksp_ptr != NULL);
439 assert ((*ksp_ptr)->ks_type == KSTAT_TYPE_NAMED);
440 #endif
442 if (kstat_read (kc, *ksp_ptr, NULL) == -1)
443 {
444 WARNING ("kstat %s could not be read", ident);
445 return (-1);
446 }
448 if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED)
449 {
450 WARNING ("kstat %s has wrong type", ident);
451 return (-1);
452 }
454 return (0);
455 }
457 long long get_kstat_value (kstat_t *ksp, char *name)
458 {
459 kstat_named_t *kn;
460 long long retval = -1LL;
462 #ifdef assert
463 assert (ksp != NULL);
464 assert (ksp->ks_type == KSTAT_TYPE_NAMED);
465 #else
466 if (ksp == NULL)
467 {
468 fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__);
469 return (-1LL);
470 }
471 else if (ksp->ks_type != KSTAT_TYPE_NAMED)
472 {
473 fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__);
474 return (-1LL);
475 }
476 #endif
478 if ((kn = (kstat_named_t *) kstat_data_lookup (ksp, name)) == NULL)
479 return (retval);
481 if (kn->data_type == KSTAT_DATA_INT32)
482 retval = (long long) kn->value.i32;
483 else if (kn->data_type == KSTAT_DATA_UINT32)
484 retval = (long long) kn->value.ui32;
485 else if (kn->data_type == KSTAT_DATA_INT64)
486 retval = (long long) kn->value.i64; /* According to ANSI C99 `long long' must hold at least 64 bits */
487 else if (kn->data_type == KSTAT_DATA_UINT64)
488 retval = (long long) kn->value.ui64; /* XXX: Might overflow! */
489 else
490 WARNING ("get_kstat_value: Not a numeric value: %s", name);
492 return (retval);
493 }
494 #endif /* HAVE_LIBKSTAT */
496 unsigned long long ntohll (unsigned long long n)
497 {
498 #if __BYTE_ORDER == __BIG_ENDIAN
499 return (n);
500 #else
501 return (((unsigned long long) ntohl (n)) << 32) + ntohl (n >> 32);
502 #endif
503 }
505 unsigned long long htonll (unsigned long long n)
506 {
507 #if __BYTE_ORDER == __BIG_ENDIAN
508 return (n);
509 #else
510 return (((unsigned long long) htonl (n)) << 32) + htonl (n >> 32);
511 #endif
512 }