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     bool 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);
 173     pa_hashmap_free(p->connections);
 174     pa_idxset_free(p->extensions, 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 void method_handler_free(pa_dbus_method_handler *h) {
 637     unsigned i;
 638
 639     pa_assert(h);
 640
 641     pa_xfree((char *) h->method_name);
 642
 643     for (i = 0; i < h->n_arguments; ++i) {
 644         pa_xfree((char *) h->arguments[i].name);
 645         pa_xfree((char *) h->arguments[i].type);
 646         pa_xfree((char *) h->arguments[i].direction);
 647     }
 648
 649     pa_xfree((pa_dbus_arg_info *) h->arguments);
 650     pa_xfree(h);
 651 }
 652
 653 static pa_hashmap *create_method_handlers(const pa_dbus_interface_info *info) {
 654     pa_hashmap *handlers;
 655     unsigned i;
 656
 657     pa_assert(info);
 658     pa_assert(info->method_handlers || info->n_method_handlers == 0);
 659
 660     handlers = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) method_handler_free);
 661
 662     for (i = 0; i < info->n_method_handlers; ++i) {
 663         pa_dbus_method_handler *h = pa_xnew(pa_dbus_method_handler, 1);
 664         h->method_name = pa_xstrdup(info->method_handlers[i].method_name);
 665         h->arguments = copy_args(info->method_handlers[i].arguments, info->method_handlers[i].n_arguments);
 666         h->n_arguments = info->method_handlers[i].n_arguments;
 667         h->receive_cb = info->method_handlers[i].receive_cb;
 668
 669         pa_hashmap_put(handlers, (char *) h->method_name, h);
 670     }
 671
 672     return handlers;
 673 }
 674
 675 static pa_hashmap *extract_method_signatures(pa_hashmap *method_handlers) {
 676     pa_hashmap *signatures = NULL;
 677     pa_dbus_method_handler *handler = NULL;
 678     void *state = NULL;
 679     pa_strbuf *sig_buf = NULL;
 680     unsigned i = 0;
 681
 682     pa_assert(method_handlers);
 683
 684     signatures = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, pa_xfree);
 685
 686     PA_HASHMAP_FOREACH(handler, method_handlers, state) {
 687         sig_buf = pa_strbuf_new();
 688
 689         for (i = 0; i < handler->n_arguments; ++i) {
 690             if (pa_streq(handler->arguments[i].direction, "in"))
 691                 pa_strbuf_puts(sig_buf, handler->arguments[i].type);
 692         }
 693
 694         pa_hashmap_put(signatures, (char *) handler->method_name, pa_strbuf_tostring_free(sig_buf));
 695     }
 696
 697     return signatures;
 698 }
 699
 700 static void property_handler_free(pa_dbus_property_handler *h) {
 701     pa_assert(h);
 702
 703     pa_xfree((char *) h->property_name);
 704     pa_xfree((char *) h->type);
 705
 706     pa_xfree(h);
 707 }
 708
 709 static pa_hashmap *create_property_handlers(const pa_dbus_interface_info *info) {
 710     pa_hashmap *handlers;
 711     unsigned i = 0;
 712
 713     pa_assert(info);
 714     pa_assert(info->property_handlers || info->n_property_handlers == 0);
 715
 716     handlers = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) property_handler_free);
 717
 718     for (i = 0; i < info->n_property_handlers; ++i) {
 719         pa_dbus_property_handler *h = pa_xnew(pa_dbus_property_handler, 1);
 720         h->property_name = pa_xstrdup(info->property_handlers[i].property_name);
 721         h->type = pa_xstrdup(info->property_handlers[i].type);
 722         h->get_cb = info->property_handlers[i].get_cb;
 723         h->set_cb = info->property_handlers[i].set_cb;
 724
 725         pa_hashmap_put(handlers, (char *) h->property_name, h);
 726     }
 727
 728     return handlers;
 729 }
 730
 731 static pa_dbus_signal_info *copy_signals(const pa_dbus_interface_info *info) {
 732     pa_dbus_signal_info *dst;
 733     unsigned i;
 734
 735     pa_assert(info);
 736
 737     if (info->n_signals == 0)
 738         return NULL;
 739
 740     pa_assert(info->signals);
 741
 742     dst = pa_xnew(pa_dbus_signal_info, info->n_signals);
 743
 744     for (i = 0; i < info->n_signals; ++i) {
 745         dst[i].name = pa_xstrdup(info->signals[i].name);
 746         dst[i].arguments = copy_args(info->signals[i].arguments, info->signals[i].n_arguments);
 747         dst[i].n_arguments = info->signals[i].n_arguments;
 748     }
 749
 750     return dst;
 751 }
 752
 753 int pa_dbus_protocol_add_interface(pa_dbus_protocol *p,
 754                                    const char *path,
 755                                    const pa_dbus_interface_info *info,
 756                                    void *userdata) {
 757     struct object_entry *obj_entry;
 758     struct interface_entry *iface_entry;
 759     bool obj_entry_created = false;
 760
 761     pa_assert(p);
 762     pa_assert(path);
 763     pa_assert(info);
 764     pa_assert(info->name);
 765     pa_assert(info->method_handlers || info->n_method_handlers == 0);
 766     pa_assert(info->property_handlers || info->n_property_handlers == 0);
 767     pa_assert(info->get_all_properties_cb || info->n_property_handlers == 0);
 768     pa_assert(info->signals || info->n_signals == 0);
 769
 770     if (!(obj_entry = pa_hashmap_get(p->objects, path))) {
 771         obj_entry = pa_xnew(struct object_entry, 1);
 772         obj_entry->path = pa_xstrdup(path);
 773         obj_entry->interfaces = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 774         obj_entry->introspection = NULL;
 775
 776         pa_hashmap_put(p->objects, obj_entry->path, obj_entry);
 777         obj_entry_created = true;
 778     }
 779
 780     if (pa_hashmap_get(obj_entry->interfaces, info->name) != NULL)
 781         goto fail; /* The interface was already registered. */
 782
 783     iface_entry = pa_xnew(struct interface_entry, 1);
 784     iface_entry->name = pa_xstrdup(info->name);
 785     iface_entry->method_handlers = create_method_handlers(info);
 786     iface_entry->method_signatures = extract_method_signatures(iface_entry->method_handlers);
 787     iface_entry->property_handlers = create_property_handlers(info);
 788     iface_entry->get_all_properties_cb = info->get_all_properties_cb;
 789     iface_entry->signals = copy_signals(info);
 790     iface_entry->n_signals = info->n_signals;
 791     iface_entry->userdata = userdata;
 792     pa_hashmap_put(obj_entry->interfaces, iface_entry->name, iface_entry);
 793
 794     update_introspection(obj_entry);
 795
 796     if (obj_entry_created)
 797         register_object(p, obj_entry);
 798
 799     pa_log_debug("Interface %s added for object %s", iface_entry->name, obj_entry->path);
 800
 801     return 0;
 802
 803 fail:
 804     return -1;
 805 }
 806
 807 static void unregister_object(pa_dbus_protocol *p, struct object_entry *obj_entry) {
 808     struct connection_entry *conn_entry;
 809     void *state = NULL;
 810
 811     pa_assert(p);
 812     pa_assert(obj_entry);
 813
 814     PA_HASHMAP_FOREACH(conn_entry, p->connections, state)
 815         pa_assert_se(dbus_connection_unregister_object_path(conn_entry->connection, obj_entry->path));
 816 }
 817
 818 int pa_dbus_protocol_remove_interface(pa_dbus_protocol *p, const char* path, const char* interface) {
 819     struct object_entry *obj_entry;
 820     struct interface_entry *iface_entry;
 821     unsigned i;
 822
 823     pa_assert(p);
 824     pa_assert(path);
 825     pa_assert(interface);
 826
 827     if (!(obj_entry = pa_hashmap_get(p->objects, path)))
 828         return -1;
 829
 830     if (!(iface_entry = pa_hashmap_remove(obj_entry->interfaces, interface)))
 831         return -1;
 832
 833     update_introspection(obj_entry);
 834
 835     pa_log_debug("Interface %s removed from object %s", iface_entry->name, obj_entry->path);
 836
 837     pa_xfree(iface_entry->name);
 838     pa_hashmap_free(iface_entry->method_signatures);
 839     pa_hashmap_free(iface_entry->method_handlers);
 840     pa_hashmap_free(iface_entry->property_handlers);
 841
 842     for (i = 0; i < iface_entry->n_signals; ++i) {
 843         unsigned j;
 844
 845         pa_xfree((char *) iface_entry->signals[i].name);
 846
 847         for (j = 0; j < iface_entry->signals[i].n_arguments; ++j) {
 848             pa_xfree((char *) iface_entry->signals[i].arguments[j].name);
 849             pa_xfree((char *) iface_entry->signals[i].arguments[j].type);
 850             pa_assert(iface_entry->signals[i].arguments[j].direction == NULL);
 851         }
 852
 853         pa_xfree((pa_dbus_arg_info *) iface_entry->signals[i].arguments);
 854     }
 855
 856     pa_xfree(iface_entry->signals);
 857     pa_xfree(iface_entry);
 858
 859     if (pa_hashmap_isempty(obj_entry->interfaces)) {
 860         unregister_object(p, obj_entry);
 861
 862         pa_hashmap_remove(p->objects, path);
 863         pa_xfree(obj_entry->path);
 864         pa_hashmap_free(obj_entry->interfaces);
 865         pa_xfree(obj_entry->introspection);
 866         pa_xfree(obj_entry);
 867     }
 868
 869     return 0;
 870 }
 871
 872 static void register_all_objects(pa_dbus_protocol *p, DBusConnection *conn) {
 873     struct object_entry *obj_entry;
 874     void *state = NULL;
 875
 876     pa_assert(p);
 877     pa_assert(conn);
 878
 879     PA_HASHMAP_FOREACH(obj_entry, p->objects, state)
 880         pa_assert_se(dbus_connection_register_object_path(conn, obj_entry->path, &vtable, p));
 881 }
 882
 883 static void signal_paths_entry_free(struct signal_paths_entry *e) {
 884     pa_assert(e);
 885
 886     pa_xfree(e->signal);
 887     pa_idxset_free(e->paths, pa_xfree);
 888     pa_xfree(e);
 889 }
 890
 891 int pa_dbus_protocol_register_connection(pa_dbus_protocol *p, DBusConnection *conn, pa_client *client) {
 892     struct connection_entry *conn_entry;
 893
 894     pa_assert(p);
 895     pa_assert(conn);
 896     pa_assert(client);
 897
 898     if (pa_hashmap_get(p->connections, conn))
 899         return -1; /* The connection was already registered. */
 900
 901     register_all_objects(p, conn);
 902
 903     conn_entry = pa_xnew(struct connection_entry, 1);
 904     conn_entry->connection = dbus_connection_ref(conn);
 905     conn_entry->client = client;
 906     conn_entry->listening_for_all_signals = false;
 907     conn_entry->all_signals_objects = pa_idxset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
 908     conn_entry->listening_signals = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL,
 909                                                         (pa_free_cb_t) signal_paths_entry_free);
 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 int pa_dbus_protocol_unregister_connection(pa_dbus_protocol *p, DBusConnection *conn) {
 940     struct connection_entry *conn_entry = NULL;
 941
 942     pa_assert(p);
 943     pa_assert(conn);
 944
 945     if (!(conn_entry = pa_hashmap_remove(p->connections, conn)))
 946         return -1;
 947
 948     unregister_all_objects(p, conn);
 949
 950     dbus_connection_unref(conn_entry->connection);
 951     pa_idxset_free(conn_entry->all_signals_objects, pa_xfree);
 952     pa_hashmap_free(conn_entry->listening_signals);
 953     pa_xfree(conn_entry);
 954
 955     return 0;
 956 }
 957
 958 pa_client *pa_dbus_protocol_get_client(pa_dbus_protocol *p, DBusConnection *conn) {
 959     struct connection_entry *conn_entry;
 960
 961     pa_assert(p);
 962     pa_assert(conn);
 963
 964     if (!(conn_entry = pa_hashmap_get(p->connections, conn)))
 965         return NULL;
 966
 967     return conn_entry->client;
 968 }
 969
 970 void pa_dbus_protocol_add_signal_listener(
 971         pa_dbus_protocol *p,
 972         DBusConnection *conn,
 973         const char *signal_name,
 974         char **objects,
 975         unsigned n_objects) {
 976     struct connection_entry *conn_entry = NULL;
 977     struct signal_paths_entry *signal_paths_entry = NULL;
 978     unsigned i = 0;
 979
 980     pa_assert(p);
 981     pa_assert(conn);
 982     pa_assert(objects || n_objects == 0);
 983
 984     pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn)));
 985
 986     /* all_signals_objects will either be emptied or replaced with new objects,
 987      * so we empty it here unconditionally. If listening_for_all_signals is
 988      * currently false, the idxset is empty already so this does nothing. */
 989     pa_idxset_remove_all(conn_entry->all_signals_objects, pa_xfree);
 990
 991     if (signal_name) {
 992         conn_entry->listening_for_all_signals = false;
 993
 994         /* Replace the old signal paths entry for this signal with a new
 995          * one. */
 996         if ((signal_paths_entry = pa_hashmap_remove(conn_entry->listening_signals, signal_name)))
 997             signal_paths_entry_free(signal_paths_entry);
 998         signal_paths_entry = signal_paths_entry_new(signal_name);
 999
1000         for (i = 0; i < n_objects; ++i)
1001             pa_idxset_put(signal_paths_entry->paths, pa_xstrdup(objects[i]), NULL);
1002
1003         pa_hashmap_put(conn_entry->listening_signals, signal_paths_entry->signal, signal_paths_entry);
1004
1005     } else {
1006         conn_entry->listening_for_all_signals = true;
1007
1008         /* We're not interested in individual signals anymore, so let's empty
1009          * listening_signals. */
1010         pa_hashmap_remove_all(conn_entry->listening_signals);
1011
1012         for (i = 0; i < n_objects; ++i)
1013             pa_idxset_put(conn_entry->all_signals_objects, pa_xstrdup(objects[i]), NULL);
1014     }
1015 }
1016
1017 void pa_dbus_protocol_remove_signal_listener(pa_dbus_protocol *p, DBusConnection *conn, const char *signal_name) {
1018     struct connection_entry *conn_entry = NULL;
1019     struct signal_paths_entry *signal_paths_entry = NULL;
1020
1021     pa_assert(p);
1022     pa_assert(conn);
1023
1024     pa_assert_se((conn_entry = pa_hashmap_get(p->connections, conn)));
1025
1026     if (signal_name) {
1027         if ((signal_paths_entry = pa_hashmap_remove(conn_entry->listening_signals, signal_name)))
1028             signal_paths_entry_free(signal_paths_entry);
1029
1030     } else {
1031         conn_entry->listening_for_all_signals = false;
1032         pa_idxset_remove_all(conn_entry->all_signals_objects, pa_xfree);
1033         pa_hashmap_remove_all(conn_entry->listening_signals);
1034     }
1035 }
1036
1037 void pa_dbus_protocol_send_signal(pa_dbus_protocol *p, DBusMessage *signal_msg) {
1038     struct connection_entry *conn_entry;
1039     struct signal_paths_entry *signal_paths_entry;
1040     void *state = NULL;
1041     DBusMessage *signal_copy;
1042     char *signal_string;
1043
1044     pa_assert(p);
1045     pa_assert(signal_msg);
1046     pa_assert(dbus_message_get_type(signal_msg) == DBUS_MESSAGE_TYPE_SIGNAL);
1047     pa_assert(dbus_message_get_path(signal_msg));
1048     pa_assert(dbus_message_get_interface(signal_msg));
1049     pa_assert(dbus_message_get_member(signal_msg));
1050
1051     signal_string = pa_sprintf_malloc("%s.%s", dbus_message_get_interface(signal_msg), dbus_message_get_member(signal_msg));
1052
1053     PA_HASHMAP_FOREACH(conn_entry, p->connections, state) {
1054         if ((conn_entry->listening_for_all_signals /* Case 1: listening for all signals */
1055              && (pa_idxset_get_by_data(conn_entry->all_signals_objects, dbus_message_get_path(signal_msg), NULL)
1056                  || pa_idxset_isempty(conn_entry->all_signals_objects)))
1057
1058             || (!conn_entry->listening_for_all_signals /* Case 2: not listening for all signals */
1059                 && (signal_paths_entry = pa_hashmap_get(conn_entry->listening_signals, signal_string))
1060                 && (pa_idxset_get_by_data(signal_paths_entry->paths, dbus_message_get_path(signal_msg), NULL)
1061                     || pa_idxset_isempty(signal_paths_entry->paths)))) {
1062
1063             pa_assert_se(signal_copy = dbus_message_copy(signal_msg));
1064             pa_assert_se(dbus_connection_send(conn_entry->connection, signal_copy, NULL));
1065             dbus_message_unref(signal_copy);
1066         }
1067     }
1068
1069     pa_xfree(signal_string);
1070 }
1071
1072 const char **pa_dbus_protocol_get_extensions(pa_dbus_protocol *p, unsigned *n) {
1073     const char **extensions;
1074     const char *ext_name;
1075     void *state = NULL;
1076     unsigned i = 0;
1077
1078     pa_assert(p);
1079     pa_assert(n);
1080
1081     *n = pa_idxset_size(p->extensions);
1082
1083     if (*n <= 0)
1084         return NULL;
1085
1086     extensions = pa_xnew(const char *, *n);
1087
1088     while ((ext_name = pa_idxset_iterate(p->extensions, &state, NULL)))
1089         extensions[i++] = ext_name;
1090
1091     return extensions;
1092 }
1093
1094 int pa_dbus_protocol_register_extension(pa_dbus_protocol *p, const char *name) {
1095     char *internal_name;
1096
1097     pa_assert(p);
1098     pa_assert(name);
1099
1100     internal_name = pa_xstrdup(name);
1101
1102     if (pa_idxset_put(p->extensions, internal_name, NULL) < 0) {
1103         pa_xfree(internal_name);
1104         return -1;
1105     }
1106
1107     pa_hook_fire(&p->hooks[PA_DBUS_PROTOCOL_HOOK_EXTENSION_REGISTERED], internal_name);
1108
1109     return 0;
1110 }
1111
1112 int pa_dbus_protocol_unregister_extension(pa_dbus_protocol *p, const char *name) {
1113     char *internal_name;
1114
1115     pa_assert(p);
1116     pa_assert(name);
1117
1118     if (!(internal_name = pa_idxset_remove_by_data(p->extensions, name, NULL)))
1119         return -1;
1120
1121     pa_hook_fire(&p->hooks[PA_DBUS_PROTOCOL_HOOK_EXTENSION_UNREGISTERED], internal_name);
1122
1123     pa_xfree(internal_name);
1124
1125     return 0;
1126 }
1127
1128 pa_hook_slot *pa_dbus_protocol_hook_connect(
1129         pa_dbus_protocol *p,
1130         pa_dbus_protocol_hook_t hook,
1131         pa_hook_priority_t prio,
1132         pa_hook_cb_t cb,
1133         void *data) {
1134     pa_assert(p);
1135     pa_assert(hook < PA_DBUS_PROTOCOL_HOOK_MAX);
1136     pa_assert(cb);
1137
1138     return pa_hook_connect(&p->hooks[hook], prio, cb, data);
1139 }