src/modules/dbus/iface-core.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 <ctype.h>
  27
  28 #include <dbus/dbus.h>
  29
  30 #include <pulse/utf8.h>
  31 #include <pulse/xmalloc.h>
  32
  33 #include <pulsecore/core-util.h>
  34 #include <pulsecore/dbus-util.h>
  35 #include <pulsecore/macro.h>
  36 #include <pulsecore/namereg.h>
  37 #include <pulsecore/protocol-dbus.h>
  38 #include <pulsecore/socket-util.h>
  39 #include <pulsecore/strbuf.h>
  40
  41 #include "iface-card.h"
  42 #include "iface-client.h"
  43 #include "iface-device.h"
  44 #include "iface-memstats.h"
  45 #include "iface-module.h"
  46 #include "iface-sample.h"
  47 #include "iface-stream.h"
  48
  49 #include "iface-core.h"
  50
  51 #define INTERFACE_REVISION 0
  52
  53 static void handle_get_interface_revision(DBusConnection *conn, DBusMessage *msg, void *userdata);
  54 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
  55 static void handle_get_version(DBusConnection *conn, DBusMessage *msg, void *userdata);
  56 static void handle_get_is_local(DBusConnection *conn, DBusMessage *msg, void *userdata);
  57 static void handle_get_username(DBusConnection *conn, DBusMessage *msg, void *userdata);
  58 static void handle_get_hostname(DBusConnection *conn, DBusMessage *msg, void *userdata);
  59 static void handle_get_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata);
  60 static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata);
  61 static void handle_get_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata);
  62 static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata);
  63 static void handle_get_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata);
  64 static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata);
  65 static void handle_get_cards(DBusConnection *conn, DBusMessage *msg, void *userdata);
  66 static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata);
  67 static void handle_get_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata);
  68 static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata);
  69 static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata);
  70 static void handle_get_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata);
  71 static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata);
  72 static void handle_get_playback_streams(DBusConnection *conn, DBusMessage *msg, void *userdata);
  73 static void handle_get_record_streams(DBusConnection *conn, DBusMessage *msg, void *userdata);
  74 static void handle_get_samples(DBusConnection *conn, DBusMessage *msg, void *userdata);
  75 static void handle_get_modules(DBusConnection *conn, DBusMessage *msg, void *userdata);
  76 static void handle_get_clients(DBusConnection *conn, DBusMessage *msg, void *userdata);
  77 static void handle_get_my_client(DBusConnection *conn, DBusMessage *msg, void *userdata);
  78 static void handle_get_extensions(DBusConnection *conn, DBusMessage *msg, void *userdata);
  79
  80 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata);
  81
  82 static void handle_get_card_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
  83 static void handle_get_sink_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
  84 static void handle_get_source_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
  85 static void handle_get_sample_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
  86 static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *userdata);
  87 static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *userdata);
  88 static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata);
  89 static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata);
  90 static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata);
  91
  92 struct pa_dbusiface_core {
  93     pa_core *core;
  94     pa_subscription *subscription;
  95
  96     pa_dbus_protocol *dbus_protocol;
  97
  98     pa_hashmap *cards;
  99     pa_hashmap *sinks_by_index;
 100     pa_hashmap *sinks_by_path;
 101     pa_hashmap *sources_by_index;
 102     pa_hashmap *sources_by_path;
 103     pa_hashmap *playback_streams;
 104     pa_hashmap *record_streams;
 105     pa_hashmap *samples;
 106     pa_hashmap *modules;
 107     pa_hashmap *clients;
 108
 109     pa_sink *fallback_sink;
 110     pa_source *fallback_source;
 111
 112     pa_hook_slot *extension_registered_slot;
 113     pa_hook_slot *extension_unregistered_slot;
 114
 115     pa_dbusiface_memstats *memstats;
 116 };
 117
 118 enum property_handler_index {
 119     PROPERTY_HANDLER_INTERFACE_REVISION,
 120     PROPERTY_HANDLER_NAME,
 121     PROPERTY_HANDLER_VERSION,
 122     PROPERTY_HANDLER_IS_LOCAL,
 123     PROPERTY_HANDLER_USERNAME,
 124     PROPERTY_HANDLER_HOSTNAME,
 125     PROPERTY_HANDLER_DEFAULT_CHANNELS,
 126     PROPERTY_HANDLER_DEFAULT_SAMPLE_FORMAT,
 127     PROPERTY_HANDLER_DEFAULT_SAMPLE_RATE,
 128     PROPERTY_HANDLER_CARDS,
 129     PROPERTY_HANDLER_SINKS,
 130     PROPERTY_HANDLER_FALLBACK_SINK,
 131     PROPERTY_HANDLER_SOURCES,
 132     PROPERTY_HANDLER_FALLBACK_SOURCE,
 133     PROPERTY_HANDLER_PLAYBACK_STREAMS,
 134     PROPERTY_HANDLER_RECORD_STREAMS,
 135     PROPERTY_HANDLER_SAMPLES,
 136     PROPERTY_HANDLER_MODULES,
 137     PROPERTY_HANDLER_CLIENTS,
 138     PROPERTY_HANDLER_MY_CLIENT,
 139     PROPERTY_HANDLER_EXTENSIONS,
 140     PROPERTY_HANDLER_MAX
 141 };
 142
 143 static pa_dbus_property_handler property_handlers[PROPERTY_HANDLER_MAX] = {
 144     [PROPERTY_HANDLER_INTERFACE_REVISION]    = { .property_name = "InterfaceRevision",   .type = "u",  .get_cb = handle_get_interface_revision,    .set_cb = NULL },
 145     [PROPERTY_HANDLER_NAME]                  = { .property_name = "Name",                .type = "s",  .get_cb = handle_get_name,                  .set_cb = NULL },
 146     [PROPERTY_HANDLER_VERSION]               = { .property_name = "Version",             .type = "s",  .get_cb = handle_get_version,               .set_cb = NULL },
 147     [PROPERTY_HANDLER_IS_LOCAL]              = { .property_name = "IsLocal",             .type = "b",  .get_cb = handle_get_is_local,              .set_cb = NULL },
 148     [PROPERTY_HANDLER_USERNAME]              = { .property_name = "Username",            .type = "s",  .get_cb = handle_get_username,              .set_cb = NULL },
 149     [PROPERTY_HANDLER_HOSTNAME]              = { .property_name = "Hostname",            .type = "s",  .get_cb = handle_get_hostname,              .set_cb = NULL },
 150     [PROPERTY_HANDLER_DEFAULT_CHANNELS]      = { .property_name = "DefaultChannels",     .type = "au", .get_cb = handle_get_default_channels,      .set_cb = handle_set_default_channels },
 151     [PROPERTY_HANDLER_DEFAULT_SAMPLE_FORMAT] = { .property_name = "DefaultSampleFormat", .type = "u",  .get_cb = handle_get_default_sample_format, .set_cb = handle_set_default_sample_format },
 152     [PROPERTY_HANDLER_DEFAULT_SAMPLE_RATE]   = { .property_name = "DefaultSampleRate",   .type = "u",  .get_cb = handle_get_default_sample_rate,   .set_cb = handle_set_default_sample_rate },
 153     [PROPERTY_HANDLER_CARDS]                 = { .property_name = "Cards",               .type = "ao", .get_cb = handle_get_cards,                 .set_cb = NULL },
 154     [PROPERTY_HANDLER_SINKS]                 = { .property_name = "Sinks",               .type = "ao", .get_cb = handle_get_sinks,                 .set_cb = NULL },
 155     [PROPERTY_HANDLER_FALLBACK_SINK]         = { .property_name = "FallbackSink",        .type = "o",  .get_cb = handle_get_fallback_sink,         .set_cb = handle_set_fallback_sink },
 156     [PROPERTY_HANDLER_SOURCES]               = { .property_name = "Sources",             .type = "ao", .get_cb = handle_get_sources,               .set_cb = NULL },
 157     [PROPERTY_HANDLER_FALLBACK_SOURCE]       = { .property_name = "FallbackSource",      .type = "o",  .get_cb = handle_get_fallback_source,       .set_cb = handle_set_fallback_source },
 158     [PROPERTY_HANDLER_PLAYBACK_STREAMS]      = { .property_name = "PlaybackStreams",     .type = "ao", .get_cb = handle_get_playback_streams,      .set_cb = NULL },
 159     [PROPERTY_HANDLER_RECORD_STREAMS]        = { .property_name = "RecordStreams",       .type = "ao", .get_cb = handle_get_record_streams,        .set_cb = NULL },
 160     [PROPERTY_HANDLER_SAMPLES]               = { .property_name = "Samples",             .type = "ao", .get_cb = handle_get_samples,               .set_cb = NULL },
 161     [PROPERTY_HANDLER_MODULES]               = { .property_name = "Modules",             .type = "ao", .get_cb = handle_get_modules,               .set_cb = NULL },
 162     [PROPERTY_HANDLER_CLIENTS]               = { .property_name = "Clients",             .type = "ao", .get_cb = handle_get_clients,               .set_cb = NULL },
 163     [PROPERTY_HANDLER_MY_CLIENT]             = { .property_name = "MyClient",            .type = "o",  .get_cb = handle_get_my_client,             .set_cb = NULL },
 164     [PROPERTY_HANDLER_EXTENSIONS]            = { .property_name = "Extensions",          .type = "as", .get_cb = handle_get_extensions,            .set_cb = NULL }
 165 };
 166
 167 enum method_handler_index {
 168     METHOD_HANDLER_GET_CARD_BY_NAME,
 169     METHOD_HANDLER_GET_SINK_BY_NAME,
 170     METHOD_HANDLER_GET_SOURCE_BY_NAME,
 171     METHOD_HANDLER_GET_SAMPLE_BY_NAME,
 172     METHOD_HANDLER_UPLOAD_SAMPLE,
 173     METHOD_HANDLER_LOAD_MODULE,
 174     METHOD_HANDLER_EXIT,
 175     METHOD_HANDLER_LISTEN_FOR_SIGNAL,
 176     METHOD_HANDLER_STOP_LISTENING_FOR_SIGNAL,
 177     METHOD_HANDLER_MAX
 178 };
 179
 180 static pa_dbus_arg_info get_card_by_name_args[] = { { "name", "s", "in" }, { "card", "o", "out" } };
 181 static pa_dbus_arg_info get_sink_by_name_args[] = { { "name", "s", "in" }, { "sink", "o", "out" } };
 182 static pa_dbus_arg_info get_source_by_name_args[] = { { "name", "s", "in" }, { "source", "o", "out" } };
 183 static pa_dbus_arg_info get_sample_by_name_args[] = { { "name", "s", "in" }, { "sample", "o", "out" } };
 184 static pa_dbus_arg_info upload_sample_args[] = { { "name",           "s",      "in" },
 185                                                  { "sample_format",  "u",      "in" },
 186                                                  { "sample_rate",    "u",      "in" },
 187                                                  { "channels",       "au",     "in" },
 188                                                  { "default_volume", "au",     "in" },
 189                                                  { "property_list",  "a{say}", "in" },
 190                                                  { "data",           "ay",     "in" },
 191                                                  { "sample",         "o",      "out" } };
 192 static pa_dbus_arg_info load_module_args[] = { { "name", "s", "in" }, { "arguments", "a{ss}", "in" }, { "module", "o", "out" } };
 193 static pa_dbus_arg_info listen_for_signal_args[] = { { "signal", "s", "in" }, { "objects", "ao", "in" } };
 194 static pa_dbus_arg_info stop_listening_for_signal_args[] = { { "signal", "s", "in" } };
 195
 196 static pa_dbus_method_handler method_handlers[METHOD_HANDLER_MAX] = {
 197     [METHOD_HANDLER_GET_CARD_BY_NAME] = {
 198         .method_name = "GetCardByName",
 199         .arguments = get_card_by_name_args,
 200         .n_arguments = sizeof(get_card_by_name_args) / sizeof(pa_dbus_arg_info),
 201         .receive_cb = handle_get_card_by_name },
 202     [METHOD_HANDLER_GET_SINK_BY_NAME] = {
 203         .method_name = "GetSinkByName",
 204         .arguments = get_sink_by_name_args,
 205         .n_arguments = sizeof(get_sink_by_name_args) / sizeof(pa_dbus_arg_info),
 206         .receive_cb = handle_get_sink_by_name },
 207     [METHOD_HANDLER_GET_SOURCE_BY_NAME] = {
 208         .method_name = "GetSourceByName",
 209         .arguments = get_source_by_name_args,
 210         .n_arguments = sizeof(get_source_by_name_args) / sizeof(pa_dbus_arg_info),
 211         .receive_cb = handle_get_source_by_name },
 212     [METHOD_HANDLER_GET_SAMPLE_BY_NAME] = {
 213         .method_name = "GetSampleByName",
 214         .arguments = get_sample_by_name_args,
 215         .n_arguments = sizeof(get_sample_by_name_args) / sizeof(pa_dbus_arg_info),
 216         .receive_cb = handle_get_sample_by_name },
 217     [METHOD_HANDLER_UPLOAD_SAMPLE] = {
 218         .method_name = "UploadSample",
 219         .arguments = upload_sample_args,
 220         .n_arguments = sizeof(upload_sample_args) / sizeof(pa_dbus_arg_info),
 221         .receive_cb = handle_upload_sample },
 222     [METHOD_HANDLER_LOAD_MODULE] = {
 223         .method_name = "LoadModule",
 224         .arguments = load_module_args,
 225         .n_arguments = sizeof(load_module_args) / sizeof(pa_dbus_arg_info),
 226         .receive_cb = handle_load_module },
 227     [METHOD_HANDLER_EXIT] = {
 228         .method_name = "Exit",
 229         .arguments = NULL,
 230         .n_arguments = 0,
 231         .receive_cb = handle_exit },
 232     [METHOD_HANDLER_LISTEN_FOR_SIGNAL] = {
 233         .method_name = "ListenForSignal",
 234         .arguments = listen_for_signal_args,
 235         .n_arguments = sizeof(listen_for_signal_args) / sizeof(pa_dbus_arg_info),
 236         .receive_cb = handle_listen_for_signal },
 237     [METHOD_HANDLER_STOP_LISTENING_FOR_SIGNAL] = {
 238         .method_name = "StopListeningForSignal",
 239         .arguments = stop_listening_for_signal_args,
 240         .n_arguments = sizeof(stop_listening_for_signal_args) / sizeof(pa_dbus_arg_info),
 241         .receive_cb = handle_stop_listening_for_signal }
 242 };
 243
 244 enum signal_index {
 245     SIGNAL_NEW_CARD,
 246     SIGNAL_CARD_REMOVED,
 247     SIGNAL_NEW_SINK,
 248     SIGNAL_SINK_REMOVED,
 249     SIGNAL_FALLBACK_SINK_UPDATED,
 250     SIGNAL_NEW_SOURCE,
 251     SIGNAL_SOURCE_REMOVED,
 252     SIGNAL_FALLBACK_SOURCE_UPDATED,
 253     SIGNAL_NEW_PLAYBACK_STREAM,
 254     SIGNAL_PLAYBACK_STREAM_REMOVED,
 255     SIGNAL_NEW_RECORD_STREAM,
 256     SIGNAL_RECORD_STREAM_REMOVED,
 257     SIGNAL_NEW_SAMPLE,
 258     SIGNAL_SAMPLE_REMOVED,
 259     SIGNAL_NEW_MODULE,
 260     SIGNAL_MODULE_REMOVED,
 261     SIGNAL_NEW_CLIENT,
 262     SIGNAL_CLIENT_REMOVED,
 263     SIGNAL_NEW_EXTENSION,
 264     SIGNAL_EXTENSION_REMOVED,
 265     SIGNAL_MAX
 266 };
 267
 268 static pa_dbus_arg_info new_card_args[] =                { { "card",            "o", NULL } };
 269 static pa_dbus_arg_info card_removed_args[] =            { { "card",            "o", NULL } };
 270 static pa_dbus_arg_info new_sink_args[] =                { { "sink",            "o", NULL } };
 271 static pa_dbus_arg_info sink_removed_args[] =            { { "sink",            "o", NULL } };
 272 static pa_dbus_arg_info fallback_sink_updated_args[] =   { { "sink",            "o", NULL } };
 273 static pa_dbus_arg_info new_source_args[] =              { { "source",          "o", NULL } };
 274 static pa_dbus_arg_info source_removed_args[] =          { { "source",          "o", NULL } };
 275 static pa_dbus_arg_info fallback_source_updated_args[] = { { "source",          "o", NULL } };
 276 static pa_dbus_arg_info new_playback_stream_args[] =     { { "playback_stream", "o", NULL } };
 277 static pa_dbus_arg_info playback_stream_removed_args[] = { { "playback_stream", "o", NULL } };
 278 static pa_dbus_arg_info new_record_stream_args[] =       { { "record_stream",   "o", NULL } };
 279 static pa_dbus_arg_info record_stream_removed_args[] =   { { "record_stream",   "o", NULL } };
 280 static pa_dbus_arg_info new_sample_args[] =              { { "sample",          "o", NULL } };
 281 static pa_dbus_arg_info sample_removed_args[] =          { { "sample",          "o", NULL } };
 282 static pa_dbus_arg_info new_module_args[] =              { { "module",          "o", NULL } };
 283 static pa_dbus_arg_info module_removed_args[] =          { { "module",          "o", NULL } };
 284 static pa_dbus_arg_info new_client_args[] =              { { "client",          "o", NULL } };
 285 static pa_dbus_arg_info client_removed_args[] =          { { "client",          "o", NULL } };
 286 static pa_dbus_arg_info new_extension_args[] =           { { "extension",       "s", NULL } };
 287 static pa_dbus_arg_info extension_removed_args[] =       { { "extension",       "s", NULL } };
 288
 289 static pa_dbus_signal_info signals[SIGNAL_MAX] = {
 290     [SIGNAL_NEW_CARD]                = { .name = "NewCard",               .arguments = new_card_args,                .n_arguments = 1 },
 291     [SIGNAL_CARD_REMOVED]            = { .name = "CardRemoved",           .arguments = card_removed_args,            .n_arguments = 1 },
 292     [SIGNAL_NEW_SINK]                = { .name = "NewSink",               .arguments = new_sink_args,                .n_arguments = 1 },
 293     [SIGNAL_SINK_REMOVED]            = { .name = "SinkRemoved",           .arguments = sink_removed_args,            .n_arguments = 1 },
 294     [SIGNAL_FALLBACK_SINK_UPDATED]   = { .name = "FallbackSinkUpdated",   .arguments = fallback_sink_updated_args,   .n_arguments = 1 },
 295     [SIGNAL_NEW_SOURCE]              = { .name = "NewSource",             .arguments = new_source_args,              .n_arguments = 1 },
 296     [SIGNAL_SOURCE_REMOVED]          = { .name = "SourceRemoved",         .arguments = source_removed_args,          .n_arguments = 1 },
 297     [SIGNAL_FALLBACK_SOURCE_UPDATED] = { .name = "FallbackSourceUpdated", .arguments = fallback_source_updated_args, .n_arguments = 1 },
 298     [SIGNAL_NEW_PLAYBACK_STREAM]     = { .name = "NewPlaybackStream",     .arguments = new_playback_stream_args,     .n_arguments = 1 },
 299     [SIGNAL_PLAYBACK_STREAM_REMOVED] = { .name = "PlaybackStreamRemoved", .arguments = playback_stream_removed_args, .n_arguments = 1 },
 300     [SIGNAL_NEW_RECORD_STREAM]       = { .name = "NewRecordStream",       .arguments = new_record_stream_args,       .n_arguments = 1 },
 301     [SIGNAL_RECORD_STREAM_REMOVED]   = { .name = "RecordStreamRemoved",   .arguments = record_stream_removed_args,   .n_arguments = 1 },
 302     [SIGNAL_NEW_SAMPLE]              = { .name = "NewSample",             .arguments = new_sample_args,              .n_arguments = 1 },
 303     [SIGNAL_SAMPLE_REMOVED]          = { .name = "SampleRemoved",         .arguments = sample_removed_args,          .n_arguments = 1 },
 304     [SIGNAL_NEW_MODULE]              = { .name = "NewModule",             .arguments = new_module_args,              .n_arguments = 1 },
 305     [SIGNAL_MODULE_REMOVED]          = { .name = "ModuleRemoved",         .arguments = module_removed_args,          .n_arguments = 1 },
 306     [SIGNAL_NEW_CLIENT]              = { .name = "NewClient",             .arguments = new_client_args,              .n_arguments = 1 },
 307     [SIGNAL_CLIENT_REMOVED]          = { .name = "ClientRemoved",         .arguments = client_removed_args,          .n_arguments = 1 },
 308     [SIGNAL_NEW_EXTENSION]           = { .name = "NewExtension",          .arguments = new_extension_args,           .n_arguments = 1 },
 309     [SIGNAL_EXTENSION_REMOVED]       = { .name = "ExtensionRemoved",      .arguments = extension_removed_args,       .n_arguments = 1 }
 310 };
 311
 312 static pa_dbus_interface_info core_interface_info = {
 313     .name = PA_DBUS_CORE_INTERFACE,
 314     .method_handlers = method_handlers,
 315     .n_method_handlers = METHOD_HANDLER_MAX,
 316     .property_handlers = property_handlers,
 317     .n_property_handlers = PROPERTY_HANDLER_MAX,
 318     .get_all_properties_cb = handle_get_all,
 319     .signals = signals,
 320     .n_signals = SIGNAL_MAX
 321 };
 322
 323 static void handle_get_interface_revision(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 324     dbus_uint32_t interface_revision = INTERFACE_REVISION;
 325
 326     pa_assert(conn);
 327     pa_assert(msg);
 328
 329     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &interface_revision);
 330 }
 331
 332 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 333     const char *server_name = PACKAGE_NAME;
 334
 335     pa_assert(conn);
 336     pa_assert(msg);
 337
 338     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &server_name);
 339 }
 340
 341 static void handle_get_version(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 342     const char *version = PACKAGE_VERSION;
 343
 344     pa_assert(conn);
 345     pa_assert(msg);
 346
 347     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &version);
 348 }
 349
 350 static dbus_bool_t get_is_local(DBusConnection *conn) {
 351     int conn_fd;
 352
 353     pa_assert(conn);
 354
 355     if (!dbus_connection_get_socket(conn, &conn_fd))
 356         return FALSE;
 357
 358     return pa_socket_is_local(conn_fd);
 359 }
 360
 361 static void handle_get_is_local(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 362     dbus_bool_t is_local;
 363
 364     pa_assert(conn);
 365     pa_assert(msg);
 366
 367     is_local = get_is_local(conn);
 368
 369     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_BOOLEAN, &is_local);
 370 }
 371
 372 static void handle_get_username(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 373     char *username = NULL;
 374
 375     pa_assert(conn);
 376     pa_assert(msg);
 377
 378     username = pa_get_user_name_malloc();
 379
 380     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &username);
 381
 382     pa_xfree(username);
 383 }
 384
 385 static void handle_get_hostname(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 386     char *hostname = NULL;
 387
 388     pa_assert(conn);
 389     pa_assert(msg);
 390
 391     hostname = pa_get_host_name_malloc();
 392
 393     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &hostname);
 394
 395     pa_xfree(hostname);
 396 }
 397
 398 /* Caller frees the returned array. */
 399 static dbus_uint32_t *get_default_channels(pa_dbusiface_core *c, unsigned *n) {
 400     dbus_uint32_t *default_channels = NULL;
 401     unsigned i;
 402
 403     pa_assert(c);
 404     pa_assert(n);
 405
 406     *n = c->core->default_channel_map.channels;
 407     default_channels = pa_xnew(dbus_uint32_t, *n);
 408
 409     for (i = 0; i < *n; ++i)
 410         default_channels[i] = c->core->default_channel_map.map[i];
 411
 412     return default_channels;
 413 }
 414
 415 static void handle_get_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 416     pa_dbusiface_core *c = userdata;
 417     dbus_uint32_t *default_channels = NULL;
 418     unsigned n;
 419
 420     pa_assert(conn);
 421     pa_assert(msg);
 422     pa_assert(c);
 423
 424     default_channels = get_default_channels(c, &n);
 425
 426     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_UINT32, default_channels, n);
 427
 428     pa_xfree(default_channels);
 429 }
 430
 431 static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
 432     pa_dbusiface_core *c = userdata;
 433     DBusMessageIter array_iter;
 434     pa_channel_map new_channel_map;
 435     const dbus_uint32_t *default_channels;
 436     int n_channels;
 437     unsigned i;
 438
 439     pa_assert(conn);
 440     pa_assert(msg);
 441     pa_assert(iter);
 442     pa_assert(c);
 443
 444     pa_channel_map_init(&new_channel_map);
 445
 446     dbus_message_iter_recurse(iter, &array_iter);
 447     dbus_message_iter_get_fixed_array(&array_iter, &default_channels, &n_channels);
 448
 449     if (n_channels <= 0) {
 450         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty channel array.");
 451         return;
 452     }
 453
 454     if (n_channels > (int) PA_CHANNELS_MAX) {
 455         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
 456                            "Too many channels: %i. The maximum number of channels is %u.", n_channels, PA_CHANNELS_MAX);
 457         return;
 458     }
 459
 460     new_channel_map.channels = n_channels;
 461
 462     for (i = 0; i < new_channel_map.channels; ++i) {
 463         if (default_channels[i] >= PA_CHANNEL_POSITION_MAX) {
 464             pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid channel position: %u.", default_channels[i]);
 465             return;
 466         }
 467
 468         new_channel_map.map[i] = default_channels[i];
 469     }
 470
 471     c->core->default_channel_map = new_channel_map;
 472     c->core->default_sample_spec.channels = n_channels;
 473
 474     pa_dbus_send_empty_reply(conn, msg);
 475 };
 476
 477 static void handle_get_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 478     pa_dbusiface_core *c = userdata;
 479     dbus_uint32_t default_sample_format;
 480
 481     pa_assert(conn);
 482     pa_assert(msg);
 483     pa_assert(c);
 484
 485     default_sample_format = c->core->default_sample_spec.format;
 486
 487     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_format);
 488 }
 489
 490 static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
 491     pa_dbusiface_core *c = userdata;
 492     dbus_uint32_t default_sample_format;
 493
 494     pa_assert(conn);
 495     pa_assert(msg);
 496     pa_assert(iter);
 497     pa_assert(c);
 498
 499     dbus_message_iter_get_basic(iter, &default_sample_format);
 500
 501     if (default_sample_format >= PA_SAMPLE_MAX) {
 502         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format.");
 503         return;
 504     }
 505
 506     c->core->default_sample_spec.format = default_sample_format;
 507
 508     pa_dbus_send_empty_reply(conn, msg);
 509 }
 510
 511 static void handle_get_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 512     pa_dbusiface_core *c = userdata;
 513     dbus_uint32_t default_sample_rate;
 514
 515     pa_assert(conn);
 516     pa_assert(msg);
 517     pa_assert(c);
 518
 519     default_sample_rate = c->core->default_sample_spec.rate;
 520
 521     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_rate);
 522 }
 523
 524 static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
 525     pa_dbusiface_core *c = userdata;
 526     dbus_uint32_t default_sample_rate;
 527
 528     pa_assert(conn);
 529     pa_assert(msg);
 530     pa_assert(iter);
 531     pa_assert(c);
 532
 533     dbus_message_iter_get_basic(iter, &default_sample_rate);
 534
 535     if (default_sample_rate <= 0 || default_sample_rate > PA_RATE_MAX) {
 536         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample rate.");
 537         return;
 538     }
 539
 540     c->core->default_sample_spec.rate = default_sample_rate;
 541
 542     pa_dbus_send_empty_reply(conn, msg);
 543 }
 544
 545 /* The caller frees the array, but not the strings. */
 546 static const char **get_cards(pa_dbusiface_core *c, unsigned *n) {
 547     const char **cards;
 548     unsigned i = 0;
 549     void *state = NULL;
 550     pa_dbusiface_card *card;
 551
 552     pa_assert(c);
 553     pa_assert(n);
 554
 555     *n = pa_hashmap_size(c->cards);
 556
 557     if (*n == 0)
 558         return NULL;
 559
 560     cards = pa_xnew(const char *, *n);
 561
 562     PA_HASHMAP_FOREACH(card, c->cards, state)
 563         cards[i++] = pa_dbusiface_card_get_path(card);
 564
 565     return cards;
 566 }
 567
 568 static void handle_get_cards(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 569     pa_dbusiface_core *c = userdata;
 570     const char **cards;
 571     unsigned n;
 572
 573     pa_assert(conn);
 574     pa_assert(msg);
 575     pa_assert(c);
 576
 577     cards = get_cards(c, &n);
 578
 579     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, cards, n);
 580
 581     pa_xfree(cards);
 582 }
 583
 584 /* The caller frees the array, but not the strings. */
 585 static const char **get_sinks(pa_dbusiface_core *c, unsigned *n) {
 586     const char **sinks;
 587     unsigned i = 0;
 588     void *state = NULL;
 589     pa_dbusiface_device *sink;
 590
 591     pa_assert(c);
 592     pa_assert(n);
 593
 594     *n = pa_hashmap_size(c->sinks_by_index);
 595
 596     if (*n == 0)
 597         return NULL;
 598
 599     sinks = pa_xnew(const char *, *n);
 600
 601     PA_HASHMAP_FOREACH(sink, c->sinks_by_index, state)
 602         sinks[i++] = pa_dbusiface_device_get_path(sink);
 603
 604     return sinks;
 605 }
 606
 607 static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 608     pa_dbusiface_core *c = userdata;
 609     const char **sinks;
 610     unsigned n;
 611
 612     pa_assert(conn);
 613     pa_assert(msg);
 614     pa_assert(c);
 615
 616     sinks = get_sinks(c, &n);
 617
 618     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sinks, n);
 619
 620     pa_xfree(sinks);
 621 }
 622
 623 static void handle_get_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 624     pa_dbusiface_core *c = userdata;
 625     pa_dbusiface_device *fallback_sink;
 626     const char *object_path;
 627
 628     pa_assert(conn);
 629     pa_assert(msg);
 630     pa_assert(c);
 631
 632     if (!c->fallback_sink) {
 633         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 634                            "There are no sinks, and therefore no fallback sink either.");
 635         return;
 636     }
 637
 638     pa_assert_se((fallback_sink = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(c->fallback_sink->index))));
 639     object_path = pa_dbusiface_device_get_path(fallback_sink);
 640
 641     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
 642 }
 643
 644 static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
 645     pa_dbusiface_core *c = userdata;
 646     pa_dbusiface_device *fallback_sink;
 647     const char *object_path;
 648
 649     pa_assert(conn);
 650     pa_assert(msg);
 651     pa_assert(iter);
 652     pa_assert(c);
 653
 654     if (!c->fallback_sink) {
 655         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 656                            "There are no sinks, and therefore no fallback sink either.");
 657         return;
 658     }
 659
 660     dbus_message_iter_get_basic(iter, &object_path);
 661
 662     if (!(fallback_sink = pa_hashmap_get(c->sinks_by_path, object_path))) {
 663         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such sink.", object_path);
 664         return;
 665     }
 666
 667     pa_namereg_set_default_sink(c->core, pa_dbusiface_device_get_sink(fallback_sink));
 668
 669     pa_dbus_send_empty_reply(conn, msg);
 670 }
 671
 672 /* The caller frees the array, but not the strings. */
 673 static const char **get_sources(pa_dbusiface_core *c, unsigned *n) {
 674     const char **sources;
 675     unsigned i = 0;
 676     void *state = NULL;
 677     pa_dbusiface_device *source;
 678
 679     pa_assert(c);
 680     pa_assert(n);
 681
 682     *n = pa_hashmap_size(c->sources_by_index);
 683
 684     if (*n == 0)
 685         return NULL;
 686
 687     sources = pa_xnew(const char *, *n);
 688
 689     PA_HASHMAP_FOREACH(source, c->sources_by_index, state)
 690         sources[i++] = pa_dbusiface_device_get_path(source);
 691
 692     return sources;
 693 }
 694
 695 static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 696     pa_dbusiface_core *c = userdata;
 697     const char **sources;
 698     unsigned n;
 699
 700     pa_assert(conn);
 701     pa_assert(msg);
 702     pa_assert(c);
 703
 704     sources = get_sources(c, &n);
 705
 706     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sources, n);
 707
 708     pa_xfree(sources);
 709 }
 710
 711 static void handle_get_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 712     pa_dbusiface_core *c = userdata;
 713     pa_dbusiface_device *fallback_source;
 714     const char *object_path;
 715
 716     pa_assert(conn);
 717     pa_assert(msg);
 718     pa_assert(c);
 719
 720     if (!c->fallback_source) {
 721         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 722                            "There are no sources, and therefore no fallback source either.");
 723         return;
 724     }
 725
 726     pa_assert_se((fallback_source = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(c->fallback_source->index))));
 727     object_path = pa_dbusiface_device_get_path(fallback_source);
 728
 729     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
 730 }
 731
 732 static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
 733     pa_dbusiface_core *c = userdata;
 734     pa_dbusiface_device *fallback_source;
 735     const char *object_path;
 736
 737     pa_assert(conn);
 738     pa_assert(msg);
 739     pa_assert(iter);
 740     pa_assert(c);
 741
 742     if (!c->fallback_source) {
 743         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
 744                            "There are no sources, and therefore no fallback source either.");
 745         return;
 746     }
 747
 748     dbus_message_iter_get_basic(iter, &object_path);
 749
 750     if (!(fallback_source = pa_hashmap_get(c->sources_by_path, object_path))) {
 751         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such source.", object_path);
 752         return;
 753     }
 754
 755     pa_namereg_set_default_source(c->core, pa_dbusiface_device_get_source(fallback_source));
 756
 757     pa_dbus_send_empty_reply(conn, msg);
 758 }
 759
 760 /* The caller frees the array, but not the strings. */
 761 static const char **get_playback_streams(pa_dbusiface_core *c, unsigned *n) {
 762     const char **streams;
 763     unsigned i = 0;
 764     void *state = NULL;
 765     pa_dbusiface_stream *stream;
 766
 767     pa_assert(c);
 768     pa_assert(n);
 769
 770     *n = pa_hashmap_size(c->playback_streams);
 771
 772     if (*n == 0)
 773         return NULL;
 774
 775     streams = pa_xnew(const char *, *n);
 776
 777     PA_HASHMAP_FOREACH(stream, c->playback_streams, state)
 778         streams[i++] = pa_dbusiface_stream_get_path(stream);
 779
 780     return streams;
 781 }
 782
 783 static void handle_get_playback_streams(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 784     pa_dbusiface_core *c = userdata;
 785     const char **playback_streams;
 786     unsigned n;
 787
 788     pa_assert(conn);
 789     pa_assert(msg);
 790     pa_assert(c);
 791
 792     playback_streams = get_playback_streams(c, &n);
 793
 794     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, playback_streams, n);
 795
 796     pa_xfree(playback_streams);
 797 }
 798
 799 /* The caller frees the array, but not the strings. */
 800 static const char **get_record_streams(pa_dbusiface_core *c, unsigned *n) {
 801     const char **streams;
 802     unsigned i = 0;
 803     void *state = NULL;
 804     pa_dbusiface_stream *stream;
 805
 806     pa_assert(c);
 807     pa_assert(n);
 808
 809     *n = pa_hashmap_size(c->record_streams);
 810
 811     if (*n == 0)
 812         return NULL;
 813
 814     streams = pa_xnew(const char *, *n);
 815
 816     PA_HASHMAP_FOREACH(stream, c->record_streams, state)
 817         streams[i++] = pa_dbusiface_stream_get_path(stream);
 818
 819     return streams;
 820 }
 821
 822 static void handle_get_record_streams(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 823     pa_dbusiface_core *c = userdata;
 824     const char **record_streams;
 825     unsigned n;
 826
 827     pa_assert(conn);
 828     pa_assert(msg);
 829     pa_assert(c);
 830
 831     record_streams = get_record_streams(c, &n);
 832
 833     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, record_streams, n);
 834
 835     pa_xfree(record_streams);
 836 }
 837
 838 /* The caller frees the array, but not the strings. */
 839 static const char **get_samples(pa_dbusiface_core *c, unsigned *n) {
 840     const char **samples;
 841     unsigned i = 0;
 842     void *state = NULL;
 843     pa_dbusiface_sample *sample;
 844
 845     pa_assert(c);
 846     pa_assert(n);
 847
 848     *n = pa_hashmap_size(c->samples);
 849
 850     if (*n == 0)
 851         return NULL;
 852
 853     samples = pa_xnew(const char *, *n);
 854
 855     PA_HASHMAP_FOREACH(sample, c->samples, state)
 856         samples[i++] = pa_dbusiface_sample_get_path(sample);
 857
 858     return samples;
 859 }
 860
 861 static void handle_get_samples(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 862     pa_dbusiface_core *c = userdata;
 863     const char **samples;
 864     unsigned n;
 865
 866     pa_assert(conn);
 867     pa_assert(msg);
 868     pa_assert(c);
 869
 870     samples = get_samples(c, &n);
 871
 872     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, samples, n);
 873
 874     pa_xfree(samples);
 875 }
 876
 877 /* The caller frees the array, but not the strings. */
 878 static const char **get_modules(pa_dbusiface_core *c, unsigned *n) {
 879     const char **modules;
 880     unsigned i = 0;
 881     void *state = NULL;
 882     pa_dbusiface_module *module;
 883
 884     pa_assert(c);
 885     pa_assert(n);
 886
 887     *n = pa_hashmap_size(c->modules);
 888
 889     if (*n == 0)
 890         return NULL;
 891
 892     modules = pa_xnew(const char *, *n);
 893
 894     PA_HASHMAP_FOREACH(module, c->modules, state)
 895         modules[i++] = pa_dbusiface_module_get_path(module);
 896
 897     return modules;
 898 }
 899
 900 static void handle_get_modules(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 901     pa_dbusiface_core *c = userdata;
 902     const char **modules;
 903     unsigned n;
 904
 905     pa_assert(conn);
 906     pa_assert(msg);
 907     pa_assert(c);
 908
 909     modules = get_modules(c, &n);
 910
 911     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, modules, n);
 912
 913     pa_xfree(modules);
 914 }
 915
 916 /* The caller frees the array, but not the strings. */
 917 static const char **get_clients(pa_dbusiface_core *c, unsigned *n) {
 918     const char **clients;
 919     unsigned i = 0;
 920     void *state = NULL;
 921     pa_dbusiface_client *client;
 922
 923     pa_assert(c);
 924     pa_assert(n);
 925
 926     *n = pa_hashmap_size(c->clients);
 927
 928     if (*n == 0)
 929         return NULL;
 930
 931     clients = pa_xnew(const char *, *n);
 932
 933     PA_HASHMAP_FOREACH(client, c->clients, state)
 934         clients[i++] = pa_dbusiface_client_get_path(client);
 935
 936     return clients;
 937 }
 938
 939 static void handle_get_clients(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 940     pa_dbusiface_core *c = userdata;
 941     const char **clients;
 942     unsigned n;
 943
 944     pa_assert(conn);
 945     pa_assert(msg);
 946     pa_assert(c);
 947
 948     clients = get_clients(c, &n);
 949
 950     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, clients, n);
 951
 952     pa_xfree(clients);
 953 }
 954
 955 static const char *get_my_client(pa_dbusiface_core *c, DBusConnection *conn) {
 956     pa_client *my_client;
 957
 958     pa_assert(c);
 959     pa_assert(conn);
 960
 961     pa_assert_se((my_client = pa_dbus_protocol_get_client(c->dbus_protocol, conn)));
 962
 963     return pa_dbusiface_client_get_path(pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(my_client->index)));
 964 }
 965
 966 static void handle_get_my_client(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 967     pa_dbusiface_core *c = userdata;
 968     const char *my_client;
 969
 970     pa_assert(conn);
 971     pa_assert(msg);
 972     pa_assert(c);
 973
 974     my_client = get_my_client(c, conn);
 975
 976     pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &my_client);
 977 }
 978
 979 static void handle_get_extensions(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 980     pa_dbusiface_core *c = userdata;
 981     const char **extensions;
 982     unsigned n;
 983
 984     pa_assert(conn);
 985     pa_assert(msg);
 986     pa_assert(c);
 987
 988     extensions = pa_dbus_protocol_get_extensions(c->dbus_protocol, &n);
 989
 990     pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_STRING, extensions, n);
 991
 992     pa_xfree(extensions);
 993 }
 994
 995 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata) {
 996     pa_dbusiface_core *c = userdata;
 997     DBusMessage *reply = NULL;
 998     DBusMessageIter msg_iter;
 999     DBusMessageIter dict_iter;
1000     dbus_uint32_t interface_revision;
1001     const char *server_name;
1002     const char *version;
1003     dbus_bool_t is_local;
1004     char *username;
1005     char *hostname;
1006     dbus_uint32_t *default_channels;
1007     unsigned n_default_channels;
1008     dbus_uint32_t default_sample_format;
1009     dbus_uint32_t default_sample_rate;
1010     const char **cards;
1011     unsigned n_cards;
1012     const char **sinks;
1013     unsigned n_sinks;
1014     const char *fallback_sink;
1015     const char **sources;
1016     unsigned n_sources;
1017     const char *fallback_source;
1018     const char **playback_streams;
1019     unsigned n_playback_streams;
1020     const char **record_streams;
1021     unsigned n_record_streams;
1022     const char **samples;
1023     unsigned n_samples;
1024     const char **modules;
1025     unsigned n_modules;
1026     const char **clients;
1027     unsigned n_clients;
1028     const char *my_client;
1029     const char **extensions;
1030     unsigned n_extensions;
1031
1032     pa_assert(conn);
1033     pa_assert(msg);
1034     pa_assert(c);
1035
1036     interface_revision = INTERFACE_REVISION;
1037     server_name = PACKAGE_NAME;
1038     version = PACKAGE_VERSION;
1039     is_local = get_is_local(conn);
1040     username = pa_get_user_name_malloc();
1041     hostname = pa_get_host_name_malloc();
1042     default_channels = get_default_channels(c, &n_default_channels);
1043     default_sample_format = c->core->default_sample_spec.format;
1044     default_sample_rate = c->core->default_sample_spec.rate;
1045     cards = get_cards(c, &n_cards);
1046     sinks = get_sinks(c, &n_sinks);
1047     fallback_sink = c->fallback_sink
1048                     ? pa_dbusiface_device_get_path(pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(c->fallback_sink->index)))
1049                     : NULL;
1050     sources = get_sources(c, &n_sources);
1051     fallback_source = c->fallback_source
1052                       ? pa_dbusiface_device_get_path(pa_hashmap_get(c->sources_by_index,
1053                                                                     PA_UINT32_TO_PTR(c->fallback_source->index)))
1054                       : NULL;
1055     playback_streams = get_playback_streams(c, &n_playback_streams);
1056     record_streams = get_record_streams(c, &n_record_streams);
1057     samples = get_samples(c, &n_samples);
1058     modules = get_modules(c, &n_modules);
1059     clients = get_clients(c, &n_clients);
1060     my_client = get_my_client(c, conn);
1061     extensions = pa_dbus_protocol_get_extensions(c->dbus_protocol, &n_extensions);
1062
1063     pa_assert_se((reply = dbus_message_new_method_return(msg)));
1064
1065     dbus_message_iter_init_append(reply, &msg_iter);
1066     pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
1067
1068     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_INTERFACE_REVISION].property_name, DBUS_TYPE_UINT32, &interface_revision);
1069     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_NAME].property_name, DBUS_TYPE_STRING, &server_name);
1070     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_VERSION].property_name, DBUS_TYPE_STRING, &version);
1071     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_IS_LOCAL].property_name, DBUS_TYPE_BOOLEAN, &is_local);
1072     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_USERNAME].property_name, DBUS_TYPE_STRING, &username);
1073     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_HOSTNAME].property_name, DBUS_TYPE_STRING, &hostname);
1074     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_CHANNELS].property_name, DBUS_TYPE_UINT32, default_channels, n_default_channels);
1075     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_SAMPLE_FORMAT].property_name, DBUS_TYPE_UINT32, &default_sample_format);
1076     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_SAMPLE_RATE].property_name, DBUS_TYPE_UINT32, &default_sample_rate);
1077     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CARDS].property_name, DBUS_TYPE_OBJECT_PATH, cards, n_cards);
1078     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SINKS].property_name, DBUS_TYPE_OBJECT_PATH, sinks, n_sinks);
1079
1080     if (fallback_sink)
1081         pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_FALLBACK_SINK].property_name, DBUS_TYPE_OBJECT_PATH, &fallback_sink);
1082
1083     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SOURCES].property_name, DBUS_TYPE_OBJECT_PATH, sources, n_sources);
1084
1085     if (fallback_source)
1086         pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_FALLBACK_SOURCE].property_name, DBUS_TYPE_OBJECT_PATH, &fallback_source);
1087
1088     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_PLAYBACK_STREAMS].property_name, DBUS_TYPE_OBJECT_PATH, playback_streams, n_playback_streams);
1089     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_RECORD_STREAMS].property_name, DBUS_TYPE_OBJECT_PATH, record_streams, n_record_streams);
1090     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SAMPLES].property_name, DBUS_TYPE_OBJECT_PATH, samples, n_samples);
1091     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_MODULES].property_name, DBUS_TYPE_OBJECT_PATH, modules, n_modules);
1092     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CLIENTS].property_name, DBUS_TYPE_OBJECT_PATH, clients, n_clients);
1093     pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_MY_CLIENT].property_name, DBUS_TYPE_OBJECT_PATH, &my_client);
1094     pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_EXTENSIONS].property_name, DBUS_TYPE_STRING, extensions, n_extensions);
1095
1096     pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
1097
1098     pa_assert_se(dbus_connection_send(conn, reply, NULL));
1099
1100     dbus_message_unref(reply);
1101
1102     pa_xfree(username);
1103     pa_xfree(hostname);
1104     pa_xfree(default_channels);
1105     pa_xfree(cards);
1106     pa_xfree(sinks);
1107     pa_xfree(sources);
1108     pa_xfree(playback_streams);
1109     pa_xfree(record_streams);
1110     pa_xfree(samples);
1111     pa_xfree(modules);
1112     pa_xfree(clients);
1113     pa_xfree(extensions);
1114 }
1115
1116 static void handle_get_card_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1117     pa_dbusiface_core *c = userdata;
1118     char *card_name;
1119     pa_card *card;
1120     pa_dbusiface_card *dbus_card;
1121     const char *object_path;
1122
1123     pa_assert(conn);
1124     pa_assert(msg);
1125     pa_assert(c);
1126
1127     pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &card_name, DBUS_TYPE_INVALID));
1128
1129     if (!(card = pa_namereg_get(c->core, card_name, PA_NAMEREG_CARD))) {
1130         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such card.");
1131         return;
1132     }
1133
1134     pa_assert_se((dbus_card = pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(card->index))));
1135
1136     object_path = pa_dbusiface_card_get_path(dbus_card);
1137
1138     pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1139 }
1140
1141 static void handle_get_sink_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1142     pa_dbusiface_core *c = userdata;
1143     char *sink_name;
1144     pa_sink *sink;
1145     pa_dbusiface_device *dbus_sink;
1146     const char *object_path;
1147
1148     pa_assert(conn);
1149     pa_assert(msg);
1150     pa_assert(c);
1151
1152     pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &sink_name, DBUS_TYPE_INVALID));
1153
1154     if (!(sink = pa_namereg_get(c->core, sink_name, PA_NAMEREG_SINK))) {
1155         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such sink.", sink_name);
1156         return;
1157     }
1158
1159     pa_assert_se((dbus_sink = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(sink->index))));
1160
1161     object_path = pa_dbusiface_device_get_path(dbus_sink);
1162
1163     pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1164 }
1165
1166 static void handle_get_source_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1167     pa_dbusiface_core *c = userdata;
1168     char *source_name;
1169     pa_source *source;
1170     pa_dbusiface_device *dbus_source;
1171     const char *object_path;
1172
1173     pa_assert(conn);
1174     pa_assert(msg);
1175     pa_assert(c);
1176
1177     pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &source_name, DBUS_TYPE_INVALID));
1178
1179     if (!(source = pa_namereg_get(c->core, source_name, PA_NAMEREG_SOURCE))) {
1180         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such source.", source_name);
1181         return;
1182     }
1183
1184     pa_assert_se((dbus_source = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(source->index))));
1185
1186     object_path = pa_dbusiface_device_get_path(dbus_source);
1187
1188     pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1189 }
1190
1191 static void handle_get_sample_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1192     pa_dbusiface_core *c = userdata;
1193     char *sample_name;
1194     pa_scache_entry *sample;
1195     pa_dbusiface_sample *dbus_sample;
1196     const char *object_path;
1197
1198     pa_assert(conn);
1199     pa_assert(msg);
1200     pa_assert(c);
1201
1202     pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &sample_name, DBUS_TYPE_INVALID));
1203
1204     if (!(sample = pa_namereg_get(c->core, sample_name, PA_NAMEREG_SAMPLE))) {
1205         pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such sample.");
1206         return;
1207     }
1208
1209     pa_assert_se((dbus_sample = pa_hashmap_get(c->samples, PA_UINT32_TO_PTR(sample->index))));
1210
1211     object_path = pa_dbusiface_sample_get_path(dbus_sample);
1212
1213     pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1214 }
1215
1216 static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1217     pa_dbusiface_core *c = userdata;
1218     DBusMessageIter msg_iter;
1219     DBusMessageIter array_iter;
1220     const char *name;
1221     dbus_uint32_t sample_format;
1222     dbus_uint32_t sample_rate;
1223     const dbus_uint32_t *channels;
1224     int n_channels;
1225     const dbus_uint32_t *default_volume;
1226     int n_volume_entries;
1227     pa_proplist *property_list;
1228     const uint8_t *data;
1229     int data_length;
1230     int i;
1231     pa_sample_spec ss;
1232     pa_channel_map map;
1233     pa_memchunk chunk;
1234     uint32_t idx;
1235     pa_dbusiface_sample *dbus_sample = NULL;
1236     pa_scache_entry *sample = NULL;
1237     const char *object_path;
1238
1239     pa_assert(conn);
1240     pa_assert(msg);
1241     pa_assert(c);
1242
1243     chunk.memblock = NULL;
1244
1245     pa_assert_se(dbus_message_iter_init(msg, &msg_iter));
1246     dbus_message_iter_get_basic(&msg_iter, &name);
1247
1248     pa_assert_se(dbus_message_iter_next(&msg_iter));
1249     dbus_message_iter_get_basic(&msg_iter, &sample_format);
1250
1251     pa_assert_se(dbus_message_iter_next(&msg_iter));
1252     dbus_message_iter_get_basic(&msg_iter, &sample_rate);
1253
1254     pa_assert_se(dbus_message_iter_next(&msg_iter));
1255     dbus_message_iter_recurse(&msg_iter, &array_iter);
1256     dbus_message_iter_get_fixed_array(&array_iter, &channels, &n_channels);
1257
1258     pa_assert_se(dbus_message_iter_next(&msg_iter));
1259     dbus_message_iter_recurse(&msg_iter, &array_iter);
1260     dbus_message_iter_get_fixed_array(&array_iter, &default_volume, &n_volume_entries);
1261
1262     pa_assert_se(dbus_message_iter_next(&msg_iter));
1263     if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter)))
1264         return;
1265
1266     dbus_message_iter_recurse(&msg_iter, &array_iter);
1267     dbus_message_iter_get_fixed_array(&array_iter, &data, &data_length);
1268
1269     if (sample_format >= PA_SAMPLE_MAX) {
1270         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format.");
1271         goto finish;
1272     }
1273
1274     if (sample_rate <= 0 || sample_rate > PA_RATE_MAX) {
1275         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample rate.");
1276         goto finish;
1277     }
1278
1279     if (n_channels <= 0) {
1280         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty channel map.");
1281         goto finish;
1282     }
1283
1284     if (n_channels > (int) PA_CHANNELS_MAX) {
1285         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1286                            "Too many channels: %i. The maximum is %u.", n_channels, PA_CHANNELS_MAX);
1287         goto finish;
1288     }
1289
1290     for (i = 0; i < n_channels; ++i) {
1291         if (channels[i] >= PA_CHANNEL_POSITION_MAX) {
1292             pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid channel position.");
1293             goto finish;
1294         }
1295     }
1296
1297     if (n_volume_entries != 0 && n_volume_entries != n_channels) {
1298         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1299                            "The channels and default_volume arguments have different number of elements (%i and %i, resp).",
1300                            n_channels, n_volume_entries);
1301         goto finish;
1302     }
1303
1304     for (i = 0; i < n_volume_entries; ++i) {
1305         if (default_volume[i] > PA_VOLUME_MAX) {
1306             pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid volume: %u.", default_volume[i]);
1307             goto finish;
1308         }
1309     }
1310
1311     if (data_length == 0) {
1312         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty data.");
1313         goto finish;
1314     }
1315
1316     if (data_length > PA_SCACHE_ENTRY_SIZE_MAX) {
1317         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1318                            "Too big sample: %i bytes. The maximum sample length is %u bytes.",
1319                            data_length, PA_SCACHE_ENTRY_SIZE_MAX);
1320         goto finish;
1321     }
1322
1323     ss.format = sample_format;
1324     ss.rate = sample_rate;
1325     ss.channels = n_channels;
1326
1327     pa_assert(pa_sample_spec_valid(&ss));
1328
1329     if (!pa_frame_aligned(data_length, &ss)) {
1330         char buf[PA_SAMPLE_SPEC_SNPRINT_MAX];
1331         pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1332                            "The sample length (%i bytes) doesn't align with the sample format and channels (%s).",
1333                            data_length, pa_sample_spec_snprint(buf, sizeof(buf), &ss));
1334         goto finish;
1335     }
1336
1337     map.channels = n_channels;
1338     for (i = 0; i < n_channels; ++i)
1339         map.map[i] = channels[i];
1340
1341     chunk.memblock = pa_memblock_new(c->core->mempool, data_length);
1342     chunk.index = 0;
1343     chunk.length = data_length;
1344
1345     memcpy(pa_memblock_acquire(chunk.memblock), data, data_length);
1346     pa_memblock_release(chunk.memblock);
1347
1348     if (pa_scache_add_item(c->core, name, &ss, &map, &chunk, property_list, &idx) < 0) {
1349         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Adding the sample failed.");
1350         goto finish;
1351     }
1352
1353     sample = pa_idxset_get_by_index(c->core->scache, idx);
1354
1355     if (n_volume_entries > 0) {
1356         sample->volume.channels = n_channels;
1357         for (i = 0; i < n_volume_entries; ++i)
1358             sample->volume.values[i] = default_volume[i];
1359         sample->volume_is_set = TRUE;
1360     } else {
1361         sample->volume_is_set = FALSE;
1362     }
1363
1364     dbus_sample = pa_dbusiface_sample_new(c, sample);
1365     pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), dbus_sample);
1366
1367     object_path = pa_dbusiface_sample_get_path(dbus_sample);
1368
1369     pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1370
1371 finish:
1372     if (property_list)
1373         pa_proplist_free(property_list);
1374
1375     if (chunk.memblock)
1376         pa_memblock_unref(chunk.memblock);
1377 }
1378
1379 static pa_bool_t contains_space(const char *string) {
1380     const char *p;
1381
1382     pa_assert(string);
1383
1384     for (p = string; *p; ++p) {
1385         if (isspace(*p))
1386             return TRUE;
1387     }
1388
1389     return FALSE;
1390 }
1391
1392 static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1393     pa_dbusiface_core *c = userdata;
1394     DBusMessageIter msg_iter;
1395     DBusMessageIter dict_iter;
1396     DBusMessageIter dict_entry_iter;
1397     char *name = NULL;
1398     const char *key = NULL;
1399     const char *value = NULL;
1400     char *escaped_value = NULL;
1401     pa_strbuf *arg_buffer = NULL;
1402     char *arg_string = NULL;
1403     pa_module *module = NULL;
1404     pa_dbusiface_module *dbus_module = NULL;
1405     const char *object_path = NULL;
1406
1407     pa_assert(conn);
1408     pa_assert(msg);
1409     pa_assert(c);
1410
1411     if (c->core->disallow_module_loading) {
1412         pa_dbus_send_error(conn, msg, DBUS_ERROR_ACCESS_DENIED, "The server is configured to disallow module loading.");
1413         return;
1414     }
1415
1416     pa_assert_se(dbus_message_iter_init(msg, &msg_iter));
1417     dbus_message_iter_get_basic(&msg_iter, &name);
1418
1419     arg_buffer = pa_strbuf_new();
1420
1421     pa_assert_se(dbus_message_iter_next(&msg_iter));
1422     dbus_message_iter_recurse(&msg_iter, &dict_iter);
1423
1424     while (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_INVALID) {
1425         if (!pa_strbuf_isempty(arg_buffer))
1426             pa_strbuf_putc(arg_buffer, ' ');
1427
1428         dbus_message_iter_recurse(&dict_iter, &dict_entry_iter);
1429
1430         dbus_message_iter_get_basic(&dict_entry_iter, &key);
1431
1432         if (strlen(key) <= 0 || !pa_ascii_valid(key) || contains_space(key)) {
1433             pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid module argument name: %s", key);
1434             goto finish;
1435         }
1436
1437         pa_assert_se(dbus_message_iter_next(&dict_entry_iter));
1438         dbus_message_iter_get_basic(&dict_entry_iter, &value);
1439
1440         escaped_value = pa_escape(value, "\"");
1441         pa_strbuf_printf(arg_buffer, "%s=\"%s\"", key, escaped_value);
1442         pa_xfree(escaped_value);
1443
1444         dbus_message_iter_next(&dict_iter);
1445     }
1446
1447     arg_string = pa_strbuf_tostring(arg_buffer);
1448
1449     if (!(module = pa_module_load(c->core, name, arg_string))) {
1450         pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Failed to load module.");
1451         goto finish;
1452     }
1453
1454     dbus_module = pa_dbusiface_module_new(module);
1455     pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(module->index), dbus_module);
1456
1457     object_path = pa_dbusiface_module_get_path(dbus_module);
1458
1459     pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1460
1461 finish:
1462     if (arg_buffer)
1463         pa_strbuf_free(arg_buffer);
1464
1465     pa_xfree(arg_string);
1466 }
1467
1468 static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1469     pa_dbusiface_core *c = userdata;
1470
1471     pa_assert(conn);
1472     pa_assert(msg);
1473     pa_assert(c);
1474
1475     if (c->core->disallow_exit) {
1476         pa_dbus_send_error(conn, msg, DBUS_ERROR_ACCESS_DENIED, "The server is configured to disallow exiting.");
1477         return;
1478     }
1479
1480     pa_dbus_send_empty_reply(conn, msg);
1481
1482     pa_core_exit(c->core, FALSE, 0);
1483 }
1484
1485 static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1486     pa_dbusiface_core *c = userdata;
1487     const char *signal;
1488     char **objects = NULL;
1489     int n_objects;
1490
1491     pa_assert(conn);
1492     pa_assert(msg);
1493     pa_assert(c);
1494
1495     pa_assert_se(dbus_message_get_args(msg, NULL,
1496                                        DBUS_TYPE_STRING, &signal,
1497                                        DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objects, &n_objects,
1498                                        DBUS_TYPE_INVALID));
1499
1500     pa_dbus_protocol_add_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL, objects, n_objects);
1501
1502     pa_dbus_send_empty_reply(conn, msg);
1503
1504     dbus_free_string_array(objects);
1505 }
1506
1507 static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1508     pa_dbusiface_core *c = userdata;
1509     const char *signal;
1510
1511     pa_assert(conn);
1512     pa_assert(msg);
1513     pa_assert(c);
1514
1515     pa_assert_se(dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &signal, DBUS_TYPE_INVALID));
1516
1517     pa_dbus_protocol_remove_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL);
1518
1519     pa_dbus_send_empty_reply(conn, msg);
1520 }
1521
1522 static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
1523     pa_dbusiface_core *c = userdata;
1524     pa_dbusiface_card *card_iface = NULL;
1525     pa_dbusiface_device *device_iface = NULL;
1526     pa_dbusiface_stream *stream_iface = NULL;
1527     pa_dbusiface_sample *sample_iface = NULL;
1528     pa_dbusiface_module *module_iface = NULL;
1529     pa_dbusiface_client *client_iface = NULL;
1530     DBusMessage *signal = NULL;
1531     const char *object_path = NULL;
1532     pa_sink *new_fallback_sink = NULL;
1533     pa_source *new_fallback_source = NULL;
1534
1535     pa_assert(c);
1536
1537     switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
1538         case PA_SUBSCRIPTION_EVENT_SERVER:
1539             new_fallback_sink = pa_namereg_get_default_sink(core);
1540             new_fallback_source = pa_namereg_get_default_source(core);
1541
1542             if (c->fallback_sink != new_fallback_sink) {
1543                 if (c->fallback_sink)
1544                     pa_sink_unref(c->fallback_sink);
1545                 c->fallback_sink = new_fallback_sink ? pa_sink_ref(new_fallback_sink) : NULL;
1546
1547                 if (new_fallback_sink
1548                     && (device_iface = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(new_fallback_sink->index)))) {
1549                     object_path = pa_dbusiface_device_get_path(device_iface);
1550
1551                     pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1552                                                                    PA_DBUS_CORE_INTERFACE,
1553                                                                    signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
1554                     pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1555                     pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1556                     dbus_message_unref(signal);
1557                     signal = NULL;
1558                 }
1559             }
1560
1561             if (c->fallback_source != new_fallback_source) {
1562                 if (c->fallback_source)
1563                     pa_source_unref(c->fallback_source);
1564                 c->fallback_source = new_fallback_source ? pa_source_ref(new_fallback_source) : NULL;
1565
1566                 if (new_fallback_source
1567                     && (device_iface = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(new_fallback_source->index)))) {
1568                     object_path = pa_dbusiface_device_get_path(device_iface);
1569
1570                     pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1571                                                                    PA_DBUS_CORE_INTERFACE,
1572                                                                    signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
1573                     pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1574                     pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1575                     dbus_message_unref(signal);
1576                     signal = NULL;
1577                 }
1578             }
1579             break;
1580
1581         case PA_SUBSCRIPTION_EVENT_CARD:
1582             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1583                 if (!(card_iface = pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(idx)))) {
1584                     pa_card *card = NULL;
1585
1586                     if (!(card = pa_idxset_get_by_index(core->cards, idx)))
1587                         return; /* The card was removed immediately after creation. */
1588
1589                     card_iface = pa_dbusiface_card_new(c, card);
1590                     pa_hashmap_put(c->cards, PA_UINT32_TO_PTR(idx), card_iface);
1591                 }
1592
1593                 object_path = pa_dbusiface_card_get_path(card_iface);
1594
1595                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1596                                                                PA_DBUS_CORE_INTERFACE,
1597                                                                signals[SIGNAL_NEW_CARD].name)));
1598                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1599
1600             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1601                 if (!(card_iface = pa_hashmap_remove(c->cards, PA_UINT32_TO_PTR(idx))))
1602                     return;
1603
1604                 object_path = pa_dbusiface_card_get_path(card_iface);
1605
1606                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1607                                                                PA_DBUS_CORE_INTERFACE,
1608                                                                signals[SIGNAL_CARD_REMOVED].name)));
1609                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1610
1611                 pa_dbusiface_card_free(card_iface);
1612             }
1613             break;
1614
1615         case PA_SUBSCRIPTION_EVENT_SINK:
1616             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1617                 pa_sink *sink = NULL;
1618
1619                 if (!(sink = pa_idxset_get_by_index(core->sinks, idx)))
1620                     return; /* The sink was removed immediately after creation. */
1621
1622                 if (!(device_iface = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(idx)))) {
1623                     device_iface = pa_dbusiface_device_new_sink(c, sink);
1624                     pa_hashmap_put(c->sinks_by_index, PA_UINT32_TO_PTR(idx), device_iface);
1625                     pa_hashmap_put(c->sinks_by_path, pa_dbusiface_device_get_path(device_iface), device_iface);
1626                 }
1627
1628                 object_path = pa_dbusiface_device_get_path(device_iface);
1629
1630                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1631                                                                PA_DBUS_CORE_INTERFACE,
1632                                                                signals[SIGNAL_NEW_SINK].name)));
1633                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1634
1635                 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1636                 dbus_message_unref(signal);
1637                 signal = NULL;
1638
1639                 if (c->fallback_sink && pa_streq(c->fallback_sink->name, sink->name)) {
1640                     /* We have got default sink change event, but at that point
1641                      * the D-Bus sink object wasn't created yet. Now that the
1642                      * object is created, let's send the fallback sink change
1643                      * signal. */
1644                     pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1645                                                                    PA_DBUS_CORE_INTERFACE,
1646                                                                    signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
1647                     pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1648
1649                     pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1650                     dbus_message_unref(signal);
1651                     signal = NULL;
1652                 }
1653
1654             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1655                 if (!(device_iface = pa_hashmap_remove(c->sinks_by_index, PA_UINT32_TO_PTR(idx))))
1656                     return;
1657
1658                 object_path = pa_dbusiface_device_get_path(device_iface);
1659                 pa_assert_se(pa_hashmap_remove(c->sinks_by_path, object_path));
1660
1661                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1662                                                                PA_DBUS_CORE_INTERFACE,
1663                                                                signals[SIGNAL_SINK_REMOVED].name)));
1664                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1665
1666                 pa_dbusiface_device_free(device_iface);
1667             }
1668             break;
1669
1670         case PA_SUBSCRIPTION_EVENT_SOURCE:
1671             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1672                 pa_source *source = pa_idxset_get_by_index(core->sources, idx);
1673
1674                 if (!(source = pa_idxset_get_by_index(core->sources, idx)))
1675                     return; /* The source was removed immediately after creation. */
1676
1677                 if (!(device_iface = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(idx)))) {
1678                     device_iface = pa_dbusiface_device_new_source(c, source);
1679                     pa_hashmap_put(c->sources_by_index, PA_UINT32_TO_PTR(idx), device_iface);
1680                     pa_hashmap_put(c->sources_by_path, pa_dbusiface_device_get_path(device_iface), device_iface);
1681                 }
1682
1683                 object_path = pa_dbusiface_device_get_path(device_iface);
1684
1685                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1686                                                                PA_DBUS_CORE_INTERFACE,
1687                                                                signals[SIGNAL_NEW_SOURCE].name)));
1688                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1689
1690                 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1691                 dbus_message_unref(signal);
1692                 signal = NULL;
1693
1694                 if (c->fallback_source && pa_streq(c->fallback_source->name, source->name)) {
1695                     /* We have got default source change event, but at that
1696                      * point the D-Bus source object wasn't created yet. Now
1697                      * that the object is created, let's send the fallback
1698                      * source change signal. */
1699                     pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1700                                                                    PA_DBUS_CORE_INTERFACE,
1701                                                                    signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
1702                     pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1703
1704                     pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1705                     dbus_message_unref(signal);
1706                     signal = NULL;
1707                 }
1708
1709             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1710                 if (!(device_iface = pa_hashmap_remove(c->sources_by_index, PA_UINT32_TO_PTR(idx))))
1711                     return;
1712
1713                 object_path = pa_dbusiface_device_get_path(device_iface);
1714                 pa_assert_se(pa_hashmap_remove(c->sources_by_path, object_path));
1715
1716                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1717                                                                PA_DBUS_CORE_INTERFACE,
1718                                                                signals[SIGNAL_SOURCE_REMOVED].name)));
1719                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1720
1721                 pa_dbusiface_device_free(device_iface);
1722             }
1723             break;
1724
1725         case PA_SUBSCRIPTION_EVENT_SINK_INPUT:
1726             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1727                 pa_sink_input *sink_input = NULL;
1728
1729                 if (!(sink_input = pa_idxset_get_by_index(core->sink_inputs, idx)))
1730                     return; /* The sink input was removed immediately after creation. */
1731
1732                 if (!(stream_iface = pa_hashmap_get(c->playback_streams, PA_UINT32_TO_PTR(idx)))) {
1733                     stream_iface = pa_dbusiface_stream_new_playback(c, sink_input);
1734                     pa_hashmap_put(c->playback_streams, PA_UINT32_TO_PTR(idx), stream_iface);
1735                 }
1736
1737                 object_path = pa_dbusiface_stream_get_path(stream_iface);
1738
1739                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1740                                                                PA_DBUS_CORE_INTERFACE,
1741                                                                signals[SIGNAL_NEW_PLAYBACK_STREAM].name)));
1742                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1743
1744             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1745                 if (!(stream_iface = pa_hashmap_remove(c->playback_streams, PA_UINT32_TO_PTR(idx))))
1746                     return;
1747
1748                 object_path = pa_dbusiface_stream_get_path(stream_iface);
1749
1750                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1751                                                                PA_DBUS_CORE_INTERFACE,
1752                                                                signals[SIGNAL_PLAYBACK_STREAM_REMOVED].name)));
1753                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1754
1755                 pa_dbusiface_stream_free(stream_iface);
1756             }
1757             break;
1758
1759         case PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT:
1760             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1761                 pa_source_output *source_output = NULL;
1762
1763                 if (!(source_output = pa_idxset_get_by_index(core->source_outputs, idx)))
1764                     return; /* The source output was removed immediately after creation. */
1765
1766                 if (!(stream_iface = pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(idx)))) {
1767                     stream_iface = pa_dbusiface_stream_new_record(c, source_output);
1768                     pa_hashmap_put(c->record_streams, PA_UINT32_TO_PTR(idx), stream_iface);
1769                 }
1770
1771                 object_path = pa_dbusiface_stream_get_path(stream_iface);
1772
1773                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1774                                                                PA_DBUS_CORE_INTERFACE,
1775                                                                signals[SIGNAL_NEW_RECORD_STREAM].name)));
1776                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1777
1778             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1779                 if (!(stream_iface = pa_hashmap_remove(c->record_streams, PA_UINT32_TO_PTR(idx))))
1780                     return;
1781
1782                 object_path = pa_dbusiface_stream_get_path(stream_iface);
1783
1784                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1785                                                                PA_DBUS_CORE_INTERFACE,
1786                                                                signals[SIGNAL_RECORD_STREAM_REMOVED].name)));
1787                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1788
1789                 pa_dbusiface_stream_free(stream_iface);
1790             }
1791             break;
1792
1793         case PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE:
1794             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1795                 pa_scache_entry *sample = NULL;
1796
1797                 if (!(sample = pa_idxset_get_by_index(core->scache, idx)))
1798                     return; /* The sample was removed immediately after creation. */
1799
1800                 if (!(sample_iface = pa_hashmap_get(c->samples, PA_UINT32_TO_PTR(idx)))) {
1801                     sample_iface = pa_dbusiface_sample_new(c, sample);
1802                     pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), sample_iface);
1803                 }
1804
1805                 object_path = pa_dbusiface_sample_get_path(sample_iface);
1806
1807                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1808                                                                PA_DBUS_CORE_INTERFACE,
1809                                                                signals[SIGNAL_NEW_SAMPLE].name)));
1810                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1811
1812             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1813                 if (!(sample_iface = pa_hashmap_remove(c->samples, PA_UINT32_TO_PTR(idx))))
1814                     return;
1815
1816                 object_path = pa_dbusiface_sample_get_path(sample_iface);
1817
1818                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1819                                                                PA_DBUS_CORE_INTERFACE,
1820                                                                signals[SIGNAL_SAMPLE_REMOVED].name)));
1821                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1822
1823                 pa_dbusiface_sample_free(sample_iface);
1824             }
1825             break;
1826
1827         case PA_SUBSCRIPTION_EVENT_MODULE:
1828             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1829                 pa_module *module = NULL;
1830
1831                 if (!(module = pa_idxset_get_by_index(core->modules, idx)))
1832                     return; /* The module was removed immediately after creation. */
1833
1834                 if (!(module_iface = pa_hashmap_get(c->modules, PA_UINT32_TO_PTR(idx)))) {
1835                     module_iface = pa_dbusiface_module_new(module);
1836                     pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(idx), module_iface);
1837                 }
1838
1839                 object_path = pa_dbusiface_module_get_path(module_iface);
1840
1841                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1842                                                                PA_DBUS_CORE_INTERFACE,
1843                                                                signals[SIGNAL_NEW_MODULE].name)));
1844                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1845
1846             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1847                 if (!(module_iface = pa_hashmap_remove(c->modules, PA_UINT32_TO_PTR(idx))))
1848                     return;
1849
1850                 object_path = pa_dbusiface_module_get_path(module_iface);
1851
1852                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1853                                                                PA_DBUS_CORE_INTERFACE,
1854                                                                signals[SIGNAL_MODULE_REMOVED].name)));
1855                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1856
1857                 pa_dbusiface_module_free(module_iface);
1858             }
1859             break;
1860
1861         case PA_SUBSCRIPTION_EVENT_CLIENT:
1862             if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1863                 pa_client *client = NULL;
1864
1865                 if (!(client = pa_idxset_get_by_index(core->clients, idx)))
1866                     return; /* The client was removed immediately after creation. */
1867
1868                 if (!(client_iface = pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(idx)))) {
1869                     client_iface = pa_dbusiface_client_new(c, client);
1870                     pa_hashmap_put(c->clients, PA_UINT32_TO_PTR(idx), client_iface);
1871                 }
1872
1873                 object_path = pa_dbusiface_client_get_path(client_iface);
1874
1875                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1876                                                                PA_DBUS_CORE_INTERFACE,
1877                                                                signals[SIGNAL_NEW_CLIENT].name)));
1878                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1879
1880             } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1881                 if (!(client_iface = pa_hashmap_remove(c->clients, PA_UINT32_TO_PTR(idx))))
1882                     return;
1883
1884                 object_path = pa_dbusiface_client_get_path(client_iface);
1885
1886                 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1887                                                                PA_DBUS_CORE_INTERFACE,
1888                                                                signals[SIGNAL_CLIENT_REMOVED].name)));
1889                 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1890
1891                 pa_dbusiface_client_free(client_iface);
1892             }
1893             break;
1894     }
1895
1896     if (signal) {
1897         pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1898         dbus_message_unref(signal);
1899     }
1900 }
1901
1902 static pa_hook_result_t extension_registered_cb(void *hook_data, void *call_data, void *slot_data) {
1903     pa_dbusiface_core *c = slot_data;
1904     const char *ext_name = call_data;
1905     DBusMessage *signal = NULL;
1906
1907     pa_assert(c);
1908     pa_assert(ext_name);
1909
1910     pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1911                                                    PA_DBUS_CORE_INTERFACE,
1912                                                    signals[SIGNAL_NEW_EXTENSION].name)));
1913     pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
1914
1915     pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1916     dbus_message_unref(signal);
1917
1918     return PA_HOOK_OK;
1919 }
1920
1921 static pa_hook_result_t extension_unregistered_cb(void *hook_data, void *call_data, void *slot_data) {
1922     pa_dbusiface_core *c = slot_data;
1923     const char *ext_name = call_data;
1924     DBusMessage *signal = NULL;
1925
1926     pa_assert(c);
1927     pa_assert(ext_name);
1928
1929     pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1930                                                    PA_DBUS_CORE_INTERFACE,
1931                                                    signals[SIGNAL_EXTENSION_REMOVED].name)));
1932     pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
1933
1934     pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1935     dbus_message_unref(signal);
1936
1937     return PA_HOOK_OK;
1938 }
1939
1940 pa_dbusiface_core *pa_dbusiface_core_new(pa_core *core) {
1941     pa_dbusiface_core *c;
1942     pa_card *card;
1943     pa_sink *sink;
1944     pa_source *source;
1945     pa_dbusiface_device *device;
1946     pa_sink_input *sink_input;
1947     pa_source_output *source_output;
1948     pa_scache_entry *sample;
1949     pa_module *module;
1950     pa_client *client;
1951     uint32_t idx;
1952
1953     pa_assert(core);
1954
1955     c = pa_xnew(pa_dbusiface_core, 1);
1956     c->core = pa_core_ref(core);
1957     c->subscription = pa_subscription_new(core, PA_SUBSCRIPTION_MASK_ALL, subscription_cb, c);
1958     c->dbus_protocol = pa_dbus_protocol_get(core);
1959     c->cards = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1960     c->sinks_by_index = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1961     c->sinks_by_path = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1962     c->sources_by_index = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1963     c->sources_by_path = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1964     c->playback_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1965     c->record_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1966     c->samples = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1967     c->modules = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1968     c->clients = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1969     c->fallback_sink = pa_namereg_get_default_sink(core);
1970     c->fallback_source = pa_namereg_get_default_source(core);
1971     c->extension_registered_slot = pa_dbus_protocol_hook_connect(c->dbus_protocol,
1972                                                                  PA_DBUS_PROTOCOL_HOOK_EXTENSION_REGISTERED,
1973                                                                  PA_HOOK_NORMAL,
1974                                                                  extension_registered_cb,
1975                                                                  c);
1976     c->extension_unregistered_slot = pa_dbus_protocol_hook_connect(c->dbus_protocol,
1977                                                                    PA_DBUS_PROTOCOL_HOOK_EXTENSION_UNREGISTERED,
1978                                                                    PA_HOOK_NORMAL,
1979                                                                    extension_unregistered_cb,
1980                                                                    c);
1981     c->memstats = pa_dbusiface_memstats_new(c, core);
1982
1983     if (c->fallback_sink)
1984         pa_sink_ref(c->fallback_sink);
1985     if (c->fallback_source)
1986         pa_source_ref(c->fallback_source);
1987
1988     PA_IDXSET_FOREACH(card, core->cards, idx)
1989         pa_hashmap_put(c->cards, PA_UINT32_TO_PTR(idx), pa_dbusiface_card_new(c, card));
1990
1991     PA_IDXSET_FOREACH(sink, core->sinks, idx) {
1992         device = pa_dbusiface_device_new_sink(c, sink);
1993         pa_hashmap_put(c->sinks_by_index, PA_UINT32_TO_PTR(idx), device);
1994         pa_hashmap_put(c->sinks_by_path, pa_dbusiface_device_get_path(device), device);
1995     }
1996
1997     PA_IDXSET_FOREACH(source, core->sources, idx) {
1998         device = pa_dbusiface_device_new_source(c, source);
1999         pa_hashmap_put(c->sources_by_index, PA_UINT32_TO_PTR(idx), device);
2000         pa_hashmap_put(c->sources_by_path, pa_dbusiface_device_get_path(device), device);
2001     }
2002
2003     PA_IDXSET_FOREACH(sink_input, core->sink_inputs, idx)
2004         pa_hashmap_put(c->playback_streams, PA_UINT32_TO_PTR(idx), pa_dbusiface_stream_new_playback(c, sink_input));
2005
2006     PA_IDXSET_FOREACH(source_output, core->source_outputs, idx)
2007         pa_hashmap_put(c->record_streams, PA_UINT32_TO_PTR(idx), pa_dbusiface_stream_new_record(c, source_output));
2008
2009     PA_IDXSET_FOREACH(sample, core->scache, idx)
2010         pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), pa_dbusiface_sample_new(c, sample));
2011
2012     PA_IDXSET_FOREACH(module, core->modules, idx)
2013         pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(idx), pa_dbusiface_module_new(module));
2014
2015     PA_IDXSET_FOREACH(client, core->clients, idx)
2016         pa_hashmap_put(c->clients, PA_UINT32_TO_PTR(idx), pa_dbusiface_client_new(c, client));
2017
2018     pa_assert_se(pa_dbus_protocol_add_interface(c->dbus_protocol, PA_DBUS_CORE_OBJECT_PATH, &core_interface_info, c) >= 0);
2019
2020     return c;
2021 }
2022
2023 static void free_card_cb(void *p, void *userdata) {
2024     pa_dbusiface_card *c = p;
2025
2026     pa_assert(c);
2027
2028     pa_dbusiface_card_free(c);
2029 }
2030
2031 static void free_device_cb(void *p, void *userdata) {
2032     pa_dbusiface_device *d = p;
2033
2034     pa_assert(d);
2035
2036     pa_dbusiface_device_free(d);
2037 }
2038
2039 static void free_stream_cb(void *p, void *userdata) {
2040     pa_dbusiface_stream *s = p;
2041
2042     pa_assert(s);
2043
2044     pa_dbusiface_stream_free(s);
2045 }
2046
2047 static void free_sample_cb(void *p, void *userdata) {
2048     pa_dbusiface_sample *s = p;
2049
2050     pa_assert(s);
2051
2052     pa_dbusiface_sample_free(s);
2053 }
2054
2055 static void free_module_cb(void *p, void *userdata) {
2056     pa_dbusiface_module *m = p;
2057
2058     pa_assert(m);
2059
2060     pa_dbusiface_module_free(m);
2061 }
2062
2063 static void free_client_cb(void *p, void *userdata) {
2064     pa_dbusiface_client *c = p;
2065
2066     pa_assert(c);
2067
2068     pa_dbusiface_client_free(c);
2069 }
2070
2071 void pa_dbusiface_core_free(pa_dbusiface_core *c) {
2072     pa_assert(c);
2073
2074     pa_assert_se(pa_dbus_protocol_remove_interface(c->dbus_protocol, PA_DBUS_CORE_OBJECT_PATH, core_interface_info.name) >= 0);
2075
2076     pa_subscription_free(c->subscription);
2077     pa_hashmap_free(c->cards, free_card_cb, NULL);
2078     pa_hashmap_free(c->sinks_by_index, free_device_cb, NULL);
2079     pa_hashmap_free(c->sinks_by_path, NULL, NULL);
2080     pa_hashmap_free(c->sources_by_index, free_device_cb, NULL);
2081     pa_hashmap_free(c->sources_by_path, NULL, NULL);
2082     pa_hashmap_free(c->playback_streams, free_stream_cb, NULL);
2083     pa_hashmap_free(c->record_streams, free_stream_cb, NULL);
2084     pa_hashmap_free(c->samples, free_sample_cb, NULL);
2085     pa_hashmap_free(c->modules, free_module_cb, NULL);
2086     pa_hashmap_free(c->clients, free_client_cb, NULL);
2087     pa_hook_slot_free(c->extension_registered_slot);
2088     pa_hook_slot_free(c->extension_unregistered_slot);
2089     pa_dbusiface_memstats_free(c->memstats);
2090
2091     if (c->fallback_sink)
2092         pa_sink_unref(c->fallback_sink);
2093     if (c->fallback_source)
2094         pa_source_unref(c->fallback_source);
2095
2096     pa_dbus_protocol_unref(c->dbus_protocol);
2097     pa_core_unref(c->core);
2098
2099     pa_xfree(c);
2100 }
2101
2102 const char *pa_dbusiface_core_get_card_path(pa_dbusiface_core *c, const pa_card *card) {
2103     pa_assert(c);
2104     pa_assert(card);
2105
2106     return pa_dbusiface_card_get_path(pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(card->index)));
2107 }
2108
2109 const char *pa_dbusiface_core_get_sink_path(pa_dbusiface_core *c, const pa_sink *sink) {
2110     pa_assert(c);
2111     pa_assert(sink);
2112
2113     return pa_dbusiface_device_get_path(pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(sink->index)));
2114 }
2115
2116 const char *pa_dbusiface_core_get_source_path(pa_dbusiface_core *c, const pa_source *source) {
2117     pa_assert(c);
2118     pa_assert(source);
2119
2120     return pa_dbusiface_device_get_path(pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(source->index)));
2121 }
2122
2123 const char *pa_dbusiface_core_get_playback_stream_path(pa_dbusiface_core *c, const pa_sink_input *sink_input) {
2124     pa_assert(c);
2125     pa_assert(sink_input);
2126
2127     return pa_dbusiface_stream_get_path(pa_hashmap_get(c->playback_streams, PA_UINT32_TO_PTR(sink_input->index)));
2128 }
2129
2130 const char *pa_dbusiface_core_get_record_stream_path(pa_dbusiface_core *c, const pa_source_output *source_output) {
2131     pa_assert(c);
2132     pa_assert(source_output);
2133
2134     return pa_dbusiface_stream_get_path(pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(source_output->index)));
2135 }
2136
2137 const char *pa_dbusiface_core_get_module_path(pa_dbusiface_core *c, const pa_module *module) {
2138     pa_assert(c);
2139     pa_assert(module);
2140
2141     return pa_dbusiface_module_get_path(pa_hashmap_get(c->modules, PA_UINT32_TO_PTR(module->index)));
2142 }
2143
2144 const char *pa_dbusiface_core_get_client_path(pa_dbusiface_core *c, const pa_client *client) {
2145     pa_assert(c);
2146     pa_assert(client);
2147
2148     return pa_dbusiface_client_get_path(pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(client->index)));
2149 }
2150
2151 pa_sink *pa_dbusiface_core_get_sink(pa_dbusiface_core *c, const char *object_path) {
2152     pa_dbusiface_device *device = NULL;
2153
2154     pa_assert(c);
2155     pa_assert(object_path);
2156
2157     device = pa_hashmap_get(c->sinks_by_path, object_path);
2158
2159     if (device)
2160         return pa_dbusiface_device_get_sink(device);
2161     else
2162         return NULL;
2163 }
2164
2165 pa_source *pa_dbusiface_core_get_source(pa_dbusiface_core *c, const char *object_path) {
2166     pa_dbusiface_device *device = NULL;
2167
2168     pa_assert(c);
2169     pa_assert(object_path);
2170
2171     device = pa_hashmap_get(c->sources_by_path, object_path);
2172
2173     if (device)
2174         return pa_dbusiface_device_get_source(device);
2175     else
2176         return NULL;
2177 }