* Gaim is the legal property of its developers, whose names are too numerous * to list here. Please refer to the COPYRIGHT file distributed with this * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA #define DBUS_API_SUBJECT_TO_CHANGE #include "conversation.h" #include "dbus-bindings.h" /**************************************************************************/ /** @name Gaim DBUS pointer registration mechanism */ /**************************************************************************/ Here we include the list of #GAIM_DBUS_DEFINE_TYPE statements for all structs defined in gaim. This file has been generated by the #dbus-analize-types.py script. /* The following three hashtables map are used to translate between pointers (nodes) and the corresponding handles (ids). */ static GHashTable *map_node_id; static GHashTable *map_id_node; static GHashTable *map_id_type; /* This function initializes the pointer-id traslation system. It creates the three above hashtables and defines parents of some types. void gaim_dbus_init_ids(void) { map_id_node = g_hash_table_new (g_direct_hash, g_direct_equal); map_id_type = g_hash_table_new (g_direct_hash, g_direct_equal); map_node_id = g_hash_table_new (g_direct_hash, g_direct_equal); GAIM_DBUS_TYPE(GaimBuddy)->parent = GAIM_DBUS_TYPE(GaimBlistNode); GAIM_DBUS_TYPE(GaimContact)->parent = GAIM_DBUS_TYPE(GaimBlistNode); GAIM_DBUS_TYPE(GaimChat)->parent = GAIM_DBUS_TYPE(GaimBlistNode); GAIM_DBUS_TYPE(GaimGroup)->parent = GAIM_DBUS_TYPE(GaimBlistNode); void gaim_dbus_register_pointer(gpointer node, GaimDBusType *type) g_return_if_fail(map_node_id); g_return_if_fail(g_hash_table_lookup(map_node_id, node) == NULL); g_hash_table_insert(map_node_id, node, GINT_TO_POINTER(last_id)); g_hash_table_insert(map_id_node, GINT_TO_POINTER(last_id), node); g_hash_table_insert(map_id_type, GINT_TO_POINTER(last_id), type); void gaim_dbus_unregister_pointer(gpointer node) { gpointer id = g_hash_table_lookup(map_node_id, node); g_hash_table_remove(map_node_id, node); g_hash_table_remove(map_id_node, GINT_TO_POINTER(id)); g_hash_table_remove(map_id_type, GINT_TO_POINTER(id)); gint gaim_dbus_pointer_to_id(gpointer node) { gint id = GPOINTER_TO_INT(g_hash_table_lookup(map_node_id, node)); g_return_val_if_fail(id || node == NULL, 0); gpointer gaim_dbus_id_to_pointer(gint id, GaimDBusType *type) { (GaimDBusType*) g_hash_table_lookup(map_id_type, while (objtype != type && objtype != NULL) objtype = objtype->parent; return g_hash_table_lookup(map_id_node, GINT_TO_POINTER(id)); gint gaim_dbus_pointer_to_id_error(gpointer ptr, DBusError *error) gint id = gaim_dbus_pointer_to_id(ptr); if (ptr != NULL && id == 0) dbus_set_error(error, "net.sf.gaim.ObjectNotFound", "The return object is not mapped (this is a Gaim error)"); gpointer gaim_dbus_id_to_pointer_error(gint id, GaimDBusType *type, const char *typename, DBusError *error) gpointer ptr = gaim_dbus_id_to_pointer(id, type); if (ptr == NULL && id != 0) dbus_set_error(error, "net.sf.gaim.InvalidHandle", "%s object with ID = %i not found", typename, id); /**************************************************************************/ /** @name Modified versions of some DBus functions */ /**************************************************************************/ gaim_dbus_message_get_args (DBusMessage *message, va_start (var_args, first_arg_type); retval = gaim_dbus_message_get_args_valist (message, error, first_arg_type, var_args); gaim_dbus_message_get_args_valist (DBusMessage *message, dbus_message_iter_init (message, &iter); return gaim_dbus_message_iter_get_args_valist (&iter, error, first_arg_type, var_args); gaim_dbus_message_iter_get_args(DBusMessageIter *iter, va_start (var_args, first_arg_type); retval = gaim_dbus_message_iter_get_args_valist(iter, error, first_arg_type, var_args); #define TYPE_IS_CONTAINER(typecode) \ ((typecode) == DBUS_TYPE_STRUCT || \ (typecode) == DBUS_TYPE_DICT_ENTRY || \ (typecode) == DBUS_TYPE_VARIANT || \ (typecode) == DBUS_TYPE_ARRAY) gaim_dbus_message_iter_get_args_valist (DBusMessageIter *iter, int spec_type, msg_type, i; spec_type = first_arg_type; for(i=0; spec_type != DBUS_TYPE_INVALID; i++) { msg_type = dbus_message_iter_get_arg_type (iter); if (msg_type != spec_type) { dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, "Argument %d is specified to be of type \"%i\", but " "is actually of type \"%i\"\n", i, if (!TYPE_IS_CONTAINER(spec_type)) { ptr = va_arg (var_args, gpointer); dbus_message_iter_get_basic(iter, ptr); sub = va_arg (var_args, DBusMessageIter*); dbus_message_iter_recurse(iter, sub); g_print("subiter %i:%i\n", (int) sub, * (int*) sub); break; /* for testing only! */ spec_type = va_arg (var_args, int); if (!dbus_message_iter_next(iter) && spec_type != DBUS_TYPE_INVALID) { dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, "Message has only %d arguments, but more were expected", i); /**************************************************************************/ /** @name Useful functions */ /**************************************************************************/ const char* empty_to_null(const char *str) { if (str == NULL || str[0] == 0) const char* null_to_empty(const char *s) { dbus_int32_t* gaim_dbusify_GList(GList *list, gboolean free_memory, *len = g_list_length(list); array = g_new0(dbus_int32_t, g_list_length(list)); for(i = 0, elem = list; elem != NULL; elem = elem->next, i++) array[i] = gaim_dbus_pointer_to_id(elem->data); dbus_int32_t* gaim_dbusify_GSList(GSList *list, gboolean free_memory, *len = g_slist_length(list); array = g_new0(dbus_int32_t, g_slist_length(list)); for(i = 0, elem = list; elem != NULL; elem = elem->next, i++) array[i] = gaim_dbus_pointer_to_id(elem->data); gpointer* gaim_GList_to_array(GList *list, gboolean free_memory, *len = g_list_length(list); array = g_new0(gpointer, g_list_length(list)); for(i = 0, elem = list; elem != NULL; elem = elem->next, i++) gpointer* gaim_GSList_to_array(GSList *list, gboolean free_memory, *len = g_slist_length(list); array = g_new0(gpointer, g_slist_length(list)); for(i = 0, elem = list; elem != NULL; elem = elem->next, i++) GHashTable *gaim_dbus_iter_hash_table(DBusMessageIter *iter, DBusError *error) { /* we do not need to destroy strings because they are part of the message */ hash = g_hash_table_new(g_str_hash, g_str_equal); if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_DICT_ENTRY) goto error; /* With all due respect to Dijkstra, this goto is for exception handling, and it is ok because it avoids duplication of the code responsible for destroying the hash table. Exceptional instructions for exceptional situations. */ dbus_message_iter_recurse(iter, &subiter); if (!gaim_dbus_message_iter_get_args(&subiter, error, DBUS_TYPE_STRING, &value, goto error; /* same here */ g_hash_table_insert(hash, key, value); } while (dbus_message_iter_next(iter)); g_hash_table_destroy(hash); /**************************************************************/ /**************************************************************/ static DBusConnection *gaim_dbus_connection; DBusConnection *gaim_dbus_get_connection(void) { return gaim_dbus_connection; #include "dbus-bindings.c" void *gaim_dbus_get_handle(void) { gaim_dbus_dispatch_cb(DBusConnection *connection, GaimDBusBinding *bindings; bindings = (GaimDBusBinding*) user_data; if (!dbus_message_has_path(message, DBUS_PATH_GAIM)) name = dbus_message_get_member(message); if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL) for(i=0; bindings[i].name; i++) if (!strcmp(name, bindings[i].name)) { reply = bindings[i].handler(message, &error); if (reply == NULL && dbus_error_is_set(&error)) reply = dbus_message_new_error (message, dbus_connection_send (connection, reply, NULL); dbus_message_unref(reply); return TRUE; /* return reply! */ static const char *gettext(const char **ptr) { *ptr += strlen(text) + 1; gaim_dbus_introspect_cb(GList **bindings_list, void *bindings) { *bindings_list = g_list_prepend(*bindings_list, bindings); static DBusMessage *gaim_dbus_introspect(DBusMessage *message) GList *bindings_list, *node; str = g_string_sized_new(0x1000); /* fixme: why this size? */ g_string_append(str, "<!DOCTYPE node PUBLIC '-//freedesktop//DTD D-BUS Object Introspection 1.0//EN' 'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd'>\n"); g_string_append_printf(str, "<node name='%s'>\n", DBUS_PATH_GAIM); g_string_append_printf(str, "<interface name='%s'>\n", DBUS_INTERFACE_GAIM); gaim_signal_emit(gaim_dbus_get_handle(), "dbus-introspect", &bindings_list); for(node = bindings_list; node; node = node->next) { GaimDBusBinding *bindings; bindings = (GaimDBusBinding*) node->data; for(i=0; bindings[i].name; i++) { g_string_append_printf(str, "<method name='%s'>\n", bindings[i].name); text = bindings[i].parameters; const char *name, *direction, *type; direction = gettext(&text); g_string_append_printf(str, "<arg name='%s' type='%s' direction='%s'/>\n", g_string_append(str, "</method>\n"); g_string_append(str, "</interface>\n</node>\n"); reply = dbus_message_new_method_return (message); dbus_message_append_args(reply, DBUS_TYPE_STRING, &(str->str), g_string_free(str, TRUE); g_list_free(bindings_list); static DBusHandlerResult gaim_dbus_dispatch(DBusConnection *connection, if (gaim_signal_emit_return_1(gaim_dbus_get_handle(), return DBUS_HANDLER_RESULT_HANDLED; if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL && dbus_message_has_path(message, DBUS_PATH_GAIM) && dbus_message_has_interface(message, DBUS_INTERFACE_INTROSPECTABLE) && dbus_message_has_member(message, "Introspect")) reply = gaim_dbus_introspect(message); dbus_connection_send (connection, reply, NULL); dbus_message_unref(reply); return DBUS_HANDLER_RESULT_HANDLED; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; void gaim_dbus_register_bindings(void *handle, GaimDBusBinding *bindings) { gaim_signal_connect(gaim_dbus_get_handle(), "dbus-method-called", GAIM_CALLBACK(gaim_dbus_dispatch_cb), gaim_signal_connect(gaim_dbus_get_handle(), "dbus-introspect", GAIM_CALLBACK(gaim_dbus_introspect_cb), static gboolean gaim_dbus_dispatch_init(void) static DBusObjectPathVTable vtable = {NULL, &gaim_dbus_dispatch, NULL, NULL, NULL, NULL}; dbus_error_init (&error); gaim_dbus_connection = dbus_bus_get (DBUS_BUS_STARTER, &error); if (gaim_dbus_connection == NULL) { gaim_debug_error("dbus", "Failed to get connection\n"); if (!dbus_connection_register_object_path (gaim_dbus_connection, DBUS_PATH_GAIM, &vtable, NULL)) gaim_debug_error("dbus", "Failed to get name: %s\n", error.name); result = dbus_bus_request_name (gaim_dbus_connection, DBUS_SERVICE_GAIM, if (dbus_error_is_set (&error)) { dbus_connection_unref(gaim_dbus_connection); gaim_dbus_connection = NULL; gaim_debug_error("dbus", "Failed to get serv name: %s\n", error.name); dbus_connection_setup_with_g_main(gaim_dbus_connection, NULL); gaim_debug_misc ("dbus", "okkk\n"); gaim_signal_register(gaim_dbus_get_handle(), "dbus-method-called", gaim_marshal_BOOLEAN__POINTER_POINTER, gaim_value_new(GAIM_TYPE_BOOLEAN), 2, gaim_value_new(GAIM_TYPE_POINTER), gaim_value_new(GAIM_TYPE_POINTER)); gaim_signal_register(gaim_dbus_get_handle(), "dbus-introspect", gaim_marshal_VOID__POINTER, NULL, 1, gaim_value_new_outgoing(GAIM_TYPE_POINTER)); GAIM_DBUS_REGISTER_BINDINGS(gaim_dbus_get_handle()); /**************************************************************************/ /**************************************************************************/ static char *gaim_dbus_convert_signal_name(const char *gaim_name) char *g_name = g_new(char, strlen(gaim_name)+1); gboolean capitalize_next = TRUE; for(gaim_index = g_index = 0; gaim_name[gaim_index]; gaim_index++) if (gaim_name[gaim_index] != '-' && gaim_name[gaim_index] != '_') { g_name[g_index++] = g_ascii_toupper(gaim_name[gaim_index]); g_name[g_index++] = gaim_name[gaim_index]; #define my_arg(type) (ptr != NULL ? * ((type *)ptr) : va_arg(data, type)) static void gaim_dbus_message_append_gaim_values(DBusMessageIter *iter, for(i=0; i<number; i++) { if (gaim_value_is_outgoing(gaim_values[i])) { switch(gaim_values[i]->type) { dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &xint); dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &xuint); xboolean = my_arg(gboolean); dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &xboolean); str = null_to_empty(my_arg(char*)); dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str); case GAIM_TYPE_SUBTYPE: /* registered pointers only! */ id = gaim_dbus_pointer_to_id(my_arg(gpointer)); dbus_message_iter_append_basic(iter, (sizeof(void *) == 4) ? DBUS_TYPE_UINT32 : DBUS_TYPE_UINT64, &id); default: /* no conversion implemented */ void gaim_dbus_signal_emit_gaim(const char *name, int num_values, GaimValue **values, va_list vargs) #if 0 /* this is noisy with no dbus connection */ g_return_if_fail(gaim_dbus_connection); if (gaim_dbus_connection == NULL) /* The test below is a hack that prevents our "dbus-method-called" signal from being propagated to dbus. What we really need is a flag for each signal that states whether this signal is to be dbus-propagated or not. */ if (!strcmp(name, "dbus-method-called")) newname = gaim_dbus_convert_signal_name(name); signal = dbus_message_new_signal(DBUS_PATH_GAIM, DBUS_INTERFACE_GAIM, newname); dbus_message_iter_init_append(signal, &iter); gaim_dbus_message_append_gaim_values(&iter, num_values, values, vargs); dbus_connection_send(gaim_dbus_connection, signal, NULL); dbus_message_unref(signal); gboolean gaim_dbus_init(void) return gaim_dbus_dispatch_init() ;