libpurple/dbus-server.c

   1 /*
   2  * purple
   3  *
   4  * Purple is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  *
  22  */
  23
  24 #ifndef DBUS_API_SUBJECT_TO_CHANGE
  25 #define DBUS_API_SUBJECT_TO_CHANGE
  26 #endif
  27
  28 /* Allow the code below to see deprecated functions, so we can continue to
  29  * export them via DBus. */
  30 #undef PURPLE_DISABLE_DEPRECATED
  31
  32 #include "internal.h"
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37
  38 #include "account.h"
  39 #include "blist.h"
  40 #include "conversation.h"
  41 #include "dbus-purple.h"
  42 #include "dbus-server.h"
  43 #include "dbus-useful.h"
  44 #include "dbus-bindings.h"
  45 #include "debug.h"
  46 #include "core.h"
  47 #include "savedstatuses.h"
  48 #include "smiley.h"
  49 #include "util.h"
  50 #include "value.h"
  51 #include "xmlnode.h"
  52
  53
  54 /**************************************************************************/
  55 /** @name Purple DBUS pointer registration mechanism                        */
  56 /**************************************************************************/
  57
  58 /*
  59  * Here we include the list of #PURPLE_DBUS_DEFINE_TYPE statements for
  60  * all structs defined in purple.  This file has been generated by the
  61  * #dbus-analyze-types.py script.
  62  */
  63
  64 #include "dbus-types.c"
  65
  66 /*
  67  * The following three hashtables map are used to translate between
  68  * pointers (nodes) and the corresponding handles (ids).
  69  */
  70
  71 static GHashTable *map_node_id;
  72 static GHashTable *map_id_node;
  73 static GHashTable *map_id_type;
  74
  75 static gchar *init_error;
  76 static int dbus_request_name_reply = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
  77
  78 gboolean purple_dbus_is_owner(void)
  79 {
  80         return(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER == dbus_request_name_reply);
  81 }
  82
  83 /**
  84  * This function initializes the pointer-id traslation system.  It
  85  * creates the three above hashtables and defines parents of some types.
  86  */
  87 void
  88 purple_dbus_init_ids(void)
  89 {
  90         map_id_node = g_hash_table_new(g_direct_hash, g_direct_equal);
  91         map_id_type = g_hash_table_new(g_direct_hash, g_direct_equal);
  92         map_node_id = g_hash_table_new(g_direct_hash, g_direct_equal);
  93
  94         PURPLE_DBUS_TYPE(PurpleBuddy)->parent   = PURPLE_DBUS_TYPE(PurpleBlistNode);
  95         PURPLE_DBUS_TYPE(PurpleContact)->parent = PURPLE_DBUS_TYPE(PurpleBlistNode);
  96         PURPLE_DBUS_TYPE(PurpleChat)->parent    = PURPLE_DBUS_TYPE(PurpleBlistNode);
  97         PURPLE_DBUS_TYPE(PurpleGroup)->parent   = PURPLE_DBUS_TYPE(PurpleBlistNode);
  98 }
  99
 100 void
 101 purple_dbus_register_pointer(gpointer node, PurpleDBusType *type)
 102 {
 103         static gint last_id = 0;
 104
 105         g_return_if_fail(map_node_id);
 106         g_return_if_fail(g_hash_table_lookup(map_node_id, node) == NULL);
 107
 108         last_id++;
 109         g_hash_table_insert(map_node_id, node, GINT_TO_POINTER(last_id));
 110         g_hash_table_insert(map_id_node, GINT_TO_POINTER(last_id), node);
 111         g_hash_table_insert(map_id_type, GINT_TO_POINTER(last_id), type);
 112 }
 113
 114 void
 115 purple_dbus_unregister_pointer(gpointer node)
 116 {
 117         gpointer id = g_hash_table_lookup(map_node_id, node);
 118
 119         g_hash_table_remove(map_node_id, node);
 120         g_hash_table_remove(map_id_node, GINT_TO_POINTER(id));
 121         g_hash_table_remove(map_id_type, GINT_TO_POINTER(id));
 122 }
 123
 124 gint
 125 purple_dbus_pointer_to_id(gconstpointer node)
 126 {
 127         gint id = GPOINTER_TO_INT(g_hash_table_lookup(map_node_id, node));
 128         if ((id == 0) && (node != NULL))
 129         {
 130                 if (purple_debug_is_verbose())
 131                         purple_debug_warning("dbus",
 132                                 "Need to register an object with the dbus subsystem."
 133                                 " (If you are not a developer, please ignore this message.)\n");
 134                 return 0;
 135         }
 136         return id;
 137 }
 138
 139 gpointer
 140 purple_dbus_id_to_pointer(gint id, PurpleDBusType *type)
 141 {
 142         PurpleDBusType *objtype;
 143
 144         objtype = (PurpleDBusType*)g_hash_table_lookup(map_id_type,
 145                         GINT_TO_POINTER(id));
 146
 147         while (objtype != type && objtype != NULL)
 148                 objtype = objtype->parent;
 149
 150         if (objtype == type)
 151                 return g_hash_table_lookup(map_id_node, GINT_TO_POINTER(id));
 152         else
 153                 return NULL;
 154 }
 155
 156 gint
 157 purple_dbus_pointer_to_id_error(gconstpointer ptr, DBusError *error)
 158 {
 159         gint id = purple_dbus_pointer_to_id(ptr);
 160
 161         if (ptr != NULL && id == 0)
 162                 dbus_set_error(error, "im.pidgin.purple.ObjectNotFound",
 163                                 "The return object is not mapped (this is a Purple error)");
 164
 165         return id;
 166 }
 167
 168 gpointer
 169 purple_dbus_id_to_pointer_error(gint id, PurpleDBusType *type,
 170                 const char *typename, DBusError *error)
 171 {
 172         gpointer ptr = purple_dbus_id_to_pointer(id, type);
 173
 174         if (ptr == NULL && id != 0)
 175                 dbus_set_error(error, "im.pidgin.purple.InvalidHandle",
 176                                 "%s object with ID = %i not found", typename, id);
 177
 178         return ptr;
 179 }
 180
 181
 182 /**************************************************************************/
 183 /** @name Modified versions of some DBus functions                        */
 184 /**************************************************************************/
 185
 186 dbus_bool_t
 187 purple_dbus_message_get_args(DBusMessage *message,
 188                 DBusError *error, int first_arg_type, ...)
 189 {
 190         dbus_bool_t retval;
 191         va_list var_args;
 192
 193         va_start(var_args, first_arg_type);
 194         retval = purple_dbus_message_get_args_valist(message, error, first_arg_type, var_args);
 195         va_end(var_args);
 196
 197         return retval;
 198 }
 199
 200 dbus_bool_t
 201 purple_dbus_message_get_args_valist(DBusMessage *message,
 202                 DBusError *error, int first_arg_type, va_list var_args)
 203 {
 204         DBusMessageIter iter;
 205
 206         dbus_message_iter_init(message, &iter);
 207         return purple_dbus_message_iter_get_args_valist(&iter, error, first_arg_type, var_args);
 208 }
 209
 210 dbus_bool_t
 211 purple_dbus_message_iter_get_args(DBusMessageIter *iter,
 212                 DBusError *error, int first_arg_type, ...)
 213 {
 214         dbus_bool_t retval;
 215         va_list var_args;
 216
 217         va_start(var_args, first_arg_type);
 218         retval = purple_dbus_message_iter_get_args_valist(iter, error, first_arg_type, var_args);
 219         va_end(var_args);
 220
 221         return retval;
 222 }
 223
 224 #define TYPE_IS_CONTAINER(typecode)        \
 225         ((typecode) == DBUS_TYPE_STRUCT ||     \
 226          (typecode) == DBUS_TYPE_DICT_ENTRY || \
 227          (typecode) == DBUS_TYPE_VARIANT ||    \
 228          (typecode) == DBUS_TYPE_ARRAY)
 229
 230
 231 dbus_bool_t
 232 purple_dbus_message_iter_get_args_valist(DBusMessageIter *iter,
 233                 DBusError *error, int first_arg_type, va_list var_args)
 234 {
 235         int spec_type, msg_type, i;
 236
 237         spec_type = first_arg_type;
 238
 239         for (i = 0; spec_type != DBUS_TYPE_INVALID; i++)
 240         {
 241                 msg_type = dbus_message_iter_get_arg_type(iter);
 242
 243                 if (msg_type != spec_type)
 244                 {
 245                         dbus_set_error(error, DBUS_ERROR_INVALID_ARGS,
 246                                         "Argument %d is specified to be of type \"%i\", but "
 247                                         "is actually of type \"%i\"\n", i,
 248                                         spec_type, msg_type);
 249                         return FALSE;
 250                 }
 251
 252                 if (!TYPE_IS_CONTAINER(spec_type))
 253                 {
 254                         gpointer ptr;
 255                         ptr = va_arg (var_args, gpointer);
 256                         dbus_message_iter_get_basic(iter, ptr);
 257                 }
 258                 else
 259                 {
 260                         DBusMessageIter *sub;
 261                         sub = va_arg (var_args, DBusMessageIter*);
 262                         dbus_message_iter_recurse(iter, sub);
 263                         purple_debug_info("dbus", "subiter %p:%p\n", sub, * (gpointer*) sub);
 264                         break; /* for testing only! */
 265                 }
 266
 267                 spec_type = va_arg(var_args, int);
 268                 if (!dbus_message_iter_next(iter) && spec_type != DBUS_TYPE_INVALID)
 269                 {
 270                         dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
 271                                         "Message has only %d arguments, but more were expected", i);
 272                         return FALSE;
 273                 }
 274         }
 275
 276         return TRUE;
 277 }
 278
 279
 280
 281 /**************************************************************************/
 282 /** @name Useful functions                                                */
 283 /**************************************************************************/
 284
 285 const char *empty_to_null(const char *str)
 286 {
 287         if (str == NULL || str[0] == 0)
 288                 return NULL;
 289         else
 290                 return str;
 291 }
 292
 293 const char *
 294 null_to_empty(const char *s)
 295 {
 296         if (s)
 297                 return s;
 298         else
 299                 return "";
 300 }
 301
 302 dbus_int32_t *
 303 purple_dbusify_GList(GList *list, gboolean free_memory, dbus_int32_t *len)
 304 {
 305         dbus_int32_t *array;
 306         int i;
 307         GList *elem;
 308
 309         *len = g_list_length(list);
 310         array = g_new0(dbus_int32_t, *len);
 311         for (i = 0, elem = list; elem != NULL; elem = elem->next, i++)
 312                 array[i] = purple_dbus_pointer_to_id(elem->data);
 313
 314         if (free_memory)
 315                 g_list_free(list);
 316
 317         return array;
 318 }
 319
 320 dbus_int32_t *
 321 purple_dbusify_GSList(GSList *list, gboolean free_memory, dbus_int32_t *len)
 322 {
 323         dbus_int32_t *array;
 324         int i;
 325         GSList *elem;
 326
 327         *len = g_slist_length(list);
 328         array = g_new0(dbus_int32_t, *len);
 329         for (i = 0, elem = list; elem != NULL; elem = elem->next, i++)
 330                 array[i] = purple_dbus_pointer_to_id(elem->data);
 331
 332         if (free_memory)
 333                 g_slist_free(list);
 334
 335         return array;
 336 }
 337
 338 gpointer *
 339 purple_GList_to_array(GList *list, gboolean free_memory, dbus_int32_t *len)
 340 {
 341         gpointer *array;
 342         int i;
 343         GList *elem;
 344
 345         *len = g_list_length(list);
 346         array = g_new0(gpointer, *len);
 347         for (i = 0, elem = list; elem != NULL; elem = elem->next, i++)
 348                 array[i] = elem->data;
 349
 350         if (free_memory)
 351                 g_list_free(list);
 352
 353         return array;
 354 }
 355
 356 gpointer *
 357 purple_GSList_to_array(GSList *list, gboolean free_memory, dbus_int32_t *len)
 358 {
 359         gpointer *array;
 360         int i;
 361         GSList *elem;
 362
 363         *len = g_slist_length(list);
 364         array = g_new0(gpointer, *len);
 365         for (i = 0, elem = list; elem != NULL; elem = elem->next, i++)
 366                 array[i] = elem->data;
 367
 368         if (free_memory)
 369                 g_slist_free(list);
 370
 371         return array;
 372 }
 373
 374 GHashTable *
 375 purple_dbus_iter_hash_table(DBusMessageIter *iter, DBusError *error)
 376 {
 377         GHashTable *hash;
 378
 379         /* we do not need to destroy strings because they are part of the message */
 380         hash = g_hash_table_new(g_str_hash, g_str_equal);
 381
 382         do {
 383                 char *key, *value;
 384                 DBusMessageIter subiter;
 385
 386                 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_DICT_ENTRY)
 387                         goto error;
 388                         /* With all due respect to Dijkstra,
 389                          * this goto is for exception
 390                          * handling, and it is ok because it
 391                          * avoids duplication of the code
 392                          * responsible for destroying the hash
 393                          * table.  Exceptional instructions
 394                          * for exceptional situations.
 395                          */
 396
 397                 dbus_message_iter_recurse(iter, &subiter);
 398                 if (!purple_dbus_message_iter_get_args(&subiter, error,
 399                                 DBUS_TYPE_STRING, &key,
 400                                 DBUS_TYPE_STRING, &value,
 401                                 DBUS_TYPE_INVALID))
 402                         goto error; /* same here */
 403
 404                 g_hash_table_insert(hash, key, value);
 405         } while (dbus_message_iter_next(iter));
 406
 407         return hash;
 408
 409 error:
 410         g_hash_table_destroy(hash);
 411         return NULL;
 412 }
 413
 414 /**************************************************************/
 415 /* DBus bindings ...                                          */
 416 /**************************************************************/
 417
 418 static DBusConnection *purple_dbus_connection;
 419
 420 DBusConnection *
 421 purple_dbus_get_connection(void)
 422 {
 423         return purple_dbus_connection;
 424 }
 425
 426 #include "dbus-bindings.c"
 427 #include "dbus-signals.c"
 428
 429 static gboolean
 430 purple_dbus_dispatch_cb(DBusConnection *connection,
 431                 DBusMessage *message, void *user_data)
 432 {
 433         const char *name;
 434         PurpleDBusBinding *bindings;
 435         int i;
 436
 437         bindings = (PurpleDBusBinding*) user_data;
 438
 439         if (!dbus_message_has_path(message, DBUS_PATH_PURPLE))
 440                 return FALSE;
 441
 442         name = dbus_message_get_member(message);
 443
 444         if (name == NULL)
 445                 return FALSE;
 446
 447         if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
 448                 return FALSE;
 449
 450         for (i = 0; bindings[i].name; i++)
 451                 if (!strcmp(name, bindings[i].name))
 452                 {
 453                         DBusMessage *reply;
 454                         DBusError error;
 455
 456                         dbus_error_init(&error);
 457
 458                         reply = bindings[i].handler(message, &error);
 459
 460                         if (reply == NULL && dbus_error_is_set(&error))
 461                                 reply = dbus_message_new_error (message,
 462                                                 error.name, error.message);
 463
 464                         if (reply != NULL)
 465                         {
 466                                 dbus_connection_send(connection, reply, NULL);
 467                                 dbus_message_unref(reply);
 468                         }
 469
 470                         return TRUE; /* return reply! */
 471                 }
 472
 473         return FALSE;
 474 }
 475
 476
 477 static const char *
 478 dbus_gettext(const char **ptr)
 479 {
 480         const char *text = *ptr;
 481         *ptr += strlen(text) + 1;
 482         return text;
 483 }
 484
 485 static void
 486 purple_dbus_introspect_cb(GList **bindings_list, void *bindings)
 487 {
 488         *bindings_list = g_list_prepend(*bindings_list, bindings);
 489 }
 490
 491 static DBusMessage *purple_dbus_introspect(DBusMessage *message)
 492 {
 493         DBusMessage *reply;
 494         GString *str;
 495         GList *bindings_list, *node;
 496         const char *signals;
 497         const char *type;
 498         const char *pointer_type;
 499
 500         str = g_string_sized_new(0x1000); /* TODO: why this size? */
 501
 502         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");
 503         g_string_append_printf(str, "<node name='%s'>\n", DBUS_PATH_PURPLE);
 504         g_string_append(str, "  <interface name='org.freedesktop.DBus.Introspectable'>\n    <method name='Introspect'>\n      <arg name='data' direction='out' type='s'/>\n    </method>\n  </interface>\n\n");
 505
 506         g_string_append_printf(str, "  <interface name='%s'>\n", DBUS_INTERFACE_PURPLE);
 507
 508         bindings_list = NULL;
 509         purple_signal_emit(purple_dbus_get_handle(), "dbus-introspect", &bindings_list);
 510
 511         for (node = bindings_list; node; node = node->next)
 512         {
 513                 PurpleDBusBinding *bindings;
 514                 int i;
 515
 516                 bindings = (PurpleDBusBinding*)node->data;
 517
 518                 for (i = 0; bindings[i].name; i++)
 519                 {
 520                         const char *text;
 521
 522                         g_string_append_printf(str, "    <method name='%s'>\n", bindings[i].name);
 523
 524                         text = bindings[i].parameters;
 525                         while (*text)
 526                         {
 527                                 const char *name, *direction, *type;
 528
 529                                 direction = dbus_gettext(&text);
 530                                 type = dbus_gettext(&text);
 531                                 name = dbus_gettext(&text);
 532
 533                                 g_string_append_printf(str,
 534                                                 "      <arg name='%s' type='%s' direction='%s'/>\n",
 535                                                 name, type, direction);
 536                         }
 537                         g_string_append(str, "    </method>\n");
 538                 }
 539         }
 540
 541         if (sizeof(int) == sizeof(dbus_int32_t))
 542                 pointer_type = "type='i'";
 543         else
 544                 pointer_type = "type='x'";
 545
 546         signals = dbus_signals;
 547         while ((type = strstr(signals, "type='p'")) != NULL) {
 548                 g_string_append_len(str, signals, type - signals);
 549                 g_string_append(str, pointer_type);
 550                 signals = type + sizeof("type='p'") - 1;
 551         }
 552         g_string_append(str, signals);
 553
 554         g_string_append(str, "  </interface>\n</node>\n");
 555
 556         reply = dbus_message_new_method_return(message);
 557         dbus_message_append_args(reply, DBUS_TYPE_STRING, &(str->str),
 558                         DBUS_TYPE_INVALID);
 559         g_string_free(str, TRUE);
 560         g_list_free(bindings_list);
 561
 562         return reply;
 563 }
 564
 565 static DBusHandlerResult
 566 purple_dbus_dispatch(DBusConnection *connection,
 567                 DBusMessage *message, void *user_data)
 568 {
 569         if (purple_signal_emit_return_1(purple_dbus_get_handle(),
 570                         "dbus-method-called", connection, message))
 571                 return DBUS_HANDLER_RESULT_HANDLED;
 572
 573         if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect") &&
 574                         dbus_message_has_path(message, DBUS_PATH_PURPLE))
 575         {
 576                 DBusMessage *reply;
 577                 reply = purple_dbus_introspect(message);
 578                 dbus_connection_send (connection, reply, NULL);
 579                 dbus_message_unref(reply);
 580                 return DBUS_HANDLER_RESULT_HANDLED;
 581         }
 582
 583         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 584 }
 585
 586 void
 587 purple_dbus_register_bindings(void *handle, PurpleDBusBinding *bindings)
 588 {
 589         purple_signal_connect(purple_dbus_get_handle(), "dbus-method-called",
 590                         handle,
 591                         PURPLE_CALLBACK(purple_dbus_dispatch_cb),
 592                         bindings);
 593         purple_signal_connect(purple_dbus_get_handle(), "dbus-introspect",
 594                         handle,
 595                         PURPLE_CALLBACK(purple_dbus_introspect_cb),
 596                         bindings);
 597 }
 598
 599 static void
 600 purple_dbus_dispatch_init(void)
 601 {
 602         static DBusObjectPathVTable vtable = {NULL, &purple_dbus_dispatch, NULL, NULL, NULL, NULL};
 603         DBusError error;
 604
 605         dbus_error_init(&error);
 606         purple_dbus_connection = dbus_bus_get(DBUS_BUS_STARTER, &error);
 607
 608         if (purple_dbus_connection == NULL)
 609         {
 610                 init_error = g_strdup_printf(N_("Failed to get connection: %s"), error.message);
 611                 dbus_error_free(&error);
 612                 return;
 613         }
 614
 615         /* Do not allow libdbus to exit on connection failure (This may
 616            work around random exit(1) on SIGPIPE errors) */
 617         dbus_connection_set_exit_on_disconnect (purple_dbus_connection, FALSE);
 618
 619         if (!dbus_connection_register_object_path(purple_dbus_connection,
 620                         DBUS_PATH_PURPLE, &vtable, NULL))
 621         {
 622                 init_error = g_strdup_printf(N_("Failed to get name: %s"), error.name);
 623                 dbus_error_free(&error);
 624                 return;
 625         }
 626
 627         dbus_request_name_reply = dbus_bus_request_name(purple_dbus_connection,
 628                         DBUS_SERVICE_PURPLE, 0, &error);
 629
 630         if (dbus_error_is_set(&error))
 631         {
 632                 dbus_connection_unref(purple_dbus_connection);
 633                 purple_dbus_connection = NULL;
 634                 init_error = g_strdup_printf(N_("Failed to get serv name: %s"), error.name);
 635                 dbus_error_free(&error);
 636                 return;
 637         }
 638
 639         dbus_connection_setup_with_g_main(purple_dbus_connection, NULL);
 640
 641         purple_debug_misc("dbus", "okkk\n");
 642
 643         purple_signal_register(purple_dbus_get_handle(), "dbus-method-called",
 644                          purple_marshal_BOOLEAN__POINTER_POINTER,
 645                          purple_value_new(PURPLE_TYPE_BOOLEAN), 2,
 646                          purple_value_new(PURPLE_TYPE_POINTER),
 647                          purple_value_new(PURPLE_TYPE_POINTER));
 648
 649         purple_signal_register(purple_dbus_get_handle(), "dbus-introspect",
 650                          purple_marshal_VOID__POINTER, NULL, 1,
 651                          purple_value_new_outgoing(PURPLE_TYPE_POINTER));
 652
 653         PURPLE_DBUS_REGISTER_BINDINGS(purple_dbus_get_handle());
 654 }
 655
 656
 657
 658 /**************************************************************************/
 659 /** @name Signals                                                         */
 660 /**************************************************************************/
 661
 662
 663
 664 static char *
 665 purple_dbus_convert_signal_name(const char *purple_name)
 666 {
 667         int purple_index, g_index;
 668         char *g_name = g_new(char, strlen(purple_name) + 1);
 669         gboolean capitalize_next = TRUE;
 670
 671         for (purple_index = g_index = 0; purple_name[purple_index]; purple_index++)
 672                 if (purple_name[purple_index] != '-' && purple_name[purple_index] != '_')
 673                 {
 674                         if (capitalize_next)
 675                                 g_name[g_index++] = g_ascii_toupper(purple_name[purple_index]);
 676                         else
 677                                 g_name[g_index++] = purple_name[purple_index];
 678                         capitalize_next = FALSE;
 679                 } else
 680                         capitalize_next = TRUE;
 681
 682         g_name[g_index] = 0;
 683
 684         return g_name;
 685 }
 686
 687 #define my_arg(type) (ptr != NULL ? * ((type *)ptr) : va_arg(data, type))
 688
 689 static gboolean
 690 purple_dbus_message_append_purple_values(DBusMessageIter *iter,
 691                 int number, PurpleValue **purple_values, va_list data)
 692 {
 693         int i;
 694         gboolean error = FALSE;
 695
 696         for (i = 0; i < number; i++)
 697         {
 698                 const char *str;
 699                 int id;
 700                 gint xint;
 701                 guint xuint;
 702                 gint64 xint64;
 703                 guint64 xuint64;
 704                 gboolean xboolean;
 705                 gpointer ptr = NULL;
 706                 gpointer val;
 707
 708                 if (purple_value_is_outgoing(purple_values[i]))
 709                 {
 710                         ptr = my_arg(gpointer);
 711                         g_return_val_if_fail(ptr, TRUE);
 712                 }
 713
 714                 switch (purple_values[i]->type)
 715                 {
 716                 case PURPLE_TYPE_INT:
 717                 case PURPLE_TYPE_ENUM:
 718                         xint = my_arg(gint);
 719                         dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &xint);
 720                         break;
 721                 case PURPLE_TYPE_UINT:
 722                         xuint = my_arg(guint);
 723                         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &xuint);
 724                         break;
 725                 case PURPLE_TYPE_INT64:
 726                         xint64 = my_arg(gint64);
 727                         dbus_message_iter_append_basic(iter, DBUS_TYPE_INT64, &xint64);
 728                         break;
 729                 case PURPLE_TYPE_UINT64:
 730                         xuint64 = my_arg(guint64);
 731                         dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &xuint64);
 732                         break;
 733                 case PURPLE_TYPE_BOOLEAN:
 734                         xboolean = my_arg(gboolean);
 735                         dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &xboolean);
 736                         break;
 737                 case PURPLE_TYPE_STRING:
 738                         str = null_to_empty(my_arg(char*));
 739                         if (!g_utf8_validate(str, -1, NULL)) {
 740                                 gchar *tmp;
 741                                 purple_debug_error("dbus", "Invalid UTF-8 string passed to signal, emitting salvaged string!\n");
 742                                 tmp = purple_utf8_salvage(str);
 743                                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &tmp);
 744                                 g_free(tmp);
 745                         } else {
 746                                 dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
 747                         }
 748                         break;
 749                 case PURPLE_TYPE_SUBTYPE: /* registered pointers only! */
 750                 case PURPLE_TYPE_POINTER:
 751                 case PURPLE_TYPE_OBJECT:
 752                 case PURPLE_TYPE_BOXED:
 753                         val = my_arg(gpointer);
 754                         id = purple_dbus_pointer_to_id(val);
 755                         if (id == 0 && val != NULL)
 756                                 error = TRUE;      /* Some error happened. */
 757                         dbus_message_iter_append_basic(iter,
 758                                         (sizeof(id) == sizeof(dbus_int32_t)) ? DBUS_TYPE_INT32 : DBUS_TYPE_INT64, &id);
 759                         break;
 760                 default: /* no conversion implemented */
 761                         g_return_val_if_reached(TRUE);
 762                 }
 763         }
 764         return error;
 765 }
 766
 767 #undef my_arg
 768
 769 void
 770 purple_dbus_signal_emit_purple(const char *name, int num_values,
 771                 PurpleValue **values, va_list vargs)
 772 {
 773         DBusMessage *signal;
 774         DBusMessageIter iter;
 775         char *newname;
 776
 777 #if 0 /* this is noisy with no dbus connection */
 778         g_return_if_fail(purple_dbus_connection);
 779 #else
 780         if (purple_dbus_connection == NULL)
 781                 return;
 782 #endif
 783
 784
 785         /*
 786          * The test below is a hack that prevents our "dbus-method-called"
 787          * signal from being propagated to dbus.  What we really need is a
 788          * flag for each signal that states whether this signal is to be
 789          * dbus-propagated or not.
 790          */
 791         if (!strcmp(name, "dbus-method-called"))
 792                 return;
 793
 794         newname = purple_dbus_convert_signal_name(name);
 795         signal = dbus_message_new_signal(DBUS_PATH_PURPLE, DBUS_INTERFACE_PURPLE, newname);
 796         dbus_message_iter_init_append(signal, &iter);
 797
 798         if (purple_dbus_message_append_purple_values(&iter, num_values, values, vargs))
 799                 if (purple_debug_is_verbose())
 800                         purple_debug_warning("dbus",
 801                                 "The signal \"%s\" caused some dbus error."
 802                                 " (If you are not a developer, please ignore this message.)\n",
 803                                 name);
 804
 805         dbus_connection_send(purple_dbus_connection, signal, NULL);
 806
 807         g_free(newname);
 808         dbus_message_unref(signal);
 809 }
 810
 811 const char *
 812 purple_dbus_get_init_error(void)
 813 {
 814         return init_error;
 815 }
 816
 817 void *
 818 purple_dbus_get_handle(void)
 819 {
 820         static int handle;
 821
 822         return &handle;
 823 }
 824
 825 void
 826 purple_dbus_init(void)
 827 {
 828         if (g_thread_supported())
 829                 dbus_g_thread_init();
 830
 831         purple_dbus_init_ids();
 832
 833         g_free(init_error);
 834         init_error = NULL;
 835         purple_dbus_dispatch_init();
 836         if (init_error != NULL)
 837                 purple_debug_error("dbus", "%s\n", init_error);
 838 }
 839
 840 void
 841 purple_dbus_uninit(void)
 842 {
 843         DBusError error;
 844         if (!purple_dbus_connection)
 845                 return;
 846
 847         dbus_error_init(&error);
 848         dbus_connection_unregister_object_path(purple_dbus_connection, DBUS_PATH_PURPLE);
 849         dbus_bus_release_name(purple_dbus_connection, DBUS_SERVICE_PURPLE, &error);
 850         dbus_error_free(&error);
 851         dbus_connection_unref(purple_dbus_connection);
 852         purple_dbus_connection = NULL;
 853         purple_signals_disconnect_by_handle(purple_dbus_get_handle());
 854         g_free(init_error);
 855         init_error = NULL;
 856 }
 857