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