X-Git-Url: https://git.octo.it/?p=collectd.git;a=blobdiff_plain;f=src%2Fdaemon%2Fplugin.c;h=427a813485adeeefb325c298d3b641fd62e41fa4;hp=0f067374d05e7148ce79ae32a44d531e5db42ac2;hb=06a86a60a7dabc685bdbd81ce3d36ea5f7e2c2d4;hpb=01761867ced7bc5fe71546baf350be4a3e800600

diff --git a/src/daemon/plugin.c b/src/daemon/plugin.c
index 0f067374..427a8134 100644
--- a/src/daemon/plugin.c
+++ b/src/daemon/plugin.c
@@ -46,7 +46,7 @@
 #include <pthread_np.h> /* for pthread_set_name_np(3) */
 #endif
 
-#include <ltdl.h>
+#include <dlfcn.h>
 
 /*
  * Private structures
@@ -94,7 +94,7 @@ typedef struct flush_callback_s flush_callback_t;
 /*
  * Private variables
  */
-static c_avl_tree_t *plugins_loaded = NULL;
+static c_avl_tree_t *plugins_loaded;
 
 static llist_t *list_init;
 static llist_t *list_write;
@@ -104,42 +104,42 @@ static llist_t *list_shutdown;
 static llist_t *list_log;
 static llist_t *list_notification;
 
-static fc_chain_t *pre_cache_chain = NULL;
-static fc_chain_t *post_cache_chain = NULL;
+static fc_chain_t *pre_cache_chain;
+static fc_chain_t *post_cache_chain;
 
 static c_avl_tree_t *data_sets;
 
-static char *plugindir = NULL;
+static char *plugindir;
 
 #ifndef DEFAULT_MAX_READ_INTERVAL
 #define DEFAULT_MAX_READ_INTERVAL TIME_T_TO_CDTIME_T_STATIC(86400)
 #endif
-static c_heap_t *read_heap = NULL;
+static c_heap_t *read_heap;
 static llist_t *read_list;
 static int read_loop = 1;
 static pthread_mutex_t read_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t read_cond = PTHREAD_COND_INITIALIZER;
-static pthread_t *read_threads = NULL;
-static size_t read_threads_num = 0;
+static pthread_t *read_threads;
+static size_t read_threads_num;
 static cdtime_t max_read_interval = DEFAULT_MAX_READ_INTERVAL;
 
 static write_queue_t *write_queue_head;
 static write_queue_t *write_queue_tail;
-static long write_queue_length = 0;
-static _Bool write_loop = 1;
+static long write_queue_length;
+static bool write_loop = true;
 static pthread_mutex_t write_lock = PTHREAD_MUTEX_INITIALIZER;
 static pthread_cond_t write_cond = PTHREAD_COND_INITIALIZER;
-static pthread_t *write_threads = NULL;
-static size_t write_threads_num = 0;
+static pthread_t *write_threads;
+static size_t write_threads_num;
 
 static pthread_key_t plugin_ctx_key;
-static _Bool plugin_ctx_key_initialized = 0;
+static bool plugin_ctx_key_initialized;
 
-static long write_limit_high = 0;
-static long write_limit_low = 0;
+static long write_limit_high;
+static long write_limit_low;
 
-static derive_t stats_values_dropped = 0;
-static _Bool record_statistics = 0;
+static derive_t stats_values_dropped;
+static bool record_statistics;
 
 /*
  * Static functions
@@ -148,9 +148,9 @@ static int plugin_dispatch_values_internal(value_list_t *vl);
 
 static const char *plugin_get_dir(void) {
   if (plugindir == NULL)
-    return (PLUGINDIR);
+    return PLUGINDIR;
   else
-    return (plugindir);
+    return plugindir;
 }
 
 static int plugin_update_internal_statistics(void) { /* {{{ */
@@ -191,16 +191,21 @@ static int plugin_update_internal_statistics(void) { /* {{{ */
   return 0;
 } /* }}} int plugin_update_internal_statistics */
 
-static void destroy_callback(callback_func_t *cf) /* {{{ */
+static void free_userdata(user_data_t const *ud) /* {{{ */
 {
-  if (cf == NULL)
+  if (ud == NULL)
     return;
 
-  if ((cf->cf_udata.data != NULL) && (cf->cf_udata.free_func != NULL)) {
-    cf->cf_udata.free_func(cf->cf_udata.data);
-    cf->cf_udata.data = NULL;
-    cf->cf_udata.free_func = NULL;
+  if ((ud->data != NULL) && (ud->free_func != NULL)) {
+    ud->free_func(ud->data);
   }
+} /* }}} void free_userdata */
+
+static void destroy_callback(callback_func_t *cf) /* {{{ */
+{
+  if (cf == NULL)
+    return;
+  free_userdata(&cf->cf_udata);
   sfree(cf);
 } /* }}} void destroy_callback */
 
@@ -258,7 +263,7 @@ static int register_callback(llist_t **list, /* {{{ */
       ERROR("plugin: register_callback: "
             "llist_create failed.");
       destroy_callback(cf);
-      return (-1);
+      return -1;
     }
   }
 
@@ -266,7 +271,7 @@ static int register_callback(llist_t **list, /* {{{ */
   if (key == NULL) {
     ERROR("plugin: register_callback: strdup failed.");
     destroy_callback(cf);
-    return (-1);
+    return -1;
   }
 
   le = llist_search(*list, name);
@@ -277,7 +282,7 @@ static int register_callback(llist_t **list, /* {{{ */
             "llentry_create failed.");
       sfree(key);
       destroy_callback(cf);
-      return (-1);
+      return -1;
     }
 
     llist_append(*list, le);
@@ -296,7 +301,7 @@ static int register_callback(llist_t **list, /* {{{ */
     sfree(key);
   }
 
-  return (0);
+  return 0;
 } /* }}} int register_callback */
 
 static void log_list_callbacks(llist_t **list, /* {{{ */
@@ -345,8 +350,9 @@ static int create_register_callback(llist_t **list, /* {{{ */
 
   cf = calloc(1, sizeof(*cf));
   if (cf == NULL) {
+    free_userdata(ud);
     ERROR("plugin: create_register_callback: calloc failed.");
-    return (-1);
+    return -1;
   }
 
   cf->cf_callback = callback;
@@ -359,7 +365,7 @@ static int create_register_callback(llist_t **list, /* {{{ */
 
   cf->cf_ctx = plugin_get_ctx();
 
-  return (register_callback(list, name, cf));
+  return register_callback(list, name, cf);
 } /* }}} int create_register_callback */
 
 static int plugin_unregister(llist_t *list, const char *name) /* {{{ */
@@ -367,11 +373,11 @@ static int plugin_unregister(llist_t *list, const char *name) /* {{{ */
   llentry_t *e;
 
   if (list == NULL)
-    return (-1);
+    return -1;
 
   e = llist_search(list, name);
   if (e == NULL)
-    return (-1);
+    return -1;
 
   llist_remove(list, e);
 
@@ -380,68 +386,48 @@ static int plugin_unregister(llist_t *list, const char *name) /* {{{ */
 
   llentry_destroy(e);
 
-  return (0);
+  return 0;
 } /* }}} int plugin_unregister */
 
-/*
- * (Try to) load the shared object `file'. Won't complain if it isn't a shared
- * object, but it will bitch about a shared object not having a
- * ``module_register'' symbol..
- */
-static int plugin_load_file(char *file, uint32_t flags) {
-  lt_dlhandle dlh;
-  void (*reg_handle)(void);
-
-  lt_dlinit();
-  lt_dlerror(); /* clear errors */
-
-#if LIBTOOL_VERSION == 2
-  if (flags & PLUGIN_FLAGS_GLOBAL) {
-    lt_dladvise advise;
-    lt_dladvise_init(&advise);
-    lt_dladvise_global(&advise);
-    dlh = lt_dlopenadvise(file, advise);
-    lt_dladvise_destroy(&advise);
-  } else {
-    dlh = lt_dlopen(file);
-  }
-#else /* if LIBTOOL_VERSION == 1 */
-  if (flags & PLUGIN_FLAGS_GLOBAL)
-    WARNING("plugin_load_file: The global flag is not supported, "
-            "libtool 2 is required for this.");
-  dlh = lt_dlopen(file);
-#endif
+/* plugin_load_file loads the shared object "file" and calls its
+ * "module_register" function. Returns zero on success, non-zero otherwise. */
+static int plugin_load_file(char const *file, bool global) {
+  int flags = RTLD_NOW;
+  if (global)
+    flags |= RTLD_GLOBAL;
 
+  void *dlh = dlopen(file, flags);
   if (dlh == NULL) {
     char errbuf[1024] = "";
 
-    ssnprintf(errbuf, sizeof(errbuf),
-              "lt_dlopen (\"%s\") failed: %s. "
-              "The most common cause for this problem is "
-              "missing dependencies. Use ldd(1) to check "
-              "the dependencies of the plugin "
-              "/ shared object.",
-              file, lt_dlerror());
-
-    ERROR("%s", errbuf);
-    /* Make sure this is printed to STDERR in any case, but also
-     * make sure it's printed only once. */
-    if (list_log != NULL)
-      fprintf(stderr, "ERROR: %s\n", errbuf);
+    snprintf(errbuf, sizeof(errbuf),
+             "dlopen(\"%s\") failed: %s. "
+             "The most common cause for this problem is missing dependencies. "
+             "Use ldd(1) to check the dependencies of the plugin / shared "
+             "object.",
+             file, dlerror());
+
+    /* This error is printed to STDERR unconditionally. If list_log is NULL,
+     * plugin_log() will also print to STDERR. We avoid duplicate output by
+     * checking that the list of log handlers, list_log, is not NULL. */
+    fprintf(stderr, "ERROR: %s\n", errbuf);
+    if (list_log != NULL) {
+      ERROR("%s", errbuf);
+    }
 
-    return (1);
+    return ENOENT;
   }
 
-  if ((reg_handle = (void (*)(void))lt_dlsym(dlh, "module_register")) == NULL) {
-    WARNING("Couldn't find symbol \"module_register\" in \"%s\": %s\n", file,
-            lt_dlerror());
-    lt_dlclose(dlh);
-    return (-1);
+  void (*reg_handle)(void) = dlsym(dlh, "module_register");
+  if (reg_handle == NULL) {
+    ERROR("Couldn't find symbol \"module_register\" in \"%s\": %s\n", file,
+          dlerror());
+    dlclose(dlh);
+    return ENOENT;
   }
 
   (*reg_handle)();
-
-  return (0);
+  return 0;
 }
 
 static void *plugin_read_thread(void __attribute__((unused)) * args) {
@@ -596,7 +582,7 @@ static void *plugin_read_thread(void __attribute__((unused)) * args) {
   } /* while (read_loop) */
 
   pthread_exit(NULL);
-  return ((void *)0);
+  return (void *)0;
 } /* void *plugin_read_thread */
 
 #ifdef PTHREAD_MAX_NAMELEN_NP
@@ -618,9 +604,7 @@ static void set_thread_name(pthread_t tid, char const *name) {
 #if defined(HAVE_PTHREAD_SETNAME_NP)
   int status = pthread_setname_np(tid, n);
   if (status != 0) {
-    char errbuf[1024];
-    ERROR("set_thread_name(\"%s\"): %s", n,
-          sstrerror(status, errbuf, sizeof(errbuf)));
+    ERROR("set_thread_name(\"%s\"): %s", n, STRERROR(status));
   }
 #else /* if defined(HAVE_PTHREAD_SET_NAME_NP) */
   pthread_set_name_np(tid, n);
@@ -646,15 +630,14 @@ static void start_read_threads(size_t num) /* {{{ */
                                 /* attr = */ NULL, plugin_read_thread,
                                 /* arg = */ NULL);
     if (status != 0) {
-      char errbuf[1024];
-      ERROR("plugin: start_read_threads: pthread_create failed "
-            "with status %i (%s).",
-            status, sstrerror(status, errbuf, sizeof(errbuf)));
+      ERROR("plugin: start_read_threads: pthread_create failed with status %i "
+            "(%s).",
+            status, STRERROR(status));
       return;
     }
 
     char name[THREAD_NAME_MAX];
-    ssnprintf(name, sizeof(name), "reader#%zu", read_threads_num);
+    snprintf(name, sizeof(name), "reader#%" PRIsz, read_threads_num);
     set_thread_name(read_threads[read_threads_num], name);
 
     read_threads_num++;
@@ -665,7 +648,7 @@ static void stop_read_threads(void) {
   if (read_threads == NULL)
     return;
 
-  INFO("collectd: Stopping %zu read threads.", read_threads_num);
+  INFO("collectd: Stopping %" PRIsz " read threads.", read_threads_num);
 
   pthread_mutex_lock(&read_lock);
   read_loop = 0;
@@ -699,11 +682,11 @@ plugin_value_list_clone(value_list_t const *vl_orig) /* {{{ */
   value_list_t *vl;
 
   if (vl_orig == NULL)
-    return (NULL);
+    return NULL;
 
   vl = malloc(sizeof(*vl));
   if (vl == NULL)
-    return (NULL);
+    return NULL;
   memcpy(vl, vl_orig, sizeof(*vl));
 
   if (vl->host[0] == 0)
@@ -712,7 +695,7 @@ plugin_value_list_clone(value_list_t const *vl_orig) /* {{{ */
   vl->values = calloc(vl_orig->values_len, sizeof(*vl->values));
   if (vl->values == NULL) {
     plugin_value_list_free(vl);
-    return (NULL);
+    return NULL;
   }
   memcpy(vl->values, vl_orig->values,
          vl_orig->values_len * sizeof(*vl->values));
@@ -720,7 +703,7 @@ plugin_value_list_clone(value_list_t const *vl_orig) /* {{{ */
   vl->meta = meta_data_clone(vl->meta);
   if ((vl_orig->meta != NULL) && (vl->meta == NULL)) {
     plugin_value_list_free(vl);
-    return (NULL);
+    return NULL;
   }
 
   if (vl->time == 0)
@@ -747,7 +730,7 @@ plugin_value_list_clone(value_list_t const *vl_orig) /* {{{ */
     }
   }
 
-  return (vl);
+  return vl;
 } /* }}} value_list_t *plugin_value_list_clone */
 
 static int plugin_write_enqueue(value_list_t const *vl) /* {{{ */
@@ -756,13 +739,13 @@ static int plugin_write_enqueue(value_list_t const *vl) /* {{{ */
 
   q = malloc(sizeof(*q));
   if (q == NULL)
-    return (ENOMEM);
+    return ENOMEM;
   q->next = NULL;
 
   q->vl = plugin_value_list_clone(vl);
   if (q->vl == NULL) {
     sfree(q);
-    return (ENOMEM);
+    return ENOMEM;
   }
 
   /* Store context of caller (read plugin); otherwise, it would not be
@@ -785,7 +768,7 @@ static int plugin_write_enqueue(value_list_t const *vl) /* {{{ */
   pthread_cond_signal(&write_cond);
   pthread_mutex_unlock(&write_lock);
 
-  return (0);
+  return 0;
 } /* }}} int plugin_write_enqueue */
 
 static value_list_t *plugin_write_dequeue(void) /* {{{ */
@@ -800,7 +783,7 @@ static value_list_t *plugin_write_dequeue(void) /* {{{ */
 
   if (write_queue_head == NULL) {
     pthread_mutex_unlock(&write_lock);
-    return (NULL);
+    return NULL;
   }
 
   q = write_queue_head;
@@ -817,7 +800,7 @@ static value_list_t *plugin_write_dequeue(void) /* {{{ */
 
   vl = q->vl;
   sfree(q);
-  return (vl);
+  return vl;
 } /* }}} value_list_t *plugin_write_dequeue */
 
 static void *plugin_write_thread(void __attribute__((unused)) * args) /* {{{ */
@@ -833,7 +816,7 @@ static void *plugin_write_thread(void __attribute__((unused)) * args) /* {{{ */
   }
 
   pthread_exit(NULL);
-  return ((void *)0);
+  return (void *)0;
 } /* }}} void *plugin_write_thread */
 
 static void start_write_threads(size_t num) /* {{{ */
@@ -853,15 +836,14 @@ static void start_write_threads(size_t num) /* {{{ */
                                 /* attr = */ NULL, plugin_write_thread,
                                 /* arg = */ NULL);
     if (status != 0) {
-      char errbuf[1024];
-      ERROR("plugin: start_write_threads: pthread_create failed "
-            "with status %i (%s).",
-            status, sstrerror(status, errbuf, sizeof(errbuf)));
+      ERROR("plugin: start_write_threads: pthread_create failed with status %i "
+            "(%s).",
+            status, STRERROR(status));
       return;
     }
 
     char name[THREAD_NAME_MAX];
-    ssnprintf(name, sizeof(name), "writer#%zu", write_threads_num);
+    snprintf(name, sizeof(name), "writer#%" PRIsz, write_threads_num);
     set_thread_name(write_threads[write_threads_num], name);
 
     write_threads_num++;
@@ -876,10 +858,10 @@ static void stop_write_threads(void) /* {{{ */
   if (write_threads == NULL)
     return;
 
-  INFO("collectd: Stopping %zu write threads.", write_threads_num);
+  INFO("collectd: Stopping %" PRIsz " write threads.", write_threads_num);
 
   pthread_mutex_lock(&write_lock);
-  write_loop = 0;
+  write_loop = false;
   DEBUG("plugin: stop_write_threads: Signalling `write_cond'");
   pthread_cond_broadcast(&write_cond);
   pthread_mutex_unlock(&write_lock);
@@ -908,7 +890,7 @@ static void stop_write_threads(void) /* {{{ */
   pthread_mutex_unlock(&write_lock);
 
   if (i > 0) {
-    WARNING("plugin: %zu value list%s left after shutting down "
+    WARNING("plugin: %" PRIsz " value list%s left after shutting down "
             "the write threads.",
             i, (i == 1) ? " was" : "s were");
   }
@@ -930,7 +912,7 @@ void plugin_set_dir(const char *dir) {
     ERROR("plugin_set_dir: strdup(\"%s\") failed", dir);
 }
 
-static _Bool plugin_is_loaded(char const *name) {
+static bool plugin_is_loaded(char const *name) {
   int status;
 
   if (plugins_loaded == NULL)
@@ -939,7 +921,7 @@ static _Bool plugin_is_loaded(char const *name) {
   assert(plugins_loaded != NULL);
 
   status = c_avl_get(plugins_loaded, name, /* ret_value = */ NULL);
-  return (status == 0);
+  return status == 0;
 }
 
 static int plugin_mark_loaded(char const *name) {
@@ -948,11 +930,11 @@ static int plugin_mark_loaded(char const *name) {
 
   name_copy = strdup(name);
   if (name_copy == NULL)
-    return (ENOMEM);
+    return ENOMEM;
 
   status = c_avl_insert(plugins_loaded,
                         /* key = */ name_copy, /* value = */ NULL);
-  return (status);
+  return status;
 }
 
 static void plugin_free_loaded(void) {
@@ -972,7 +954,7 @@ static void plugin_free_loaded(void) {
 }
 
 #define BUFSIZE 512
-int plugin_load(char const *plugin_name, uint32_t flags) {
+int plugin_load(char const *plugin_name, bool global) {
   DIR *dh;
   const char *dir;
   char filename[BUFSIZE] = "";
@@ -983,12 +965,12 @@ int plugin_load(char const *plugin_name, uint32_t flags) {
   int status;
 
   if (plugin_name == NULL)
-    return (EINVAL);
+    return EINVAL;
 
   /* Check if plugin is already loaded and don't do anything in this
    * case. */
   if (plugin_is_loaded(plugin_name))
-    return (0);
+    return 0;
 
   dir = plugin_get_dir();
   ret = 1;
@@ -1006,37 +988,33 @@ int plugin_load(char const *plugin_name, uint32_t flags) {
    */
   if ((strcasecmp("perl", plugin_name) == 0) ||
       (strcasecmp("python", plugin_name) == 0))
-    flags |= PLUGIN_FLAGS_GLOBAL;
+    global = true;
 
   /* `cpu' should not match `cpufreq'. To solve this we add `.so' to the
    * type when matching the filename */
-  status = ssnprintf(typename, sizeof(typename), "%s.so", plugin_name);
+  status = snprintf(typename, sizeof(typename), "%s.so", plugin_name);
   if ((status < 0) || ((size_t)status >= sizeof(typename))) {
     WARNING("plugin_load: Filename too long: \"%s.so\"", plugin_name);
-    return (-1);
+    return -1;
   }
 
   if ((dh = opendir(dir)) == NULL) {
-    char errbuf[1024];
-    ERROR("plugin_load: opendir (%s) failed: %s", dir,
-          sstrerror(errno, errbuf, sizeof(errbuf)));
-    return (-1);
+    ERROR("plugin_load: opendir (%s) failed: %s", dir, STRERRNO);
+    return -1;
   }
 
   while ((de = readdir(dh)) != NULL) {
     if (strcasecmp(de->d_name, typename))
       continue;
 
-    status = ssnprintf(filename, sizeof(filename), "%s/%s", dir, de->d_name);
+    status = snprintf(filename, sizeof(filename), "%s/%s", dir, de->d_name);
     if ((status < 0) || ((size_t)status >= sizeof(filename))) {
       WARNING("plugin_load: Filename too long: \"%s/%s\"", dir, de->d_name);
       continue;
     }
 
     if (lstat(filename, &statbuf) == -1) {
-      char errbuf[1024];
-      WARNING("plugin_load: stat (\"%s\") failed: %s", filename,
-              sstrerror(errno, errbuf, sizeof(errbuf)));
+      WARNING("plugin_load: stat (\"%s\") failed: %s", filename, STRERRNO);
       continue;
     } else if (!S_ISREG(statbuf.st_mode)) {
       /* don't follow symlinks */
@@ -1044,7 +1022,7 @@ int plugin_load(char const *plugin_name, uint32_t flags) {
       continue;
     }
 
-    status = plugin_load_file(filename, flags);
+    status = plugin_load_file(filename, global);
     if (status == 0) {
       /* success */
       plugin_mark_loaded(plugin_name);
@@ -1063,7 +1041,7 @@ int plugin_load(char const *plugin_name, uint32_t flags) {
   if (filename[0] == 0)
     ERROR("plugin_load: Could not find plugin \"%s\" in %s", plugin_name, dir);
 
-  return (ret);
+  return ret;
 }
 
 /*
@@ -1073,17 +1051,16 @@ int plugin_register_config(const char *name,
                            int (*callback)(const char *key, const char *val),
                            const char **keys, int keys_num) {
   cf_register(name, callback, keys, keys_num);
-  return (0);
+  return 0;
 } /* int plugin_register_config */
 
 int plugin_register_complex_config(const char *type,
                                    int (*callback)(oconfig_item_t *)) {
-  return (cf_register_complex(type, callback));
+  return cf_register_complex(type, callback);
 } /* int plugin_register_complex_config */
 
 int plugin_register_init(const char *name, int (*callback)(void)) {
-  return (create_register_callback(&list_init, name, (void *)callback,
-                                   /* user_data = */ NULL));
+  return create_register_callback(&list_init, name, (void *)callback, NULL);
 } /* plugin_register_init */
 
 static int plugin_compare_read_func(const void *arg0, const void *arg1) {
@@ -1094,11 +1071,11 @@ static int plugin_compare_read_func(const void *arg0, const void *arg1) {
   rf1 = arg1;
 
   if (rf0->rf_next_read < rf1->rf_next_read)
-    return (-1);
+    return -1;
   else if (rf0->rf_next_read > rf1->rf_next_read)
-    return (1);
+    return 1;
   else
-    return (0);
+    return 0;
 } /* int plugin_compare_read_func */
 
 /* Add a read function to both, the heap and a linked list. The linked list if
@@ -1118,7 +1095,7 @@ static int plugin_insert_read(read_func_t *rf) {
     if (read_list == NULL) {
       pthread_mutex_unlock(&read_lock);
       ERROR("plugin_insert_read: read_list failed.");
-      return (-1);
+      return -1;
     }
   }
 
@@ -1127,7 +1104,7 @@ static int plugin_insert_read(read_func_t *rf) {
     if (read_heap == NULL) {
       pthread_mutex_unlock(&read_lock);
       ERROR("plugin_insert_read: c_heap_create failed.");
-      return (-1);
+      return -1;
     }
   }
 
@@ -1135,17 +1112,16 @@ static int plugin_insert_read(read_func_t *rf) {
   if (le != NULL) {
     pthread_mutex_unlock(&read_lock);
     WARNING("The read function \"%s\" is already registered. "
-            "Check for duplicate \"LoadPlugin\" lines "
-            "in your configuration!",
+            "Check for duplicates in your configuration!",
             rf->rf_name);
-    return (EINVAL);
+    return EINVAL;
   }
 
   le = llentry_create(rf->rf_name, rf);
   if (le == NULL) {
     pthread_mutex_unlock(&read_lock);
     ERROR("plugin_insert_read: llentry_create failed.");
-    return (-1);
+    return -1;
   }
 
   status = c_heap_insert(read_heap, rf);
@@ -1153,7 +1129,7 @@ static int plugin_insert_read(read_func_t *rf) {
     pthread_mutex_unlock(&read_lock);
     ERROR("plugin_insert_read: c_heap_insert failed.");
     llentry_destroy(le);
-    return (-1);
+    return -1;
   }
 
   /* This does not fail. */
@@ -1162,7 +1138,7 @@ static int plugin_insert_read(read_func_t *rf) {
   /* Wake up all the read threads. */
   pthread_cond_broadcast(&read_cond);
   pthread_mutex_unlock(&read_lock);
-  return (0);
+  return 0;
 } /* int plugin_insert_read */
 
 int plugin_register_read(const char *name, int (*callback)(void)) {
@@ -1172,7 +1148,7 @@ int plugin_register_read(const char *name, int (*callback)(void)) {
   rf = calloc(1, sizeof(*rf));
   if (rf == NULL) {
     ERROR("plugin_register_read: calloc failed.");
-    return (ENOMEM);
+    return ENOMEM;
   }
 
   rf->rf_callback = (void *)callback;
@@ -1190,7 +1166,7 @@ int plugin_register_read(const char *name, int (*callback)(void)) {
     sfree(rf);
   }
 
-  return (status);
+  return status;
 } /* int plugin_register_read */
 
 int plugin_register_complex_read(const char *group, const char *name,
@@ -1201,8 +1177,9 @@ int plugin_register_complex_read(const char *group, const char *name,
 
   rf = calloc(1, sizeof(*rf));
   if (rf == NULL) {
+    free_userdata(user_data);
     ERROR("plugin_register_complex_read: calloc failed.");
-    return (ENOMEM);
+    return ENOMEM;
   }
 
   rf->rf_callback = (void *)callback;
@@ -1226,22 +1203,23 @@ int plugin_register_complex_read(const char *group, const char *name,
 
   status = plugin_insert_read(rf);
   if (status != 0) {
+    free_userdata(&rf->rf_udata);
     sfree(rf->rf_name);
     sfree(rf);
   }
 
-  return (status);
+  return status;
 } /* int plugin_register_complex_read */
 
 int plugin_register_write(const char *name, plugin_write_cb callback,
                           user_data_t const *ud) {
-  return (create_register_callback(&list_write, name, (void *)callback, ud));
+  return create_register_callback(&list_write, name, (void *)callback, ud);
 } /* int plugin_register_write */
 
 static int plugin_flush_timeout_callback(user_data_t *ud) {
   flush_callback_t *cb = ud->data;
 
-  return plugin_flush(cb->name, cb->timeout, /* identifier = */ NULL);
+  return plugin_flush(cb->name, cb->timeout, NULL);
 } /* static int plugin_flush_callback */
 
 static void plugin_flush_timeout_callback_free(void *data) {
@@ -1266,7 +1244,7 @@ static char *plugin_flush_callback_name(const char *name) {
   flush_name = malloc(name_size + prefix_size + 1);
   if (flush_name == NULL) {
     ERROR("plugin_flush_callback_name: malloc failed.");
-    return (NULL);
+    return NULL;
   }
 
   sstrncpy(flush_name, flush_prefix, prefix_size + 1);
@@ -1290,13 +1268,13 @@ int plugin_register_flush(const char *name, plugin_flush_cb callback,
 
     flush_name = plugin_flush_callback_name(name);
     if (flush_name == NULL)
-      return (-1);
+      return -1;
 
     cb = malloc(sizeof(*cb));
     if (cb == NULL) {
       ERROR("plugin_register_flush: malloc failed.");
       sfree(flush_name);
-      return (-1);
+      return -1;
     }
 
     cb->name = strdup(name);
@@ -1304,7 +1282,7 @@ int plugin_register_flush(const char *name, plugin_flush_cb callback,
       ERROR("plugin_register_flush: strdup failed.");
       sfree(cb);
       sfree(flush_name);
-      return (-1);
+      return -1;
     }
     cb->timeout = ctx.flush_timeout;
 
@@ -1318,11 +1296,7 @@ int plugin_register_flush(const char *name, plugin_flush_cb callback,
         });
 
     sfree(flush_name);
-    if (status != 0) {
-      sfree(cb->name);
-      sfree(cb);
-      return status;
-    }
+    return status;
   }
 
   return 0;
@@ -1330,12 +1304,11 @@ int plugin_register_flush(const char *name, plugin_flush_cb callback,
 
 int plugin_register_missing(const char *name, plugin_missing_cb callback,
                             user_data_t const *ud) {
-  return (create_register_callback(&list_missing, name, (void *)callback, ud));
+  return create_register_callback(&list_missing, name, (void *)callback, ud);
 } /* int plugin_register_missing */
 
 int plugin_register_shutdown(const char *name, int (*callback)(void)) {
-  return (create_register_callback(&list_shutdown, name, (void *)callback,
-                                   /* user_data = */ NULL));
+  return create_register_callback(&list_shutdown, name, (void *)callback, NULL);
 } /* int plugin_register_shutdown */
 
 static void plugin_free_data_sets(void) {
@@ -1366,50 +1339,50 @@ int plugin_register_data_set(const data_set_t *ds) {
   } else if (data_sets == NULL) {
     data_sets = c_avl_create((int (*)(const void *, const void *))strcmp);
     if (data_sets == NULL)
-      return (-1);
+      return -1;
   }
 
   ds_copy = malloc(sizeof(*ds_copy));
   if (ds_copy == NULL)
-    return (-1);
+    return -1;
   memcpy(ds_copy, ds, sizeof(data_set_t));
 
   ds_copy->ds = malloc(sizeof(*ds_copy->ds) * ds->ds_num);
   if (ds_copy->ds == NULL) {
     sfree(ds_copy);
-    return (-1);
+    return -1;
   }
 
   for (size_t i = 0; i < ds->ds_num; i++)
     memcpy(ds_copy->ds + i, ds->ds + i, sizeof(data_source_t));
 
-  return (c_avl_insert(data_sets, (void *)ds_copy->type, (void *)ds_copy));
+  return c_avl_insert(data_sets, (void *)ds_copy->type, (void *)ds_copy);
 } /* int plugin_register_data_set */
 
 int plugin_register_log(const char *name, plugin_log_cb callback,
                         user_data_t const *ud) {
-  return (create_register_callback(&list_log, name, (void *)callback, ud));
+  return create_register_callback(&list_log, name, (void *)callback, ud);
 } /* int plugin_register_log */
 
 int plugin_register_notification(const char *name,
                                  plugin_notification_cb callback,
                                  user_data_t const *ud) {
-  return (
-      create_register_callback(&list_notification, name, (void *)callback, ud));
+  return create_register_callback(&list_notification, name, (void *)callback,
+                                  ud);
 } /* int plugin_register_log */
 
 int plugin_unregister_config(const char *name) {
   cf_unregister(name);
-  return (0);
+  return 0;
 } /* int plugin_unregister_config */
 
 int plugin_unregister_complex_config(const char *name) {
   cf_unregister_complex(name);
-  return (0);
+  return 0;
 } /* int plugin_unregister_complex_config */
 
 int plugin_unregister_init(const char *name) {
-  return (plugin_unregister(list_init, name));
+  return plugin_unregister(list_init, name);
 }
 
 int plugin_unregister_read(const char *name) /* {{{ */
@@ -1418,20 +1391,20 @@ int plugin_unregister_read(const char *name) /* {{{ */
   read_func_t *rf;
 
   if (name == NULL)
-    return (-ENOENT);
+    return -ENOENT;
 
   pthread_mutex_lock(&read_lock);
 
   if (read_list == NULL) {
     pthread_mutex_unlock(&read_lock);
-    return (-ENOENT);
+    return -ENOENT;
   }
 
   le = llist_search(read_list, name);
   if (le == NULL) {
     pthread_mutex_unlock(&read_lock);
     WARNING("plugin_unregister_read: No such read function: %s", name);
-    return (-ENOENT);
+    return -ENOENT;
   }
 
   llist_remove(read_list, le);
@@ -1446,7 +1419,7 @@ int plugin_unregister_read(const char *name) /* {{{ */
 
   DEBUG("plugin_unregister_read: Marked `%s' for removal.", name);
 
-  return (0);
+  return 0;
 } /* }}} int plugin_unregister_read */
 
 void plugin_log_available_writers(void) {
@@ -1469,13 +1442,13 @@ int plugin_unregister_read_group(const char *group) /* {{{ */
   int found = 0;
 
   if (group == NULL)
-    return (-ENOENT);
+    return -ENOENT;
 
   pthread_mutex_lock(&read_lock);
 
   if (read_list == NULL) {
     pthread_mutex_unlock(&read_lock);
-    return (-ENOENT);
+    return -ENOENT;
   }
 
   while (42) {
@@ -1505,14 +1478,14 @@ int plugin_unregister_read_group(const char *group) /* {{{ */
     WARNING("plugin_unregister_read_group: No such "
             "group of read function: %s",
             group);
-    return (-ENOENT);
+    return -ENOENT;
   }
 
-  return (0);
+  return 0;
 } /* }}} int plugin_unregister_read_group */
 
 int plugin_unregister_write(const char *name) {
-  return (plugin_unregister(list_write, name));
+  return plugin_unregister(list_write, name);
 }
 
 int plugin_unregister_flush(const char *name) {
@@ -1532,34 +1505,34 @@ int plugin_unregister_flush(const char *name) {
 }
 
 int plugin_unregister_missing(const char *name) {
-  return (plugin_unregister(list_missing, name));
+  return plugin_unregister(list_missing, name);
 }
 
 int plugin_unregister_shutdown(const char *name) {
-  return (plugin_unregister(list_shutdown, name));
+  return plugin_unregister(list_shutdown, name);
 }
 
 int plugin_unregister_data_set(const char *name) {
   data_set_t *ds;
 
   if (data_sets == NULL)
-    return (-1);
+    return -1;
 
   if (c_avl_remove(data_sets, name, NULL, (void *)&ds) != 0)
-    return (-1);
+    return -1;
 
   sfree(ds->ds);
   sfree(ds);
 
-  return (0);
+  return 0;
 } /* int plugin_unregister_data_set */
 
 int plugin_unregister_log(const char *name) {
-  return (plugin_unregister(list_log, name));
+  return plugin_unregister(list_log, name);
 }
 
 int plugin_unregister_notification(const char *name) {
-  return (plugin_unregister(list_notification, name));
+  return plugin_unregister(list_notification, name);
 }
 
 int plugin_init_all(void) {
@@ -1572,7 +1545,7 @@ int plugin_init_all(void) {
   uc_init();
 
   if (IS_TRUE(global_option_get("CollectInternalStats"))) {
-    record_statistics = 1;
+    record_statistics = true;
     plugin_register_read("collectd", plugin_update_internal_statistics);
   }
 
@@ -1674,7 +1647,7 @@ int plugin_read_all_once(void) {
 
   if (read_heap == NULL) {
     NOTICE("No read-functions are registered.");
-    return (0);
+    return 0;
   }
 
   while (42) {
@@ -1710,7 +1683,7 @@ int plugin_read_all_once(void) {
     destroy_callback((void *)rf);
   }
 
-  return (return_status);
+  return return_status;
 } /* int plugin_read_all_once */
 
 int plugin_write(const char *plugin, /* {{{ */
@@ -1719,16 +1692,16 @@ int plugin_write(const char *plugin, /* {{{ */
   int status;
 
   if (vl == NULL)
-    return (EINVAL);
+    return EINVAL;
 
   if (list_write == NULL)
-    return (ENOENT);
+    return ENOENT;
 
   if (ds == NULL) {
     ds = plugin_get_ds(vl->type);
     if (ds == NULL) {
       ERROR("plugin_write: Unable to lookup type `%s'.", vl->type);
-      return (ENOENT);
+      return ENOENT;
     }
   }
 
@@ -1773,7 +1746,7 @@ int plugin_write(const char *plugin, /* {{{ */
     }
 
     if (le == NULL)
-      return (ENOENT);
+      return ENOENT;
 
     cf = le->value;
 
@@ -1785,14 +1758,14 @@ int plugin_write(const char *plugin, /* {{{ */
     status = (*callback)(ds, vl, &cf->cf_udata);
   }
 
-  return (status);
+  return status;
 } /* }}} int plugin_write */
 
 int plugin_flush(const char *plugin, cdtime_t timeout, const char *identifier) {
   llentry_t *le;
 
   if (list_flush == NULL)
-    return (0);
+    return 0;
 
   le = llist_head(list_flush);
   while (le != NULL) {
@@ -1815,7 +1788,7 @@ int plugin_flush(const char *plugin, cdtime_t timeout, const char *identifier) {
 
     le = le->next;
   }
-  return (0);
+  return 0;
 } /* int plugin_flush */
 
 int plugin_shutdown_all(void) {
@@ -1881,52 +1854,43 @@ int plugin_shutdown_all(void) {
 
   plugin_free_loaded();
   plugin_free_data_sets();
-  return (ret);
+  return ret;
 } /* void plugin_shutdown_all */
 
 int plugin_dispatch_missing(const value_list_t *vl) /* {{{ */
 {
-  llentry_t *le;
-
   if (list_missing == NULL)
-    return (0);
+    return 0;
 
-  le = llist_head(list_missing);
+  llentry_t *le = llist_head(list_missing);
   while (le != NULL) {
-    callback_func_t *cf;
-    plugin_missing_cb callback;
-    plugin_ctx_t old_ctx;
-    int status;
+    callback_func_t *cf = le->value;
+    plugin_ctx_t old_ctx = plugin_set_ctx(cf->cf_ctx);
+    plugin_missing_cb callback = cf->cf_callback;
 
-    cf = le->value;
-    old_ctx = plugin_set_ctx(cf->cf_ctx);
-    callback = cf->cf_callback;
-
-    status = (*callback)(vl, &cf->cf_udata);
+    int status = (*callback)(vl, &cf->cf_udata);
     plugin_set_ctx(old_ctx);
     if (status != 0) {
       if (status < 0) {
         ERROR("plugin_dispatch_missing: Callback function \"%s\" "
               "failed with status %i.",
               le->key, status);
-        return (status);
+        return status;
       } else {
-        return (0);
+        return 0;
       }
     }
 
     le = le->next;
   }
-  return (0);
+  return 0;
 } /* int }}} plugin_dispatch_missing */
 
 static int plugin_dispatch_values_internal(value_list_t *vl) {
   int status;
   static c_complain_t no_write_complaint = C_COMPLAIN_INIT_STATIC;
 
-  data_set_t *ds;
-
-  _Bool free_meta_data = 0;
+  bool free_meta_data = false;
 
   assert(vl != NULL);
 
@@ -1939,14 +1903,14 @@ static int plugin_dispatch_values_internal(value_list_t *vl) {
     ERROR("plugin_dispatch_values: Invalid value list "
           "from plugin %s.",
           vl->plugin);
-    return (-1);
+    return -1;
   }
 
   /* Free meta data only if the calling function didn't specify any. In
    * this case matches and targets may add some and the calling function
    * may not expect (and therefore free) that data. */
   if (vl->meta == NULL)
-    free_meta_data = 1;
+    free_meta_data = true;
 
   if (list_write == NULL)
     c_complain_once(LOG_WARNING, &no_write_complaint,
@@ -1958,9 +1922,10 @@ static int plugin_dispatch_values_internal(value_list_t *vl) {
     ERROR("plugin_dispatch_values: No data sets registered. "
           "Could the types database be read? Check "
           "your `TypesDB' setting!");
-    return (-1);
+    return -1;
   }
 
+  data_set_t *ds = NULL;
   if (c_avl_get(data_sets, vl->type, (void *)&ds) != 0) {
     char ident[6 * DATA_MAX_NAME_LEN];
 
@@ -1968,7 +1933,7 @@ static int plugin_dispatch_values_internal(value_list_t *vl) {
     INFO("plugin_dispatch_values: Dataset not found: %s "
          "(from \"%s\"), check your types.db!",
          vl->type, ident);
-    return (-1);
+    return -1;
   }
 
   DEBUG("plugin_dispatch_values: time = %.3f; interval = %.3f; "
@@ -1991,10 +1956,10 @@ static int plugin_dispatch_values_internal(value_list_t *vl) {
 #else
   if (ds->ds_num != vl->values_len) {
     ERROR("plugin_dispatch_values: ds->type = %s: "
-          "(ds->ds_num = %zu) != "
-          "(vl->values_len = %zu)",
+          "(ds->ds_num = %" PRIsz ") != "
+          "(vl->values_len = %" PRIsz ")",
           ds->type, ds->ds_num, vl->values_len);
-    return (-1);
+    return -1;
   }
 #endif
 
@@ -2012,7 +1977,7 @@ static int plugin_dispatch_values_internal(value_list_t *vl) {
               "status %i (%#x).",
               status, status);
     } else if (status == FC_TARGET_STOP)
-      return (0);
+      return 0;
   }
 
   /* Update the value cache */
@@ -2029,12 +1994,12 @@ static int plugin_dispatch_values_internal(value_list_t *vl) {
   } else
     fc_default_action(ds, vl);
 
-  if ((free_meta_data != 0) && (vl->meta != NULL)) {
+  if ((free_meta_data == true) && (vl->meta != NULL)) {
     meta_data_destroy(vl->meta);
     vl->meta = NULL;
   }
 
-  return (0);
+  return 0;
 } /* int plugin_dispatch_values_internal */
 
 static double get_drop_probability(void) /* {{{ */
@@ -2048,19 +2013,19 @@ static double get_drop_probability(void) /* {{{ */
   pthread_mutex_unlock(&write_lock);
 
   if (wql < write_limit_low)
-    return (0.0);
+    return 0.0;
   if (wql >= write_limit_high)
-    return (1.0);
+    return 1.0;
 
   pos = 1 + wql - write_limit_low;
   size = 1 + write_limit_high - write_limit_low;
 
-  return (((double)pos) / ((double)size));
+  return (double)pos / (double)size;
 } /* }}} double get_drop_probability */
 
-static _Bool check_drop_value(void) /* {{{ */
+static bool check_drop_value(void) /* {{{ */
 {
-  static cdtime_t last_message_time = 0;
+  static cdtime_t last_message_time;
   static pthread_mutex_t last_message_lock = PTHREAD_MUTEX_INITIALIZER;
 
   double p;
@@ -2068,11 +2033,11 @@ static _Bool check_drop_value(void) /* {{{ */
   int status;
 
   if (write_limit_high == 0)
-    return (0);
+    return false;
 
   p = get_drop_probability();
   if (p == 0.0)
-    return (0);
+    return false;
 
   status = pthread_mutex_trylock(&last_message_lock);
   if (status == 0) {
@@ -2089,14 +2054,14 @@ static _Bool check_drop_value(void) /* {{{ */
   }
 
   if (p == 1.0)
-    return (1);
+    return true;
 
   q = cdrand_d();
   if (q > p)
-    return (1);
+    return true;
   else
-    return (0);
-} /* }}} _Bool check_drop_value */
+    return false;
+} /* }}} bool check_drop_value */
 
 int plugin_dispatch_values(value_list_t const *vl) {
   int status;
@@ -2108,24 +2073,23 @@ int plugin_dispatch_values(value_list_t const *vl) {
       stats_values_dropped++;
       pthread_mutex_unlock(&statistics_lock);
     }
-    return (0);
+    return 0;
   }
 
   status = plugin_write_enqueue(vl);
   if (status != 0) {
-    char errbuf[1024];
-    ERROR("plugin_dispatch_values: plugin_write_enqueue failed "
-          "with status %i (%s).",
-          status, sstrerror(status, errbuf, sizeof(errbuf)));
-    return (status);
+    ERROR("plugin_dispatch_values: plugin_write_enqueue failed with status %i "
+          "(%s).",
+          status, STRERROR(status));
+    return status;
   }
 
-  return (0);
+  return 0;
 }
 
 __attribute__((sentinel)) int
 plugin_dispatch_multivalue(value_list_t const *template, /* {{{ */
-                           _Bool store_percentage, int store_type, ...) {
+                           bool store_percentage, int store_type, ...) {
   value_list_t *vl;
   int failed = 0;
   gauge_t sum = 0.0;
@@ -2195,7 +2159,7 @@ plugin_dispatch_multivalue(value_list_t const *template, /* {{{ */
   va_end(ap);
 
   plugin_value_list_free(vl);
-  return (failed);
+  return failed;
 } /* }}} int plugin_dispatch_multivalue */
 
 int plugin_dispatch_notification(const notification_t *notif) {
@@ -2209,7 +2173,7 @@ int plugin_dispatch_notification(const notification_t *notif) {
 
   /* Nobody cares for notifications */
   if (list_notification == NULL)
-    return (-1);
+    return -1;
 
   le = llist_head(list_notification);
   while (le != NULL) {
@@ -2232,7 +2196,7 @@ int plugin_dispatch_notification(const notification_t *notif) {
     le = le->next;
   }
 
-  return (0);
+  return 0;
 } /* int plugin_dispatch_notification */
 
 void plugin_log(int level, const char *format, ...) {
@@ -2290,7 +2254,7 @@ int parse_log_severity(const char *severity) {
     log_level = LOG_DEBUG;
 #endif /* COLLECT_DEBUG */
 
-  return (log_level);
+  return log_level;
 } /* int parse_log_severity */
 
 int parse_notif_severity(const char *severity) {
@@ -2304,7 +2268,7 @@ int parse_notif_severity(const char *severity) {
            (strcmp(severity, "WARN") == 0))
     notif_severity = NOTIF_WARNING;
 
-  return (notif_severity);
+  return notif_severity;
 } /* int parse_notif_severity */
 
 const data_set_t *plugin_get_ds(const char *name) {
@@ -2312,15 +2276,15 @@ const data_set_t *plugin_get_ds(const char *name) {
 
   if (data_sets == NULL) {
     ERROR("plugin_get_ds: No data sets are defined yet.");
-    return (NULL);
+    return NULL;
   }
 
   if (c_avl_get(data_sets, name, (void *)&ds) != 0) {
     DEBUG("No such dataset registered: %s", name);
-    return (NULL);
+    return NULL;
   }
 
-  return (ds);
+  return ds;
 } /* data_set_t *plugin_get_ds */
 
 static int plugin_notification_meta_add(notification_t *n, const char *name,
@@ -2331,13 +2295,13 @@ static int plugin_notification_meta_add(notification_t *n, const char *name,
 
   if ((n == NULL) || (name == NULL) || (value == NULL)) {
     ERROR("plugin_notification_meta_add: A pointer is NULL!");
-    return (-1);
+    return -1;
   }
 
   meta = calloc(1, sizeof(*meta));
   if (meta == NULL) {
     ERROR("plugin_notification_meta_add: calloc failed.");
-    return (-1);
+    return -1;
   }
 
   sstrncpy(meta->name, name, sizeof(meta->name));
@@ -2349,7 +2313,7 @@ static int plugin_notification_meta_add(notification_t *n, const char *name,
     if (meta->nm_value.nm_string == NULL) {
       ERROR("plugin_notification_meta_add: strdup failed.");
       sfree(meta);
-      return (-1);
+      return -1;
     }
     break;
   }
@@ -2366,13 +2330,13 @@ static int plugin_notification_meta_add(notification_t *n, const char *name,
     break;
   }
   case NM_TYPE_BOOLEAN: {
-    meta->nm_value.nm_boolean = *((_Bool *)value);
+    meta->nm_value.nm_boolean = *((bool *)value);
     break;
   }
   default: {
     ERROR("plugin_notification_meta_add: Unknown type: %i", type);
     sfree(meta);
-    return (-1);
+    return -1;
   }
   } /* switch (type) */
 
@@ -2386,33 +2350,33 @@ static int plugin_notification_meta_add(notification_t *n, const char *name,
   else
     tail->next = meta;
 
-  return (0);
+  return 0;
 } /* int plugin_notification_meta_add */
 
 int plugin_notification_meta_add_string(notification_t *n, const char *name,
                                         const char *value) {
-  return (plugin_notification_meta_add(n, name, NM_TYPE_STRING, value));
+  return plugin_notification_meta_add(n, name, NM_TYPE_STRING, value);
 }
 
 int plugin_notification_meta_add_signed_int(notification_t *n, const char *name,
                                             int64_t value) {
-  return (plugin_notification_meta_add(n, name, NM_TYPE_SIGNED_INT, &value));
+  return plugin_notification_meta_add(n, name, NM_TYPE_SIGNED_INT, &value);
 }
 
 int plugin_notification_meta_add_unsigned_int(notification_t *n,
                                               const char *name,
                                               uint64_t value) {
-  return (plugin_notification_meta_add(n, name, NM_TYPE_UNSIGNED_INT, &value));
+  return plugin_notification_meta_add(n, name, NM_TYPE_UNSIGNED_INT, &value);
 }
 
 int plugin_notification_meta_add_double(notification_t *n, const char *name,
                                         double value) {
-  return (plugin_notification_meta_add(n, name, NM_TYPE_DOUBLE, &value));
+  return plugin_notification_meta_add(n, name, NM_TYPE_DOUBLE, &value);
 }
 
 int plugin_notification_meta_add_boolean(notification_t *n, const char *name,
-                                         _Bool value) {
-  return (plugin_notification_meta_add(n, name, NM_TYPE_BOOLEAN, &value));
+                                         bool value) {
+  return plugin_notification_meta_add(n, name, NM_TYPE_BOOLEAN, &value);
 }
 
 int plugin_notification_meta_copy(notification_t *dst,
@@ -2440,7 +2404,7 @@ int plugin_notification_meta_copy(notification_t *dst,
                                            meta->nm_value.nm_boolean);
   }
 
-  return (0);
+  return 0;
 } /* int plugin_notification_meta_copy */
 
 int plugin_notification_meta_free(notification_meta_t *n) {
@@ -2449,7 +2413,7 @@ int plugin_notification_meta_free(notification_meta_t *n) {
 
   if (n == NULL) {
     ERROR("plugin_notification_meta_free: n == NULL!");
-    return (-1);
+    return -1;
   }
 
   this = n;
@@ -2469,7 +2433,7 @@ int plugin_notification_meta_free(notification_meta_t *n) {
     this = next;
   }
 
-  return (0);
+  return 0;
 } /* int plugin_notification_meta_free */
 
 static void plugin_ctx_destructor(void *ctx) {
@@ -2483,9 +2447,7 @@ static plugin_ctx_t *plugin_ctx_create(void) {
 
   ctx = malloc(sizeof(*ctx));
   if (ctx == NULL) {
-    char errbuf[1024];
-    ERROR("Failed to allocate plugin context: %s",
-          sstrerror(errno, errbuf, sizeof(errbuf)));
+    ERROR("Failed to allocate plugin context: %s", STRERRNO);
     return NULL;
   }
 
@@ -2493,12 +2455,12 @@ static plugin_ctx_t *plugin_ctx_create(void) {
   assert(plugin_ctx_key_initialized);
   pthread_setspecific(plugin_ctx_key, ctx);
   DEBUG("Created new plugin context.");
-  return (ctx);
+  return ctx;
 } /* int plugin_ctx_create */
 
 void plugin_init_ctx(void) {
   pthread_key_create(&plugin_ctx_key, plugin_ctx_destructor);
-  plugin_ctx_key_initialized = 1;
+  plugin_ctx_key_initialized = true;
 } /* void plugin_init_ctx */
 
 plugin_ctx_t plugin_get_ctx(void) {
@@ -2514,7 +2476,7 @@ plugin_ctx_t plugin_get_ctx(void) {
       return ctx_init;
   }
 
-  return (*ctx);
+  return *ctx;
 } /* plugin_ctx_t plugin_get_ctx */
 
 plugin_ctx_t plugin_set_ctx(plugin_ctx_t ctx) {
@@ -2534,7 +2496,7 @@ plugin_ctx_t plugin_set_ctx(plugin_ctx_t ctx) {
   old = *c;
   *c = ctx;
 
-  return (old);
+  return old;
 } /* void plugin_set_ctx */
 
 cdtime_t plugin_get_interval(void) {
@@ -2590,5 +2552,3 @@ int plugin_thread_create(pthread_t *thread, const pthread_attr_t *attr,
 
   return 0;
 } /* int plugin_thread_create */
-
-/* vim: set sw=8 ts=8 noet fdm=marker : */