code.delx.au - pulseaudio/blob - src/modules/dbus/iface-core.c

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