src/pulsecore/protocol-dbus.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2009 Tanu Kaskinen
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2.1 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <dbus/dbus.h>
  27
  28 #include <pulse/xmalloc.h>
  29
  30 #include <pulsecore/core-util.h>
  31 #include <pulsecore/dbus-util.h>
  32 #include <pulsecore/hashmap.h>
  33 #include <pulsecore/idxset.h>
  34 #include <pulsecore/shared.h>
  35 #include <pulsecore/strbuf.h>
  36
  37 #include "protocol-dbus.h"
  38
  39 struct pa_dbus_protocol {
  40     PA_REFCNT_DECLARE;
  41
  42     pa_core *core;
  43     pa_hashmap *objects; /* Object path -> struct object_entry */
  44     pa_hashmap *connections; /* DBusConnection -> struct connection_entry */
  45     pa_idxset *extensions; /* Strings */
  46
  47     pa_hook hooks[PA_DBUS_PROTOCOL_HOOK_MAX];
  48 };
  49
  50 struct object_entry {
  51     char *path;
  52     pa_hashmap *interfaces; /* Interface name -> struct interface_entry */
  53     char *introspection;
  54 };
  55
  56 struct connection_entry {
  57     DBusConnection *connection;
  58     pa_client *client;
  59
  60     pa_bool_t listening_for_all_signals;
  61
  62     /* Contains object paths. If this is empty, then signals from all objects
  63      * are accepted. Only used when listening_for_all_signals == TRUE. */
  64     pa_idxset *all_signals_objects;
  65
  66     /* Signal name -> signal paths entry. The entries contain object paths. If
  67      * a path set is empty, then that signal is accepted from all objects. This
  68      * variable is only used when listening_for_all_signals == FALSE. */
  69     pa_hashmap *listening_signals;
  70 };
  71
  72 /* Only used in connection entries' listening_signals hashmap. */
  73 struct signal_paths_entry {
  74     char *signal;
  75     pa_idxset *paths;
  76 };
  77
  78 struct interface_entry {
  79     char *name;
  80     pa_hashmap *method_handlers;
  81     pa_hashmap *method_signatures; /* Derived from method_handlers. Contains only "in" arguments. */
  82     pa_hashmap *property_handlers;
  83     pa_dbus_receive_cb_t get_all_properties_cb;
  84     pa_dbus_signal_info *signals;
  85     unsigned n_signals;
  86     void *userdata;
  87 };
  88
  89 char *pa_get_dbus_address_from_server_type(pa_server_type_t server_type) {
  90     char *address = NULL;
  91     char *runtime_path = NULL;
  92     char *escaped_path = NULL;
  93
  94     switch (server_type) {
  95         case PA_SERVER_TYPE_USER:
  96             pa_assert_se((runtime_path = pa_runtime_path(PA_DBUS_SOCKET_NAME)));
  97             pa_assert_se((escaped_path = dbus_address_escape_value(runtime_path)));
  98             address = pa_sprintf_malloc("unix:path=%s", escaped_path);
  99             break;
 100
 101         case PA_SERVER_TYPE_SYSTEM:
 102             pa_assert_se((escaped_path = dbus_address_escape_value(PA_DBUS_SYSTEM_SOCKET_PATH)));
 103             address = pa_sprintf_malloc("unix:path=%s", escaped_path);
 104             break;
 105
 106         case PA_SERVER_TYPE_NONE:
 107             address = pa_xnew0(char, 1);
 108             break;
 109
 110         default:
 111             pa_assert_not_reached();
 112     }
 113
 114     pa_xfree(runtime_path);
 115     dbus_free(escaped_path);
 116
 117     return address;
 118 }
 119
 120 static pa_dbus_protocol *dbus_protocol_new(pa_core *c) {
 121     pa_dbus_protocol *p;
 122     unsigned i;
 123
 124     pa_assert(c);
 125
 126     p = pa_xnew(pa_dbus_protocol, 1);
 127     PA_REFCNT_INIT(p);
 128     p->core = c;
 129     p->objects = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 130     p->connections = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
 131     p->extensions = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 132
 133     for (i = 0; i < PA_DBUS_PROTOCOL_HOOK_MAX; ++i)
 134         pa_hook_init(&p->hooks[i], p);
 135
 136     pa_assert_se(pa_shared_set(c, "dbus-protocol", p) >= 0);
 137
 138     return p;
 139 }
 140
 141 pa_dbus_protocol* pa_dbus_protocol_get(pa_core *c) {
 142     pa_dbus_protocol *p;
 143
 144     if ((p = pa_shared_get(c, "dbus-protocol")))
 145         return pa_dbus_protocol_ref(p);
 146
 147     return dbus_protocol_new(c);
 148 }
 149
 150 pa_dbus_protocol* pa_dbus_protocol_ref(pa_dbus_protocol *p) {
 151     pa_assert(p);
 152     pa_assert(PA_REFCNT_VALUE(p) >= 1);
 153
 154     PA_REFCNT_INC(p);
 155
 156     return p;
 157 }
 158
 159 void pa_dbus_protocol_unref(pa_dbus_protocol *p) {
 160     unsigned i;
 161
 162     pa_assert(p);
 163     pa_assert(PA_REFCNT_VALUE(p) >= 1);
 164
 165     if (PA_REFCNT_DEC(p) > 0)
 166         return;
 167
 168     pa_assert(pa_hashmap_isempty(p->objects));
 169     pa_assert(pa_hashmap_isempty(p->connections));
 170     pa_assert(pa_idxset_isempty(p->extensions));
 171
 172     pa_hashmap_free(p->objects, NULL, NULL);
 173     pa_hashmap_free(p->connections, NULL, NULL);
 174     pa_idxset_free(p->extensions, NULL, NULL);
 175
 176     for (i = 0; i < PA_DBUS_PROTOCOL_HOOK_MAX; ++i)
 177         pa_hook_done(&p->hooks[i]);
 178
 179     pa_assert_se(pa_shared_remove(p->core, "dbus-protocol") >= 0);
 180
 181     pa_xfree(p);
 182 }
 183
 184 static void update_introspection(struct object_entry *oe) {
 185     pa_strbuf *buf;
 186     void *interfaces_state = NULL;
 187     struct interface_entry *iface_entry = NULL;
 188
 189     pa_assert(oe);
 190
 191     buf = pa_strbuf_new();
 192     pa_strbuf_puts(buf, DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE);
 193     pa_strbuf_puts(buf, "<node>\n");
 194
 195     PA_HASHMAP_FOREACH(iface_entry, oe->interfaces, interfaces_state) {
 196         pa_dbus_method_handler *method_handler;
 197         pa_dbus_property_handler *property_handler;
 198         void *handlers_state = NULL;
 199         unsigned i;
 200         unsigned j;
 201
 202         pa_strbuf_printf(buf, " <interface name=\"%s\">\n", iface_entry->name);
 203
 204         PA_HASHMAP_FOREACH(method_handler, iface_entry->method_handlers, handlers_state) {
 205             pa_strbuf_printf(buf, "  <method name=\"%s\">\n", method_handler->method_name);
 206
 207             for (i = 0; i < method_handler->n_arguments; ++i)
 208                 pa_strbuf_printf(buf, "   <arg name=\"%s\" type=\"%s\" direction=\"%s\"/>\n",
 209                                  method_handler->arguments[i].name,
 210                                  method_handler->arguments[i].type,
 211                                  method_handler->arguments[i].direction);
 212
 213             pa_strbuf_puts(buf, "  </method>\n");
 214         }
 215
 216         handlers_state = NULL;
 217
 218         PA_HASHMAP_FOREACH(property_handler, iface_entry->property_handlers, handlers_state)
 219             pa_strbuf_printf(buf, "  <property name=\"%s\" type=\"%s\" access=\"%s\"/>\n",
 220                              property_handler->property_name,
 221                              property_handler->type,
 222                              property_handler->get_cb ? (property_handler->set_cb ? "readwrite" : "read") : "write");
 223
 224         for (i = 0; i < iface_entry->n_signals; ++i) {
 225             pa_strbuf_printf(buf, "  <signal name=\"%s\">\n", iface_entry->signals[i].name);
 226
 227             for (j = 0; j < iface_entry->signals[i].n_arguments; ++j)
 228                 pa_strbuf_printf(buf, "   <arg name=\"%s\" type=\"%s\"/>\n", iface_entry->signals[i].arguments[j].name,
 229                                                                              iface_entry->signals[i].arguments[j].type);
 230
 231             pa_strbuf_puts(buf, "  </signal>\n");
 232         }
 233
 234         pa_strbuf_puts(buf, " </interface>\n");
 235     }
 236
 237     pa_strbuf_puts(buf, " <interface name=\"" DBUS_INTERFACE_INTROSPECTABLE "\">\n"
 238                         "  <method name=\"Introspect\">\n"
 239                         "   <arg name=\"data\" type=\"s\" direction=\"out\"/>\n"
 240                         "  </method>\n"
 241                         " </interface>\n"
 242                         " <interface name=\"" DBUS_INTERFACE_PROPERTIES "\">\n"
 243                         "  <method name=\"Get\">\n"
 244                         "   <arg name=\"interface_name\" type=\"s\" direction=\"in\"/>\n"
 245                         "   <arg name=\"property_name\" type=\"s\" direction=\"in\"/>\n"
 246                         "   <arg name=\"value\" type=\"v\" direction=\"out\"/>\n"
 247                         "  </method>\n"
 248                         "  <method name=\"Set\">\n"
 249                         "   <arg name=\"interface_name\" type=\"s\" direction=\"in\"/>\n"
 250                         "   <arg name=\"property_name\" type=\"s\" direction=\"in\"/>\n"
 251                         "   <arg name=\"value\" type=\"v\" direction=\"in\"/>\n"
 252                         "  </method>\n"
 253                         "  <method name=\"GetAll\">\n"
 254                         "   <arg name=\"interface_name\" type=\"s\" direction=\"in\"/>\n"
 255                         "   <arg name=\"props\" type=\"a{sv}\" direction=\"out\"/>\n"
 256                         "  </method>\n"
 257                         " </interface>\n");
 258
 259     pa_strbuf_puts(buf, "</node>\n");
 260
 261     pa_xfree(oe->introspection);
 262     oe->introspection = pa_strbuf_tostring_free(buf);
 263 }
 264
 265 /* Return value of find_handler() and its subfunctions. */
 266 enum find_result_t {
 267     /* The received message is a valid .Get call. */
 268     FOUND_GET_PROPERTY,
 269
 270     /* The received message is a valid .Set call. */
 271     FOUND_SET_PROPERTY,
 272
 273     /* The received message is a valid .GetAll call. */
 274     FOUND_GET_ALL,
 275
 276     /* The received message is a valid method call. */
 277     FOUND_METHOD,
 278
 279     /* The interface of the received message hasn't been registered for the
 280      * destination object. */
 281     NO_SUCH_INTERFACE,
 282
 283     /* No property handler was found for the received .Get or .Set call. */
 284     NO_SUCH_PROPERTY,
 285
 286     /* The interface argument of a property call didn't match any registered
 287      * interface. */
 288     NO_SUCH_PROPERTY_INTERFACE,
 289
 290     /* The received message called .Get or .Set for a property whose access
 291      * mode doesn't match the call. */
 292     PROPERTY_ACCESS_DENIED,
 293
 294     /* The new value signature of a .Set call didn't match the expected
 295      * signature. */
 296     INVALID_PROPERTY_SIG,
 297
 298     /* No method handler was found for the received message. */
 299     NO_SUCH_METHOD,
 300
 301     /* The signature of the received message didn't match the expected
 302      * signature. Despite the name, this can also be returned for a property
 303      * call if its message signature is invalid. */
 304     INVALID_METHOD_SIG
 305 };
 306
 307 /* Data for resolving the correct reaction to a received message. */
 308 struct call_info {
 309     DBusMessage *message; /* The received message. */
 310     struct object_entry *obj_entry;
 311     const char *interface; /* Destination interface name (extracted from the message). */
 312     struct interface_entry *iface_entry;
 313
 314     const char *property; /* Property name (extracted from the message). */
 315     const char *property_interface; /* The interface argument of a property call is stored here. */
 316     pa_dbus_property_handler *property_handler;
 317     const char *expected_property_sig; /* Property signature from the introspection data. */
 318     const char *property_sig; /* The signature of the new value in the received .Set message. */
 319     DBusMessageIter variant_iter; /* Iterator pointing to the beginning of the new value variant of a .Set call. */
 320
 321     const char *method; /* Method name (extracted from the message). */
 322     pa_dbus_method_handler *method_handler;
 323     const char *expected_method_sig; /* Method signature from the introspection data. */
 324     const char *method_sig; /* The signature of the received message. */
 325 };
 326
 327 /* Called when call_info->property has been set and the property interface has
 328  * not been given. In case of a Set call, call_info->property_sig is also set,
 329  * which is checked against the expected value in this function. */
 330 static enum find_result_t find_handler_by_property(struct call_info *call_info) {
 331     void *state = NULL;
 332
 333     pa_assert(call_info);
 334
 335     PA_HASHMAP_FOREACH(call_info->iface_entry, call_info->obj_entry->interfaces, state) {
 336         if ((call_info->property_handler = pa_hashmap_get(call_info->iface_entry->property_handlers, call_info->property))) {
 337             if (pa_streq(call_info->method, "Get"))
 338                 return call_info->property_handler->get_cb ? FOUND_GET_PROPERTY : PROPERTY_ACCESS_DENIED;
 339
 340             else if (pa_streq(call_info->method, "Set")) {
 341                 call_info->expected_property_sig = call_info->property_handler->type;
 342
 343                 if (pa_streq(call_info->property_sig, call_info->expected_property_sig))
 344                     return call_info->property_handler->set_cb ? FOUND_SET_PROPERTY : PROPERTY_ACCESS_DENIED;
 345                 else
 346                     return INVALID_PROPERTY_SIG;
 347
 348             } else
 349                 pa_assert_not_reached();
 350         }
 351     }
 352
 353     return NO_SUCH_PROPERTY;
 354 }
 355
 356 static enum find_result_t find_handler_by_method(struct call_info *call_info) {
 357     void *state = NULL;
 358
 359     pa_assert(call_info);
 360
 361     PA_HASHMAP_FOREACH(call_info->iface_entry, call_info->obj_entry->interfaces, state) {
 362         if ((call_info->method_handler = pa_hashmap_get(call_info->iface_entry->method_handlers, call_info->method))) {
 363             pa_assert_se(call_info->expected_method_sig = pa_hashmap_get(call_info->iface_entry->method_signatures, call_info->method));
 364
 365             if (pa_streq(call_info->method_sig, call_info->expected_method_sig))
 366                 return FOUND_METHOD;
 367             else
 368                 return INVALID_METHOD_SIG;
 369         }
 370     }
 371
 372     return NO_SUCH_METHOD;
 373 }
 374
 375 static enum find_result_t find_handler_from_properties_call(struct call_info *call_info) {
 376     pa_assert(call_info);
 377
 378     if (pa_streq(call_info->method, "GetAll")) {
 379         call_info->expected_method_sig = "s";
 380         if (!pa_streq(call_info->method_sig, call_info->expected_method_sig))
 381             return INVALID_METHOD_SIG;
 382
 383         pa_assert_se(dbus_message_get_args(call_info->message, NULL,
 384                                            DBUS_TYPE_STRING, &call_info->property_interface,
 385                                            DBUS_TYPE_INVALID));
 386
 387         if (*call_info->property_interface) {
 388             if ((call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->property_interface)))
 389                 return FOUND_GET_ALL;
 390             else
 391                 return NO_SUCH_PROPERTY_INTERFACE;
 392
 393         } else {
 394             pa_assert_se(call_info->iface_entry = pa_hashmap_first(call_info->obj_entry->interfaces));
 395             return FOUND_GET_ALL;
 396         }
 397
 398     } else if (pa_streq(call_info->method, "Get")) {
 399         call_info->expected_method_sig = "ss";
 400         if (!pa_streq(call_info->method_sig, call_info->expected_method_sig))
 401             return INVALID_METHOD_SIG;
 402
 403         pa_assert_se(dbus_message_get_args(call_info->message, NULL,
 404                                            DBUS_TYPE_STRING, &call_info->property_interface,
 405                                            DBUS_TYPE_STRING, &call_info->property,
 406                                            DBUS_TYPE_INVALID));
 407
 408         if (*call_info->property_interface) {
 409             if (!(call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->property_interface)))
 410                 return NO_SUCH_PROPERTY_INTERFACE;
 411             else if ((call_info->property_handler =
 412                         pa_hashmap_get(call_info->iface_entry->property_handlers, call_info->property)))
 413                 return call_info->property_handler->get_cb ? FOUND_GET_PROPERTY : PROPERTY_ACCESS_DENIED;
 414             else
 415                 return NO_SUCH_PROPERTY;
 416
 417         } else
 418             return find_handler_by_property(call_info);
 419
 420     } else if (pa_streq(call_info->method, "Set")) {
 421         DBusMessageIter msg_iter;
 422
 423         call_info->expected_method_sig = "ssv";
 424         if (!pa_streq(call_info->method_sig, call_info->expected_method_sig))
 425             return INVALID_METHOD_SIG;
 426
 427         pa_assert_se(dbus_message_iter_init(call_info->message, &msg_iter));
 428
 429         dbus_message_iter_get_basic(&msg_iter, &call_info->property_interface);
 430         pa_assert_se(dbus_message_iter_next(&msg_iter));
 431         dbus_message_iter_get_basic(&msg_iter, &call_info->property);
 432         pa_assert_se(dbus_message_iter_next(&msg_iter));
 433
 434         dbus_message_iter_recurse(&msg_iter, &call_info->variant_iter);
 435
 436         call_info->property_sig = dbus_message_iter_get_signature(&call_info->variant_iter);
 437
 438         if (*call_info->property_interface) {
 439             if (!(call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->property_interface)))
 440                 return NO_SUCH_PROPERTY_INTERFACE;
 441
 442             else if ((call_info->property_handler =
 443                         pa_hashmap_get(call_info->iface_entry->property_handlers, call_info->property))) {
 444                 call_info->expected_property_sig = call_info->property_handler->type;
 445
 446                 if (pa_streq(call_info->property_sig, call_info->expected_property_sig))
 447                     return call_info->property_handler->set_cb ? FOUND_SET_PROPERTY : PROPERTY_ACCESS_DENIED;
 448                 else
 449                     return INVALID_PROPERTY_SIG;
 450
 451             } else
 452                 return NO_SUCH_PROPERTY;
 453
 454         } else
 455             return find_handler_by_property(call_info);
 456
 457     } else
 458         pa_assert_not_reached();
 459 }
 460
 461 static enum find_result_t find_handler(struct call_info *call_info) {
 462     pa_assert(call_info);
 463
 464     if (call_info->interface) {
 465         if (pa_streq(call_info->interface, DBUS_INTERFACE_PROPERTIES))
 466             return find_handler_from_properties_call(call_info);
 467
 468         else if (!(call_info->iface_entry = pa_hashmap_get(call_info->obj_entry->interfaces, call_info->interface)))
 469             return NO_SUCH_INTERFACE;
 470
 471         else if ((call_info->method_handler = pa_hashmap_get(call_info->iface_entry->method_handlers, call_info->method))) {
 472             pa_assert_se(call_info->expected_method_sig = pa_hashmap_get(call_info->iface_entry->method_signatures, call_info->method));
 473
 474             if (!pa_streq(call_info->method_sig, call_info->expected_method_sig))
 475                 return INVALID_METHOD_SIG;
 476
 477             return FOUND_METHOD;
 478
 479         } else
 480             return NO_SUCH_METHOD;
 481
 482     } else { /* The method call doesn't contain an interface. */
 483         if (pa_streq(call_info->method, "Get") || pa_streq(call_info->method, "Set") || pa_streq(call_info->method, "GetAll")) {
 484             if (find_handler_by_method(call_info) == FOUND_METHOD)
 485                 /* The object has a method named Get, Set or GetAll in some other interface than .Properties. */
 486                 return FOUND_METHOD;
 487             else
 488                 /* Assume this is a .Properties call. */
 489                 return find_handler_from_properties_call(call_info);
 490
 491         } else /* This is not a .Properties call. */
 492             return find_handler_by_method(call_info);
 493     }
 494 }
 495
 496 static DBusHandlerResult handle_message_cb(DBusConnection *connection, DBusMessage *message, void *user_data) {
 497     pa_dbus_protocol *p = user_data;
 498     struct call_info call_info;
 499
 500     pa_assert(connection);
 501     pa_assert(message);
 502     pa_assert(p);
 503     pa_assert(p->objects);
 504
 505     if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
 506         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 507
 508     pa_log_debug("Received message: destination = %s, interface = %s, member = %s",
 509                  dbus_message_get_path(message),
 510                  dbus_message_get_interface(message),
 511                  dbus_message_get_member(message));
 512
 513     call_info.message = message;
 514     pa_assert_se(call_info.obj_entry = pa_hashmap_get(p->objects, dbus_message_get_path(message)));
 515     call_info.interface = dbus_message_get_interface(message);
 516     pa_assert_se(call_info.method = dbus_message_get_member(message));
 517     pa_assert_se(call_info.method_sig = dbus_message_get_signature(message));
 518
 519     if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect") ||
 520         (!dbus_message_get_interface(message) && dbus_message_has_member(message, "Introspect"))) {
 521         pa_dbus_send_basic_value_reply(connection, message, DBUS_TYPE_STRING, &call_info.obj_entry->introspection);
 522         goto finish;
 523     }
 524
 525     switch (find_handler(&call_info)) {
 526         case FOUND_GET_PROPERTY:
 527             call_info.property_handler->get_cb(connection, message, call_info.iface_entry->userdata);
 528             break;
 529
 530         case FOUND_SET_PROPERTY:
 531             call_info.property_handler->set_cb(connection, message, &call_info.variant_iter, call_info.iface_entry->userdata);
 532             break;
 533
 534         case FOUND_METHOD:
 535             call_info.method_handler->receive_cb(connection, message, call_info.iface_entry->userdata);
 536             break;
 537
 538         case FOUND_GET_ALL:
 539             if (call_info.iface_entry->get_all_properties_cb)
 540                 call_info.iface_entry->get_all_properties_cb(connection, message, call_info.iface_entry->userdata);
 541             else {
 542                 DBusMessage *dummy_reply = NULL;
 543                 DBusMessageIter msg_iter;
 544                 DBusMessageIter dict_iter;
 545
 546                 pa_assert_se(dummy_reply = dbus_message_new_method_return(message));
 547                 dbus_message_iter_init_append(dummy_reply, &msg_iter);
 548                 pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
 549                 pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
 550                 pa_assert_se(dbus_connection_send(connection, dummy_reply, NULL));
 551                 dbus_message_unref(dummy_reply);
 552             }
 553             break;
 554
 555         case PROPERTY_ACCESS_DENIED:
 556             pa_dbus_send_error(connection, message, DBUS_ERROR_ACCESS_DENIED,
 557                                "%s access denied for property %s", call_info.method, call_info.property);
 558             break;
 559
 560         case NO_SUCH_METHOD:
 561             pa_dbus_send_error(connection, message, DBUS_ERROR_UNKNOWN_METHOD, "No such method: %s", call_info.method);
 562             break;
 563
 564         case NO_SUCH_INTERFACE:
 565             pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_INTERFACE, "No such interface: %s", call_info.interface);
 566             break;
 567
 568         case NO_SUCH_PROPERTY:
 569             pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "No such property: %s", call_info.property);
 570             break;
 571
 572         case NO_SUCH_PROPERTY_INTERFACE:
 573             pa_dbus_send_error(connection, message, PA_DBUS_ERROR_NO_SUCH_INTERFACE, "No such property interface: %s", call_info.property_interface);
 574             break;
 575
 576         case INVALID_METHOD_SIG:
 577             pa_dbus_send_error(connection, message, DBUS_ERROR_INVALID_ARGS,
 578                                "Invalid signature for method %s: '%s'. Expected '%s'.",
 579                                call_info.method, call_info.method_sig, call_info.expected_method_sig);
 580             break;
 581
 582         case INVALID_PROPERTY_SIG:
 583             pa_dbus_send_error(connection, message, DBUS_ERROR_INVALID_ARGS,
 584                                "Invalid signature for property %s: '%s'. Expected '%s'.",
 585                                call_info.property, call_info.property_sig, call_info.expected_property_sig);
 586             break;
 587
 588         default:
 589             pa_assert_not_reached();
 590     }
 591
 592 finish:
 593     return DBUS_HANDLER_RESULT_HANDLED;
 594 }
 595
 596 static DBusObjectPathVTable vtable = {
 597     .unregister_function = NULL,
 598     .message_function = handle_message_cb,
 599     .dbus_internal_pad1 = NULL,
 600     .dbus_internal_pad2 = NULL,
 601     .dbus_internal_pad3 = NULL,
 602     .dbus_internal_pad4 = NULL
 603 };
 604
 605 static void register_object(pa_dbus_protocol *p, struct object_entry *obj_entry) {
 606     struct connection_entry *conn_entry;
 607     void *state = NULL;
 608
 609     pa_assert(p);
 610     pa_assert(obj_entry);
 611
 612     PA_HASHMAP_FOREACH(conn_entry, p->connections, state)
 613         pa_assert_se(dbus_connection_register_object_path(conn_entry->connection, obj_entry->path, &vtable, p));
 614 }
 615
 616 static pa_dbus_arg_info *copy_args(const pa_dbus_arg_info *src, unsigned n) {
 617     pa_dbus_arg_info *dst;
 618     unsigned i;
 619
 620     if (n == 0)
 621         return NULL;
 622
 623     pa_assert(src);
 624
 625     dst = pa_xnew0(pa_dbus_arg_info, n);
 626
 627     for (i = 0; i < n; ++i) {
 628         dst[i].name = pa_xstrdup(src[i].name);
 629         dst[i].type = pa_xstrdup(src[i].type);
 630         dst[i].direction = pa_xstrdup(src[i].direction);
 631     }
 632
 633     return dst;
 634 }
 635
 636 static pa_hashmap *create_method_handlers(const pa_dbus_interface_info *info) {
 637     pa_hashmap *handlers;
 638     unsigned i;
 639
 640     pa_assert(info);
 641     pa_assert(info->method_handlers || info->n_method_handlers == 0);
 642
 643     handlers = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 644
 645     for (i = 0; i < info->n_method_handlers; ++i) {
 646         pa_dbus_method_handler *h = pa_xnew(pa_dbus_method_handler, 1);
 647         h->method_name = pa_xstrdup(info->method_handlers[i].method_name);
 648         h->arguments = copy_args(info->method_handlers[i].arguments, info->method_handlers[i].n_arguments);
 649         h->n_arguments = info->method_handlers[i].n_arguments;
 650         h->receive_cb = info->method_handlers[i].receive_cb;
 651
 652         pa_hashmap_put(handlers, h->method_name, h);
 653     }
 654
 655     return handlers;
 656 }
 657
 658 static pa_hashmap *extract_method_signatures(pa_hashmap *method_handlers) {
 659     pa_hashmap *signatures = NULL;
 660     pa_dbus_method_handler *handler = NULL;
 661     void *state = NULL;
 662     pa_strbuf *sig_buf = NULL;
 663     unsigned i = 0;
 664
 665     pa_assert(method_handlers);
 666
 667     signatures = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 668
 669     PA_HASHMAP_FOREACH(handler, method_handlers, state) {
 670         sig_buf = pa_strbuf_new();
 671
 672         for (i = 0; i < handler->n_arguments; ++i) {
 673             if (pa_streq(handler->arguments[i].direction, "in"))
 674                 pa_strbuf_puts(sig_buf, handler->arguments[i].type);
 675         }
 676
 677         pa_hashmap_put(signatures, handler->method_name, pa_strbuf_tostring_free(sig_buf));
 678     }
 679
 680     return signatures;
 681 }
 682
 683 static pa_hashmap *create_property_handlers(const pa_dbus_interface_info *info) {
 684     pa_hashmap *handlers;
 685     unsigned i = 0;
 686
 687     pa_assert(info);
 688     pa_assert(info->property_handlers || info->n_property_handlers == 0);
 689
 690     handlers = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 691
 692     for (i = 0; i < info->n_property_handlers; ++i) {
 693         pa_dbus_property_handler *h = pa_xnew(pa_dbus_property_handler, 1);
 694         h->property_name = pa_xstrdup(info->property_handlers[i].property_name);
 695         h->type = pa_xstrdup(info->property_handlers[i].type);
 696         h->get_cb = info->property_handlers[i].get_cb;
 697         h->set_cb = info->property_handlers[i].set_cb;
 698
 699         pa_hashmap_put(handlers, h->property_name, h);
 700     }
 701
 702     return handlers;
 703 }
 704
 705 static pa_dbus_signal_info *copy_signals(const pa_dbus_interface_info *info) {
 706     pa_dbus_signal_info *dst;
 707     unsigned i;
 708
 709     pa_assert(info);
 710
 711     if (info->n_signals == 0)
 712         return NULL;
 713
 714     pa_assert(info->signals);
 715
 716     dst = pa_xnew(pa_dbus_signal_info, info->n_signals);
 717
 718     for (i = 0; i < info->n_signals; ++i) {
 719         dst[i].name = pa_xstrdup(info->signals[i].name);
 720         dst[i].arguments = copy_args(info->signals[i].arguments, info->signals[i].n_arguments);
 721         dst[i].n_arguments = info->signals[i].n_arguments;
 722     }
 723
 724     return dst;
 725 }
 726
 727 int pa_dbus_protocol_add_interface(pa_dbus_protocol *p,
 728                                    const char *path,
 729                                    const pa_dbus_interface_info *info,
 730                                    void *userdata) {
 731     struct object_entry *obj_entry;
 732     struct interface_entry *iface_entry;
 733     pa_bool_t obj_entry_created = FALSE;
 734
 735     pa_assert(p);
 736     pa_assert(path);
 737     pa_assert(info);
 738     pa_assert(info->name);
 739     pa_assert(info->method_handlers || info->n_method_handlers == 0);
 740     pa_assert(info->property_handlers || info->n_property_handlers == 0);
 741     pa_assert(info->get_all_properties_cb || info->n_property_handlers == 0);
 742     pa_assert(info->signals || info->n_signals == 0);
 743
 744     if (!(obj_entry = pa_hashmap_get(p->objects, path))) {
 745         obj_entry = pa_xnew(struct object_entry, 1);
 746         obj_entry->path = pa_xstrdup(path);
 747         obj_entry->interfaces = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 748         obj_entry->introspection = NULL;
 749
 750         pa_hashmap_put(p->objects, obj_entry->path, obj_entry);
 751         obj_entry_created = TRUE;
 752     }
 753
 754     if (pa_hashmap_get(obj_entry->interfaces, info->name) != NULL)
 755         goto fail; /* The interface was already registered. */
 756
 757     iface_entry = pa_xnew(struct interface_entry, 1);
 758     iface_entry->name = pa_xstrdup(info->name);
 759     iface_entry->method_handlers = create_method_handlers(info);
 760     iface_entry->method_signatures = extract_method_signatures(iface_entry->method_handlers);
 761     iface_entry->property_handlers = create_property_handlers(info);
 762     iface_entry->get_all_properties_cb = info->get_all_properties_cb;
 763     iface_entry->signals = copy_signals(info);
 764     iface_entry->n_signals = info->n_signals;
 765     iface_entry->userdata = userdata;
 766     pa_hashmap_put(obj_entry->interfaces, iface_entry->name, iface_entry);
 767
 768     update_introspection(obj_entry);
 769
 770     if (obj_entry_created)
 771         register_object(p, obj_entry);
 772
 773     pa_log_debug("Interface %s added for object %s", iface_entry->name, obj_entry->path);
 774
 775     return 0;
 776
 777 fail:
 778     return -1;
 779 }
 780
 781 static void unregister_object(pa_dbus_protocol *p, struct object_entry *obj_entry) {
 782     struct connection_entry *conn_entry;
 783     void *state = NULL;
 784
 785     pa_assert(p);
 786     pa_assert(obj_entry);
 787
 788     PA_HASHMAP_FOREACH(conn_entry, p->connections, state)
 789         pa_assert_se(dbus_connection_unregister_object_path(conn_entry->connection, obj_entry->path));
 790 }
 791
 792 static void method_handler_free_cb(void *p, void *userdata) {
 793     pa_dbus_method_handler *h = p;
 794     unsigned i;
 795
 796     pa_assert(h);
 797
 798     pa_xfree((char *) h->method_name);
 799
 800     for (i = 0; i < h->n_arguments; ++i) {
 801         pa_xfree((char *) h->arguments[i].name);
 802         pa_xfree((char *) h->arguments[i].type);
 803         pa_xfree((char *) h->arguments[i].direction);
 804     }
 805
 806     pa_xfree((pa_dbus_arg_info *) h->arguments);
 807     pa_xfree(h);
 808 }
 809
 810 static void method_signature_free_cb(void *p, void *userdata) {
 811     pa_assert(p);
 812
 813     pa_xfree(p);
 814 }
 815
 816 static void property_handler_free_cb(void *p, void *userdata) {
 817     pa_dbus_property_handler *h = p;
 818
 819     pa_assert(h);
 820
 821     pa_xfree((char *) h->property_name);
 822     pa_xfree((char *) h->type);
 823
 824     pa_xfree(h);
 825 }
 826
 827 int pa_dbus_protocol_remove_interface(pa_dbus_protocol *p, const char* path, const char* interface) {
 828     struct object_entry *obj_entry;
 829     struct interface_entry *iface_entry;
 830     unsigned i;
 831
 832     pa_assert(p);
 833     pa_assert(path);
 834     pa_assert(interface);
 835
 836     if (!(obj_entry = pa_hashmap_get(p->objects, path)))
 837         return -1;
 838
 839     if (!(iface_entry = pa_hashmap_remove(obj_entry->interfaces, interface)))
 840         return -1;
 841
 842     update_introspection(obj_entry);
 843
 844     pa_log_debug("Interface %s removed from object %s", iface_entry->name, obj_entry->path);
 845
 846     pa_xfree(iface_entry->name);
 847     pa_hashmap_free(iface_entry->method_signatures, method_signature_free_cb, NULL);
 848     pa_hashmap_free(iface_entry->method_handlers, method_handler_free_cb, NULL);
 849     pa_hashmap_free(iface_entry->property_handlers, property_handler_free_cb, NULL);
 850
 851     for (i = 0; i < iface_entry->n_signals; ++i) {
 852         unsigned j;
 853
 854         pa_xfree((char *) iface_entry->signals[i].name);
 855
 856         for (j = 0; j < iface_entry->signals[i].n_arguments; ++j) {
 857             pa_xfree((char *) iface_entry->signals[i].arguments[j].name);
 858             pa_xfree((char *) iface_entry->signals[i].arguments[j].type);
 859             pa_assert(iface_entry->signals[i].arguments[j].direction == NULL);
 860         }
 861
 862         pa_xfree((pa_dbus_arg_info *) iface_entry->signals[i].arguments);
 863     }
 864
 865     pa_xfree(iface_entry->signals);
 866     pa_xfree(iface_entry);
 867
 868     if (pa_hashmap_isempty(obj_entry->interfaces)) {
 869         unregister_object(p, obj_entry);
 870
 871         pa_hashmap_remove(p->objects, path);
 872         pa_xfree(obj_entry->path);
 873         pa_hashmap_free(obj_entry->interfaces, NULL, NULL);
 874         pa_xfree(obj_entry->introspection);
 875         pa_xfree(obj_entry);
 876     }
 877
 878     return 0;
 879 }
 880
 881 static void register_all_objects(pa_dbus_protocol *p, DBusConnection *conn) {
 882     struct object_entry *obj_entry;
 883     void *state = NULL;
 884
 885     pa_assert(p);
 886     pa_assert(conn);
 887
 888     PA_HASHMAP_FOREACH(obj_entry, p->objects, state)
 889         pa_assert_se(dbus_connection_register_object_path(conn, obj_entry->path, &vtable, p));
 890 }
 891
 892 int pa_dbus_protocol_register_connection(pa_dbus_protocol *p, DBusConnection *conn, pa_client *client) {
 893     struct connection_entry *conn_entry;
 894
 895     pa_assert(p);
 896     pa_assert(conn);
 897     pa_assert(client);
 898
 899     if (pa_hashmap_get(p->connections, conn))
 900         return -1; /* The connection was already registered. */
 901
 902     register_all_objects(p, conn);
 903
 904     conn_entry = pa_xnew(struct connection_entry, 1);
 905     conn_entry->connection = dbus_connection_ref(conn);
 906     conn_entry->client = client;
 907     conn_entry->listening_for_all_signals = FALSE;
 908     conn_entry->all_signals_objects = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 909     conn_entry->listening_signals = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 910
 911     pa_hashmap_put(p->connections, conn, conn_entry);
 912
 913     return 0;
 914 }
 915
 916 static void unregister_all_objects(pa_dbus_protocol *p, DBusConnection *conn) {
 917     struct object_entry *obj_entry;
 918     void *state = NULL;
 919
 920     pa_assert(p);
 921     pa_assert(conn);
 922
 923     PA_HASHMAP_FOREACH(obj_entry, p->objects, state)
 924         pa_assert_se(dbus_connection_unregister_object_path(conn, obj_entry->path));
 925 }
 926
 927 static struct signal_paths_entry *signal_paths_entry_new(const char *signal_name) {
 928     struct signal_paths_entry *e = NULL;
 929
 930     pa_assert(signal_name);
 931
 932     e = pa_xnew0(struct signal_paths_entry, 1);
 933     e->signal = pa_xstrdup(signal_name);
 934     e->paths = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 935
 936     return e;
 937 }
 938
 939 static void signal_paths_entry_free(struct signal_paths_entry *e) {
 940     char *path = NULL;
 941
 942     pa_assert(e);
 943
 944     pa_xfree(e->signal);
 945
 946     while ((path = pa_idxset_steal_first(e->paths, NULL)))
 947         pa_xfree(path);
 948
 949     pa_idxset_free(e->paths, NULL, NULL);
 950     pa_xfree(e);
 951 }
 952
 953 int pa_dbus_protocol_unregister_connection(pa_dbus_protocol *p, DBusConnection *conn) {
 954     struct connection_entry *conn_entry = NULL;
 955     struct signal_paths_entry *signal_paths_entry = NULL;
 956     char *object_path = NULL;
 957
 958     pa_assert(p);
 959     pa_assert(conn);
 960
 961     if (!(conn_entry = pa_hashmap_remove(p->connections, conn)))
 962         return -1;
 963
 964     unregister_all_objects(p, conn);
 965
 966     dbus_connection_unref(conn_entry->connection);
 967
 968     while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL)))
 969         pa_xfree(object_path);
 970
 971     pa_idxset_free(conn_entry->all_signals_objects, NULL, NULL);
 972
 973     while ((signal_paths_entry = pa_hashmap_steal_first(conn_entry->listening_signals)))
 974         signal_paths_entry_free(signal_paths_entry);
 975
 976     pa_hashmap_free(conn_entry->listening_signals, NULL, NULL);
 977     pa_xfree(conn_entry);
 978
 979     return 0;
 980 }
 981
 982 pa_client *pa_dbus_protocol_get_client(pa_dbus_protocol *p, DBusConnection *conn) {
 983     struct connection_entry *conn_entry;
 984
 985     pa_assert(p);
 986     pa_assert(conn);
 987
 988     if (!(conn_entry = pa_hashmap_get(p->connections, conn)))
 989         return NULL;
 990
 991     return conn_entry->client;
 992 }
 993
 994 void pa_dbus_protocol_add_signal_listener(
 995         pa_dbus_protocol *p,
 996         DBusConnection *conn,
 997         const char *signal_name,
 998         char **objects,
 999         unsigned n_objects) {
1000     struct connection_entry *conn_entry = NULL;
1001     struct signal_paths_entry *signal_paths_entry = NULL;
1002     char *object_path = NULL;
1003     unsigned i = 0;
1004
1005     pa_assert(p);
1006     pa_assert(conn);
1007     pa_assert(objects || n_objects == 0);
1008
1009     pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn)));
1010
1011     /* all_signals_objects will either be emptied or replaced with new objects,
1012      * so we empty it here unconditionally. If listening_for_all_signals is
1013      * currently FALSE, the idxset is empty already so this does nothing. */
1014     while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL)))
1015         pa_xfree(object_path);
1016
1017     if (signal_name) {
1018         conn_entry->listening_for_all_signals = FALSE;
1019
1020         /* Replace the old signal paths entry for this signal with a new
1021          * one. */
1022         if ((signal_paths_entry = pa_hashmap_remove(conn_entry->listening_signals, signal_name)))
1023             signal_paths_entry_free(signal_paths_entry);
1024         signal_paths_entry = signal_paths_entry_new(signal_name);
1025
1026         for (i = 0; i < n_objects; ++i)
1027             pa_idxset_put(signal_paths_entry->paths, pa_xstrdup(objects[i]), NULL);
1028
1029         pa_hashmap_put(conn_entry->listening_signals, signal_paths_entry->signal, signal_paths_entry);
1030
1031     } else {
1032         conn_entry->listening_for_all_signals = TRUE;
1033
1034         /* We're not interested in individual signals anymore, so let's empty
1035          * listening_signals. */
1036         while ((signal_paths_entry = pa_hashmap_steal_first(conn_entry->listening_signals)))
1037             signal_paths_entry_free(signal_paths_entry);
1038
1039         for (i = 0; i < n_objects; ++i)
1040             pa_idxset_put(conn_entry->all_signals_objects, pa_xstrdup(objects[i]), NULL);
1041     }
1042 }
1043
1044 void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal_name) {
1045     struct connection_entry *conn_entry = NULL;
1046     struct signal_paths_entry *signal_paths_entry = NULL;
1047
1048     pa_assert(p);
1049     pa_assert(conn);
1050
1051     pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn)));
1052
1053     if (signal_name) {
1054         if ((signal_paths_entry = pa_hashmap_get(conn_entry->listening_signals, signal_name)))
1055             signal_paths_entry_free(signal_paths_entry);
1056
1057     } else {
1058         char *object_path;
1059
1060         conn_entry->listening_for_all_signals = FALSE;
1061
1062         while ((object_path = pa_idxset_steal_first(conn_entry->all_signals_objects, NULL)))
1063             pa_xfree(object_path);
1064
1065         while ((signal_paths_entry = pa_hashmap_steal_first(conn_entry->listening_signals)))
1066             signal_paths_entry_free(signal_paths_entry);
1067     }
1068 }
1069
1070 void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal_msg) {
1071     struct connection_entry *conn_entry;
1072     struct signal_paths_entry *signal_paths_entry;
1073     void *state = NULL;
1074     DBusMessage *signal_copy;
1075     char *signal_string;
1076
1077     pa_assert(p);
1078     pa_assert(signal_msg);
1079     pa_assert(dbus_message_get_type(signal_msg) == DBUS_MESSAGE_TYPE_SIGNAL);
1080     pa_assert(dbus_message_get_path(signal_msg));
1081     pa_assert(dbus_message_get_interface(signal_msg));
1082     pa_assert(dbus_message_get_member(signal_msg));
1083
1084     signal_string = pa_sprintf_malloc("%s.%s", dbus_message_get_interface(signal_msg), dbus_message_get_member(signal_msg));
1085
1086     PA_HASHMAP_FOREACH(conn_entry, p->connections, state) {
1087         if ((conn_entry->listening_for_all_signals /* Case 1: listening for all signals */
1088              && (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal_msg), NULL)
1089                  || pa_idxset_isempty(conn_entry->all_signals_objects)))
1090
1091             || (!conn_entry->listening_for_all_signals /* Case 2: not listening for all signals */
1092                 && (signal_paths_entry = pa_hashmap_get(conn_entry->listening_signals, signal_string))
1093                 && (pa_idxset_get_by_data(signal_paths_entry->paths, dbus_message_get_path(signal_msg), NULL)
1094                     || pa_idxset_isempty(signal_paths_entry->paths)))) {
1095
1096             pa_assert_se(signal_copy = dbus_message_copy(signal_msg));
1097             pa_assert_se(dbus_connection_send(conn_entry->connection, signal_copy, NULL));
1098             dbus_message_unref(signal_copy);
1099         }
1100     }
1101
1102     pa_xfree(signal_string);
1103 }
1104
1105 const char **pa_dbus_protocol_get_extensions(pa_dbus_protocol *p, unsigned *n) {
1106     const char **extensions;
1107     const char *ext_name;
1108     void *state = NULL;
1109     unsigned i = 0;
1110
1111     pa_assert(p);
1112     pa_assert(n);
1113
1114     *n = pa_idxset_size(p->extensions);
1115
1116     if (*n <= 0)
1117         return NULL;
1118
1119     extensions = pa_xnew(const char *, *n);
1120
1121     while ((ext_name = pa_idxset_iterate(p->extensions, &state, NULL)))
1122         extensions[i++] = ext_name;
1123
1124     return extensions;
1125 }
1126
1127 int pa_dbus_protocol_register_extension(pa_dbus_protocol *p, const char *name) {
1128     char *internal_name;
1129
1130     pa_assert(p);
1131     pa_assert(name);
1132
1133     internal_name = pa_xstrdup(name);
1134
1135     if (pa_idxset_put(p->extensions, internal_name, NULL) < 0) {
1136         pa_xfree(internal_name);
1137         return -1;
1138     }
1139
1140     pa_hook_fire(&p->hooks[PA_DBUS_PROTOCOL_HOOK_EXTENSION_REGISTERED], internal_name);
1141
1142     return 0;
1143 }
1144
1145 int pa_dbus_protocol_unregister_extension(pa_dbus_protocol *p, const char *name) {
1146     char *internal_name;
1147
1148     pa_assert(p);
1149     pa_assert(name);
1150
1151     if (!(internal_name = pa_idxset_remove_by_data(p->extensions, name, NULL)))
1152         return -1;
1153
1154     pa_hook_fire(&p->hooks[PA_DBUS_PROTOCOL_HOOK_EXTENSION_UNREGISTERED], internal_name);
1155
1156     pa_xfree(internal_name);
1157
1158     return 0;
1159 }
1160
1161 pa_hook_slot *pa_dbus_protocol_hook_connect(
1162         pa_dbus_protocol *p,
1163         pa_dbus_protocol_hook_t hook,
1164         pa_hook_priority_t prio,
1165         pa_hook_cb_t cb,
1166         void *data) {
1167     pa_assert(p);
1168     pa_assert(hook < PA_DBUS_PROTOCOL_HOOK_MAX);
1169     pa_assert(cb);
1170
1171     return pa_hook_connect(&p->hooks[hook], prio, cb, data);
1172 }