dbus/helpers.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2008, 2009, 2010 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 <stdlib.h>
  34
  35 #include "helpers.h"
  36 #include "method.h"
  37 #include "../log.h"
  38 #include "../assert.h"
  39 #include "../common/klist.h"
  40
  41 DBusConnection * g_dbus_connection;
  42 DBusError g_dbus_error;
  43
  44 struct dbus_signal_hook_descriptor
  45 {
  46   struct list_head siblings;
  47   char * object;
  48   char * interface;
  49   void * hook_context;
  50   const struct dbus_signal_hook * signal_hooks;
  51 };
  52
  53 struct dbus_service_descriptor
  54 {
  55   struct list_head siblings;
  56   char * service_name;
  57   void (* lifetime_hook_function)(bool appeared);
  58   struct list_head hooks;
  59 };
  60
  61 LIST_HEAD(g_dbus_services);
  62
  63 bool dbus_iter_get_dict_entry(DBusMessageIter * iter_ptr, const char * key, void * value, int * type, int * size)
  64 {
  65   DBusMessageIter dict_iter;
  66   DBusMessageIter entry_iter;
  67   DBusMessageIter variant_iter;
  68   const char * current_key;
  69   DBusMessageIter array_iter;
  70   int n;
  71   int detype;
  72
  73   dbus_message_iter_recurse(iter_ptr, &dict_iter);
  74
  75 loop:
  76   detype = dbus_message_iter_get_arg_type(&dict_iter);
  77
  78   if (detype == DBUS_TYPE_INVALID)
  79   {
  80     return false;
  81   }
  82
  83   if (detype != DBUS_TYPE_DICT_ENTRY)
  84   {
  85     log_error("Iterator does not point to a dict entry container");
  86     return false;
  87   }
  88
  89   dbus_message_iter_recurse(&dict_iter, &entry_iter);
  90
  91   if (dbus_message_iter_get_arg_type(&entry_iter) != DBUS_TYPE_STRING)
  92   {
  93     log_error("Cannot find key in dict entry container");
  94     return false;
  95   }
  96
  97   dbus_message_iter_get_basic(&entry_iter, &current_key);
  98   if (strcmp(current_key, key) != 0)
  99   {
 100     dbus_message_iter_next(&dict_iter);
 101     goto loop;
 102   }
 103
 104   if (!dbus_message_iter_next(&entry_iter) || dbus_message_iter_get_arg_type(&entry_iter) != DBUS_TYPE_VARIANT)
 105   {
 106     log_error("Cannot find variant container in dict entry");
 107     return false;
 108   }
 109
 110   dbus_message_iter_recurse(&entry_iter, &variant_iter);
 111
 112   *type = dbus_message_iter_get_arg_type(&variant_iter);
 113   if (*type == DBUS_TYPE_INVALID)
 114   {
 115     log_error("Cannot find value in variant container");
 116     return false;
 117   }
 118
 119   if (*type == DBUS_TYPE_ARRAY)
 120   {
 121     if (dbus_message_iter_get_element_type(&variant_iter) != DBUS_TYPE_BYTE)
 122     {
 123       log_error("Dict entry value is a non-byte array");
 124       return false;
 125     }
 126     *type = '-';
 127
 128     dbus_message_iter_recurse(&variant_iter, &array_iter);
 129     dbus_message_iter_get_fixed_array(&array_iter, value, &n);
 130
 131     if (size != NULL)
 132     {
 133       *size = n;
 134     }
 135   }
 136   else
 137   {
 138     dbus_message_iter_get_basic(&variant_iter, value);
 139   }
 140
 141   return true;
 142 }
 143
 144 bool dbus_iter_get_dict_entry_string(DBusMessageIter * iter_ptr, const char * key, const char ** value)
 145 {
 146   int type;
 147
 148   if (!dbus_iter_get_dict_entry(iter_ptr, key, value, &type, NULL))
 149   {
 150     return false;
 151   }
 152
 153   if (type != DBUS_TYPE_STRING)
 154   {
 155     log_error("value of the dict entry '%s' is not a string", key);
 156     return false;
 157   }
 158
 159   return true;
 160 }
 161
 162 /*
 163  * Append a variant type to a D-Bus message.
 164  * Return false if something fails, true otherwise.
 165  */
 166 bool dbus_iter_append_variant(DBusMessageIter * iter, int type, const void * arg)
 167 {
 168   DBusMessageIter sub_iter;
 169   char s[2];
 170
 171   s[0] = (char)type;
 172   s[1] = '\0';
 173
 174   /* Open a variant container. */
 175   if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, (const char *)s, &sub_iter))
 176     return false;
 177
 178   /* Append the supplied value. */
 179   if (!dbus_message_iter_append_basic(&sub_iter, type, arg))
 180   {
 181     dbus_message_iter_close_container(iter, &sub_iter);
 182     return false;
 183   }
 184
 185   /* Close the container. */
 186   if (!dbus_message_iter_close_container(iter, &sub_iter))
 187     return false;
 188
 189   return true;
 190 }
 191
 192 static __inline__ bool dbus_iter_append_variant_raw(DBusMessageIter * iter, const void * buf, int len)
 193 {
 194   DBusMessageIter variant_iter, array_iter;
 195
 196   /* Open a variant container. */
 197   if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 198                                         "ay", &variant_iter))
 199     return false;
 200
 201   /* Open an array container. */
 202   if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
 203                                         "y", &array_iter))
 204     goto fail;
 205
 206   /* Append the supplied data. */
 207   if (!dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE, buf, len)) {
 208     dbus_message_iter_close_container(&variant_iter, &array_iter);
 209     goto fail;
 210   }
 211
 212   /* Close the containers. */
 213   if (!dbus_message_iter_close_container(&variant_iter, &array_iter))
 214     goto fail;
 215   else if (!dbus_message_iter_close_container(iter, &variant_iter))
 216     return false;
 217
 218   return true;
 219
 220 fail:
 221   dbus_message_iter_close_container(iter, &variant_iter);
 222   return false;
 223 }
 224
 225 bool dbus_iter_append_dict_entry(DBusMessageIter * iter, int type, const char * key, const void * value, int length)
 226 {
 227   DBusMessageIter dict_iter;
 228
 229   if (!dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter))
 230     return false;
 231
 232   if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &key))
 233     goto fail;
 234
 235   if (type == '-')
 236   {
 237     if (!dbus_iter_append_variant_raw(&dict_iter, value, length))
 238       goto fail;
 239   }
 240   else if (!dbus_iter_append_variant(&dict_iter, type, value))
 241   {
 242     goto fail;
 243   }
 244
 245   if (!dbus_message_iter_close_container(iter, &dict_iter))
 246     return false;
 247
 248   return true;
 249
 250 fail:
 251   dbus_message_iter_close_container(iter, &dict_iter);
 252   return false;
 253 }
 254
 255 bool dbus_maybe_add_dict_entry_string(DBusMessageIter *dict_iter_ptr, const char * key, const char * value)
 256 {
 257   DBusMessageIter dict_entry_iter;
 258
 259   if (value == NULL)
 260   {
 261     return true;
 262   }
 263
 264   if (!dbus_message_iter_open_container(dict_iter_ptr, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter))
 265   {
 266     return false;
 267   }
 268
 269   if (!dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, (const void *) &key))
 270   {
 271     dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter);
 272     return false;
 273   }
 274
 275   dbus_iter_append_variant(&dict_entry_iter, DBUS_TYPE_STRING, &value);
 276
 277   if (!dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter))
 278   {
 279     return false;
 280   }
 281
 282   return true;
 283 }
 284
 285 bool dbus_add_dict_entry_uint32(DBusMessageIter * dict_iter_ptr, const char * key, dbus_uint32_t value)
 286 {
 287   DBusMessageIter dict_entry_iter;
 288
 289   if (!dbus_message_iter_open_container(dict_iter_ptr, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter))
 290   {
 291     return false;
 292   }
 293
 294   if (!dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, (const void *) &key))
 295   {
 296     dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter);
 297     return false;
 298   }
 299
 300   dbus_iter_append_variant(&dict_entry_iter, DBUS_TYPE_UINT32, &value);
 301
 302   if (!dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter))
 303   {
 304     return false;
 305   }
 306
 307   return true;
 308 }
 309
 310 bool dbus_add_dict_entry_bool(DBusMessageIter * dict_iter_ptr, const char * key, dbus_bool_t value)
 311 {
 312   DBusMessageIter dict_entry_iter;
 313
 314   if (!dbus_message_iter_open_container(dict_iter_ptr, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter))
 315   {
 316     return false;
 317   }
 318
 319   if (!dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, (const void *) &key))
 320   {
 321     dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter);
 322     return false;
 323   }
 324
 325   dbus_iter_append_variant(&dict_entry_iter, DBUS_TYPE_BOOLEAN, &value);
 326
 327   if (!dbus_message_iter_close_container(dict_iter_ptr, &dict_entry_iter))
 328   {
 329     return false;
 330   }
 331
 332   return true;
 333 }
 334
 335 bool
 336 dbus_call(
 337   const char * service,
 338   const char * object,
 339   const char * iface,
 340   const char * method,
 341   const char * input_signature,
 342   ...)
 343 {
 344   DBusMessageIter iter;
 345   DBusMessage * request_ptr;
 346   DBusMessage * reply_ptr;
 347   const char * output_signature;
 348   const char * reply_signature;
 349   va_list ap;
 350   bool ret;
 351   void * parameter_ptr;
 352   int type;
 353   DBusSignatureIter sig_iter;
 354
 355   //log_info("dbus_call('%s', '%s', '%s', '%s')", service, object, iface, method);
 356
 357   ret = false;
 358   va_start(ap, input_signature);
 359
 360   if (input_signature != NULL)
 361   {
 362     if (!dbus_signature_validate(input_signature, NULL))
 363     {
 364       log_error("input signature '%s' is invalid", input_signature);
 365       goto fail;
 366     }
 367
 368     dbus_signature_iter_init(&sig_iter, input_signature);
 369
 370     request_ptr = dbus_message_new_method_call(service, object, iface, method);
 371     if (request_ptr == NULL)
 372     {
 373       log_error("dbus_message_new_method_call() failed.");
 374       goto fail;
 375     }
 376
 377     dbus_message_iter_init_append(request_ptr, &iter);
 378
 379     while (*input_signature != '\0')
 380     {
 381       type = dbus_signature_iter_get_current_type(&sig_iter);
 382       if (!dbus_type_is_basic(type))
 383       {
 384         log_error("non-basic input parameter '%c' (%d)", *input_signature, type);
 385         goto fail;
 386       }
 387
 388       parameter_ptr = va_arg(ap, void *);
 389
 390       if (!dbus_message_iter_append_basic(&iter, type, parameter_ptr))
 391       {
 392         log_error("dbus_message_iter_append_basic() failed.");
 393         goto fail;
 394       }
 395
 396       dbus_signature_iter_next(&sig_iter);
 397       input_signature++;
 398     }
 399   }
 400   else
 401   {
 402     request_ptr = va_arg(ap, DBusMessage *);
 403   }
 404
 405   output_signature = va_arg(ap, const char *);
 406
 407   reply_ptr = dbus_connection_send_with_reply_and_block(
 408     g_dbus_connection,
 409     request_ptr,
 410     DBUS_CALL_DEFAULT_TIMEOUT,
 411     &g_dbus_error);
 412
 413   if (input_signature != NULL)
 414   {
 415     dbus_message_unref(request_ptr);
 416   }
 417
 418   if (reply_ptr == NULL)
 419   {
 420     //log_error("calling method '%s' failed, error is '%s'", method, g_dbus_error.message);
 421     dbus_error_free(&g_dbus_error);
 422     goto fail;
 423   }
 424
 425   if (output_signature != NULL)
 426   {
 427     reply_signature = dbus_message_get_signature(reply_ptr);
 428
 429     if (strcmp(reply_signature, output_signature) != 0)
 430     {
 431       log_error("reply signature is '%s' but expected signature is '%s'", reply_signature, output_signature);
 432     }
 433
 434     dbus_message_iter_init(reply_ptr, &iter);
 435
 436     while (*output_signature++ != '\0')
 437     {
 438       ASSERT(dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INVALID); /* we've checked the signature, this should not happen */
 439       parameter_ptr = va_arg(ap, void *);
 440       dbus_message_iter_get_basic(&iter, parameter_ptr);
 441       dbus_message_iter_next(&iter);
 442     }
 443
 444     ASSERT(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_INVALID); /* we've checked the signature, this should not happen */
 445     dbus_message_unref(reply_ptr);
 446   }
 447   else
 448   {
 449     parameter_ptr = va_arg(ap, DBusMessage **);
 450     *(DBusMessage **)parameter_ptr = reply_ptr;
 451   }
 452
 453   ret = true;
 454
 455 fail:
 456   va_end(ap);
 457   return ret;
 458 }
 459
 460 static
 461 const char *
 462 compose_signal_match(
 463   const char * service,
 464   const char * object,
 465   const char * iface,
 466   const char * signal)
 467 {
 468   static char rule[1024];
 469   snprintf(rule, sizeof(rule), "type='signal',sender='%s',path='%s',interface='%s',member='%s'", service, object, iface, signal);
 470   return rule;
 471 }
 472
 473 static const char * compose_name_owner_match(const char * service)
 474 {
 475   static char rule[1024];
 476   snprintf(rule, sizeof(rule), "type='signal',interface='"DBUS_INTERFACE_DBUS"',member=NameOwnerChanged,arg0='%s'", service);
 477   return rule;
 478 }
 479
 480 bool
 481 dbus_register_object_signal_handler(
 482   DBusConnection * connection,
 483   const char * service,
 484   const char * object,
 485   const char * iface,
 486   const char * const * signals,
 487   DBusHandleMessageFunction handler,
 488   void * handler_data)
 489 {
 490   const char * const * signal;
 491
 492   for (signal = signals; *signal != NULL; signal++)
 493   {
 494     dbus_bus_add_match(connection, compose_signal_match(service, object, iface, *signal), &g_dbus_error);
 495     if (dbus_error_is_set(&g_dbus_error))
 496     {
 497       log_error("Failed to add D-Bus match rule: %s", g_dbus_error.message);
 498       dbus_error_free(&g_dbus_error);
 499       return false;
 500     }
 501   }
 502
 503   dbus_connection_add_filter(g_dbus_connection, handler, handler_data, NULL);
 504
 505   return true;
 506 }
 507
 508 bool
 509 dbus_unregister_object_signal_handler(
 510   DBusConnection * connection,
 511   const char * service,
 512   const char * object,
 513   const char * iface,
 514   const char * const * signals,
 515   DBusHandleMessageFunction handler,
 516   void * handler_data)
 517 {
 518   const char * const * signal;
 519
 520   for (signal = signals; *signal != NULL; signal++)
 521   {
 522     dbus_bus_remove_match(connection, compose_signal_match(service, object, iface, *signal), &g_dbus_error);
 523     if (dbus_error_is_set(&g_dbus_error))
 524     {
 525       log_error("Failed to remove D-Bus match rule: %s", g_dbus_error.message);
 526       dbus_error_free(&g_dbus_error);
 527       return false;
 528     }
 529   }
 530
 531   dbus_connection_remove_filter(g_dbus_connection, handler, handler_data);
 532
 533   return true;
 534 }
 535
 536 static
 537 struct dbus_signal_hook_descriptor *
 538 find_signal_hook_descriptor(
 539   struct dbus_service_descriptor * service_ptr,
 540   const char * object,
 541   const char * interface)
 542 {
 543   struct list_head * node_ptr;
 544   struct dbus_signal_hook_descriptor * hook_ptr;
 545
 546   list_for_each(node_ptr, &service_ptr->hooks)
 547   {
 548     hook_ptr = list_entry(node_ptr, struct dbus_signal_hook_descriptor, siblings);
 549     if (strcmp(hook_ptr->object, object) == 0 &&
 550         strcmp(hook_ptr->interface, interface) == 0)
 551     {
 552       return hook_ptr;
 553     }
 554   }
 555
 556   return NULL;
 557 }
 558
 559 #define service_ptr ((struct dbus_service_descriptor *)data)
 560
 561 static
 562 DBusHandlerResult
 563 dbus_signal_handler(
 564   DBusConnection * connection_ptr,
 565   DBusMessage * message_ptr,
 566   void * data)
 567 {
 568   const char * object_path;
 569   const char * interface;
 570   const char * signal_name;
 571   const char * object_name;
 572   const char * old_owner;
 573   const char * new_owner;
 574   struct dbus_signal_hook_descriptor * hook_ptr;
 575   const struct dbus_signal_hook * signal_ptr;
 576
 577   /* Non-signal messages are ignored */
 578   if (dbus_message_get_type(message_ptr) != DBUS_MESSAGE_TYPE_SIGNAL)
 579   {
 580     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 581   }
 582
 583   interface = dbus_message_get_interface(message_ptr);
 584   if (interface == NULL)
 585   {
 586     /* Signals with no interface are ignored */
 587     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 588   }
 589
 590   object_path = dbus_message_get_path(message_ptr);
 591
 592   signal_name = dbus_message_get_member(message_ptr);
 593   if (signal_name == NULL)
 594   {
 595     log_error("Received signal with NULL member");
 596     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 597   }
 598
 599   log_debug("'%s' sent signal '%s'::'%s'", object_path, interface, signal_name);
 600
 601   /* Handle session bus signals to track service alive state */
 602   if (strcmp(interface, DBUS_INTERFACE_DBUS) == 0)
 603   {
 604     if (strcmp(signal_name, "NameOwnerChanged") != 0)
 605     {
 606       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 607     }
 608
 609     if (service_ptr->lifetime_hook_function == NULL)
 610     {
 611       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 612     }
 613
 614     //log_info("NameOwnerChanged signal received");
 615
 616     dbus_error_init(&g_dbus_error);
 617     if (!dbus_message_get_args(
 618           message_ptr,
 619           &g_dbus_error,
 620           DBUS_TYPE_STRING, &object_name,
 621           DBUS_TYPE_STRING, &old_owner,
 622           DBUS_TYPE_STRING, &new_owner,
 623           DBUS_TYPE_INVALID))
 624     {
 625       log_error("Cannot get message arguments: %s", g_dbus_error.message);
 626       dbus_error_free(&g_dbus_error);
 627       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 628     }
 629
 630     if (strcmp(object_name, service_ptr->service_name) != 0)
 631     {
 632       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 633     }
 634
 635     if (old_owner[0] == '\0')
 636     {
 637       service_ptr->lifetime_hook_function(true);
 638     }
 639     else if (new_owner[0] == '\0')
 640     {
 641       service_ptr->lifetime_hook_function(false);
 642     }
 643
 644     return DBUS_HANDLER_RESULT_HANDLED;
 645   }
 646
 647   /* Handle object interface signals */
 648   if (object_path != NULL)
 649   {
 650     hook_ptr = find_signal_hook_descriptor(service_ptr, object_path, interface);
 651     if (hook_ptr != NULL)
 652     {
 653       for (signal_ptr = hook_ptr->signal_hooks; signal_ptr->signal_name != NULL; signal_ptr++)
 654       {
 655         if (strcmp(signal_name, signal_ptr->signal_name) == 0)
 656         {
 657           signal_ptr->hook_function(hook_ptr->hook_context, message_ptr);
 658           return DBUS_HANDLER_RESULT_HANDLED;
 659         }
 660       }
 661     }
 662   }
 663
 664   /* Let everything else pass through */
 665   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 666 }
 667
 668 #undef service_ptr
 669
 670 static struct dbus_service_descriptor * find_service_descriptor(const char * service_name)
 671 {
 672   struct list_head * node_ptr;
 673   struct dbus_service_descriptor * descr_ptr;
 674
 675   list_for_each(node_ptr, &g_dbus_services)
 676   {
 677     descr_ptr = list_entry(node_ptr, struct dbus_service_descriptor, siblings);
 678     if (strcmp(descr_ptr->service_name, service_name) == 0)
 679     {
 680       return descr_ptr;
 681     }
 682   }
 683
 684   return NULL;
 685 }
 686
 687 static struct dbus_service_descriptor * find_or_create_service_descriptor(const char * service_name)
 688 {
 689   struct dbus_service_descriptor * descr_ptr;
 690
 691   descr_ptr = find_service_descriptor(service_name);
 692   if (descr_ptr != NULL)
 693   {
 694     return descr_ptr;
 695   }
 696
 697   descr_ptr = malloc(sizeof(struct dbus_service_descriptor));
 698   if (descr_ptr == NULL)
 699   {
 700     log_error("malloc() failed to allocate struct dbus_service_descriptor");
 701     return NULL;
 702   }
 703
 704   descr_ptr->service_name = strdup(service_name);
 705   if (descr_ptr->service_name == NULL)
 706   {
 707     log_error("strdup() failed for service name '%s'", service_name);
 708     free(descr_ptr);
 709     return NULL;
 710   }
 711
 712   descr_ptr->lifetime_hook_function = NULL;
 713   INIT_LIST_HEAD(&descr_ptr->hooks);
 714
 715   list_add_tail(&descr_ptr->siblings, &g_dbus_services);
 716
 717   dbus_connection_add_filter(g_dbus_connection, dbus_signal_handler, descr_ptr, NULL);
 718
 719   return descr_ptr;
 720 }
 721
 722 static void free_service_descriptor_if_empty(struct dbus_service_descriptor * service_ptr)
 723 {
 724   if (service_ptr->lifetime_hook_function != NULL)
 725   {
 726     return;
 727   }
 728
 729   if (!list_empty(&service_ptr->hooks))
 730   {
 731     return;
 732   }
 733
 734   dbus_connection_remove_filter(g_dbus_connection, dbus_signal_handler, service_ptr);
 735
 736   list_del(&service_ptr->siblings);
 737   free(service_ptr->service_name);
 738   free(service_ptr);
 739 }
 740
 741 bool
 742 dbus_register_object_signal_hooks(
 743   DBusConnection * connection,
 744   const char * service_name,
 745   const char * object,
 746   const char * iface,
 747   void * hook_context,
 748   const struct dbus_signal_hook * signal_hooks)
 749 {
 750   struct dbus_service_descriptor * service_ptr;
 751   struct dbus_signal_hook_descriptor * hook_ptr;
 752   const struct dbus_signal_hook * signal_ptr;
 753
 754   if (connection != g_dbus_connection)
 755   {
 756     log_error("multiple connections are not implemented yet");
 757     ASSERT_NO_PASS;
 758     goto fail;
 759   }
 760
 761   service_ptr = find_or_create_service_descriptor(service_name);
 762   if (service_ptr == NULL)
 763   {
 764     log_error("find_or_create_service_descriptor() failed.");
 765     goto fail;
 766   }
 767
 768   hook_ptr = find_signal_hook_descriptor(service_ptr, object, iface);
 769   if (hook_ptr != NULL)
 770   {
 771     log_error("refusing to register two signal monitors for '%s':'%s':'%s'", service_name, object, iface);
 772     ASSERT_NO_PASS;
 773     goto maybe_free_service;
 774   }
 775
 776   hook_ptr = malloc(sizeof(struct dbus_signal_hook_descriptor));
 777   if (hook_ptr == NULL)
 778   {
 779     log_error("malloc() failed to allocate struct dbus_signal_hook_descriptor");
 780     goto maybe_free_service;
 781   }
 782
 783   hook_ptr->object = strdup(object);
 784   if (hook_ptr->object == NULL)
 785   {
 786     log_error("strdup() failed for object name");
 787     goto free_hook;
 788   }
 789
 790   hook_ptr->interface = strdup(iface);
 791   if (hook_ptr->interface == NULL)
 792   {
 793     log_error("strdup() failed for interface name");
 794     goto free_object_name;
 795   }
 796
 797   hook_ptr->hook_context = hook_context;
 798   hook_ptr->signal_hooks = signal_hooks;
 799
 800   list_add_tail(&hook_ptr->siblings, &service_ptr->hooks);
 801
 802   for (signal_ptr = signal_hooks; signal_ptr->signal_name != NULL; signal_ptr++)
 803   {
 804     dbus_bus_add_match(connection, compose_signal_match(service_name, object, iface, signal_ptr->signal_name), &g_dbus_error);
 805     if (dbus_error_is_set(&g_dbus_error))
 806     {
 807       log_error("Failed to add D-Bus match rule: %s", g_dbus_error.message);
 808       dbus_error_free(&g_dbus_error);
 809
 810       while (signal_ptr != signal_hooks)
 811       {
 812         ASSERT(signal_ptr > signal_hooks);
 813         signal_ptr--;
 814
 815         dbus_bus_remove_match(connection, compose_signal_match(service_name, object, iface, signal_ptr->signal_name), &g_dbus_error);
 816         if (dbus_error_is_set(&g_dbus_error))
 817         {
 818           log_error("Failed to remove D-Bus match rule: %s", g_dbus_error.message);
 819           dbus_error_free(&g_dbus_error);
 820         }
 821       }
 822
 823       goto remove_hook;
 824     }
 825   }
 826
 827   return true;
 828
 829 remove_hook:
 830   list_del(&hook_ptr->siblings);
 831   free(hook_ptr->interface);
 832 free_object_name:
 833   free(hook_ptr->object);
 834 free_hook:
 835   free(hook_ptr);
 836 maybe_free_service:
 837   free_service_descriptor_if_empty(service_ptr);
 838 fail:
 839   return false;
 840 }
 841
 842 void
 843 dbus_unregister_object_signal_hooks(
 844   DBusConnection * connection,
 845   const char * service_name,
 846   const char * object,
 847   const char * iface)
 848 {
 849   struct dbus_service_descriptor * service_ptr;
 850   struct dbus_signal_hook_descriptor * hook_ptr;
 851   const struct dbus_signal_hook * signal_ptr;
 852
 853   if (connection != g_dbus_connection)
 854   {
 855     log_error("multiple connections are not implemented yet");
 856     ASSERT_NO_PASS;
 857     return;
 858   }
 859
 860   service_ptr = find_service_descriptor(service_name);
 861   if (service_ptr == NULL)
 862   {
 863     log_error("find_service_descriptor() failed.");
 864     ASSERT_NO_PASS;
 865     return;
 866   }
 867
 868   hook_ptr = find_signal_hook_descriptor(service_ptr, object, iface);
 869   if (hook_ptr == NULL)
 870   {
 871     log_error("cannot unregister non-existing signal monitor for '%s':'%s':'%s'", service_name, object, iface);
 872     ASSERT_NO_PASS;
 873     return;
 874   }
 875
 876   for (signal_ptr = hook_ptr->signal_hooks; signal_ptr->signal_name != NULL; signal_ptr++)
 877   {
 878     dbus_bus_remove_match(connection, compose_signal_match(service_name, object, iface, signal_ptr->signal_name), &g_dbus_error);
 879     if (dbus_error_is_set(&g_dbus_error))
 880     {
 881       if (dbus_error_is_set(&g_dbus_error))
 882       {
 883         log_error("Failed to remove D-Bus match rule: %s", g_dbus_error.message);
 884         dbus_error_free(&g_dbus_error);
 885       }
 886     }
 887   }
 888
 889   list_del(&hook_ptr->siblings);
 890
 891   free(hook_ptr->interface);
 892   free(hook_ptr->object);
 893   free(hook_ptr);
 894
 895   free_service_descriptor_if_empty(service_ptr);
 896 }
 897
 898 bool
 899 dbus_register_service_lifetime_hook(
 900   DBusConnection * connection,
 901   const char * service_name,
 902   void (* hook_function)(bool appeared))
 903 {
 904   struct dbus_service_descriptor * service_ptr;
 905
 906   if (connection != g_dbus_connection)
 907   {
 908     log_error("multiple connections are not implemented yet");
 909     ASSERT_NO_PASS;
 910     goto fail;
 911   }
 912
 913   service_ptr = find_or_create_service_descriptor(service_name);
 914   if (service_ptr == NULL)
 915   {
 916     log_error("find_or_create_service_descriptor() failed.");
 917     goto fail;
 918   }
 919
 920   if (service_ptr->lifetime_hook_function != NULL)
 921   {
 922     log_error("cannot register two lifetime hooks for '%s'", service_name);
 923     ASSERT_NO_PASS;
 924     goto maybe_free_service;
 925   }
 926
 927   service_ptr->lifetime_hook_function = hook_function;
 928
 929   dbus_bus_add_match(connection, compose_name_owner_match(service_name), &g_dbus_error);
 930   if (dbus_error_is_set(&g_dbus_error))
 931   {
 932     log_error("Failed to add D-Bus match rule: %s", g_dbus_error.message);
 933     dbus_error_free(&g_dbus_error);
 934     goto clear_hook;
 935   }
 936
 937   return true;
 938
 939 clear_hook:
 940   service_ptr->lifetime_hook_function = NULL;
 941 maybe_free_service:
 942   free_service_descriptor_if_empty(service_ptr);
 943 fail:
 944   return false;
 945 }
 946
 947 void
 948 dbus_unregister_service_lifetime_hook(
 949   DBusConnection * connection,
 950   const char * service_name)
 951 {
 952   struct dbus_service_descriptor * service_ptr;
 953
 954   if (connection != g_dbus_connection)
 955   {
 956     log_error("multiple connections are not implemented yet");
 957     ASSERT_NO_PASS;
 958     return;
 959   }
 960
 961   service_ptr = find_service_descriptor(service_name);
 962   if (service_ptr == NULL)
 963   {
 964     log_error("find_service_descriptor() failed.");
 965     return;
 966   }
 967
 968   if (service_ptr->lifetime_hook_function == NULL)
 969   {
 970     log_error("cannot unregister non-existent lifetime hook for '%s'", service_name);
 971     ASSERT_NO_PASS;
 972     return;
 973   }
 974
 975   service_ptr->lifetime_hook_function = NULL;
 976
 977   dbus_bus_remove_match(connection, compose_name_owner_match(service_name), &g_dbus_error);
 978   if (dbus_error_is_set(&g_dbus_error))
 979   {
 980     log_error("Failed to remove D-Bus match rule: %s", g_dbus_error.message);
 981     dbus_error_free(&g_dbus_error);
 982   }
 983
 984   free_service_descriptor_if_empty(service_ptr);
 985 }