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     prop_funcs = (PropertyPair *) g_hash_table_lookup (path->properties, &pair);
 314     if (!prop_funcs)
 315         return dbus_message_new_error (message, DBUS_ERROR_FAILED, "Property unavailable");
 316
 317     if (get && prop_funcs->get)
 318       {
 319         void *datum = path_get_datum (path, pathstr);
 320         DBusMessageIter iter;
 321
 322         _DROUTE_DEBUG ("DRoute (handle prop Get): %s|%s on %s\n", pair.one, pair.two, pathstr);
 323
 324         reply = dbus_message_new_method_return (message);
 325         dbus_message_iter_init_append (reply, &iter);
 326         if (!(prop_funcs->get) (&iter, datum))
 327           {
 328             dbus_message_unref (reply);
 329             reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Get failed");
 330           }
 331       }
 332     else if (!get && prop_funcs->set)
 333       {
 334         void *datum = path_get_datum (path, pathstr);
 335         DBusMessageIter iter;
 336
 337         _DROUTE_DEBUG ("DRoute (handle prop Get): %s|%s on %s\n", pair.one, pair.two, pathstr);
 338
 339         dbus_message_iter_init (message, &iter);
 340         /* Skip the interface and property name */
 341         dbus_message_iter_next(&iter);
 342         dbus_message_iter_next(&iter);
 343         (prop_funcs->set) (&iter, datum);
 344
 345         reply = dbus_message_new_method_return (message);
 346       }
 347     else
 348       {
 349         reply = dbus_message_new_error (message, DBUS_ERROR_FAILED, "Getter or setter unavailable");
 350       }
 351
 352     return reply;
 353 }
 354
 355 static DBusHandlerResult
 356 handle_properties (DBusConnection *bus,
 357                    DBusMessage    *message,
 358                    DRoutePath     *path,
 359                    const gchar    *iface,
 360                    const gchar    *member,
 361                    const gchar    *pathstr)
 362 {
 363     DBusMessage *reply;
 364     DBusHandlerResult result = DBUS_HANDLER_RESULT_HANDLED;
 365
 366     if (!g_strcmp0(member, "GetAll"))
 367        reply = impl_prop_GetAll (message, path, pathstr);
 368     else if (!g_strcmp0 (member, "Get"))
 369        reply = impl_prop_GetSet (message, path, pathstr, TRUE);
 370     else if (!g_strcmp0 (member, "Set"))
 371        reply = impl_prop_GetSet (message, path, pathstr, FALSE);
 372     else
 373        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 374
 375     if (reply)
 376       {
 377         dbus_connection_send (bus, reply, NULL);
 378         dbus_message_unref (reply);
 379       }
 380
 381     return result;
 382 }
 383
 384 /*---------------------------------------------------------------------------*/
 385
 386 static const char *introspection_header =
 387 "<?xml version=\"1.0\"?>\n";
 388
 389 static const char *introspection_node_element =
 390 "<node name=\"%s\">\n";
 391
 392 static const char *introspection_footer =
 393 "</node>";
 394
 395 static void
 396 append_interface (GString     *str,
 397                   const gchar *interface,
 398                   const gchar *directory)
 399 {
 400     gchar *filename;
 401     gchar *contents;
 402     gsize len;
 403
 404     GError *err = NULL;
 405
 406     filename = g_build_filename (directory, interface, NULL);
 407
 408     if (g_file_get_contents (filename, &contents, &len, &err))
 409       {
 410         g_string_append_len (str, contents, len);
 411       }
 412     else
 413       {
 414         g_warning ("AT-SPI: Cannot find introspection XML file %s - %s",
 415                    filename, err->message);
 416         g_error_free (err);
 417       }
 418
 419     g_string_append (str, "\n");
 420     g_free (filename);
 421     g_free (contents);
 422 }
 423
 424 static DBusHandlerResult
 425 handle_introspection (DBusConnection *bus,
 426                       DBusMessage    *message,
 427                       DRoutePath     *path,
 428                       const gchar    *iface,
 429                       const gchar    *member,
 430                       const gchar    *pathstr)
 431 {
 432     GString *output;
 433     gchar *final;
 434     gint i;
 435
 436     DBusMessage *reply;
 437
 438     _DROUTE_DEBUG ("DRoute (handle introspection): %s\n", pathstr);
 439
 440     if (g_strcmp0 (member, "Introspect"))
 441         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 442
 443     output = g_string_new(introspection_header);
 444
 445     g_string_append_printf(output, introspection_node_element, pathstr);
 446
 447     for (i=0; i < path->interfaces->len; i++)
 448       {
 449         gchar *interface = (gchar *) g_ptr_array_index (path->interfaces, i);
 450         append_interface(output, interface, path->cnx->introspect_dir);
 451       }
 452
 453     g_string_append(output, introspection_footer);
 454     final = g_string_free(output, FALSE);
 455
 456     reply = dbus_message_new_method_return (message);
 457     if (!reply)
 458         oom ();
 459     dbus_message_append_args(reply, DBUS_TYPE_STRING, &final,
 460                              DBUS_TYPE_INVALID);
 461     dbus_connection_send (bus, reply, NULL);
 462
 463     dbus_message_unref (reply);
 464     g_free(final);
 465     return DBUS_HANDLER_RESULT_HANDLED;
 466 }
 467
 468 /*---------------------------------------------------------------------------*/
 469
 470 static DBusHandlerResult
 471 handle_other (DBusConnection *bus,
 472               DBusMessage    *message,
 473               DRoutePath     *path,
 474               const gchar    *iface,
 475               const gchar    *member,
 476               const gchar    *pathstr)
 477 {
 478     gint result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 479
 480     StrPair pair;
 481     DRouteFunction func;
 482     DBusMessage *reply = NULL;
 483
 484     pair.one = iface;
 485     pair.two = member;
 486
 487     _DROUTE_DEBUG ("DRoute (handle other): %s|%s on %s\n", member, iface, pathstr);
 488
 489     func = (DRouteFunction) g_hash_table_lookup (path->methods, &pair);
 490     if (func != NULL)
 491       {
 492         void *datum = path_get_datum (path, pathstr);
 493
 494         reply = (func) (bus, message, datum);
 495
 496         if (!reply)
 497           {
 498             /* All D-Bus method calls must have a reply.
 499              * If one is not provided presume that the call has a void
 500              * return and no error has occured.
 501              */
 502             reply = dbus_message_new_method_return (message);
 503           }
 504         dbus_connection_send (bus, reply, NULL);
 505         dbus_message_unref (reply);
 506         result = DBUS_HANDLER_RESULT_HANDLED;
 507       }
 508     return result;
 509 }
 510
 511 /*---------------------------------------------------------------------------*/
 512
 513 static DBusHandlerResult
 514 handle_message (DBusConnection *bus, DBusMessage *message, void *user_data)
 515 {
 516     DRoutePath *path = (DRoutePath *) user_data;
 517     const gchar *iface   = dbus_message_get_interface (message);
 518     const gchar *member  = dbus_message_get_member (message);
 519     const gint   type    = dbus_message_get_type (message);
 520     const gchar *pathstr = dbus_message_get_path (message);
 521
 522     /* Check for basic reasons not to handle */
 523     if (type   != DBUS_MESSAGE_TYPE_METHOD_CALL ||
 524         member == NULL ||
 525         iface  == NULL)
 526         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 527
 528     if (!strcmp (iface, "org.freedesktop.DBus.Properties"))
 529         return handle_properties (bus, message, path, iface, member, pathstr);
 530
 531     if (!strcmp (iface, "org.freedesktop.DBus.Introspectable"))
 532         return handle_introspection (bus, message, path, iface, member, pathstr);
 533
 534     return handle_other (bus, message, path, iface, member, pathstr);
 535 }
 536
 537 /*---------------------------------------------------------------------------*/
 538
 539 DBusMessage *
 540 droute_not_yet_handled_error (DBusMessage *message)
 541 {
 542     DBusMessage *reply;
 543     gchar       *errmsg;
 544
 545     errmsg= g_strdup_printf (
 546             "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
 547             dbus_message_get_member (message),
 548             dbus_message_get_signature (message),
 549             dbus_message_get_interface (message));
 550     reply = dbus_message_new_error (message,
 551                                     DBUS_ERROR_UNKNOWN_METHOD,
 552                                     errmsg);
 553     g_free (errmsg);
 554     return reply;
 555 }
 556
 557 DBusMessage *
 558 droute_out_of_memory_error (DBusMessage *message)
 559 {
 560     DBusMessage *reply;
 561     gchar       *errmsg;
 562
 563     errmsg= g_strdup_printf (
 564             "Method \"%s\" with signature \"%s\" on interface \"%s\" could not be processed due to lack of memory\n",
 565             dbus_message_get_member (message),
 566             dbus_message_get_signature (message),
 567             dbus_message_get_interface (message));
 568     reply = dbus_message_new_error (message,
 569                                     DBUS_ERROR_NO_MEMORY,
 570                                     errmsg);
 571     g_free (errmsg);
 572     return reply;
 573 }
 574
 575 DBusMessage *
 576 droute_invalid_arguments_error (DBusMessage *message)
 577 {
 578     DBusMessage *reply;
 579     gchar       *errmsg;
 580
 581     errmsg= g_strdup_printf (
 582             "Method \"%s\" with signature \"%s\" on interface \"%s\" was supplied with invalid arguments\n",
 583             dbus_message_get_member (message),
 584             dbus_message_get_signature (message),
 585             dbus_message_get_interface (message));
 586     reply = dbus_message_new_error (message,
 587                                     DBUS_ERROR_INVALID_ARGS,
 588                                     errmsg);
 589     g_free (errmsg);
 590     return reply;
 591 }
 592
 593 /*END------------------------------------------------------------------------*/