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 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34
  35 #include <pulse/xmalloc.h>
  36 #include <pulse/util.h>
  37 #include <pulse/i18n.h>
  38 #include <pulse/utf8.h>
  39
  40 #include <pulsecore/sink.h>
  41 #include <pulsecore/source.h>
  42 #include <pulsecore/core-util.h>
  43 #include <pulsecore/log.h>
  44 #include <pulsecore/modargs.h>
  45 #include <pulsecore/dbus-shared.h>
  46 #include <pulsecore/endianmacros.h>
  47 #include <pulsecore/namereg.h>
  48 #include <pulsecore/mime-type.h>
  49 #include <pulsecore/strbuf.h>
  50 #include <pulsecore/protocol-http.h>
  51 #include <pulsecore/parseaddr.h>
  52
  53 #include "module-rygel-media-server-symdef.h"
  54
  55 PA_MODULE_AUTHOR("Lennart Poettering");
  56 PA_MODULE_DESCRIPTION("UPnP MediaServer Plugin for Rygel");
  57 PA_MODULE_VERSION(PACKAGE_VERSION);
  58 PA_MODULE_LOAD_ONCE(TRUE);
  59 PA_MODULE_USAGE(
  60         "display_name=<UPnP Media Server name>");
  61
  62 /* This implements http://live.gnome.org/action/edit/Rygel/MediaServerSpec */
  63
  64 #define SERVICE_NAME "org.Rygel.MediaServer1.PulseAudio"
  65
  66 #define OBJECT_ROOT "/org/Rygel/MediaServer1/PulseAudio"
  67 #define OBJECT_SINKS "/org/Rygel/MediaServer1/PulseAudio/Sinks"
  68 #define OBJECT_SOURCES "/org/Rygel/MediaServer1/PulseAudio/Sources"
  69
  70 #define CONTAINER_INTROSPECT_XML_PREFIX                                 \
  71     DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                           \
  72     "<node>"                                                            \
  73     " <!-- If you are looking for documentation make sure to check out" \
  74     "      http://live.gnome.org/Rygel/MediaServerSpec -->"             \
  75     " <interface name=\"org.Rygel.MediaContainer1\">"                   \
  76     "  <method name=\"GetContainers\">"                                 \
  77     "   <arg name=\"children\" type=\"ao\" direction=\"out\"/>"         \
  78     "  </method>"                                                       \
  79     "  <method name=\"GetItems\">"                                      \
  80     "   <arg name=\"children\" type=\"ao\" direction=\"out\"/>"         \
  81     "  </method>"                                                       \
  82     "  <signal name=\"Updated\">"                                       \
  83     "   <arg name=\"path\" type=\"o\"/>"                                \
  84     "  </signal>"                                                       \
  85     "  <property name=\"item-count\" type=\"u\" access=\"read\"/>"      \
  86     "  <property name=\"container-count\" type=\"u\" access=\"read\"/>" \
  87     " </interface>"                                                     \
  88     " <interface name=\"org.Rygel.MediaObject1\">"                      \
  89     "  <property name=\"icon-name\" type=\"s\" access=\"read\"/>"       \
  90     "  <property name=\"display-name\" type=\"s\" access=\"read\"/>"    \
  91     " </interface>"                                                     \
  92     " <interface name=\"org.freedesktop.DBus.Properties\">"             \
  93     "  <method name=\"Get\">"                                           \
  94     "   <arg name=\"interface\" direction=\"in\" type=\"s\"/>"          \
  95     "   <arg name=\"property\" direction=\"in\" type=\"s\"/>"           \
  96     "   <arg name=\"value\" direction=\"out\" type=\"v\"/>"             \
  97     "  </method>"                                                       \
  98     "  <method name=\"GetAll\">"                                        \
  99     "   <arg name=\"interface\" direction=\"in\" type=\"s\"/>"          \
 100     "   <arg name=\"properties\" direction=\"out\" type=\"a{sv}\"/>"    \
 101     "  </method>"                                                       \
 102     " </interface>"                                                     \
 103     " <interface name=\"org.freedesktop.DBus.Introspectable\">"         \
 104     "  <method name=\"Introspect\">"                                    \
 105     "   <arg name=\"data\" type=\"s\" direction=\"out\"/>"              \
 106     "  </method>"                                                       \
 107     " </interface>"
 108
 109 #define CONTAINER_INTROSPECT_XML_POSTFIX                                \
 110     "</node>"
 111
 112 #define ROOT_INTROSPECT_XML                                             \
 113     CONTAINER_INTROSPECT_XML_PREFIX                                     \
 114     "<node name=\"Sinks\"/>"                                            \
 115     "<node name=\"Sources\"/>"                                          \
 116     CONTAINER_INTROSPECT_XML_POSTFIX
 117
 118 #define ITEM_INTROSPECT_XML                                             \
 119     DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                           \
 120     "<node>"                                                            \
 121     " <!-- If you are looking for documentation make sure to check out" \
 122     "      http://live.gnome.org/Rygel/MediaProviderSpec -->"           \
 123     " <interface name=\"org.Rygel.MediaItem1\">"                        \
 124     "  <property name=\"urls\" type=\"as\" access=\"read\"/>"           \
 125     "  <property name=\"mime-type\" type=\"s\" access=\"read\"/>"       \
 126     "  <property name=\"type\" type=\"s\" access=\"read\"/>"            \
 127     " </interface>"                                                     \
 128     " <interface name=\"org.Rygel.MediaObject1\">"                      \
 129     "  <property name=\"display-name\" type=\"s\" access=\"read\"/>"    \
 130     " </interface>"                                                     \
 131     " <interface name=\"org.freedesktop.DBus.Properties\">"             \
 132     "  <method name=\"Get\">"                                           \
 133     "   <arg name=\"interface\" direction=\"in\" type=\"s\"/>"          \
 134     "   <arg name=\"property\" direction=\"in\" type=\"s\"/>"           \
 135     "   <arg name=\"value\" direction=\"out\" type=\"v\"/>"             \
 136     "  </method>"                                                       \
 137     "  <method name=\"GetAll\">"                                        \
 138     "   <arg name=\"interface\" direction=\"in\" type=\"s\"/>"          \
 139     "   <arg name=\"properties\" direction=\"out\" type=\"a{sv}\"/>"    \
 140     "  </method>"                                                       \
 141     " </interface>"                                                     \
 142     " <interface name=\"org.freedesktop.DBus.Introspectable\">"         \
 143     "  <method name=\"Introspect\">"                                    \
 144     "   <arg name=\"data\" type=\"s\" direction=\"out\"/>"              \
 145     "  </method>"                                                       \
 146     " </interface>"                                                     \
 147     "</node>"
 148
 149
 150 static const char* const valid_modargs[] = {
 151     "display_name",
 152     NULL
 153 };
 154
 155 struct userdata {
 156     pa_core *core;
 157     pa_module *module;
 158
 159     pa_dbus_connection *bus;
 160     pa_bool_t got_name:1;
 161
 162     char *display_name;
 163
 164     pa_hook_slot *source_new_slot, *source_unlink_slot;
 165
 166     pa_http_protocol *http;
 167 };
 168
 169 static void send_signal(struct userdata *u, pa_source *s) {
 170     DBusMessage *m;
 171     const char *parent;
 172
 173     pa_assert(u);
 174     pa_source_assert_ref(s);
 175
 176     if (u->core->state == PA_CORE_SHUTDOWN)
 177         return;
 178
 179     if (s->monitor_of)
 180         parent = OBJECT_SINKS;
 181     else
 182         parent = OBJECT_SOURCES;
 183
 184     pa_assert_se(m = dbus_message_new_signal(parent, "org.Rygel.MediaContainer1", "Updated"));
 185     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->bus), m, NULL));
 186
 187     dbus_message_unref(m);
 188 }
 189
 190 static pa_hook_result_t source_new_or_unlink_cb(pa_core *c, pa_source *s, struct userdata *u) {
 191     pa_assert(c);
 192     pa_source_assert_ref(s);
 193
 194     send_signal(u, s);
 195
 196     return PA_HOOK_OK;
 197 }
 198
 199 static pa_bool_t message_is_property_get(DBusMessage *m, const char *interface, const char *property) {
 200     const char *i, *p;
 201     DBusError error;
 202
 203     dbus_error_init(&error);
 204
 205     pa_assert(m);
 206
 207     if (!dbus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get"))
 208         return FALSE;
 209
 210     if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &i, DBUS_TYPE_STRING, &p, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
 211         dbus_error_free(&error);
 212         return FALSE;
 213     }
 214
 215     return pa_streq(i, interface) && pa_streq(p, property);
 216 }
 217
 218 static pa_bool_t message_is_property_get_all(DBusMessage *m, const char *interface) {
 219     const char *i;
 220     DBusError error;
 221
 222     dbus_error_init(&error);
 223
 224     pa_assert(m);
 225
 226     if (!dbus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "GetAll"))
 227         return FALSE;
 228
 229     if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &i, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
 230         dbus_error_free(&error);
 231         return FALSE;
 232     }
 233
 234     return pa_streq(i, interface);
 235 }
 236
 237 static void append_variant_string(DBusMessage *m, DBusMessageIter *iter, const char *s) {
 238     DBusMessageIter _iter, sub;
 239
 240     pa_assert(m);
 241     pa_assert(s);
 242
 243     if (!iter) {
 244         dbus_message_iter_init_append(m, &_iter);
 245         iter = &_iter;
 246     }
 247
 248     pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "s", &sub));
 249     pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &s));
 250     pa_assert_se(dbus_message_iter_close_container(iter, &sub));
 251 }
 252
 253 static void append_variant_unsigned(DBusMessage *m, DBusMessageIter *iter, unsigned u) {
 254     DBusMessageIter _iter, sub;
 255
 256     pa_assert(m);
 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, "u", &sub));
 264     pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &u));
 265     pa_assert_se(dbus_message_iter_close_container(iter, &sub));
 266 }
 267
 268 static void append_property_dict_entry_string(DBusMessage *m, DBusMessageIter *iter, const char *name, const char *value) {
 269     DBusMessageIter sub;
 270
 271     pa_assert(iter);
 272
 273     pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
 274     pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name));
 275     append_variant_string(m, &sub, value);
 276     pa_assert_se(dbus_message_iter_close_container(iter, &sub));
 277 }
 278
 279 static void append_property_dict_entry_unsigned(DBusMessage *m, DBusMessageIter *iter, const char *name, unsigned u) {
 280     DBusMessageIter sub;
 281
 282     pa_assert(iter);
 283
 284     pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub));
 285     pa_assert_se(dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &name));
 286     append_variant_unsigned(m, &sub, u);
 287     pa_assert_se(dbus_message_iter_close_container(iter, &sub));
 288 }
 289
 290 static DBusHandlerResult root_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
 291     struct userdata *u = userdata;
 292     DBusMessage *r = NULL;
 293
 294     pa_assert(u);
 295
 296     if (dbus_message_is_method_call(m, "org.Rygel.MediaContainer1", "GetContainers")) {
 297         const char * array[] = { OBJECT_SINKS, OBJECT_SOURCES };
 298         const char ** parray = array;
 299
 300         pa_assert_se(r = dbus_message_new_method_return(m));
 301         pa_assert_se(dbus_message_append_args(
 302                              r,
 303                              DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &parray, 2,
 304                              DBUS_TYPE_INVALID));
 305
 306     } else if (dbus_message_is_method_call(m, "org.Rygel.MediaContainer1", "GetItems")) {
 307         const char * array[] = { };
 308         const char **  parray = array;
 309
 310         pa_assert_se(r = dbus_message_new_method_return(m));
 311         pa_assert_se(dbus_message_append_args(
 312                              r,
 313                              DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &parray, 0,
 314                              DBUS_TYPE_INVALID));
 315
 316     } else if (message_is_property_get(m, "org.Rygel.MediaObject1", "display-name")) {
 317         pa_assert_se(r = dbus_message_new_method_return(m));
 318         append_variant_string(r, NULL, u->display_name);
 319
 320     } else if (message_is_property_get(m, "org.Rygel.MediaObject1", "icon-name")) {
 321         pa_assert_se(r = dbus_message_new_method_return(m));
 322         append_variant_string(r, NULL, "audio-card");
 323
 324     } else if (message_is_property_get_all(m, "org.Rygel.MediaObject1")) {
 325         DBusMessageIter iter, sub;
 326
 327         pa_assert_se(r = dbus_message_new_method_return(m));
 328         dbus_message_iter_init_append(r, &iter);
 329
 330         pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
 331         append_property_dict_entry_string(r, &sub, "display-name", u->display_name);
 332         append_property_dict_entry_string(r, &sub, "icon-name", "audio-card");
 333         pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
 334
 335     } else if (message_is_property_get(m, "org.Rygel.MediaContainer1", "item-count")) {
 336         pa_assert_se(r = dbus_message_new_method_return(m));
 337         append_variant_unsigned(r, NULL, 0);
 338
 339     } else if (message_is_property_get(m, "org.Rygel.MediaContainer1", "container-count")) {
 340         pa_assert_se(r = dbus_message_new_method_return(m));
 341         append_variant_unsigned(r, NULL, 2);
 342
 343     } else if (message_is_property_get_all(m, "org.Rygel.MediaContainer1")) {
 344         DBusMessageIter iter, sub;
 345
 346         pa_assert_se(r = dbus_message_new_method_return(m));
 347         dbus_message_iter_init_append(r, &iter);
 348
 349         pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
 350         append_property_dict_entry_unsigned(r, &sub, "item-count", 0);
 351         append_property_dict_entry_unsigned(r, &sub, "container-count", 2);
 352         pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
 353
 354     } else if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 355         const char *xml = ROOT_INTROSPECT_XML;
 356
 357         pa_assert_se(r = dbus_message_new_method_return(m));
 358         pa_assert_se(dbus_message_append_args(
 359                              r,
 360                              DBUS_TYPE_STRING, &xml,
 361                              DBUS_TYPE_INVALID));
 362
 363     } else
 364         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 365
 366     if (r) {
 367         pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->bus), r, NULL));
 368         dbus_message_unref(r);
 369     }
 370
 371     return DBUS_HANDLER_RESULT_HANDLED;
 372 }
 373
 374 static char *compute_url(struct userdata *u, const char *name) {
 375     pa_strlist *i;
 376
 377     pa_assert(u);
 378     pa_assert(name);
 379
 380     for (i = pa_http_protocol_servers(u->http); i; i = pa_strlist_next(i)) {
 381         pa_parsed_address a;
 382
 383         if (pa_parse_address(pa_strlist_data(i), &a) >= 0 &&
 384             (a.type == PA_PARSED_ADDRESS_TCP4 ||
 385              a.type == PA_PARSED_ADDRESS_TCP6 ||
 386              a.type == PA_PARSED_ADDRESS_TCP_AUTO)) {
 387
 388             const char *address;
 389             char *s;
 390
 391             if (pa_is_ip_address(a.path_or_host))
 392                 address = a.path_or_host;
 393             else
 394                 address = "@ADDRESS@";
 395
 396             if (a.port <= 0)
 397                 a.port = 4714;
 398
 399             s = pa_sprintf_malloc("http://%s:%u/listen/source/%s", address, a.port, name);
 400
 401             pa_xfree(a.path_or_host);
 402             return s;
 403         }
 404
 405         pa_xfree(a.path_or_host);
 406     }
 407
 408     return pa_sprintf_malloc("http://@ADDRESS@:4714/listen/source/%s", name);
 409 }
 410
 411 static DBusHandlerResult sinks_and_sources_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
 412     struct userdata *u = userdata;
 413     DBusMessage *r = NULL;
 414     const char *path;
 415
 416     pa_assert(u);
 417
 418     path = dbus_message_get_path(m);
 419
 420     if (pa_streq(path, OBJECT_SINKS) || pa_streq(path, OBJECT_SOURCES)) {
 421
 422         /* Container nodes */
 423
 424         if (dbus_message_is_method_call(m, "org.Rygel.MediaContainer1", "GetContainers")) {
 425
 426             const char * array[] = { };
 427             const char ** parray = array;
 428
 429             pa_assert_se(r = dbus_message_new_method_return(m));
 430             pa_assert_se(dbus_message_append_args(
 431                                  r,
 432                                  DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &parray, 0,
 433                                  DBUS_TYPE_INVALID));
 434
 435         } else if (dbus_message_is_method_call(m, "org.Rygel.MediaContainer1", "GetItems")) {
 436             unsigned n, i = 0;
 437             char ** array;
 438             uint32_t idx;
 439
 440             if (pa_streq(path, OBJECT_SINKS))
 441                 n = pa_idxset_size(u->core->sinks);
 442             else
 443                 n = pa_idxset_size(u->core->sources);
 444
 445             array = pa_xnew(char*, n);
 446
 447             if (pa_streq(path, OBJECT_SINKS)) {
 448                 pa_sink *sink;
 449
 450                 PA_IDXSET_FOREACH(sink, u->core->sinks, idx)
 451                     array[i++] = pa_sprintf_malloc(OBJECT_SINKS "/%u", sink->index);
 452             } else {
 453                 pa_source *source;
 454
 455                 PA_IDXSET_FOREACH(source, u->core->sources, idx)
 456                     if (!source->monitor_of)
 457                         array[i++] = pa_sprintf_malloc(OBJECT_SOURCES "/%u", source->index);
 458             }
 459
 460             pa_assert(i <= n);
 461
 462             pa_assert_se(r = dbus_message_new_method_return(m));
 463             pa_assert_se(dbus_message_append_args(
 464                                  r,
 465                                  DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &array, i,
 466                                  DBUS_TYPE_INVALID));
 467
 468             for (; i >= 1; i--)
 469                 pa_xfree(array[i-1]);
 470
 471             pa_xfree(array);
 472
 473         } else if (message_is_property_get(m, "org.Rygel.MediaObject1", "display-name")) {
 474
 475             pa_assert_se(r = dbus_message_new_method_return(m));
 476
 477             append_variant_string(r,
 478                                   NULL,
 479                                   pa_streq(path, OBJECT_SINKS) ?
 480                                   _("Output Devices") :
 481                                   _("Input Devices"));
 482
 483         } else if (message_is_property_get_all(m, "org.Rygel.MediaObject1")) {
 484             DBusMessageIter iter, sub;
 485
 486             pa_assert_se(r = dbus_message_new_method_return(m));
 487
 488             dbus_message_iter_init_append(r, &iter);
 489
 490             pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
 491             append_property_dict_entry_string(m, &sub, "display-name",
 492                                               pa_streq(path, OBJECT_SINKS) ?
 493                                               _("Output Devices") :
 494                                               _("Input Devices"));
 495             pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
 496
 497         } else if (message_is_property_get(m, "org.Rygel.MediaContainer1", "item-count")) {
 498             pa_assert_se(r = dbus_message_new_method_return(m));
 499
 500             append_variant_unsigned(r, NULL,
 501                                     pa_streq(path, OBJECT_SINKS) ?
 502                                     pa_idxset_size(u->core->sinks) :
 503                                     pa_idxset_size(u->core->sources));
 504
 505         } else if (message_is_property_get(m, "org.Rygel.MediaContainer1", "container-count")) {
 506             pa_assert_se(r = dbus_message_new_method_return(m));
 507             append_variant_unsigned(r, NULL, 0);
 508
 509         } else if (message_is_property_get_all(m, "org.Rygel.MediaContainer1")) {
 510             DBusMessageIter iter, sub;
 511
 512             pa_assert_se(r = dbus_message_new_method_return(m));
 513             dbus_message_iter_init_append(r, &iter);
 514
 515             pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
 516             append_property_dict_entry_unsigned(r, &sub, "item-count",
 517                                                 pa_streq(path, OBJECT_SINKS) ?
 518                                                 pa_idxset_size(u->core->sinks) :
 519                                                 pa_idxset_size(u->core->sources));
 520             append_property_dict_entry_unsigned(r, &sub, "container-count", 0);
 521             pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
 522         } else if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 523             pa_strbuf *sb;
 524             char *xml;
 525             uint32_t idx;
 526
 527             sb = pa_strbuf_new();
 528             pa_strbuf_puts(sb, CONTAINER_INTROSPECT_XML_PREFIX);
 529
 530             if (pa_streq(path, OBJECT_SINKS)) {
 531                 pa_sink *sink;
 532
 533                 PA_IDXSET_FOREACH(sink, u->core->sinks, idx)
 534                     pa_strbuf_printf(sb, "<node name=\"%u\"/>", sink->index);
 535             } else {
 536                 pa_source *source;
 537
 538                 PA_IDXSET_FOREACH(source, u->core->sources, idx)
 539                     if (!source->monitor_of)
 540                         pa_strbuf_printf(sb, "<node name=\"%u\"/>", source->index);
 541             }
 542
 543             pa_strbuf_puts(sb, CONTAINER_INTROSPECT_XML_POSTFIX);
 544             xml = pa_strbuf_tostring_free(sb);
 545
 546             pa_assert_se(r = dbus_message_new_method_return(m));
 547             pa_assert_se(dbus_message_append_args(
 548                                  r,
 549                                  DBUS_TYPE_STRING, &xml,
 550                                  DBUS_TYPE_INVALID));
 551
 552             pa_xfree(xml);
 553         } else
 554             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 555
 556     } else {
 557         pa_sink *sink = NULL;
 558         pa_source *source = NULL;
 559
 560         /* Child nodes */
 561
 562         if (pa_startswith(path, OBJECT_SINKS "/"))
 563             sink = pa_namereg_get(u->core, path + sizeof(OBJECT_SINKS), PA_NAMEREG_SINK);
 564         else if (pa_startswith(path, OBJECT_SOURCES "/"))
 565             source = pa_namereg_get(u->core, path + sizeof(OBJECT_SOURCES), PA_NAMEREG_SOURCE);
 566
 567         if (!sink && !source)
 568             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 569
 570         if (message_is_property_get(m, "org.Rygel.MediaObject1", "display-name")) {
 571             pa_assert_se(r = dbus_message_new_method_return(m));
 572             append_variant_string(r, NULL, pa_strna(pa_proplist_gets(sink ? sink->proplist : source->proplist, PA_PROP_DEVICE_DESCRIPTION)));
 573
 574         } else if (message_is_property_get(m, "org.Rygel.MediaItem1", "type")) {
 575             pa_assert_se(r = dbus_message_new_method_return(m));
 576             append_variant_string(r, NULL, "audio");
 577
 578         } else if (message_is_property_get(m, "org.Rygel.MediaItem1", "mime-type")) {
 579             char *t;
 580
 581             if (sink)
 582                 t = pa_sample_spec_to_mime_type_mimefy(&sink->sample_spec, &sink->channel_map);
 583             else
 584                 t = pa_sample_spec_to_mime_type_mimefy(&source->sample_spec, &source->channel_map);
 585
 586             pa_assert_se(r = dbus_message_new_method_return(m));
 587             append_variant_string(r, NULL, t);
 588             pa_xfree(t);
 589
 590         } else if (message_is_property_get(m, "org.Rygel.MediaItem1", "urls")) {
 591             DBusMessageIter iter, sub, array;
 592             char *url;
 593
 594             pa_assert_se(r = dbus_message_new_method_return(m));
 595
 596             dbus_message_iter_init_append(r, &iter);
 597
 598             url = compute_url(u, sink ? sink->monitor_source->name : source->name);
 599
 600             pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, "as", &sub));
 601             pa_assert_se(dbus_message_iter_open_container(&sub, DBUS_TYPE_ARRAY, "s", &array));
 602             pa_assert_se(dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &url));
 603             pa_assert_se(dbus_message_iter_close_container(&sub, &array));
 604             pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
 605
 606             pa_xfree(url);
 607
 608         } else if (message_is_property_get_all(m, "org.Rygel.MediaObject1")) {
 609             DBusMessageIter iter, sub;
 610
 611             pa_assert_se(r = dbus_message_new_method_return(m));
 612             dbus_message_iter_init_append(r, &iter);
 613
 614             pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
 615             append_property_dict_entry_string(r, &sub, "display-name", pa_strna(pa_proplist_gets(sink ? sink->proplist : source->proplist, PA_PROP_DEVICE_DESCRIPTION)));
 616             pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
 617
 618         } else if (message_is_property_get_all(m, "org.Rygel.MediaItem1")) {
 619             DBusMessageIter iter, sub, dict, variant, array;
 620             char *url, *t;
 621             const char *un = "urls";
 622
 623             pa_assert_se(r = dbus_message_new_method_return(m));
 624             dbus_message_iter_init_append(r, &iter);
 625
 626             pa_assert_se(dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &sub));
 627             append_property_dict_entry_string(r, &sub, "type", "audio");
 628
 629             if (sink)
 630                 t = pa_sample_spec_to_mime_type_mimefy(&sink->sample_spec, &sink->channel_map);
 631             else
 632                 t = pa_sample_spec_to_mime_type_mimefy(&source->sample_spec, &source->channel_map);
 633
 634             append_property_dict_entry_string(r, &sub, "mime-type", t);
 635             pa_xfree(t);
 636
 637             pa_assert_se(dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, NULL, &dict));
 638             pa_assert_se(dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &un));
 639
 640             url = compute_url(u, sink ? sink->monitor_source->name : source->name);
 641
 642             pa_assert_se(dbus_message_iter_open_container(&dict, DBUS_TYPE_VARIANT, "as", &variant));
 643             pa_assert_se(dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, "s", &array));
 644             pa_assert_se(dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &url));
 645             pa_assert_se(dbus_message_iter_close_container(&variant, &array));
 646             pa_assert_se(dbus_message_iter_close_container(&dict, &variant));
 647             pa_assert_se(dbus_message_iter_close_container(&sub, &dict));
 648
 649             pa_xfree(url);
 650
 651             pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
 652
 653         } else if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 654             const char *xml =
 655                 ITEM_INTROSPECT_XML;
 656
 657             pa_assert_se(r = dbus_message_new_method_return(m));
 658             pa_assert_se(dbus_message_append_args(
 659                                  r,
 660                                  DBUS_TYPE_STRING, &xml,
 661                                  DBUS_TYPE_INVALID));
 662
 663         } else
 664             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 665     }
 666
 667     if (r) {
 668         pa_assert_se(dbus_connection_send(pa_dbus_connection_get(u->bus), r, NULL));
 669         dbus_message_unref(r);
 670     }
 671
 672     return DBUS_HANDLER_RESULT_HANDLED;
 673 }
 674
 675 int pa__init(pa_module *m) {
 676
 677     struct userdata *u;
 678     pa_modargs *ma = NULL;
 679     DBusError error;
 680     const char *t;
 681
 682     static const DBusObjectPathVTable vtable_root = {
 683         .message_function = root_handler,
 684     };
 685     static const DBusObjectPathVTable vtable_sinks_and_sources = {
 686         .message_function = sinks_and_sources_handler,
 687     };
 688
 689     dbus_error_init(&error);
 690
 691     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 692         pa_log("Failed to parse module arguments.");
 693         goto fail;
 694     }
 695
 696     m->userdata = u = pa_xnew0(struct userdata, 1);
 697     u->core = m->core;
 698     u->module = m;
 699     u->http = pa_http_protocol_get(u->core);
 700
 701     if ((t = pa_modargs_get_value(ma, "display_name", NULL)))
 702         u->display_name = pa_utf8_filter(t);
 703     else
 704         u->display_name = pa_xstrdup(_("Audio on @HOSTNAME@"));
 705
 706     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);
 707     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);
 708
 709     if (!(u->bus = pa_dbus_bus_get(m->core, DBUS_BUS_SESSION, &error))) {
 710         pa_log("Failed to get session bus connection: %s", error.message);
 711         goto fail;
 712     }
 713
 714     pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(u->bus), OBJECT_ROOT, &vtable_root, u));
 715     pa_assert_se(dbus_connection_register_fallback(pa_dbus_connection_get(u->bus), OBJECT_SINKS, &vtable_sinks_and_sources, u));
 716     pa_assert_se(dbus_connection_register_fallback(pa_dbus_connection_get(u->bus), OBJECT_SOURCES, &vtable_sinks_and_sources, u));
 717
 718     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) {
 719         pa_log("Failed to request service name " SERVICE_NAME ": %s", error.message);
 720         goto fail;
 721     }
 722
 723     u->got_name = TRUE;
 724
 725     pa_modargs_free(ma);
 726
 727     return 0;
 728
 729 fail:
 730     pa__done(m);
 731
 732     if (ma)
 733         pa_modargs_free(ma);
 734
 735     dbus_error_free(&error);
 736
 737     return -1;
 738 }
 739
 740 void pa__done(pa_module*m) {
 741     struct userdata*u;
 742     pa_assert(m);
 743
 744     if (!(u = m->userdata))
 745         return;
 746
 747     if (u->source_new_slot)
 748         pa_hook_slot_free(u->source_new_slot);
 749     if (u->source_unlink_slot)
 750         pa_hook_slot_free(u->source_unlink_slot);
 751
 752     if (u->bus) {
 753         DBusError error;
 754
 755         dbus_error_init(&error);
 756
 757         dbus_connection_unregister_object_path(pa_dbus_connection_get(u->bus), OBJECT_ROOT);
 758         dbus_connection_unregister_object_path(pa_dbus_connection_get(u->bus), OBJECT_SINKS);
 759         dbus_connection_unregister_object_path(pa_dbus_connection_get(u->bus), OBJECT_SOURCES);
 760
 761         if (u->got_name) {
 762             if (dbus_bus_release_name(pa_dbus_connection_get(u->bus), SERVICE_NAME, &error) != DBUS_RELEASE_NAME_REPLY_RELEASED) {
 763                 pa_log("Failed to release service name " SERVICE_NAME ": %s", error.message);
 764                 dbus_error_free(&error);
 765             }
 766         }
 767
 768         pa_dbus_connection_unref(u->bus);
 769     }
 770
 771     pa_xfree(u->display_name);
 772
 773     if (u->http)
 774         pa_http_protocol_unref(u->http);
 775
 776     pa_xfree(u);
 777 }