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