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