From 9c8848b1b4bc307b18eabc22f913313fecdd36af Mon Sep 17 00:00:00 2001 From: Florian Forster Date: Mon, 23 Feb 2009 14:50:03 +0100 Subject: [PATCH] src/plugin.c: Add a user_data_t pointer to notification callbacks. --- src/exec.c | 8 +- src/logfile.c | 6 +- src/network.c | 6 +- src/notify_desktop.c | 6 +- src/notify_email.c | 6 +- src/perl.c | 6 +- src/plugin.c | 530 +++++++++++++++++++++++---------------------------- src/plugin.h | 10 +- 8 files changed, 274 insertions(+), 304 deletions(-) diff --git a/src/exec.c b/src/exec.c index 973cd52b..cdcf6ade 100644 --- 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 26d805a4..8e98c047 100644 --- 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 0434b359..c9a92ac5 100644 --- 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 2e62e88c..839bc610 100644 --- 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 32bd9164..62e1c486 100644 --- 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 e6b7c460..96ba8024 100644 --- 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 41a816f8..4e35bf2b 100644 --- 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 b4e5cb37..bc4b07c2 100644 --- 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); -- 2.11.0