src/plugin.c: Add a user_data_t pointer to notification callbacks.

diff --git a/src/exec.c b/src/exec.c
index 973cd52b713c21277a7d27233fa000effccc79c0..cdcf6adebdba0f886aa2515cb92e7ac9b21a92d7 100644 (file)
--- a/src/exec.c
+++ b/src/exec.c
@@ -761,7 +761,8 @@ static int exec_read (void) /* {{{ */
   return (0);
 } /* int exec_read }}} */
 
-static int exec_notification (const notification_t *n)
+static int exec_notification (const notification_t *n,
+    user_data_t __attribute__((unused)) *user_data)
 {
   program_list_t *pl;
   program_list_and_notification_t *pln;
@@ -801,7 +802,7 @@ static int exec_notification (const notification_t *n)
   } /* for (pl) */
 
   return (0);
-} /* int exec_notification */
+} /* }}} int exec_notification */
 
 static int exec_shutdown (void) /* {{{ */
 {
@@ -834,7 +835,8 @@ void module_register (void)
   plugin_register_complex_config ("exec", exec_config);
   plugin_register_init ("exec", exec_init);
   plugin_register_read ("exec", exec_read);
-  plugin_register_notification ("exec", exec_notification);
+  plugin_register_notification ("exec", exec_notification,
+      /* user_data = */ NULL);
   plugin_register_shutdown ("exec", exec_shutdown);
 } /* void module_register */
 

diff --git a/src/logfile.c b/src/logfile.c
index 26d805a4ce4a9c93481e886aadd2ef787e4d3d40..8e98c0478e925de5ad3a6e1372206e88af79dddf 100644 (file)
--- a/src/logfile.c
+++ b/src/logfile.c
@@ -152,7 +152,8 @@ static void logfile_log (int severity, const char *msg,
        logfile_print (msg, time (NULL));
 } /* void logfile_log (int, const char *) */
 
-static int logfile_notification (const notification_t *n)
+static int logfile_notification (const notification_t *n,
+               user_data_t __attribute__((unused)) *user_data)
 {
        char  buf[1024] = "";
        char *buf_ptr = buf;
@@ -196,7 +197,8 @@ void module_register (void)
        plugin_register_config ("logfile", logfile_config,
                        config_keys, config_keys_num);
        plugin_register_log ("logfile", logfile_log, /* user_data = */ NULL);
-       plugin_register_notification ("logfile", logfile_notification);
+       plugin_register_notification ("logfile", logfile_notification,
+                       /* user_data = */ NULL);
 } /* void module_register (void) */
 
 /* vim: set sw=4 ts=4 tw=78 noexpandtab : */

diff --git a/src/network.c b/src/network.c
index 0434b35908ed578d7a5c7607a4ef104b4eb98999..c9a92ac5b887ce4549fc4ec3805d3312fd669414 100644 (file)
--- a/src/network.c
+++ b/src/network.c
@@ -1632,7 +1632,8 @@ static int network_config (const char *key, const char *val)
        return (0);
 } /* int network_config */
 
-static int network_notification (const notification_t *n)
+static int network_notification (const notification_t *n,
+               user_data_t __attribute__((unused)) *user_data)
 {
   char  buffer[BUFF_SIZE];
   char *buffer_ptr = buffer;
@@ -1770,7 +1771,8 @@ static int network_init (void)
        {
                plugin_register_write ("network", network_write,
                                /* user_data = */ NULL);
-               plugin_register_notification ("network", network_notification);
+               plugin_register_notification ("network", network_notification,
+                               /* user_data = */ NULL);
        }
 
        if ((listen_sockets_num != 0) && (receive_thread_id == 0))

diff --git a/src/notify_desktop.c b/src/notify_desktop.c
index 2e62e88c46fa61c3ea3b5200524d88fdb12ac779..839bc61027180599d67f6d70600f42fb2465e7c6 100644 (file)
--- a/src/notify_desktop.c
+++ b/src/notify_desktop.c
@@ -72,7 +72,8 @@ static int c_notify_config (oconfig_item_t *ci)
        return 0;
 } /* c_notify_config */
 
-static int c_notify (const notification_t *n)
+static int c_notify (const notification_t *n,
+               user_data_t __attribute__((unused)) *user_data)
 {
        NotifyNotification *notification = NULL;
        NotifyUrgency       urgency      = NOTIFY_URGENCY_LOW;
@@ -145,7 +146,8 @@ static int c_notify_init (void)
                free (spec_version);
        }
 
-       plugin_register_notification ("notify_desktop", c_notify);
+       plugin_register_notification ("notify_desktop", c_notify,
+                       /* user_data = */ NULL);
        plugin_register_shutdown ("notify_desktop", c_notify_shutdown);
        return 0;
 } /* c_notify_init */

diff --git a/src/notify_email.c b/src/notify_email.c
index 32bd91647a75f51089011b59e3759ec00c6f7f6a..62e1c486a3601f20db464b1e2083d96cc46544d3 100644 (file)
--- a/src/notify_email.c
+++ b/src/notify_email.c
@@ -203,7 +203,8 @@ static int notify_email_config (const char *key, const char *value)
   return 0;
 } /* int notify_email_config (const char *, const char *) */
 
-static int notify_email_notification (const notification_t *n)
+static int notify_email_notification (const notification_t *n,
+    user_data_t __attribute__((unused)) *user_data)
 {
   smtp_recipient_t recipient;
 
@@ -282,7 +283,8 @@ void module_register (void)
   plugin_register_shutdown ("notify_email", notify_email_shutdown);
   plugin_register_config ("notify_email", notify_email_config,
       config_keys, config_keys_num);
-  plugin_register_notification ("notify_email", notify_email_notification);
+  plugin_register_notification ("notify_email", notify_email_notification,
+      /* user_data = */ NULL);
 } /* void module_register (void) */
 
 /* vim: set sw=2 sts=2 ts=8 et : */

diff --git a/src/perl.c b/src/perl.c
index e6b7c460d9b59a3e711361bb058a9473e6d98477..96ba802445b7e6e1aa56b2de17aeec597cda2a74 100644 (file)
--- a/src/perl.c
+++ b/src/perl.c
@@ -1955,7 +1955,8 @@ static void perl_log (int level, const char *msg,
        return;
 } /* static void perl_log (int, const char *) */
 
-static int perl_notify (const notification_t *notif)
+static int perl_notify (const notification_t *notif,
+               user_data_t __attribute__((unused)) *user_data)
 {
        dTHX;
 
@@ -2222,7 +2223,8 @@ static int init_pi (int argc, char **argv)
        perl_run (aTHX);
 
        plugin_register_log ("perl", perl_log, /* user_data = */ NULL);
-       plugin_register_notification ("perl", perl_notify);
+       plugin_register_notification ("perl", perl_notify,
+                       /* user_data = */ NULL);
        plugin_register_init ("perl", perl_init);
 
        plugin_register_read ("perl", perl_read);

diff --git a/src/plugin.c b/src/plugin.c
index 41a816f81e7817187cbf9cd538770262dda6e5fe..4e35bf2ba56e584dd908e53f2ba12681ca285d8a 100644 (file)
--- a/src/plugin.c
+++ b/src/plugin.c
@@ -41,44 +41,29 @@
 /*
  * Private structures
  */
+struct callback_func_s
+{
+       void *cf_callback;
+       user_data_t cf_udata;
+};
+typedef struct callback_func_s callback_func_t;
+
 #define RF_SIMPLE  0
 #define RF_COMPLEX 1
 struct read_func_s
 {
-       int wait_time;
-       int wait_left;
-       int type;
-       union
-       {
-               int (*cb_simple) (void);
-               plugin_read_cb cb_complex;
-       } callback;
-       enum { DONE = 0, TODO = 1, ACTIVE = 2 } needs_read;
-       user_data_t udata;
+       /* `read_func_t' "inherits" from `callback_func_t'.
+        * The `rf_super' member MUST be the first one in this structure! */
+#define rf_callback rf_super.cf_callback
+#define rf_udata rf_super.cf_udata
+       callback_func_t rf_super;
+       int rf_type;
+       int rf_wait_time;
+       int rf_wait_left;
+       enum { DONE = 0, TODO = 1, ACTIVE = 2 } rf_needs_read;
 };
 typedef struct read_func_s read_func_t;
 
-struct write_func_s
-{
-       plugin_write_cb callback;
-       user_data_t udata;
-};
-typedef struct write_func_s write_func_t;
-
-struct flush_func_s
-{
-       plugin_flush_cb callback;
-       user_data_t udata;
-};
-typedef struct flush_func_s flush_func_t;
-
-struct log_func_s
-{
-       plugin_log_cb callback;
-       user_data_t udata;
-};
-typedef struct log_func_s log_func_t;
-
 /*
  * Private variables
  */
@@ -114,26 +99,81 @@ static const char *plugin_get_dir (void)
                return (plugindir);
 }
 
-static int register_callback (llist_t **list, const char *name, void *callback)
+static void destroy_callback (callback_func_t *cf) /* {{{ */
+{
+       if (cf == 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;
+       }
+       sfree (cf);
+} /* }}} void destroy_callback */
+
+static void destroy_all_callbacks (llist_t **list) /* {{{ */
+{
+       llentry_t *le;
+
+       if (*list == NULL)
+               return;
+
+       le = llist_head (*list);
+       while (le != NULL)
+       {
+               llentry_t *le_next;
+
+               le_next = le->next;
+
+               sfree (le->key);
+               destroy_callback (le->value);
+               le->value = NULL;
+
+               le = le_next;
+       }
+
+       llist_destroy (*list);
+       *list = NULL;
+} /* }}} void destroy_all_callbacks */
+
+static int register_callback (llist_t **list, /* {{{ */
+               const char *name, callback_func_t *cf)
 {
        llentry_t *le;
        char *key;
 
-       if ((*list == NULL)
-                       && ((*list = llist_create ()) == NULL))
+       if (*list == NULL)
+       {
+               *list = llist_create ();
+               if (*list == NULL)
+               {
+                       ERROR ("plugin: create_register_callback: "
+                                       "llist_create failed.");
+                       destroy_callback (cf);
+                       return (-1);
+               }
+       }
+
+       key = strdup (name);
+       if (key == NULL)
+       {
+               ERROR ("plugin: create_register_callback: strdup failed.");
+               destroy_callback (cf);
                return (-1);
+       }
 
        le = llist_search (*list, name);
        if (le == NULL)
        {
-               key = strdup (name);
-               if (key == NULL)
-                       return (-1);
-
-               le = llentry_create (key, callback);
+               le = llentry_create (key, cf);
                if (le == NULL)
                {
+                       ERROR ("plugin: create_register_callback: "
+                                       "llentry_create failed.");
                        free (key);
+                       destroy_callback (cf);
                        return (-1);
                }
 
@@ -141,37 +181,67 @@ static int register_callback (llist_t **list, const char *name, void *callback)
        }
        else
        {
-               le->value = callback;
+               callback_func_t *old_cf;
+
+               old_cf = le->value;
+               le->value = cf;
+
+               destroy_callback (old_cf);
+               sfree (key);
        }
 
        return (0);
-} /* int register_callback */
+} /* }}} int register_callback */
 
-static void plugin_user_data_destroy (user_data_t *ud)
+static int create_register_callback (llist_t **list, /* {{{ */
+               const char *name, void *callback, user_data_t *ud)
 {
-       if ((ud != NULL) && (ud->data != NULL) && (ud->free_func != NULL))
+       char *key;
+       callback_func_t *cf;
+
+       cf = (callback_func_t *) malloc (sizeof (*cf));
+       if (cf == NULL)
+       {
+               ERROR ("plugin: create_register_callback: malloc failed.");
+               sfree (key);
+               return (-1);
+       }
+       memset (cf, 0, sizeof (*cf));
+
+       cf->cf_callback = callback;
+       if (ud == NULL)
+       {
+               cf->cf_udata.data = NULL;
+               cf->cf_udata.free_func = NULL;
+       }
+       else
        {
-               ud->free_func (ud->data);
-               ud->data = NULL;
-               ud->free_func = NULL;
+               cf->cf_udata = *ud;
        }
-} /* void plugin_user_data_destroy */
 
-static int plugin_unregister (llist_t *list, const char *name)
+       return (register_callback (list, name, cf));
+} /* }}} int create_register_callback */
+
+static int plugin_unregister (llist_t *list, const char *name) /* {{{ */
 {
        llentry_t *e;
 
-       e = llist_search (list, name);
+       if (list == NULL)
+               return (-1);
 
+       e = llist_search (list, name);
        if (e == NULL)
                return (-1);
 
        llist_remove (list, e);
-       free (e->key);
+
+       sfree (e->key);
+       destroy_callback (e->value);
+
        llentry_destroy (e);
 
        return (0);
-} /* int plugin_unregister */
+} /* }}} int plugin_unregister */
 
 /*
  * (Try to) load the shared object `file'. Won't complain if it isn't a shared
@@ -228,52 +298,58 @@ static void *plugin_read_thread (void __attribute__((unused)) *args)
                {
                        rf = (read_func_t *) le->value;
 
-                       if (rf->needs_read != TODO)
+                       if (rf->rf_needs_read != TODO)
                        {
                                le = le->next;
                                continue;
                        }
 
                        /* We will do this read function */
-                       rf->needs_read = ACTIVE;
+                       rf->rf_needs_read = ACTIVE;
 
                        DEBUG ("[thread #%5lu] plugin: plugin_read_thread: Handling %s",
                                        (unsigned long int) pthread_self (), le->key);
                        pthread_mutex_unlock (&read_lock);
 
-                       if (rf->type == RF_SIMPLE)
+                       if (rf->rf_type == RF_SIMPLE)
                        {
-                               status = rf->callback.cb_simple ();
+                               int (*callback) (void);
+
+                               callback = rf->rf_callback;
+                               status = (*callback) ();
                        }
                        else
                        {
-                               assert (rf->type == RF_COMPLEX);
-                               status = rf->callback.cb_complex (&rf->udata);
+                               plugin_read_cb callback;
+
+                               callback = rf->rf_callback;
+                               status = (*callback) (&rf->rf_udata);
                        }
+
                        done++;
 
                        if (status != 0)
                        {
-                               if (rf->wait_time < interval_g)
-                                       rf->wait_time = interval_g;
-                               rf->wait_left = rf->wait_time;
-                               rf->wait_time = rf->wait_time * 2;
-                               if (rf->wait_time > 86400)
-                                       rf->wait_time = 86400;
+                               if (rf->rf_wait_time < interval_g)
+                                       rf->rf_wait_time = interval_g;
+                               rf->rf_wait_left = rf->rf_wait_time;
+                               rf->rf_wait_time = rf->rf_wait_time * 2;
+                               if (rf->rf_wait_time > 86400)
+                                       rf->rf_wait_time = 86400;
 
                                NOTICE ("read-function of plugin `%s' "
                                                "failed. Will suspend it for %i "
-                                               "seconds.", le->key, rf->wait_left);
+                                               "seconds.", le->key, rf->rf_wait_left);
                        }
                        else
                        {
-                               rf->wait_left = 0;
-                               rf->wait_time = interval_g;
+                               rf->rf_wait_left = 0;
+                               rf->rf_wait_time = interval_g;
                        }
 
                        pthread_mutex_lock (&read_lock);
 
-                       rf->needs_read = DONE;
+                       rf->rf_needs_read = DONE;
                        le = le->next;
                } /* while (le != NULL) */
 
@@ -346,36 +422,6 @@ static void stop_read_threads (void)
        read_threads_num = 0;
 } /* void stop_read_threads */
 
-static int remove_read_functions (void)
-{
-       llentry_t *this;
-
-       if (list_read == NULL)
-               return (0);
-
-       this = llist_head (list_read);
-       while (this != NULL)
-       {
-               llentry_t *next;
-               read_func_t *rf;
-
-               next = this->next;
-               rf = (read_func_t *) this->value;
-
-               free (this->key);
-
-               plugin_user_data_destroy (&rf->udata);
-               free (rf);
-
-               this = next;
-       }
-
-       llist_destroy (list_read);
-       list_read = NULL;
-
-       return (0);
-} /* }}} int remove_read_functions */
-
 /*
  * Public functions
  */
@@ -496,7 +542,8 @@ int plugin_register_complex_config (const char *type,
 int plugin_register_init (const char *name,
                int (*callback) (void))
 {
-       return (register_callback (&list_init, name, (void *) callback));
+       return (create_register_callback (&list_init, name, (void *) callback,
+                               /* user_data = */ NULL));
 } /* plugin_register_init */
 
 int plugin_register_read (const char *name,
@@ -514,15 +561,15 @@ int plugin_register_read (const char *name,
        }
 
        memset (rf, 0, sizeof (read_func_t));
-       rf->wait_time = interval_g;
-       rf->wait_left = 0;
-       rf->type = RF_SIMPLE;
-       rf->callback.cb_simple = callback;
-       rf->needs_read = DONE;
-       rf->udata.data = NULL;
-       rf->udata.free_func = NULL;
-
-       return (register_callback (&list_read, name, (void *) rf));
+       rf->rf_callback = (void *) callback;
+       rf->rf_udata.data = NULL;
+       rf->rf_udata.free_func = NULL;
+       rf->rf_wait_time = interval_g;
+       rf->rf_wait_left = 0;
+       rf->rf_type = RF_SIMPLE;
+       rf->rf_needs_read = DONE;
+
+       return (register_callback (&list_read, name, (callback_func_t *) rf));
 } /* int plugin_register_read */
 
 int plugin_register_complex_read (const char *name,
@@ -538,84 +585,45 @@ int plugin_register_complex_read (const char *name,
        }
 
        memset (rf, 0, sizeof (read_func_t));
-       rf->wait_time = interval_g;
-       rf->wait_left = 0;
-       rf->type = RF_COMPLEX;
-       rf->callback.cb_complex = callback;
-       rf->needs_read = DONE;
+       rf->rf_callback = (void *) callback;
+       rf->rf_wait_time = interval_g;
+       rf->rf_wait_left = 0;
+       rf->rf_type = RF_COMPLEX;
+       rf->rf_needs_read = DONE;
 
        /* Set user data */
        if (user_data == NULL)
        {
-               rf->udata.data = NULL;
-               rf->udata.free_func = NULL;
+               rf->rf_udata.data = NULL;
+               rf->rf_udata.free_func = NULL;
        }
        else
        {
-               rf->udata = *user_data;
+               rf->rf_udata = *user_data;
        }
 
-       return (register_callback (&list_read, name, (void *) rf));
+       return (register_callback (&list_read, name, (callback_func_t *) rf));
 } /* int plugin_register_complex_read */
 
 int plugin_register_write (const char *name,
-               plugin_write_cb callback, user_data_t *user_data)
+               plugin_write_cb callback, user_data_t *ud)
 {
-       write_func_t *wf;
-
-       wf = (write_func_t *) malloc (sizeof (*wf));
-       if (wf == NULL)
-       {
-               ERROR ("plugin_register_write: malloc failed.");
-               return (-1);
-       }
-       memset (wf, 0, sizeof (*wf));
-
-       wf->callback = callback;
-       if (user_data == NULL)
-       {
-               wf->udata.data = NULL;
-               wf->udata.free_func = NULL;
-       }
-       else
-       {
-               wf->udata = *user_data;
-       }
-
-       return (register_callback (&list_write, name, (void *) wf));
+       return (create_register_callback (&list_write, name,
+                               (void *) callback, ud));
 } /* int plugin_register_write */
 
 int plugin_register_flush (const char *name,
-               plugin_flush_cb callback, user_data_t *user_data)
+               plugin_flush_cb callback, user_data_t *ud)
 {
-       flush_func_t *ff;
-
-       ff = (flush_func_t *) malloc (sizeof (*ff));
-       if (ff == NULL)
-       {
-               ERROR ("plugin_register_flush: malloc failed.");
-               return (-1);
-       }
-       memset (ff, 0, sizeof (*ff));
-
-       ff->callback = callback;
-       if (user_data == NULL)
-       {
-               ff->udata.data = NULL;
-               ff->udata.free_func = NULL;
-       }
-       else
-       {
-               ff->udata = *user_data;
-       }
-
-       return (register_callback (&list_flush, name, (void *) ff));
+       return (create_register_callback (&list_flush, name,
+                               (void *) callback, ud));
 } /* int plugin_register_flush */
 
 int plugin_register_shutdown (char *name,
                int (*callback) (void))
 {
-       return (register_callback (&list_shutdown, name, (void *) callback));
+       return (create_register_callback (&list_shutdown, name,
+                               (void *) callback, /* user_data = */ NULL));
 } /* int plugin_register_shutdown */
 
 int plugin_register_data_set (const data_set_t *ds)
@@ -656,36 +664,17 @@ int plugin_register_data_set (const data_set_t *ds)
 } /* int plugin_register_data_set */
 
 int plugin_register_log (const char *name,
-               plugin_log_cb callback, user_data_t *user_data)
+               plugin_log_cb callback, user_data_t *ud)
 {
-       log_func_t *lf;
-
-       lf = (log_func_t *) malloc (sizeof (*lf));
-       if (lf == NULL)
-       {
-               ERROR ("plugin_register_log: malloc failed.");
-               return (-1);
-       }
-       memset (lf, 0, sizeof (*lf));
-
-       lf->callback = callback;
-       if (user_data == NULL)
-       {
-               lf->udata.data = NULL;
-               lf->udata.free_func = NULL;
-       }
-       else
-       {
-               lf->udata = *user_data;
-       }
-
-       return (register_callback (&list_log, name, (void *) lf));
+       return (create_register_callback (&list_log, name,
+                               (void *) callback, ud));
 } /* int plugin_register_log */
 
 int plugin_register_notification (const char *name,
-               int (*callback) (const notification_t *notif))
+               plugin_notification_cb callback, user_data_t *ud)
 {
-       return (register_callback (&list_notification, name, (void *) callback));
+       return (create_register_callback (&list_notification, name,
+                               (void *) callback, ud));
 } /* int plugin_register_log */
 
 int plugin_unregister_config (const char *name)
@@ -707,68 +696,17 @@ int plugin_unregister_init (const char *name)
 
 int plugin_unregister_read (const char *name)
 {
-       llentry_t *e;
-       read_func_t *rf;
-
-       e = llist_search (list_read, name);
-
-       if (e == NULL)
-               return (-1);
-
-       llist_remove (list_read, e);
-
-       rf = (read_func_t *) e->value;
-       plugin_user_data_destroy (&rf->udata);
-       free (rf);
-       free (e->key);
-
-       llentry_destroy (e);
-
-       return (0);
+       return (plugin_unregister (list_read, name));
 }
 
 int plugin_unregister_write (const char *name)
 {
-       llentry_t *e;
-       write_func_t *wf;
-
-       e = llist_search (list_write, name);
-
-       if (e == NULL)
-               return (-1);
-
-       llist_remove (list_write, e);
-
-       wf = (write_func_t *) e->value;
-       plugin_user_data_destroy (&wf->udata);
-       free (wf);
-       free (e->key);
-
-       llentry_destroy (e);
-
-       return (0);
+       return (plugin_unregister (list_write, name));
 }
 
 int plugin_unregister_flush (const char *name)
 {
-       llentry_t *e;
-       flush_func_t *ff;
-
-       e = llist_search (list_flush, name);
-
-       if (e == NULL)
-               return (-1);
-
-       llist_remove (list_flush, e);
-
-       ff = (flush_func_t *) e->value;
-       plugin_user_data_destroy (&ff->udata);
-       free (ff);
-       free (e->key);
-
-       llentry_destroy (e);
-
-       return (0);
+       return (plugin_unregister (list_flush, name));
 }
 
 int plugin_unregister_shutdown (const char *name)
@@ -794,24 +732,7 @@ int plugin_unregister_data_set (const char *name)
 
 int plugin_unregister_log (const char *name)
 {
-       llentry_t *e;
-       log_func_t *lf;
-
-       e = llist_search (list_log, name);
-
-       if (e == NULL)
-               return (-1);
-
-       llist_remove (list_log, e);
-
-       lf = (log_func_t *) e->value;
-       plugin_user_data_destroy (&lf->udata);
-       free (lf);
-       free (e->key);
-
-       llentry_destroy (e);
-
-       return (0);
+       return (plugin_unregister (list_log, name));
 }
 
 int plugin_unregister_notification (const char *name)
@@ -822,7 +743,6 @@ int plugin_unregister_notification (const char *name)
 void plugin_init_all (void)
 {
        const char *chain_name;
-       int (*callback) (void);
        llentry_t *le;
        int status;
 
@@ -845,7 +765,11 @@ void plugin_init_all (void)
        le = llist_head (list_init);
        while (le != NULL)
        {
-               callback = (int (*) (void)) le->value;
+               callback_func_t *cf;
+               plugin_init_cb callback;
+
+               cf = le->value;
+               callback = cf->cf_callback;
                status = (*callback) ();
 
                if (status != 0)
@@ -893,18 +817,18 @@ void plugin_read_all (void)
        {
                rf = (read_func_t *) le->value;
 
-               if (rf->needs_read != DONE)
+               if (rf->rf_needs_read != DONE)
                {
                        le = le->next;
                        continue;
                }
 
-               if (rf->wait_left > 0)
-                       rf->wait_left -= interval_g;
+               if (rf->rf_wait_left > 0)
+                       rf->rf_wait_left -= interval_g;
 
-               if (rf->wait_left <= 0)
+               if (rf->rf_wait_left <= 0)
                {
-                       rf->needs_read = TODO;
+                       rf->rf_needs_read = TODO;
                }
 
                le = le->next;
@@ -935,14 +859,19 @@ int plugin_read_all_once (void)
        {
                rf = (read_func_t *) le->value;
 
-               if (rf->type == RF_SIMPLE)
+               if (rf->rf_type == RF_SIMPLE)
                {
-                       status = rf->callback.cb_simple ();
+                       int (*callback) (void);
+
+                       callback = rf->rf_callback;
+                       status = (*callback) ();
                }
                else
                {
-                       assert (rf->type == RF_COMPLEX);
-                       status = rf->callback.cb_complex (&rf->udata);
+                       plugin_read_cb callback;
+
+                       callback = rf->rf_callback;
+                       status = (*callback) (&rf->rf_udata);
                }
 
                if (status != 0)
@@ -986,10 +915,12 @@ int plugin_write (const char *plugin, /* {{{ */
     le = llist_head (list_write);
     while (le != NULL)
     {
-      write_func_t *wf = le->value;
+      callback_func_t *cf = le->value;
+      plugin_write_cb callback;
 
       DEBUG ("plugin: plugin_write: Writing values via %s.", le->key);
-      status = wf->callback (ds, vl, &wf->udata);
+      callback = cf->cf_callback;
+      status = (*callback) (ds, vl, &cf->cf_udata);
       if (status != 0)
         failure++;
       else
@@ -1005,7 +936,9 @@ int plugin_write (const char *plugin, /* {{{ */
   }
   else /* plugin != NULL */
   {
-    write_func_t *wf;
+    callback_func_t *cf;
+    plugin_write_cb callback;
+
     le = llist_head (list_write);
     while (le != NULL)
     {
@@ -1018,10 +951,11 @@ int plugin_write (const char *plugin, /* {{{ */
     if (le == NULL)
       return (ENOENT);
 
-    wf = le->value;
+    cf = le->value;
 
     DEBUG ("plugin: plugin_write: Writing values via %s.", le->key);
-    status = wf->callback (ds, vl, &wf->udata);
+    callback = cf->cf_callback;
+    status = (*callback) (ds, vl, &cf->cf_udata);
   }
 
   return (status);
@@ -1037,7 +971,8 @@ int plugin_flush (const char *plugin, int timeout, const char *identifier)
   le = llist_head (list_flush);
   while (le != NULL)
   {
-    flush_func_t *ff;
+    callback_func_t *cf;
+    plugin_flush_cb callback;
 
     if ((plugin != NULL)
         && (strcmp (plugin, le->key) != 0))
@@ -1046,9 +981,10 @@ int plugin_flush (const char *plugin, int timeout, const char *identifier)
       continue;
     }
 
-    ff = (flush_func_t *) le->value;
+    cf = le->value;
+    callback = cf->cf_callback;
 
-    ff->callback (timeout, identifier, &ff->udata);
+    (*callback) (timeout, identifier, &cf->cf_udata);
 
     le = le->next;
   }
@@ -1057,19 +993,27 @@ int plugin_flush (const char *plugin, int timeout, const char *identifier)
 
 void plugin_shutdown_all (void)
 {
-       int (*callback) (void);
        llentry_t *le;
 
        stop_read_threads ();
-       remove_read_functions ();
 
-       if (list_shutdown == NULL)
-               return;
+       destroy_all_callbacks (&list_init);
+       destroy_all_callbacks (&list_read);
+
+       plugin_flush (/* plugin = */ NULL, /* timeout = */ -1,
+                       /* identifier = */ NULL);
+
+       le = NULL;
+       if (list_shutdown != NULL)
+               le = llist_head (list_shutdown);
 
-       le = llist_head (list_shutdown);
        while (le != NULL)
        {
-               callback = (int (*) (void)) le->value;
+               callback_func_t *cf;
+               plugin_shutdown_cb callback;
+
+               cf = le->value;
+               callback = cf->cf_callback;
 
                /* Advance the pointer before calling the callback allows
                 * shutdown functions to unregister themselves. If done the
@@ -1079,6 +1023,12 @@ void plugin_shutdown_all (void)
 
                (*callback) ();
        }
+
+       destroy_all_callbacks (&list_write);
+       destroy_all_callbacks (&list_flush);
+       destroy_all_callbacks (&list_notification);
+       destroy_all_callbacks (&list_shutdown);
+       destroy_all_callbacks (&list_log);
 } /* void plugin_shutdown_all */
 
 int plugin_dispatch_values (value_list_t *vl)
@@ -1235,11 +1185,13 @@ void plugin_log (int level, const char *format, ...)
        le = llist_head (list_log);
        while (le != NULL)
        {
-               log_func_t *lf;
+               callback_func_t *cf;
+               plugin_log_cb callback;
 
-               lf = (log_func_t *) le->value;
+               cf = le->value;
+               callback = cf->cf_callback;
 
-               lf->callback (level, msg, &lf->udata);
+               (*callback) (level, msg, &cf->cf_udata);
 
                le = le->next;
        }
@@ -1432,3 +1384,5 @@ int plugin_notification_meta_free (notification_meta_t *n)
 
   return (0);
 } /* int plugin_notification_meta_free */
+
+/* vim: set sw=8 ts=8 noet fdm=marker : */

diff --git a/src/plugin.h b/src/plugin.h
index b4e5cb37744042143905e000912c31cd3d930988..bc4b07c2258f01b0eb9f4fcef591d9eafe774a78 100644 (file)
--- a/src/plugin.h
+++ b/src/plugin.h
@@ -146,6 +146,7 @@ typedef struct user_data_s user_data_t;
 /*
  * Callback types
  */
+typedef int (*plugin_init_cb) (void);
 typedef int (*plugin_read_cb) (user_data_t *);
 typedef int (*plugin_write_cb) (const data_set_t *, const value_list_t *,
                user_data_t *);
@@ -153,6 +154,9 @@ typedef int (*plugin_flush_cb) (int timeout, const char *identifier,
                user_data_t *);
 typedef void (*plugin_log_cb) (int severity, const char *message,
                user_data_t *);
+typedef int (*plugin_shutdown_cb) (void);
+typedef int (*plugin_notification_cb) (const notification_t *,
+               user_data_t *);
 
 /*
  * NAME
@@ -240,7 +244,7 @@ int plugin_register_config (const char *name,
 int plugin_register_complex_config (const char *type,
                int (*callback) (oconfig_item_t *));
 int plugin_register_init (const char *name,
-               int (*callback) (void));
+               plugin_init_cb callback);
 int plugin_register_read (const char *name,
                int (*callback) (void));
 int plugin_register_complex_read (const char *name,
@@ -250,12 +254,12 @@ int plugin_register_write (const char *name,
 int plugin_register_flush (const char *name,
                plugin_flush_cb callback, user_data_t *user_data);
 int plugin_register_shutdown (char *name,
-               int (*callback) (void));
+               plugin_shutdown_cb callback);
 int plugin_register_data_set (const data_set_t *ds);
 int plugin_register_log (const char *name,
                plugin_log_cb callback, user_data_t *user_data);
 int plugin_register_notification (const char *name,
-               int (*callback) (const notification_t *notif));
+               plugin_notification_cb callback, user_data_t *user_data);
 
 int plugin_unregister_config (const char *name);
 int plugin_unregister_complex_config (const char *name);