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
  34 #include "helpers.h"
  35 #include "method.h"
  36 #include "../log.h"
  37 #include "../assert.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     log_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     log_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     log_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     log_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     log_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       log_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   //log_info("dbus_call('%s', '%s', '%s', '%s')", service, object, iface, method);
 295
 296   ret = false;
 297   va_start(ap, input_signature);
 298
 299   if (input_signature != NULL)
 300   {
 301     if (!dbus_signature_validate(input_signature, NULL))
 302     {
 303       log_error("input signature '%s' is invalid", input_signature);
 304       goto fail;
 305     }
 306
 307     dbus_signature_iter_init(&sig_iter, input_signature);
 308
 309     request_ptr = dbus_message_new_method_call(service, object, iface, method);
 310     if (request_ptr == NULL)
 311     {
 312       log_error("dbus_message_new_method_call() failed.");
 313       goto fail;
 314     }
 315
 316     dbus_message_iter_init_append(request_ptr, &iter);
 317
 318     while (*input_signature != '\0')
 319     {
 320       type = dbus_signature_iter_get_current_type(&sig_iter);
 321       if (!dbus_type_is_basic(type))
 322       {
 323         log_error("non-basic input parameter '%c' (%d)", *input_signature, type);
 324         goto fail;
 325       }
 326
 327       parameter_ptr = va_arg(ap, void *);
 328
 329       if (!dbus_message_iter_append_basic(&iter, type, parameter_ptr))
 330       {
 331         log_error("dbus_message_iter_append_basic() failed.");
 332         goto fail;
 333       }
 334
 335       dbus_signature_iter_next(&sig_iter);
 336       input_signature++;
 337     }
 338   }
 339   else
 340   {
 341     request_ptr = va_arg(ap, DBusMessage *);
 342   }
 343
 344   output_signature = va_arg(ap, const char *);
 345
 346   reply_ptr = dbus_connection_send_with_reply_and_block(
 347     g_dbus_connection,
 348     request_ptr,
 349     DBUS_CALL_DEFAULT_TIMEOUT,
 350     &g_dbus_error);
 351
 352   if (input_signature != NULL)
 353   {
 354     dbus_message_unref(request_ptr);
 355   }
 356
 357   if (reply_ptr == NULL)
 358   {
 359     log_error("calling method '%s' failed, error is '%s'", method, g_dbus_error.message);
 360     dbus_error_free(&g_dbus_error);
 361     goto fail;
 362   }
 363
 364   if (output_signature != NULL)
 365   {
 366     reply_signature = dbus_message_get_signature(reply_ptr);
 367
 368     if (strcmp(reply_signature, output_signature) != 0)
 369     {
 370       log_error("reply signature is '%s' but expected signature is '%s'", reply_signature, output_signature);
 371     }
 372
 373     dbus_message_iter_init(reply_ptr, &iter);
 374
 375     while (*output_signature++ != '\0')
 376     {
 377       ASSERT(dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INVALID); /* we've checked the signature, this should not happen */
 378       parameter_ptr = va_arg(ap, void *);
 379       dbus_message_iter_get_basic(&iter, parameter_ptr);
 380       dbus_message_iter_next(&iter);
 381     }
 382
 383     ASSERT(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_INVALID); /* we've checked the signature, this should not happen */
 384     dbus_message_unref(reply_ptr);
 385   }
 386   else
 387   {
 388     parameter_ptr = va_arg(ap, DBusMessage **);
 389     *(DBusMessage **)parameter_ptr = reply_ptr;
 390   }
 391
 392   ret = true;
 393
 394 fail:
 395   va_end(ap);
 396   return ret;
 397 }
 398
 399 static
 400 const char *
 401 compose_signal_match(
 402   const char * service,
 403   const char * object,
 404   const char * iface,
 405   const char * signal)
 406 {
 407   static char rule[1024];
 408   snprintf(rule, sizeof(rule), "type='signal',sender='%s',path='%s',interface='%s',member='%s'", service, object, iface, signal);
 409   return rule;
 410 }
 411
 412 bool
 413 dbus_register_object_signal_handler(
 414   DBusConnection * connection,
 415   const char * service,
 416   const char * object,
 417   const char * iface,
 418   const char * const * signals,
 419   DBusHandleMessageFunction handler,
 420   void * handler_data)
 421 {
 422   const char * const * signal;
 423
 424   for (signal = signals; *signal != NULL; signal++)
 425   {
 426     dbus_bus_add_match(connection, compose_signal_match(service, object, iface, *signal), &g_dbus_error);
 427     if (dbus_error_is_set(&g_dbus_error))
 428     {
 429       log_error("Failed to add D-Bus match rule: %s", g_dbus_error.message);
 430       dbus_error_free(&g_dbus_error);
 431       return false;
 432     }
 433   }
 434
 435   dbus_connection_add_filter(g_dbus_connection, handler, handler_data, NULL);
 436
 437   return true;
 438 }
 439
 440 bool
 441 dbus_unregister_object_signal_handler(
 442   DBusConnection * connection,
 443   const char * service,
 444   const char * object,
 445   const char * iface,
 446   const char * const * signals,
 447   DBusHandleMessageFunction handler,
 448   void * handler_data)
 449 {
 450   const char * const * signal;
 451
 452   for (signal = signals; *signal != NULL; signal++)
 453   {
 454     dbus_bus_remove_match(connection, compose_signal_match(service, object, iface, *signal), &g_dbus_error);
 455     if (dbus_error_is_set(&g_dbus_error))
 456     {
 457       log_error("Failed to add D-Bus match rule: %s", g_dbus_error.message);
 458       dbus_error_free(&g_dbus_error);
 459       return false;
 460     }
 461   }
 462
 463   dbus_connection_remove_filter(g_dbus_connection, handler, handler_data);
 464
 465   return true;
 466 }