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


c54a3b7a6d1b5138e892e3bc44a81c695387b179
[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,
454 "Too many channels: %u. The maximum number of channels is %u.", n_channels, PA_CHANNELS_MAX);
455 return;
456 }
457
458 new_channel_map.channels = n_channels;
459
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]);
463 return;
464 }
465
466 new_channel_map.map[i] = default_channels[i];
467 }
468
469 c->core->default_channel_map = new_channel_map;
470 c->core->default_sample_spec.channels = n_channels;
471
472 pa_dbus_send_empty_reply(conn, msg);
473 };
474
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;
478
479 pa_assert(conn);
480 pa_assert(msg);
481 pa_assert(c);
482
483 default_sample_format = c->core->default_sample_spec.format;
484
485 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_format);
486 }
487
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;
491
492 pa_assert(conn);
493 pa_assert(msg);
494 pa_assert(c);
495
496 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_sample_format) < 0)
497 return;
498
499 if (default_sample_format >= PA_SAMPLE_MAX) {
500 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format.");
501 return;
502 }
503
504 c->core->default_sample_spec.format = default_sample_format;
505
506 pa_dbus_send_empty_reply(conn, msg);
507 }
508
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;
512
513 pa_assert(conn);
514 pa_assert(msg);
515 pa_assert(c);
516
517 default_sample_rate = c->core->default_sample_spec.rate;
518
519 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_UINT32, &default_sample_rate);
520 }
521
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;
525
526 pa_assert(conn);
527 pa_assert(msg);
528 pa_assert(c);
529
530 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_UINT32, &default_sample_rate) < 0)
531 return;
532
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.");
535 return;
536 }
537
538 c->core->default_sample_spec.rate = default_sample_rate;
539
540 pa_dbus_send_empty_reply(conn, msg);
541 }
542
543 /* The caller frees the array, but not the strings. */
544 static const char **get_cards(pa_dbusiface_core *c, unsigned *n) {
545 const char **cards;
546 unsigned i = 0;
547 void *state = NULL;
548 pa_dbusiface_card *card;
549
550 pa_assert(c);
551 pa_assert(n);
552
553 *n = pa_hashmap_size(c->cards);
554
555 if (*n == 0)
556 return NULL;
557
558 cards = pa_xnew(const char *, *n);
559
560 PA_HASHMAP_FOREACH(card, c->cards, state)
561 cards[i++] = pa_dbusiface_card_get_path(card);
562
563 return cards;
564 }
565
566 static void handle_get_cards(DBusConnection *conn, DBusMessage *msg, void *userdata) {
567 pa_dbusiface_core *c = userdata;
568 const char **cards;
569 unsigned n;
570
571 pa_assert(conn);
572 pa_assert(msg);
573 pa_assert(c);
574
575 cards = get_cards(c, &n);
576
577 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, cards, n);
578
579 pa_xfree(cards);
580 }
581
582 /* The caller frees the array, but not the strings. */
583 static const char **get_sinks(pa_dbusiface_core *c, unsigned *n) {
584 const char **sinks;
585 unsigned i = 0;
586 void *state = NULL;
587 pa_dbusiface_device *sink;
588
589 pa_assert(c);
590 pa_assert(n);
591
592 *n = pa_hashmap_size(c->sinks_by_index);
593
594 if (*n == 0)
595 return NULL;
596
597 sinks = pa_xnew(const char *, *n);
598
599 PA_HASHMAP_FOREACH(sink, c->sinks_by_index, state)
600 sinks[i++] = pa_dbusiface_device_get_path(sink);
601
602 return sinks;
603 }
604
605 static void handle_get_sinks(DBusConnection *conn, DBusMessage *msg, void *userdata) {
606 pa_dbusiface_core *c = userdata;
607 const char **sinks;
608 unsigned n;
609
610 pa_assert(conn);
611 pa_assert(msg);
612 pa_assert(c);
613
614 sinks = get_sinks(c, &n);
615
616 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sinks, n);
617
618 pa_xfree(sinks);
619 }
620
621 static void handle_get_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
622 pa_dbusiface_core *c = userdata;
623 pa_dbusiface_device *fallback_sink;
624 const char *object_path;
625
626 pa_assert(conn);
627 pa_assert(msg);
628 pa_assert(c);
629
630 if (!c->fallback_sink) {
631 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
632 "There are no sinks, and therefore no fallback sink either.");
633 return;
634 }
635
636 pa_assert_se((fallback_sink = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(c->fallback_sink->index))));
637 object_path = pa_dbusiface_device_get_path(fallback_sink);
638
639 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
640 }
641
642 static void handle_set_fallback_sink(DBusConnection *conn, DBusMessage *msg, void *userdata) {
643 pa_dbusiface_core *c = userdata;
644 pa_dbusiface_device *fallback_sink;
645 const char *object_path;
646
647 pa_assert(conn);
648 pa_assert(msg);
649 pa_assert(c);
650
651 if (!c->fallback_sink) {
652 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
653 "There are no sinks, and therefore no fallback sink either.");
654 return;
655 }
656
657 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path) < 0)
658 return;
659
660 if (!(fallback_sink = pa_hashmap_get(c->sinks_by_path, object_path))) {
661 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such sink.", object_path);
662 return;
663 }
664
665 pa_namereg_set_default_sink(c->core, pa_dbusiface_device_get_sink(fallback_sink));
666
667 pa_dbus_send_empty_reply(conn, msg);
668 }
669
670 /* The caller frees the array, but not the strings. */
671 static const char **get_sources(pa_dbusiface_core *c, unsigned *n) {
672 const char **sources;
673 unsigned i = 0;
674 void *state = NULL;
675 pa_dbusiface_device *source;
676
677 pa_assert(c);
678 pa_assert(n);
679
680 *n = pa_hashmap_size(c->sources_by_index);
681
682 if (*n == 0)
683 return NULL;
684
685 sources = pa_xnew(const char *, *n);
686
687 PA_HASHMAP_FOREACH(source, c->sources_by_index, state)
688 sources[i++] = pa_dbusiface_device_get_path(source);
689
690 return sources;
691 }
692
693 static void handle_get_sources(DBusConnection *conn, DBusMessage *msg, void *userdata) {
694 pa_dbusiface_core *c = userdata;
695 const char **sources;
696 unsigned n;
697
698 pa_assert(conn);
699 pa_assert(msg);
700 pa_assert(c);
701
702 sources = get_sources(c, &n);
703
704 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, sources, n);
705
706 pa_xfree(sources);
707 }
708
709 static void handle_get_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata) {
710 pa_dbusiface_core *c = userdata;
711 pa_dbusiface_device *fallback_source;
712 const char *object_path;
713
714 pa_assert(conn);
715 pa_assert(msg);
716 pa_assert(c);
717
718 if (!c->fallback_source) {
719 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
720 "There are no sources, and therefore no fallback source either.");
721 return;
722 }
723
724 pa_assert_se((fallback_source = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(c->fallback_source->index))));
725 object_path = pa_dbusiface_device_get_path(fallback_source);
726
727 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
728 }
729
730 static void handle_set_fallback_source(DBusConnection *conn, DBusMessage *msg, void *userdata) {
731 pa_dbusiface_core *c = userdata;
732 pa_dbusiface_device *fallback_source;
733 const char *object_path;
734
735 pa_assert(conn);
736 pa_assert(msg);
737 pa_assert(c);
738
739 if (!c->fallback_source) {
740 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY,
741 "There are no sources, and therefore no fallback source either.");
742 return;
743 }
744
745 if (pa_dbus_get_basic_set_property_arg(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path) < 0)
746 return;
747
748 if (!(fallback_source = pa_hashmap_get(c->sources_by_path, object_path))) {
749 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such source.", object_path);
750 return;
751 }
752
753 pa_namereg_set_default_source(c->core, pa_dbusiface_device_get_source(fallback_source));
754
755 pa_dbus_send_empty_reply(conn, msg);
756 }
757
758 /* The caller frees the array, but not the strings. */
759 static const char **get_playback_streams(pa_dbusiface_core *c, unsigned *n) {
760 const char **streams;
761 unsigned i = 0;
762 void *state = NULL;
763 pa_dbusiface_stream *stream;
764
765 pa_assert(c);
766 pa_assert(n);
767
768 *n = pa_hashmap_size(c->playback_streams);
769
770 if (*n == 0)
771 return NULL;
772
773 streams = pa_xnew(const char *, *n);
774
775 PA_HASHMAP_FOREACH(stream, c->playback_streams, state)
776 streams[i++] = pa_dbusiface_stream_get_path(stream);
777
778 return streams;
779 }
780
781 static void handle_get_playback_streams(DBusConnection *conn, DBusMessage *msg, void *userdata) {
782 pa_dbusiface_core *c = userdata;
783 const char **playback_streams;
784 unsigned n;
785
786 pa_assert(conn);
787 pa_assert(msg);
788 pa_assert(c);
789
790 playback_streams = get_playback_streams(c, &n);
791
792 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, playback_streams, n);
793
794 pa_xfree(playback_streams);
795 }
796
797 /* The caller frees the array, but not the strings. */
798 static const char **get_record_streams(pa_dbusiface_core *c, unsigned *n) {
799 const char **streams;
800 unsigned i = 0;
801 void *state = NULL;
802 pa_dbusiface_stream *stream;
803
804 pa_assert(c);
805 pa_assert(n);
806
807 *n = pa_hashmap_size(c->record_streams);
808
809 if (*n == 0)
810 return NULL;
811
812 streams = pa_xnew(const char *, *n);
813
814 PA_HASHMAP_FOREACH(stream, c->record_streams, state)
815 streams[i++] = pa_dbusiface_stream_get_path(stream);
816
817 return streams;
818 }
819
820 static void handle_get_record_streams(DBusConnection *conn, DBusMessage *msg, void *userdata) {
821 pa_dbusiface_core *c = userdata;
822 const char **record_streams;
823 unsigned n;
824
825 pa_assert(conn);
826 pa_assert(msg);
827 pa_assert(c);
828
829 record_streams = get_record_streams(c, &n);
830
831 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, record_streams, n);
832
833 pa_xfree(record_streams);
834 }
835
836 /* The caller frees the array, but not the strings. */
837 static const char **get_samples(pa_dbusiface_core *c, unsigned *n) {
838 const char **samples;
839 unsigned i = 0;
840 void *state = NULL;
841 pa_dbusiface_sample *sample;
842
843 pa_assert(c);
844 pa_assert(n);
845
846 *n = pa_hashmap_size(c->samples);
847
848 if (*n == 0)
849 return NULL;
850
851 samples = pa_xnew(const char *, *n);
852
853 PA_HASHMAP_FOREACH(sample, c->samples, state)
854 samples[i++] = pa_dbusiface_sample_get_path(sample);
855
856 return samples;
857 }
858
859 static void handle_get_samples(DBusConnection *conn, DBusMessage *msg, void *userdata) {
860 pa_dbusiface_core *c = userdata;
861 const char **samples;
862 unsigned n;
863
864 pa_assert(conn);
865 pa_assert(msg);
866 pa_assert(c);
867
868 samples = get_samples(c, &n);
869
870 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, samples, n);
871
872 pa_xfree(samples);
873 }
874
875 /* The caller frees the array, but not the strings. */
876 static const char **get_modules(pa_dbusiface_core *c, unsigned *n) {
877 const char **modules;
878 unsigned i = 0;
879 void *state = NULL;
880 pa_dbusiface_module *module;
881
882 pa_assert(c);
883 pa_assert(n);
884
885 *n = pa_hashmap_size(c->modules);
886
887 if (*n == 0)
888 return NULL;
889
890 modules = pa_xnew(const char *, *n);
891
892 PA_HASHMAP_FOREACH(module, c->modules, state)
893 modules[i++] = pa_dbusiface_module_get_path(module);
894
895 return modules;
896 }
897
898 static void handle_get_modules(DBusConnection *conn, DBusMessage *msg, void *userdata) {
899 pa_dbusiface_core *c = userdata;
900 const char **modules;
901 unsigned n;
902
903 pa_assert(conn);
904 pa_assert(msg);
905 pa_assert(c);
906
907 modules = get_modules(c, &n);
908
909 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, modules, n);
910
911 pa_xfree(modules);
912 }
913
914 /* The caller frees the array, but not the strings. */
915 static const char **get_clients(pa_dbusiface_core *c, unsigned *n) {
916 const char **clients;
917 unsigned i = 0;
918 void *state = NULL;
919 pa_dbusiface_client *client;
920
921 pa_assert(c);
922 pa_assert(n);
923
924 *n = pa_hashmap_size(c->clients);
925
926 if (*n == 0)
927 return NULL;
928
929 clients = pa_xnew(const char *, *n);
930
931 PA_HASHMAP_FOREACH(client, c->clients, state)
932 clients[i++] = pa_dbusiface_client_get_path(client);
933
934 return clients;
935 }
936
937 static void handle_get_clients(DBusConnection *conn, DBusMessage *msg, void *userdata) {
938 pa_dbusiface_core *c = userdata;
939 const char **clients;
940 unsigned n;
941
942 pa_assert(conn);
943 pa_assert(msg);
944 pa_assert(c);
945
946 clients = get_clients(c, &n);
947
948 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, clients, n);
949
950 pa_xfree(clients);
951 }
952
953 static const char *get_my_client(pa_dbusiface_core *c, DBusConnection *conn) {
954 pa_client *my_client;
955
956 pa_assert(c);
957 pa_assert(conn);
958
959 pa_assert_se((my_client = pa_dbus_protocol_get_client(c->dbus_protocol, conn)));
960
961 return pa_dbusiface_client_get_path(pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(my_client->index)));
962 }
963
964 static void handle_get_my_client(DBusConnection *conn, DBusMessage *msg, void *userdata) {
965 pa_dbusiface_core *c = userdata;
966 const char *my_client;
967
968 pa_assert(conn);
969 pa_assert(msg);
970 pa_assert(c);
971
972 my_client = get_my_client(c, conn);
973
974 pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &my_client);
975 }
976
977 static void handle_get_extensions(DBusConnection *conn, DBusMessage *msg, void *userdata) {
978 pa_dbusiface_core *c = userdata;
979 const char **extensions;
980 unsigned n;
981
982 pa_assert(conn);
983 pa_assert(msg);
984 pa_assert(c);
985
986 extensions = pa_dbus_protocol_get_extensions(c->dbus_protocol, &n);
987
988 pa_dbus_send_basic_array_variant_reply(conn, msg, DBUS_TYPE_STRING, extensions, n);
989
990 pa_xfree(extensions);
991 }
992
993 static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdata) {
994 pa_dbusiface_core *c = userdata;
995 DBusMessage *reply = NULL;
996 DBusMessageIter msg_iter;
997 DBusMessageIter dict_iter;
998 dbus_uint32_t interface_revision;
999 const char *server_name;
1000 const char *version;
1001 dbus_bool_t is_local;
1002 char *username;
1003 char *hostname;
1004 dbus_uint32_t *default_channels;
1005 unsigned n_default_channels;
1006 dbus_uint32_t default_sample_format;
1007 dbus_uint32_t default_sample_rate;
1008 const char **cards;
1009 unsigned n_cards;
1010 const char **sinks;
1011 unsigned n_sinks;
1012 const char *fallback_sink;
1013 const char **sources;
1014 unsigned n_sources;
1015 const char *fallback_source;
1016 const char **playback_streams;
1017 unsigned n_playback_streams;
1018 const char **record_streams;
1019 unsigned n_record_streams;
1020 const char **samples;
1021 unsigned n_samples;
1022 const char **modules;
1023 unsigned n_modules;
1024 const char **clients;
1025 unsigned n_clients;
1026 const char *my_client;
1027 const char **extensions;
1028 unsigned n_extensions;
1029
1030 pa_assert(conn);
1031 pa_assert(msg);
1032 pa_assert(c);
1033
1034 interface_revision = INTERFACE_REVISION;
1035 server_name = PACKAGE_NAME;
1036 version = PACKAGE_VERSION;
1037 is_local = get_is_local(conn);
1038 username = pa_get_user_name_malloc();
1039 hostname = pa_get_host_name_malloc();
1040 default_channels = get_default_channels(c, &n_default_channels);
1041 default_sample_format = c->core->default_sample_spec.format;
1042 default_sample_rate = c->core->default_sample_spec.rate;
1043 cards = get_cards(c, &n_cards);
1044 sinks = get_sinks(c, &n_sinks);
1045 fallback_sink = c->fallback_sink
1046 ? pa_dbusiface_device_get_path(pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(c->fallback_sink->index)))
1047 : NULL;
1048 sources = get_sources(c, &n_sources);
1049 fallback_source = c->fallback_source
1050 ? pa_dbusiface_device_get_path(pa_hashmap_get(c->sources_by_index,
1051 PA_UINT32_TO_PTR(c->fallback_source->index)))
1052 : NULL;
1053 playback_streams = get_playback_streams(c, &n_playback_streams);
1054 record_streams = get_record_streams(c, &n_record_streams);
1055 samples = get_samples(c, &n_samples);
1056 modules = get_modules(c, &n_modules);
1057 clients = get_clients(c, &n_clients);
1058 my_client = get_my_client(c, conn);
1059 extensions = pa_dbus_protocol_get_extensions(c->dbus_protocol, &n_extensions);
1060
1061 pa_assert_se((reply = dbus_message_new_method_return(msg)));
1062
1063 dbus_message_iter_init_append(reply, &msg_iter);
1064 pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter));
1065
1066 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_INTERFACE_REVISION].property_name, DBUS_TYPE_UINT32, &interface_revision);
1067 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_NAME].property_name, DBUS_TYPE_STRING, &server_name);
1068 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_VERSION].property_name, DBUS_TYPE_STRING, &version);
1069 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_IS_LOCAL].property_name, DBUS_TYPE_BOOLEAN, &is_local);
1070 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_USERNAME].property_name, DBUS_TYPE_STRING, &username);
1071 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_HOSTNAME].property_name, DBUS_TYPE_STRING, &hostname);
1072 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);
1073 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_SAMPLE_FORMAT].property_name, DBUS_TYPE_UINT32, &default_sample_format);
1074 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_DEFAULT_SAMPLE_RATE].property_name, DBUS_TYPE_UINT32, &default_sample_rate);
1075 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CARDS].property_name, DBUS_TYPE_OBJECT_PATH, cards, n_cards);
1076 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SINKS].property_name, DBUS_TYPE_OBJECT_PATH, sinks, n_sinks);
1077
1078 if (fallback_sink)
1079 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_FALLBACK_SINK].property_name, DBUS_TYPE_OBJECT_PATH, &fallback_sink);
1080
1081 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SOURCES].property_name, DBUS_TYPE_OBJECT_PATH, sources, n_sources);
1082
1083 if (fallback_source)
1084 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_FALLBACK_SOURCE].property_name, DBUS_TYPE_OBJECT_PATH, &fallback_source);
1085
1086 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);
1087 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);
1088 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_SAMPLES].property_name, DBUS_TYPE_OBJECT_PATH, samples, n_samples);
1089 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_MODULES].property_name, DBUS_TYPE_OBJECT_PATH, modules, n_modules);
1090 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_CLIENTS].property_name, DBUS_TYPE_OBJECT_PATH, clients, n_clients);
1091 pa_dbus_append_basic_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_MY_CLIENT].property_name, DBUS_TYPE_OBJECT_PATH, &my_client);
1092 pa_dbus_append_basic_array_variant_dict_entry(&dict_iter, property_handlers[PROPERTY_HANDLER_EXTENSIONS].property_name, DBUS_TYPE_STRING, extensions, n_extensions);
1093
1094 pa_assert_se(dbus_message_iter_close_container(&msg_iter, &dict_iter));
1095
1096 pa_assert_se(dbus_connection_send(conn, reply, NULL));
1097
1098 dbus_message_unref(reply);
1099
1100 pa_xfree(username);
1101 pa_xfree(hostname);
1102 pa_xfree(default_channels);
1103 pa_xfree(cards);
1104 pa_xfree(sinks);
1105 pa_xfree(sources);
1106 pa_xfree(playback_streams);
1107 pa_xfree(record_streams);
1108 pa_xfree(samples);
1109 pa_xfree(modules);
1110 pa_xfree(clients);
1111 pa_xfree(extensions);
1112 }
1113
1114 static void handle_get_card_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1115 pa_dbusiface_core *c = userdata;
1116 char *card_name;
1117 pa_card *card;
1118 pa_dbusiface_card *dbus_card;
1119 const char *object_path;
1120 DBusError error;
1121
1122 pa_assert(conn);
1123 pa_assert(msg);
1124 pa_assert(c);
1125
1126 dbus_error_init(&error);
1127
1128 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &card_name, DBUS_TYPE_INVALID)) {
1129 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1130 dbus_error_free(&error);
1131 return;
1132 }
1133
1134 if (!(card = pa_namereg_get(c->core, card_name, PA_NAMEREG_CARD))) {
1135 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such card.");
1136 return;
1137 }
1138
1139 pa_assert_se((dbus_card = pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(card->index))));
1140
1141 object_path = pa_dbusiface_card_get_path(dbus_card);
1142
1143 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1144 }
1145
1146 static void handle_get_sink_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1147 pa_dbusiface_core *c = userdata;
1148 char *sink_name;
1149 pa_sink *sink;
1150 pa_dbusiface_device *dbus_sink;
1151 const char *object_path;
1152 DBusError error;
1153
1154 pa_assert(conn);
1155 pa_assert(msg);
1156 pa_assert(c);
1157
1158 dbus_error_init(&error);
1159
1160 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &sink_name, DBUS_TYPE_INVALID)) {
1161 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1162 dbus_error_free(&error);
1163 return;
1164 }
1165
1166 if (!(sink = pa_namereg_get(c->core, sink_name, PA_NAMEREG_SINK))) {
1167 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such sink.", sink_name);
1168 return;
1169 }
1170
1171 pa_assert_se((dbus_sink = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(sink->index))));
1172
1173 object_path = pa_dbusiface_device_get_path(dbus_sink);
1174
1175 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1176 }
1177
1178 static void handle_get_source_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1179 pa_dbusiface_core *c = userdata;
1180 char *source_name;
1181 pa_source *source;
1182 pa_dbusiface_device *dbus_source;
1183 const char *object_path;
1184 DBusError error;
1185
1186 pa_assert(conn);
1187 pa_assert(msg);
1188 pa_assert(c);
1189
1190 dbus_error_init(&error);
1191
1192 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &source_name, DBUS_TYPE_INVALID)) {
1193 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1194 dbus_error_free(&error);
1195 return;
1196 }
1197
1198 if (!(source = pa_namereg_get(c->core, source_name, PA_NAMEREG_SOURCE))) {
1199 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "%s: No such source.", source_name);
1200 return;
1201 }
1202
1203 pa_assert_se((dbus_source = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(source->index))));
1204
1205 object_path = pa_dbusiface_device_get_path(dbus_source);
1206
1207 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1208 }
1209
1210 static void handle_get_sample_by_name(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1211 pa_dbusiface_core *c = userdata;
1212 char *sample_name;
1213 pa_scache_entry *sample;
1214 pa_dbusiface_sample *dbus_sample;
1215 const char *object_path;
1216 DBusError error;
1217
1218 pa_assert(conn);
1219 pa_assert(msg);
1220 pa_assert(c);
1221
1222 dbus_error_init(&error);
1223
1224 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &sample_name, DBUS_TYPE_INVALID)) {
1225 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1226 dbus_error_free(&error);
1227 return;
1228 }
1229
1230 if (!(sample = pa_namereg_get(c->core, sample_name, PA_NAMEREG_SAMPLE))) {
1231 pa_dbus_send_error(conn, msg, PA_DBUS_ERROR_NOT_FOUND, "No such sample.");
1232 return;
1233 }
1234
1235 pa_assert_se((dbus_sample = pa_hashmap_get(c->samples, PA_UINT32_TO_PTR(sample->index))));
1236
1237 object_path = pa_dbusiface_sample_get_path(dbus_sample);
1238
1239 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1240 }
1241
1242 static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1243 pa_dbusiface_core *c = userdata;
1244 DBusMessageIter msg_iter;
1245 const char *name;
1246 dbus_uint32_t sample_format;
1247 dbus_uint32_t sample_rate;
1248 const dbus_uint32_t *channels;
1249 unsigned n_channels;
1250 const dbus_uint32_t *default_volume;
1251 unsigned n_volume_entries;
1252 pa_proplist *property_list;
1253 const uint8_t *data;
1254 unsigned data_length;
1255 unsigned i;
1256 pa_sample_spec ss;
1257 pa_channel_map map;
1258 pa_memchunk chunk;
1259 uint32_t idx;
1260 pa_dbusiface_sample *dbus_sample = NULL;
1261 pa_scache_entry *sample = NULL;
1262 const char *object_path;
1263
1264 pa_assert(conn);
1265 pa_assert(msg);
1266 pa_assert(c);
1267
1268 chunk.memblock = NULL;
1269
1270 if (!dbus_message_iter_init(msg, &msg_iter)) {
1271 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments.");
1272 return;
1273 }
1274
1275 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &name) < 0)
1276 return;
1277
1278 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &sample_format) < 0)
1279 return;
1280
1281 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &sample_rate) < 0)
1282 return;
1283
1284 if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &channels, &n_channels) < 0)
1285 return;
1286
1287 if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_UINT32, &default_volume, &n_volume_entries) < 0)
1288 return;
1289
1290 if (!(property_list = pa_dbus_get_proplist_arg(conn, msg, &msg_iter)))
1291 return;
1292
1293 if (pa_dbus_get_fixed_array_arg(conn, msg, &msg_iter, DBUS_TYPE_BYTE, &data, &data_length) < 0)
1294 goto finish;
1295
1296 if (sample_format >= PA_SAMPLE_MAX) {
1297 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample format.");
1298 goto finish;
1299 }
1300
1301 if (sample_rate <= 0 || sample_rate > PA_RATE_MAX) {
1302 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid sample rate.");
1303 goto finish;
1304 }
1305
1306 if (n_channels == 0) {
1307 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty channel map.");
1308 goto finish;
1309 }
1310
1311 if (n_channels > PA_CHANNELS_MAX) {
1312 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1313 "Too many channels: %u. The maximum is %u.", n_channels, PA_CHANNELS_MAX);
1314 goto finish;
1315 }
1316
1317 for (i = 0; i < n_channels; ++i) {
1318 if (channels[i] >= PA_CHANNEL_POSITION_MAX) {
1319 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid channel position.");
1320 goto finish;
1321 }
1322 }
1323
1324 if (n_volume_entries != 0 && n_volume_entries != n_channels) {
1325 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1326 "The channels and default_volume arguments have different number of elements.");
1327 goto finish;
1328 }
1329
1330 for (i = 0; i < n_volume_entries; ++i) {
1331 if (default_volume[i] > PA_VOLUME_MAX) {
1332 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid volume.");
1333 goto finish;
1334 }
1335 }
1336
1337 if (data_length == 0) {
1338 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Empty data.");
1339 goto finish;
1340 }
1341
1342 if (data_length > PA_SCACHE_ENTRY_SIZE_MAX) {
1343 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too big sample.");
1344 goto finish;
1345 }
1346
1347 ss.format = sample_format;
1348 ss.rate = sample_rate;
1349 ss.channels = n_channels;
1350
1351 if (!pa_frame_aligned(data_length, &ss)) {
1352 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1353 "The sample length in bytes doesn't align with the sample format and channels.");
1354 goto finish;
1355 }
1356
1357 map.channels = n_channels;
1358 for (i = 0; i < n_channels; ++i)
1359 map.map[i] = channels[i];
1360
1361 chunk.memblock = pa_memblock_new(c->core->mempool, data_length);
1362 chunk.index = 0;
1363 chunk.length = data_length;
1364
1365 memcpy(pa_memblock_acquire(chunk.memblock), data, data_length);
1366 pa_memblock_release(chunk.memblock);
1367
1368 if (pa_scache_add_item(c->core, name, &ss, &map, &chunk, property_list, &idx) < 0) {
1369 pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Adding the sample failed.");
1370 goto finish;
1371 }
1372
1373 sample = pa_idxset_get_by_index(c->core->scache, idx);
1374
1375 if (n_volume_entries > 0) {
1376 sample->volume.channels = n_channels;
1377 for (i = 0; i < n_volume_entries; ++i)
1378 sample->volume.values[i] = default_volume[i];
1379 sample->volume_is_set = TRUE;
1380 } else {
1381 sample->volume_is_set = FALSE;
1382 }
1383
1384 dbus_sample = pa_dbusiface_sample_new(c, sample);
1385 pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), dbus_sample);
1386
1387 object_path = pa_dbusiface_sample_get_path(dbus_sample);
1388
1389 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1390
1391 finish:
1392 if (property_list)
1393 pa_proplist_free(property_list);
1394
1395 if (chunk.memblock)
1396 pa_memblock_unref(chunk.memblock);
1397 }
1398
1399 static pa_bool_t contains_space(const char *string) {
1400 const char *p;
1401
1402 pa_assert(string);
1403
1404 for (p = string; *p; ++p) {
1405 if (isspace(*p))
1406 return TRUE;
1407 }
1408
1409 return FALSE;
1410 }
1411
1412 static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1413 pa_dbusiface_core *c = userdata;
1414 DBusMessageIter msg_iter;
1415 DBusMessageIter dict_iter;
1416 DBusMessageIter dict_entry_iter;
1417 char *name;
1418 const char *key;
1419 const char *value;
1420 char *escaped_value;
1421 pa_strbuf *arg_buffer = NULL;
1422 pa_module *module;
1423 pa_dbusiface_module *dbus_module;
1424 const char *object_path;
1425 int arg_type;
1426
1427 pa_assert(conn);
1428 pa_assert(msg);
1429 pa_assert(c);
1430
1431 if (c->core->disallow_module_loading) {
1432 pa_dbus_send_error(conn, msg, DBUS_ERROR_ACCESS_DENIED, "The server is configured to disallow module loading.");
1433 return;
1434 }
1435
1436 if (!dbus_message_iter_init(msg, &msg_iter)) {
1437 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Too few arguments.");
1438 return;
1439 }
1440
1441 if (pa_dbus_get_basic_arg(conn, msg, &msg_iter, DBUS_TYPE_STRING, &name) < 0)
1442 return;
1443
1444 arg_type = dbus_message_iter_get_arg_type(&msg_iter);
1445 if (arg_type != DBUS_TYPE_ARRAY) {
1446 if (arg_type == DBUS_TYPE_INVALID)
1447 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1448 "Too few arguments. A dictionary from strings to strings was expected.");
1449 else
1450 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1451 "Wrong argument type: '%c'. An dictionary from strings to strings was expected.",
1452 (char) arg_type);
1453 return;
1454 }
1455
1456 arg_type = dbus_message_iter_get_element_type(&msg_iter);
1457 if (arg_type != DBUS_TYPE_DICT_ENTRY) {
1458 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1459 "Wrong array element type: '%c'. A dict entry (string to string) was expected.", (char) arg_type);
1460 return;
1461 }
1462
1463 arg_buffer = pa_strbuf_new();
1464
1465 dbus_message_iter_recurse(&msg_iter, &dict_iter);
1466
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, ' ');
1470
1471 dbus_message_iter_recurse(&dict_iter, &dict_entry_iter);
1472
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,
1476 "Wrong dict key type: '%c'. A string was expected.", (char) arg_type);
1477 goto finish;
1478 }
1479
1480 dbus_message_iter_get_basic(&dict_entry_iter, &key);
1481 dbus_message_iter_next(&dict_entry_iter);
1482
1483 if (strlen(key) <= 0 || !pa_ascii_valid(key) || contains_space(key)) {
1484 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Invalid module argument name: %s", key);
1485 goto finish;
1486 }
1487
1488 arg_type = dbus_message_iter_get_arg_type(&dict_entry_iter);
1489 if (arg_type != DBUS_TYPE_STRING) {
1490 if (arg_type == DBUS_TYPE_INVALID)
1491 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "Dict value missing.");
1492 else
1493 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS,
1494 "Wrong dict value type: '%c'. A string was expected.", (char) arg_type);
1495 goto finish;
1496 }
1497
1498 dbus_message_iter_get_basic(&dict_entry_iter, &value);
1499
1500 dbus_message_iter_next(&dict_iter);
1501
1502 escaped_value = pa_escape(value, "\"");
1503 pa_strbuf_printf(arg_buffer, "%s=\"%s\"", key, escaped_value);
1504 pa_xfree(escaped_value);
1505 }
1506
1507 if (!(module = pa_module_load(c->core, name, pa_strbuf_tostring(arg_buffer)))) {
1508 pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED, "Failed to load module.");
1509 goto finish;
1510 }
1511
1512 dbus_module = pa_dbusiface_module_new(module);
1513 pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(module->index), dbus_module);
1514
1515 object_path = pa_dbusiface_module_get_path(dbus_module);
1516
1517 pa_dbus_send_basic_value_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &object_path);
1518
1519 finish:
1520 if (arg_buffer)
1521 pa_strbuf_free(arg_buffer);
1522 }
1523
1524 static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1525 pa_dbusiface_core *c = userdata;
1526
1527 pa_assert(conn);
1528 pa_assert(msg);
1529 pa_assert(c);
1530
1531 if (c->core->disallow_exit) {
1532 pa_dbus_send_error(conn, msg, DBUS_ERROR_ACCESS_DENIED, "The server is configured to disallow exiting.");
1533 return;
1534 }
1535
1536 pa_dbus_send_empty_reply(conn, msg);
1537
1538 pa_core_exit(c->core, FALSE, 0);
1539 }
1540
1541 static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1542 pa_dbusiface_core *c = userdata;
1543 const char *signal;
1544 char **objects = NULL;
1545 int n_objects;
1546 DBusError error;
1547
1548 pa_assert(conn);
1549 pa_assert(msg);
1550 pa_assert(c);
1551
1552 dbus_error_init(&error);
1553
1554 if (!dbus_message_get_args(msg, &error,
1555 DBUS_TYPE_STRING, &signal,
1556 DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &objects, &n_objects,
1557 DBUS_TYPE_INVALID)) {
1558 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1559 dbus_error_free(&error);
1560 goto finish;
1561 }
1562
1563 pa_dbus_protocol_add_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL, objects, n_objects);
1564
1565 pa_dbus_send_empty_reply(conn, msg);
1566
1567 finish:
1568 dbus_free_string_array(objects);
1569 }
1570
1571 static void handle_stop_listening_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {
1572 pa_dbusiface_core *c = userdata;
1573 const char *signal;
1574 DBusError error;
1575
1576 pa_assert(conn);
1577 pa_assert(msg);
1578 pa_assert(c);
1579
1580 dbus_error_init(&error);
1581
1582 if (!dbus_message_get_args(msg, &error, DBUS_TYPE_STRING, &signal, DBUS_TYPE_INVALID)) {
1583 pa_dbus_send_error(conn, msg, DBUS_ERROR_INVALID_ARGS, "%s", error.message);
1584 dbus_error_free(&error);
1585 return;
1586 }
1587
1588 pa_dbus_protocol_remove_signal_listener(c->dbus_protocol, conn, *signal ? signal : NULL);
1589
1590 pa_dbus_send_empty_reply(conn, msg);
1591 }
1592
1593 static void subscription_cb(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
1594 pa_dbusiface_core *c = userdata;
1595 pa_dbusiface_card *card_iface = NULL;
1596 pa_dbusiface_device *device_iface = NULL;
1597 pa_dbusiface_stream *stream_iface = NULL;
1598 pa_dbusiface_sample *sample_iface = NULL;
1599 pa_dbusiface_module *module_iface = NULL;
1600 pa_dbusiface_client *client_iface = NULL;
1601 DBusMessage *signal = NULL;
1602 const char *object_path = NULL;
1603 pa_sink *new_fallback_sink = NULL;
1604 pa_source *new_fallback_source = NULL;
1605
1606 pa_assert(c);
1607
1608 switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
1609 case PA_SUBSCRIPTION_EVENT_SERVER:
1610 new_fallback_sink = pa_namereg_get_default_sink(core);
1611 new_fallback_source = pa_namereg_get_default_source(core);
1612
1613 if (c->fallback_sink != new_fallback_sink) {
1614 if (c->fallback_sink)
1615 pa_sink_unref(c->fallback_sink);
1616 c->fallback_sink = new_fallback_sink ? pa_sink_ref(new_fallback_sink) : NULL;
1617
1618 if (new_fallback_sink
1619 && (device_iface = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(new_fallback_sink->index)))) {
1620 object_path = pa_dbusiface_device_get_path(device_iface);
1621
1622 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1623 PA_DBUS_CORE_INTERFACE,
1624 signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
1625 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1626 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1627 dbus_message_unref(signal);
1628 signal = NULL;
1629 }
1630 }
1631
1632 if (c->fallback_source != new_fallback_source) {
1633 if (c->fallback_source)
1634 pa_source_unref(c->fallback_source);
1635 c->fallback_source = new_fallback_source ? pa_source_ref(new_fallback_source) : NULL;
1636
1637 if (new_fallback_source
1638 && (device_iface = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(new_fallback_source->index)))) {
1639 object_path = pa_dbusiface_device_get_path(device_iface);
1640
1641 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1642 PA_DBUS_CORE_INTERFACE,
1643 signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
1644 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1645 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1646 dbus_message_unref(signal);
1647 signal = NULL;
1648 }
1649 }
1650 break;
1651
1652 case PA_SUBSCRIPTION_EVENT_CARD:
1653 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1654 if (!(card_iface = pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(idx)))) {
1655 pa_card *card = NULL;
1656
1657 if (!(card = pa_idxset_get_by_index(core->cards, idx)))
1658 return; /* The card was removed immediately after creation. */
1659
1660 card_iface = pa_dbusiface_card_new(c, card);
1661 pa_hashmap_put(c->cards, PA_UINT32_TO_PTR(idx), card_iface);
1662 }
1663
1664 object_path = pa_dbusiface_card_get_path(card_iface);
1665
1666 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1667 PA_DBUS_CORE_INTERFACE,
1668 signals[SIGNAL_NEW_CARD].name)));
1669 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1670
1671 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1672 if (!(card_iface = pa_hashmap_remove(c->cards, PA_UINT32_TO_PTR(idx))))
1673 return;
1674
1675 object_path = pa_dbusiface_card_get_path(card_iface);
1676
1677 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1678 PA_DBUS_CORE_INTERFACE,
1679 signals[SIGNAL_CARD_REMOVED].name)));
1680 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1681
1682 pa_dbusiface_card_free(card_iface);
1683 }
1684 break;
1685
1686 case PA_SUBSCRIPTION_EVENT_SINK:
1687 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1688 pa_sink *sink = NULL;
1689
1690 if (!(sink = pa_idxset_get_by_index(core->sinks, idx)))
1691 return; /* The sink was removed immediately after creation. */
1692
1693 if (!(device_iface = pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(idx)))) {
1694 device_iface = pa_dbusiface_device_new_sink(c, sink);
1695 pa_hashmap_put(c->sinks_by_index, PA_UINT32_TO_PTR(idx), device_iface);
1696 pa_hashmap_put(c->sinks_by_path, pa_dbusiface_device_get_path(device_iface), device_iface);
1697 }
1698
1699 object_path = pa_dbusiface_device_get_path(device_iface);
1700
1701 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1702 PA_DBUS_CORE_INTERFACE,
1703 signals[SIGNAL_NEW_SINK].name)));
1704 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1705
1706 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1707 dbus_message_unref(signal);
1708 signal = NULL;
1709
1710 if (c->fallback_sink && pa_streq(c->fallback_sink->name, sink->name)) {
1711 /* We have got default sink change event, but at that point
1712 * the D-Bus sink object wasn't created yet. Now that the
1713 * object is created, let's send the fallback sink change
1714 * signal. */
1715 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1716 PA_DBUS_CORE_INTERFACE,
1717 signals[SIGNAL_FALLBACK_SINK_UPDATED].name)));
1718 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1719
1720 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1721 dbus_message_unref(signal);
1722 signal = NULL;
1723 }
1724
1725 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1726 if (!(device_iface = pa_hashmap_remove(c->sinks_by_index, PA_UINT32_TO_PTR(idx))))
1727 return;
1728
1729 object_path = pa_dbusiface_device_get_path(device_iface);
1730 pa_assert_se(pa_hashmap_remove(c->sinks_by_path, object_path));
1731
1732 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1733 PA_DBUS_CORE_INTERFACE,
1734 signals[SIGNAL_SINK_REMOVED].name)));
1735 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1736
1737 pa_dbusiface_device_free(device_iface);
1738 }
1739 break;
1740
1741 case PA_SUBSCRIPTION_EVENT_SOURCE:
1742 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1743 pa_source *source = pa_idxset_get_by_index(core->sources, idx);
1744
1745 if (!(source = pa_idxset_get_by_index(core->sources, idx)))
1746 return; /* The source was removed immediately after creation. */
1747
1748 if (!(device_iface = pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(idx)))) {
1749 device_iface = pa_dbusiface_device_new_source(c, source);
1750 pa_hashmap_put(c->sources_by_index, PA_UINT32_TO_PTR(idx), device_iface);
1751 pa_hashmap_put(c->sources_by_path, pa_dbusiface_device_get_path(device_iface), device_iface);
1752 }
1753
1754 object_path = pa_dbusiface_device_get_path(device_iface);
1755
1756 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1757 PA_DBUS_CORE_INTERFACE,
1758 signals[SIGNAL_NEW_SOURCE].name)));
1759 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1760
1761 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1762 dbus_message_unref(signal);
1763 signal = NULL;
1764
1765 if (c->fallback_source && pa_streq(c->fallback_source->name, source->name)) {
1766 /* We have got default source change event, but at that
1767 * point the D-Bus source object wasn't created yet. Now
1768 * that the object is created, let's send the fallback
1769 * source change signal. */
1770 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1771 PA_DBUS_CORE_INTERFACE,
1772 signals[SIGNAL_FALLBACK_SOURCE_UPDATED].name)));
1773 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1774
1775 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1776 dbus_message_unref(signal);
1777 signal = NULL;
1778 }
1779
1780 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1781 if (!(device_iface = pa_hashmap_remove(c->sources_by_index, PA_UINT32_TO_PTR(idx))))
1782 return;
1783
1784 object_path = pa_dbusiface_device_get_path(device_iface);
1785 pa_assert_se(pa_hashmap_remove(c->sources_by_path, object_path));
1786
1787 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1788 PA_DBUS_CORE_INTERFACE,
1789 signals[SIGNAL_SOURCE_REMOVED].name)));
1790 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1791
1792 pa_dbusiface_device_free(device_iface);
1793 }
1794 break;
1795
1796 case PA_SUBSCRIPTION_EVENT_SINK_INPUT:
1797 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1798 pa_sink_input *sink_input = NULL;
1799
1800 if (!(sink_input = pa_idxset_get_by_index(core->sink_inputs, idx)))
1801 return; /* The sink input was removed immediately after creation. */
1802
1803 if (!(stream_iface = pa_hashmap_get(c->playback_streams, PA_UINT32_TO_PTR(idx)))) {
1804 stream_iface = pa_dbusiface_stream_new_playback(c, sink_input);
1805 pa_hashmap_put(c->playback_streams, PA_UINT32_TO_PTR(idx), stream_iface);
1806 }
1807
1808 object_path = pa_dbusiface_stream_get_path(stream_iface);
1809
1810 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1811 PA_DBUS_CORE_INTERFACE,
1812 signals[SIGNAL_NEW_PLAYBACK_STREAM].name)));
1813 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1814
1815 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1816 if (!(stream_iface = pa_hashmap_remove(c->playback_streams, PA_UINT32_TO_PTR(idx))))
1817 return;
1818
1819 object_path = pa_dbusiface_stream_get_path(stream_iface);
1820
1821 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1822 PA_DBUS_CORE_INTERFACE,
1823 signals[SIGNAL_PLAYBACK_STREAM_REMOVED].name)));
1824 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1825
1826 pa_dbusiface_stream_free(stream_iface);
1827 }
1828 break;
1829
1830 case PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT:
1831 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1832 pa_source_output *source_output = NULL;
1833
1834 if (!(source_output = pa_idxset_get_by_index(core->source_outputs, idx)))
1835 return; /* The source output was removed immediately after creation. */
1836
1837 if (!(stream_iface = pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(idx)))) {
1838 stream_iface = pa_dbusiface_stream_new_record(c, source_output);
1839 pa_hashmap_put(c->record_streams, PA_UINT32_TO_PTR(idx), stream_iface);
1840 }
1841
1842 object_path = pa_dbusiface_stream_get_path(stream_iface);
1843
1844 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1845 PA_DBUS_CORE_INTERFACE,
1846 signals[SIGNAL_NEW_RECORD_STREAM].name)));
1847 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1848
1849 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1850 if (!(stream_iface = pa_hashmap_remove(c->record_streams, PA_UINT32_TO_PTR(idx))))
1851 return;
1852
1853 object_path = pa_dbusiface_stream_get_path(stream_iface);
1854
1855 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1856 PA_DBUS_CORE_INTERFACE,
1857 signals[SIGNAL_RECORD_STREAM_REMOVED].name)));
1858 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1859
1860 pa_dbusiface_stream_free(stream_iface);
1861 }
1862 break;
1863
1864 case PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE:
1865 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1866 pa_scache_entry *sample = NULL;
1867
1868 if (!(sample = pa_idxset_get_by_index(core->scache, idx)))
1869 return; /* The sample was removed immediately after creation. */
1870
1871 if (!(sample_iface = pa_hashmap_get(c->samples, PA_UINT32_TO_PTR(idx)))) {
1872 sample_iface = pa_dbusiface_sample_new(c, sample);
1873 pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), sample_iface);
1874 }
1875
1876 object_path = pa_dbusiface_sample_get_path(sample_iface);
1877
1878 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1879 PA_DBUS_CORE_INTERFACE,
1880 signals[SIGNAL_NEW_SAMPLE].name)));
1881 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1882
1883 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1884 if (!(sample_iface = pa_hashmap_remove(c->samples, PA_UINT32_TO_PTR(idx))))
1885 return;
1886
1887 object_path = pa_dbusiface_sample_get_path(sample_iface);
1888
1889 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1890 PA_DBUS_CORE_INTERFACE,
1891 signals[SIGNAL_SAMPLE_REMOVED].name)));
1892 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1893
1894 pa_dbusiface_sample_free(sample_iface);
1895 }
1896 break;
1897
1898 case PA_SUBSCRIPTION_EVENT_MODULE:
1899 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1900 pa_module *module = NULL;
1901
1902 if (!(module = pa_idxset_get_by_index(core->modules, idx)))
1903 return; /* The module was removed immediately after creation. */
1904
1905 if (!(module_iface = pa_hashmap_get(c->modules, PA_UINT32_TO_PTR(idx)))) {
1906 module_iface = pa_dbusiface_module_new(module);
1907 pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(idx), module_iface);
1908 }
1909
1910 object_path = pa_dbusiface_module_get_path(module_iface);
1911
1912 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1913 PA_DBUS_CORE_INTERFACE,
1914 signals[SIGNAL_NEW_MODULE].name)));
1915 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1916
1917 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1918 if (!(module_iface = pa_hashmap_remove(c->modules, PA_UINT32_TO_PTR(idx))))
1919 return;
1920
1921 object_path = pa_dbusiface_module_get_path(module_iface);
1922
1923 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1924 PA_DBUS_CORE_INTERFACE,
1925 signals[SIGNAL_MODULE_REMOVED].name)));
1926 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1927
1928 pa_dbusiface_module_free(module_iface);
1929 }
1930 break;
1931
1932 case PA_SUBSCRIPTION_EVENT_CLIENT:
1933 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
1934 pa_client *client = NULL;
1935
1936 if (!(client = pa_idxset_get_by_index(core->clients, idx)))
1937 return; /* The client was removed immediately after creation. */
1938
1939 if (!(client_iface = pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(idx)))) {
1940 client_iface = pa_dbusiface_client_new(c, client);
1941 pa_hashmap_put(c->clients, PA_UINT32_TO_PTR(idx), client_iface);
1942 }
1943
1944 object_path = pa_dbusiface_client_get_path(client_iface);
1945
1946 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1947 PA_DBUS_CORE_INTERFACE,
1948 signals[SIGNAL_NEW_CLIENT].name)));
1949 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1950
1951 } else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
1952 if (!(client_iface = pa_hashmap_remove(c->clients, PA_UINT32_TO_PTR(idx))))
1953 return;
1954
1955 object_path = pa_dbusiface_client_get_path(client_iface);
1956
1957 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1958 PA_DBUS_CORE_INTERFACE,
1959 signals[SIGNAL_CLIENT_REMOVED].name)));
1960 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_OBJECT_PATH, &object_path, DBUS_TYPE_INVALID));
1961
1962 pa_dbusiface_client_free(client_iface);
1963 }
1964 break;
1965 }
1966
1967 if (signal) {
1968 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1969 dbus_message_unref(signal);
1970 }
1971 }
1972
1973 static pa_hook_result_t extension_registered_cb(void *hook_data, void *call_data, void *slot_data) {
1974 pa_dbusiface_core *c = slot_data;
1975 const char *ext_name = call_data;
1976 DBusMessage *signal = NULL;
1977
1978 pa_assert(c);
1979 pa_assert(ext_name);
1980
1981 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
1982 PA_DBUS_CORE_INTERFACE,
1983 signals[SIGNAL_NEW_EXTENSION].name)));
1984 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
1985
1986 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
1987 dbus_message_unref(signal);
1988
1989 return PA_HOOK_OK;
1990 }
1991
1992 static pa_hook_result_t extension_unregistered_cb(void *hook_data, void *call_data, void *slot_data) {
1993 pa_dbusiface_core *c = slot_data;
1994 const char *ext_name = call_data;
1995 DBusMessage *signal = NULL;
1996
1997 pa_assert(c);
1998 pa_assert(ext_name);
1999
2000 pa_assert_se((signal = dbus_message_new_signal(PA_DBUS_CORE_OBJECT_PATH,
2001 PA_DBUS_CORE_INTERFACE,
2002 signals[SIGNAL_EXTENSION_REMOVED].name)));
2003 pa_assert_se(dbus_message_append_args(signal, DBUS_TYPE_STRING, &ext_name, DBUS_TYPE_INVALID));
2004
2005 pa_dbus_protocol_send_signal(c->dbus_protocol, signal);
2006 dbus_message_unref(signal);
2007
2008 return PA_HOOK_OK;
2009 }
2010
2011 pa_dbusiface_core *pa_dbusiface_core_new(pa_core *core) {
2012 pa_dbusiface_core *c;
2013 pa_card *card;
2014 pa_sink *sink;
2015 pa_source *source;
2016 pa_dbusiface_device *device;
2017 pa_sink_input *sink_input;
2018 pa_source_output *source_output;
2019 pa_scache_entry *sample;
2020 pa_module *module;
2021 pa_client *client;
2022 uint32_t idx;
2023
2024 pa_assert(core);
2025
2026 c = pa_xnew(pa_dbusiface_core, 1);
2027 c->core = pa_core_ref(core);
2028 c->subscription = pa_subscription_new(core, PA_SUBSCRIPTION_MASK_ALL, subscription_cb, c);
2029 c->dbus_protocol = pa_dbus_protocol_get(core);
2030 c->cards = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2031 c->sinks_by_index = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2032 c->sinks_by_path = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2033 c->sources_by_index = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2034 c->sources_by_path = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
2035 c->playback_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2036 c->record_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2037 c->samples = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2038 c->modules = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2039 c->clients = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
2040 c->fallback_sink = pa_namereg_get_default_sink(core);
2041 c->fallback_source = pa_namereg_get_default_source(core);
2042 c->extension_registered_slot = pa_dbus_protocol_hook_connect(c->dbus_protocol,
2043 PA_DBUS_PROTOCOL_HOOK_EXTENSION_REGISTERED,
2044 PA_HOOK_NORMAL,
2045 extension_registered_cb,
2046 c);
2047 c->extension_unregistered_slot = pa_dbus_protocol_hook_connect(c->dbus_protocol,
2048 PA_DBUS_PROTOCOL_HOOK_EXTENSION_UNREGISTERED,
2049 PA_HOOK_NORMAL,
2050 extension_unregistered_cb,
2051 c);
2052 c->memstats = pa_dbusiface_memstats_new(c, core);
2053
2054 if (c->fallback_sink)
2055 pa_sink_ref(c->fallback_sink);
2056 if (c->fallback_source)
2057 pa_source_ref(c->fallback_source);
2058
2059 PA_IDXSET_FOREACH(card, core->cards, idx)
2060 pa_hashmap_put(c->cards, PA_UINT32_TO_PTR(idx), pa_dbusiface_card_new(c, card));
2061
2062 PA_IDXSET_FOREACH(sink, core->sinks, idx) {
2063 device = pa_dbusiface_device_new_sink(c, sink);
2064 pa_hashmap_put(c->sinks_by_index, PA_UINT32_TO_PTR(idx), device);
2065 pa_hashmap_put(c->sinks_by_path, pa_dbusiface_device_get_path(device), device);
2066 }
2067
2068 PA_IDXSET_FOREACH(source, core->sources, idx) {
2069 device = pa_dbusiface_device_new_source(c, source);
2070 pa_hashmap_put(c->sources_by_index, PA_UINT32_TO_PTR(idx), device);
2071 pa_hashmap_put(c->sources_by_path, pa_dbusiface_device_get_path(device), device);
2072 }
2073
2074 PA_IDXSET_FOREACH(sink_input, core->sink_inputs, idx)
2075 pa_hashmap_put(c->playback_streams, PA_UINT32_TO_PTR(idx), pa_dbusiface_stream_new_playback(c, sink_input));
2076
2077 PA_IDXSET_FOREACH(source_output, core->source_outputs, idx)
2078 pa_hashmap_put(c->record_streams, PA_UINT32_TO_PTR(idx), pa_dbusiface_stream_new_record(c, source_output));
2079
2080 PA_IDXSET_FOREACH(sample, core->scache, idx)
2081 pa_hashmap_put(c->samples, PA_UINT32_TO_PTR(idx), pa_dbusiface_sample_new(c, sample));
2082
2083 PA_IDXSET_FOREACH(module, core->modules, idx)
2084 pa_hashmap_put(c->modules, PA_UINT32_TO_PTR(idx), pa_dbusiface_module_new(module));
2085
2086 PA_IDXSET_FOREACH(client, core->clients, idx)
2087 pa_hashmap_put(c->clients, PA_UINT32_TO_PTR(idx), pa_dbusiface_client_new(c, client));
2088
2089 pa_assert_se(pa_dbus_protocol_add_interface(c->dbus_protocol, PA_DBUS_CORE_OBJECT_PATH, &core_interface_info, c) >= 0);
2090
2091 return c;
2092 }
2093
2094 static void free_card_cb(void *p, void *userdata) {
2095 pa_dbusiface_card *c = p;
2096
2097 pa_assert(c);
2098
2099 pa_dbusiface_card_free(c);
2100 }
2101
2102 static void free_device_cb(void *p, void *userdata) {
2103 pa_dbusiface_device *d = p;
2104
2105 pa_assert(d);
2106
2107 pa_dbusiface_device_free(d);
2108 }
2109
2110 static void free_stream_cb(void *p, void *userdata) {
2111 pa_dbusiface_stream *s = p;
2112
2113 pa_assert(s);
2114
2115 pa_dbusiface_stream_free(s);
2116 }
2117
2118 static void free_sample_cb(void *p, void *userdata) {
2119 pa_dbusiface_sample *s = p;
2120
2121 pa_assert(s);
2122
2123 pa_dbusiface_sample_free(s);
2124 }
2125
2126 static void free_module_cb(void *p, void *userdata) {
2127 pa_dbusiface_module *m = p;
2128
2129 pa_assert(m);
2130
2131 pa_dbusiface_module_free(m);
2132 }
2133
2134 static void free_client_cb(void *p, void *userdata) {
2135 pa_dbusiface_client *c = p;
2136
2137 pa_assert(c);
2138
2139 pa_dbusiface_client_free(c);
2140 }
2141
2142 void pa_dbusiface_core_free(pa_dbusiface_core *c) {
2143 pa_assert(c);
2144
2145 pa_assert_se(pa_dbus_protocol_remove_interface(c->dbus_protocol, PA_DBUS_CORE_OBJECT_PATH, core_interface_info.name) >= 0);
2146
2147 pa_subscription_free(c->subscription);
2148 pa_hashmap_free(c->cards, free_card_cb, NULL);
2149 pa_hashmap_free(c->sinks_by_index, free_device_cb, NULL);
2150 pa_hashmap_free(c->sinks_by_path, NULL, NULL);
2151 pa_hashmap_free(c->sources_by_index, free_device_cb, NULL);
2152 pa_hashmap_free(c->sources_by_path, NULL, NULL);
2153 pa_hashmap_free(c->playback_streams, free_stream_cb, NULL);
2154 pa_hashmap_free(c->record_streams, free_stream_cb, NULL);
2155 pa_hashmap_free(c->samples, free_sample_cb, NULL);
2156 pa_hashmap_free(c->modules, free_module_cb, NULL);
2157 pa_hashmap_free(c->clients, free_client_cb, NULL);
2158 pa_hook_slot_free(c->extension_registered_slot);
2159 pa_hook_slot_free(c->extension_unregistered_slot);
2160 pa_dbusiface_memstats_free(c->memstats);
2161
2162 if (c->fallback_sink)
2163 pa_sink_unref(c->fallback_sink);
2164 if (c->fallback_source)
2165 pa_source_unref(c->fallback_source);
2166
2167 pa_dbus_protocol_unref(c->dbus_protocol);
2168 pa_core_unref(c->core);
2169
2170 pa_xfree(c);
2171 }
2172
2173 const char *pa_dbusiface_core_get_card_path(pa_dbusiface_core *c, const pa_card *card) {
2174 pa_assert(c);
2175 pa_assert(card);
2176
2177 return pa_dbusiface_card_get_path(pa_hashmap_get(c->cards, PA_UINT32_TO_PTR(card->index)));
2178 }
2179
2180 const char *pa_dbusiface_core_get_sink_path(pa_dbusiface_core *c, const pa_sink *sink) {
2181 pa_assert(c);
2182 pa_assert(sink);
2183
2184 return pa_dbusiface_device_get_path(pa_hashmap_get(c->sinks_by_index, PA_UINT32_TO_PTR(sink->index)));
2185 }
2186
2187 const char *pa_dbusiface_core_get_source_path(pa_dbusiface_core *c, const pa_source *source) {
2188 pa_assert(c);
2189 pa_assert(source);
2190
2191 return pa_dbusiface_device_get_path(pa_hashmap_get(c->sources_by_index, PA_UINT32_TO_PTR(source->index)));
2192 }
2193
2194 const char *pa_dbusiface_core_get_playback_stream_path(pa_dbusiface_core *c, const pa_sink_input *sink_input) {
2195 pa_assert(c);
2196 pa_assert(sink_input);
2197
2198 return pa_dbusiface_stream_get_path(pa_hashmap_get(c->playback_streams, PA_UINT32_TO_PTR(sink_input->index)));
2199 }
2200
2201 const char *pa_dbusiface_core_get_record_stream_path(pa_dbusiface_core *c, const pa_source_output *source_output) {
2202 pa_assert(c);
2203 pa_assert(source_output);
2204
2205 return pa_dbusiface_stream_get_path(pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(source_output->index)));
2206 }
2207
2208 const char *pa_dbusiface_core_get_module_path(pa_dbusiface_core *c, const pa_module *module) {
2209 pa_assert(c);
2210 pa_assert(module);
2211
2212 return pa_dbusiface_module_get_path(pa_hashmap_get(c->modules, PA_UINT32_TO_PTR(module->index)));
2213 }
2214
2215 const char *pa_dbusiface_core_get_client_path(pa_dbusiface_core *c, const pa_client *client) {
2216 pa_assert(c);
2217 pa_assert(client);
2218
2219 return pa_dbusiface_client_get_path(pa_hashmap_get(c->clients, PA_UINT32_TO_PTR(client->index)));
2220 }
2221
2222 pa_sink *pa_dbusiface_core_get_sink(pa_dbusiface_core *c, const char *object_path) {
2223 pa_dbusiface_device *device = NULL;
2224
2225 pa_assert(c);
2226 pa_assert(object_path);
2227
2228 device = pa_hashmap_get(c->sinks_by_path, object_path);
2229
2230 if (device)
2231 return pa_dbusiface_device_get_sink(device);
2232 else
2233 return NULL;
2234 }
2235
2236 pa_source *pa_dbusiface_core_get_source(pa_dbusiface_core *c, const char *object_path) {
2237 pa_dbusiface_device *device = NULL;
2238
2239 pa_assert(c);
2240 pa_assert(object_path);
2241
2242 device = pa_hashmap_get(c->sources_by_path, object_path);
2243
2244 if (device)
2245 return pa_dbusiface_device_get_source(device);
2246 else
2247 return NULL;
2248 }