X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fcommon.c;h=1af2f144647b191c38321ddd4aed4264b2c79577;hb=e8999694aac7184ac4eea29564a2892f188c4171;hp=e8050412b022e7c59dd7b9fef37d85991ea012bf;hpb=c999f7e40b0e9ce8f5fd4eb2042d6f3adbd6ce1e;p=collectd.git diff --git a/src/common.c b/src/common.c index e8050412..1af2f144 100644 --- a/src/common.c +++ b/src/common.c @@ -18,12 +18,15 @@ * Authors: * Florian octo Forster * Niki W. Waibel + * Sebastian Harl + * Michał Mirosław **/ #if HAVE_CONFIG_H # include "config.h" #endif +#include "collectd.h" #include "common.h" #include "plugin.h" @@ -52,27 +55,48 @@ static pthread_mutex_t getpwnam_r_lock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t strerror_r_lock = PTHREAD_MUTEX_INITIALIZER; #endif -void sstrncpy (char *d, const char *s, int len) +char *sstrncpy (char *dest, const char *src, size_t n) { - strncpy (d, s, len); - d[len - 1] = '\0'; -} + strncpy (dest, src, n); + dest[n - 1] = '\0'; + + return (dest); +} /* char *sstrncpy */ + +int ssnprintf (char *dest, size_t n, const char *format, ...) +{ + int ret = 0; + va_list ap; + + va_start (ap, format); + ret = vsnprintf (dest, n, format, ap); + dest[n - 1] = '\0'; + va_end (ap); + + return (ret); +} /* int ssnprintf */ char *sstrdup (const char *s) { char *r; + size_t sz; if (s == NULL) return (NULL); - if((r = strdup (s)) == NULL) + /* Do not use `strdup' here, because it's not specified in POSIX. It's + * ``only'' an XSI extension. */ + sz = strlen (s) + 1; + r = (char *) malloc (sizeof (char) * sz); + if (r == NULL) { - DEBUG ("Not enough memory."); - exit(3); + ERROR ("sstrdup: Out of memory."); + exit (3); } + memcpy (r, s, sizeof (char) * sz); return (r); -} +} /* char *sstrdup */ /* Even though Posix requires "strerror_r" to return an "int", * some systems (e.g. the GNU libc) return a "char *" _and_ @@ -88,7 +112,7 @@ char *sstrerror (int errnum, char *buf, size_t buflen) pthread_mutex_lock (&strerror_r_lock); temp = strerror (errnum); - strncpy (buf, temp, buflen); + sstrncpy (buf, temp, buflen); pthread_mutex_unlock (&strerror_r_lock); } @@ -101,9 +125,9 @@ char *sstrerror (int errnum, char *buf, size_t buflen) if (buf[0] == '\0') { if ((temp != NULL) && (temp != buf) && (temp[0] != '\0')) - strncpy (buf, temp, buflen); + sstrncpy (buf, temp, buflen); else - strncpy (buf, "strerror_r did not return " + sstrncpy (buf, "strerror_r did not return " "an error message", buflen); } } @@ -112,13 +136,12 @@ char *sstrerror (int errnum, char *buf, size_t buflen) #else if (strerror_r (errnum, buf, buflen) != 0) { - snprintf (buf, buflen, "Error #%i; " + ssnprintf (buf, buflen, "Error #%i; " "Additionally, strerror_r failed.", errnum); } #endif /* STRERROR_R_CHAR_P */ - buf[buflen - 1] = '\0'; return (buf); } /* char *sstrerror */ @@ -128,12 +151,12 @@ void *smalloc (size_t size) if ((r = malloc (size)) == NULL) { - DEBUG("Not enough memory."); - exit(3); + ERROR ("Not enough memory."); + exit (3); } - return r; -} + return (r); +} /* void *smalloc */ #if 0 void sfree (void **ptr) @@ -221,7 +244,7 @@ int strsplit (char *string, char **fields, size_t size) i = 0; ptr = string; saveptr = NULL; - while ((fields[i] = strtok_r (ptr, " \t", &saveptr)) != NULL) + while ((fields[i] = strtok_r (ptr, " \t\r\n", &saveptr)) != NULL) { ptr = NULL; i++; @@ -326,28 +349,56 @@ int escape_slashes (char *buf, int buf_len) return (0); } /* int escape_slashes */ -int timeval_sub_timespec (struct timeval *tv0, struct timeval *tv1, struct timespec *ret) +int timeval_cmp (struct timeval tv0, struct timeval tv1, struct timeval *delta) { - if ((tv0 == NULL) || (tv1 == NULL) || (ret == NULL)) - return (-2); + struct timeval *larger; + struct timeval *smaller; - if ((tv0->tv_sec < tv1->tv_sec) - || ((tv0->tv_sec == tv1->tv_sec) && (tv0->tv_usec < tv1->tv_usec))) - return (-1); + int status; - ret->tv_sec = tv0->tv_sec - tv1->tv_sec; - ret->tv_nsec = 1000 * ((long) (tv0->tv_usec - tv1->tv_usec)); + NORMALIZE_TIMEVAL (tv0); + NORMALIZE_TIMEVAL (tv1); - if (ret->tv_nsec < 0) + if ((tv0.tv_sec == tv1.tv_sec) && (tv0.tv_usec == tv1.tv_usec)) { - assert (ret->tv_sec > 0); + if (delta != NULL) { + delta->tv_sec = 0; + delta->tv_usec = 0; + } + return (0); + } - ret->tv_nsec += 1000000000; - ret->tv_sec -= 1; + if ((tv0.tv_sec < tv1.tv_sec) + || ((tv0.tv_sec == tv1.tv_sec) && (tv0.tv_usec < tv1.tv_usec))) + { + larger = &tv1; + smaller = &tv0; + status = -1; + } + else + { + larger = &tv0; + smaller = &tv1; + status = 1; } - return (0); -} + if (delta != NULL) { + delta->tv_sec = larger->tv_sec - smaller->tv_sec; + + if (smaller->tv_usec <= larger->tv_usec) + delta->tv_usec = larger->tv_usec - smaller->tv_usec; + else + { + --delta->tv_sec; + delta->tv_usec = 1000000 + larger->tv_usec - smaller->tv_usec; + } + } + + assert ((delta == NULL) + || ((0 <= delta->tv_usec) && (delta->tv_usec < 1000000))); + + return (status); +} /* int timeval_cmp */ int check_create_dir (const char *file_orig) { @@ -362,7 +413,7 @@ int check_create_dir (const char *file_orig) char *saveptr; int last_is_file = 1; int path_is_absolute = 0; - int len; + size_t len; int i; /* @@ -373,7 +424,7 @@ int check_create_dir (const char *file_orig) if ((len = strlen (file_orig)) < 1) return (-1); - else if (len >= 512) + else if (len >= sizeof (file_copy)) return (-1); /* @@ -388,8 +439,7 @@ int check_create_dir (const char *file_orig) /* * Create a copy for `strtok_r' to destroy */ - strncpy (file_copy, file_orig, 512); - file_copy[511] = '\0'; + sstrncpy (file_copy, file_orig, sizeof (file_copy)); /* * Break into components. This will eat up several slashes in a row and @@ -419,7 +469,8 @@ int check_create_dir (const char *file_orig) */ if (fields[i][0] == '.') { - ERROR ("Cowardly refusing to create a directory that begins with a `.' (dot): `%s'", file_orig); + ERROR ("Cowardly refusing to create a directory that " + "begins with a `.' (dot): `%s'", file_orig); return (-2); } @@ -434,32 +485,42 @@ int check_create_dir (const char *file_orig) return (-1); } - if (stat (dir, &statbuf) == -1) - { - if (errno == ENOENT) + while (42) { + if (stat (dir, &statbuf) == -1) { - if (mkdir (dir, 0755) == -1) + if (errno == ENOENT) { + if (mkdir (dir, 0755) == 0) + break; + + /* this might happen, if a different thread created + * the directory in the meantime + * => call stat() again to check for S_ISDIR() */ + if (EEXIST == errno) + continue; + char errbuf[1024]; ERROR ("check_create_dir: mkdir (%s): %s", dir, sstrerror (errno, errbuf, sizeof (errbuf))); return (-1); } + else + { + char errbuf[1024]; + ERROR ("check_create_dir: stat (%s): %s", dir, + sstrerror (errno, errbuf, + sizeof (errbuf))); + return (-1); + } } - else + else if (!S_ISDIR (statbuf.st_mode)) { - char errbuf[1024]; - ERROR ("stat (%s): %s", dir, - sstrerror (errno, errbuf, - sizeof (errbuf))); + ERROR ("check_create_dir: `%s' exists but is not " + "a directory!", dir); return (-1); } - } - else if (!S_ISDIR (statbuf.st_mode)) - { - ERROR ("stat (%s): Not a directory!", dir); - return (-1); + break; } } @@ -470,27 +531,26 @@ int check_create_dir (const char *file_orig) int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name) { char ident[128]; + + *ksp_ptr = NULL; if (kc == NULL) return (-1); - snprintf (ident, 128, "%s,%i,%s", module, instance, name); - ident[127] = '\0'; + ssnprintf (ident, sizeof (ident), "%s,%i,%s", module, instance, name); + *ksp_ptr = kstat_lookup (kc, module, instance, name); if (*ksp_ptr == NULL) { - if ((*ksp_ptr = kstat_lookup (kc, module, instance, name)) == NULL) - { - ERROR ("Cound not find kstat %s", ident); - return (-1); - } + ERROR ("get_kstat: Cound not find kstat %s", ident); + return (-1); + } - if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED) - { - WARNING ("kstat %s has wrong type", ident); - *ksp_ptr = NULL; - return (-1); - } + if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED) + { + ERROR ("get_kstat: kstat %s has wrong type", ident); + *ksp_ptr = NULL; + return (-1); } #ifdef assert @@ -500,13 +560,13 @@ int get_kstat (kstat_t **ksp_ptr, char *module, int instance, char *name) if (kstat_read (kc, *ksp_ptr, NULL) == -1) { - WARNING ("kstat %s could not be read", ident); + ERROR ("get_kstat: kstat %s could not be read", ident); return (-1); } if ((*ksp_ptr)->ks_type != KSTAT_TYPE_NAMED) { - WARNING ("kstat %s has wrong type", ident); + ERROR ("get_kstat: kstat %s has wrong type", ident); return (-1); } @@ -524,12 +584,12 @@ long long get_kstat_value (kstat_t *ksp, char *name) #else if (ksp == NULL) { - fprintf (stderr, "ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__); + ERROR ("ERROR: %s:%i: ksp == NULL\n", __FILE__, __LINE__); return (-1LL); } else if (ksp->ks_type != KSTAT_TYPE_NAMED) { - fprintf (stderr, "ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__); + ERROR ("ERROR: %s:%i: ksp->ks_type != KSTAT_TYPE_NAMED\n", __FILE__, __LINE__); return (-1LL); } #endif @@ -554,7 +614,7 @@ long long get_kstat_value (kstat_t *ksp, char *name) unsigned long long ntohll (unsigned long long n) { -#if __BYTE_ORDER == __BIG_ENDIAN +#if BYTE_ORDER == BIG_ENDIAN return (n); #else return (((unsigned long long) ntohl (n)) << 32) + ntohl (n >> 32); @@ -563,13 +623,90 @@ unsigned long long ntohll (unsigned long long n) unsigned long long htonll (unsigned long long n) { -#if __BYTE_ORDER == __BIG_ENDIAN +#if BYTE_ORDER == BIG_ENDIAN return (n); #else return (((unsigned long long) htonl (n)) << 32) + htonl (n >> 32); #endif } /* unsigned long long htonll */ +#if FP_LAYOUT_NEED_NOTHING +/* Well, we need nothing.. */ +/* #endif FP_LAYOUT_NEED_NOTHING */ + +#elif FP_LAYOUT_NEED_ENDIANFLIP || FP_LAYOUT_NEED_INTSWAP +# if FP_LAYOUT_NEED_ENDIANFLIP +# define FP_CONVERT(A) ((((uint64_t)(A) & 0xff00000000000000LL) >> 56) | \ + (((uint64_t)(A) & 0x00ff000000000000LL) >> 40) | \ + (((uint64_t)(A) & 0x0000ff0000000000LL) >> 24) | \ + (((uint64_t)(A) & 0x000000ff00000000LL) >> 8) | \ + (((uint64_t)(A) & 0x00000000ff000000LL) << 8) | \ + (((uint64_t)(A) & 0x0000000000ff0000LL) << 24) | \ + (((uint64_t)(A) & 0x000000000000ff00LL) << 40) | \ + (((uint64_t)(A) & 0x00000000000000ffLL) << 56)) +# else +# define FP_CONVERT(A) ((((uint64_t)(A) & 0xffffffff00000000LL) >> 32) | \ + (((uint64_t)(A) & 0x00000000ffffffffLL) << 32)) +# endif + +double ntohd (double d) +{ + union + { + uint8_t byte[8]; + uint64_t integer; + double floating; + } ret; + + ret.floating = d; + + /* NAN in x86 byte order */ + if ((ret.byte[0] == 0x00) && (ret.byte[1] == 0x00) + && (ret.byte[2] == 0x00) && (ret.byte[3] == 0x00) + && (ret.byte[4] == 0x00) && (ret.byte[5] == 0x00) + && (ret.byte[6] == 0xf8) && (ret.byte[7] == 0x7f)) + { + return (NAN); + } + else + { + uint64_t tmp; + + tmp = ret.integer; + ret.integer = FP_CONVERT (tmp); + return (ret.floating); + } +} /* double ntohd */ + +double htond (double d) +{ + union + { + uint8_t byte[8]; + uint64_t integer; + double floating; + } ret; + + if (isnan (d)) + { + ret.byte[0] = ret.byte[1] = ret.byte[2] = ret.byte[3] = 0x00; + ret.byte[4] = ret.byte[5] = 0x00; + ret.byte[6] = 0xf8; + ret.byte[7] = 0x7f; + return (ret.floating); + } + else + { + uint64_t tmp; + + ret.floating = d; + tmp = FP_CONVERT (ret.integer); + ret.integer = tmp; + return (ret.floating); + } +} /* double htond */ +#endif /* FP_LAYOUT_NEED_ENDIANFLIP || FP_LAYOUT_NEED_INTSWAP */ + int format_name (char *ret, int ret_len, const char *hostname, const char *plugin, const char *plugin_instance, @@ -583,21 +720,21 @@ int format_name (char *ret, int ret_len, if ((plugin_instance == NULL) || (strlen (plugin_instance) == 0)) { if ((type_instance == NULL) || (strlen (type_instance) == 0)) - status = snprintf (ret, ret_len, "%s/%s/%s", + status = ssnprintf (ret, ret_len, "%s/%s/%s", hostname, plugin, type); else - status = snprintf (ret, ret_len, "%s/%s/%s-%s", + status = ssnprintf (ret, ret_len, "%s/%s/%s-%s", hostname, plugin, type, type_instance); } else { if ((type_instance == NULL) || (strlen (type_instance) == 0)) - status = snprintf (ret, ret_len, "%s/%s-%s/%s", + status = ssnprintf (ret, ret_len, "%s/%s-%s/%s", hostname, plugin, plugin_instance, type); else - status = snprintf (ret, ret_len, "%s/%s-%s/%s-%s", + status = ssnprintf (ret, ret_len, "%s/%s-%s/%s-%s", hostname, plugin, plugin_instance, type, type_instance); } @@ -758,26 +895,93 @@ int notification_init (notification_t *n, int severity, const char *message, n->severity = severity; if (message != NULL) - strncpy (n->message, message, sizeof (n->message)); + sstrncpy (n->message, message, sizeof (n->message)); if (host != NULL) - strncpy (n->host, host, sizeof (n->host)); + sstrncpy (n->host, host, sizeof (n->host)); if (plugin != NULL) - strncpy (n->plugin, plugin, sizeof (n->plugin)); + sstrncpy (n->plugin, plugin, sizeof (n->plugin)); if (plugin_instance != NULL) - strncpy (n->plugin_instance, plugin_instance, + sstrncpy (n->plugin_instance, plugin_instance, sizeof (n->plugin_instance)); if (type != NULL) - strncpy (n->type, type, sizeof (n->type)); + sstrncpy (n->type, type, sizeof (n->type)); if (type_instance != NULL) - strncpy (n->type_instance, type_instance, + sstrncpy (n->type_instance, type_instance, sizeof (n->type_instance)); - n->message[sizeof (n->message) - 1] = '\0'; - n->host[sizeof (n->host) - 1] = '\0'; - n->plugin[sizeof (n->plugin) - 1] = '\0'; - n->plugin_instance[sizeof (n->plugin_instance) - 1] = '\0'; - n->type[sizeof (n->type) - 1] = '\0'; - n->type_instance[sizeof (n->type_instance) - 1] = '\0'; - return (0); } /* int notification_init */ + +int walk_directory (const char *dir, dirwalk_callback_f callback, + void *user_data) +{ + struct dirent *ent; + DIR *dh; + int success; + int failure; + + success = 0; + failure = 0; + + if ((dh = opendir (dir)) == NULL) + { + char errbuf[1024]; + ERROR ("walk_directory: Cannot open '%s': %s", dir, + sstrerror (errno, errbuf, sizeof (errbuf))); + return -1; + } + + while ((ent = readdir (dh)) != NULL) + { + int status; + + if (ent->d_name[0] == '.') + continue; + + status = (*callback) (dir, ent->d_name, user_data); + if (status != 0) + failure++; + else + success++; + } + + closedir (dh); + + if ((success == 0) && (failure > 0)) + return (-1); + return (0); +} + +int read_file_contents (const char *filename, char *buf, int bufsize) +{ + FILE *fh; + int n; + + if ((fh = fopen (filename, "r")) == NULL) + return -1; + + n = fread(buf, 1, bufsize, fh); + fclose(fh); + + return n; +} + +counter_t counter_diff (counter_t old_value, counter_t new_value) +{ + counter_t diff; + + if (old_value > new_value) + { + if (old_value <= 4294967295U) + diff = (4294967295U - old_value) + new_value; + else + diff = (18446744073709551615ULL - old_value) + + new_value; + } + else + { + diff = new_value - old_value; + } + + return (diff); +} /* counter_t counter_to_gauge */