2 This file is part of PulseAudio.
4 Copyright 2009 Tanu Kaskinen
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.
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.
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
28 #include <dbus/dbus.h>
30 #include <pulse/utf8.h>
31 #include <pulse/xmalloc.h>
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>
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"
48 #include "iface-core.h"
50 #define OBJECT_PATH "/org/pulseaudio/core1"
52 #define INTERFACE_REVISION 0
56 static void handle_get_interface_revision(DBusConnection *conn, DBusMessage *msg, void *userdata);
57 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
58 static void handle_get_version(DBusConnection *conn, DBusMessage *msg, void *userdata);
59 static void handle_get_is_local(DBusConnection *conn, DBusMessage *msg, void *userdata);
60 static void handle_get_username(DBusConnection *conn, DBusMessage *msg, void *userdata);
61 static void handle_get_hostname(DBusConnection *conn, DBusMessage *msg, void *userdata);
62 static void handle_get_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata);
63 static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata);
64 static void handle_get_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata);
65 static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata);
66 static void handle_get_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata);
67 static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata);
68 static void handle_get_cards(DBusConnection *conn, DBusMessage *msg, void *userdata);
69 static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata);
70 static void handle_get_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata);
71 static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata);
72 static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata);
73 static void handle_get_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata);
74 static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata);
75 static void handle_get_playback_streams(DBusConnection *conn, DBusMessage *msg, void *userdata);
76 static void handle_get_record_streams(DBusConnection *conn, DBusMessage *msg, void *userdata);
77 static void handle_get_samples(DBusConnection *conn, DBusMessage *msg, void *userdata);
78 static void handle_get_modules(DBusConnection *conn, DBusMessage *msg, void *userdata);
79 static void handle_get_clients(DBusConnection *conn, DBusMessage *msg, void *userdata);
80 static void handle_get_my_client(DBusConnection *conn, DBusMessage *msg, void *userdata);
81 static void handle_get_extensions(DBusConnection *conn, DBusMessage *msg, void *userdata);
83 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata);
85 static void handle_get_card_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
86 static void handle_get_sink_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
87 static void handle_get_source_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
88 static void handle_get_sample_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata);
89 static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *userdata);
90 static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *userdata);
91 static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata);
92 static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata);
93 static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata);
95 struct pa_dbusiface_core {
97 pa_subscription *subscription;
99 pa_dbus_protocol *dbus_protocol;
102 pa_hashmap *sinks_by_index;
103 pa_hashmap *sinks_by_path;
104 pa_hashmap *sources_by_index;
105 pa_hashmap *sources_by_path;
106 pa_hashmap *playback_streams;
107 pa_hashmap *record_streams;
112 pa_sink *fallback_sink;
113 pa_source *fallback_source;
115 pa_hook_slot *extension_registered_slot;
116 pa_hook_slot *extension_unregistered_slot;
119 enum property_handler_index {
120 PROPERTY_HANDLER_INTERFACE_REVISION,
121 PROPERTY_HANDLER_NAME,
122 PROPERTY_HANDLER_VERSION,
123 PROPERTY_HANDLER_IS_LOCAL,
124 PROPERTY_HANDLER_USERNAME,
125 PROPERTY_HANDLER_HOSTNAME,
126 PROPERTY_HANDLER_DEFAULT_CHANNELS,
127 PROPERTY_HANDLER_DEFAULT_SAMPLE_FORMAT,
128 PROPERTY_HANDLER_DEFAULT_SAMPLE_RATE,
129 PROPERTY_HANDLER_CARDS,
130 PROPERTY_HANDLER_SINKS,
131 PROPERTY_HANDLER_FALLBACK_SINK,
132 PROPERTY_HANDLER_SOURCES,
133 PROPERTY_HANDLER_FALLBACK_SOURCE,
134 PROPERTY_HANDLER_PLAYBACK_STREAMS,
135 PROPERTY_HANDLER_RECORD_STREAMS,
136 PROPERTY_HANDLER_SAMPLES,
137 PROPERTY_HANDLER_MODULES,
138 PROPERTY_HANDLER_CLIENTS,
139 PROPERTY_HANDLER_MY_CLIENT,
140 PROPERTY_HANDLER_EXTENSIONS,
144 static pa_dbus_property_handler property_handlers[PROPERTY_HANDLER_MAX] = {
145 [PROPERTY_HANDLER_INTERFACE_REVISION] = { .property_name = "InterfaceRevision", .type = "u", .get_cb = handle_get_interface_revision, .set_cb = NULL },
146 [PROPERTY_HANDLER_NAME] = { .property_name = "Name", .type = "s", .get_cb = handle_get_name, .set_cb = NULL },
147 [PROPERTY_HANDLER_VERSION] = { .property_name = "Version", .type = "s", .get_cb = handle_get_version, .set_cb = NULL },
148 [PROPERTY_HANDLER_IS_LOCAL] = { .property_name = "IsLocal", .type = "b", .get_cb = handle_get_is_local, .set_cb = NULL },
149 [PROPERTY_HANDLER_USERNAME] = { .property_name = "Username", .type = "s", .get_cb = handle_get_username, .set_cb = NULL },
150 [PROPERTY_HANDLER_HOSTNAME] = { .property_name = "Hostname", .type = "s", .get_cb = handle_get_hostname, .set_cb = NULL },
151 [PROPERTY_HANDLER_DEFAULT_CHANNELS] = { .property_name = "DefaultChannels", .type = "au", .get_cb = handle_get_default_channels, .set_cb = handle_set_default_channels },
152 [PROPERTY_HANDLER_DEFAULT_SAMPLE_FORMAT] = { .property_name = "DefaultSampleFormat", .type = "u", .get_cb = handle_get_default_sample_format, .set_cb = handle_set_default_sample_format },
153 [PROPERTY_HANDLER_DEFAULT_SAMPLE_RATE] = { .property_name = "DefaultSampleRate", .type = "u", .get_cb = handle_get_default_sample_rate, .set_cb = handle_set_default_sample_rate },
154 [PROPERTY_HANDLER_CARDS] = { .property_name = "Cards", .type = "ao", .get_cb = handle_get_cards, .set_cb = NULL },
155 [PROPERTY_HANDLER_SINKS] = { .property_name = "Sinks", .type = "ao", .get_cb = handle_get_sinks, .set_cb = NULL },
156 [PROPERTY_HANDLER_FALLBACK_SINK] = { .property_name = "FallbackSink", .type = "o", .get_cb = handle_get_fallback_sink, .set_cb = handle_set_fallback_sink },
157 [PROPERTY_HANDLER_SOURCES] = { .property_name = "Sources", .type = "ao", .get_cb = handle_get_sources, .set_cb = NULL },
158 [PROPERTY_HANDLER_FALLBACK_SOURCE] = { .property_name = "FallbackSource", .type = "o", .get_cb = handle_get_fallback_source, .set_cb = handle_set_fallback_source },
159 [PROPERTY_HANDLER_PLAYBACK_STREAMS] = { .property_name = "PlaybackStreams", .type = "ao", .get_cb = handle_get_playback_streams, .set_cb = NULL },
160 [PROPERTY_HANDLER_RECORD_STREAMS] = { .property_name = "RecordStreams", .type = "ao", .get_cb = handle_get_record_streams, .set_cb = NULL },
161 [PROPERTY_HANDLER_SAMPLES] = { .property_name = "Samples", .type = "ao", .get_cb = handle_get_samples, .set_cb = NULL },
162 [PROPERTY_HANDLER_MODULES] = { .property_name = "Modules", .type = "ao", .get_cb = handle_get_modules, .set_cb = NULL },
163 [PROPERTY_HANDLER_CLIENTS] = { .property_name = "Clients", .type = "ao", .get_cb = handle_get_clients, .set_cb = NULL },
164 [PROPERTY_HANDLER_MY_CLIENT] = { .property_name = "MyClient", .type = "o", .get_cb = handle_get_my_client, .set_cb = NULL },
165 [PROPERTY_HANDLER_EXTENSIONS] = { .property_name = "Extensions", .type = "as", .get_cb = handle_get_extensions, .set_cb = NULL }
168 enum method_handler_index {
169 METHOD_HANDLER_GET_CARD_BY_NAME,
170 METHOD_HANDLER_GET_SINK_BY_NAME,
171 METHOD_HANDLER_GET_SOURCE_BY_NAME,
172 METHOD_HANDLER_GET_SAMPLE_BY_NAME,
173 METHOD_HANDLER_UPLOAD_SAMPLE,
174 METHOD_HANDLER_LOAD_MODULE,
176 METHOD_HANDLER_LISTEN_FOR_SIGNAL,
177 METHOD_HANDLER_STOP_LISTENING_FOR_SIGNAL,
181 static pa_dbus_arg_info get_card_by_name_args[] = { { "name", "s", "in" }, { "card", "o", "out" } };
182 static pa_dbus_arg_info get_sink_by_name_args[] = { { "name", "s", "in" }, { "sink", "o", "out" } };
183 static pa_dbus_arg_info get_source_by_name_args[] = { { "name", "s", "in" }, { "source", "o", "out" } };
184 static pa_dbus_arg_info get_sample_by_name_args[] = { { "name", "s", "in" }, { "sample", "o", "out" } };
185 static pa_dbus_arg_info upload_sample_args[] = { { "name", "s", "in" },
186 { "sample_format", "u", "in" },
187 { "sample_rate", "u", "in" },
188 { "channels", "au", "in" },
189 { "default_volume", "au", "in" },
190 { "property_list", "a{say}", "in" },
191 { "data", "ay", "in" },
192 { "sample", "o", "out" } };
193 static pa_dbus_arg_info load_module_args[] = { { "name", "s", "in" }, { "arguments", "a{ss}", "in" }, { "module", "o", "out" } };
194 static pa_dbus_arg_info listen_for_signal_args[] = { { "signal", "s", "in" }, { "objects", "ao", "in" } };
195 static pa_dbus_arg_info stop_listening_for_signal_args[] = { { "signal", "s", "in" } };
197 static pa_dbus_method_handler method_handlers[METHOD_HANDLER_MAX] = {
198 [METHOD_HANDLER_GET_CARD_BY_NAME] = {
199 .method_name = "GetCardByName",
200 .arguments = get_card_by_name_args,
201 .n_arguments = sizeof(get_card_by_name_args) / sizeof(pa_dbus_arg_info),
202 .receive_cb = handle_get_card_by_name },
203 [METHOD_HANDLER_GET_SINK_BY_NAME] = {
204 .method_name = "GetSinkByName",
205 .arguments = get_sink_by_name_args,
206 .n_arguments = sizeof(get_sink_by_name_args) / sizeof(pa_dbus_arg_info),
207 .receive_cb = handle_get_sink_by_name },
208 [METHOD_HANDLER_GET_SOURCE_BY_NAME] = {
209 .method_name = "GetSourceByName",
210 .arguments = get_source_by_name_args,
211 .n_arguments = sizeof(get_source_by_name_args) / sizeof(pa_dbus_arg_info),
212 .receive_cb = handle_get_source_by_name },
213 [METHOD_HANDLER_GET_SAMPLE_BY_NAME] = {
214 .method_name = "GetSampleByName",
215 .arguments = get_sample_by_name_args,
216 .n_arguments = sizeof(get_sample_by_name_args) / sizeof(pa_dbus_arg_info),
217 .receive_cb = handle_get_sample_by_name },
218 [METHOD_HANDLER_UPLOAD_SAMPLE] = {
219 .method_name = "UploadSample",
220 .arguments = upload_sample_args,
221 .n_arguments = sizeof(upload_sample_args) / sizeof(pa_dbus_arg_info),
222 .receive_cb = handle_upload_sample },
223 [METHOD_HANDLER_LOAD_MODULE] = {
224 .method_name = "LoadModule",
225 .arguments = load_module_args,
226 .n_arguments = sizeof(load_module_args) / sizeof(pa_dbus_arg_info),
227 .receive_cb = handle_load_module },
228 [METHOD_HANDLER_EXIT] = {
229 .method_name = "Exit",
232 .receive_cb = handle_exit },
233 [METHOD_HANDLER_LISTEN_FOR_SIGNAL] = {
234 .method_name = "ListenForSignal",
235 .arguments = listen_for_signal_args,
236 .n_arguments = sizeof(listen_for_signal_args) / sizeof(pa_dbus_arg_info),
237 .receive_cb = handle_listen_for_signal },
238 [METHOD_HANDLER_STOP_LISTENING_FOR_SIGNAL] = {
239 .method_name = "StopListeningForSignal",
240 .arguments = stop_listening_for_signal_args,
241 .n_arguments = sizeof(stop_listening_for_signal_args) / sizeof(pa_dbus_arg_info),
242 .receive_cb = handle_stop_listening_for_signal }
250 SIGNAL_FALLBACK_SINK_UPDATED,
252 SIGNAL_SOURCE_REMOVED,
253 SIGNAL_FALLBACK_SOURCE_UPDATED,
254 SIGNAL_NEW_PLAYBACK_STREAM,
255 SIGNAL_PLAYBACK_STREAM_REMOVED,
256 SIGNAL_NEW_RECORD_STREAM,
257 SIGNAL_RECORD_STREAM_REMOVED,
259 SIGNAL_SAMPLE_REMOVED,
261 SIGNAL_MODULE_REMOVED,
263 SIGNAL_CLIENT_REMOVED,
264 SIGNAL_NEW_EXTENSION,
265 SIGNAL_EXTENSION_REMOVED,
269 static pa_dbus_arg_info new_card_args[] = { { "card", "o", NULL } };
270 static pa_dbus_arg_info card_removed_args[] = { { "card", "o", NULL } };
271 static pa_dbus_arg_info new_sink_args[] = { { "sink", "o", NULL } };
272 static pa_dbus_arg_info sink_removed_args[] = { { "sink", "o", NULL } };
273 static pa_dbus_arg_info fallback_sink_updated_args[] = { { "sink", "o", NULL } };
274 static pa_dbus_arg_info new_source_args[] = { { "source", "o", NULL } };
275 static pa_dbus_arg_info source_removed_args[] = { { "source", "o", NULL } };
276 static pa_dbus_arg_info fallback_source_updated_args[] = { { "source", "o", NULL } };
277 static pa_dbus_arg_info new_playback_stream_args[] = { { "playback_stream", "o", NULL } };
278 static pa_dbus_arg_info playback_stream_removed_args[] = { { "playback_stream", "o", NULL } };
279 static pa_dbus_arg_info new_record_stream_args[] = { { "record_stream", "o", NULL } };
280 static pa_dbus_arg_info record_stream_removed_args[] = { { "record_stream", "o", NULL } };
281 static pa_dbus_arg_info new_sample_args[] = { { "sample", "o", NULL } };
282 static pa_dbus_arg_info sample_removed_args[] = { { "sample", "o", NULL } };
283 static pa_dbus_arg_info new_module_args[] = { { "module", "o", NULL } };
284 static pa_dbus_arg_info module_removed_args[] = { { "module", "o", NULL } };
285 static pa_dbus_arg_info new_client_args[] = { { "client", "o", NULL } };
286 static pa_dbus_arg_info client_removed_args[] = { { "client", "o", NULL } };
287 static pa_dbus_arg_info new_extension_args[] = { { "extension", "s", NULL } };
288 static pa_dbus_arg_info extension_removed_args[] = { { "extension", "s", NULL } };
290 static pa_dbus_signal_info signals[SIGNAL_MAX] = {
291 [SIGNAL_NEW_CARD] = { .name = "NewCard", .arguments = new_card_args, .n_arguments = 1 },
292 [SIGNAL_CARD_REMOVED] = { .name = "CardRemoved", .arguments = card_removed_args, .n_arguments = 1 },
293 [SIGNAL_NEW_SINK] = { .name = "NewSink", .arguments = new_sink_args, .n_arguments = 1 },
294 [SIGNAL_SINK_REMOVED] = { .name = "SinkRemoved", .arguments = sink_removed_args, .n_arguments = 1 },
295 [SIGNAL_FALLBACK_SINK_UPDATED] = { .name = "FallbackSinkUpdated", .arguments = fallback_sink_updated_args, .n_arguments = 1 },
296 [SIGNAL_NEW_SOURCE] = { .name = "NewSource", .arguments = new_source_args, .n_arguments = 1 },
297 [SIGNAL_SOURCE_REMOVED] = { .name = "SourceRemoved", .arguments = source_removed_args, .n_arguments = 1 },
298 [SIGNAL_FALLBACK_SOURCE_UPDATED] = { .name = "FallbackSourceUpdated", .arguments = fallback_source_updated_args, .n_arguments = 1 },
299 [SIGNAL_NEW_PLAYBACK_STREAM] = { .name = "NewPlaybackStream", .arguments = new_playback_stream_args, .n_arguments = 1 },
300 [SIGNAL_PLAYBACK_STREAM_REMOVED] = { .name = "PlaybackStreamRemoved", .arguments = playback_stream_removed_args, .n_arguments = 1 },
301 [SIGNAL_NEW_RECORD_STREAM] = { .name = "NewRecordStream", .arguments = new_record_stream_args, .n_arguments = 1 },
302 [SIGNAL_RECORD_STREAM_REMOVED] = { .name = "RecordStreamRemoved", .arguments = record_stream_removed_args, .n_arguments = 1 },
303 [SIGNAL_NEW_SAMPLE] = { .name = "NewSample", .arguments = new_sample_args, .n_arguments = 1 },
304 [SIGNAL_SAMPLE_REMOVED] = { .name = "SampleRemoved", .arguments = sample_removed_args, .n_arguments = 1 },
305 [SIGNAL_NEW_MODULE] = { .name = "NewModule", .arguments = new_module_args, .n_arguments = 1 },
306 [SIGNAL_MODULE_REMOVED] = { .name = "ModuleRemoved", .arguments = module_removed_args, .n_arguments = 1 },
307 [SIGNAL_NEW_CLIENT] = { .name = "NewClient", .arguments = new_client_args, .n_arguments = 1 },
308 [SIGNAL_CLIENT_REMOVED] = { .name = "ClientRemoved", .arguments = client_removed_args, .n_arguments = 1 },
309 [SIGNAL_NEW_EXTENSION] = { .name = "NewExtension", .arguments = new_extension_args, .n_arguments = 1 },
310 [SIGNAL_EXTENSION_REMOVED] = { .name = "ExtensionRemoved", .arguments = extension_removed_args, .n_arguments = 1 }
313 static pa_dbus_interface_info core_interface_info = {
314 .name = PA_DBUSIFACE_CORE_INTERFACE,
315 .method_handlers = method_handlers,
316 .n_method_handlers = METHOD_HANDLER_MAX,
317 .property_handlers = property_handlers,
318 .n_property_handlers = PROPERTY_HANDLER_MAX,
319 .get_all_properties_cb = handle_get_all,
321 .n_signals = SIGNAL_MAX
324 static void handle_get_interface_revision(DBusConnection *conn, DBusMessage *msg, void *userdata) {
325 dbus_uint32_t interface_revision = INTERFACE_REVISION;
330 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &interface_revision);
333 static void handle_get_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
334 const char *server_name = PACKAGE_NAME;
339 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &server_name);
342 static void handle_get_version(DBusConnection *conn, DBusMessage *msg, void *userdata) {
343 const char *version = PACKAGE_VERSION;
348 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &version);
351 static dbus_bool_t get_is_local(DBusConnection *conn) {
356 if (!dbus_connection_get_socket(conn, &conn_fd))
359 return pa_socket_is_local(conn_fd);
362 static void handle_get_is_local(DBusConnection *conn, DBusMessage *msg, void *userdata) {
363 dbus_bool_t is_local;
368 is_local = get_is_local(conn);
370 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_BOOLEAN, &is_local);
373 static void handle_get_username(DBusConnection *conn, DBusMessage *msg, void *userdata) {
374 char *username = NULL;
379 username = pa_get_user_name_malloc();
381 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &username);
386 static void handle_get_hostname(DBusConnection *conn, DBusMessage *msg, void *userdata) {
387 char *hostname = NULL;
392 hostname = pa_get_host_name_malloc();
394 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_STRING, &hostname);
399 /* Caller frees the returned array. */
400 static dbus_uint32_t *get_default_channels(pa_dbusiface_core *c, unsigned *n) {
401 dbus_uint32_t *default_channels = NULL;
407 *n = c->core->default_channel_map.channels;
408 default_channels = pa_xnew(dbus_uint32_t, *n);
410 for (i = 0; i < *n; ++i)
411 default_channels[i] = c->core->default_channel_map.map[i];
413 return default_channels;
416 static void handle_get_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata) {
417 pa_dbusiface_core *c = userdata;
418 dbus_uint32_t *default_channels = NULL;
425 default_channels = get_default_channels(c, &n);
427 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_UINT32, default_channels, n);
429 pa_xfree(default_channels);
432 static void handle_set_default_channels(DBusConnection *conn, DBusMessage *msg, void *userdata) {
433 pa_dbusiface_core *c = userdata;
434 pa_channel_map new_channel_map;
435 dbus_uint32_t *default_channels;
443 pa_channel_map_init(&new_channel_map);
445 if (pa_dbus_get_fixed_array_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_channels, &n_channels) < 0)
448 if (n_channels <= 0) {
449 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty channel array.");
453 if (n_channels > PA_CHANNELS_MAX) {
454 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);
458 new_channel_map.channels = n_channels;
460 for (i = 0; i < new_channel_map.channels; ++i) {
461 if (default_channels[i] >= PA_CHANNEL_POSITION_MAX) {
462 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid channel position: %u.", default_channels[i]);
466 new_channel_map.map[i] = default_channels[i];
469 c->core->default_channel_map = new_channel_map;
470 c->core->default_sample_spec.channels = n_channels;
472 pa_dbus_send_empty_reply(conn, msg);
475 static void handle_get_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) {
476 pa_dbusiface_core *c = userdata;
477 dbus_uint32_t default_sample_format;
483 default_sample_format = c->core->default_sample_spec.format;
485 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_format);
488 static void handle_set_default_sample_format(DBusConnection *conn, DBusMessage *msg, void *userdata) {
489 pa_dbusiface_core *c = userdata;
490 dbus_uint32_t default_sample_format;
496 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_sample_format) < 0)
499 if (default_sample_format >= PA_SAMPLE_MAX) {
500 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format.");
504 c->core->default_sample_spec.format = default_sample_format;
506 pa_dbus_send_empty_reply(conn, msg);
509 static void handle_get_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) {
510 pa_dbusiface_core *c = userdata;
511 dbus_uint32_t default_sample_rate;
517 default_sample_rate = c->core->default_sample_spec.rate;
519 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_rate);
522 static void handle_set_default_sample_rate(DBusConnection *conn, DBusMessage *msg, void *userdata) {
523 pa_dbusiface_core *c = userdata;
524 dbus_uint32_t default_sample_rate;
530 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_sample_rate) < 0)
533 if (default_sample_rate <= 0 || default_sample_rate > PA_RATE_MAX) {
534 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample rate.");
538 c->core->default_sample_spec.rate = default_sample_rate;
540 pa_dbus_send_empty_reply(conn, msg);
543 /* The caller frees the array, but not the strings. */
544 static const char **get_cards(pa_dbusiface_core *c, unsigned *n) {
548 pa_dbusiface_card *card;
553 *n = pa_hashmap_size(c->cards);
558 cards = pa_xnew(const char *, *n);
560 for (i = 0, card = pa_hashmap_iterate(c->cards, &state, NULL); card; ++i, card = pa_hashmap_iterate(c->cards, &state, NULL))
561 cards[i] = pa_dbusiface_card_get_path(card);
568 static void handle_get_cards(DBusConnection *conn, DBusMessage *msg, void *userdata) {
569 pa_dbusiface_core *c = userdata;
577 cards = get_cards(c, &n);
579 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, cards, n);
584 /* The caller frees the array, but not the strings. */
585 static const char **get_sinks(pa_dbusiface_core *c, unsigned *n) {
589 pa_dbusiface_device *sink;
594 *n = pa_hashmap_size(c->sinks_by_index);
599 sinks = pa_xnew(const char *, *n);
601 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))
602 sinks[i] = pa_dbusiface_device_get_path(sink);
609 static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata) {
610 pa_dbusiface_core *c = userdata;
618 sinks = get_sinks(c, &n);
620 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sinks, n);
625 static void handle_get_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
626 pa_dbusiface_core *c = userdata;
627 pa_dbusiface_device *fallback_sink;
628 const char *object_path;
634 if (!c->fallback_sink) {
635 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "There are no sinks, and therefore no fallback sink either.");
639 pa_assert_se((fallback_sink = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(c->fallback_sink->index))));
640 object_path = pa_dbusiface_device_get_path(fallback_sink);
642 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
645 static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
646 pa_dbusiface_core *c = userdata;
647 pa_dbusiface_device *fallback_sink;
648 const char *object_path;
654 if (!c->fallback_sink) {
655 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "There are no sinks, and therefore no fallback sink either.");
659 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path) < 0)
662 if (!(fallback_sink = pa_hashmap_get(c->sinks_by_path, object_path))) {
663 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such sink.");
667 pa_namereg_set_default_sink(c->core, pa_dbusiface_device_get_sink(fallback_sink));
669 pa_dbus_send_empty_reply(conn, msg);
672 /* The caller frees the array, but not the strings. */
673 static const char **get_sources(pa_dbusiface_core *c, unsigned *n) {
674 const char **sources;
677 pa_dbusiface_device *source;
682 *n = pa_hashmap_size(c->sources_by_index);
687 sources = pa_xnew(const char *, *n);
689 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))
690 sources[i] = pa_dbusiface_device_get_path(source);
697 static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata) {
698 pa_dbusiface_core *c = userdata;
699 const char **sources;
706 sources = get_sources(c, &n);
708 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sources, n);
713 static void handle_get_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata) {
714 pa_dbusiface_core *c = userdata;
715 pa_dbusiface_device *fallback_source;
716 const char *object_path;
722 if (!c->fallback_source) {
723 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "There are no sources, and therefore no fallback source either.");
727 pa_assert_se((fallback_source = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(c->fallback_source->index))));
728 object_path = pa_dbusiface_device_get_path(fallback_source);
730 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
733 static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata) {
734 pa_dbusiface_core *c = userdata;
735 pa_dbusiface_device *fallback_source;
736 const char *object_path;
742 if (!c->fallback_source) {
743 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "There are no sources, and therefore no fallback source either.");
747 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path) < 0)
750 if (!(fallback_source = pa_hashmap_get(c->sources_by_path, object_path))) {
751 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such source.");
755 pa_namereg_set_default_source(c->core, pa_dbusiface_device_get_source(fallback_source));
757 pa_dbus_send_empty_reply(conn, msg);
760 /* The caller frees the array, but not the strings. */
761 static const char **get_playback_streams(pa_dbusiface_core *c, unsigned *n) {
762 const char **streams;
765 pa_dbusiface_stream *stream;
770 *n = pa_hashmap_size(c->playback_streams);
775 streams = pa_xnew(const char *, *n);
777 for (i = 0, stream = pa_hashmap_iterate(c->playback_streams, &state, NULL); stream; ++i, stream = pa_hashmap_iterate(c->playback_streams, &state, NULL))
778 streams[i] = pa_dbusiface_stream_get_path(stream);
785 static void handle_get_playback_streams(DBusConnection *conn, DBusMessage *msg, void *userdata) {
786 pa_dbusiface_core *c = userdata;
787 const char **playback_streams;
794 playback_streams = get_playback_streams(c, &n);
796 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, playback_streams, n);
798 pa_xfree(playback_streams);
801 /* The caller frees the array, but not the strings. */
802 static const char **get_record_streams(pa_dbusiface_core *c, unsigned *n) {
803 const char **streams;
806 pa_dbusiface_stream *stream;
811 *n = pa_hashmap_size(c->record_streams);
816 streams = pa_xnew(const char *, *n);
818 for (i = 0, stream = pa_hashmap_iterate(c->record_streams, &state, NULL); stream; ++i, stream = pa_hashmap_iterate(c->record_streams, &state, NULL))
819 streams[i] = pa_dbusiface_stream_get_path(stream);
826 static void handle_get_record_streams(DBusConnection *conn, DBusMessage *msg, void *userdata) {
827 pa_dbusiface_core *c = userdata;
828 const char **record_streams;
835 record_streams = get_record_streams(c, &n);
837 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, record_streams, n);
839 pa_xfree(record_streams);
842 /* The caller frees the array, but not the strings. */
843 static const char **get_samples(pa_dbusiface_core *c, unsigned *n) {
844 const char **samples;
847 pa_dbusiface_sample *sample;
852 *n = pa_hashmap_size(c->samples);
857 samples = pa_xnew(const char *, *n);
859 for (i = 0, sample = pa_hashmap_iterate(c->samples, &state, NULL); sample; ++i, sample = pa_hashmap_iterate(c->samples, &state, NULL))
860 samples[i] = pa_dbusiface_sample_get_path(sample);
867 static void handle_get_samples(DBusConnection *conn, DBusMessage *msg, void *userdata) {
868 pa_dbusiface_core *c = userdata;
869 const char **samples;
876 samples = get_samples(c, &n);
878 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, samples, n);
883 /* The caller frees the array, but not the strings. */
884 static const char **get_modules(pa_dbusiface_core *c, unsigned *n) {
885 const char **modules;
888 pa_dbusiface_module *module;
893 *n = pa_hashmap_size(c->modules);
898 modules = pa_xnew(const char *, *n);
900 for (i = 0, module = pa_hashmap_iterate(c->modules, &state, NULL); module; ++i, module = pa_hashmap_iterate(c->modules, &state, NULL))
901 modules[i] = pa_dbusiface_module_get_path(module);
908 static void handle_get_modules(DBusConnection *conn, DBusMessage *msg, void *userdata) {
909 pa_dbusiface_core *c = userdata;
910 const char **modules;
917 modules = get_modules(c, &n);
919 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, modules, n);
924 /* The caller frees the array, but not the strings. */
925 static const char **get_clients(pa_dbusiface_core *c, unsigned *n) {
926 const char **clients;
929 pa_dbusiface_client *client;
934 *n = pa_hashmap_size(c->clients);
939 clients = pa_xnew(const char *, *n);
941 for (i = 0, client = pa_hashmap_iterate(c->clients, &state, NULL); client; ++i, client = pa_hashmap_iterate(c->clients, &state, NULL))
942 clients[i] = pa_dbusiface_client_get_path(client);
949 static void handle_get_clients(DBusConnection *conn, DBusMessage *msg, void *userdata) {
950 pa_dbusiface_core *c = userdata;
951 const char **clients;
958 clients = get_clients(c, &n);
960 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, clients, n);
965 static const char *get_my_client(pa_dbusiface_core *c, DBusConnection *conn) {
966 pa_client *my_client;
971 pa_assert_se((my_client = pa_dbus_protocol_get_client(c->dbus_protocol, conn)));
973 return pa_dbusiface_client_get_path(pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(my_client->index)));
976 static void handle_get_my_client(DBusConnection *conn, DBusMessage *msg, void *userdata) {
977 pa_dbusiface_core *c = userdata;
978 const char *my_client;
984 my_client = get_my_client(c, conn);
986 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &my_client);
989 static void handle_get_extensions(DBusConnection *conn, DBusMessage *msg, void *userdata) {
990 pa_dbusiface_core *c = userdata;
991 const char **extensions;
998 extensions = pa_dbus_protocol_get_extensions(c->dbus_protocol, &n);
1000 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_STRING, extensions, n);
1002 pa_xfree(extensions);
1005 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1006 pa_dbusiface_core *c = userdata;
1007 DBusMessage *reply = NULL;
1008 DBusMessageIter msg_iter;
1009 DBusMessageIter dict_iter;
1010 dbus_uint32_t interface_revision;
1011 const char *server_name;
1012 const char *version;
1013 dbus_bool_t is_local;
1016 dbus_uint32_t *default_channels;
1017 unsigned n_default_channels;
1018 dbus_uint32_t default_sample_format;
1019 dbus_uint32_t default_sample_rate;
1024 const char *fallback_sink;
1025 const char **sources;
1027 const char *fallback_source;
1028 const char **playback_streams;
1029 unsigned n_playback_streams;
1030 const char **record_streams;
1031 unsigned n_record_streams;
1032 const char **samples;
1034 const char **modules;
1036 const char **clients;
1038 const char *my_client;
1039 const char **extensions;
1040 unsigned n_extensions;
1046 interface_revision = INTERFACE_REVISION;
1047 server_name = PACKAGE_NAME;
1048 version = PACKAGE_VERSION;
1049 is_local = get_is_local(conn);
1050 username = pa_get_user_name_malloc();
1051 hostname = pa_get_host_name_malloc();
1052 default_channels = get_default_channels(c, &n_default_channels);
1053 default_sample_format = c->core->default_sample_spec.format;
1054 default_sample_rate = c->core->default_sample_spec.rate;
1055 cards = get_cards(c, &n_cards);
1056 sinks = get_sinks(c, &n_sinks);
1057 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;
1058 sources = get_sources(c, &n_sources);
1059 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;
1060 playback_streams = get_playback_streams(c, &n_playback_streams);
1061 record_streams = get_record_streams(c, &n_record_streams);
1062 samples = get_samples(c, &n_samples);
1063 modules = get_modules(c, &n_modules);
1064 clients = get_clients(c, &n_clients);
1065 my_client = get_my_client(c, conn);
1066 extensions = pa_dbus_protocol_get_extensions(c->dbus_protocol, &n_extensions);
1068 pa_assert_se((reply = dbus_message_new_method_return(msg)));
1070 dbus_message_iter_init_append(reply, &msg_iter);
1071 pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
1073 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_INTERFACE_REVISION].property_name, DBUS_TYPE_UINT32, &interface_revision);
1074 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_NAME].property_name, DBUS_TYPE_STRING, &server_name);
1075 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_VERSION].property_name, DBUS_TYPE_STRING, &version);
1076 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_IS_LOCAL].property_name, DBUS_TYPE_BOOLEAN, &is_local);
1077 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_USERNAME].property_name, DBUS_TYPE_STRING, &username);
1078 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_HOSTNAME].property_name, DBUS_TYPE_STRING, &hostname);
1079 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);
1080 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_SAMPLE_FORMAT].property_name, DBUS_TYPE_UINT32, &default_sample_format);
1081 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_SAMPLE_RATE].property_name, DBUS_TYPE_UINT32, &default_sample_rate);
1082 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CARDS].property_name, DBUS_TYPE_OBJECT_PATH, cards, n_cards);
1083 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SINKS].property_name, DBUS_TYPE_OBJECT_PATH, sinks, n_sinks);
1086 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_FALLBACK_SINK].property_name, DBUS_TYPE_OBJECT_PATH, &fallback_sink);
1088 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SOURCES].property_name, DBUS_TYPE_OBJECT_PATH, sources, n_sources);
1090 if (fallback_source)
1091 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_FALLBACK_SOURCE].property_name, DBUS_TYPE_OBJECT_PATH, &fallback_source);
1093 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);
1094 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);
1095 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SAMPLES].property_name, DBUS_TYPE_OBJECT_PATH, samples, n_samples);
1096 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_MODULES].property_name, DBUS_TYPE_OBJECT_PATH, modules, n_modules);
1097 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CLIENTS].property_name, DBUS_TYPE_OBJECT_PATH, clients, n_clients);
1098 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_MY_CLIENT].property_name, DBUS_TYPE_OBJECT_PATH, &my_client);
1099 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_EXTENSIONS].property_name, DBUS_TYPE_STRING, extensions, n_extensions);
1101 pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
1103 pa_assert_se(dbus_connection_send(conn, reply, NULL));
1105 dbus_message_unref(reply);
1109 pa_xfree(default_channels);
1113 pa_xfree(playback_streams);
1114 pa_xfree(record_streams);
1118 pa_xfree(extensions);
1121 static void handle_get_card_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1122 pa_dbusiface_core *c = userdata;
1125 pa_dbusiface_card *dbus_card;
1126 const char *object_path;
1133 dbus_error_init(&error);
1135 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &card_name, DBUS_TYPE_INVALID)) {
1136 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1137 dbus_error_free(&error);
1141 if (!(card = pa_namereg_get(c->core, card_name, PA_NAMEREG_CARD))) {
1142 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such card.");
1146 pa_assert_se((dbus_card = pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(card->index))));
1148 object_path = pa_dbusiface_card_get_path(dbus_card);
1150 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1153 static void handle_get_sink_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1154 pa_dbusiface_core *c = userdata;
1157 pa_dbusiface_device *dbus_sink;
1158 const char *object_path;
1165 dbus_error_init(&error);
1167 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &sink_name, DBUS_TYPE_INVALID)) {
1168 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1169 dbus_error_free(&error);
1173 if (!(sink = pa_namereg_get(c->core, sink_name, PA_NAMEREG_SINK))) {
1174 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such sink.");
1178 pa_assert_se((dbus_sink = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(sink->index))));
1180 object_path = pa_dbusiface_device_get_path(dbus_sink);
1182 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1185 static void handle_get_source_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1186 pa_dbusiface_core *c = userdata;
1189 pa_dbusiface_device *dbus_source;
1190 const char *object_path;
1197 dbus_error_init(&error);
1199 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &source_name, DBUS_TYPE_INVALID)) {
1200 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1201 dbus_error_free(&error);
1205 if (!(source = pa_namereg_get(c->core, source_name, PA_NAMEREG_SOURCE))) {
1206 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such source.");
1210 pa_assert_se((dbus_source = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(source->index))));
1212 object_path = pa_dbusiface_device_get_path(dbus_source);
1214 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1217 static void handle_get_sample_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1218 pa_dbusiface_core *c = userdata;
1220 pa_scache_entry *sample;
1221 pa_dbusiface_sample *dbus_sample;
1222 const char *object_path;
1229 dbus_error_init(&error);
1231 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &sample_name, DBUS_TYPE_INVALID)) {
1232 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1233 dbus_error_free(&error);
1237 if (!(sample = pa_namereg_get(c->core, sample_name, PA_NAMEREG_SAMPLE))) {
1238 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such sample.");
1242 pa_assert_se((dbus_sample = pa_hashmap_get(c->samples, PA_UINT32_TO_PTR(sample->index))));
1244 object_path = pa_dbusiface_sample_get_path(dbus_sample);
1246 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1249 static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1250 pa_dbusiface_core *c = userdata;
1251 DBusMessageIter msg_iter;
1253 dbus_uint32_t sample_format;
1254 dbus_uint32_t sample_rate;
1255 const dbus_uint32_t *channels;
1256 unsigned n_channels;
1257 const dbus_uint32_t *default_volume;
1258 unsigned n_volume_entries;
1259 pa_proplist *property_list;
1260 const uint8_t *data;
1261 unsigned data_length;
1267 pa_dbusiface_sample *dbus_sample = NULL;
1268 pa_scache_entry *sample = NULL;
1269 const char *object_path;
1275 chunk.memblock = NULL;
1277 if (!dbus_message_iter_init(msg, &msg_iter)) {
1278 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments.");
1282 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &name) < 0)
1285 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &sample_format) < 0)
1288 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &sample_rate) < 0)
1291 if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &channels, &n_channels) < 0)
1294 if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &default_volume, &n_volume_entries) < 0)
1297 if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter)))
1300 if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_BYTE, &data, &data_length) < 0)
1303 if (sample_format >= PA_SAMPLE_MAX) {
1304 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format.");
1308 if (sample_rate <= 0 || sample_rate > PA_RATE_MAX) {
1309 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample rate.");
1313 if (n_channels == 0) {
1314 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty channel map.");
1318 if (n_channels > PA_CHANNELS_MAX) {
1319 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too many channels.");
1323 for (i = 0; i < n_channels; ++i) {
1324 if (channels[i] >= PA_CHANNEL_POSITION_MAX) {
1325 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid channel position.");
1330 if (n_volume_entries != 0 && n_volume_entries != n_channels) {
1331 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "The channels and default_volume arguments have different number of elements.");
1335 for (i = 0; i < n_volume_entries; ++i) {
1336 if (default_volume[i] > PA_VOLUME_MAX) {
1337 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid volume.");
1342 if (data_length == 0) {
1343 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty data.");
1347 if (data_length > PA_SCACHE_ENTRY_SIZE_MAX) {
1348 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too big sample.");
1352 ss.format = sample_format;
1353 ss.rate = sample_rate;
1354 ss.channels = n_channels;
1356 if (!pa_frame_aligned(data_length, &ss)) {
1357 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "The sample length in bytes doesn't align with the sample format and channels.");
1361 map.channels = n_channels;
1362 for (i = 0; i < n_channels; ++i)
1363 map.map[i] = channels[i];
1365 chunk.memblock = pa_memblock_new(c->core->mempool, data_length);
1367 chunk.length = data_length;
1369 memcpy(pa_memblock_acquire(chunk.memblock), data, data_length);
1370 pa_memblock_release(chunk.memblock);
1372 if (pa_scache_add_item(c->core, name, &ss, &map, &chunk, property_list, &idx) < 0) {
1373 pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Adding the sample failed.");
1377 sample = pa_idxset_get_by_index(c->core->scache, idx);
1379 if (n_volume_entries > 0) {
1380 sample->volume.channels = n_channels;
1381 for (i = 0; i < n_volume_entries; ++i)
1382 sample->volume.values[i] = default_volume[i];
1383 sample->volume_is_set = TRUE;
1385 sample->volume_is_set = FALSE;
1388 dbus_sample = pa_dbusiface_sample_new(sample, OBJECT_PATH);
1389 pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), dbus_sample);
1391 object_path = pa_dbusiface_sample_get_path(dbus_sample);
1393 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1397 pa_proplist_free(property_list);
1400 pa_memblock_unref(chunk.memblock);
1403 static pa_bool_t contains_space(const char *string) {
1408 for (p = string; *p; ++p) {
1416 static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1417 pa_dbusiface_core *c = userdata;
1418 DBusMessageIter msg_iter;
1419 DBusMessageIter dict_iter;
1420 DBusMessageIter dict_entry_iter;
1424 char *escaped_value;
1425 pa_strbuf *arg_buffer = NULL;
1427 pa_dbusiface_module *dbus_module;
1428 const char *object_path;
1435 if (c->core->disallow_module_loading) {
1436 pa_dbus_send_error(conn, msg, DBUS_ERROR_ACCESS_DENIED, "The server is configured to disallow module loading.");
1440 if (!dbus_message_iter_init(msg, &msg_iter)) {
1441 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments.");
1445 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &name) < 0)
1448 arg_type = dbus_message_iter_get_arg_type(&msg_iter);
1449 if (arg_type != DBUS_TYPE_ARRAY) {
1450 if (arg_type == DBUS_TYPE_INVALID)
1451 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments. A dictionary from strings to strings was expected.");
1453 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);
1457 arg_type = dbus_message_iter_get_element_type(&msg_iter);
1458 if (arg_type != DBUS_TYPE_DICT_ENTRY) {
1459 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);
1463 arg_buffer = pa_strbuf_new();
1465 dbus_message_iter_recurse(&msg_iter, &dict_iter);
1467 while (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_INVALID) {
1468 if (!pa_strbuf_isempty(arg_buffer))
1469 pa_strbuf_putc(arg_buffer, ' ');
1471 dbus_message_iter_recurse(&dict_iter, &dict_entry_iter);
1473 arg_type = dbus_message_iter_get_arg_type(&dict_entry_iter);
1474 if (arg_type != DBUS_TYPE_STRING) {
1475 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Wrong dict key type: '%c'. A string was expected.", (char) arg_type);
1479 dbus_message_iter_get_basic(&dict_entry_iter, &key);
1480 dbus_message_iter_next(&dict_entry_iter);
1482 if (strlen(key) <= 0 || !pa_ascii_valid(key) || contains_space(key)) {
1483 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid module argument name: %s", key);
1487 arg_type = dbus_message_iter_get_arg_type(&dict_entry_iter);
1488 if (arg_type != DBUS_TYPE_STRING) {
1489 if (arg_type == DBUS_TYPE_INVALID)
1490 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Dict value missing.");
1492 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Wrong dict value type: '%c'. A string was expected.", (char) arg_type);
1496 dbus_message_iter_get_basic(&dict_entry_iter, &value);
1498 dbus_message_iter_next(&dict_iter);
1500 escaped_value = pa_escape(value, "\"");
1501 pa_strbuf_printf(arg_buffer, "%s=\"%s\"", key, escaped_value);
1502 pa_xfree(escaped_value);
1505 if (!(module = pa_module_load(c->core, name, pa_strbuf_tostring(arg_buffer)))) {
1506 pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Failed to load module.");
1510 dbus_module = pa_dbusiface_module_new(module, OBJECT_PATH);
1511 pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(module->index), dbus_module);
1513 object_path = pa_dbusiface_module_get_path(dbus_module);
1515 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1519 pa_strbuf_free(arg_buffer);
1522 static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1523 pa_dbusiface_core *c = userdata;
1529 if (c->core->disallow_exit) {
1530 pa_dbus_send_error(conn, msg, DBUS_ERROR_ACCESS_DENIED, "The server is configured to disallow exiting.");
1534 pa_dbus_send_empty_reply(conn, msg);
1536 pa_core_exit(c->core, FALSE, 0);
1539 static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1540 pa_dbusiface_core *c = userdata;
1542 char **objects = NULL;
1550 dbus_error_init(&error);
1552 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &signal, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objects, &n_objects, DBUS_TYPE_INVALID)) {
1553 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1554 dbus_error_free(&error);
1558 pa_dbus_protocol_add_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL, objects, n_objects);
1560 pa_dbus_send_empty_reply(conn, msg);
1563 dbus_free_string_array(objects);
1566 static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1567 pa_dbusiface_core *c = userdata;
1575 dbus_error_init(&error);
1577 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &signal, DBUS_TYPE_INVALID)) {
1578 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1579 dbus_error_free(&error);
1583 pa_dbus_protocol_remove_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL);
1585 pa_dbus_send_empty_reply(conn, msg);
1588 static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
1589 pa_dbusiface_core *c = userdata;
1590 pa_dbusiface_card *card = NULL;
1591 pa_dbusiface_device *device = NULL;
1592 pa_dbusiface_stream *stream = NULL;
1593 pa_dbusiface_sample *sample = NULL;
1594 pa_dbusiface_module *module = NULL;
1595 pa_dbusiface_client *client = NULL;
1596 DBusMessage *signal = NULL;
1597 const char *object_path = NULL;
1598 pa_sink *new_fallback_sink = NULL;
1599 pa_source *new_fallback_source = NULL;
1603 switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
1604 case PA_SUBSCRIPTION_EVENT_SERVER:
1605 new_fallback_sink = pa_namereg_get_default_sink(core);
1606 new_fallback_source = pa_namereg_get_default_source(core);
1608 if (c->fallback_sink != new_fallback_sink) {
1609 c->fallback_sink = new_fallback_sink;
1611 if (new_fallback_sink && (device = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(new_fallback_sink->index)))) {
1612 object_path = pa_dbusiface_device_get_path(device);
1614 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
1615 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1616 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1617 dbus_message_unref(signal);
1622 if (c->fallback_source != new_fallback_source) {
1623 c->fallback_source = new_fallback_source;
1625 if (new_fallback_source && (device = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(new_fallback_source->index)))) {
1626 object_path = pa_dbusiface_device_get_path(device);
1628 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
1629 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1630 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1631 dbus_message_unref(signal);
1637 case PA_SUBSCRIPTION_EVENT_CARD:
1638 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1639 if (!(card = pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(idx)))) {
1640 card = pa_dbusiface_card_new(pa_idxset_get_by_index(core->cards, idx), OBJECT_PATH);
1641 pa_hashmap_put(c->cards, PA_UINT32_TO_PTR(idx), card);
1644 object_path = pa_dbusiface_card_get_path(card);
1646 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_CARD].name)));
1647 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1649 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1650 pa_assert_se((card = pa_hashmap_remove(c->cards, PA_UINT32_TO_PTR(idx))));
1652 object_path = pa_dbusiface_card_get_path(card);
1654 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_CARD_REMOVED].name)));
1655 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1657 pa_dbusiface_card_free(card);
1661 case PA_SUBSCRIPTION_EVENT_SINK:
1662 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1663 pa_sink *sink = pa_idxset_get_by_index(core->sinks, idx);
1665 if (!(device = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(idx)))) {
1666 device = pa_dbusiface_device_new_sink(sink, OBJECT_PATH);
1667 pa_hashmap_put(c->sinks_by_index, PA_UINT32_TO_PTR(idx), device);
1668 pa_hashmap_put(c->sinks_by_path, pa_dbusiface_device_get_path(device), device);
1671 object_path = pa_dbusiface_device_get_path(device);
1673 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_SINK].name)));
1674 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1676 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1677 dbus_message_unref(signal);
1680 if (c->fallback_sink && pa_streq(c->fallback_sink->name, sink->name)) {
1681 /* We have got default sink change event, but at that point
1682 * the D-Bus sink object wasn't created yet. Now that the
1683 * object is created, let's send the fallback sink change
1685 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
1686 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1688 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1689 dbus_message_unref(signal);
1693 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1694 pa_assert_se((device = pa_hashmap_remove(c->sinks_by_index, PA_UINT32_TO_PTR(idx))));
1695 object_path = pa_dbusiface_device_get_path(device);
1696 pa_assert_se(pa_hashmap_remove(c->sinks_by_path, object_path));
1698 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_SINK_REMOVED].name)));
1699 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1701 pa_dbusiface_device_free(device);
1705 case PA_SUBSCRIPTION_EVENT_SOURCE:
1706 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1707 pa_source *source = pa_idxset_get_by_index(core->sources, idx);
1709 if (!(device = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(idx)))) {
1710 device = pa_dbusiface_device_new_source(source, OBJECT_PATH);
1711 pa_hashmap_put(c->sources_by_index, PA_UINT32_TO_PTR(idx), device);
1712 pa_hashmap_put(c->sources_by_path, pa_dbusiface_device_get_path(device), device);
1715 object_path = pa_dbusiface_device_get_path(device);
1717 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_SOURCE].name)));
1718 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1720 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1721 dbus_message_unref(signal);
1724 if (c->fallback_source && pa_streq(c->fallback_source->name, source->name)) {
1725 /* We have got default source change event, but at that
1726 * point the D-Bus source object wasn't created yet. Now
1727 * that the object is created, let's send the fallback
1728 * source change signal. */
1729 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
1730 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1732 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1733 dbus_message_unref(signal);
1737 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1738 pa_assert_se((device = pa_hashmap_remove(c->sources_by_index, PA_UINT32_TO_PTR(idx))));
1739 object_path = pa_dbusiface_device_get_path(device);
1740 pa_assert_se(pa_hashmap_remove(c->sources_by_path, object_path));
1742 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_SOURCE_REMOVED].name)));
1743 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1745 pa_dbusiface_device_free(device);
1749 case PA_SUBSCRIPTION_EVENT_SINK_INPUT:
1750 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1751 if (!(stream = pa_hashmap_get(c->playback_streams, PA_UINT32_TO_PTR(idx)))) {
1752 stream = pa_dbusiface_stream_new_playback(pa_idxset_get_by_index(core->sink_inputs, idx), OBJECT_PATH);
1753 pa_hashmap_put(c->playback_streams, PA_UINT32_TO_PTR(idx), stream);
1756 object_path = pa_dbusiface_stream_get_path(stream);
1758 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_PLAYBACK_STREAM].name)));
1759 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1761 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1762 pa_assert_se((stream = pa_hashmap_remove(c->playback_streams, PA_UINT32_TO_PTR(idx))));
1764 object_path = pa_dbusiface_stream_get_path(stream);
1766 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_PLAYBACK_STREAM_REMOVED].name)));
1767 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1769 pa_dbusiface_stream_free(stream);
1773 case PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT:
1774 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1775 if (!(stream = pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(idx)))) {
1776 stream = pa_dbusiface_stream_new_record(pa_idxset_get_by_index(core->source_outputs, idx), OBJECT_PATH);
1777 pa_hashmap_put(c->record_streams, PA_UINT32_TO_PTR(idx), stream);
1780 object_path = pa_dbusiface_stream_get_path(stream);
1782 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_RECORD_STREAM].name)));
1783 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1785 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1786 pa_assert_se((stream = pa_hashmap_remove(c->record_streams, PA_UINT32_TO_PTR(idx))));
1788 object_path = pa_dbusiface_stream_get_path(stream);
1790 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_RECORD_STREAM_REMOVED].name)));
1791 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1793 pa_dbusiface_stream_free(stream);
1797 case PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE:
1798 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1799 if (!(sample = pa_hashmap_get(c->samples, PA_UINT32_TO_PTR(idx)))) {
1800 sample = pa_dbusiface_sample_new(pa_idxset_get_by_index(core->scache, idx), OBJECT_PATH);
1801 pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), sample);
1804 object_path = pa_dbusiface_sample_get_path(sample);
1806 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_SAMPLE].name)));
1807 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1809 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1810 pa_assert_se((sample = pa_hashmap_remove(c->samples, PA_UINT32_TO_PTR(idx))));
1812 object_path = pa_dbusiface_sample_get_path(sample);
1814 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_SAMPLE_REMOVED].name)));
1815 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1817 pa_dbusiface_sample_free(sample);
1821 case PA_SUBSCRIPTION_EVENT_MODULE:
1822 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1823 if (!(module = pa_hashmap_get(c->modules, PA_UINT32_TO_PTR(idx)))) {
1824 module = pa_dbusiface_module_new(pa_idxset_get_by_index(core->modules, idx), OBJECT_PATH);
1825 pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(idx), module);
1828 object_path = pa_dbusiface_module_get_path(module);
1830 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_MODULE].name)));
1831 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1833 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1834 pa_assert_se((module = pa_hashmap_remove(c->modules, PA_UINT32_TO_PTR(idx))));
1836 object_path = pa_dbusiface_module_get_path(module);
1838 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_MODULE_REMOVED].name)));
1839 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1841 pa_dbusiface_module_free(module);
1845 case PA_SUBSCRIPTION_EVENT_CLIENT:
1846 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1847 if (!(client = pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(idx)))) {
1848 client = pa_dbusiface_client_new(pa_idxset_get_by_index(core->clients, idx), OBJECT_PATH);
1849 pa_hashmap_put(c->clients, PA_UINT32_TO_PTR(idx), client);
1852 object_path = pa_dbusiface_client_get_path(client);
1854 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_CLIENT].name)));
1855 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1857 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1858 pa_assert_se((client = pa_hashmap_remove(c->clients, PA_UINT32_TO_PTR(idx))));
1860 object_path = pa_dbusiface_client_get_path(client);
1862 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_CLIENT_REMOVED].name)));
1863 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1865 pa_dbusiface_client_free(client);
1871 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1872 dbus_message_unref(signal);
1876 static pa_hook_result_t extension_registered_cb(void *hook_data, void *call_data, void *slot_data) {
1877 pa_dbusiface_core *c = slot_data;
1878 const char *ext_name = call_data;
1879 DBusMessage *signal = NULL;
1882 pa_assert(ext_name);
1884 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_NEW_EXTENSION].name)));
1885 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
1887 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1888 dbus_message_unref(signal);
1893 static pa_hook_result_t extension_unregistered_cb(void *hook_data, void *call_data, void *slot_data) {
1894 pa_dbusiface_core *c = slot_data;
1895 const char *ext_name = call_data;
1896 DBusMessage *signal = NULL;
1899 pa_assert(ext_name);
1901 pa_assert_se((signal = dbus_message_new_signal(OBJECT_PATH, PA_DBUSIFACE_CORE_INTERFACE, signals[SIGNAL_EXTENSION_REMOVED].name)));
1902 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
1904 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1905 dbus_message_unref(signal);
1910 pa_dbusiface_core *pa_dbusiface_core_new(pa_core *core) {
1911 pa_dbusiface_core *c;
1915 pa_dbusiface_device *device;
1916 pa_sink_input *sink_input;
1917 pa_source_output *source_output;
1918 pa_scache_entry *sample;
1925 c = pa_xnew(pa_dbusiface_core, 1);
1926 c->core = pa_core_ref(core);
1927 c->subscription = pa_subscription_new(core, PA_SUBSCRIPTION_MASK_ALL, subscription_cb, c);
1928 c->dbus_protocol = pa_dbus_protocol_get(core);
1929 c->cards = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1930 c->sinks_by_index = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1931 c->sinks_by_path = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1932 c->sources_by_index = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1933 c->sources_by_path = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1934 c->playback_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1935 c->record_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1936 c->samples = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1937 c->modules = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1938 c->clients = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
1939 c->fallback_sink = pa_namereg_get_default_sink(core);
1940 c->fallback_source = pa_namereg_get_default_source(core);
1941 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);
1942 c->extension_unregistered_slot = pa_dbus_protocol_hook_connect(c->dbus_protocol, PA_DBUS_PROTOCOL_HOOK_EXTENSION_UNREGISTERED, PA_HOOK_NORMAL, extension_unregistered_cb, c);
1944 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(card, OBJECT_PATH));
1947 for (sink = pa_idxset_first(core->sinks, &idx); sink; sink = pa_idxset_next(core->sinks, &idx)) {
1948 device = pa_dbusiface_device_new_sink(sink, OBJECT_PATH);
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);
1953 for (source = pa_idxset_first(core->sources, &idx); source; source = pa_idxset_next(core->sources, &idx)) {
1954 device = pa_dbusiface_device_new_source(source, OBJECT_PATH);
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);
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(sink_input, OBJECT_PATH));
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(source_output, OBJECT_PATH));
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(sample, OBJECT_PATH));
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(module, OBJECT_PATH));
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(client, OBJECT_PATH));
1974 pa_dbus_protocol_add_interface(c->dbus_protocol, OBJECT_PATH, &core_interface_info, c);
1979 static void free_card_cb(void *p, void *userdata) {
1980 pa_dbusiface_card *c = p;
1984 pa_dbusiface_card_free(c);
1987 static void free_device_cb(void *p, void *userdata) {
1988 pa_dbusiface_device *d = p;
1992 pa_dbusiface_device_free(d);
1995 static void free_stream_cb(void *p, void *userdata) {
1996 pa_dbusiface_stream *s = p;
2000 pa_dbusiface_stream_free(s);
2003 static void free_sample_cb(void *p, void *userdata) {
2004 pa_dbusiface_sample *s = p;
2008 pa_dbusiface_sample_free(s);
2011 static void free_module_cb(void *p, void *userdata) {
2012 pa_dbusiface_module *m = p;
2016 pa_dbusiface_module_free(m);
2019 static void free_client_cb(void *p, void *userdata) {
2020 pa_dbusiface_client *c = p;
2024 pa_dbusiface_client_free(c);
2027 void pa_dbusiface_core_free(pa_dbusiface_core *c) {
2030 pa_dbus_protocol_remove_interface(c->dbus_protocol, OBJECT_PATH, core_interface_info.name);
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);
2046 pa_dbus_protocol_unref(c->dbus_protocol);
2047 pa_core_unref(c->core);