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