]> code.delx.au - pulseaudio/blob - src/modules/module-rygel-media-server.c
delx.au / code / pulseaudio / blob


855d7bbf98af07e1d30908fa74363ff896300c62
[pulseaudio] / src / modules / module-rygel-media-server.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2005-2009 Lennart Poettering
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 <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30
31 #include <pulse/gccmacro.h>
32 #include <pulse/xmalloc.h>
33 #include <pulse/utf8.h>
34
35 #include <pulsecore/i18n.h>
36 #include <pulsecore/sink.h>
37 #include <pulsecore/source.h>
38 #include <pulsecore/core-util.h>
39 #include <pulsecore/log.h>
40 #include <pulsecore/macro.h>
41 #include <pulsecore/modargs.h>
42 #include <pulsecore/dbus-shared.h>
43 #include <pulsecore/namereg.h>
44 #include <pulsecore/mime-type.h>
45 #include <pulsecore/strbuf.h>
46 #include <pulsecore/protocol-http.h>
47 #include <pulsecore/parseaddr.h>
48
49 #include "module-rygel-media-server-symdef.h"
50
51 PA_MODULE_AUTHOR("Lennart Poettering");
52 PA_MODULE_DESCRIPTION("UPnP MediaServer Plugin for Rygel");
53 PA_MODULE_VERSION(PACKAGE_VERSION);
54 PA_MODULE_LOAD_ONCE(TRUE);
55 PA_MODULE_USAGE("display_name=<UPnP Media Server name>");
56
57 /* This implements http://live.gnome.org/Rygel/MediaServer2Spec */
58
59 #define SERVICE_NAME "org.gnome.UPnP.MediaServer2.PulseAudio"
60
61 #define OBJECT_ROOT "/org/gnome/UPnP/MediaServer2/PulseAudio"
62 #define OBJECT_SINKS "/org/gnome/UPnP/MediaServer2/PulseAudio/Sinks"
63 #define OBJECT_SOURCES "/org/gnome/UPnP/MediaServer2/PulseAudio/Sources"
64
65 #define CONTAINER_INTROSPECT_XML_PREFIX \
66 DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
67 "<node>" \
68 " <!-- If you are looking for documentation make sure to check out" \
69 " http://live.gnome.org/Rygel/MediaServer2Spec -->" \
70 " <interface name=\"org.gnome.UPnP.MediaContainer2\">" \
71 " <method name='ListChildren'>" \
72 " <arg direction='in' name='offset' type='u' />" \
73 " <arg direction='in' name='max' type='u' />" \
74 " <arg direction='in' name='filter' type='as' />" \
75 " <arg direction='out' type='aa{sv}' />" \
76 " </method>" \
77 " <method name='ListContainers'>" \
78 " <arg direction='in' name='offset' type='u' />" \
79 " <arg direction='in' name='max' type='u' />" \
80 " <arg direction='in' name='filter' type='as' />" \
81 " <arg direction='out' type='aa{sv}' />" \
82 " </method>" \
83 " <method name='ListItems'>" \
84 " <arg direction='in' name='offset' type='u' />" \
85 " <arg direction='in' name='max' type='u' />" \
86 " <arg direction='in' name='filter' type='as' />" \
87 " <arg direction='out' type='aa{sv}' />" \
88 " </method>" \
89 " <signal name=\"Updated\">" \
90 " <arg name=\"path\" type=\"o\"/>" \
91 " </signal>" \
92 " <property name=\"ChildCount\" type=\"u\" access=\"read\"/>" \
93 " <property name=\"ItemCount\" type=\"u\" access=\"read\"/>" \
94 " <property name=\"ContainerCount\" type=\"u\" access=\"read\"/>" \
95 " <property name=\"Searchable\" type=\"b\" access=\"read\"/>" \
96 " </interface>" \
97 " <interface name=\"org.gnome.UPnP.MediaObject2\">" \
98 " <property name=\"Parent\" type=\"s\" access=\"read\"/>" \
99 " <property name=\"Type\" type=\"s\" access=\"read\"/>" \
100 " <property name=\"Path\" type=\"s\" access=\"read\"/>" \
101 " <property name=\"DisplayName\" type=\"s\" access=\"read\"/>" \
102 " </interface>" \
103 " <interface name=\"org.freedesktop.DBus.Properties\">" \
104 " <method name=\"Get\">" \
105 " <arg name=\"interface\" direction=\"in\" type=\"s\"/>" \
106 " <arg name=\"property\" direction=\"in\" type=\"s\"/>" \
107 " <arg name=\"value\" direction=\"out\" type=\"v\"/>" \
108 " </method>" \
109 " <method name=\"GetAll\">" \
110 " <arg name=\"interface\" direction=\"in\" type=\"s\"/>" \
111 " <arg name=\"properties\" direction=\"out\" type=\"a{sv}\"/>" \
112 " </method>" \
113 " </interface>" \
114 " <interface name=\"org.freedesktop.DBus.Introspectable\">" \
115 " <method name=\"Introspect\">" \
116 " <arg name=\"data\" type=\"s\" direction=\"out\"/>" \
117 " </method>" \
118 " </interface>"
119
120 #define CONTAINER_INTROSPECT_XML_POSTFIX \
121 "</node>"
122
123 #define ROOT_INTROSPECT_XML \
124 CONTAINER_INTROSPECT_XML_PREFIX \
125 "<node name=\"Sinks\"/>" \
126 "<node name=\"Sources\"/>" \
127 CONTAINER_INTROSPECT_XML_POSTFIX
128
129 #define ITEM_INTROSPECT_XML \
130 DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
131 "<node>" \
132 " <!-- If you are looking for documentation make sure to check out" \
133 " http://live.gnome.org/Rygel/MediaProvider2Spec -->" \
134 " <interface name=\"org.gnome.UPnP.MediaItem2\">" \
135 " <property name=\"URLs\" type=\"as\" access=\"read\"/>" \
136 " <property name=\"MIMEType\" type=\"s\" access=\"read\"/>" \
137 " <property name=\"DLNAProfile\" type=\"s\" access=\"read\"/>" \
138 " </interface>" \
139 " <interface name=\"org.gnome.UPnP.MediaObject2\">" \
140 " <property name=\"Parent\" type=\"s\" access=\"read\"/>" \
141 " <property name=\"Type\" type=\"s\" access=\"read\"/>" \
142 " <property name=\"Path\" type=\"s\" access=\"read\"/>" \
143 " <property name=\"DisplayName\" type=\"s\" access=\"read\"/>" \
144 " </interface>" \
145 " <interface name=\"org.freedesktop.DBus.Properties\">" \
146 " <method name=\"Get\">" \
147 " <arg name=\"interface\" direction=\"in\" type=\"s\"/>" \
148 " <arg name=\"property\" direction=\"in\" type=\"s\"/>" \
149 " <arg name=\"value\" direction=\"out\" type=\"v\"/>" \
150 " </method>" \
151 " <method name=\"GetAll\">" \
152 " <arg name=\"interface\" direction=\"in\" type=\"s\"/>" \
153 " <arg name=\"properties\" direction=\"out\" type=\"a{sv}\"/>" \
154 " </method>" \
155 " </interface>" \
156 " <interface name=\"org.freedesktop.DBus.Introspectable\">" \
157 " <method name=\"Introspect\">" \
158 " <arg name=\"data\" type=\"s\" direction=\"out\"/>" \
159 " </method>" \
160 " </interface>" \
161 "</node>"
162
163
164 static const char* const valid_modargs[] = {
165 "display_name",
166 NULL
167 };
168
169 struct userdata {
170 pa_core *core;
171 pa_module *module;
172
173 pa_dbus_connection *bus;
174 pa_bool_t got_name:1;
175
176 char *display_name;
177
178 pa_hook_slot *source_new_slot, *source_unlink_slot;
179
180 pa_http_protocol *http;
181 };
182
183 static char *compute_url(const struct userdata *u, const char *name);
184
185 static void send_signal(struct userdata *u, pa_source *s) {
186 DBusMessage *m;
187 const char *parent;
188
189 pa_assert(u);
190 pa_source_assert_ref(s);
191
192 if (u->core->state == PA_CORE_SHUTDOWN)
193 return;
194
195 if (s->monitor_of)
196 parent = OBJECT_SINKS;
197 else
198 parent = OBJECT_SOURCES;
199
200 pa_assert_se(m = dbus_message_new_signal(parent, "org.gnome.UPnP.MediaContainer2", "Updated"));
201 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->bus), m, NULL));
202
203 dbus_message_unref(m);
204 }
205
206 static pa_hook_result_t source_new_or_unlink_cb(pa_core *c, pa_source *s, struct userdata *u) {
207 pa_assert(c);
208 pa_source_assert_ref(s);
209
210 send_signal(u, s);
211
212 return PA_HOOK_OK;
213 }
214
215 static pa_bool_t message_is_property_get(DBusMessage *m, const char *interface, const char *property) {
216 const char *i, *p;
217 DBusError error;
218
219 dbus_error_init(&error);
220
221 pa_assert(m);
222
223 if (!dbus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get"))
224 return FALSE;
225
226 if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &i, DBUS_TYPE_STRING, &p, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
227 dbus_error_free(&error);
228 return FALSE;
229 }
230
231 return pa_streq(i, interface) && pa_streq(p, property);
232 }
233
234 static pa_bool_t message_is_property_get_all(DBusMessage *m, const char *interface) {
235 const char *i;
236 DBusError error;
237
238 dbus_error_init(&error);
239
240 pa_assert(m);
241
242 if (!dbus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "GetAll"))
243 return FALSE;
244
245 if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &i, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
246 dbus_error_free(&error);
247 return FALSE;
248 }
249
250 return pa_streq(i, interface);
251 }
252
253 static void append_variant_object_array(DBusMessage *m, DBusMessageIter *iter, const char *path[], unsigned n) {
254 DBusMessageIter _iter, variant, array;
255 unsigned c;
256
257 pa_assert(m);
258 pa_assert(path);
259
260 if (!iter) {
261 dbus_message_iter_init_append(m, &_iter);
262 iter = &_iter;
263 }
264
265 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "ao", &variant));
266 pa_assert_se(dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, "o", &array));
267
268 for (c = 0; c < n; c++)
269 pa_assert_se(dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH, path + c));
270
271 pa_assert_se(dbus_message_iter_close_container(&variant, &array));
272 pa_assert_se(dbus_message_iter_close_container(iter, &variant));
273 }
274
275 static void append_variant_string(DBusMessage *m, DBusMessageIter *iter, const char *s) {
276 DBusMessageIter _iter, sub;
277
278 pa_assert(m);
279 pa_assert(s);
280
281 if (!iter) {
282 dbus_message_iter_init_append(m, &_iter);
283 iter = &_iter;
284 }
285
286 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "s", &sub));
287 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s));
288 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
289 }
290
291 static void append_variant_object(DBusMessage *m, DBusMessageIter *iter, const char *s) {
292 DBusMessageIter _iter, sub;
293
294 pa_assert(m);
295 pa_assert(s);
296
297 if (!iter) {
298 dbus_message_iter_init_append(m, &_iter);
299 iter = &_iter;
300 }
301
302 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "o", &sub));
303 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &s));
304 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
305 }
306
307 static void append_variant_unsigned(DBusMessage *m, DBusMessageIter *iter, unsigned u) {
308 DBusMessageIter _iter, sub;
309
310 pa_assert(m);
311
312 if (!iter) {
313 dbus_message_iter_init_append(m, &_iter);
314 iter = &_iter;
315 }
316
317 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "u", &sub));
318 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &u));
319 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
320 }
321
322 static void append_variant_boolean(DBusMessage *m, DBusMessageIter *iter, dbus_bool_t b) {
323 DBusMessageIter _iter, sub;
324
325 pa_assert(m);
326
327 if (!iter) {
328 dbus_message_iter_init_append(m, &_iter);
329 iter = &_iter;
330 }
331
332 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "b", &sub));
333 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_BOOLEAN, &b));
334 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
335 }
336
337 static void append_variant_urls(DBusMessage *m, DBusMessageIter *iter, const struct userdata *u, pa_sink *sink, pa_source *source) {
338 DBusMessageIter _iter, sub, array;
339 char *url;
340
341 pa_assert(m);
342 pa_assert(u);
343 pa_assert(sink || source);
344
345 if (!iter) {
346 dbus_message_iter_init_append(m, &_iter);
347 iter = &_iter;
348 }
349
350 url = compute_url(u, sink ? sink->monitor_source->name : source->name);
351
352 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "as", &sub));
353 pa_assert_se(dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "s", &array));
354 pa_assert_se(dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &url));
355 pa_assert_se(dbus_message_iter_close_container(&sub, &array));
356 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
357
358 pa_xfree(url);
359 }
360
361 static void append_variant_mime_type(DBusMessage *m, DBusMessageIter *iter, pa_sink *sink, pa_source *source) {
362 char *mime_type;
363
364 pa_assert(sink || source);
365
366 if (sink)
367 mime_type = pa_sample_spec_to_mime_type_mimefy(&sink->sample_spec, &sink->channel_map);
368 else
369 mime_type = pa_sample_spec_to_mime_type_mimefy(&source->sample_spec, &source->channel_map);
370
371 append_variant_string(m, iter, mime_type);
372
373 pa_xfree(mime_type);
374 }
375
376 static void append_variant_item_display_name(DBusMessage *m, DBusMessageIter *iter, pa_sink *sink, pa_source *source) {
377 const char *display_name;
378
379 pa_assert(sink || source);
380
381 display_name = pa_strna(pa_proplist_gets(sink ? sink->proplist : source->proplist, PA_PROP_DEVICE_DESCRIPTION));
382 append_variant_string(m, iter, display_name);
383 }
384
385 PA_GCC_UNUSED
386 static void append_property_dict_entry_object_array(DBusMessage *m, DBusMessageIter *iter, const char *name, const char *path[], unsigned n) {
387 DBusMessageIter sub;
388
389 pa_assert(iter);
390
391 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
392 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name));
393 append_variant_object_array(m, &sub, path, n);
394 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
395 }
396
397 static void append_property_dict_entry_string(DBusMessage *m, DBusMessageIter *iter, const char *name, const char *value) {
398 DBusMessageIter sub;
399
400 pa_assert(iter);
401
402 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
403 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name));
404 append_variant_string(m, &sub, value);
405 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
406 }
407
408 static void append_property_dict_entry_object(DBusMessage *m, DBusMessageIter *iter, const char *name, const char *value) {
409 DBusMessageIter sub;
410
411 pa_assert(iter);
412
413 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
414 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name));
415 append_variant_object(m, &sub, value);
416 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
417 }
418
419 static void append_property_dict_entry_unsigned(DBusMessage *m, DBusMessageIter *iter, const char *name, unsigned u) {
420 DBusMessageIter sub;
421
422 pa_assert(iter);
423
424 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
425 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name));
426 append_variant_unsigned(m, &sub, u);
427 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
428 }
429
430 static void append_property_dict_entry_boolean(DBusMessage *m, DBusMessageIter *iter, const char *name, dbus_bool_t b) {
431 DBusMessageIter sub;
432
433 pa_assert(iter);
434
435 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
436 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name));
437 append_variant_boolean(m, &sub, b);
438 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
439 }
440
441 static void append_property_dict_entry_urls(DBusMessage *m, DBusMessageIter *iter, const struct userdata *u, pa_sink *sink, pa_source *source) {
442 DBusMessageIter sub;
443 const char *property_name = "URLs";
444
445 pa_assert(iter);
446
447 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
448 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &property_name));
449 append_variant_urls(m, &sub, u, sink, source);
450 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
451 }
452
453 static void append_property_dict_entry_mime_type(DBusMessage *m, DBusMessageIter *iter, pa_sink *sink, pa_source *source) {
454 DBusMessageIter sub;
455 const char *property_name = "MIMEType";
456
457 pa_assert(iter);
458
459 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
460 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &property_name));
461 append_variant_mime_type(m, &sub, sink, source);
462 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
463 }
464
465 static void append_property_dict_entry_item_display_name(DBusMessage *m, DBusMessageIter *iter, pa_sink *sink, pa_source *source) {
466 DBusMessageIter sub;
467 const char *property_name = "DisplayName";
468
469 pa_assert(iter);
470
471 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
472 pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &property_name));
473 append_variant_item_display_name(m, &sub, sink, source);
474 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
475 }
476
477 static pa_bool_t get_mediacontainer2_list_args(DBusMessage *m, unsigned *offset, unsigned *max_entries, char ***filter, int *filter_len) {
478 DBusError error;
479
480 dbus_error_init(&error);
481
482 pa_assert(m);
483 pa_assert(offset);
484 pa_assert(max_entries);
485 pa_assert(filter);
486
487 if (!dbus_message_get_args(m, &error, DBUS_TYPE_UINT32, offset, DBUS_TYPE_UINT32, max_entries, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, filter, filter_len, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
488 dbus_error_free(&error);
489 return FALSE;
490 }
491
492 return TRUE;
493 }
494
495 static unsigned get_sinks_or_sources_count(const char *path, const struct userdata *u) {
496 unsigned n, k;
497
498 n = pa_idxset_size(u->core->sinks);
499 k = pa_idxset_size(u->core->sources);
500 pa_assert(k >= n);
501
502 return pa_streq(path, OBJECT_SINKS) ? n : k - n;
503 }
504
505 static void append_sink_or_source_container_mediaobject2_properties(DBusMessage *r, DBusMessageIter *sub, const char *path) {
506 append_property_dict_entry_object(r, sub, "Parent", OBJECT_ROOT);
507 append_property_dict_entry_string(r, sub, "Type", "container");
508 append_property_dict_entry_object(r, sub, "Path", path);
509 append_property_dict_entry_string(r, sub, "DisplayName",
510 pa_streq(path, OBJECT_SINKS) ?
511 _("Output Devices") :
512 _("Input Devices"));
513 }
514
515 static void append_sink_or_source_container_properties(
516 DBusMessage *r, DBusMessageIter *iter,
517 const char *path, const struct userdata *user_data,
518 char * const * filter, int filter_len) {
519
520 DBusMessageIter sub;
521
522 pa_assert(r);
523 pa_assert(iter);
524 pa_assert(path);
525 pa_assert(filter);
526
527 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
528
529 if (filter_len == 1 && (*filter)[0] == '*' && (*filter)[1] == '\0') {
530 append_sink_or_source_container_mediaobject2_properties(r, &sub, path);
531 append_property_dict_entry_unsigned(r, &sub, "ChildCount", get_sinks_or_sources_count(path, user_data));
532 append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
533 }
534 else {
535 for (int i = 0; i < filter_len; ++i) {
536 const char *property_name = filter[i];
537 if (pa_streq(property_name, "Parent")) {
538 append_property_dict_entry_object(r, &sub, "Parent", OBJECT_ROOT);
539 }
540 else if (pa_streq(property_name, "Type")) {
541 append_property_dict_entry_string(r, &sub, "Type", "container");
542 }
543 else if (pa_streq(property_name, "Path")) {
544 append_property_dict_entry_object(r, &sub, "Path", path);
545 }
546 else if (pa_streq(property_name, "DisplayName")) {
547 append_property_dict_entry_string(r, &sub, "DisplayName",
548 pa_streq(path, OBJECT_SINKS) ?
549 _("Output Devices") :
550 _("Input Devices"));
551 }
552 else if (pa_streq(property_name, "ChildCount")) {
553 append_property_dict_entry_unsigned(r, &sub, "ChildCount", get_sinks_or_sources_count(path, user_data));
554 }
555 else if (pa_streq(property_name, "Searchable")) {
556 append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
557 }
558 }
559 }
560
561 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
562 }
563
564 static void append_sink_or_source_item_mediaobject2_properties(DBusMessage *r, DBusMessageIter *sub, const char *path, pa_sink *sink, pa_source *source) {
565 append_property_dict_entry_object(r, sub, "Parent", sink ? OBJECT_SINKS : OBJECT_SOURCES);
566 append_property_dict_entry_string(r, sub, "Type", "audio");
567 append_property_dict_entry_object(r, sub, "Path", path);
568 append_property_dict_entry_item_display_name(r, sub, sink, source);
569 }
570
571 static void append_sink_or_source_item_properties(
572 DBusMessage *r, DBusMessageIter *iter,
573 const char *path, const struct userdata *user_data,
574 pa_sink *sink, pa_source *source,
575 char * const * filter, int filter_len) {
576
577 DBusMessageIter sub;
578
579 pa_assert(r);
580 pa_assert(iter);
581 pa_assert(path);
582 pa_assert(filter);
583 pa_assert(sink || source);
584
585 pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
586
587 if (filter_len == 1 && (*filter)[0] == '*' && (*filter)[1] == '\0') {
588 append_sink_or_source_item_mediaobject2_properties(r, &sub, path, sink, source);
589 append_property_dict_entry_urls(r, &sub, user_data, sink, source);
590 append_property_dict_entry_mime_type(r, &sub, sink, source);
591 append_property_dict_entry_string(r, &sub, "DLNAProfile", "LPCM");
592 }
593 else {
594 for (int i = 0; i < filter_len; ++i) {
595 const char *property_name = filter[i];
596 if (pa_streq(property_name, "Parent")) {
597 append_property_dict_entry_object(r, &sub, "Parent", sink ? OBJECT_SINKS : OBJECT_SOURCES);
598 }
599 else if (pa_streq(property_name, "Type")) {
600 append_property_dict_entry_string(r, &sub, "Type", "audio");
601 }
602 else if (pa_streq(property_name, "Path")) {
603 append_property_dict_entry_object(r, &sub, "Path", path);
604 }
605 else if (pa_streq(property_name, "DisplayName")) {
606 append_property_dict_entry_item_display_name(r, &sub, sink, source);
607 }
608 else if (pa_streq(property_name, "URLs")) {
609 append_property_dict_entry_urls(r, &sub, user_data, sink, source);
610 }
611 else if (pa_streq(property_name, "MIMEType")) {
612 append_property_dict_entry_mime_type(r, &sub, sink, source);
613 }
614 else if (pa_streq(property_name, "DLNAProfile")) {
615 append_property_dict_entry_string(r, &sub, "DLNAProfile", "LPCM");
616 }
617 }
618 }
619
620 pa_assert_se(dbus_message_iter_close_container(iter, &sub));
621 }
622
623 static const char *array_root_containers[] = { OBJECT_SINKS, OBJECT_SOURCES };
624 static const char *array_no_children[] = { };
625
626 static DBusHandlerResult root_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
627 struct userdata *u = userdata;
628 DBusMessage *r = NULL;
629
630 pa_assert(u);
631
632 if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "ChildCount")) {
633 pa_assert_se(r = dbus_message_new_method_return(m));
634 append_variant_unsigned(r, NULL, PA_ELEMENTSOF(array_root_containers));
635
636 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "ItemCount")) {
637 pa_assert_se(r = dbus_message_new_method_return(m));
638 append_variant_unsigned(r, NULL, PA_ELEMENTSOF(array_no_children));
639
640 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "ContainerCount")) {
641 pa_assert_se(r = dbus_message_new_method_return(m));
642 append_variant_unsigned(r, NULL, PA_ELEMENTSOF(array_root_containers));
643
644 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "Searchable")) {
645 pa_assert_se(r = dbus_message_new_method_return(m));
646 append_variant_boolean(r, NULL, FALSE);
647
648 } else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaContainer2")) {
649 DBusMessageIter iter, sub;
650
651 pa_assert_se(r = dbus_message_new_method_return(m));
652 dbus_message_iter_init_append(r, &iter);
653
654 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
655 append_property_dict_entry_unsigned(r, &sub, "ChildCount", PA_ELEMENTSOF(array_root_containers));
656 append_property_dict_entry_unsigned(r, &sub, "ItemCount", PA_ELEMENTSOF(array_no_children));
657 append_property_dict_entry_unsigned(r, &sub, "ContainerCount", PA_ELEMENTSOF(array_root_containers));
658 append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
659 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
660
661 } else if (dbus_message_is_method_call(m, "org.gnome.UPnP.MediaContainer2", "ListChildren")
662 || dbus_message_is_method_call(m, "org.gnome.UPnP.MediaContainer2", "ListContainers")) {
663 DBusMessageIter iter, sub;
664 unsigned offset, max;
665 char ** filter;
666 int filter_len;
667
668 pa_assert_se(r = dbus_message_new_method_return(m));
669
670 dbus_message_iter_init_append(r, &iter);
671 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "a{sv}", &sub));
672
673 if (get_mediacontainer2_list_args(m, &offset, &max, &filter, &filter_len)) {
674 unsigned end = (max != 0 && offset + max < PA_ELEMENTSOF(array_root_containers))
675 ? max + offset
676 : PA_ELEMENTSOF(array_root_containers);
677
678 for (unsigned i = offset; i < end; ++i) {
679 const char *container_path = array_root_containers[i];
680 append_sink_or_source_container_properties(r, &sub, container_path, u, filter, filter_len);
681 }
682
683 dbus_free_string_array(filter);
684 }
685
686 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
687
688 } else if (dbus_message_is_method_call(m, "org.gnome.UPnP.MediaContainer2", "ListItems")) {
689 DBusMessageIter iter, sub;
690
691 pa_assert_se(r = dbus_message_new_method_return(m));
692
693 dbus_message_iter_init_append(r, &iter);
694 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "a{sv}", &sub));
695 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
696
697 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Parent")) {
698 pa_assert_se(r = dbus_message_new_method_return(m));
699 append_variant_object(r, NULL, OBJECT_ROOT);
700
701 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Type")) {
702 pa_assert_se(r = dbus_message_new_method_return(m));
703 append_variant_string(r, NULL, "container");
704
705 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Path")) {
706 const char *path = dbus_message_get_path(m);
707
708 pa_assert_se(r = dbus_message_new_method_return(m));
709 append_variant_object(r, NULL, path);
710
711 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "DisplayName")) {
712 pa_assert_se(r = dbus_message_new_method_return(m));
713 append_variant_string(r, NULL, u->display_name);
714
715 } else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaObject2")) {
716 DBusMessageIter iter, sub;
717 const char *path = dbus_message_get_path(m);
718
719 pa_assert_se(r = dbus_message_new_method_return(m));
720 dbus_message_iter_init_append(r, &iter);
721
722 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
723 append_property_dict_entry_object(r, &sub, "Parent", OBJECT_ROOT);
724 append_property_dict_entry_string(r, &sub, "Type", "container");
725 append_property_dict_entry_object(r, &sub, "Path", path);
726 append_property_dict_entry_string(r, &sub, "DisplayName", u->display_name);
727 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
728
729 } else if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
730 const char *xml = ROOT_INTROSPECT_XML;
731
732 pa_assert_se(r = dbus_message_new_method_return(m));
733 pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID));
734
735 } else
736 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
737
738 if (r) {
739 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->bus), r, NULL));
740 dbus_message_unref(r);
741 }
742
743 return DBUS_HANDLER_RESULT_HANDLED;
744 }
745
746 static char *compute_url(const struct userdata *u, const char *name) {
747 pa_strlist *i;
748
749 pa_assert(u);
750 pa_assert(name);
751
752 for (i = pa_http_protocol_servers(u->http); i; i = pa_strlist_next(i)) {
753 pa_parsed_address a;
754
755 if (pa_parse_address(pa_strlist_data(i), &a) >= 0 &&
756 (a.type == PA_PARSED_ADDRESS_TCP4 ||
757 a.type == PA_PARSED_ADDRESS_TCP6 ||
758 a.type == PA_PARSED_ADDRESS_TCP_AUTO)) {
759
760 const char *address;
761 char *s;
762
763 if (pa_is_ip_address(a.path_or_host))
764 address = a.path_or_host;
765 else
766 address = "@ADDRESS@";
767
768 if (a.port <= 0)
769 a.port = 4714;
770
771 s = pa_sprintf_malloc("http://%s:%u/listen/source/%s", address, a.port, name);
772
773 pa_xfree(a.path_or_host);
774 return s;
775 }
776
777 pa_xfree(a.path_or_host);
778 }
779
780 return pa_sprintf_malloc("http://@ADDRESS@:4714/listen/source/%s", name);
781 }
782
783 static DBusHandlerResult sinks_and_sources_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
784 struct userdata *u = userdata;
785 DBusMessage *r = NULL;
786 const char *path;
787
788 pa_assert(u);
789
790 path = dbus_message_get_path(m);
791
792 if (pa_streq(path, OBJECT_SINKS) || pa_streq(path, OBJECT_SOURCES)) {
793
794 /* Container nodes */
795
796 if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "ChildCount")
797 || message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "ItemCount")) {
798 pa_assert_se(r = dbus_message_new_method_return(m));
799 append_variant_unsigned(r, NULL, get_sinks_or_sources_count(path, u));
800
801 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "ContainerCount")) {
802 pa_assert_se(r = dbus_message_new_method_return(m));
803 append_variant_unsigned(r, NULL, 0);
804
805 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "Searchable")) {
806 pa_assert_se(r = dbus_message_new_method_return(m));
807 append_variant_boolean(r, NULL, FALSE);
808
809 } else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaContainer2")) {
810 DBusMessageIter iter, sub;
811 unsigned item_count;
812
813 pa_assert_se(r = dbus_message_new_method_return(m));
814 dbus_message_iter_init_append(r, &iter);
815
816 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
817
818 item_count = get_sinks_or_sources_count(path, u);
819
820 append_property_dict_entry_unsigned(r, &sub, "ChildCount", item_count);
821 append_property_dict_entry_unsigned(r, &sub, "ItemCount", item_count);
822 append_property_dict_entry_unsigned(r, &sub, "ContainerCount", 0);
823 append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
824
825 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
826
827 } else if (dbus_message_is_method_call(m, "org.gnome.UPnP.MediaContainer2", "ListChildren")
828 || dbus_message_is_method_call(m, "org.gnome.UPnP.MediaContainer2", "ListItems")) {
829 DBusMessageIter iter, sub;
830 unsigned offset, max;
831 char **filter;
832 int filter_len;
833
834 pa_assert_se(r = dbus_message_new_method_return(m));
835
836 dbus_message_iter_init_append(r, &iter);
837 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "a{sv}", &sub));
838
839 if (get_mediacontainer2_list_args(m, &offset, &max, &filter, &filter_len)) {
840 unsigned end = (max != 0) ? max + offset : UINT_MAX;
841
842 if (pa_streq(path, OBJECT_SINKS)) {
843 pa_sink *sink;
844 char sink_path[sizeof(OBJECT_SINKS) + 32];
845 char *path_end = sink_path + sizeof(OBJECT_SINKS);
846 unsigned item_index = 0;
847 uint32_t idx;
848
849 strcpy(sink_path, OBJECT_SINKS "/");
850
851 PA_IDXSET_FOREACH(sink, u->core->sinks, idx) {
852 if (item_index >= offset && item_index < end) {
853 sprintf(path_end, "%u", sink->index);
854 append_sink_or_source_item_properties(r, &sub, sink_path, u, sink, NULL, filter, filter_len);
855 }
856 ++item_index;
857 }
858 } else {
859 pa_source *source;
860 char source_path[sizeof(OBJECT_SOURCES) + 32];
861 char *path_end = source_path + sizeof(OBJECT_SOURCES);
862 unsigned item_index = 0;
863 uint32_t idx;
864
865 strcpy(source_path, OBJECT_SOURCES "/");
866
867 PA_IDXSET_FOREACH(source, u->core->sources, idx)
868 if (!source->monitor_of) {
869 if (item_index >= offset && item_index < end) {
870 sprintf(path_end, "%u", source->index);
871 append_sink_or_source_item_properties(r, &sub, source_path, u, NULL, source, filter, filter_len);
872 }
873 ++item_index;
874 }
875 }
876
877 dbus_free_string_array(filter);
878 }
879
880 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
881
882 } else if (dbus_message_is_method_call(m, "org.gnome.UPnP.MediaContainer2", "ListContainers")) {
883 DBusMessageIter iter, sub;
884
885 pa_assert_se(r = dbus_message_new_method_return(m));
886
887 dbus_message_iter_init_append(r, &iter);
888 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "a{sv}", &sub));
889 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
890
891 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Parent")) {
892 pa_assert_se(r = dbus_message_new_method_return(m));
893 append_variant_object(r, NULL, OBJECT_ROOT);
894
895 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Type")) {
896 pa_assert_se(r = dbus_message_new_method_return(m));
897 append_variant_string(r, NULL, "container");
898
899 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Path")) {
900 pa_assert_se(r = dbus_message_new_method_return(m));
901 append_variant_object(r, NULL, path);
902
903 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "DisplayName")) {
904 pa_assert_se(r = dbus_message_new_method_return(m));
905 append_variant_string(r,
906 NULL,
907 pa_streq(path, OBJECT_SINKS) ?
908 _("Output Devices") :
909 _("Input Devices"));
910
911 } else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaObject2")) {
912 DBusMessageIter iter, sub;
913
914 pa_assert_se(r = dbus_message_new_method_return(m));
915
916 dbus_message_iter_init_append(r, &iter);
917 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
918 append_sink_or_source_container_mediaobject2_properties(r, &sub, path);
919 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
920
921 } else if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
922 pa_strbuf *sb;
923 char *xml;
924 uint32_t idx;
925
926 sb = pa_strbuf_new();
927 pa_strbuf_puts(sb, CONTAINER_INTROSPECT_XML_PREFIX);
928
929 if (pa_streq(path, OBJECT_SINKS)) {
930 pa_sink *sink;
931
932 PA_IDXSET_FOREACH(sink, u->core->sinks, idx)
933 pa_strbuf_printf(sb, "<node name=\"%u\"/>", sink->index);
934 } else {
935 pa_source *source;
936
937 PA_IDXSET_FOREACH(source, u->core->sources, idx)
938 if (!source->monitor_of)
939 pa_strbuf_printf(sb, "<node name=\"%u\"/>", source->index);
940 }
941
942 pa_strbuf_puts(sb, CONTAINER_INTROSPECT_XML_POSTFIX);
943 xml = pa_strbuf_tostring_free(sb);
944
945 pa_assert_se(r = dbus_message_new_method_return(m));
946 pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID));
947
948 pa_xfree(xml);
949 } else
950 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
951
952 } else {
953 pa_sink *sink = NULL;
954 pa_source *source = NULL;
955
956 /* Child nodes */
957
958 if (pa_startswith(path, OBJECT_SINKS "/"))
959 sink = pa_namereg_get(u->core, path + sizeof(OBJECT_SINKS), PA_NAMEREG_SINK);
960 else if (pa_startswith(path, OBJECT_SOURCES "/"))
961 source = pa_namereg_get(u->core, path + sizeof(OBJECT_SOURCES), PA_NAMEREG_SOURCE);
962
963 if (!sink && !source)
964 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
965
966 if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Parent")) {
967 pa_assert_se(r = dbus_message_new_method_return(m));
968 append_variant_object(r, NULL, sink ? OBJECT_SINKS : OBJECT_SOURCES);
969
970 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Type")) {
971 pa_assert_se(r = dbus_message_new_method_return(m));
972 append_variant_string(r, NULL, "audio");
973
974 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "Path")) {
975 pa_assert_se(r = dbus_message_new_method_return(m));
976 append_variant_object(r, NULL, path);
977
978 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaObject2", "DisplayName")) {
979 pa_assert_se(r = dbus_message_new_method_return(m));
980 append_variant_item_display_name(r, NULL, sink, source);
981
982 } else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaObject2")) {
983 DBusMessageIter iter, sub;
984
985 pa_assert_se(r = dbus_message_new_method_return(m));
986 dbus_message_iter_init_append(r, &iter);
987
988 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
989 append_sink_or_source_item_mediaobject2_properties(r, &sub, path, sink, source);
990 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
991
992 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaItem2", "MIMEType")) {
993 pa_assert_se(r = dbus_message_new_method_return(m));
994 append_variant_mime_type(r, NULL, sink, source);
995
996 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaItem2", "DLNAProfile")) {
997 pa_assert_se(r = dbus_message_new_method_return(m));
998 append_variant_string(r, NULL, "LPCM");
999
1000 } else if (message_is_property_get(m, "org.gnome.UPnP.MediaItem2", "URLs")) {
1001 pa_assert_se(r = dbus_message_new_method_return(m));
1002 append_variant_urls(r, NULL, u, sink, source);
1003
1004 } else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaItem2")) {
1005 DBusMessageIter iter, sub;
1006
1007 pa_assert_se(r = dbus_message_new_method_return(m));
1008 dbus_message_iter_init_append(r, &iter);
1009
1010 pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
1011
1012 append_property_dict_entry_mime_type(r, &sub, sink, source);
1013 append_property_dict_entry_string(r, &sub, "DLNAProfile", "LPCM");
1014 append_property_dict_entry_urls(r, &sub, u, sink, source);
1015
1016 pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
1017
1018 } else if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
1019 const char *xml =
1020 ITEM_INTROSPECT_XML;
1021
1022 pa_assert_se(r = dbus_message_new_method_return(m));
1023 pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID));
1024
1025 } else
1026 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1027 }
1028
1029 if (r) {
1030 pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->bus), r, NULL));
1031 dbus_message_unref(r);
1032 }
1033
1034 return DBUS_HANDLER_RESULT_HANDLED;
1035 }
1036
1037 int pa__init(pa_module *m) {
1038
1039 struct userdata *u;
1040 pa_modargs *ma = NULL;
1041 DBusError error;
1042 const char *t;
1043
1044 static const DBusObjectPathVTable vtable_root = {
1045 .message_function = root_handler,
1046 };
1047 static const DBusObjectPathVTable vtable_sinks_and_sources = {
1048 .message_function = sinks_and_sources_handler,
1049 };
1050
1051 dbus_error_init(&error);
1052
1053 if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
1054 pa_log("Failed to parse module arguments.");
1055 goto fail;
1056 }
1057
1058 m->userdata = u = pa_xnew0(struct userdata, 1);
1059 u->core = m->core;
1060 u->module = m;
1061 u->http = pa_http_protocol_get(u->core);
1062
1063 if ((t = pa_modargs_get_value(ma, "display_name", NULL)))
1064 u->display_name = pa_utf8_filter(t);
1065 else
1066 u->display_name = pa_xstrdup(_("Audio on @HOSTNAME@"));
1067
1068 u->source_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_LATE, (pa_hook_cb_t) source_new_or_unlink_cb, u);
1069 u->source_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], PA_HOOK_LATE, (pa_hook_cb_t) source_new_or_unlink_cb, u);
1070
1071 if (!(u->bus = pa_dbus_bus_get(m->core, DBUS_BUS_SESSION, &error))) {
1072 pa_log("Failed to get session bus connection: %s", error.message);
1073 goto fail;
1074 }
1075
1076 pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(u->bus), OBJECT_ROOT, &vtable_root, u));
1077 pa_assert_se(dbus_connection_register_fallback(pa_dbus_connection_get(u->bus), OBJECT_SINKS, &vtable_sinks_and_sources, u));
1078 pa_assert_se(dbus_connection_register_fallback(pa_dbus_connection_get(u->bus), OBJECT_SOURCES, &vtable_sinks_and_sources, u));
1079
1080 if (dbus_bus_request_name(pa_dbus_connection_get(u->bus), SERVICE_NAME, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
1081 pa_log("Failed to request service name " SERVICE_NAME ": %s", error.message);
1082 goto fail;
1083 }
1084
1085 u->got_name = TRUE;
1086
1087 pa_modargs_free(ma);
1088
1089 return 0;
1090
1091 fail:
1092 pa__done(m);
1093
1094 if (ma)
1095 pa_modargs_free(ma);
1096
1097 dbus_error_free(&error);
1098
1099 return -1;
1100 }
1101
1102 void pa__done(pa_module*m) {
1103 struct userdata*u;
1104 pa_assert(m);
1105
1106 if (!(u = m->userdata))
1107 return;
1108
1109 if (u->source_new_slot)
1110 pa_hook_slot_free(u->source_new_slot);
1111 if (u->source_unlink_slot)
1112 pa_hook_slot_free(u->source_unlink_slot);
1113
1114 if (u->bus) {
1115 DBusError error;
1116
1117 dbus_error_init(&error);
1118
1119 dbus_connection_unregister_object_path(pa_dbus_connection_get(u->bus), OBJECT_ROOT);
1120 dbus_connection_unregister_object_path(pa_dbus_connection_get(u->bus), OBJECT_SINKS);
1121 dbus_connection_unregister_object_path(pa_dbus_connection_get(u->bus), OBJECT_SOURCES);
1122
1123 if (u->got_name) {
1124 if (dbus_bus_release_name(pa_dbus_connection_get(u->bus), SERVICE_NAME, &error) != DBUS_RELEASE_NAME_REPLY_RELEASED) {
1125 pa_log("Failed to release service name " SERVICE_NAME ": %s", error.message);
1126 dbus_error_free(&error);
1127 }
1128 }
1129
1130 pa_dbus_connection_unref(u->bus);
1131 }
1132
1133 pa_xfree(u->display_name);
1134
1135 if (u->http)
1136 pa_http_protocol_unref(u->http);
1137
1138 pa_xfree(u);
1139 }