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 Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 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  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "droute.h"
  28 #include "droute-pairhash.h"
  29
  30 #define CHUNKS_DEFAULT (512)
  31
  32 #define oom() g_error ("D-Bus out of memory, this message will fail anyway")
  33
  34 #if defined DROUTE_DEBUG
  35     #define _DROUTE_DEBUG(format, args...) g_print (format , ## args)
  36 #else
  37     #define _DROUTE_DEBUG(format, args...)
  38 #endif
  39
  40 struct _DRouteContext
  41 {
  42     DBusConnection       *bus;
  43     GPtrArray            *registered_paths;
  44
  45     gchar                *introspect_dir;
  46 };
  47
  48 struct _DRoutePath
  49 {
  50     DRouteContext        *cnx;
  51     GStringChunk         *chunks;
  52     GPtrArray            *interfaces;
  53     GHashTable           *methods;
  54     GHashTable           *properties;
  55
  56     void                   *user_data;
  57     DRouteGetDatumFunction  get_datum;
  58 };
  59
  60 /*---------------------------------------------------------------------------*/
  61
  62 typedef struct PropertyPair
  63 {
  64     DRoutePropertyFunction get;
  65     DRoutePropertyFunction set;
  66 } PropertyPair;
  67
  68 /*---------------------------------------------------------------------------*/
  69
  70 static DBusHandlerResult
  71 handle_message (DBusConnection *bus, DBusMessage *message, void *user_data);
  72
  73 /*---------------------------------------------------------------------------*/
  74
  75 static DRoutePath *
  76 path_new (DRouteContext *cnx,
  77           void    *user_data,
  78           DRouteGetDatumFunction get_datum)
  79 {
  80     DRoutePath *new_path;
  81
  82     new_path = g_new0 (DRoutePath, 1);
  83     new_path->cnx = cnx;
  84     new_path->chunks = g_string_chunk_new (CHUNKS_DEFAULT);
  85     new_path->interfaces = g_ptr_array_new ();
  86
  87     new_path->methods = g_hash_table_new_full ((GHashFunc)str_pair_hash,
  88                                                str_pair_equal,
  89                                                g_free,
  90                                                NULL);
  91
  92     new_path->properties = g_hash_table_new_full ((GHashFunc)str_pair_hash,
  93                                                   str_pair_equal,
  94                                                   g_free,
  95                                                   NULL);
  96
  97     new_path->user_data = user_data;
  98     new_path->get_datum = get_datum;
  99
 100     return new_path;
 101 }
 102
 103 static void
 104 path_free (DRoutePath *path, gpointer user_data)
 105 {
 106     g_string_chunk_free  (path->chunks);
 107     g_ptr_array_free     (path->interfaces, TRUE);
 108     g_hash_table_destroy (path->methods);
 109     g_hash_table_destroy (path->properties);
 110 }
 111
 112 static void *
 113 path_get_datum (DRoutePath *path, const gchar *pathstr)
 114 {
 115     if (path->get_datum != NULL)
 116         return (path->get_datum) (pathstr, path->user_data);
 117     else
 118         return path->user_data;
 119 }
 120
 121 /*---------------------------------------------------------------------------*/
 122
 123 DRouteContext *
 124 droute_new (DBusConnection *bus, const char *introspect_dir)
 125 {
 126     DRouteContext *cnx;
 127
 128     cnx = g_new0 (DRouteContext, 1);
 129     cnx->bus = bus;
 130     cnx->registered_paths = g_ptr_array_new ();
 131     cnx->introspect_dir = g_strdup(introspect_dir);
 132
 133     return cnx;
 134 }
 135
 136 void
 137 droute_free (DRouteContext *cnx)
 138 {
 139     g_ptr_array_foreach (cnx->registered_paths, (GFunc) path_free, NULL);
 140     g_free (cnx->introspect_dir);
 141     g_free (cnx);
 142 }
 143
 144 /*---------------------------------------------------------------------------*/
 145
 146 DBusConnection *
 147 droute_get_bus (DRouteContext *cnx)
 148 {
 149     return cnx->bus;
 150 }
 151
 152 /*---------------------------------------------------------------------------*/
 153
 154 static DBusObjectPathVTable droute_vtable =
 155 {
 156   NULL,
 157   &handle_message,
 158   NULL, NULL, NULL, NULL
 159 };
 160
 161 DRoutePath *
 162 droute_add_one (DRouteContext *cnx,
 163                 const char    *path,
 164                 const void    *data)
 165 {
 166     DRoutePath *new_path;
 167     gboolean registered;
 168
 169     new_path = path_new (cnx, (void *) data, NULL);
 170
 171     registered = dbus_connection_register_object_path (cnx->bus, path, &droute_vtable, new_path);
 172     if (!registered)
 173         oom();
 174
 175     g_ptr_array_add (cnx->registered_paths, new_path);
 176     return new_path;
 177 }
 178
 179 DRoutePath *
 180 droute_add_many (DRouteContext *cnx,
 181                  const char    *path,
 182                  const void    *data,
 183                  const DRouteGetDatumFunction get_datum)
 184 {
 185     DRoutePath *new_path;
 186
 187     new_path = path_new (cnx, (void *) data, get_datum);
 188
 189     if (!dbus_connection_register_fallback (cnx->bus, path, &droute_vtable, new_path))
 190         oom();
 191
 192     g_ptr_array_add (cnx->registered_paths, new_path);
 193     return new_path;
 194 }
 195
 196 /*---------------------------------------------------------------------------*/
 197
 198 void
 199 droute_path_add_interface(DRoutePath *path,
 200                           const char *name,
 201                           const DRouteMethod   *methods,
 202                           const DRouteProperty *properties)
 203 {
 204     gchar *itf;
 205
 206     g_return_if_fail (name != NULL);
 207
 208     itf = g_string_chunk_insert (path->chunks, name);
 209     g_ptr_array_add (path->interfaces, itf);
 210
 211     for (; methods != NULL && methods->name != NULL; methods++)
 212       {
 213         gchar *meth;
 214
 215         meth = g_string_chunk_insert (path->chunks, methods->name);
 216         g_hash_table_insert (path->methods, str_pair_new (itf, meth), methods->func);
 217       }
 218
 219     for (; properties != NULL && properties->name != NULL; properties++)
 220       {
 221         gchar *prop;
 222         PropertyPair *pair;
 223
 224         prop = g_string_chunk_insert (path->chunks, properties->name);
 225         pair = g_new (PropertyPair, 1);
 226         pair->get = properties->get;
 227         pair->set = properties->set;
 228         g_hash_table_insert (path->properties, str_pair_new (itf, prop), pair);
 229       }
 230 }
 231
 232 /*---------------------------------------------------------------------------*/
 233
 234 /* The data structures don't support an efficient implementation of GetAll
 235  * and I don't really care.
 236  */
 237 static DBusMessage *
 238 impl_prop_GetAll (DBusMessage *message,
 239                   DRoutePath  *path,
 240                   const char  *pathstr)
 241 {
 242     DBusMessageIter iter, iter_dict, iter_dict_entry;
 243     DBusMessage *reply;
 244     DBusError error;
 245     GHashTableIter prop_iter;
 246
 247     StrPair *key;
 248     PropertyPair *value;
 249     gchar *iface;
 250
 251     void  *datum = path_get_datum (path, pathstr);
 252
 253     dbus_error_init (&error);
 254     if (!dbus_message_get_args
 255                 (message, &error, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID))
 256         return dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
 257
 258     reply = dbus_message_new_method_return (message);
 259     if (!reply)
 260         oom ();
 261
 262     dbus_message_iter_init_append (reply, &iter);
 263     if (!dbus_message_iter_open_container
 264                 (&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict))
 265         oom ();
 266
 267     g_hash_table_iter_init (&prop_iter, path->properties);
 268     while (g_hash_table_iter_next (&prop_iter, (gpointer*)&key, (gpointer*)&value))
 269       {
 270         if (!g_strcmp0 (key->one, iface))
 271          {
 272            if (!value->get)
 273               continue;
 274            if (!dbus_message_iter_open_container
 275                         (&iter_dict, DBUS_TYPE_DICT_ENTRY, NULL, &iter_dict_entry))
 276               oom ();
 277            dbus_message_iter_append_basic (&iter_dict_entry, DBUS_TYPE_STRING,
 278                                            key->two);
 279            (value->get) (&iter_dict_entry, datum);
 280            if (!dbus_message_iter_close_container (&iter_dict, &iter_dict_entry))
 281                oom ();
 282          }
 283       }
 284
 285     if (!dbus_message_iter_close_container (&iter, &iter_dict))
 286         oom ();
 287     return reply;
 288 }
 289
 290 static DBusMessage *
 291 impl_prop_GetSet (DBusMessage *message,
 292                   DRoutePath  *path,
 293                   const char  *pathstr,
 294                   gboolean     get)
 295 {
 296     DBusMessage *reply = NULL;
 297     DBusError error;
 298
 299     StrPair pair;
 300     PropertyPair *prop_funcs = NULL;
 301
 302
 303     dbus_error_init (&error);
 304     if (!dbus_message_get_args (message,
 305                                 &error,
 306                                 DBUS_TYPE_STRING,
 307                                 &(pair.one),
 308                                 DBUS_TYPE_STRING,
 309                                 &(pair.two),
 310                                 DBUS_TYPE_INVALID))
 311         return dbus_message_new_error (message, DBUS_ERROR_FAILED, error.message);
 312
 313     _DROUTE_DEBUG ("DRoute (handle prop): %s|%s on %s\n", pair.one, pair.two, pathstr);
 314
 315     prop_funcs = (PropertyPair *) g_hash_table_lookup (path->properties, &pair);
 316     if (!prop_funcs)
 317         return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
 318
 319     if (get && prop_funcs->get)
 320       {
 321         void *datum = path_get_datum (path, pathstr);
 322         DBusMessageIter iter;
 323
 324         _DROUTE_DEBUG ("DRoute (handle prop Get): %s|%s on %s\n", pair.one, pair.two, pathstr);
 325
 326         reply = dbus_message_new_method_return (message);
 327         dbus_message_iter_init_append (reply, &iter);
 328         if (!(prop_funcs->get) (&iter, datum))
 329           {
 330             dbus_message_unref (reply);
 331             reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Get failed");
 332           }
 333       }
 334     else if (!get && prop_funcs->set)
 335       {
 336         void *datum = path_get_datum (path, pathstr);
 337         DBusMessageIter iter;
 338
 339         _DROUTE_DEBUG ("DRoute (handle prop Get): %s|%s on %s\n", pair.one, pair.two, pathstr);
 340
 341         dbus_message_iter_init (message, &iter);
 342         /* Skip the interface and property name */
 343         dbus_message_iter_next(&iter);
 344         dbus_message_iter_next(&iter);
 345         (prop_funcs->set) (&iter, datum);
 346
 347         reply = dbus_message_new_method_return (message);
 348       }
 349     else
 350       {
 351         reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Getter or setter unavailable");
 352       }
 353
 354     return reply;
 355 }
 356
 357 static DBusHandlerResult
 358 handle_properties (DBusConnection *bus,
 359                    DBusMessage    *message,
 360                    DRoutePath     *path,
 361                    const gchar    *iface,
 362                    const gchar    *member,
 363                    const gchar    *pathstr)
 364 {
 365     DBusMessage *reply;
 366     DBusHandlerResult result = DBUS_HANDLER_RESULT_HANDLED;
 367
 368     if (!g_strcmp0(member, "GetAll"))
 369        reply = impl_prop_GetAll (message, path, pathstr);
 370     else if (!g_strcmp0 (member, "Get"))
 371        reply = impl_prop_GetSet (message, path, pathstr, TRUE);
 372     else if (!g_strcmp0 (member, "Set"))
 373        reply = impl_prop_GetSet (message, path, pathstr, FALSE);
 374     else
 375        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 376
 377     if (reply)
 378       {
 379         dbus_connection_send (bus, reply, NULL);
 380         dbus_message_unref (reply);
 381       }
 382
 383     return result;
 384 }
 385
 386 /*---------------------------------------------------------------------------*/
 387
 388 static const char *introspection_header =
 389 "<?xml version=\"1.0\"?>\n";
 390
 391 static const char *introspection_node_element =
 392 "<node name=\"%s\">\n";
 393
 394 static const char *introspection_footer =
 395 "</node>";
 396
 397 static void
 398 append_interface (GString     *str,
 399                   const gchar *interface,
 400                   const gchar *directory)
 401 {
 402     gchar *filename;
 403     gchar *contents;
 404     gsize len;
 405
 406     GError *err = NULL;
 407
 408     filename = g_build_filename (directory, interface, NULL);
 409
 410     if (g_file_get_contents (filename, &contents, &len, &err))
 411       {
 412         g_string_append_len (str, contents, len);
 413       }
 414     else
 415       {
 416         g_warning ("AT-SPI: Cannot find introspection XML file %s - %s",
 417                    filename, err->message);
 418         g_error_free (err);
 419       }
 420
 421     g_string_append (str, "\n");
 422     g_free (filename);
 423     g_free (contents);
 424 }
 425
 426 static DBusHandlerResult
 427 handle_introspection (DBusConnection *bus,
 428                       DBusMessage    *message,
 429                       DRoutePath     *path,
 430                       const gchar    *iface,
 431                       const gchar    *member,
 432                       const gchar    *pathstr)
 433 {
 434     GString *output;
 435     gchar *final;
 436     gint i;
 437
 438     DBusMessage *reply;
 439
 440     _DROUTE_DEBUG ("DRoute (handle introspection): %s\n", pathstr);
 441
 442     if (g_strcmp0 (member, "Introspect"))
 443         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 444
 445     output = g_string_new(introspection_header);
 446
 447     g_string_append_printf(output, introspection_node_element, pathstr);
 448
 449     for (i=0; i < path->interfaces->len; i++)
 450       {
 451         gchar *interface = (gchar *) g_ptr_array_index (path->interfaces, i);
 452         append_interface(output, interface, path->cnx->introspect_dir);
 453       }
 454
 455     g_string_append(output, introspection_footer);
 456     final = g_string_free(output, FALSE);
 457
 458     reply = dbus_message_new_method_return (message);
 459     if (!reply)
 460         oom ();
 461     dbus_message_append_args(reply, DBUS_TYPE_STRING, &final,
 462                              DBUS_TYPE_INVALID);
 463     dbus_connection_send (bus, reply, NULL);
 464
 465     dbus_message_unref (reply);
 466     g_free(final);
 467     return DBUS_HANDLER_RESULT_HANDLED;
 468 }
 469
 470 /*---------------------------------------------------------------------------*/
 471
 472 static DBusHandlerResult
 473 handle_other (DBusConnection *bus,
 474               DBusMessage    *message,
 475               DRoutePath     *path,
 476               const gchar    *iface,
 477               const gchar    *member,
 478               const gchar    *pathstr)
 479 {
 480     gint result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 481
 482     StrPair pair;
 483     DRouteFunction func;
 484     DBusMessage *reply = NULL;
 485
 486     pair.one = iface;
 487     pair.two = member;
 488
 489     _DROUTE_DEBUG ("DRoute (handle other): %s|%s on %s\n", member, iface, pathstr);
 490
 491     func = (DRouteFunction) g_hash_table_lookup (path->methods, &pair);
 492     if (func != NULL)
 493       {
 494         void *datum = path_get_datum (path, pathstr);
 495
 496         reply = (func) (bus, message, datum);
 497
 498         if (!reply)
 499           {
 500             /* All D-Bus method calls must have a reply.
 501              * If one is not provided presume that the call has a void
 502              * return and no error has occured.
 503              */
 504             reply = dbus_message_new_method_return (message);
 505           }
 506         dbus_connection_send (bus, reply, NULL);
 507         dbus_message_unref (reply);
 508         result = DBUS_HANDLER_RESULT_HANDLED;
 509       }
 510
 511     _DROUTE_DEBUG ("DRoute (handle other) (reply): type %d\n",
 512                    dbus_message_get_type(reply));
 513     return result;
 514 }
 515
 516 /*---------------------------------------------------------------------------*/
 517
 518 static DBusHandlerResult
 519 handle_message (DBusConnection *bus, DBusMessage *message, void *user_data)
 520 {
 521     DRoutePath *path = (DRoutePath *) user_data;
 522     const gchar *iface   = dbus_message_get_interface (message);
 523     const gchar *member  = dbus_message_get_member (message);
 524     const gint   type    = dbus_message_get_type (message);
 525     const gchar *pathstr = dbus_message_get_path (message);
 526
 527     /* Check for basic reasons not to handle */
 528     if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
 529         member == NULL ||
 530         iface  == NULL)
 531         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 532
 533     if (!strcmp (iface, "org.freedesktop.DBus.Properties"))
 534         return handle_properties (bus, message, path, iface, member, pathstr);
 535
 536     if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
 537         return handle_introspection (bus, message, path, iface, member, pathstr);
 538
 539     return handle_other (bus, message, path, iface, member, pathstr);
 540 }
 541
 542 /*---------------------------------------------------------------------------*/
 543
 544 DBusMessage *
 545 droute_not_yet_handled_error (DBusMessage *message)
 546 {
 547     DBusMessage *reply;
 548     gchar       *errmsg;
 549
 550     errmsg= g_strdup_printf (
 551             "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
 552             dbus_message_get_member (message),
 553             dbus_message_get_signature (message),
 554             dbus_message_get_interface (message));
 555     reply = dbus_message_new_error (message,
 556                                     DBUS_ERROR_UNKNOWN_METHOD,
 557                                     errmsg);
 558     g_free (errmsg);
 559     return reply;
 560 }
 561
 562 DBusMessage *
 563 droute_out_of_memory_error (DBusMessage *message)
 564 {
 565     DBusMessage *reply;
 566     gchar       *errmsg;
 567
 568     errmsg= g_strdup_printf (
 569             "Method \"%s\" with signature \"%s\" on interface \"%s\" could not be processed due to lack of memory\n",
 570             dbus_message_get_member (message),
 571             dbus_message_get_signature (message),
 572             dbus_message_get_interface (message));
 573     reply = dbus_message_new_error (message,
 574                                     DBUS_ERROR_NO_MEMORY,
 575                                     errmsg);
 576     g_free (errmsg);
 577     return reply;
 578 }
 579
 580 DBusMessage *
 581 droute_invalid_arguments_error (DBusMessage *message)
 582 {
 583     DBusMessage *reply;
 584     gchar       *errmsg;
 585
 586     errmsg= g_strdup_printf (
 587             "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n",
 588             dbus_message_get_member (message),
 589             dbus_message_get_signature (message),
 590             dbus_message_get_interface (message));
 591     reply = dbus_message_new_error (message,
 592                                     DBUS_ERROR_INVALID_ARGS,
 593                                     errmsg);
 594     g_free (errmsg);
 595     return reply;
 596 }
 597
 598 /*END------------------------------------------------------------------------*/