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