dbus/helpers.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008, 2009 Nedko Arnaudov <nedko@arnaudov.name>
   6  * Copyright (C) 2008 Juuso Alasuutari <juuso.alasuutari@gmail.com>
   7  *
   8  **************************************************************************
   9  * This file contains code of the D-Bus helpers
  10  **************************************************************************
  11  *
  12  * Licensed under the Academic Free License version 2.1
  13  *
  14  * LADI Session Handler is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * LADI Session Handler is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  26  * or write to the Free Software Foundation, Inc.,
  27  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  28  */
  29
  30 #include <stdbool.h>
  31 #include <dbus/dbus.h>
  32 #include <string.h>
  33 #include <assert.h>
  34
  35 #include "helpers.h"
  36 #include "method.h"
  37 #include "../common/debug.h"
  38
  39 DBusConnection * g_dbus_connection;
  40 DBusError g_dbus_error;
  41
  42 bool dbus_iter_get_dict_entry(DBusMessageIter * iter, const char ** key_ptr, void * value_ptr, int * type_ptr, int * size_ptr)
  43 {
  44   if (!iter || !key_ptr || !value_ptr || !type_ptr) {
  45     lash_error("Invalid arguments");
  46     return false;
  47   }
  48
  49   DBusMessageIter dict_iter, variant_iter;
  50
  51   if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_DICT_ENTRY) {
  52     lash_error("Iterator does not point to a dict entry container");
  53     return false;
  54   }
  55
  56   dbus_message_iter_recurse(iter, &dict_iter);
  57
  58   if (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_STRING) {
  59     lash_error("Cannot find key in dict entry container");
  60     return false;
  61   }
  62
  63   dbus_message_iter_get_basic(&dict_iter, key_ptr);
  64
  65   if (!dbus_message_iter_next(&dict_iter)
  66       || dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_VARIANT) {
  67     lash_error("Cannot find variant container in dict entry");
  68     return false;
  69   }
  70
  71   dbus_message_iter_recurse(&dict_iter, &variant_iter);
  72
  73   *type_ptr = dbus_message_iter_get_arg_type(&variant_iter);
  74   if (*type_ptr == DBUS_TYPE_INVALID) {
  75     lash_error("Cannot find value in variant container");
  76     return false;
  77   }
  78
  79   if (*type_ptr == DBUS_TYPE_ARRAY) {
  80     DBusMessageIter array_iter;
  81     int n;
  82
  83     if (dbus_message_iter_get_element_type(&variant_iter)
  84         != DBUS_TYPE_BYTE) {
  85       lash_error("Dict entry value is a non-byte array");
  86       return false;
  87     }
  88     *type_ptr = '-';
  89
  90     dbus_message_iter_recurse(&variant_iter, &array_iter);
  91     dbus_message_iter_get_fixed_array(&array_iter, value_ptr, &n);
  92
  93     if (size_ptr)
  94       *size_ptr = n;
  95   } else
  96     dbus_message_iter_get_basic(&variant_iter, value_ptr);
  97
  98   return true;
  99 }
 100
 101 /*
 102  * Append a variant type to a D-Bus message.
 103  * Return false if something fails, true otherwise.
 104  */
 105 bool dbus_iter_append_variant(DBusMessageIter * iter, int type, const void * arg)
 106 {
 107   DBusMessageIter sub_iter;
 108   char s[2];
 109
 110   s[0] = (char)type;
 111   s[1] = '\0';
 112
 113   /* Open a variant container. */
 114   if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, (const char *)s, &sub_iter))
 115     return false;
 116
 117   /* Append the supplied value. */
 118   if (!dbus_message_iter_append_basic(&sub_iter, type, arg))
 119   {
 120     dbus_message_iter_close_container(iter, &sub_iter);
 121     return false;
 122   }
 123
 124   /* Close the container. */
 125   if (!dbus_message_iter_close_container(iter, &sub_iter))
 126     return false;
 127
 128   return true;
 129 }
 130
 131 static __inline__ bool dbus_iter_append_variant_raw(DBusMessageIter * iter, const void * buf, int len)
 132 {
 133   DBusMessageIter variant_iter, array_iter;
 134
 135   /* Open a variant container. */
 136   if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 137                                         "ay", &variant_iter))
 138     return false;
 139
 140   /* Open an array container. */
 141   if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
 142                                         "y", &array_iter))
 143     goto fail;
 144
 145   /* Append the supplied data. */
 146   if (!dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, buf, len)) {
 147     dbus_message_iter_close_container(&variant_iter, &array_iter);
 148     goto fail;
 149   }
 150
 151   /* Close the containers. */
 152   if (!dbus_message_iter_close_container(&variant_iter, &array_iter))
 153     goto fail;
 154   else if (!dbus_message_iter_close_container(iter, &variant_iter))
 155     return false;
 156
 157   return true;
 158
 159 fail:
 160   dbus_message_iter_close_container(iter, &variant_iter);
 161   return false;
 162 }
 163
 164 bool dbus_iter_append_dict_entry(DBusMessageIter * iter, int type, const char * key, const void * value, int length)
 165 {
 166   DBusMessageIter dict_iter;
 167
 168   if (!dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter))
 169     return false;
 170
 171   if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &key))
 172     goto fail;
 173
 174   if (type == '-')
 175   {
 176     if (!dbus_iter_append_variant_raw(&dict_iter, value, length))
 177       goto fail;
 178   }
 179   else if (!dbus_iter_append_variant(&dict_iter, type, value))
 180   {
 181     goto fail;
 182   }
 183
 184   if (!dbus_message_iter_close_container(iter, &dict_iter))
 185     return false;
 186
 187   return true;
 188
 189 fail:
 190   dbus_message_iter_close_container(iter, &dict_iter);
 191   return false;
 192 }
 193
 194 bool dbus_maybe_add_dict_entry_string(DBusMessageIter *dict_iter_ptr, const char * key, const char * value)
 195 {
 196   DBusMessageIter dict_entry_iter;
 197
 198   if (value == NULL)
 199   {
 200     return true;
 201   }
 202
 203   if (!dbus_message_iter_open_container(dict_iter_ptr, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter))
 204   {
 205     return false;
 206   }
 207
 208   if (!dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, (const void *) &key))
 209   {
 210     dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter);
 211     return false;
 212   }
 213
 214   dbus_iter_append_variant(&dict_entry_iter, DBUS_TYPE_STRING, &value);
 215
 216   if (!dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter))
 217   {
 218     return false;
 219   }
 220
 221   return true;
 222 }
 223
 224 bool dbus_add_dict_entry_uint32(DBusMessageIter * dict_iter_ptr, const char * key, dbus_uint32_t value)
 225 {
 226   DBusMessageIter dict_entry_iter;
 227
 228   if (!dbus_message_iter_open_container(dict_iter_ptr, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter))
 229   {
 230     return false;
 231   }
 232
 233   if (!dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, (const void *) &key))
 234   {
 235     dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter);
 236     return false;
 237   }
 238
 239   dbus_iter_append_variant(&dict_entry_iter, DBUS_TYPE_UINT32, &value);
 240
 241   if (!dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter))
 242   {
 243     return false;
 244   }
 245
 246   return true;
 247 }
 248
 249 bool dbus_add_dict_entry_bool(DBusMessageIter * dict_iter_ptr, const char * key, dbus_bool_t value)
 250 {
 251   DBusMessageIter dict_entry_iter;
 252
 253   if (!dbus_message_iter_open_container(dict_iter_ptr, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter))
 254   {
 255     return false;
 256   }
 257
 258   if (!dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, (const void *) &key))
 259   {
 260     dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter);
 261     return false;
 262   }
 263
 264   dbus_iter_append_variant(&dict_entry_iter, DBUS_TYPE_BOOLEAN, &value);
 265
 266   if (!dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter))
 267   {
 268     return false;
 269   }
 270
 271   return true;
 272 }
 273
 274 bool
 275 dbus_call(
 276   const char * service,
 277   const char * object,
 278   const char * iface,
 279   const char * method,
 280   const char * input_signature,
 281   ...)
 282 {
 283   DBusMessageIter iter;
 284   DBusMessage * request_ptr;
 285   DBusMessage * reply_ptr;
 286   const char * output_signature;
 287   const char * reply_signature;
 288   va_list ap;
 289   bool ret;
 290   void * parameter_ptr;
 291   int type;
 292   DBusSignatureIter sig_iter;
 293
 294   //lash_info("dbus_call('%s', '%s', '%s', '%s')", service, object, iface, method);
 295
 296   ret = false;
 297   va_start(ap, input_signature);
 298
 299   if (!dbus_signature_validate(input_signature, NULL))
 300   {
 301     lash_error("input signature '%s' is invalid", input_signature);
 302     goto fail;
 303   }
 304
 305   dbus_signature_iter_init(&sig_iter, input_signature);
 306
 307   request_ptr = dbus_message_new_method_call(service, object, iface, method);
 308   if (request_ptr == NULL)
 309   {
 310     lash_error("dbus_message_new_method_call() failed.");
 311     goto fail;
 312   }
 313
 314   dbus_message_iter_init_append(request_ptr, &iter);
 315
 316   while (*input_signature != '\0')
 317   {
 318     type = dbus_signature_iter_get_current_type(&sig_iter);
 319     if (!dbus_type_is_basic(type))
 320     {
 321       lash_error("non-basic input parameter '%c' (%d)", *input_signature, type);
 322       goto fail;
 323     }
 324
 325     parameter_ptr = va_arg(ap, void *);
 326
 327     if (!dbus_message_iter_append_basic(&iter, type, parameter_ptr))
 328     {
 329       lash_error("dbus_message_iter_append_basic() failed.");
 330       goto fail;
 331     }
 332
 333     dbus_signature_iter_next(&sig_iter);
 334     input_signature++;
 335   }
 336
 337   output_signature = va_arg(ap, const char *);
 338
 339   reply_ptr = dbus_connection_send_with_reply_and_block(
 340     g_dbus_connection,
 341     request_ptr,
 342     DBUS_CALL_DEFAULT_TIMEOUT,
 343     &g_dbus_error);
 344
 345   dbus_message_unref(request_ptr);
 346
 347   if (reply_ptr == NULL)
 348   {
 349     lash_error("calling method '%s' failed, error is '%s'", method, g_dbus_error.message);
 350     dbus_error_free(&g_dbus_error);
 351     goto fail;
 352   }
 353
 354   if (output_signature != NULL)
 355   {
 356     reply_signature = dbus_message_get_signature(reply_ptr);
 357
 358     if (strcmp(reply_signature, output_signature) != 0)
 359     {
 360       lash_error("reply signature is '%s' but expected signature is '%s'", reply_signature, output_signature);
 361     }
 362
 363     dbus_message_iter_init(reply_ptr, &iter);
 364
 365     while (*output_signature++ != '\0')
 366     {
 367       assert(dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INVALID); /* we've checked the signature, this should not happen */
 368       parameter_ptr = va_arg(ap, void *);
 369       dbus_message_iter_get_basic(&iter, parameter_ptr);
 370       dbus_message_iter_next(&iter);
 371     }
 372
 373     assert(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_INVALID); /* we've checked the signature, this should not happen */
 374   }
 375   else
 376   {
 377     parameter_ptr = va_arg(ap, DBusMessage **);
 378     *(DBusMessage **)parameter_ptr = reply_ptr;
 379   }
 380
 381   ret = true;
 382
 383 fail:
 384   va_end(ap);
 385   return ret;
 386 }
 387
 388 static
 389 const char *
 390 compose_signal_match(
 391   const char * service,
 392   const char * object,
 393   const char * iface,
 394   const char * signal)
 395 {
 396   static char rule[1024];
 397   snprintf(rule, sizeof(rule), "type='signal',sender='%s',path='%s',interface='%s',member='%s'", service, object, iface, signal);
 398   return rule;
 399 }
 400
 401 bool
 402 dbus_register_object_signal_handler(
 403   DBusConnection * connection,
 404   const char * service,
 405   const char * object,
 406   const char * iface,
 407   const char * const * signals,
 408   DBusHandleMessageFunction handler,
 409   void * handler_data)
 410 {
 411   const char * const * signal;
 412
 413   for (signal = signals; *signal != NULL; signal++)
 414   {
 415     dbus_bus_add_match(connection, compose_signal_match(service, object, iface, *signal), &g_dbus_error);
 416     if (dbus_error_is_set(&g_dbus_error))
 417     {
 418       lash_error("Failed to add D-Bus match rule: %s", g_dbus_error.message);
 419       dbus_error_free(&g_dbus_error);
 420       return false;
 421     }
 422   }
 423
 424   dbus_connection_add_filter(g_dbus_connection, handler, handler_data, NULL);
 425
 426   return true;
 427 }
 428
 429 bool
 430 dbus_unregister_object_signal_handler(
 431   DBusConnection * connection,
 432   const char * service,
 433   const char * object,
 434   const char * iface,
 435   const char * const * signals,
 436   DBusHandleMessageFunction handler,
 437   void * handler_data)
 438 {
 439   const char * const * signal;
 440
 441   for (signal = signals; *signal != NULL; signal++)
 442   {
 443     dbus_bus_remove_match(connection, compose_signal_match(service, object, iface, *signal), &g_dbus_error);
 444     if (dbus_error_is_set(&g_dbus_error))
 445     {
 446       lash_error("Failed to add D-Bus match rule: %s", g_dbus_error.message);
 447       dbus_error_free(&g_dbus_error);
 448       return false;
 449     }
 450   }
 451
 452   dbus_connection_remove_filter(g_dbus_connection, handler, handler_data);
 453
 454   return true;
 455 }