HGKeeper

* gaim

* 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

* source distribution.

* 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 <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "account.h"

#include "blist.h"

#include "conversation.h"

#include "dbus-gaim.h"

#include "dbus-server.h"

#include "dbus-useful.h"

#include "dbus-bindings.h"

#include "debug.h"

#include "core.h"

#include "internal.h"

#include "savedstatuses.h"

#include "util.h"

#include "value.h"

#include "xmlnode.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-analyze-types.py script.

#include "dbus-types.c"

* 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;

static gchar *init_error;

/**

* 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)

{

static gint last_id = 0;

g_return_if_fail(map_node_id);

g_return_if_fail(g_hash_table_lookup(map_node_id, node) == NULL);

last_id++;

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));

if ((id == 0) && (node != NULL))

{

gaim_debug_warning("dbus",

"Need to register an object with the dbus subsystem.\n");

g_return_val_if_reached(0);

}

return id;

}

gpointer

gaim_dbus_id_to_pointer(gint id, GaimDBusType *type)

{

GaimDBusType *objtype;

objtype = (GaimDBusType*)g_hash_table_lookup(map_id_type,

GINT_TO_POINTER(id));

while (objtype != type && objtype != NULL)

objtype = objtype->parent;

if (objtype == type)

return g_hash_table_lookup(map_id_node, GINT_TO_POINTER(id));

else

return NULL;

}

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)");

return id;

}

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);

return ptr;

}

/**************************************************************************/

/** @name Modified versions of some DBus functions */

/**************************************************************************/

dbus_bool_t

gaim_dbus_message_get_args(DBusMessage *message,

DBusError *error, int first_arg_type, ...)

{

dbus_bool_t retval;

va_list var_args;

va_start(var_args, first_arg_type);

retval = gaim_dbus_message_get_args_valist(message, error, first_arg_type, var_args);

va_end(var_args);

return retval;

}

dbus_bool_t

gaim_dbus_message_get_args_valist(DBusMessage *message,

DBusError *error, int first_arg_type, va_list var_args)

{

DBusMessageIter iter;

dbus_message_iter_init(message, &iter);

return gaim_dbus_message_iter_get_args_valist(&iter, error, first_arg_type, var_args);

}

dbus_bool_t

gaim_dbus_message_iter_get_args(DBusMessageIter *iter,

DBusError *error, int first_arg_type, ...)

{

dbus_bool_t retval;

va_list var_args;

va_start(var_args, first_arg_type);

retval = gaim_dbus_message_iter_get_args_valist(iter, error, first_arg_type, var_args);

va_end(var_args);

return retval;

}

#define TYPE_IS_CONTAINER(typecode) \

((typecode) == DBUS_TYPE_STRUCT || \

(typecode) == DBUS_TYPE_DICT_ENTRY || \

(typecode) == DBUS_TYPE_VARIANT || \

(typecode) == DBUS_TYPE_ARRAY)

dbus_bool_t

gaim_dbus_message_iter_get_args_valist(DBusMessageIter *iter,

DBusError *error, int first_arg_type, va_list var_args)

{

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,

spec_type, msg_type);

return FALSE;

}

if (!TYPE_IS_CONTAINER(spec_type))

{

gpointer ptr;

ptr = va_arg (var_args, gpointer);

dbus_message_iter_get_basic(iter, ptr);

}

else

{

DBusMessageIter *sub;

sub = va_arg (var_args, DBusMessageIter*);

dbus_message_iter_recurse(iter, sub);

gaim_debug_info("dbus", "subiter %p:%p\n", sub, * (gpointer*) 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);

return FALSE;

}

return TRUE;

}

/**************************************************************************/

/** @name Useful functions */

/**************************************************************************/

const char *empty_to_null(const char *str)

{

if (str == NULL || str[0] == 0)

return NULL;

else

return str;

}

const char *

null_to_empty(const char *s)

{

if (s)

return s;

else

return "";

}

dbus_int32_t *

gaim_dbusify_GList(GList *list, gboolean free_memory, dbus_int32_t *len)

{

dbus_int32_t *array;

int i;

GList *elem;

*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);

if (free_memory)

g_list_free(list);

return array;

}

dbus_int32_t *

gaim_dbusify_GSList(GSList *list, gboolean free_memory, dbus_int32_t *len)

{

dbus_int32_t *array;

int i;

GSList *elem;

*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);

if (free_memory)

g_slist_free(list);

return array;

}

gpointer *

gaim_GList_to_array(GList *list, gboolean free_memory, dbus_int32_t *len)

{

gpointer *array;

int i;

GList *elem;

*len = g_list_length(list);

array = g_new0(gpointer, g_list_length(list));

for (i = 0, elem = list; elem != NULL; elem = elem->next, i++)

array[i] = elem->data;

if (free_memory)

g_list_free(list);

return array;

}

gpointer *

gaim_GSList_to_array(GSList *list, gboolean free_memory, dbus_int32_t *len)

{

gpointer *array;

int i;

GSList *elem;

*len = g_slist_length(list);

array = g_new0(gpointer, g_slist_length(list));

for (i = 0, elem = list; elem != NULL; elem = elem->next, i++)

array[i] = elem->data;

if (free_memory)

g_slist_free(list);

return array;

}

GHashTable *

gaim_dbus_iter_hash_table(DBusMessageIter *iter, DBusError *error)

{

GHashTable *hash;

/* 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);

do {

char *key, *value;

DBusMessageIter subiter;

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, &key,

DBUS_TYPE_STRING, &value,

DBUS_TYPE_INVALID))

goto error; /* same here */

g_hash_table_insert(hash, key, value);

} while (dbus_message_iter_next(iter));

return hash;

error:

g_hash_table_destroy(hash);

return NULL;

}

/**************************************************************/

/* DBus bindings ... */

/**************************************************************/

static DBusConnection *gaim_dbus_connection;

DBusConnection *

gaim_dbus_get_connection(void)

{

return gaim_dbus_connection;

}

#include "dbus-bindings.c"

static gboolean

gaim_dbus_dispatch_cb(DBusConnection *connection,

DBusMessage *message, void *user_data)

{

const char *name;

GaimDBusBinding *bindings;

int i;

bindings = (GaimDBusBinding*) user_data;

if (!dbus_message_has_path(message, DBUS_PATH_GAIM))

return FALSE;

name = dbus_message_get_member(message);

if (name == NULL)

return FALSE;

if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL)

return FALSE;

for (i = 0; bindings[i].name; i++)

if (!strcmp(name, bindings[i].name))

{

DBusMessage *reply;

DBusError error;

dbus_error_init(&error);

reply = bindings[i].handler(message, &error);

if (reply == NULL && dbus_error_is_set(&error))

reply = dbus_message_new_error (message,

error.name, error.message);

if (reply != NULL)

{

dbus_connection_send(connection, reply, NULL);

dbus_message_unref(reply);

}

return TRUE; /* return reply! */

}

return FALSE;

}

static const char *

dbus_gettext(const char **ptr)

{

const char *text = *ptr;

*ptr += strlen(text) + 1;

return text;

}

static void

gaim_dbus_introspect_cb(GList **bindings_list, void *bindings)

{

*bindings_list = g_list_prepend(*bindings_list, bindings);

}

static DBusMessage *gaim_dbus_introspect(DBusMessage *message)

{

DBusMessage *reply;

GString *str;

GList *bindings_list, *node;

str = g_string_sized_new(0x1000); /* TODO: 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);

bindings_list = NULL;

gaim_signal_emit(gaim_dbus_get_handle(), "dbus-introspect", &bindings_list);

for (node = bindings_list; node; node = node->next)

{

GaimDBusBinding *bindings;

int i;

bindings = (GaimDBusBinding*)node->data;

for (i = 0; bindings[i].name; i++)

{

const char *text;

g_string_append_printf(str, "<method name='%s'>\n", bindings[i].name);

text = bindings[i].parameters;

while (*text)

{

const char *name, *direction, *type;

direction = dbus_gettext(&text);

type = dbus_gettext(&text);

name = dbus_gettext(&text);

g_string_append_printf(str,

"<arg name='%s' type='%s' direction='%s'/>\n",

name, type, direction);

}

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),

DBUS_TYPE_INVALID);

g_string_free(str, TRUE);

g_list_free(bindings_list);

return reply;

}

static DBusHandlerResult

gaim_dbus_dispatch(DBusConnection *connection,

DBusMessage *message, void *user_data)

{

if (gaim_signal_emit_return_1(gaim_dbus_get_handle(),

"dbus-method-called", connection, message))

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"))

{

DBusMessage *reply;

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",

handle,

GAIM_CALLBACK(gaim_dbus_dispatch_cb),

bindings);

gaim_signal_connect(gaim_dbus_get_handle(), "dbus-introspect",

handle,

GAIM_CALLBACK(gaim_dbus_introspect_cb),

bindings);

}

static void

gaim_dbus_dispatch_init(void)

{

static DBusObjectPathVTable vtable = {NULL, &gaim_dbus_dispatch, NULL, NULL, NULL, NULL};

DBusError error;

int result;

dbus_error_init(&error);

gaim_dbus_connection = dbus_bus_get(DBUS_BUS_STARTER, &error);

if (gaim_dbus_connection == NULL)

{

init_error = g_strdup_printf(N_("Failed to get connection: %s"), error.message);

dbus_error_free(&error);

return;

}

/* Do not allow libdbus to exit on connection failure (This may

work around random exit(1) on SIGPIPE errors) */

dbus_connection_set_exit_on_disconnect (gaim_dbus_connection, FALSE);

if (!dbus_connection_register_object_path(gaim_dbus_connection,

DBUS_PATH_GAIM, &vtable, NULL))

{

init_error = g_strdup_printf(N_("Failed to get name: %s"), error.name);

dbus_error_free(&error);

return;

}

result = dbus_bus_request_name(gaim_dbus_connection,

DBUS_SERVICE_GAIM, 0, &error);

if (dbus_error_is_set(&error))

{

dbus_connection_unref(gaim_dbus_connection);

dbus_error_free(&error);

gaim_dbus_connection = NULL;

init_error = g_strdup_printf(N_("Failed to get serv name: %s"), error.name);

return;

}

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());

}

/**************************************************************************/

/** @name Signals */

/**************************************************************************/

static char *

gaim_dbus_convert_signal_name(const char *gaim_name)

{

int gaim_index, g_index;

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] != '_')

{

if (capitalize_next)

g_name[g_index++] = g_ascii_toupper(gaim_name[gaim_index]);

else

g_name[g_index++] = gaim_name[gaim_index];

capitalize_next = FALSE;

} else

capitalize_next = TRUE;

g_name[g_index] = 0;

return g_name;

}

#define my_arg(type) (ptr != NULL ? * ((type *)ptr) : va_arg(data, type))

static void

gaim_dbus_message_append_gaim_values(DBusMessageIter *iter,

int number, GaimValue **gaim_values, va_list data)

{

int i;

for (i = 0; i < number; i++)

{

const char *str;

int id;

gint xint;

guint xuint;

gboolean xboolean;

gpointer ptr = NULL;

if (gaim_value_is_outgoing(gaim_values[i]))

{

ptr = my_arg(gpointer);

g_return_if_fail(ptr);

}

switch (gaim_values[i]->type)

{

case GAIM_TYPE_INT:

xint = my_arg(gint);

dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &xint);

break;

case GAIM_TYPE_UINT:

xuint = my_arg(guint);

dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &xuint);

break;

case GAIM_TYPE_BOOLEAN:

xboolean = my_arg(gboolean);

dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &xboolean);

break;

case GAIM_TYPE_STRING:

str = null_to_empty(my_arg(char*));

if (!g_utf8_validate(str, -1, NULL)) {

gchar *tmp;

gaim_debug_error("dbus", "Invalid UTF-8 string passed to signal, emitting salvaged string!\n");

tmp = gaim_utf8_salvage(str);

dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &tmp);

g_free(tmp);

} else {

dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);

}

break;

case GAIM_TYPE_SUBTYPE: /* registered pointers only! */

case GAIM_TYPE_POINTER:

case GAIM_TYPE_OBJECT:

case GAIM_TYPE_BOXED:

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);

break;

default: /* no conversion implemented */

g_return_if_reached();

}

#undef my_arg

void

gaim_dbus_signal_emit_gaim(const char *name, int num_values,

GaimValue **values, va_list vargs)

{

DBusMessage *signal;

DBusMessageIter iter;

char *newname;

#if 0 /* this is noisy with no dbus connection */

g_return_if_fail(gaim_dbus_connection);

#else

if (gaim_dbus_connection == NULL)

return;

#endif

* 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"))

return;

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);

g_free(newname);

dbus_message_unref(signal);

}

const char *

gaim_dbus_get_init_error(void)

{

return init_error;

}

void *

gaim_dbus_get_handle(void)

{

static int handle;

return &handle;

}

void

gaim_dbus_init(void)

{

gaim_dbus_init_ids();

g_free(init_error);

init_error = NULL;

gaim_dbus_dispatch_init();

if (init_error != NULL)

gaim_debug_error("dbus", "%s\n", init_error);

}

void

gaim_dbus_uninit(void)

{

/* Surely we must do SOME kind of uninitialization? */

g_free(init_error);

init_error = NULL;

}

pidgin/pidgin