droute/droute.c

   1 /*
   2  * AT-SPI - Assistive Technology Service Provider Interface
   3  * (Gnome Accessibility Project; http://developer.gnome.org/projects/gap)
   4  *
   5  * Copyright 2008 Novell, Inc.
   6  * Copyright 2008 Codethink Ltd.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library 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 GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <stdio.h>
  27
  28 #include "droute.h"
  29 #include "droute-pairhash.h"
  30
  31 #define CHUNKS_DEFAULT (512)
  32
  33 #define oom() g_error ("D-Bus out of memory, this message will fail anyway")
  34
  35 #if defined DROUTE_DEBUG
  36     #define _DROUTE_DEBUG(format, args...) g_print (format , ## args)
  37 #else
  38     #define _DROUTE_DEBUG(format, args...)
  39 #endif
  40
  41 struct _DRouteContext
  42 {
  43     GPtrArray            *registered_paths;
  44
  45     gchar                *introspect_string;
  46 };
  47
  48 struct _DRoutePath
  49 {
  50     DRouteContext        *cnx;
  51     gchar *path;
  52     gboolean prefix;
  53     GStringChunk         *chunks;
  54     GPtrArray            *interfaces;
  55     GPtrArray            *introspection;
  56     GHashTable           *methods;
  57     GHashTable           *properties;
  58
  59     DRouteIntrospectChildrenFunction introspect_children_cb;
  60     void *introspect_children_data;
  61     void                   *user_data;
  62     DRouteGetDatumFunction  get_datum;
  63 };
  64
  65 /*---------------------------------------------------------------------------*/
  66
  67 typedef struct PropertyPair
  68 {
  69     DRoutePropertyFunction get;
  70     DRoutePropertyFunction set;
  71 } PropertyPair;
  72
  73 /*---------------------------------------------------------------------------*/
  74
  75 static DBusHandlerResult
  76 handle_message (DBusConnection *bus, DBusMessage *message, void *user_data);
  77
  78 static DBusMessage *
  79 droute_object_does_not_exist_error (DBusMessage *message);
  80
  81 /*---------------------------------------------------------------------------*/
  82
  83 static DRoutePath *
  84 path_new (DRouteContext *cnx,
  85           const char *path,
  86           gboolean prefix,
  87           void    *user_data,
  88           DRouteIntrospectChildrenFunction introspect_children_cb,
  89           void *introspect_children_data,
  90           DRouteGetDatumFunction get_datum)
  91 {
  92     DRoutePath *new_path;
  93
  94     new_path = g_new0 (DRoutePath, 1);
  95     new_path->cnx = cnx;
  96     new_path->path = g_strdup (path);
  97     new_path->prefix = prefix;
  98     new_path->chunks = g_string_chunk_new (CHUNKS_DEFAULT);
  99     new_path->interfaces = g_ptr_array_new ();
 100     new_path->introspection = g_ptr_array_new ();
 101
 102     new_path->methods = g_hash_table_new_full ((GHashFunc)str_pair_hash,
 103                                                str_pair_equal,
 104                                                g_free,
 105                                                NULL);
 106
 107     new_path->properties = g_hash_table_new_full ((GHashFunc)str_pair_hash,
 108                                                   str_pair_equal,
 109                                                   g_free,
 110                                                   g_free);
 111
 112     new_path->introspect_children_cb = introspect_children_cb;
 113     new_path->introspect_children_data = introspect_children_data;
 114     new_path->user_data = user_data;
 115     new_path->get_datum = get_datum;
 116
 117     return new_path;
 118 }
 119
 120 static void
 121 path_free (DRoutePath *path, gpointer user_data)
 122 {
 123     g_free (path->path);
 124     g_string_chunk_free  (path->chunks);
 125     g_ptr_array_free     (path->interfaces, TRUE);
 126     g_free(g_ptr_array_free     (path->introspection, FALSE));
 127     g_hash_table_destroy (path->methods);
 128     g_hash_table_destroy (path->properties);
 129     g_free (path);
 130 }
 131
 132 static void *
 133 path_get_datum (DRoutePath *path, const gchar *pathstr)
 134 {
 135     if (path->get_datum != NULL)
 136         return (path->get_datum) (pathstr, path->user_data);
 137     else
 138         return path->user_data;
 139 }
 140
 141 /*---------------------------------------------------------------------------*/
 142
 143 DRouteContext *
 144 droute_new ()
 145 {
 146     DRouteContext *cnx;
 147
 148     cnx = g_new0 (DRouteContext, 1);
 149     cnx->registered_paths = g_ptr_array_new ();
 150
 151     return cnx;
 152 }
 153
 154 void
 155 droute_free (DRouteContext *cnx)
 156 {
 157     g_ptr_array_foreach (cnx->registered_paths, (GFunc) path_free, NULL);
 158     g_ptr_array_free (cnx->registered_paths, TRUE);
 159     g_free (cnx);
 160 }
 161
 162 /*---------------------------------------------------------------------------*/
 163
 164 /*---------------------------------------------------------------------------*/
 165
 166 static DBusObjectPathVTable droute_vtable =
 167 {
 168   NULL,
 169   &handle_message,
 170   NULL, NULL, NULL, NULL
 171 };
 172
 173 DRoutePath *
 174 droute_add_one (DRouteContext *cnx,
 175                 const char    *path,
 176                 const void    *data)
 177 {
 178     DRoutePath *new_path;
 179
 180     new_path = path_new (cnx, path, FALSE, (void *)data, NULL, NULL, NULL);
 181
 182     g_ptr_array_add (cnx->registered_paths, new_path);
 183     return new_path;
 184 }
 185
 186 DRoutePath *
 187 droute_add_many (DRouteContext *cnx,
 188                  const char    *path,
 189                  const void    *data,
 190                  DRouteIntrospectChildrenFunction introspect_children_cb,
 191                  void *introspect_children_data,
 192                  const DRouteGetDatumFunction get_datum)
 193 {
 194     DRoutePath *new_path;
 195
 196     new_path = path_new (cnx, path, TRUE, (void *) data,
 197                          introspect_children_cb, introspect_children_data,
 198                          get_datum);
 199
 200     g_ptr_array_add (cnx->registered_paths, new_path);
 201     return new_path;
 202 }
 203
 204 /*---------------------------------------------------------------------------*/
 205
 206 void
 207 droute_path_add_interface(DRoutePath *path,
 208                           const char *name,
 209                           const char *introspect,
 210                           const DRouteMethod   *methods,
 211                           const DRouteProperty *properties)
 212 {
 213     gchar *itf;
 214
 215     g_return_if_fail (name != NULL);
 216
 217     itf = g_string_chunk_insert (path->chunks, name);
 218     g_ptr_array_add (path->interfaces, itf);
 219     g_ptr_array_add (path->introspection, (gpointer) introspect);
 220
 221     for (; methods != NULL && methods->name != NULL; methods++)
 222       {
 223         gchar *meth;
 224
 225         meth = g_string_chunk_insert (path->chunks, methods->name);
 226         g_hash_table_insert (path->methods, str_pair_new (itf, meth), methods->func);
 227       }
 228
 229     for (; properties != NULL && properties->name != NULL; properties++)
 230       {
 231         gchar *prop;
 232         PropertyPair *pair;
 233
 234         prop = g_string_chunk_insert (path->chunks, properties->name);
 235         pair = g_new (PropertyPair, 1);
 236         pair->get = properties->get;
 237         pair->set = properties->set;
 238         g_hash_table_insert (path->properties, str_pair_new (itf, prop), pair);
 239       }
 240 }
 241
 242 /*---------------------------------------------------------------------------*/
 243
 244 /* The data structures don't support an efficient implementation of GetAll
 245  * and I don't really care.
 246  */
 247 static DBusMessage *
 248 impl_prop_GetAll (DBusMessage *message,
 249                   DRoutePath  *path,
 250                   const char  *pathstr)
 251 {
 252     DBusMessageIter iter, iter_dict, iter_dict_entry;
 253     DBusMessage *reply;
 254     DBusError error;
 255     GHashTableIter prop_iter;
 256
 257     StrPair *key;
 258     PropertyPair *value;
 259     gchar *iface;
 260
 261     void  *datum = path_get_datum (path, pathstr);
 262     if (!datum)
 263         return droute_object_does_not_exist_error (message);
 264
 265     dbus_error_init (&error);
 266     if (!dbus_message_get_args
 267                 (message, &error, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID))
 268       {
 269         DBusMessage *ret;
 270         ret = dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
 271         dbus_error_free (&error);
 272         return ret;
 273       }
 274
 275     reply = dbus_message_new_method_return (message);
 276     if (!reply)
 277         oom ();
 278
 279     dbus_message_iter_init_append (reply, &iter);
 280     if (!dbus_message_iter_open_container
 281                 (&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict))
 282         oom ();
 283
 284     g_hash_table_iter_init (&prop_iter, path->properties);
 285     while (g_hash_table_iter_next (&prop_iter, (gpointer*)&key, (gpointer*)&value))
 286       {
 287         if (!g_strcmp0 (key->one, iface))
 288          {
 289            if (!value->get)
 290               continue;
 291            if (!dbus_message_iter_open_container
 292                         (&iter_dict, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict_entry))
 293               oom ();
 294            dbus_message_iter_append_basic (&iter_dict_entry, DBUS_TYPE_STRING,
 295                                            &key->two);
 296            (value->get) (&iter_dict_entry, datum);
 297            if (!dbus_message_iter_close_container (&iter_dict, &iter_dict_entry))
 298                oom ();
 299          }
 300       }
 301
 302     if (!dbus_message_iter_close_container (&iter, &iter_dict))
 303         oom ();
 304     return reply;
 305 }
 306
 307 static DBusMessage *
 308 impl_prop_GetSet (DBusMessage *message,
 309                   DRoutePath  *path,
 310                   const char  *pathstr,
 311                   gboolean     get)
 312 {
 313     DBusMessage *reply = NULL;
 314     DBusError error;
 315
 316     StrPair pair;
 317     PropertyPair *prop_funcs = NULL;
 318
 319     void *datum;
 320
 321     dbus_error_init (&error);
 322     if (!dbus_message_get_args (message,
 323                                 &error,
 324                                 DBUS_TYPE_STRING,
 325                                 &(pair.one),
 326                                 DBUS_TYPE_STRING,
 327                                 &(pair.two),
 328                                 DBUS_TYPE_INVALID))
 329       {
 330         DBusMessage *ret;
 331         ret = dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
 332         dbus_error_free (&error);
 333         return ret;
 334       }
 335
 336     _DROUTE_DEBUG ("DRoute (handle prop): %s|%s on %s\n", pair.one, pair.two, pathstr);
 337
 338     prop_funcs = (PropertyPair *) g_hash_table_lookup (path->properties, &pair);
 339     if (!prop_funcs)
 340       {
 341         DBusMessage *ret;
 342 #ifdef DBUS_ERROR_UNKNOWN_PROPERTY
 343         ret = dbus_message_new_error (message, DBUS_ERROR_UNKNOWN_PROPERTY, "Property unavailable");
 344 #else
 345         ret = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
 346 #endif
 347         dbus_error_free (&error);
 348         return ret;
 349       }
 350
 351     datum = path_get_datum (path, pathstr);
 352     if (!datum)
 353         return droute_object_does_not_exist_error (message);
 354
 355     if (get && prop_funcs->get)
 356       {
 357
 358         DBusMessageIter iter;
 359
 360         _DROUTE_DEBUG ("DRoute (handle prop Get): %s|%s on %s\n", pair.one, pair.two, pathstr);
 361
 362         reply = dbus_message_new_method_return (message);
 363         dbus_message_iter_init_append (reply, &iter);
 364         if (!(prop_funcs->get) (&iter, datum))
 365           {
 366             dbus_message_unref (reply);
 367             reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Get failed");
 368           }
 369       }
 370     else if (!get && prop_funcs->set)
 371       {
 372         DBusMessageIter iter;
 373
 374         _DROUTE_DEBUG ("DRoute (handle prop Get): %s|%s on %s\n", pair.one, pair.two, pathstr);
 375
 376         dbus_message_iter_init (message, &iter);
 377         /* Skip the interface and property name */
 378         dbus_message_iter_next(&iter);
 379         dbus_message_iter_next(&iter);
 380         (prop_funcs->set) (&iter, datum);
 381
 382         reply = dbus_message_new_method_return (message);
 383       }
 384 #ifdef DBUS_ERROR_PROPERTY_READ_ONLY
 385     else if (!get)
 386       {
 387         reply = dbus_message_new_error (message, DBUS_ERROR_PROPERTY_READ_ONLY, "Property is read-only");
 388       }
 389 #endif
 390     else
 391       {
 392         reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Getter or setter unavailable");
 393       }
 394
 395     return reply;
 396 }
 397
 398 static DBusHandlerResult
 399 handle_dbus (DBusConnection *bus,
 400                    DBusMessage    *message,
 401                    const gchar    *iface,
 402                    const gchar    *member,
 403                    const gchar    *pathstr)
 404 {
 405   static int id = 1;
 406   char *id_str = (char *) g_malloc(40);
 407   DBusMessage *reply;
 408
 409   if (strcmp (iface, DBUS_INTERFACE_DBUS) != 0 ||
 410       strcmp (member, "Hello") != 0)
 411     {
 412       g_free (id_str);
 413       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 414     }
 415
 416     /* TODO: Fix this hack (we don't handle wrap-around, for instance) */
 417     sprintf (id_str, ":1.%d", id++);
 418     reply = dbus_message_new_method_return (message);
 419     dbus_message_append_args (reply, DBUS_TYPE_STRING, &id_str, DBUS_TYPE_INVALID);
 420     dbus_connection_send (bus, reply, NULL);
 421   dbus_connection_flush (bus);
 422     dbus_message_unref (reply);
 423   g_free (id_str);
 424     return DBUS_HANDLER_RESULT_HANDLED;
 425 }
 426
 427 static DBusHandlerResult
 428 handle_properties (DBusConnection *bus,
 429                    DBusMessage    *message,
 430                    DRoutePath     *path,
 431                    const gchar    *iface,
 432                    const gchar    *member,
 433                    const gchar    *pathstr)
 434 {
 435     DBusMessage *reply = NULL;
 436     DBusHandlerResult result = DBUS_HANDLER_RESULT_HANDLED;
 437
 438     if (!g_strcmp0(member, "GetAll"))
 439        reply = impl_prop_GetAll (message, path, pathstr);
 440     else if (!g_strcmp0 (member, "Get"))
 441        reply = impl_prop_GetSet (message, path, pathstr, TRUE);
 442     else if (!g_strcmp0 (member, "Set"))
 443        reply = impl_prop_GetSet (message, path, pathstr, FALSE);
 444     else
 445        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 446
 447     if (reply)
 448       {
 449         dbus_connection_send (bus, reply, NULL);
 450         dbus_message_unref (reply);
 451       }
 452
 453     return result;
 454 }
 455
 456 /*---------------------------------------------------------------------------*/
 457
 458 static const char *introspection_header =
 459 "<?xml version=\"1.0\"?>\n";
 460
 461 static const char *introspection_node_element =
 462 "<node name=\"%s\">\n";
 463
 464 static const char *introspection_footer =
 465 "</node>";
 466
 467 static DBusHandlerResult
 468 handle_introspection (DBusConnection *bus,
 469                       DBusMessage    *message,
 470                       DRoutePath     *path,
 471                       const gchar    *iface,
 472                       const gchar    *member,
 473                       const gchar    *pathstr)
 474 {
 475     GString *output;
 476     gchar *final;
 477     gint i;
 478
 479     DBusMessage *reply;
 480
 481     _DROUTE_DEBUG ("DRoute (handle introspection): %s\n", pathstr);
 482
 483     if (g_strcmp0 (member, "Introspect"))
 484         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 485
 486     output = g_string_new(introspection_header);
 487
 488     g_string_append_printf(output, introspection_node_element, pathstr);
 489
 490     if (!path->get_datum || path_get_datum (path, pathstr))
 491       {
 492         for (i=0; i < path->introspection->len; i++)
 493           {
 494             gchar *introspect = (gchar *) g_ptr_array_index (path->introspection, i);
 495             g_string_append (output, introspect);
 496           }
 497       }
 498
 499     if (path->introspect_children_cb)
 500       {
 501         gchar *children = (*path->introspect_children_cb) (pathstr, path->introspect_children_data);
 502         if (children)
 503           {
 504             g_string_append (output, children);
 505             g_free (children);
 506           }
 507       }
 508
 509     g_string_append(output, introspection_footer);
 510     final = g_string_free(output, FALSE);
 511
 512     reply = dbus_message_new_method_return (message);
 513     if (!reply)
 514         oom ();
 515     dbus_message_append_args(reply, DBUS_TYPE_STRING, &final,
 516                              DBUS_TYPE_INVALID);
 517     dbus_connection_send (bus, reply, NULL);
 518
 519     dbus_message_unref (reply);
 520     g_free(final);
 521     return DBUS_HANDLER_RESULT_HANDLED;
 522 }
 523
 524 /*---------------------------------------------------------------------------*/
 525
 526 static DBusHandlerResult
 527 handle_other (DBusConnection *bus,
 528               DBusMessage    *message,
 529               DRoutePath     *path,
 530               const gchar    *iface,
 531               const gchar    *member,
 532               const gchar    *pathstr)
 533 {
 534     gint result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 535
 536     StrPair pair;
 537     DRouteFunction func;
 538     DBusMessage *reply = NULL;
 539
 540     void *datum;
 541
 542     pair.one = iface;
 543     pair.two = member;
 544
 545     _DROUTE_DEBUG ("DRoute (handle other): %s|%s on %s\n", member, iface, pathstr);
 546
 547     func = (DRouteFunction) g_hash_table_lookup (path->methods, &pair);
 548     if (func != NULL)
 549       {
 550         datum = path_get_datum (path, pathstr);
 551         if (!datum)
 552             reply = droute_object_does_not_exist_error (message);
 553         else
 554             reply = (func) (bus, message, datum);
 555
 556         /* All D-Bus method calls must have a reply.
 557          * If one is not provided presume that the caller has already
 558          * sent one.
 559          */
 560         if (reply)
 561           {
 562             dbus_connection_send (bus, reply, NULL);
 563             dbus_message_unref (reply);
 564           }
 565         result = DBUS_HANDLER_RESULT_HANDLED;
 566       }
 567
 568     _DROUTE_DEBUG ("DRoute (handle other) (reply): type %d\n",
 569                    dbus_message_get_type(reply));
 570     return result;
 571 }
 572
 573 /*---------------------------------------------------------------------------*/
 574
 575 static DBusHandlerResult
 576 handle_message (DBusConnection *bus, DBusMessage *message, void *user_data)
 577 {
 578     DRoutePath *path = (DRoutePath *) user_data;
 579     const gchar *iface   = dbus_message_get_interface (message);
 580     const gchar *member  = dbus_message_get_member (message);
 581     const gint   type    = dbus_message_get_type (message);
 582     const gchar *pathstr = dbus_message_get_path (message);
 583
 584     DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 585
 586     _DROUTE_DEBUG ("DRoute (handle message): %s|%s of type %d on %s\n", member, iface, type, pathstr);
 587
 588     /* Check for basic reasons not to handle */
 589     if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
 590         member == NULL ||
 591         iface  == NULL)
 592         return result;
 593
 594     if (!strcmp (pathstr, DBUS_PATH_DBUS))
 595         result = handle_dbus (bus, message, iface, member, pathstr);
 596     else if (!strcmp (iface, "org.freedesktop.DBus.Properties"))
 597         result = handle_properties (bus, message, path, iface, member, pathstr);
 598     else if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
 599         result = handle_introspection (bus, message, path, iface, member, pathstr);
 600     else
 601         result = handle_other (bus, message, path, iface, member, pathstr);
 602 #if 0
 603     if (result == DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
 604         g_print ("DRoute | Unhandled message: %s|%s of type %d on %s\n", member, iface, type, pathstr);
 605 #endif
 606
 607     return result;
 608 }
 609
 610 /*---------------------------------------------------------------------------*/
 611
 612 static DBusMessage *
 613 droute_object_does_not_exist_error (DBusMessage *message)
 614 {
 615     DBusMessage *reply;
 616     gchar       *errmsg;
 617
 618     errmsg= g_strdup_printf (
 619             "Method \"%s\" with signature \"%s\" on interface \"%s\" could not be processed as object %s does not exist\n",
 620             dbus_message_get_member (message),
 621             dbus_message_get_signature (message),
 622             dbus_message_get_interface (message),
 623             dbus_message_get_path (message));
 624 #ifdef DBUS_ERROR_UNKNOWN_OBJECT
 625     reply = dbus_message_new_error (message,
 626                                     DBUS_ERROR_UNKNOWN_OBJECT,
 627                                     errmsg);
 628 #else
 629     reply = dbus_message_new_error (message,
 630                                     DBUS_ERROR_FAILED,
 631                                     errmsg);
 632 #endif
 633     g_free (errmsg);
 634     return reply;
 635 }
 636
 637 /*---------------------------------------------------------------------------*/
 638
 639 DBusMessage *
 640 droute_not_yet_handled_error (DBusMessage *message)
 641 {
 642     DBusMessage *reply;
 643     gchar       *errmsg;
 644
 645     errmsg= g_strdup_printf (
 646             "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
 647             dbus_message_get_member (message),
 648             dbus_message_get_signature (message),
 649             dbus_message_get_interface (message));
 650     reply = dbus_message_new_error (message,
 651                                     DBUS_ERROR_UNKNOWN_METHOD,
 652                                     errmsg);
 653     g_free (errmsg);
 654     return reply;
 655 }
 656
 657 DBusMessage *
 658 droute_out_of_memory_error (DBusMessage *message)
 659 {
 660     DBusMessage *reply;
 661     gchar       *errmsg;
 662
 663     errmsg= g_strdup_printf (
 664             "Method \"%s\" with signature \"%s\" on interface \"%s\" could not be processed due to lack of memory\n",
 665             dbus_message_get_member (message),
 666             dbus_message_get_signature (message),
 667             dbus_message_get_interface (message));
 668     reply = dbus_message_new_error (message,
 669                                     DBUS_ERROR_NO_MEMORY,
 670                                     errmsg);
 671     g_free (errmsg);
 672     return reply;
 673 }
 674
 675 DBusMessage *
 676 droute_invalid_arguments_error (DBusMessage *message)
 677 {
 678     DBusMessage *reply;
 679     gchar       *errmsg;
 680
 681     errmsg= g_strdup_printf (
 682             "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n",
 683             dbus_message_get_member (message),
 684             dbus_message_get_signature (message),
 685             dbus_message_get_interface (message));
 686     reply = dbus_message_new_error (message,
 687                                     DBUS_ERROR_INVALID_ARGS,
 688                                     errmsg);
 689     g_free (errmsg);
 690     return reply;
 691 }
 692
 693 void
 694 droute_path_register (DRoutePath *path, DBusConnection *bus)
 695 {
 696     if (path->prefix)
 697       dbus_connection_register_fallback (bus, path->path, &droute_vtable, path);
 698     else
 699       dbus_connection_register_object_path (bus, path->path,
 700                                             &droute_vtable, path);
 701 }
 702
 703 void
 704 droute_path_unregister (DRoutePath *path, DBusConnection *bus)
 705 {
 706   dbus_connection_unregister_object_path (bus, path->path);
 707 }
 708
 709 void
 710 droute_context_register (DRouteContext *cnx, DBusConnection *bus)
 711 {
 712     g_ptr_array_foreach (cnx->registered_paths, (GFunc) droute_path_register,
 713                          bus);
 714 }
 715
 716 void
 717 droute_context_unregister (DRouteContext *cnx, DBusConnection *bus)
 718 {
 719     g_ptr_array_foreach (cnx->registered_paths, (GFunc) droute_path_unregister,
 720                          bus);
 721 }
 722
 723 void
 724 droute_context_deregister (DRouteContext *cnx, DBusConnection *bus)
 725 {
 726     g_ptr_array_foreach (cnx->registered_paths, (GFunc) droute_path_unregister,
 727                          bus);
 728 }
 729
 730 void
 731 droute_intercept_dbus (DBusConnection *bus)
 732 {
 733     dbus_connection_register_object_path (bus, DBUS_PATH_DBUS,
 734                                           &droute_vtable, NULL);
 735 }
 736
 737 void
 738 droute_unintercept_dbus (DBusConnection *bus)
 739 {
 740     dbus_connection_unregister_object_path (bus, DBUS_PATH_DBUS);
 741 }
 742
 743 /*END------------------------------------------------------------------------*/