From bd3c21b0cc3d5829cf91c9c75dc6943bca63298a Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Thu, 8 May 2008 17:36:48 +0000 Subject: Add directory for libgdbus library --- gdbus/Makefile.am | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 gdbus/Makefile.am (limited to 'gdbus') diff --git a/gdbus/Makefile.am b/gdbus/Makefile.am new file mode 100644 index 00000000..02742923 --- /dev/null +++ b/gdbus/Makefile.am @@ -0,0 +1,2 @@ + +MAINTAINERCLEANFILES = Makefile.in -- cgit From 5442ba4d63b8f9548e140a47f63046c11819a972 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Thu, 8 May 2008 17:58:33 +0000 Subject: Add skeleton for libgdbus support --- gdbus/Makefile.am | 6 ++++++ gdbus/gdbus.h | 22 ++++++++++++++++++++++ gdbus/mainloop.c | 40 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 68 insertions(+) create mode 100644 gdbus/gdbus.h create mode 100644 gdbus/mainloop.c (limited to 'gdbus') diff --git a/gdbus/Makefile.am b/gdbus/Makefile.am index 02742923..0a481277 100644 --- a/gdbus/Makefile.am +++ b/gdbus/Makefile.am @@ -1,2 +1,8 @@ +noinst_LTLIBRARIES = libgdbus.la + +libgdbus_la_SOURCES = gdbus.h mainloop.c + +AM_CFLAGS = @DBUS_CFLAGS@ @GLIB_CFLAGS@ + MAINTAINERCLEANFILES = Makefile.in diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h new file mode 100644 index 00000000..71377516 --- /dev/null +++ b/gdbus/gdbus.h @@ -0,0 +1,22 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2008 Marcel Holtmann + * + * + * This program 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 of the License, or + * (at your option) any later version. + * + * This program 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ diff --git a/gdbus/mainloop.c b/gdbus/mainloop.c new file mode 100644 index 00000000..f08299f0 --- /dev/null +++ b/gdbus/mainloop.c @@ -0,0 +1,40 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2008 Marcel Holtmann + * + * + * This program 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 of the License, or + * (at your option) any later version. + * + * This program 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +#include + +#ifdef NEED_DBUS_WATCH_GET_UNIX_FD +#define dbus_watch_get_unix_fd dbus_watch_get_fd +#endif + +#ifdef HAVE_DBUS_GLIB +#include +#endif + +#include "gdbus.h" -- cgit From 33191e6275ab82aa4161cdf75b45597e4d1568ec Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Thu, 8 May 2008 19:12:44 +0000 Subject: Move D-Bus mainloop integration into libgdbus --- gdbus/gdbus.h | 21 +++++ gdbus/mainloop.c | 280 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 300 insertions(+), 1 deletion(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 71377516..d749d5e2 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -20,3 +20,24 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ + +#ifndef __GDBUS_H +#define __GDBUS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +void setup_dbus_with_main_loop(DBusConnection *conn); + +DBusConnection *dbus_bus_system_setup_with_main_loop(const char *name, + void (*disconnect_cb)(void *), void *user_data); + +#ifdef __cplusplus +} +#endif + +#endif /* __GDBUS_H */ diff --git a/gdbus/mainloop.c b/gdbus/mainloop.c index f08299f0..e8e7e0af 100644 --- a/gdbus/mainloop.c +++ b/gdbus/mainloop.c @@ -25,8 +25,9 @@ #include #endif -#include +#include +#include #include #ifdef NEED_DBUS_WATCH_GET_UNIX_FD @@ -38,3 +39,280 @@ #endif #include "gdbus.h" + +#define DISPATCH_TIMEOUT 0 + +#define info(fmt...) +#define error(fmt...) +#define debug(fmt...) + +#ifndef HAVE_DBUS_GLIB +typedef struct { + uint32_t id; + DBusTimeout *timeout; +} timeout_handler_t; + +struct watch_info { + guint watch_id; + GIOChannel *io; + DBusConnection *conn; +}; + +struct server_info { + guint watch_id; + GIOChannel *io; + DBusServer *server; +}; +#endif + +struct disconnect_data { + void (*disconnect_cb)(void *); + void *user_data; +}; + +static DBusHandlerResult disconnect_filter(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct disconnect_data *dc_data = data; + + if (dbus_message_is_signal(msg, + DBUS_INTERFACE_LOCAL, "Disconnected") == TRUE) { + error("Got disconnected from the system message bus"); + dbus_connection_unref(conn); + dc_data->disconnect_cb(dc_data->user_data); + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +#ifndef HAVE_DBUS_GLIB +static gboolean message_dispatch_cb(void *data) +{ + DBusConnection *connection = data; + + dbus_connection_ref(connection); + + /* Dispatch messages */ + while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS); + + dbus_connection_unref(connection); + + return FALSE; +} + +static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data) +{ + DBusWatch *watch = data; + struct watch_info *info = dbus_watch_get_data(watch); + int flags = 0; + + if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE; + if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE; + if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP; + if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR; + + dbus_watch_handle(watch, flags); + + if (dbus_connection_get_dispatch_status(info->conn) == DBUS_DISPATCH_DATA_REMAINS) + g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, info->conn); + + return TRUE; +} + +static dbus_bool_t add_watch(DBusWatch *watch, void *data) +{ + GIOCondition cond = G_IO_HUP | G_IO_ERR; + DBusConnection *conn = data; + struct watch_info *info; + int fd, flags; + + if (!dbus_watch_get_enabled(watch)) + return TRUE; + + info = g_new(struct watch_info, 1); + + fd = dbus_watch_get_unix_fd(watch); + info->io = g_io_channel_unix_new(fd); + info->conn = dbus_connection_ref(conn); + + dbus_watch_set_data(watch, info, NULL); + + flags = dbus_watch_get_flags(watch); + + if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN; + if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT; + + info->watch_id = g_io_add_watch(info->io, cond, watch_func, watch); + + return TRUE; +} + +static void remove_watch(DBusWatch *watch, void *data) +{ + struct watch_info *info = dbus_watch_get_data(watch); + + dbus_watch_set_data(watch, NULL, NULL); + + if (info) { + g_source_remove(info->watch_id); + g_io_channel_unref(info->io); + dbus_connection_unref(info->conn); + g_free(info); + } +} + +static void watch_toggled(DBusWatch *watch, void *data) +{ + /* Because we just exit on OOM, enable/disable is + * no different from add/remove */ + if (dbus_watch_get_enabled(watch)) + add_watch(watch, data); + else + remove_watch(watch, data); +} + +static gboolean timeout_handler_dispatch(gpointer data) +{ + timeout_handler_t *handler = data; + + /* if not enabled should not be polled by the main loop */ + if (dbus_timeout_get_enabled(handler->timeout) != TRUE) + return FALSE; + + dbus_timeout_handle(handler->timeout); + + return FALSE; +} + +static void timeout_handler_free(void *data) +{ + timeout_handler_t *handler = data; + if (!handler) + return; + + g_source_remove(handler->id); + g_free(handler); +} + +static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data) +{ + timeout_handler_t *handler; + + if (!dbus_timeout_get_enabled(timeout)) + return TRUE; + + handler = g_new0(timeout_handler_t, 1); + + handler->timeout = timeout; + handler->id = g_timeout_add(dbus_timeout_get_interval(timeout), + timeout_handler_dispatch, handler); + + dbus_timeout_set_data(timeout, handler, timeout_handler_free); + + return TRUE; +} + +static void remove_timeout(DBusTimeout *timeout, void *data) +{ +} + +static void timeout_toggled(DBusTimeout *timeout, void *data) +{ + if (dbus_timeout_get_enabled(timeout)) + add_timeout(timeout, data); + else + remove_timeout(timeout, data); +} + +static void dispatch_status_cb(DBusConnection *conn, + DBusDispatchStatus new_status, void *data) +{ + if (!dbus_connection_get_is_connected(conn)) + return; + + if (new_status == DBUS_DISPATCH_DATA_REMAINS) + g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, data); +} +#endif + +void setup_dbus_with_main_loop(DBusConnection *conn) +{ +#ifdef HAVE_DBUS_GLIB + debug("Using D-Bus GLib connection setup"); + + dbus_connection_setup_with_g_main(conn, NULL); +#else + dbus_connection_set_watch_functions(conn, add_watch, remove_watch, + watch_toggled, conn, NULL); + + dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout, + timeout_toggled, conn, NULL); + + dbus_connection_set_dispatch_status_function(conn, dispatch_status_cb, + conn, NULL); +#endif +} + +static DBusConnection *init_dbus(const char *name, + void (*disconnect_cb)(void *), void *user_data) +{ + struct disconnect_data *dc_data; + DBusConnection *conn; + DBusError err; + + dbus_error_init(&err); + + conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + + if (dbus_error_is_set(&err)) { + error("Can't connect to system message bus: %s", err.message); + dbus_error_free(&err); + return NULL; + } + + setup_dbus_with_main_loop(conn); + + if (name) { + dbus_error_init(&err); + + if (dbus_bus_request_name(conn, name, 0, &err) != + DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER ) { + error("Could not become the primary owner of %s", name); + dbus_connection_unref(conn); + return NULL; + } + + if (dbus_error_is_set(&err)) { + error("Can't get bus name %s: %s", name, err.message); + dbus_error_free(&err); + dbus_connection_unref(conn); + return NULL; + } + } + + if (!disconnect_cb) + return conn; + + dc_data = g_new(struct disconnect_data, 1); + + dc_data->disconnect_cb = disconnect_cb; + dc_data->user_data = user_data; + + dbus_connection_set_exit_on_disconnect(conn, FALSE); + + if (!dbus_connection_add_filter(conn, disconnect_filter, + dc_data, g_free)) { + error("Can't add D-Bus disconnect filter"); + g_free(dc_data); + dbus_connection_unref(conn); + return NULL; + } + + return conn; +} + +DBusConnection *dbus_bus_system_setup_with_main_loop(const char *name, + void (*disconnect_cb)(void *), void *user_data) +{ + return init_dbus(name, disconnect_cb, user_data); +} -- cgit From aa215d6fa551a3edbd129d4a163210e98357bdd1 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Thu, 8 May 2008 19:39:12 +0000 Subject: Emulate libgdbus API for mainloop integration --- gdbus/gdbus.h | 10 +++++--- gdbus/mainloop.c | 71 ++++++++++++++++++++++++++------------------------------ 2 files changed, 40 insertions(+), 41 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index d749d5e2..a9f2aa51 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -31,10 +31,14 @@ extern "C" { #include #include -void setup_dbus_with_main_loop(DBusConnection *conn); +typedef void (* GDBusDisconnectFunction) (void *user_data); -DBusConnection *dbus_bus_system_setup_with_main_loop(const char *name, - void (*disconnect_cb)(void *), void *user_data); +DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name, + DBusError *error); + +gboolean g_dbus_set_disconnect_function(DBusConnection *connection, + GDBusDisconnectFunction function, + void *user_data, DBusFreeFunction destroy); #ifdef __cplusplus } diff --git a/gdbus/mainloop.c b/gdbus/mainloop.c index e8e7e0af..a9b8237c 100644 --- a/gdbus/mainloop.c +++ b/gdbus/mainloop.c @@ -235,7 +235,7 @@ static void dispatch_status_cb(DBusConnection *conn, } #endif -void setup_dbus_with_main_loop(DBusConnection *conn) +static void setup_dbus_with_main_loop(DBusConnection *conn) { #ifdef HAVE_DBUS_GLIB debug("Using D-Bus GLib connection setup"); @@ -253,66 +253,61 @@ void setup_dbus_with_main_loop(DBusConnection *conn) #endif } -static DBusConnection *init_dbus(const char *name, - void (*disconnect_cb)(void *), void *user_data) +DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name, + DBusError *error) { - struct disconnect_data *dc_data; DBusConnection *conn; - DBusError err; - - dbus_error_init(&err); - conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + conn = dbus_bus_get(type, error); - if (dbus_error_is_set(&err)) { - error("Can't connect to system message bus: %s", err.message); - dbus_error_free(&err); - return NULL; + if (error != NULL) { + if (dbus_error_is_set(error) == TRUE) + return NULL; } - setup_dbus_with_main_loop(conn); - - if (name) { - dbus_error_init(&err); + if (conn == NULL) + return NULL; - if (dbus_bus_request_name(conn, name, 0, &err) != + if (name != NULL) { + if (dbus_bus_request_name(conn, name, + DBUS_NAME_FLAG_DO_NOT_QUEUE, error) != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER ) { - error("Could not become the primary owner of %s", name); dbus_connection_unref(conn); return NULL; } - if (dbus_error_is_set(&err)) { - error("Can't get bus name %s: %s", name, err.message); - dbus_error_free(&err); - dbus_connection_unref(conn); - return NULL; + if (error != NULL) { + if (dbus_error_is_set(error) == TRUE) { + dbus_connection_unref(conn); + return NULL; + } } } - if (!disconnect_cb) - return conn; + setup_dbus_with_main_loop(conn); + + return conn; +} + +gboolean g_dbus_set_disconnect_function(DBusConnection *connection, + GDBusDisconnectFunction function, + void *user_data, DBusFreeFunction destroy) +{ + struct disconnect_data *dc_data; dc_data = g_new(struct disconnect_data, 1); - dc_data->disconnect_cb = disconnect_cb; + dc_data->disconnect_cb = function; dc_data->user_data = user_data; - dbus_connection_set_exit_on_disconnect(conn, FALSE); + dbus_connection_set_exit_on_disconnect(connection, FALSE); - if (!dbus_connection_add_filter(conn, disconnect_filter, - dc_data, g_free)) { + if (dbus_connection_add_filter(connection, disconnect_filter, + dc_data, g_free) == FALSE) { error("Can't add D-Bus disconnect filter"); g_free(dc_data); - dbus_connection_unref(conn); - return NULL; + return FALSE; } - return conn; -} - -DBusConnection *dbus_bus_system_setup_with_main_loop(const char *name, - void (*disconnect_cb)(void *), void *user_data) -{ - return init_dbus(name, disconnect_cb, user_data); + return TRUE; } -- cgit From e7d668ac9e813bc9922ee7d771848bd8822d5d1f Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Thu, 8 May 2008 20:23:45 +0000 Subject: Move D-Bus watch functions into libgdbus --- gdbus/Makefile.am | 2 +- gdbus/gdbus.h | 9 ++ gdbus/watch.c | 380 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 390 insertions(+), 1 deletion(-) create mode 100644 gdbus/watch.c (limited to 'gdbus') diff --git a/gdbus/Makefile.am b/gdbus/Makefile.am index 0a481277..937b1d7f 100644 --- a/gdbus/Makefile.am +++ b/gdbus/Makefile.am @@ -1,7 +1,7 @@ noinst_LTLIBRARIES = libgdbus.la -libgdbus_la_SOURCES = gdbus.h mainloop.c +libgdbus_la_SOURCES = gdbus.h mainloop.c watch.c AM_CFLAGS = @DBUS_CFLAGS@ @GLIB_CFLAGS@ diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index a9f2aa51..d1902a52 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -40,6 +40,15 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, GDBusDisconnectFunction function, void *user_data, DBusFreeFunction destroy); +typedef void (*name_cb_t)(const char *name, void *user_data); + +guint name_listener_add(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data); +int name_listener_remove(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data); +gboolean name_listener_id_remove(guint id); +int name_listener_indicate_disconnect(DBusConnection *connection); + #ifdef __cplusplus } #endif diff --git a/gdbus/watch.c b/gdbus/watch.c new file mode 100644 index 00000000..80be3a6a --- /dev/null +++ b/gdbus/watch.c @@ -0,0 +1,380 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2008 Marcel Holtmann + * + * + * This program 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 of the License, or + * (at your option) any later version. + * + * This program 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include + +#include +#include + +#include "gdbus.h" + +#define info(fmt...) +#define error(fmt...) +#define debug(fmt...) + +static guint listener_id = 0; +static GSList *name_listeners = NULL; + +struct name_callback { + name_cb_t func; + void *user_data; + guint id; +}; + +struct name_data { + DBusConnection *connection; + char *name; + GSList *callbacks; +}; + +static struct name_data *name_data_find(DBusConnection *connection, + const char *name) +{ + GSList *current; + + for (current = name_listeners; + current != NULL; current = current->next) { + struct name_data *data = current->data; + + if (name == NULL && data->name == NULL) { + if (connection == data->connection) + return data; + } else { + if (strcmp(name, data->name) == 0) + return data; + } + } + + return NULL; +} + +static struct name_callback *name_callback_find(GSList *callbacks, + name_cb_t func, void *user_data) +{ + GSList *current; + + for (current = callbacks; current != NULL; current = current->next) { + struct name_callback *cb = current->data; + if (cb->func == func && cb->user_data == user_data) + return cb; + } + + return NULL; +} + +static void name_data_call_and_free(struct name_data *data) +{ + GSList *l; + + for (l = data->callbacks; l != NULL; l = l->next) { + struct name_callback *cb = l->data; + if (cb->func) + cb->func(data->name, cb->user_data); + g_free(cb); + } + + g_slist_free(data->callbacks); + g_free(data->name); + g_free(data); +} + +static void name_data_free(struct name_data *data) +{ + GSList *l; + + for (l = data->callbacks; l != NULL; l = l->next) + g_free(l->data); + + g_slist_free(data->callbacks); + g_free(data->name); + g_free(data); +} + +static int name_data_add(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data, guint id) +{ + int first = 1; + struct name_data *data = NULL; + struct name_callback *cb = NULL; + + cb = g_new(struct name_callback, 1); + + cb->func = func; + cb->user_data = user_data; + cb->id = id; + + data = name_data_find(connection, name); + if (data) { + first = 0; + goto done; + } + + data = g_new0(struct name_data, 1); + + data->connection = connection; + data->name = g_strdup(name); + + name_listeners = g_slist_append(name_listeners, data); + +done: + data->callbacks = g_slist_append(data->callbacks, cb); + return first; +} + +static void name_data_remove(DBusConnection *connection, + const char *name, name_cb_t func, void *user_data) +{ + struct name_data *data; + struct name_callback *cb = NULL; + + data = name_data_find(connection, name); + if (!data) + return; + + cb = name_callback_find(data->callbacks, func, user_data); + if (cb) { + data->callbacks = g_slist_remove(data->callbacks, cb); + g_free(cb); + } + + if (!data->callbacks) { + name_listeners = g_slist_remove(name_listeners, data); + name_data_free(data); + } +} + +static gboolean add_match(DBusConnection *connection, const char *name) +{ + DBusError err; + char match_string[128]; + + snprintf(match_string, sizeof(match_string), + "interface=%s,member=NameOwnerChanged,arg0=%s", + DBUS_INTERFACE_DBUS, name); + + dbus_error_init(&err); + + dbus_bus_add_match(connection, match_string, &err); + + if (dbus_error_is_set(&err)) { + error("Adding match rule \"%s\" failed: %s", match_string, + err.message); + dbus_error_free(&err); + return FALSE; + } + + return TRUE; +} + +static gboolean remove_match(DBusConnection *connection, const char *name) +{ + DBusError err; + char match_string[128]; + + snprintf(match_string, sizeof(match_string), + "interface=%s,member=NameOwnerChanged,arg0=%s", + DBUS_INTERFACE_DBUS, name); + + dbus_error_init(&err); + + dbus_bus_remove_match(connection, match_string, &err); + + if (dbus_error_is_set(&err)) { + error("Removing owner match rule for %s failed: %s", + name, err.message); + dbus_error_free(&err); + return FALSE; + } + + return TRUE; +} + +static DBusHandlerResult name_exit_filter(DBusConnection *connection, + DBusMessage *message, void *user_data) +{ + GSList *l; + struct name_data *data; + char *name, *old, *new; + + if (!dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, + "NameOwnerChanged")) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + if (!dbus_message_get_args(message, NULL, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_STRING, &old, + DBUS_TYPE_STRING, &new, + DBUS_TYPE_INVALID)) { + error("Invalid arguments for NameOwnerChanged signal"); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + /* We are not interested of service creations */ + if (*new != '\0') + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + data = name_data_find(connection, name); + if (!data) { + error("Got NameOwnerChanged signal for %s which has no listeners", name); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + for (l = data->callbacks; l != NULL; l = l->next) { + struct name_callback *cb = l->data; + cb->func(name, cb->user_data); + } + + name_listeners = g_slist_remove(name_listeners, data); + name_data_free(data); + + remove_match(connection, name); + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +guint name_listener_add(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data) +{ + int first; + + if (!listener_id) { + if (!dbus_connection_add_filter(connection, + name_exit_filter, NULL, NULL)) { + error("dbus_connection_add_filter() failed"); + return 0; + } + } + + listener_id++; + first = name_data_add(connection, name, func, user_data, listener_id); + /* The filter is already added if this is not the first callback + * registration for the name */ + if (!first) + return listener_id; + + if (name) { + debug("name_listener_add(%s)", name); + + if (!add_match(connection, name)) { + name_data_remove(connection, name, func, user_data); + return 0; + } + } + + return listener_id; +} + +int name_listener_remove(DBusConnection *connection, const char *name, + name_cb_t func, void *user_data) +{ + struct name_data *data; + struct name_callback *cb; + + data = name_data_find(connection, name); + if (!data) { + error("remove_name_listener: no listener for %s", name); + return -1; + } + + cb = name_callback_find(data->callbacks, func, user_data); + if (!cb) { + error("No matching callback found for %s", name); + return -1; + } + + data->callbacks = g_slist_remove(data->callbacks, cb); + g_free(cb); + + /* Don't remove the filter if other callbacks exist */ + if (data->callbacks) + return 0; + + if (name) { + debug("name_listener_remove(%s)", name); + + if (!remove_match(connection, name)) + return -1; + } + + name_data_remove(connection, name, func, user_data); + + return 0; +} + +gboolean name_listener_id_remove(guint id) +{ + struct name_data *data; + struct name_callback *cb; + GSList *ldata, *lcb; + + for (ldata = name_listeners; ldata; ldata = ldata->next) { + data = ldata->data; + for (lcb = data->callbacks; lcb; lcb = lcb->next) { + cb = lcb->data; + if (cb->id == id) + goto remove; + } + } + + return FALSE; + +remove: + data->callbacks = g_slist_remove(data->callbacks, cb); + g_free(cb); + + /* Don't remove the filter if other callbacks exist */ + if (data->callbacks) + return TRUE; + + if (data->name) { + if (!remove_match(data->connection, data->name)) + return FALSE; + } + + name_listeners = g_slist_remove(name_listeners, data); + name_data_free(data); + + return TRUE; +} + +int name_listener_indicate_disconnect(DBusConnection *connection) +{ + struct name_data *data; + + data = name_data_find(connection, NULL); + if (!data) { + error("name_listener_indicate_disconnect: no listener found"); + return -1; + } + + debug("name_listener_indicate_disconnect"); + + name_data_call_and_free(data); + + return 0; +} -- cgit From 15ea15b3a752f0487bc50d0ea04925f1b9d33dcb Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Thu, 8 May 2008 22:19:14 +0000 Subject: Move D-Bus object and interface helpers into libgdbus --- gdbus/Makefile.am | 2 +- gdbus/gdbus.h | 82 +++++++ gdbus/object.c | 660 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 743 insertions(+), 1 deletion(-) create mode 100644 gdbus/object.c (limited to 'gdbus') diff --git a/gdbus/Makefile.am b/gdbus/Makefile.am index 937b1d7f..9447555f 100644 --- a/gdbus/Makefile.am +++ b/gdbus/Makefile.am @@ -1,7 +1,7 @@ noinst_LTLIBRARIES = libgdbus.la -libgdbus_la_SOURCES = gdbus.h mainloop.c watch.c +libgdbus_la_SOURCES = gdbus.h mainloop.c object.c watch.c AM_CFLAGS = @DBUS_CFLAGS@ @GLIB_CFLAGS@ diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index d1902a52..d8382306 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -40,6 +40,88 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, GDBusDisconnectFunction function, void *user_data, DBusFreeFunction destroy); +#define DBUS_TYPE_STRING_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING) +#define DBUS_TYPE_BYTE_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING) + +DBusHandlerResult dbus_connection_send_and_unref(DBusConnection *connection, + DBusMessage *message); + +dbus_bool_t dbus_connection_create_object_path(DBusConnection *connection, + const char *path, void *user_data, + DBusObjectPathUnregisterFunction function); + +dbus_bool_t dbus_connection_destroy_object_path(DBusConnection *connection, + const char *path); + +dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, + const char *path, + void **data_p); + +typedef struct DBusMethodVTable DBusMethodVTable; + +struct DBusMethodVTable { + const char *name; + DBusObjectPathMessageFunction message_function; + const char *signature; + const char *reply; +}; + +typedef struct DBusSignalVTable DBusSignalVTable; + +struct DBusSignalVTable { + const char *name; + const char *signature; +}; + +typedef struct DBusPropertyVTable DBusPropertyVTable; + +struct DBusPropertyVTable { + const char *name; +}; + +dbus_bool_t dbus_connection_register_interface(DBusConnection *connection, + const char *path, const char *name, + DBusMethodVTable *methods, + DBusSignalVTable *signals, + DBusPropertyVTable *properties); + +dbus_bool_t dbus_connection_unregister_interface(DBusConnection *connection, + const char *path, const char *name); +void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val); +void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, + const char *key, int type, void *val); +void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, + const char *first_key, + va_list var_args); +void dbus_message_iter_append_dict(DBusMessageIter *iter, + const char *first_key, ...); +dbus_bool_t dbus_connection_emit_signal(DBusConnection *conn, const char *path, + const char *interface, const char *name, + int first, ...); + +dbus_bool_t dbus_connection_emit_signal_valist(DBusConnection *conn, + const char *path, + const char *interface, + const char *name, + int first, + va_list var_args); +dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, + const char *path, + const char *interface, + const char *name, + int type, void *value); + +static inline DBusHandlerResult send_message_and_unref(DBusConnection *conn, + DBusMessage *msg) +{ + if (msg) { + dbus_connection_send(conn, msg, NULL); + dbus_message_unref(msg); + } + + return DBUS_HANDLER_RESULT_HANDLED; +} + typedef void (*name_cb_t)(const char *name, void *user_data); guint name_listener_add(DBusConnection *connection, const char *name, diff --git a/gdbus/object.c b/gdbus/object.c new file mode 100644 index 00000000..12ba66a9 --- /dev/null +++ b/gdbus/object.c @@ -0,0 +1,660 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2008 Marcel Holtmann + * + * + * This program 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 of the License, or + * (at your option) any later version. + * + * This program 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include + +#include +#include + +#include "gdbus.h" + +#define info(fmt...) +#define error(fmt...) +#define debug(fmt...) + +struct generic_data { + void *user_data; + DBusObjectPathUnregisterFunction unregister_function; + GSList *interfaces; + char *introspect; +}; + +struct interface_data { + char *name; + DBusMethodVTable *methods; + DBusSignalVTable *signals; + DBusPropertyVTable *properties; +}; + +DBusHandlerResult dbus_connection_send_and_unref(DBusConnection *connection, + DBusMessage *message) +{ + if (message) { + dbus_connection_send(connection, message, NULL); + dbus_message_unref(message); + } + + return DBUS_HANDLER_RESULT_HANDLED; +} + +static void print_arguments(GString *gstr, const char *sig, const char *direction) +{ + int i; + + for (i = 0; sig[i]; i++) { + char type[32]; + int len, struct_level, dict_level; + gboolean complete; + + complete = FALSE; + struct_level = dict_level = 0; + memset(type, 0, sizeof(type)); + + /* Gather enough data to have a single complete type */ + for (len = 0; len < (sizeof(type) - 1) && sig[i]; len++, i++) { + switch (sig[i]){ + case '(': + struct_level++; + break; + case ')': + struct_level--; + if (struct_level <= 0 && dict_level <= 0) + complete = TRUE; + break; + case '{': + dict_level++; + break; + case '}': + dict_level--; + if (struct_level <= 0 && dict_level <= 0) + complete = TRUE; + break; + case 'a': + break; + default: + if (struct_level <= 0 && dict_level <= 0) + complete = TRUE; + break; + } + + type[len] = sig[i]; + + if (complete) + break; + } + + + if (direction) + g_string_append_printf(gstr, + "\t\t\t\n", + type, direction); + else + g_string_append_printf(gstr, + "\t\t\t\n", + type); + } +} + +static void generate_introspection_xml(DBusConnection *conn, + struct generic_data *data, + const char *path) +{ + GSList *list; + GString *gstr; + char **children; + int i; + + g_free(data->introspect); + + gstr = g_string_new(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE); + + g_string_append_printf(gstr, "\n", path); + + for (list = data->interfaces; list; list = list->next) { + struct interface_data *iface = list->data; + DBusMethodVTable *method; + DBusSignalVTable *signal; + DBusPropertyVTable *property; + + g_string_append_printf(gstr, "\t\n", iface->name); + + for (method = iface->methods; method && method->name; method++) { + /* debug("%s: adding method %s.%s", + path, iface->name, method->name); */ + if (!strlen(method->signature) && !strlen(method->reply)) + g_string_append_printf(gstr, "\t\t\n", + method->name); + else { + g_string_append_printf(gstr, "\t\t\n", + method->name); + print_arguments(gstr, method->signature, "in"); + print_arguments(gstr, method->reply, "out"); + g_string_append_printf(gstr, "\t\t\n"); + } + } + + for (signal = iface->signals; signal && signal->name; signal++) { + /* debug("%s: adding signal %s.%s", + path, iface->name, signal->name); */ + if (!strlen(signal->signature)) + g_string_append_printf(gstr, "\t\t\n", + signal->name); + else { + g_string_append_printf(gstr, "\t\t\n", + signal->name); + print_arguments(gstr, signal->signature, NULL); + g_string_append_printf(gstr, "\t\t\n"); + } + } + + for (property = iface->properties; property && property->name; property++) { + debug("%s: adding property %s.%s", + path, iface->name, property->name); + } + + g_string_append_printf(gstr, "\t\n"); + } + + if (!dbus_connection_list_registered(conn, path, &children)) + goto done; + + for (i = 0; children[i]; i++) + g_string_append_printf(gstr, "\t\n", children[i]); + + dbus_free_string_array(children); + +done: + g_string_append_printf(gstr, "\n"); + + data->introspect = g_string_free(gstr, FALSE); +} + +static DBusHandlerResult introspect(DBusConnection *connection, + DBusMessage *message, struct generic_data *data) +{ + DBusMessage *reply; + + if (!dbus_message_has_signature(message, DBUS_TYPE_INVALID_AS_STRING)) { + error("Unexpected signature to introspect call"); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + if (!data->introspect) + generate_introspection_xml(connection, data, + dbus_message_get_path(message)); + + reply = dbus_message_new_method_return(message); + if (!reply) + return DBUS_HANDLER_RESULT_NEED_MEMORY; + + dbus_message_append_args(reply, DBUS_TYPE_STRING, &data->introspect, + DBUS_TYPE_INVALID); + + return dbus_connection_send_and_unref(connection, reply); +} + +static void generic_unregister(DBusConnection *connection, void *user_data) +{ + struct generic_data *data = user_data; + + if (data->unregister_function) + data->unregister_function(connection, data->user_data); + + g_free(data->introspect); + g_free(data); +} + +static struct interface_data *find_interface(GSList *interfaces, + const char *name) +{ + GSList *list; + + for (list = interfaces; list; list = list->next) { + struct interface_data *iface = list->data; + if (!strcmp(name, iface->name)) + return iface; + } + + return NULL; +} + +static DBusHandlerResult generic_message(DBusConnection *connection, + DBusMessage *message, void *user_data) +{ + struct generic_data *data = user_data; + struct interface_data *iface; + DBusMethodVTable *current; + const char *interface; + + if (dbus_message_is_method_call(message, + DBUS_INTERFACE_INTROSPECTABLE, + "Introspect")) + return introspect(connection, message, data); + + interface = dbus_message_get_interface(message); + + iface = find_interface(data->interfaces, interface); + if (!iface) + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + + for (current = iface->methods; + current->name && current->message_function; current++) { + if (!dbus_message_is_method_call(message, iface->name, + current->name)) + continue; + + if (dbus_message_has_signature(message, current->signature)) { + debug("%s: %s.%s()", dbus_message_get_path(message), + iface->name, current->name); + return current->message_function(connection, + message, data->user_data); + } + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +static DBusObjectPathVTable generic_table = { + .unregister_function = generic_unregister, + .message_function = generic_message, +}; + +static void invalidate_parent_data(DBusConnection *conn, const char *child_path) +{ + struct generic_data *data = NULL; + char *parent_path, *slash; + + parent_path = g_strdup(child_path); + slash = strrchr(parent_path, '/'); + if (!slash) + goto done; + + *slash = '\0'; + if (!strlen(parent_path)) + goto done; + + if (!dbus_connection_get_object_path_data(conn, parent_path, + (void *) &data)) + goto done; + + if (!data) + goto done; + + g_free(data->introspect); + data->introspect = NULL; + +done: + g_free(parent_path); +} + +dbus_bool_t dbus_connection_create_object_path(DBusConnection *connection, + const char *path, void *user_data, + DBusObjectPathUnregisterFunction function) +{ + struct generic_data *data; + + data = g_new0(struct generic_data, 1); + + data->user_data = user_data; + data->unregister_function = function; + + data->introspect = g_strdup(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE ""); + + if (!dbus_connection_register_object_path(connection, path, + &generic_table, data)) { + g_free(data->introspect); + g_free(data); + return FALSE; + } + + invalidate_parent_data(connection, path); + + return TRUE; +} + +dbus_bool_t dbus_connection_destroy_object_path(DBusConnection *connection, + const char *path) +{ + invalidate_parent_data(connection, path); + + return dbus_connection_unregister_object_path(connection, path); +} + +dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, + const char *path, + void **data_p) +{ + struct generic_data *data = NULL; + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &data) || !data) + return FALSE; + + *data_p = data->user_data; + + return TRUE; +} + +dbus_bool_t dbus_connection_register_interface(DBusConnection *connection, + const char *path, const char *name, + DBusMethodVTable *methods, + DBusSignalVTable *signals, + DBusPropertyVTable *properties) +{ + struct generic_data *data = NULL; + struct interface_data *iface; + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &data) || !data) + return FALSE; + + if (find_interface(data->interfaces, name)) + return FALSE; + + iface = g_new0(struct interface_data, 1); + + iface->name = g_strdup(name); + iface->methods = methods; + iface->signals = signals; + iface->properties = properties; + + data->interfaces = g_slist_append(data->interfaces, iface); + + g_free(data->introspect); + data->introspect = NULL; + + return TRUE; +} + +dbus_bool_t dbus_connection_unregister_interface(DBusConnection *connection, + const char *path, const char *name) +{ + struct generic_data *data = NULL; + struct interface_data *iface; + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &data) || !data) + return FALSE; + + iface = find_interface(data->interfaces, name); + if (!iface) + return FALSE; + + data->interfaces = g_slist_remove(data->interfaces, iface); + + g_free(iface->name); + g_free(iface); + + g_free(data->introspect); + data->introspect = NULL; + + return TRUE; +} + +void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val) +{ + DBusMessageIter value; + DBusMessageIter array; + char *sig; + + switch (type) { + case DBUS_TYPE_STRING: + sig = DBUS_TYPE_STRING_AS_STRING; + break; + case DBUS_TYPE_BYTE: + sig = DBUS_TYPE_BYTE_AS_STRING; + break; + case DBUS_TYPE_INT16: + sig = DBUS_TYPE_INT16_AS_STRING; + break; + case DBUS_TYPE_UINT16: + sig = DBUS_TYPE_UINT16_AS_STRING; + break; + case DBUS_TYPE_INT32: + sig = DBUS_TYPE_INT32_AS_STRING; + break; + case DBUS_TYPE_UINT32: + sig = DBUS_TYPE_UINT32_AS_STRING; + break; + case DBUS_TYPE_BOOLEAN: + sig = DBUS_TYPE_BOOLEAN_AS_STRING; + break; + case DBUS_TYPE_ARRAY: + sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING; + break; + case DBUS_TYPE_OBJECT_PATH: + sig = DBUS_TYPE_OBJECT_PATH_AS_STRING; + break; + default: + error("Could not append variant with type %d", type); + return; + } + + dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, sig, &value); + + if (type == DBUS_TYPE_ARRAY) { + int i; + const char ***str_array = val; + + dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, + DBUS_TYPE_STRING_AS_STRING, &array); + + for (i = 0; (*str_array)[i]; i++) + dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, + &((*str_array)[i])); + + dbus_message_iter_close_container(&value, &array); + } else + dbus_message_iter_append_basic(&value, type, val); + + dbus_message_iter_close_container(iter, &value); +} + +void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, + const char *key, int type, void *val) +{ + DBusMessageIter entry; + + dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + + dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + + dbus_message_iter_append_variant(&entry, type, val); + + dbus_message_iter_close_container(dict, &entry); +} + +void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, + const char *first_key, + va_list var_args) +{ + DBusMessageIter dict; + const char *key; + int type; + void *val; + + dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); + + key = first_key; + while (key) { + type = va_arg(var_args, int); + val = va_arg(var_args, void *); + dbus_message_iter_append_dict_entry(&dict, key, type, val); + key = va_arg(var_args, char *); + } + + dbus_message_iter_close_container(iter, &dict); +} + +void dbus_message_iter_append_dict(DBusMessageIter *iter, + const char *first_key, ...) +{ + va_list var_args; + + va_start(var_args, first_key); + dbus_message_iter_append_dict_valist(iter, first_key, var_args); + va_end(var_args); +} + +static gboolean check_signal(DBusConnection *conn, const char *path, + const char *interface, const char *name, + const char **args) +{ + struct generic_data *data = NULL; + struct interface_data *iface; + DBusSignalVTable *sig_data; + + *args = NULL; + if (!dbus_connection_get_object_path_data(conn, path, + (void *) &data) || !data) { + error("dbus_connection_emit_signal: path %s isn't registered", + path); + return FALSE; + } + + iface = find_interface(data->interfaces, interface); + + if (!iface) { + error("dbus_connection_emit_signal: %s does not implement %s", + path, interface); + return FALSE; + } + + for (sig_data = iface->signals; sig_data && sig_data->name; sig_data++) { + if (!strcmp(sig_data->name, name)) { + *args = sig_data->signature; + break; + } + } + + if (!*args) { + error("No signal named %s on interface %s", name, interface); + return FALSE; + } + + return TRUE; +} + +dbus_bool_t dbus_connection_emit_signal_valist(DBusConnection *conn, + const char *path, + const char *interface, + const char *name, + int first, + va_list var_args) +{ + DBusMessage *signal; + dbus_bool_t ret; + const char *signature, *args; + + if (!check_signal(conn, path, interface, name, &args)) + return FALSE; + + signal = dbus_message_new_signal(path, interface, name); + if (!signal) { + error("Unable to allocate new %s.%s signal", interface, name); + return FALSE; + } + + ret = dbus_message_append_args_valist(signal, first, var_args); + if (!ret) + goto fail; + + signature = dbus_message_get_signature(signal); + if (strcmp(args, signature) != 0) { + error("%s.%s: expected signature'%s' but got '%s'", + interface, name, args, signature); + ret = FALSE; + goto fail; + } + + ret = dbus_connection_send(conn, signal, NULL); +fail: + dbus_message_unref(signal); + + return ret; +} + +dbus_bool_t dbus_connection_emit_signal(DBusConnection *conn, const char *path, + const char *interface, const char *name, + int first, ...) +{ + dbus_bool_t ret; + va_list var_args; + + va_start(var_args, first); + ret = dbus_connection_emit_signal_valist(conn, path, interface, name, + first, var_args); + va_end(var_args); + + return ret; +} + +dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, + const char *path, + const char *interface, + const char *name, + int type, void *value) +{ + DBusMessage *signal; + DBusMessageIter iter; + gboolean ret; + const char *signature, *args; + + if (!check_signal(conn, path, interface, "PropertyChanged", &args)) + return FALSE; + + signal = dbus_message_new_signal(path, interface, "PropertyChanged"); + + if (!signal) { + error("Unable to allocate new %s.PropertyChanged signal", + interface); + return FALSE; + } + + dbus_message_iter_init_append(signal, &iter); + + dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); + dbus_message_iter_append_variant(&iter, type, value); + + signature = dbus_message_get_signature(signal); + if (strcmp(args, signature) != 0) { + error("%s.%s: expected signature'%s' but got '%s'", + interface, name, args, signature); + ret = FALSE; + goto fail; + } + + ret = dbus_connection_send(conn, signal, NULL); + +fail: + dbus_message_unref(signal); + return ret; +} -- cgit From 9e9f9adde3085582f81da3b681e6fe5bb62679d3 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 06:59:19 +0000 Subject: Add real libgdbus types for interface definitions --- gdbus/gdbus.h | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index d8382306..48f7fceb 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -122,6 +122,43 @@ static inline DBusHandlerResult send_message_and_unref(DBusConnection *conn, return DBUS_HANDLER_RESULT_HANDLED; } +typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection, + DBusMessage *message, void *user_data); + +typedef enum { + G_DBUS_METHOD_FLAG_DEPRECATED = (1 << 0), + G_DBUS_METHOD_FLAG_NOREPLY = (1 << 1), + G_DBUS_METHOD_FLAG_ASYNC = (1 << 2), +} GDBusMethodFlags; + +typedef enum { + G_DBUS_SIGNAL_FLAG_DEPRECATED = (1 << 0), +} GDBusSignalFlags; + +typedef enum { + G_DBUS_PROPERTY_FLAG_DEPRECATED = (1 << 0), +} GDBusPropertyFlags; + +typedef struct { + const char *name; + const char *signature; + const char *reply; + GDBusMethodFunction function; + GDBusMethodFlags flags; +} GDBusMethodTable; + +typedef struct { + const char *name; + const char *signature; + GDBusSignalFlags flags; +} GDBusSignalTable; + +typedef struct { + const char *name; + const char *type; + GDBusPropertyFlags flags; +} GDBusPropertyTable; + typedef void (*name_cb_t)(const char *name, void *user_data); guint name_listener_add(DBusConnection *connection, const char *name, -- cgit From 5567809ce0381ebfc22d77e5df31624d23c591dc Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 07:06:07 +0000 Subject: Add prototypes for interface registration --- gdbus/gdbus.h | 12 ++++++++++++ gdbus/object.c | 17 +++++++++++++++++ 2 files changed, 29 insertions(+) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 48f7fceb..f5087b15 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -122,6 +122,8 @@ static inline DBusHandlerResult send_message_and_unref(DBusConnection *conn, return DBUS_HANDLER_RESULT_HANDLED; } +typedef void (* GDBusDestroyFunction) (void *user_data); + typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection, DBusMessage *message, void *user_data); @@ -159,6 +161,16 @@ typedef struct { GDBusPropertyFlags flags; } GDBusPropertyTable; +gboolean g_dbus_register_interface(DBusConnection *connection, + const char *path, const char *name, + GDBusMethodTable *methods, + GDBusSignalTable *signals, + GDBusPropertyTable *properties, + void *user_data, + GDBusDestroyFunction destroy); +gboolean g_dbus_unregister_interface(DBusConnection *connection, + const char *path, const char *name); + typedef void (*name_cb_t)(const char *name, void *user_data); guint name_listener_add(DBusConnection *connection, const char *name, diff --git a/gdbus/object.c b/gdbus/object.c index 12ba66a9..738a6385 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -658,3 +658,20 @@ fail: dbus_message_unref(signal); return ret; } + +gboolean g_dbus_register_interface(DBusConnection *connection, + const char *path, const char *name, + GDBusMethodTable *methods, + GDBusSignalTable *signals, + GDBusPropertyTable *properties, + void *user_data, + GDBusDestroyFunction destroy) +{ + return FALSE; +} + +gboolean g_dbus_unregister_interface(DBusConnection *connection, + const char *path, const char *name) +{ + return FALSE; +} -- cgit From 97e97deb25d098c2e094ebfa8be2ed3994cc56ba Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 07:20:56 +0000 Subject: Add first implementation of libgdbus interface helpers --- gdbus/object.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 65 insertions(+), 13 deletions(-) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index 738a6385..bc3ea5e7 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -46,9 +46,15 @@ struct generic_data { struct interface_data { char *name; - DBusMethodVTable *methods; - DBusSignalVTable *signals; - DBusPropertyVTable *properties; + GDBusMethodTable *methods; + GDBusSignalTable *signals; + GDBusPropertyTable *properties; + void *user_data; + GDBusDestroyFunction destroy; + + DBusMethodVTable *old_methods; + DBusSignalVTable *old_signals; + DBusPropertyVTable *old_properties; }; DBusHandlerResult dbus_connection_send_and_unref(DBusConnection *connection, @@ -143,7 +149,7 @@ static void generate_introspection_xml(DBusConnection *conn, g_string_append_printf(gstr, "\t\n", iface->name); - for (method = iface->methods; method && method->name; method++) { + for (method = iface->old_methods; method && method->name; method++) { /* debug("%s: adding method %s.%s", path, iface->name, method->name); */ if (!strlen(method->signature) && !strlen(method->reply)) @@ -158,7 +164,7 @@ static void generate_introspection_xml(DBusConnection *conn, } } - for (signal = iface->signals; signal && signal->name; signal++) { + for (signal = iface->old_signals; signal && signal->name; signal++) { /* debug("%s: adding signal %s.%s", path, iface->name, signal->name); */ if (!strlen(signal->signature)) @@ -172,7 +178,7 @@ static void generate_introspection_xml(DBusConnection *conn, } } - for (property = iface->properties; property && property->name; property++) { + for (property = iface->old_properties; property && property->name; property++) { debug("%s: adding property %s.%s", path, iface->name, property->name); } @@ -262,7 +268,7 @@ static DBusHandlerResult generic_message(DBusConnection *connection, if (!iface) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - for (current = iface->methods; + for (current = iface->old_methods; current->name && current->message_function; current++) { if (!dbus_message_is_method_call(message, iface->name, current->name)) @@ -379,9 +385,9 @@ dbus_bool_t dbus_connection_register_interface(DBusConnection *connection, iface = g_new0(struct interface_data, 1); iface->name = g_strdup(name); - iface->methods = methods; - iface->signals = signals; - iface->properties = properties; + iface->old_methods = methods; + iface->old_signals = signals; + iface->old_properties = properties; data->interfaces = g_slist_append(data->interfaces, iface); @@ -548,7 +554,7 @@ static gboolean check_signal(DBusConnection *conn, const char *path, return FALSE; } - for (sig_data = iface->signals; sig_data && sig_data->name; sig_data++) { + for (sig_data = iface->old_signals; sig_data && sig_data->name; sig_data++) { if (!strcmp(sig_data->name, name)) { *args = sig_data->signature; break; @@ -667,11 +673,57 @@ gboolean g_dbus_register_interface(DBusConnection *connection, void *user_data, GDBusDestroyFunction destroy) { - return FALSE; + struct generic_data *data = NULL; + struct interface_data *iface; + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &data) || !data) + return FALSE; + + if (find_interface(data->interfaces, name)) + return FALSE; + + iface = g_new0(struct interface_data, 1); + + iface->name = g_strdup(name); + iface->methods = methods; + iface->signals = signals; + iface->properties = properties; + iface->user_data = user_data; + iface->destroy = destroy; + + data->interfaces = g_slist_append(data->interfaces, iface); + + g_free(data->introspect); + data->introspect = NULL; + + return TRUE; } gboolean g_dbus_unregister_interface(DBusConnection *connection, const char *path, const char *name) { - return FALSE; + struct generic_data *data = NULL; + struct interface_data *iface; + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &data) || !data) + return FALSE; + + iface = find_interface(data->interfaces, name); + if (!iface) + return FALSE; + + data->interfaces = g_slist_remove(data->interfaces, iface); + + if (iface->destroy) + iface->destroy(iface->user_data); + + g_free(iface->name); + g_free(iface); + + g_free(data->introspect); + data->introspect = NULL; + + return TRUE; } -- cgit From ac79141ef561c9d87494350c2b28b0d37975650a Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 07:47:26 +0000 Subject: Use reference counting for the object paths --- gdbus/object.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 54 insertions(+), 13 deletions(-) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index bc3ea5e7..762ab74e 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -42,6 +42,7 @@ struct generic_data { DBusObjectPathUnregisterFunction unregister_function; GSList *interfaces; char *introspect; + unsigned int refcount; }; struct interface_data { @@ -318,37 +319,75 @@ done: g_free(parent_path); } -dbus_bool_t dbus_connection_create_object_path(DBusConnection *connection, - const char *path, void *user_data, - DBusObjectPathUnregisterFunction function) +static struct generic_data *object_path_ref(DBusConnection *connection, + const char *path) { - struct generic_data *data; + struct generic_data *data = NULL; - data = g_new0(struct generic_data, 1); + if (dbus_connection_get_object_path_data(connection, path, + (void *) &data) || !data) { + data->refcount++; + return data; + } - data->user_data = user_data; - data->unregister_function = function; + data = g_new0(struct generic_data, 1); data->introspect = g_strdup(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE ""); + data->refcount = 1; + if (!dbus_connection_register_object_path(connection, path, &generic_table, data)) { g_free(data->introspect); g_free(data); - return FALSE; + return NULL; } invalidate_parent_data(connection, path); + return data; +} + +static void object_path_unref(DBusConnection *connection, const char *path) +{ + struct generic_data *data = NULL; + + if (!dbus_connection_get_object_path_data(connection, path, + (void *) &data) || !data) + return; + + data->refcount--; + + if (data->refcount > 0) + return; + + invalidate_parent_data(connection, path); + + dbus_connection_unregister_object_path(connection, path); +} + +dbus_bool_t dbus_connection_create_object_path(DBusConnection *connection, + const char *path, void *user_data, + DBusObjectPathUnregisterFunction function) +{ + struct generic_data *data; + + data = object_path_ref(connection, path); + if (data == NULL) + return FALSE; + + data->user_data = user_data; + data->unregister_function = function; + return TRUE; } dbus_bool_t dbus_connection_destroy_object_path(DBusConnection *connection, const char *path) { - invalidate_parent_data(connection, path); + object_path_unref(connection, path); - return dbus_connection_unregister_object_path(connection, path); + return TRUE; } dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, @@ -673,11 +712,11 @@ gboolean g_dbus_register_interface(DBusConnection *connection, void *user_data, GDBusDestroyFunction destroy) { - struct generic_data *data = NULL; + struct generic_data *data; struct interface_data *iface; - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &data) || !data) + data = object_path_ref(connection, path); + if (data == NULL) return FALSE; if (find_interface(data->interfaces, name)) @@ -725,5 +764,7 @@ gboolean g_dbus_unregister_interface(DBusConnection *connection, g_free(data->introspect); data->introspect = NULL; + object_path_unref(connection, path); + return TRUE; } -- cgit From e7bf43c753dda82371be083bdb063a96767576eb Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 07:57:04 +0000 Subject: Add introspection support for new interface handlers --- gdbus/object.c | 119 ++++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 79 insertions(+), 40 deletions(-) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index 762ab74e..56d17c93 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -127,9 +127,80 @@ static void print_arguments(GString *gstr, const char *sig, const char *directio } } +static void generate_old_interface_xml(GString *gstr, struct interface_data *iface) +{ + DBusMethodVTable *method; + DBusSignalVTable *signal; + DBusPropertyVTable *property; + + for (method = iface->old_methods; method && method->name; method++) { + /* debug("%s: adding method %s.%s", + path, iface->name, method->name); */ + if (!strlen(method->signature) && !strlen(method->reply)) + g_string_append_printf(gstr, "\t\t\n", + method->name); + else { + g_string_append_printf(gstr, "\t\t\n", + method->name); + print_arguments(gstr, method->signature, "in"); + print_arguments(gstr, method->reply, "out"); + g_string_append_printf(gstr, "\t\t\n"); + } + } + + for (signal = iface->old_signals; signal && signal->name; signal++) { + /* debug("%s: adding signal %s.%s", + path, iface->name, signal->name); */ + if (!strlen(signal->signature)) + g_string_append_printf(gstr, "\t\t\n", + signal->name); + else { + g_string_append_printf(gstr, "\t\t\n", + signal->name); + print_arguments(gstr, signal->signature, NULL); + g_string_append_printf(gstr, "\t\t\n"); + } + } + + for (property = iface->old_properties; property && property->name; property++) { + debug("%s: adding property %s.%s", + path, iface->name, property->name); + } +} + +static void generate_interface_xml(GString *gstr, struct interface_data *iface) +{ + GDBusMethodTable *method; + GDBusSignalTable *signal; + + for (method = iface->methods; method && method->name; method++) { + if (!strlen(method->signature) && !strlen(method->reply)) + g_string_append_printf(gstr, "\t\t\n", + method->name); + else { + g_string_append_printf(gstr, "\t\t\n", + method->name); + print_arguments(gstr, method->signature, "in"); + print_arguments(gstr, method->reply, "out"); + g_string_append_printf(gstr, "\t\t\n"); + } + } + + for (signal = iface->signals; signal && signal->name; signal++) { + if (!strlen(signal->signature)) + g_string_append_printf(gstr, "\t\t\n", + signal->name); + else { + g_string_append_printf(gstr, "\t\t\n", + signal->name); + print_arguments(gstr, signal->signature, NULL); + g_string_append_printf(gstr, "\t\t\n"); + } + } +} + static void generate_introspection_xml(DBusConnection *conn, - struct generic_data *data, - const char *path) + struct generic_data *data, const char *path) { GSList *list; GString *gstr; @@ -144,45 +215,12 @@ static void generate_introspection_xml(DBusConnection *conn, for (list = data->interfaces; list; list = list->next) { struct interface_data *iface = list->data; - DBusMethodVTable *method; - DBusSignalVTable *signal; - DBusPropertyVTable *property; - - g_string_append_printf(gstr, "\t\n", iface->name); - - for (method = iface->old_methods; method && method->name; method++) { - /* debug("%s: adding method %s.%s", - path, iface->name, method->name); */ - if (!strlen(method->signature) && !strlen(method->reply)) - g_string_append_printf(gstr, "\t\t\n", - method->name); - else { - g_string_append_printf(gstr, "\t\t\n", - method->name); - print_arguments(gstr, method->signature, "in"); - print_arguments(gstr, method->reply, "out"); - g_string_append_printf(gstr, "\t\t\n"); - } - } - for (signal = iface->old_signals; signal && signal->name; signal++) { - /* debug("%s: adding signal %s.%s", - path, iface->name, signal->name); */ - if (!strlen(signal->signature)) - g_string_append_printf(gstr, "\t\t\n", - signal->name); - else { - g_string_append_printf(gstr, "\t\t\n", - signal->name); - print_arguments(gstr, signal->signature, NULL); - g_string_append_printf(gstr, "\t\t\n"); - } - } + g_string_append_printf(gstr, "\t\n", + iface->name); - for (property = iface->old_properties; property && property->name; property++) { - debug("%s: adding property %s.%s", - path, iface->name, property->name); - } + generate_interface_xml(gstr, iface); + generate_old_interface_xml(gstr, iface); g_string_append_printf(gstr, "\t\n"); } @@ -191,7 +229,8 @@ static void generate_introspection_xml(DBusConnection *conn, goto done; for (i = 0; children[i]; i++) - g_string_append_printf(gstr, "\t\n", children[i]); + g_string_append_printf(gstr, "\t\n", + children[i]); dbus_free_string_array(children); -- cgit From af6885a49f231d2e5fe421187679b27252658b6c Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 08:33:45 +0000 Subject: Fix object path reference count handling --- gdbus/object.c | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index 56d17c93..24da21c9 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -361,12 +361,14 @@ done: static struct generic_data *object_path_ref(DBusConnection *connection, const char *path) { - struct generic_data *data = NULL; + struct generic_data *data; if (dbus_connection_get_object_path_data(connection, path, - (void *) &data) || !data) { - data->refcount++; - return data; + (void *) &data) == TRUE) { + if (data != NULL) { + data->refcount++; + return data; + } } data = g_new0(struct generic_data, 1); @@ -391,8 +393,11 @@ static void object_path_unref(DBusConnection *connection, const char *path) { struct generic_data *data = NULL; - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &data) || !data) + if (dbus_connection_get_object_path_data(connection, path, + (void *) &data) == FALSE) + return; + + if (data == NULL) return; data->refcount--; @@ -784,8 +789,11 @@ gboolean g_dbus_unregister_interface(DBusConnection *connection, struct generic_data *data = NULL; struct interface_data *iface; - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &data) || !data) + if (dbus_connection_get_object_path_data(connection, path, + (void *) &data) == FALSE) + return FALSE; + + if (data == NULL) return FALSE; iface = find_interface(data->interfaces, name); -- cgit From aff0ec6707716c2ea129695f85715d59e3d9474b Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 08:50:36 +0000 Subject: Add new message dispatching --- gdbus/object.c | 40 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index 24da21c9..6011753d 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -294,12 +294,13 @@ static DBusHandlerResult generic_message(DBusConnection *connection, { struct generic_data *data = user_data; struct interface_data *iface; + GDBusMethodTable *method; DBusMethodVTable *current; const char *interface; if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, - "Introspect")) + "Introspect")) return introspect(connection, message, data); interface = dbus_message_get_interface(message); @@ -308,6 +309,43 @@ static DBusHandlerResult generic_message(DBusConnection *connection, if (!iface) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + for (method = iface->methods; + method->name && method->function; method++) { + DBusMessage *reply; + + if (dbus_message_is_method_call(message, iface->name, + method->name) == FALSE) + continue; + + if (dbus_message_has_signature(message, + method->signature) == FALSE) + continue; + + if (method->function == NULL) + continue; + + reply = method->function(connection, message, iface->user_data); + + if (method->flags & G_DBUS_METHOD_FLAG_NOREPLY) { + if (reply != NULL) + dbus_message_unref(reply); + return DBUS_HANDLER_RESULT_HANDLED; + } + + if (method->flags & G_DBUS_METHOD_FLAG_ASYNC) { + if (reply == NULL) + return DBUS_HANDLER_RESULT_HANDLED; + } + + if (reply == NULL) + return DBUS_HANDLER_RESULT_NEED_MEMORY; + + dbus_connection_send(connection, reply, NULL); + dbus_message_unref(reply); + + return DBUS_HANDLER_RESULT_HANDLED; + } + for (current = iface->old_methods; current->name && current->message_function; current++) { if (!dbus_message_is_method_call(message, iface->name, -- cgit From cc2d696524d90b3c624c8857338f8572c7edff99 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 09:07:28 +0000 Subject: More fixes for the message dispatch handling --- gdbus/object.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index 6011753d..d018fce3 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -309,7 +309,7 @@ static DBusHandlerResult generic_message(DBusConnection *connection, if (!iface) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; - for (method = iface->methods; + for (method = iface->methods; method && method->name && method->function; method++) { DBusMessage *reply; @@ -321,9 +321,6 @@ static DBusHandlerResult generic_message(DBusConnection *connection, method->signature) == FALSE) continue; - if (method->function == NULL) - continue; - reply = method->function(connection, message, iface->user_data); if (method->flags & G_DBUS_METHOD_FLAG_NOREPLY) { @@ -346,7 +343,7 @@ static DBusHandlerResult generic_message(DBusConnection *connection, return DBUS_HANDLER_RESULT_HANDLED; } - for (current = iface->old_methods; + for (current = iface->old_methods; current && current->name && current->message_function; current++) { if (!dbus_message_is_method_call(message, iface->name, current->name)) -- cgit From d0b06ea8fd1a8642c99d6b2c7661d562acf3c43e Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 11:42:46 +0000 Subject: Add helpers for error creation --- gdbus/gdbus.h | 5 +++++ gdbus/object.c | 21 +++++++++++++++++++++ 2 files changed, 26 insertions(+) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index f5087b15..66baa852 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -171,6 +171,11 @@ gboolean g_dbus_register_interface(DBusConnection *connection, gboolean g_dbus_unregister_interface(DBusConnection *connection, const char *path, const char *name); +DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, + const char *format, va_list args); +DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name, + const char *format, ...); + typedef void (*name_cb_t)(const char *name, void *user_data); guint name_listener_add(DBusConnection *connection, const char *name, diff --git a/gdbus/object.c b/gdbus/object.c index d018fce3..f5561404 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -850,3 +850,24 @@ gboolean g_dbus_unregister_interface(DBusConnection *connection, return TRUE; } + +DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, + const char *format, va_list args) +{ + return dbus_message_new_error(message, name, format); +} + +DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name, + const char *format, ...) +{ + va_list args; + DBusMessage *reply; + + va_start(args, format); + + reply = g_dbus_create_error_valist(message, name, format, args); + + va_end(args); + + return reply; +} -- cgit From 1ed48482e52554d7bfa1a8edf8239399ae3e1155 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 12:17:15 +0000 Subject: Fix broken signal checking for new style API --- gdbus/object.c | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index f5561404..869482a4 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -654,6 +654,7 @@ static gboolean check_signal(DBusConnection *conn, const char *path, { struct generic_data *data = NULL; struct interface_data *iface; + GDBusSignalTable *signal; DBusSignalVTable *sig_data; *args = NULL; @@ -672,6 +673,13 @@ static gboolean check_signal(DBusConnection *conn, const char *path, return FALSE; } + for (signal = iface->signals; signal && signal->name; signal++) { + if (!strcmp(signal->name, name)) { + *args = signal->signature; + break; + } + } + for (sig_data = iface->old_signals; sig_data && sig_data->name; sig_data++) { if (!strcmp(sig_data->name, name)) { *args = sig_data->signature; -- cgit From 671e8bc7340909da8b0fe750176423113e9ea8c1 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 17:48:01 +0000 Subject: Add helpers for creating replies --- gdbus/gdbus.h | 3 +++ gdbus/object.c | 31 +++++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 66baa852..dc337954 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -175,6 +175,9 @@ DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, const char *format, va_list args); DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name, const char *format, ...); +DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...); +DBusMessage *g_dbus_create_reply_valist(DBusMessage *message, + int type, va_list args); typedef void (*name_cb_t)(const char *name, void *user_data); diff --git a/gdbus/object.c b/gdbus/object.c index 869482a4..56ff4433 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -879,3 +879,34 @@ DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name, return reply; } + +DBusMessage *g_dbus_create_reply_valist(DBusMessage *message, + int type, va_list args) +{ + DBusMessage *reply; + + reply = dbus_message_new_method_return(message); + if (reply == NULL) + return NULL; + + if (dbus_message_append_args_valist(reply, type, args) == FALSE) { + dbus_message_unref(reply); + return NULL; + } + + return reply; +} + +DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...) +{ + va_list args; + DBusMessage *reply; + + va_start(args, type); + + reply = g_dbus_create_reply_valist(message, type, args); + + va_end(args); + + return reply; +} -- cgit From 80d6914d167a731d97aff4e25497f84e96e09fe3 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 27 May 2008 18:02:23 +0000 Subject: Add helpers for sending async replies --- gdbus/gdbus.h | 6 ++++++ gdbus/object.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index dc337954..6f3ddb79 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -179,6 +179,12 @@ DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...); DBusMessage *g_dbus_create_reply_valist(DBusMessage *message, int type, va_list args); +gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message); +gboolean g_dbus_send_reply(DBusConnection *connection, + DBusMessage *message, int type, ...); +gboolean g_dbus_send_reply_valist(DBusConnection *connection, + DBusMessage *message, int type, va_list args); + typedef void (*name_cb_t)(const char *name, void *user_data); guint name_listener_add(DBusConnection *connection, const char *name, diff --git a/gdbus/object.c b/gdbus/object.c index 56ff4433..dd3d8609 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -910,3 +910,46 @@ DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...) return reply; } + +gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message) +{ + dbus_bool_t result; + + result = dbus_connection_send(connection, message, NULL); + + dbus_message_unref(message); + + return result; +} + +gboolean g_dbus_send_reply_valist(DBusConnection *connection, + DBusMessage *message, int type, va_list args) +{ + DBusMessage *reply; + + reply = dbus_message_new_method_return(message); + if (reply == NULL) + return FALSE; + + if (dbus_message_append_args_valist(reply, type, args) == FALSE) { + dbus_message_unref(reply); + return FALSE; + } + + return g_dbus_send_message(connection, reply); +} + +gboolean g_dbus_send_reply(DBusConnection *connection, + DBusMessage *message, int type, ...) +{ + va_list args; + gboolean result; + + va_start(args, type); + + result = g_dbus_send_reply_valist(connection, message, type, args); + + va_end(args); + + return result; +} -- cgit From cc0f97ec2cb298bde87cd3753fd96f11ce41ff64 Mon Sep 17 00:00:00 2001 From: Johan Hedberg Date: Thu, 29 May 2008 14:43:27 +0000 Subject: Change name_listener API to libgdbus watch API --- gdbus/gdbus.h | 16 +++++++-------- gdbus/watch.c | 63 ++++++++++++----------------------------------------------- 2 files changed, 21 insertions(+), 58 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 6f3ddb79..22c10569 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -185,14 +185,14 @@ gboolean g_dbus_send_reply(DBusConnection *connection, gboolean g_dbus_send_reply_valist(DBusConnection *connection, DBusMessage *message, int type, va_list args); -typedef void (*name_cb_t)(const char *name, void *user_data); - -guint name_listener_add(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data); -int name_listener_remove(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data); -gboolean name_listener_id_remove(guint id); -int name_listener_indicate_disconnect(DBusConnection *connection); +typedef void (* GDBusWatchFunction) (void *user_data); + +guint g_dbus_add_disconnect_watch(DBusConnection *connection, + const char *name, + GDBusWatchFunction function, + void *user_data, GDBusDestroyFunction destroy); +gboolean g_dbus_remove_watch(DBusConnection *connection, guint tag); +void g_dbus_remove_all_watches(DBusConnection *connection); #ifdef __cplusplus } diff --git a/gdbus/watch.c b/gdbus/watch.c index 80be3a6a..3c7a03a4 100644 --- a/gdbus/watch.c +++ b/gdbus/watch.c @@ -41,7 +41,7 @@ static guint listener_id = 0; static GSList *name_listeners = NULL; struct name_callback { - name_cb_t func; + GDBusWatchFunction func; void *user_data; guint id; }; @@ -74,7 +74,7 @@ static struct name_data *name_data_find(DBusConnection *connection, } static struct name_callback *name_callback_find(GSList *callbacks, - name_cb_t func, void *user_data) + GDBusWatchFunction func, void *user_data) { GSList *current; @@ -94,7 +94,7 @@ static void name_data_call_and_free(struct name_data *data) for (l = data->callbacks; l != NULL; l = l->next) { struct name_callback *cb = l->data; if (cb->func) - cb->func(data->name, cb->user_data); + cb->func(cb->user_data); g_free(cb); } @@ -116,7 +116,7 @@ static void name_data_free(struct name_data *data) } static int name_data_add(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data, guint id) + GDBusWatchFunction func, void *user_data, guint id) { int first = 1; struct name_data *data = NULL; @@ -147,7 +147,7 @@ done: } static void name_data_remove(DBusConnection *connection, - const char *name, name_cb_t func, void *user_data) + const char *name, GDBusWatchFunction func, void *user_data) { struct name_data *data; struct name_callback *cb = NULL; @@ -246,7 +246,7 @@ static DBusHandlerResult name_exit_filter(DBusConnection *connection, for (l = data->callbacks; l != NULL; l = l->next) { struct name_callback *cb = l->data; - cb->func(name, cb->user_data); + cb->func(cb->user_data); } name_listeners = g_slist_remove(name_listeners, data); @@ -257,8 +257,10 @@ static DBusHandlerResult name_exit_filter(DBusConnection *connection, return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -guint name_listener_add(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data) +guint g_dbus_add_disconnect_watch(DBusConnection *connection, + const char *name, + GDBusWatchFunction func, + void *user_data, GDBusDestroyFunction destroy) { int first; @@ -289,44 +291,7 @@ guint name_listener_add(DBusConnection *connection, const char *name, return listener_id; } -int name_listener_remove(DBusConnection *connection, const char *name, - name_cb_t func, void *user_data) -{ - struct name_data *data; - struct name_callback *cb; - - data = name_data_find(connection, name); - if (!data) { - error("remove_name_listener: no listener for %s", name); - return -1; - } - - cb = name_callback_find(data->callbacks, func, user_data); - if (!cb) { - error("No matching callback found for %s", name); - return -1; - } - - data->callbacks = g_slist_remove(data->callbacks, cb); - g_free(cb); - - /* Don't remove the filter if other callbacks exist */ - if (data->callbacks) - return 0; - - if (name) { - debug("name_listener_remove(%s)", name); - - if (!remove_match(connection, name)) - return -1; - } - - name_data_remove(connection, name, func, user_data); - - return 0; -} - -gboolean name_listener_id_remove(guint id) +gboolean g_dbus_remove_watch(DBusConnection *connection, guint id) { struct name_data *data; struct name_callback *cb; @@ -362,19 +327,17 @@ remove: return TRUE; } -int name_listener_indicate_disconnect(DBusConnection *connection) +void g_dbus_remove_all_watches(DBusConnection *connection) { struct name_data *data; data = name_data_find(connection, NULL); if (!data) { error("name_listener_indicate_disconnect: no listener found"); - return -1; + return; } debug("name_listener_indicate_disconnect"); name_data_call_and_free(data); - - return 0; } -- cgit From 7d1a9d56719aea39ecd38c8dafffee9de898e68b Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Thu, 29 May 2008 21:12:03 +0000 Subject: Remove GDBusDisconnectFunction type --- gdbus/gdbus.h | 6 ++---- gdbus/mainloop.c | 2 +- 2 files changed, 3 insertions(+), 5 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 22c10569..68c6fe80 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -31,13 +31,13 @@ extern "C" { #include #include -typedef void (* GDBusDisconnectFunction) (void *user_data); +typedef void (* GDBusWatchFunction) (void *user_data); DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name, DBusError *error); gboolean g_dbus_set_disconnect_function(DBusConnection *connection, - GDBusDisconnectFunction function, + GDBusWatchFunction function, void *user_data, DBusFreeFunction destroy); #define DBUS_TYPE_STRING_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING) @@ -185,8 +185,6 @@ gboolean g_dbus_send_reply(DBusConnection *connection, gboolean g_dbus_send_reply_valist(DBusConnection *connection, DBusMessage *message, int type, va_list args); -typedef void (* GDBusWatchFunction) (void *user_data); - guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name, GDBusWatchFunction function, diff --git a/gdbus/mainloop.c b/gdbus/mainloop.c index a9b8237c..36abbf33 100644 --- a/gdbus/mainloop.c +++ b/gdbus/mainloop.c @@ -290,7 +290,7 @@ DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name, } gboolean g_dbus_set_disconnect_function(DBusConnection *connection, - GDBusDisconnectFunction function, + GDBusWatchFunction function, void *user_data, DBusFreeFunction destroy) { struct disconnect_data *dc_data; -- cgit From 21e5707fba726c379ed6a260f6efb4dab9d7c44b Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 3 Jun 2008 14:51:51 +0000 Subject: Add skeleton for g_dbus_unregister_all_interfaces --- gdbus/gdbus.h | 2 ++ gdbus/object.c | 6 ++++++ 2 files changed, 8 insertions(+) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 68c6fe80..f7187f22 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -170,6 +170,8 @@ gboolean g_dbus_register_interface(DBusConnection *connection, GDBusDestroyFunction destroy); gboolean g_dbus_unregister_interface(DBusConnection *connection, const char *path, const char *name); +gboolean g_dbus_unregister_all_interfaces(DBusConnection *connection, + const char *path); DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, const char *format, va_list args); diff --git a/gdbus/object.c b/gdbus/object.c index dd3d8609..0094e76b 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -859,6 +859,12 @@ gboolean g_dbus_unregister_interface(DBusConnection *connection, return TRUE; } +gboolean g_dbus_unregister_all_interfaces(DBusConnection *connection, + const char *path) +{ + return FALSE; +} + DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, const char *format, va_list args) { -- cgit From c4d01c3cd114eccaa8ef79d8e082b345783ba9f1 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Tue, 3 Jun 2008 14:56:37 +0000 Subject: Add simple g_dbus_unregister_all_interfaces implementation --- gdbus/object.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) (limited to 'gdbus') diff --git a/gdbus/object.c b/gdbus/object.c index 0094e76b..0e979f97 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -862,7 +862,20 @@ gboolean g_dbus_unregister_interface(DBusConnection *connection, gboolean g_dbus_unregister_all_interfaces(DBusConnection *connection, const char *path) { - return FALSE; + struct generic_data *data = NULL; + + if (dbus_connection_get_object_path_data(connection, path, + (void *) &data) == FALSE) + return FALSE; + + if (data == NULL) + return FALSE; + + invalidate_parent_data(connection, path); + + dbus_connection_unregister_object_path(connection, path); + + return TRUE; } DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, -- cgit From 38b422bbfe271a79b098acb99551812b0b9bde43 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Fri, 6 Jun 2008 10:42:15 +0000 Subject: Remove obsolete D-Bus sending helpers --- gdbus/gdbus.h | 14 -------------- gdbus/object.c | 17 +++++------------ 2 files changed, 5 insertions(+), 26 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index f7187f22..8bce2ee5 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -43,9 +43,6 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, #define DBUS_TYPE_STRING_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING) #define DBUS_TYPE_BYTE_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING) -DBusHandlerResult dbus_connection_send_and_unref(DBusConnection *connection, - DBusMessage *message); - dbus_bool_t dbus_connection_create_object_path(DBusConnection *connection, const char *path, void *user_data, DBusObjectPathUnregisterFunction function); @@ -111,17 +108,6 @@ dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, const char *name, int type, void *value); -static inline DBusHandlerResult send_message_and_unref(DBusConnection *conn, - DBusMessage *msg) -{ - if (msg) { - dbus_connection_send(conn, msg, NULL); - dbus_message_unref(msg); - } - - return DBUS_HANDLER_RESULT_HANDLED; -} - typedef void (* GDBusDestroyFunction) (void *user_data); typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection, diff --git a/gdbus/object.c b/gdbus/object.c index 0e979f97..5d956f29 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -58,17 +58,6 @@ struct interface_data { DBusPropertyVTable *old_properties; }; -DBusHandlerResult dbus_connection_send_and_unref(DBusConnection *connection, - DBusMessage *message) -{ - if (message) { - dbus_connection_send(connection, message, NULL); - dbus_message_unref(message); - } - - return DBUS_HANDLER_RESULT_HANDLED; -} - static void print_arguments(GString *gstr, const char *sig, const char *direction) { int i; @@ -261,7 +250,11 @@ static DBusHandlerResult introspect(DBusConnection *connection, dbus_message_append_args(reply, DBUS_TYPE_STRING, &data->introspect, DBUS_TYPE_INVALID); - return dbus_connection_send_and_unref(connection, reply); + dbus_connection_send(connection, reply, NULL); + + dbus_message_unref(reply); + + return DBUS_HANDLER_RESULT_HANDLED; } static void generic_unregister(DBusConnection *connection, void *user_data) -- cgit From 30877999b61e655ff7f4e804240098c4cd31831e Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Fri, 6 Jun 2008 10:45:39 +0000 Subject: Remove obsolete D-Bus interface helpers --- gdbus/gdbus.h | 33 +------------- gdbus/object.c | 134 +++------------------------------------------------------ 2 files changed, 8 insertions(+), 159 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 8bce2ee5..9b95e2e5 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -54,37 +54,8 @@ dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, const char *path, void **data_p); -typedef struct DBusMethodVTable DBusMethodVTable; - -struct DBusMethodVTable { - const char *name; - DBusObjectPathMessageFunction message_function; - const char *signature; - const char *reply; -}; - -typedef struct DBusSignalVTable DBusSignalVTable; - -struct DBusSignalVTable { - const char *name; - const char *signature; -}; - -typedef struct DBusPropertyVTable DBusPropertyVTable; - -struct DBusPropertyVTable { - const char *name; -}; - -dbus_bool_t dbus_connection_register_interface(DBusConnection *connection, - const char *path, const char *name, - DBusMethodVTable *methods, - DBusSignalVTable *signals, - DBusPropertyVTable *properties); - -dbus_bool_t dbus_connection_unregister_interface(DBusConnection *connection, - const char *path, const char *name); -void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val); +void dbus_message_iter_append_variant(DBusMessageIter *iter, + int type, void *val); void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, const char *key, int type, void *val); void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, diff --git a/gdbus/object.c b/gdbus/object.c index 5d956f29..6e5e8aab 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -52,13 +52,10 @@ struct interface_data { GDBusPropertyTable *properties; void *user_data; GDBusDestroyFunction destroy; - - DBusMethodVTable *old_methods; - DBusSignalVTable *old_signals; - DBusPropertyVTable *old_properties; }; -static void print_arguments(GString *gstr, const char *sig, const char *direction) +static void print_arguments(GString *gstr, const char *sig, + const char *direction) { int i; @@ -116,47 +113,6 @@ static void print_arguments(GString *gstr, const char *sig, const char *directio } } -static void generate_old_interface_xml(GString *gstr, struct interface_data *iface) -{ - DBusMethodVTable *method; - DBusSignalVTable *signal; - DBusPropertyVTable *property; - - for (method = iface->old_methods; method && method->name; method++) { - /* debug("%s: adding method %s.%s", - path, iface->name, method->name); */ - if (!strlen(method->signature) && !strlen(method->reply)) - g_string_append_printf(gstr, "\t\t\n", - method->name); - else { - g_string_append_printf(gstr, "\t\t\n", - method->name); - print_arguments(gstr, method->signature, "in"); - print_arguments(gstr, method->reply, "out"); - g_string_append_printf(gstr, "\t\t\n"); - } - } - - for (signal = iface->old_signals; signal && signal->name; signal++) { - /* debug("%s: adding signal %s.%s", - path, iface->name, signal->name); */ - if (!strlen(signal->signature)) - g_string_append_printf(gstr, "\t\t\n", - signal->name); - else { - g_string_append_printf(gstr, "\t\t\n", - signal->name); - print_arguments(gstr, signal->signature, NULL); - g_string_append_printf(gstr, "\t\t\n"); - } - } - - for (property = iface->old_properties; property && property->name; property++) { - debug("%s: adding property %s.%s", - path, iface->name, property->name); - } -} - static void generate_interface_xml(GString *gstr, struct interface_data *iface) { GDBusMethodTable *method; @@ -209,7 +165,6 @@ static void generate_introspection_xml(DBusConnection *conn, iface->name); generate_interface_xml(gstr, iface); - generate_old_interface_xml(gstr, iface); g_string_append_printf(gstr, "\t\n"); } @@ -288,7 +243,6 @@ static DBusHandlerResult generic_message(DBusConnection *connection, struct generic_data *data = user_data; struct interface_data *iface; GDBusMethodTable *method; - DBusMethodVTable *current; const char *interface; if (dbus_message_is_method_call(message, @@ -336,20 +290,6 @@ static DBusHandlerResult generic_message(DBusConnection *connection, return DBUS_HANDLER_RESULT_HANDLED; } - for (current = iface->old_methods; current && - current->name && current->message_function; current++) { - if (!dbus_message_is_method_call(message, iface->name, - current->name)) - continue; - - if (dbus_message_has_signature(message, current->signature)) { - debug("%s: %s.%s()", dbus_message_get_path(message), - iface->name, current->name); - return current->message_function(connection, - message, data->user_data); - } - } - return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } @@ -477,63 +417,8 @@ dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, return TRUE; } -dbus_bool_t dbus_connection_register_interface(DBusConnection *connection, - const char *path, const char *name, - DBusMethodVTable *methods, - DBusSignalVTable *signals, - DBusPropertyVTable *properties) -{ - struct generic_data *data = NULL; - struct interface_data *iface; - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &data) || !data) - return FALSE; - - if (find_interface(data->interfaces, name)) - return FALSE; - - iface = g_new0(struct interface_data, 1); - - iface->name = g_strdup(name); - iface->old_methods = methods; - iface->old_signals = signals; - iface->old_properties = properties; - - data->interfaces = g_slist_append(data->interfaces, iface); - - g_free(data->introspect); - data->introspect = NULL; - - return TRUE; -} - -dbus_bool_t dbus_connection_unregister_interface(DBusConnection *connection, - const char *path, const char *name) -{ - struct generic_data *data = NULL; - struct interface_data *iface; - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &data) || !data) - return FALSE; - - iface = find_interface(data->interfaces, name); - if (!iface) - return FALSE; - - data->interfaces = g_slist_remove(data->interfaces, iface); - - g_free(iface->name); - g_free(iface); - - g_free(data->introspect); - data->introspect = NULL; - - return TRUE; -} - -void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val) +void dbus_message_iter_append_variant(DBusMessageIter *iter, + int type, void *val) { DBusMessageIter value; DBusMessageIter array; @@ -597,7 +482,8 @@ void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, { DBusMessageIter entry; - dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); + dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, + NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); @@ -648,7 +534,6 @@ static gboolean check_signal(DBusConnection *conn, const char *path, struct generic_data *data = NULL; struct interface_data *iface; GDBusSignalTable *signal; - DBusSignalVTable *sig_data; *args = NULL; if (!dbus_connection_get_object_path_data(conn, path, @@ -673,13 +558,6 @@ static gboolean check_signal(DBusConnection *conn, const char *path, } } - for (sig_data = iface->old_signals; sig_data && sig_data->name; sig_data++) { - if (!strcmp(sig_data->name, name)) { - *args = sig_data->signature; - break; - } - } - if (!*args) { error("No signal named %s on interface %s", name, interface); return FALSE; -- cgit From dd368f19884b9751a0f99ffebcd2c5520069f5db Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Fri, 6 Jun 2008 13:52:43 +0000 Subject: Remove object path creation and destroy helpers --- gdbus/gdbus.h | 7 ------- gdbus/object.c | 42 +++--------------------------------------- 2 files changed, 3 insertions(+), 46 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 9b95e2e5..5ddc4058 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -43,13 +43,6 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, #define DBUS_TYPE_STRING_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING) #define DBUS_TYPE_BYTE_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING) -dbus_bool_t dbus_connection_create_object_path(DBusConnection *connection, - const char *path, void *user_data, - DBusObjectPathUnregisterFunction function); - -dbus_bool_t dbus_connection_destroy_object_path(DBusConnection *connection, - const char *path); - dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, const char *path, void **data_p); diff --git a/gdbus/object.c b/gdbus/object.c index 6e5e8aab..437659c7 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -38,11 +38,9 @@ #define debug(fmt...) struct generic_data { - void *user_data; - DBusObjectPathUnregisterFunction unregister_function; + unsigned int refcount; GSList *interfaces; char *introspect; - unsigned int refcount; }; struct interface_data { @@ -216,9 +214,6 @@ static void generic_unregister(DBusConnection *connection, void *user_data) { struct generic_data *data = user_data; - if (data->unregister_function) - data->unregister_function(connection, data->user_data); - g_free(data->introspect); g_free(data); } @@ -378,43 +373,11 @@ static void object_path_unref(DBusConnection *connection, const char *path) dbus_connection_unregister_object_path(connection, path); } -dbus_bool_t dbus_connection_create_object_path(DBusConnection *connection, - const char *path, void *user_data, - DBusObjectPathUnregisterFunction function) -{ - struct generic_data *data; - - data = object_path_ref(connection, path); - if (data == NULL) - return FALSE; - - data->user_data = user_data; - data->unregister_function = function; - - return TRUE; -} - -dbus_bool_t dbus_connection_destroy_object_path(DBusConnection *connection, - const char *path) -{ - object_path_unref(connection, path); - - return TRUE; -} - dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, const char *path, void **data_p) { - struct generic_data *data = NULL; - - if (!dbus_connection_get_object_path_data(connection, path, - (void *) &data) || !data) - return FALSE; - - *data_p = data->user_data; - - return TRUE; + return FALSE; } void dbus_message_iter_append_variant(DBusMessageIter *iter, @@ -599,6 +562,7 @@ dbus_bool_t dbus_connection_emit_signal_valist(DBusConnection *conn, } ret = dbus_connection_send(conn, signal, NULL); + fail: dbus_message_unref(signal); -- cgit From c910fb98d032261cc27c462d481d77674f13bded Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 16:14:31 +0000 Subject: Remove obsolete dbus_connection_get_object_user_data function --- gdbus/gdbus.h | 4 ---- gdbus/object.c | 7 ------- 2 files changed, 11 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 5ddc4058..99f34a84 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -43,10 +43,6 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, #define DBUS_TYPE_STRING_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING) #define DBUS_TYPE_BYTE_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING) -dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, - const char *path, - void **data_p); - void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val); void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, diff --git a/gdbus/object.c b/gdbus/object.c index 437659c7..fbcc8131 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -373,13 +373,6 @@ static void object_path_unref(DBusConnection *connection, const char *path) dbus_connection_unregister_object_path(connection, path); } -dbus_bool_t dbus_connection_get_object_user_data(DBusConnection *connection, - const char *path, - void **data_p) -{ - return FALSE; -} - void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val) { -- cgit From f06919f22999bd132ae6d84191245387eae9d733 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 16:22:47 +0000 Subject: Add proper signal sending helpers --- gdbus/gdbus.h | 13 +++++++------ gdbus/object.c | 30 +++++++++++++++++++++++++++--- 2 files changed, 34 insertions(+), 9 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 99f34a84..0ec90dcb 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -56,12 +56,6 @@ dbus_bool_t dbus_connection_emit_signal(DBusConnection *conn, const char *path, const char *interface, const char *name, int first, ...); -dbus_bool_t dbus_connection_emit_signal_valist(DBusConnection *conn, - const char *path, - const char *interface, - const char *name, - int first, - va_list var_args); dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, const char *path, const char *interface, @@ -133,6 +127,13 @@ gboolean g_dbus_send_reply(DBusConnection *connection, gboolean g_dbus_send_reply_valist(DBusConnection *connection, DBusMessage *message, int type, va_list args); +gboolean g_dbus_emit_signal(DBusConnection *connection, + const char *path, const char *interface, + const char *name, int type, ...); +gboolean g_dbus_emit_signal_valist(DBusConnection *connection, + const char *path, const char *interface, + const char *name, int type, va_list args); + guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name, GDBusWatchFunction function, diff --git a/gdbus/object.c b/gdbus/object.c index fbcc8131..dcda5489 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -522,7 +522,7 @@ static gboolean check_signal(DBusConnection *conn, const char *path, return TRUE; } -dbus_bool_t dbus_connection_emit_signal_valist(DBusConnection *conn, +static dbus_bool_t emit_signal_valist(DBusConnection *conn, const char *path, const char *interface, const char *name, @@ -570,8 +570,7 @@ dbus_bool_t dbus_connection_emit_signal(DBusConnection *conn, const char *path, va_list var_args; va_start(var_args, first); - ret = dbus_connection_emit_signal_valist(conn, path, interface, name, - first, var_args); + ret = emit_signal_valist(conn, path, interface, name, first, var_args); va_end(var_args); return ret; @@ -800,3 +799,28 @@ gboolean g_dbus_send_reply(DBusConnection *connection, return result; } + +gboolean g_dbus_emit_signal(DBusConnection *connection, + const char *path, const char *interface, + const char *name, int type, ...) +{ + va_list args; + gboolean result; + + va_start(args, type); + + result = emit_signal_valist(connection, path, interface, + name, type, args); + + va_end(args); + + return result; +} + +gboolean g_dbus_emit_signal_valist(DBusConnection *connection, + const char *path, const char *interface, + const char *name, int type, va_list args) +{ + return emit_signal_valist(connection, path, interface, + name, type, args); +} -- cgit From e26cc82994acb2b8acfe24f29825b7f5326f9673 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 19:32:20 +0000 Subject: Remove another obsolete function --- gdbus/gdbus.h | 3 --- gdbus/object.c | 14 -------------- 2 files changed, 17 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 0ec90dcb..c2c75ec5 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -52,9 +52,6 @@ void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, va_list var_args); void dbus_message_iter_append_dict(DBusMessageIter *iter, const char *first_key, ...); -dbus_bool_t dbus_connection_emit_signal(DBusConnection *conn, const char *path, - const char *interface, const char *name, - int first, ...); dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, const char *path, diff --git a/gdbus/object.c b/gdbus/object.c index dcda5489..6339328a 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -562,20 +562,6 @@ fail: return ret; } -dbus_bool_t dbus_connection_emit_signal(DBusConnection *conn, const char *path, - const char *interface, const char *name, - int first, ...) -{ - dbus_bool_t ret; - va_list var_args; - - va_start(var_args, first); - ret = emit_signal_valist(conn, path, interface, name, first, var_args); - va_end(var_args); - - return ret; -} - dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, const char *path, const char *interface, -- cgit From 957b231578f267c158aad42662d8ebbe916aab2d Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 19:35:09 +0000 Subject: Don't consider mainloop integration of dbus-glib --- gdbus/mainloop.c | 14 -------------- 1 file changed, 14 deletions(-) (limited to 'gdbus') diff --git a/gdbus/mainloop.c b/gdbus/mainloop.c index 36abbf33..ddcacedc 100644 --- a/gdbus/mainloop.c +++ b/gdbus/mainloop.c @@ -34,10 +34,6 @@ #define dbus_watch_get_unix_fd dbus_watch_get_fd #endif -#ifdef HAVE_DBUS_GLIB -#include -#endif - #include "gdbus.h" #define DISPATCH_TIMEOUT 0 @@ -46,7 +42,6 @@ #define error(fmt...) #define debug(fmt...) -#ifndef HAVE_DBUS_GLIB typedef struct { uint32_t id; DBusTimeout *timeout; @@ -63,7 +58,6 @@ struct server_info { GIOChannel *io; DBusServer *server; }; -#endif struct disconnect_data { void (*disconnect_cb)(void *); @@ -85,7 +79,6 @@ static DBusHandlerResult disconnect_filter(DBusConnection *conn, return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } -#ifndef HAVE_DBUS_GLIB static gboolean message_dispatch_cb(void *data) { DBusConnection *connection = data; @@ -233,15 +226,9 @@ static void dispatch_status_cb(DBusConnection *conn, if (new_status == DBUS_DISPATCH_DATA_REMAINS) g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, data); } -#endif static void setup_dbus_with_main_loop(DBusConnection *conn) { -#ifdef HAVE_DBUS_GLIB - debug("Using D-Bus GLib connection setup"); - - dbus_connection_setup_with_g_main(conn, NULL); -#else dbus_connection_set_watch_functions(conn, add_watch, remove_watch, watch_toggled, conn, NULL); @@ -250,7 +237,6 @@ static void setup_dbus_with_main_loop(DBusConnection *conn) dbus_connection_set_dispatch_status_function(conn, dispatch_status_cb, conn, NULL); -#endif } DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name, -- cgit From a80ddb03c8b75d36cf26c639c12f1f6ed693ab69 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 19:42:42 +0000 Subject: Remove unused defines --- gdbus/gdbus.h | 3 --- 1 file changed, 3 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index c2c75ec5..969cb66f 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -40,9 +40,6 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, GDBusWatchFunction function, void *user_data, DBusFreeFunction destroy); -#define DBUS_TYPE_STRING_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING) -#define DBUS_TYPE_BYTE_ARRAY_AS_STRING (DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING) - void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val); void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, -- cgit From 7abfb49cae784002c5a2326a3a1ab5cb8076a1f0 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 19:44:44 +0000 Subject: Make helper function static and local --- gdbus/gdbus.h | 2 -- gdbus/object.c | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 969cb66f..efa045e1 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -40,8 +40,6 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, GDBusWatchFunction function, void *user_data, DBusFreeFunction destroy); -void dbus_message_iter_append_variant(DBusMessageIter *iter, - int type, void *val); void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, const char *key, int type, void *val); void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, diff --git a/gdbus/object.c b/gdbus/object.c index 6339328a..cad97447 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -373,7 +373,7 @@ static void object_path_unref(DBusConnection *connection, const char *path) dbus_connection_unregister_object_path(connection, path); } -void dbus_message_iter_append_variant(DBusMessageIter *iter, +static void dbus_message_iter_append_variant(DBusMessageIter *iter, int type, void *val) { DBusMessageIter value; -- cgit From 012cac6d32c56eac1d4f8dbc6051b2450e809efc Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 19:48:45 +0000 Subject: Remove another unused function --- gdbus/gdbus.h | 2 -- gdbus/object.c | 10 ---------- 2 files changed, 12 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index efa045e1..84e7e1ae 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -45,8 +45,6 @@ void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, const char *first_key, va_list var_args); -void dbus_message_iter_append_dict(DBusMessageIter *iter, - const char *first_key, ...); dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, const char *path, diff --git a/gdbus/object.c b/gdbus/object.c index cad97447..61b46a26 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -473,16 +473,6 @@ void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, dbus_message_iter_close_container(iter, &dict); } -void dbus_message_iter_append_dict(DBusMessageIter *iter, - const char *first_key, ...) -{ - va_list var_args; - - va_start(var_args, first_key); - dbus_message_iter_append_dict_valist(iter, first_key, var_args); - va_end(var_args); -} - static gboolean check_signal(DBusConnection *conn, const char *path, const char *interface, const char *name, const char **args) -- cgit From a1a65a6821bddc4d3e076b8600e4bd497a64d162 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 19:53:51 +0000 Subject: Don't abstract functions that are only used once --- gdbus/gdbus.h | 3 --- gdbus/object.c | 25 ------------------------- 2 files changed, 28 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index 84e7e1ae..ffa5cf19 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -42,9 +42,6 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, const char *key, int type, void *val); -void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, - const char *first_key, - va_list var_args); dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, const char *path, diff --git a/gdbus/object.c b/gdbus/object.c index 61b46a26..8e362be5 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -448,31 +448,6 @@ void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, dbus_message_iter_close_container(dict, &entry); } -void dbus_message_iter_append_dict_valist(DBusMessageIter *iter, - const char *first_key, - va_list var_args) -{ - DBusMessageIter dict; - const char *key; - int type; - void *val; - - dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, - DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING - DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING - DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); - - key = first_key; - while (key) { - type = va_arg(var_args, int); - val = va_arg(var_args, void *); - dbus_message_iter_append_dict_entry(&dict, key, type, val); - key = va_arg(var_args, char *); - } - - dbus_message_iter_close_container(iter, &dict); -} - static gboolean check_signal(DBusConnection *conn, const char *path, const char *interface, const char *name, const char **args) -- cgit From 22ec945f109d9d1e21a8cfbc6e2dec3dd4b88c8e Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sat, 7 Jun 2008 20:09:25 +0000 Subject: Move some D-Bus helpers around --- gdbus/gdbus.h | 13 +------ gdbus/object.c | 117 --------------------------------------------------------- 2 files changed, 2 insertions(+), 128 deletions(-) (limited to 'gdbus') diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h index ffa5cf19..eefd3734 100644 --- a/gdbus/gdbus.h +++ b/gdbus/gdbus.h @@ -40,15 +40,6 @@ gboolean g_dbus_set_disconnect_function(DBusConnection *connection, GDBusWatchFunction function, void *user_data, DBusFreeFunction destroy); -void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, - const char *key, int type, void *val); - -dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, - const char *path, - const char *interface, - const char *name, - int type, void *value); - typedef void (* GDBusDestroyFunction) (void *user_data); typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection, @@ -100,10 +91,10 @@ gboolean g_dbus_unregister_interface(DBusConnection *connection, gboolean g_dbus_unregister_all_interfaces(DBusConnection *connection, const char *path); -DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, - const char *format, va_list args); DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name, const char *format, ...); +DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, + const char *format, va_list args); DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...); DBusMessage *g_dbus_create_reply_valist(DBusMessage *message, int type, va_list args); diff --git a/gdbus/object.c b/gdbus/object.c index 8e362be5..09a841e5 100644 --- a/gdbus/object.c +++ b/gdbus/object.c @@ -373,81 +373,6 @@ static void object_path_unref(DBusConnection *connection, const char *path) dbus_connection_unregister_object_path(connection, path); } -static void dbus_message_iter_append_variant(DBusMessageIter *iter, - int type, void *val) -{ - DBusMessageIter value; - DBusMessageIter array; - char *sig; - - switch (type) { - case DBUS_TYPE_STRING: - sig = DBUS_TYPE_STRING_AS_STRING; - break; - case DBUS_TYPE_BYTE: - sig = DBUS_TYPE_BYTE_AS_STRING; - break; - case DBUS_TYPE_INT16: - sig = DBUS_TYPE_INT16_AS_STRING; - break; - case DBUS_TYPE_UINT16: - sig = DBUS_TYPE_UINT16_AS_STRING; - break; - case DBUS_TYPE_INT32: - sig = DBUS_TYPE_INT32_AS_STRING; - break; - case DBUS_TYPE_UINT32: - sig = DBUS_TYPE_UINT32_AS_STRING; - break; - case DBUS_TYPE_BOOLEAN: - sig = DBUS_TYPE_BOOLEAN_AS_STRING; - break; - case DBUS_TYPE_ARRAY: - sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING; - break; - case DBUS_TYPE_OBJECT_PATH: - sig = DBUS_TYPE_OBJECT_PATH_AS_STRING; - break; - default: - error("Could not append variant with type %d", type); - return; - } - - dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, sig, &value); - - if (type == DBUS_TYPE_ARRAY) { - int i; - const char ***str_array = val; - - dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, - DBUS_TYPE_STRING_AS_STRING, &array); - - for (i = 0; (*str_array)[i]; i++) - dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, - &((*str_array)[i])); - - dbus_message_iter_close_container(&value, &array); - } else - dbus_message_iter_append_basic(&value, type, val); - - dbus_message_iter_close_container(iter, &value); -} - -void dbus_message_iter_append_dict_entry(DBusMessageIter *dict, - const char *key, int type, void *val) -{ - DBusMessageIter entry; - - dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, - NULL, &entry); - - dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); - - dbus_message_iter_append_variant(&entry, type, val); - - dbus_message_iter_close_container(dict, &entry); -} - static gboolean check_signal(DBusConnection *conn, const char *path, const char *interface, const char *name, const char **args) @@ -527,48 +452,6 @@ fail: return ret; } -dbus_bool_t dbus_connection_emit_property_changed(DBusConnection *conn, - const char *path, - const char *interface, - const char *name, - int type, void *value) -{ - DBusMessage *signal; - DBusMessageIter iter; - gboolean ret; - const char *signature, *args; - - if (!check_signal(conn, path, interface, "PropertyChanged", &args)) - return FALSE; - - signal = dbus_message_new_signal(path, interface, "PropertyChanged"); - - if (!signal) { - error("Unable to allocate new %s.PropertyChanged signal", - interface); - return FALSE; - } - - dbus_message_iter_init_append(signal, &iter); - - dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); - dbus_message_iter_append_variant(&iter, type, value); - - signature = dbus_message_get_signature(signal); - if (strcmp(args, signature) != 0) { - error("%s.%s: expected signature'%s' but got '%s'", - interface, name, args, signature); - ret = FALSE; - goto fail; - } - - ret = dbus_connection_send(conn, signal, NULL); - -fail: - dbus_message_unref(signal); - return ret; -} - gboolean g_dbus_register_interface(DBusConnection *connection, const char *path, const char *name, GDBusMethodTable *methods, -- cgit From 1008177538c7f2fac766d6144b7f653719c56328 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sun, 8 Jun 2008 13:42:27 +0000 Subject: Avoid a watch id of 0 --- gdbus/watch.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'gdbus') diff --git a/gdbus/watch.c b/gdbus/watch.c index 3c7a03a4..1e66f542 100644 --- a/gdbus/watch.c +++ b/gdbus/watch.c @@ -37,7 +37,7 @@ #define error(fmt...) #define debug(fmt...) -static guint listener_id = 0; +static guint listener_id = 1; static GSList *name_listeners = NULL; struct name_callback { @@ -297,6 +297,9 @@ gboolean g_dbus_remove_watch(DBusConnection *connection, guint id) struct name_callback *cb; GSList *ldata, *lcb; + if (id == 0) + return FALSE; + for (ldata = name_listeners; ldata; ldata = ldata->next) { data = ldata->data; for (lcb = data->callbacks; lcb; lcb = lcb->next) { -- cgit From 24d6b3d375b51044e0185c52a1ea172774a0ec47 Mon Sep 17 00:00:00 2001 From: Marcel Holtmann Date: Sun, 8 Jun 2008 14:01:39 +0000 Subject: Revert wrong listner id counter offset --- gdbus/watch.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'gdbus') diff --git a/gdbus/watch.c b/gdbus/watch.c index 1e66f542..b451cb00 100644 --- a/gdbus/watch.c +++ b/gdbus/watch.c @@ -37,7 +37,7 @@ #define error(fmt...) #define debug(fmt...) -static guint listener_id = 1; +static guint listener_id = 0; static GSList *name_listeners = NULL; struct name_callback { -- cgit