diff options
Diffstat (limited to 'plugin_dbus.c')
| -rw-r--r-- | plugin_dbus.c | 857 |
1 files changed, 857 insertions, 0 deletions
diff --git a/plugin_dbus.c b/plugin_dbus.c new file mode 100644 index 0000000..0647e1c --- /dev/null +++ b/plugin_dbus.c @@ -0,0 +1,857 @@ +/* $Id: plugin_dbus.c -1 $ + * $URL: https://ssl.bulix.org/svn/lcd4linux/trunk/plugin_dbus.c $ + * + * plugin template + * + * Copyright (C) 2009 Edward Martin <edman007@edman007.com> + * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net> + * + * This file is part of LCD4Linux. + * + * LCD4Linux is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * LCD4Linux is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + */ + +/* + * exported functions: + * + * int plugin_init_dbus (void) + * adds various functions + * + */ + + +/* define the include files you need */ +#include "config.h" + +#include <stdlib.h> +#include <stdint.h> +#include <string.h> +#include <ctype.h> +#include <unistd.h> + +/* these should always be included */ +#include "debug.h" +#include "plugin.h" +#include "cfg.h" +#include "timer.h" + +#ifdef WITH_DMALLOC +#include <dmalloc.h> +#endif + +#include "event.h" +#include <dbus/dbus.h> +#include <stdio.h> +#include <assert.h> +/* + * Internal Text Storage (to catch the events) + */ + +//a buffer of the most recent results (store the strings you see on the screen) +typedef struct { + int argc; + char **arguments; +} dbus_signal_t; + +static struct { + int signals; + dbus_signal_t *a; +} dbus_results = { +0, NULL}; + +//free all resources for the text of a signal +static int clear_signal_txt(const int sig); + +//return a pointer to the struct of text for the signal +static dbus_signal_t *get_signal_txt(const int sig); + +//set the struct of text for the signal +static int set_signal_txt(const int sig, const dbus_signal_t * data); + + +/* + * DBus Functions/types + */ + + +//the max that a message may be in characters (if you have a screen that fits more go crazy) +static const int LCD_MAX_MSG_LEN = 255; +#define DBUS_MAX_SIGNALS 64 +static const char *DBUS_PLUGIN_SECTION = "Plugin:DBus"; + + + +/* + * This connects to dbus and gets relavant things for the LCD + */ + +typedef struct lcd_sig_t lcd_sig_t; +//do not look inside, its private! +struct lcd_sig_t { + void *user_data; + void (*callback) (void *user_data, int argc, char **argv); + void (*user_free) (void *); + char *sender; + char *path; + char *interface; + char *member; + char *rule; +}; + + +typedef struct { + int id; + char *event_name; +} handle_signal_t; + +static DBusConnection *sessconn; +static DBusConnection *sysconn; +static DBusError err; + +static lcd_sig_t *lcd_registered_signals[DBUS_MAX_SIGNALS]; //used mostly for freeing resources +static int registered_sig_count = 0; + +//takes the signal, matches it against a rule, and sends the correct agrument, as a string, to the screen +static DBusHandlerResult lcd_sig_received(DBusConnection * connection, DBusMessage * message, void *sigv); + +//frees all resources for a signal (use lcd_unregister_signal instead) +static void free_signal(lcd_sig_t * sig); +//unregisters a signal and frees its resources +static void lcd_unregister_signal(lcd_sig_t * sig); + +//these copy data in/out of dbus +static void fill_args(DBusMessage * message, int *argcount, char ***argv); +static void free_args(int argc, char **argv); + +//returns 0 on error (no connection opened) +// 1 when only the system connection was opened +// 2 when only the session connection was opened +// 3 both connections were opened +static int lcd_dbus_init(void); + +static void handle_inbound_signal(void *signal, int argc, char **argv); +static void free_handle_signal(handle_signal_t * sig); + +//given a signal, will add a hook so when the signal appears your callback is called +static lcd_sig_t *lcd_register_signal(const char *sender, const char *path, + const char *interface, const char *member, + void (*callback) (void *user_data, int argc, char **argv), void *user_data, + void (*user_free) (void *)); + +static void setup_dbus_events(DBusConnection * conn); + +//to handle watches through the main loop +static dbus_bool_t add_watch(DBusWatch * w, void *data); +static void remove_watch(DBusWatch * w, void *data); +static void toggle_watch(DBusWatch * w, void *data); +static void watch_handle(event_flags_t f, void *data); + +static void dispatch_dbus(void); //tell dbus to read something + + +//to handle timers through the main loop +static void timeout_dbus_handle(void *data); +static dbus_bool_t add_dbus_timeout(DBusTimeout * t, void *data); +static void remove_dbus_timeout(DBusTimeout * t, void *data); +static void toggle_dbus_timeout(DBusTimeout * t, void *data); + +static lcd_sig_t *create_signal(const char *sender, const char *path, + const char *interface, const char *member, + void (*callback) (void *user_data, int argc, char **argv), void *user_data, + void (*user_free) (void *)); + +static int clear_signal_txt(const int sig) +{ + dbus_signal_t *s = get_signal_txt(sig); + if (s == NULL) { + return 1; + } + int i; + if (s->arguments != NULL) { + for (i = 0; i < s->argc; i++) { + if (s->arguments[i] != NULL) { + free(s->arguments[i]); + } + } + free(s->arguments); + s->arguments = NULL; + } + s->argc = 0; + return 0; +} + +static dbus_signal_t *get_signal_txt(const int sig) +{ + if (sig < 0 || sig >= dbus_results.signals) { + return NULL; + } + return &dbus_results.a[sig]; +} + +//sets a signal struct for the given data +static int set_signal_txt(const int sig, const dbus_signal_t * data) +{ + if (sig < 0 || sig >= dbus_results.signals) { + int new_sigs = sig + 1; + //allocate it + dbus_results.a = realloc(dbus_results.a, sizeof(dbus_signal_t) * new_sigs); + int i; + //clear anything just allocated that we are not writing to right now + for (i = dbus_results.signals; i < new_sigs; i++) { + dbus_results.a[i].argc = 0; + dbus_results.a[i].arguments = NULL; + } + dbus_results.signals = new_sigs; + } + //free the old version + if (dbus_results.a[sig].argc != 0) { + clear_signal_txt(sig); + } + dbus_results.a[sig].argc = data->argc; + //need to dup the strings + dbus_results.a[sig].arguments = malloc(sizeof(data->arguments) * data->argc); + int i; + for (i = 0; i < data->argc; i++) { + dbus_results.a[sig].arguments[i] = strdup(data->arguments[i]); + } + return 0; +} + + + +/* + * lcd4linux interface fucntions + */ + + +static void get_argument(RESULT * result, RESULT * sig, RESULT * arg) +{ + int signal = (int) R2N(sig); + int argument = (int) R2N(arg); + + dbus_signal_t *signal_value = get_signal_txt(signal); + char *value = ""; + if (signal_value != NULL && signal_value->argc > argument && signal_value->arguments[argument] != NULL) { + value = signal_value->arguments[argument]; + + } + + /* store result */ + SetResult(&result, R_STRING, value); + +} + +static void clear_arguments(RESULT * result, RESULT * sig) +{ + int signal = (int) R2N(sig); + dbus_signal_t *signal_value = get_signal_txt(signal); + int i; + if (signal_value->arguments != NULL) { + for (i = 0; i < signal_value->argc; i++) { + if (signal_value->arguments[i] != NULL) { + free(signal_value->arguments[i]); + } + } + free(signal_value->arguments); + signal_value->arguments = NULL; + } + signal_value->argc = 0; + + /* store result */ + SetResult(&result, R_STRING, ""); +} + +static void load_dbus_cfg(void) +{ + char *sender, *path, *interface, *member, *eventname; + int i; + const char *sender_fmt = "signal%dsender"; + const char *path_fmt = "signal%dpath"; + const char *interface_fmt = "signal%dinterface"; + const char *member_fmt = "signal%dmember"; + const char *eventname_fmt = "signal%deventname"; + const int max_cfg_len = 32; + char cfg_name[max_cfg_len]; + for (i = 0; i < DBUS_MAX_SIGNALS; i++) { + snprintf(cfg_name, max_cfg_len - 1, sender_fmt, i); + sender = cfg_get(DBUS_PLUGIN_SECTION, cfg_name, ""); + + snprintf(cfg_name, max_cfg_len - 1, path_fmt, i); + path = cfg_get(DBUS_PLUGIN_SECTION, cfg_name, ""); + + snprintf(cfg_name, max_cfg_len - 1, interface_fmt, i); + interface = cfg_get(DBUS_PLUGIN_SECTION, cfg_name, ""); + + snprintf(cfg_name, max_cfg_len - 1, member_fmt, i); + member = cfg_get(DBUS_PLUGIN_SECTION, cfg_name, ""); + + snprintf(cfg_name, max_cfg_len - 1, eventname_fmt, i); + eventname = cfg_get(DBUS_PLUGIN_SECTION, cfg_name, ""); + + if (*path == '\0' && *interface == '\0' && *member == '\0') { + goto cleanup; + } else if (*path == '\0' || *interface == '\0' || *member == '\0') { + error("[DBus] Incomplete configuration specified for signal%d", i); + goto cleanup; + } + + handle_signal_t *sig_info = malloc(sizeof(handle_signal_t)); + sig_info->id = i; + if (*eventname == '\0') { + sig_info->event_name = NULL; + } else { + sig_info->event_name = strdup(eventname); + } + + if (!lcd_register_signal(sender, path, interface, member, handle_inbound_signal, + sig_info, (void (*)(void *)) free_handle_signal)) { + error("[DBus] Error Registering signal %d", i); + } + cleanup: + free(sender); + free(path); + free(interface); + free(member); + free(eventname); + } +} + + +static void free_handle_signal(handle_signal_t * sig) +{ + if (sig->event_name != NULL) { + free(sig->event_name); + } + free(sig); +} + +/* plugin initialization */ +int plugin_init_dbus(void) +{ + if (!lcd_dbus_init()) { + error("[DBus] Could not connect to DBus"); + return 1; + } + //dbus::argument(<DisplaySignal>, <Argument#>)//displays arg# for signal# + AddFunction("dbus::argument", 2, get_argument); + //dbus::clear(<signal>)//sets the arguments for signal# + AddFunction("dbus::clear", 1, clear_arguments); + + //read out config + load_dbus_cfg(); + return 0; +} + +void plugin_exit_dbus(void) +{ + int i; + //remove all known signals + for (i = registered_sig_count - 1; i >= 0; i--) { + lcd_unregister_signal(lcd_registered_signals[i]); + } + if (sysconn != NULL) { + dbus_connection_unref(sysconn); + } + if (sessconn != NULL) { + dbus_connection_unref(sessconn); + } + //remove all knows signal results + for (i = dbus_results.signals - 1; i >= 0; i--) { + clear_signal_txt(i); + } + +#ifdef DEBUG + //needs to be called to actually free everything, but might free stuff + //mpris_dbus uses and cause a crash on shutdown, enable for leak debugging + dbus_shutdown(); +#endif +} + + +/* + * From here one out it is all dbus specific funtions, + * should probably be split into a seperate file, but i + * keept it here to make the plugin a single file + * + */ + +//watch functions +static dbus_bool_t add_watch(DBusWatch * w, void *data) +{ + (void) data; //ignore it +#if (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR == 1 && DBUS_VERSION_MICRO >= 1) || (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR > 1) || (DBUS_VERSION_MAJOR > 1) + int fd = dbus_watch_get_unix_fd(w); +#else + int fd = dbus_watch_get_fd(w); +#endif + // int fd = dbus_watch_get_unix_fd(w); //we assume we are using unix + int flags = dbus_watch_get_flags(w); + event_add(watch_handle, w, fd, flags & DBUS_WATCH_READABLE, flags & DBUS_WATCH_WRITABLE, dbus_watch_get_enabled(w)); + return TRUE; +} + +static void remove_watch(DBusWatch * w, void *data) +{ + (void) data; //ignore it +#if (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR == 1 && DBUS_VERSION_MICRO >= 1) || (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR > 1) || (DBUS_VERSION_MAJOR > 1) + event_del(dbus_watch_get_unix_fd(w)); +#else + event_del(dbus_watch_get_fd(w)); +#endif + // event_del(dbus_watch_get_unix_fd(w)); +} + +static void toggle_watch(DBusWatch * w, void *data) +{ + (void) data; +#if (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR == 1 && DBUS_VERSION_MICRO >= 1) || (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR > 1) || (DBUS_VERSION_MAJOR > 1) + int fd = dbus_watch_get_unix_fd(w); +#else + int fd = dbus_watch_get_fd(w); +#endif + // int fd = dbus_watch_get_unix_fd(w); //we assume we are using unix + int flags = dbus_watch_get_flags(w); + event_modify(fd, flags & DBUS_WATCH_READABLE, flags & DBUS_WATCH_WRITABLE, dbus_watch_get_enabled(w)); +} + +static void watch_handle(event_flags_t f, void *data) +{ + DBusWatch *w = (DBusWatch *) data; + + //convert the flags + unsigned int flags = 0; + + flags |= (f & EVENT_READ) ? DBUS_WATCH_READABLE : 0; + flags |= (f & EVENT_WRITE) ? DBUS_WATCH_WRITABLE : 0; + flags |= (f & EVENT_HUP) ? DBUS_WATCH_HANGUP : 0; + flags |= (f & EVENT_ERR) ? DBUS_WATCH_ERROR : 0; + + //tell dbus + if (!dbus_watch_handle(w, flags)) { + info("[DBus] dbus_watch_handle(): Not enough memory!"); + } + dispatch_dbus(); +} + +static void dispatch_dbus(void) +{ + if (sessconn != NULL && dbus_connection_get_dispatch_status(sessconn) == DBUS_DISPATCH_DATA_REMAINS) { + while (DBUS_DISPATCH_DATA_REMAINS == dbus_connection_dispatch(sessconn)); + } + if (sysconn != NULL && dbus_connection_get_dispatch_status(sysconn) == DBUS_DISPATCH_DATA_REMAINS) { + while (DBUS_DISPATCH_DATA_REMAINS == dbus_connection_dispatch(sysconn)); + } +} + +static void timeout_dbus_handle(void *data) +{ + DBusTimeout *t = (DBusTimeout *) data; + if (!dbus_timeout_handle(t)) { + info("[DBus] Not enough memory to handle timeout!"); + } + dispatch_dbus(); +} + +static dbus_bool_t add_dbus_timeout(DBusTimeout * t, void *data) +{ + (void) data; //ignore warning + if (!timer_add_late(timeout_dbus_handle, t, dbus_timeout_get_interval(t), 0)) { + return FALSE; + } + return TRUE; +} + + +static void remove_dbus_timeout(DBusTimeout * t, void *data) +{ + (void) data; //ignore warning + timer_remove(timeout_dbus_handle, t); +} + +static void toggle_dbus_timeout(DBusTimeout * t, void *data) +{ + remove_dbus_timeout(t, data); + add_dbus_timeout(t, data); +} + +//add the proper events/callbacks so we get notified about out messages +static void setup_dbus_events(DBusConnection * conn) +{ + if (!dbus_connection_set_watch_functions(conn, add_watch, remove_watch, toggle_watch, NULL, NULL)) { + error("[DBus] dbus_connection_set_watch_functions(): Not enough memory!"); + } + if (!dbus_connection_set_timeout_functions + (conn, add_dbus_timeout, remove_dbus_timeout, toggle_dbus_timeout, NULL, NULL)) { + error("[DBus] dbus_connection_set_timeout_functions(): Not enough memory!"); + } +} + +static int lcd_dbus_init(void) +{ + + int success = 3; + dbus_error_init(&err); //dbus_error_free(&err); + sessconn = dbus_bus_get(DBUS_BUS_SESSION, &err); + if (sessconn == NULL) { + info("[DBus] Error connecting to the dbus session bus: %s\n", err.message); + dbus_error_free(&err); + success &= 1; + } else { +#ifdef DEBUG + dbus_connection_set_exit_on_disconnect(sessconn, FALSE); +#endif + setup_dbus_events(sessconn); + } + + sysconn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + if (sysconn == NULL) { + info("[DBus] Error connecting to the dbus system bus: %s\n", err.message); + success &= 2; + } else { +#ifdef DEBUG + dbus_connection_set_exit_on_disconnect(sysconn, FALSE); +#endif + setup_dbus_events(sysconn); + } + + return success; +} + +static lcd_sig_t *create_signal(const char *sender, const char *path, + const char *interface, const char *member, + void (*callback) (void *user_data, int argc, char **argv), void *user_data, + void (*user_free) (void *)) +{ + lcd_sig_t *sig = malloc(sizeof(lcd_sig_t)); + sig->callback = callback; + sig->user_data = user_data; + sig->user_free = user_free; + sig->sender = malloc(sizeof(char) * (1 + strlen(sender))); + strcpy(sig->sender, sender); + sig->path = malloc(sizeof(char) * (1 + strlen(path))); + strcpy(sig->path, path); + sig->interface = malloc(sizeof(char) * (1 + strlen(interface))); + strcpy(sig->interface, interface); + sig->member = malloc(sizeof(char) * (1 + strlen(member))); + strcpy(sig->member, member); + + size_t len = strlen(sender) + strlen(path) + strlen(interface) + strlen(member); + char *format; + if (strlen(sig->sender) == 0) { + format = "type='signal',path='%s',interface='%s',member='%s'"; + } else { + format = "type='signal',sender='%s',path='%s',interface='%s',member='%s'"; + } + len += strlen(format); + len *= sizeof(char); + sig->rule = malloc(len); + if (strlen(sig->sender) == 0) { + sprintf(sig->rule, format, path, interface, member); + } else { + sprintf(sig->rule, format, sender, path, interface, member); + } + assert(strlen(sig->rule) < len); + return sig; +} + +static void handle_inbound_signal(void *signal, int argc, char **argv) +{ + handle_signal_t *signal_info = (handle_signal_t *) signal; + dbus_signal_t sig; + sig.argc = argc; + sig.arguments = argv; + set_signal_txt(signal_info->id, &sig); + + if (signal_info->event_name != NULL) { + named_event_trigger(signal_info->event_name); + } +} + +static lcd_sig_t *lcd_register_signal(const char *sender, const char *path, + const char *interface, const char *member, + void (*callback) (void *user_data, int argc, char **argv), void *user_data, + void (*user_free) (void *)) +{ + if (__builtin_expect(registered_sig_count >= DBUS_MAX_SIGNALS, 0)) { //gcc >= 2.96 + //i don't think anything will allow this to ever be hit..in fact It's impossible in the form i wrote the plugin + error + ("[DBus] Attempted to add more than %d dus signals, if you actually need more than that edit DBUS_MAX_SIGNALS in plugin_dbus.c", + DBUS_MAX_SIGNALS); + return NULL; + } + //store everything we need in the singal struct + lcd_sig_t *sig = create_signal(sender, path, interface, member, callback, user_data, user_free); + int success = 3; + if (sessconn != NULL) { + dbus_bus_add_match(sessconn, sig->rule, &err); + if (dbus_error_is_set(&err)) { + info("[DBus] Error adding dbus match to the session bus: %s \n", err.message); + dbus_error_free(&err); + success ^= 1; + } + + + if (!dbus_connection_add_filter(sessconn, lcd_sig_received, sig, NULL) && (success & 1)) { + info("[DBus] Dbus signal registration failed to the session bus!\n"); + dbus_bus_remove_match(sessconn, sig->rule, &err); + success ^= 1; + } + } else { + success ^= 1; + } + if (sysconn != NULL) { + dbus_bus_add_match(sysconn, sig->rule, &err); + if (dbus_error_is_set(&err)) { + info("[DBus] Error adding dbus match to the system bus: %s \n", err.message); + success ^= 2; + } + + if (!dbus_connection_add_filter(sysconn, lcd_sig_received, sig, NULL) && (success & 2)) { + info("[DBus] Dbus signal registration failed to the system bus!\n"); + dbus_bus_remove_match(sysconn, sig->rule, &err); + success ^= 2; + } + } else { + success ^= 2; + } + if (!success) { + free_signal(sig); + return NULL; + } + + lcd_registered_signals[registered_sig_count] = sig; + registered_sig_count++; + return sig; +} + +static void free_signal(lcd_sig_t * sig) +{ + if (sig->user_free != NULL) { + sig->user_free(sig->user_data); + } + free(sig->sender); + free(sig->path); + free(sig->interface); + free(sig->member); + free(sig->rule); + free(sig); +} + +static void lcd_unregister_signal(lcd_sig_t * sig) +{ + if (sig == NULL) { + return; + } + //remove filter and match + if (sessconn != NULL) { + dbus_connection_remove_filter(sessconn, lcd_sig_received, sig); + dbus_bus_remove_match(sessconn, sig->rule, NULL); + } + if (sysconn != NULL) { + dbus_connection_remove_filter(sysconn, lcd_sig_received, sig); + dbus_bus_remove_match(sysconn, sig->rule, NULL); + } + //free user data + free_signal(sig); + + //drop it off the list + int i; + for (i = 0; i < registered_sig_count; i++) { + if (lcd_registered_signals[i] == sig) { + registered_sig_count--; + lcd_registered_signals[i] = lcd_registered_signals[registered_sig_count]; + break; + } + } +} + + +static void fill_args(DBusMessage * message, int *argcount, char ***argv) +{ + dbus_message_ref(message); + int argc = 0; + char **args = NULL; + + + DBusMessageIter iter; + int buf_size = 0; + dbus_message_iter_init(message, &iter); + int current_type; + + //iterate over all arguments, casting all primitaves to strings + while ((current_type = dbus_message_iter_get_arg_type(&iter)) != DBUS_TYPE_INVALID) { + assert(argc <= buf_size); + if (argc >= buf_size) { + buf_size = argc * 2; + if (buf_size == 0) { + buf_size = 1; + } + args = realloc(args, sizeof(char **) * buf_size); + } + if (dbus_type_is_basic(current_type)) { + args[argc] = malloc(sizeof(char) * (1 + LCD_MAX_MSG_LEN)); + args[argc][LCD_MAX_MSG_LEN] = '\0'; + //determine the type + switch (current_type) { + /* Primitive types */ + case DBUS_TYPE_BYTE: + { + char value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%hhx", value); + } + + break; + case DBUS_TYPE_BOOLEAN: + { + dbus_bool_t value; + dbus_message_iter_get_basic(&iter, &value); + if (value) { + strcpy(args[argc], "true"); + } else { + strcpy(args[argc], "false"); + } + + } + break; + case DBUS_TYPE_INT16: + { + dbus_int16_t value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%hd", value); + } + break; + case DBUS_TYPE_UINT16: + { + dbus_uint16_t value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%hu", value); + } + break; + case DBUS_TYPE_INT32: + { + dbus_int32_t value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%d", value); + } + break; + case DBUS_TYPE_UINT32: + { + dbus_uint32_t value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%u", value); + } + break; + case DBUS_TYPE_INT64: + { + dbus_int64_t value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%jd", (intmax_t) value); + } + break; + case DBUS_TYPE_UINT64: + { + dbus_uint64_t value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%ju", (uintmax_t) value); + } + break; + case DBUS_TYPE_DOUBLE: + { + double value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%f", value); + } + break; + case DBUS_TYPE_STRING: //all strings + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + { + char *value; + dbus_message_iter_get_basic(&iter, &value); + snprintf(args[argc], LCD_MAX_MSG_LEN, "%s", value); + } + break; + case DBUS_TYPE_INVALID: + default: + //not supported + free(args[argc]); + args[argc] = NULL; + assert(0); //should never ever happen... + + break; + } + } else { + args[argc] = NULL; + } + + argc++; + dbus_message_iter_next(&iter); + } + + + *argcount = argc; + *argv = args; + dbus_message_unref(message); +} + + +static DBusHandlerResult lcd_sig_received(DBusConnection * connection, DBusMessage * msg, void *sigv) +{ + (void) connection; + dbus_message_ref(msg); + lcd_sig_t *sig = sigv; + //compare the signal to the one we were assigned + if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) { + dbus_message_unref(msg); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + //we don't check the sender because we (probably) asked by name, not by sender + if (!dbus_message_has_member(msg, sig->member) || + !dbus_message_has_path(msg, sig->path) || !dbus_message_has_interface(msg, sig->interface)) { + dbus_message_unref(msg); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + //call the users function + if (sig->callback != NULL) { + char **args; + int argc; + fill_args(msg, &argc, &args); + sig->callback(sig->user_data, argc, args); + free_args(argc, args); + } + + dbus_message_unref(msg); + return DBUS_HANDLER_RESULT_HANDLED; +} + + + +static void free_args(int argc, char **argv) +{ + int i; + //free args + for (i = 0; i < argc; i++) { + if (argv[i] != NULL) { + free(argv[i]); + } + } + + if (argv != NULL && argc != 0) { + free(argv); + } + +} |