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