code.delx.au - pulseaudio/blob - src/modules/bluetooth/bluez5-util.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2008-2013 João Paulo Rechi Vita
   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
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, 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
  17   License 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 <pulse/xmalloc.h>
  27
  28 #include <pulsecore/core.h>
  29 #include <pulsecore/core-util.h>
  30 #include <pulsecore/dbus-shared.h>
  31 #include <pulsecore/log.h>
  32 #include <pulsecore/macro.h>
  33 #include <pulsecore/refcnt.h>
  34 #include <pulsecore/shared.h>
  35
  36 #include "a2dp-codecs.h"
  37
  38 #include "bluez5-util.h"
  39
  40 #define BLUEZ_SERVICE "org.bluez"
  41 #define BLUEZ_ADAPTER_INTERFACE BLUEZ_SERVICE ".Adapter1"
  42 #define BLUEZ_DEVICE_INTERFACE BLUEZ_SERVICE ".Device1"
  43 #define BLUEZ_MEDIA_ENDPOINT_INTERFACE BLUEZ_SERVICE ".MediaEndpoint1"
  44 #define BLUEZ_MEDIA_TRANSPORT_INTERFACE BLUEZ_SERVICE ".MediaTransport1"
  45
  46 #define A2DP_SOURCE_ENDPOINT "/MediaEndpoint/A2DPSource"
  47 #define A2DP_SINK_ENDPOINT "/MediaEndpoint/A2DPSink"
  48
  49 #define ENDPOINT_INTROSPECT_XML                                         \
  50     DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                           \
  51     "<node>"                                                            \
  52     " <interface name=\"" BLUEZ_MEDIA_ENDPOINT_INTERFACE "\">"          \
  53     "  <method name=\"SetConfiguration\">"                              \
  54     "   <arg name=\"transport\" direction=\"in\" type=\"o\"/>"          \
  55     "   <arg name=\"properties\" direction=\"in\" type=\"ay\"/>"        \
  56     "  </method>"                                                       \
  57     "  <method name=\"SelectConfiguration\">"                           \
  58     "   <arg name=\"capabilities\" direction=\"in\" type=\"ay\"/>"      \
  59     "   <arg name=\"configuration\" direction=\"out\" type=\"ay\"/>"    \
  60     "  </method>"                                                       \
  61     "  <method name=\"ClearConfiguration\">"                            \
  62     "   <arg name=\"transport\" direction=\"in\" type=\"o\"/>"          \
  63     "  </method>"                                                       \
  64     "  <method name=\"Release\">"                                       \
  65     "  </method>"                                                       \
  66     " </interface>"                                                     \
  67     " <interface name=\"org.freedesktop.DBus.Introspectable\">"         \
  68     "  <method name=\"Introspect\">"                                    \
  69     "   <arg name=\"data\" type=\"s\" direction=\"out\"/>"              \
  70     "  </method>"                                                       \
  71     " </interface>"                                                     \
  72     "</node>"
  73
  74 struct pa_bluetooth_discovery {
  75     PA_REFCNT_DECLARE;
  76
  77     pa_core *core;
  78     pa_dbus_connection *connection;
  79     bool filter_added;
  80     bool matches_added;
  81     bool objects_listed;
  82     pa_hook hooks[PA_BLUETOOTH_HOOK_MAX];
  83     pa_hashmap *adapters;
  84     pa_hashmap *devices;
  85     pa_hashmap *transports;
  86
  87     PA_LLIST_HEAD(pa_dbus_pending, pending);
  88 };
  89
  90 static pa_dbus_pending* send_and_add_to_pending(pa_bluetooth_discovery *y, DBusMessage *m,
  91                                                                   DBusPendingCallNotifyFunction func, void *call_data) {
  92     pa_dbus_pending *p;
  93     DBusPendingCall *call;
  94
  95     pa_assert(y);
  96     pa_assert(m);
  97
  98     pa_assert_se(dbus_connection_send_with_reply(pa_dbus_connection_get(y->connection), m, &call, -1));
  99
 100     p = pa_dbus_pending_new(pa_dbus_connection_get(y->connection), m, call, y, call_data);
 101     PA_LLIST_PREPEND(pa_dbus_pending, y->pending, p);
 102     dbus_pending_call_set_notify(call, func, p, NULL);
 103
 104     return p;
 105 }
 106
 107 pa_bluetooth_transport *pa_bluetooth_transport_new(pa_bluetooth_device *d, const char *owner, const char *path,
 108                                                    pa_bluetooth_profile_t p, const uint8_t *config, size_t size) {
 109     pa_bluetooth_transport *t;
 110
 111     t = pa_xnew0(pa_bluetooth_transport, 1);
 112     t->device = d;
 113     t->owner = pa_xstrdup(owner);
 114     t->path = pa_xstrdup(path);
 115     t->profile = p;
 116     t->config_size = size;
 117
 118     if (size > 0) {
 119         t->config = pa_xnew(uint8_t, size);
 120         memcpy(t->config, config, size);
 121     }
 122
 123     pa_assert_se(pa_hashmap_put(d->discovery->transports, t->path, t) >= 0);
 124
 125     return t;
 126 }
 127
 128 static const char *transport_state_to_string(pa_bluetooth_transport_state_t state) {
 129     switch(state) {
 130         case PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED:
 131             return "disconnected";
 132         case PA_BLUETOOTH_TRANSPORT_STATE_IDLE:
 133             return "idle";
 134         case PA_BLUETOOTH_TRANSPORT_STATE_PLAYING:
 135             return "playing";
 136     }
 137
 138     return "invalid";
 139 }
 140
 141 static void transport_state_changed(pa_bluetooth_transport *t, pa_bluetooth_transport_state_t state) {
 142     bool old_any_connected;
 143
 144     pa_assert(t);
 145
 146     if (t->state == state)
 147         return;
 148
 149     old_any_connected = pa_bluetooth_device_any_transport_connected(t->device);
 150
 151     pa_log_debug("Transport %s state changed from %s to %s",
 152                  t->path, transport_state_to_string(t->state), transport_state_to_string(state));
 153
 154     t->state = state;
 155     if (state == PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED)
 156         t->device->transports[t->profile] = NULL;
 157
 158     pa_hook_fire(&t->device->discovery->hooks[PA_BLUETOOTH_HOOK_TRANSPORT_STATE_CHANGED], t);
 159
 160     if (old_any_connected != pa_bluetooth_device_any_transport_connected(t->device))
 161         pa_hook_fire(&t->device->discovery->hooks[PA_BLUETOOTH_HOOK_DEVICE_CONNECTION_CHANGED], t->device);
 162 }
 163
 164 void pa_bluetooth_transport_put(pa_bluetooth_transport *t) {
 165     transport_state_changed(t, PA_BLUETOOTH_TRANSPORT_STATE_IDLE);
 166 }
 167
 168 void pa_bluetooth_transport_free(pa_bluetooth_transport *t) {
 169     pa_assert(t);
 170
 171     pa_hashmap_remove(t->device->discovery->transports, t->path);
 172     pa_xfree(t->owner);
 173     pa_xfree(t->path);
 174     pa_xfree(t->config);
 175     pa_xfree(t);
 176 }
 177
 178 static int bluez5_transport_acquire_cb(pa_bluetooth_transport *t, bool optional, size_t *imtu, size_t *omtu) {
 179     DBusMessage *m, *r;
 180     DBusError err;
 181     int ret;
 182     uint16_t i, o;
 183     const char *method = optional ? "TryAcquire" : "Acquire";
 184
 185     pa_assert(t);
 186     pa_assert(t->device);
 187     pa_assert(t->device->discovery);
 188
 189     pa_assert_se(m = dbus_message_new_method_call(t->owner, t->path, BLUEZ_MEDIA_TRANSPORT_INTERFACE, method));
 190
 191     dbus_error_init(&err);
 192
 193     r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(t->device->discovery->connection), m, -1, &err);
 194     if (!r) {
 195         if (optional && pa_streq(err.name, "org.bluez.Error.NotAvailable"))
 196             pa_log_info("Failed optional acquire of unavailable transport %s", t->path);
 197         else
 198             pa_log_error("Transport %s() failed for transport %s (%s)", method, t->path, err.message);
 199
 200         dbus_error_free(&err);
 201         return -1;
 202     }
 203
 204     if (!dbus_message_get_args(r, &err, DBUS_TYPE_UNIX_FD, &ret, DBUS_TYPE_UINT16, &i, DBUS_TYPE_UINT16, &o,
 205                                DBUS_TYPE_INVALID)) {
 206         pa_log_error("Failed to parse %s() reply: %s", method, err.message);
 207         dbus_error_free(&err);
 208         ret = -1;
 209         goto finish;
 210     }
 211
 212     if (imtu)
 213         *imtu = i;
 214
 215     if (omtu)
 216         *omtu = o;
 217
 218 finish:
 219     dbus_message_unref(r);
 220     return ret;
 221 }
 222
 223 static void bluez5_transport_release_cb(pa_bluetooth_transport *t) {
 224     DBusMessage *m;
 225     DBusError err;
 226
 227     pa_assert(t);
 228     pa_assert(t->device);
 229     pa_assert(t->device->discovery);
 230
 231     dbus_error_init(&err);
 232
 233     if (t->state <= PA_BLUETOOTH_TRANSPORT_STATE_IDLE) {
 234         pa_log_info("Transport %s auto-released by BlueZ or already released", t->path);
 235         return;
 236     }
 237
 238     pa_assert_se(m = dbus_message_new_method_call(t->owner, t->path, BLUEZ_MEDIA_TRANSPORT_INTERFACE, "Release"));
 239     dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(t->device->discovery->connection), m, -1, &err);
 240
 241     if (dbus_error_is_set(&err)) {
 242         pa_log_error("Failed to release transport %s: %s", t->path, err.message);
 243         dbus_error_free(&err);
 244     } else
 245         pa_log_info("Transport %s released", t->path);
 246 }
 247
 248 bool pa_bluetooth_device_any_transport_connected(const pa_bluetooth_device *d) {
 249     unsigned i;
 250
 251     pa_assert(d);
 252
 253     if (d->device_info_valid != 1)
 254         return false;
 255
 256     for (i = 0; i < PA_BLUETOOTH_PROFILE_COUNT; i++)
 257         if (d->transports[i] && d->transports[i]->state != PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED)
 258             return true;
 259
 260     return false;
 261 }
 262
 263 static pa_bluetooth_device* device_create(pa_bluetooth_discovery *y, const char *path) {
 264     pa_bluetooth_device *d;
 265
 266     pa_assert(y);
 267     pa_assert(path);
 268
 269     d = pa_xnew0(pa_bluetooth_device, 1);
 270     d->discovery = y;
 271     d->path = pa_xstrdup(path);
 272
 273     pa_hashmap_put(y->devices, d->path, d);
 274
 275     return d;
 276 }
 277
 278 pa_bluetooth_device* pa_bluetooth_discovery_get_device_by_path(pa_bluetooth_discovery *y, const char *path) {
 279     pa_bluetooth_device *d;
 280
 281     pa_assert(y);
 282     pa_assert(PA_REFCNT_VALUE(y) > 0);
 283     pa_assert(path);
 284
 285     if ((d = pa_hashmap_get(y->devices, path)))
 286         if (d->device_info_valid == 1)
 287             return d;
 288
 289     return NULL;
 290 }
 291
 292 pa_bluetooth_device* pa_bluetooth_discovery_get_device_by_address(pa_bluetooth_discovery *y, const char *remote, const char *local) {
 293     pa_bluetooth_device *d;
 294     void *state = NULL;
 295
 296     pa_assert(y);
 297     pa_assert(PA_REFCNT_VALUE(y) > 0);
 298     pa_assert(remote);
 299     pa_assert(local);
 300
 301     while ((d = pa_hashmap_iterate(y->devices, &state, NULL)))
 302         if (pa_streq(d->address, remote) && pa_streq(d->adapter->address, local))
 303             return d->device_info_valid == 1 ? d : NULL;
 304
 305     return NULL;
 306 }
 307
 308 static void device_free(pa_bluetooth_device *d) {
 309     unsigned i;
 310
 311     pa_assert(d);
 312
 313     for (i = 0; i < PA_BLUETOOTH_PROFILE_COUNT; i++) {
 314         pa_bluetooth_transport *t;
 315
 316         if (!(t = d->transports[i]))
 317             continue;
 318
 319         transport_state_changed(t, PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED);
 320         pa_bluetooth_transport_free(t);
 321     }
 322
 323     d->discovery = NULL;
 324     d->adapter = NULL;
 325     pa_xfree(d->path);
 326     pa_xfree(d->alias);
 327     pa_xfree(d->address);
 328     pa_xfree(d);
 329 }
 330
 331 static void device_remove(pa_bluetooth_discovery *y, const char *path) {
 332     pa_bluetooth_device *d;
 333
 334     if (!(d = pa_hashmap_remove(y->devices, path)))
 335         pa_log_warn("Unknown device removed %s", path);
 336     else {
 337         pa_log_debug("Device %s removed", path);
 338         device_free(d);
 339     }
 340 }
 341
 342 static void device_remove_all(pa_bluetooth_discovery *y) {
 343     pa_bluetooth_device *d;
 344
 345     pa_assert(y);
 346
 347     while ((d = pa_hashmap_steal_first(y->devices))) {
 348         d->device_info_valid = -1;
 349         pa_hook_fire(&y->hooks[PA_BLUETOOTH_HOOK_DEVICE_CONNECTION_CHANGED], d);
 350         device_free(d);
 351    }
 352 }
 353
 354 static pa_bluetooth_adapter* adapter_create(pa_bluetooth_discovery *y, const char *path) {
 355     pa_bluetooth_adapter *a;
 356
 357     pa_assert(y);
 358     pa_assert(path);
 359
 360     a = pa_xnew0(pa_bluetooth_adapter, 1);
 361     a->discovery = y;
 362     a->path = pa_xstrdup(path);
 363
 364     pa_hashmap_put(y->adapters, a->path, a);
 365
 366     return a;
 367 }
 368
 369 static void adapter_free(pa_bluetooth_adapter *a) {
 370     pa_bluetooth_device *d;
 371     void *state;
 372
 373     pa_assert(a);
 374     pa_assert(a->discovery);
 375
 376     PA_HASHMAP_FOREACH(d, a->discovery->devices, state)
 377         if (d->adapter == a)
 378             d->adapter = NULL;
 379
 380     pa_xfree(a->path);
 381     pa_xfree(a->address);
 382     pa_xfree(a);
 383 }
 384
 385 static void adapter_remove(pa_bluetooth_discovery *y, const char *path) {
 386     pa_bluetooth_adapter *a;
 387
 388     if (!(a = pa_hashmap_remove(y->adapters, path)))
 389         pa_log_warn("Unknown adapter removed %s", path);
 390     else {
 391         pa_log_debug("Adapter %s removed", path);
 392         adapter_free(a);
 393     }
 394 }
 395
 396 static void adapter_remove_all(pa_bluetooth_discovery *y) {
 397     pa_bluetooth_adapter *a;
 398
 399     pa_assert(y);
 400
 401     /* When this function is called all devices have already been freed */
 402
 403     while ((a = pa_hashmap_steal_first(y->adapters)))
 404         adapter_free(a);
 405 }
 406
 407 static void get_managed_objects_reply(DBusPendingCall *pending, void *userdata) {
 408     pa_dbus_pending *p;
 409     pa_bluetooth_discovery *y;
 410     DBusMessage *r;
 411     DBusMessageIter arg_i, element_i;
 412
 413     pa_assert_se(p = userdata);
 414     pa_assert_se(y = p->context_data);
 415     pa_assert_se(r = dbus_pending_call_steal_reply(pending));
 416
 417     if (dbus_message_is_error(r, DBUS_ERROR_UNKNOWN_METHOD)) {
 418         pa_log_warn("BlueZ D-Bus ObjectManager not available");
 419         goto finish;
 420     }
 421
 422     if (dbus_message_get_type(r) == DBUS_MESSAGE_TYPE_ERROR) {
 423         pa_log_error("GetManagedObjects() failed: %s: %s", dbus_message_get_error_name(r), pa_dbus_get_error_message(r));
 424         goto finish;
 425     }
 426
 427     if (!dbus_message_iter_init(r, &arg_i) || !pa_streq(dbus_message_get_signature(r), "a{oa{sa{sv}}}")) {
 428         pa_log_error("Invalid reply signature for GetManagedObjects()");
 429         goto finish;
 430     }
 431
 432     dbus_message_iter_recurse(&arg_i, &element_i);
 433     while (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
 434         DBusMessageIter dict_i;
 435
 436         dbus_message_iter_recurse(&element_i, &dict_i);
 437
 438         /* TODO: parse interfaces and properties */
 439
 440         dbus_message_iter_next(&element_i);
 441     }
 442
 443     y->objects_listed = true;
 444
 445 finish:
 446     dbus_message_unref(r);
 447
 448     PA_LLIST_REMOVE(pa_dbus_pending, y->pending, p);
 449     pa_dbus_pending_free(p);
 450 }
 451
 452 static void get_managed_objects(pa_bluetooth_discovery *y) {
 453     DBusMessage *m;
 454
 455     pa_assert(y);
 456
 457     pa_assert_se(m = dbus_message_new_method_call(BLUEZ_SERVICE, "/", "org.freedesktop.DBus.ObjectManager",
 458                                                   "GetManagedObjects"));
 459     send_and_add_to_pending(y, m, get_managed_objects_reply, NULL);
 460 }
 461
 462 pa_hook* pa_bluetooth_discovery_hook(pa_bluetooth_discovery *y, pa_bluetooth_hook_t hook) {
 463     pa_assert(y);
 464     pa_assert(PA_REFCNT_VALUE(y) > 0);
 465
 466     return &y->hooks[hook];
 467 }
 468
 469 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *m, void *userdata) {
 470     pa_bluetooth_discovery *y;
 471     DBusError err;
 472
 473     pa_assert(bus);
 474     pa_assert(m);
 475     pa_assert_se(y = userdata);
 476
 477     dbus_error_init(&err);
 478
 479     if (dbus_message_is_signal(m, "org.freedesktop.DBus", "NameOwnerChanged")) {
 480         const char *name, *old_owner, *new_owner;
 481
 482         if (!dbus_message_get_args(m, &err,
 483                                    DBUS_TYPE_STRING, &name,
 484                                    DBUS_TYPE_STRING, &old_owner,
 485                                    DBUS_TYPE_STRING, &new_owner,
 486                                    DBUS_TYPE_INVALID)) {
 487             pa_log_error("Failed to parse org.freedesktop.DBus.NameOwnerChanged: %s", err.message);
 488             goto fail;
 489         }
 490
 491         if (pa_streq(name, BLUEZ_SERVICE)) {
 492             if (old_owner && *old_owner) {
 493                 pa_log_debug("Bluetooth daemon disappeared");
 494                 device_remove_all(y);
 495                 adapter_remove_all(y);
 496                 y->objects_listed = false;
 497             }
 498
 499             if (new_owner && *new_owner) {
 500                 pa_log_debug("Bluetooth daemon appeared");
 501                 get_managed_objects(y);
 502             }
 503         }
 504
 505         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 506     } else if (dbus_message_is_signal(m, "org.freedesktop.DBus.ObjectManager", "InterfacesAdded")) {
 507         DBusMessageIter arg_i;
 508
 509         if (!y->objects_listed)
 510             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* No reply received yet from GetManagedObjects */
 511
 512         if (!dbus_message_iter_init(m, &arg_i) || !pa_streq(dbus_message_get_signature(m), "oa{sa{sv}}")) {
 513             pa_log_error("Invalid signature found in InterfacesAdded");
 514             goto fail;
 515         }
 516
 517         /* TODO: parse interfaces and properties */
 518
 519         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 520     } else if (dbus_message_is_signal(m, "org.freedesktop.DBus.ObjectManager", "InterfacesRemoved")) {
 521         const char *p;
 522         DBusMessageIter arg_i;
 523         DBusMessageIter element_i;
 524
 525         if (!y->objects_listed)
 526             return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* No reply received yet from GetManagedObjects */
 527
 528         if (!dbus_message_iter_init(m, &arg_i) || !pa_streq(dbus_message_get_signature(m), "oas")) {
 529             pa_log_error("Invalid signature found in InterfacesRemoved");
 530             goto fail;
 531         }
 532
 533         dbus_message_iter_get_basic(&arg_i, &p);
 534
 535         pa_assert_se(dbus_message_iter_next(&arg_i));
 536         pa_assert(dbus_message_iter_get_arg_type(&arg_i) == DBUS_TYPE_ARRAY);
 537
 538         dbus_message_iter_recurse(&arg_i, &element_i);
 539
 540         while (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_STRING) {
 541             const char *iface;
 542
 543             dbus_message_iter_get_basic(&element_i, &iface);
 544
 545             if (pa_streq(iface, BLUEZ_DEVICE_INTERFACE))
 546                 device_remove(y, p);
 547             else if (pa_streq(iface, BLUEZ_ADAPTER_INTERFACE))
 548                 adapter_remove(y, p);
 549
 550             dbus_message_iter_next(&element_i);
 551         }
 552
 553         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 554
 555     }
 556
 557 fail:
 558     dbus_error_free(&err);
 559
 560     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 561 }
 562
 563 static uint8_t a2dp_default_bitpool(uint8_t freq, uint8_t mode) {
 564     /* These bitpool values were chosen based on the A2DP spec recommendation */
 565     switch (freq) {
 566         case SBC_SAMPLING_FREQ_16000:
 567         case SBC_SAMPLING_FREQ_32000:
 568             return 53;
 569
 570         case SBC_SAMPLING_FREQ_44100:
 571
 572             switch (mode) {
 573                 case SBC_CHANNEL_MODE_MONO:
 574                 case SBC_CHANNEL_MODE_DUAL_CHANNEL:
 575                     return 31;
 576
 577                 case SBC_CHANNEL_MODE_STEREO:
 578                 case SBC_CHANNEL_MODE_JOINT_STEREO:
 579                     return 53;
 580             }
 581
 582             pa_log_warn("Invalid channel mode %u", mode);
 583             return 53;
 584
 585         case SBC_SAMPLING_FREQ_48000:
 586
 587             switch (mode) {
 588                 case SBC_CHANNEL_MODE_MONO:
 589                 case SBC_CHANNEL_MODE_DUAL_CHANNEL:
 590                     return 29;
 591
 592                 case SBC_CHANNEL_MODE_STEREO:
 593                 case SBC_CHANNEL_MODE_JOINT_STEREO:
 594                     return 51;
 595             }
 596
 597             pa_log_warn("Invalid channel mode %u", mode);
 598             return 51;
 599     }
 600
 601     pa_log_warn("Invalid sampling freq %u", freq);
 602     return 53;
 603 }
 604
 605 const char *pa_bluetooth_profile_to_string(pa_bluetooth_profile_t profile) {
 606     switch(profile) {
 607         case PA_BLUETOOTH_PROFILE_A2DP_SINK:
 608             return "a2dp_sink";
 609         case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
 610             return "a2dp_source";
 611         case PA_BLUETOOTH_PROFILE_OFF:
 612             return "off";
 613     }
 614
 615     return NULL;
 616 }
 617
 618 static DBusMessage *endpoint_set_configuration(DBusConnection *conn, DBusMessage *m, void *userdata) {
 619     pa_bluetooth_discovery *y = userdata;
 620     pa_bluetooth_device *d;
 621     pa_bluetooth_transport *t;
 622     const char *sender, *path, *endpoint_path, *dev_path = NULL, *uuid = NULL;
 623     const uint8_t *config = NULL;
 624     int size = 0;
 625     pa_bluetooth_profile_t p = PA_BLUETOOTH_PROFILE_OFF;
 626     DBusMessageIter args, props;
 627     DBusMessage *r;
 628
 629     if (!dbus_message_iter_init(m, &args) || !pa_streq(dbus_message_get_signature(m), "oa{sv}")) {
 630         pa_log_error("Invalid signature for method SetConfiguration()");
 631         goto fail2;
 632     }
 633
 634     dbus_message_iter_get_basic(&args, &path);
 635
 636     if (pa_hashmap_get(y->transports, path)) {
 637         pa_log_error("Endpoint SetConfiguration(): Transport %s is already configured.", path);
 638         goto fail2;
 639     }
 640
 641     pa_assert_se(dbus_message_iter_next(&args));
 642
 643     dbus_message_iter_recurse(&args, &props);
 644     if (dbus_message_iter_get_arg_type(&props) != DBUS_TYPE_DICT_ENTRY)
 645         goto fail;
 646
 647     /* Read transport properties */
 648     while (dbus_message_iter_get_arg_type(&props) == DBUS_TYPE_DICT_ENTRY) {
 649         const char *key;
 650         DBusMessageIter value, entry;
 651         int var;
 652
 653         dbus_message_iter_recurse(&props, &entry);
 654         dbus_message_iter_get_basic(&entry, &key);
 655
 656         dbus_message_iter_next(&entry);
 657         dbus_message_iter_recurse(&entry, &value);
 658
 659         var = dbus_message_iter_get_arg_type(&value);
 660
 661         if (pa_streq(key, "UUID")) {
 662             if (var != DBUS_TYPE_STRING) {
 663                 pa_log_error("Property %s of wrong type %c", key, (char)var);
 664                 goto fail;
 665             }
 666
 667             dbus_message_iter_get_basic(&value, &uuid);
 668
 669             endpoint_path = dbus_message_get_path(m);
 670             if (pa_streq(endpoint_path, A2DP_SOURCE_ENDPOINT)) {
 671                 if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SOURCE))
 672                     p = PA_BLUETOOTH_PROFILE_A2DP_SINK;
 673             } else if (pa_streq(endpoint_path, A2DP_SINK_ENDPOINT)) {
 674                 if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SINK))
 675                     p = PA_BLUETOOTH_PROFILE_A2DP_SOURCE;
 676             }
 677
 678             if (p == PA_BLUETOOTH_PROFILE_OFF) {
 679                 pa_log_error("UUID %s of transport %s incompatible with endpoint %s", uuid, path, endpoint_path);
 680                 goto fail;
 681             }
 682         } else if (pa_streq(key, "Device")) {
 683             if (var != DBUS_TYPE_OBJECT_PATH) {
 684                 pa_log_error("Property %s of wrong type %c", key, (char)var);
 685                 goto fail;
 686             }
 687
 688             dbus_message_iter_get_basic(&value, &dev_path);
 689         } else if (pa_streq(key, "Configuration")) {
 690             DBusMessageIter array;
 691             a2dp_sbc_t *c;
 692
 693             if (var != DBUS_TYPE_ARRAY) {
 694                 pa_log_error("Property %s of wrong type %c", key, (char)var);
 695                 goto fail;
 696             }
 697
 698             dbus_message_iter_recurse(&value, &array);
 699             var = dbus_message_iter_get_arg_type(&array);
 700             if (var != DBUS_TYPE_BYTE) {
 701                 pa_log_error("%s is an array of wrong type %c", key, (char)var);
 702                 goto fail;
 703             }
 704
 705             dbus_message_iter_get_fixed_array(&array, &config, &size);
 706             if (size != sizeof(a2dp_sbc_t)) {
 707                 pa_log_error("Configuration array of invalid size");
 708                 goto fail;
 709             }
 710
 711             c = (a2dp_sbc_t *) config;
 712
 713             if (c->frequency != SBC_SAMPLING_FREQ_16000 && c->frequency != SBC_SAMPLING_FREQ_32000 &&
 714                 c->frequency != SBC_SAMPLING_FREQ_44100 && c->frequency != SBC_SAMPLING_FREQ_48000) {
 715                 pa_log_error("Invalid sampling frequency in configuration");
 716                 goto fail;
 717             }
 718
 719             if (c->channel_mode != SBC_CHANNEL_MODE_MONO && c->channel_mode != SBC_CHANNEL_MODE_DUAL_CHANNEL &&
 720                 c->channel_mode != SBC_CHANNEL_MODE_STEREO && c->channel_mode != SBC_CHANNEL_MODE_JOINT_STEREO) {
 721                 pa_log_error("Invalid channel mode in configuration");
 722                 goto fail;
 723             }
 724
 725             if (c->allocation_method != SBC_ALLOCATION_SNR && c->allocation_method != SBC_ALLOCATION_LOUDNESS) {
 726                 pa_log_error("Invalid allocation method in configuration");
 727                 goto fail;
 728             }
 729
 730             if (c->subbands != SBC_SUBBANDS_4 && c->subbands != SBC_SUBBANDS_8) {
 731                 pa_log_error("Invalid SBC subbands in configuration");
 732                 goto fail;
 733             }
 734
 735             if (c->block_length != SBC_BLOCK_LENGTH_4 && c->block_length != SBC_BLOCK_LENGTH_8 &&
 736                 c->block_length != SBC_BLOCK_LENGTH_12 && c->block_length != SBC_BLOCK_LENGTH_16) {
 737                 pa_log_error("Invalid block length in configuration");
 738                 goto fail;
 739             }
 740         }
 741
 742         dbus_message_iter_next(&props);
 743     }
 744
 745     if ((d = pa_hashmap_get(y->devices, dev_path))) {
 746         if (d->device_info_valid == -1) {
 747             pa_log_error("Information about device %s is invalid", dev_path);
 748             goto fail2;
 749         }
 750     } else {
 751         /* InterfacesAdded signal is probably on it's way, device_info_valid is kept as 0. */
 752         pa_log_warn("SetConfiguration() received for unknown device %s", dev_path);
 753         d = device_create(y, dev_path);
 754     }
 755
 756     if (d->transports[p] != NULL) {
 757         pa_log_error("Cannot configure transport %s because profile %s is already used", path, pa_bluetooth_profile_to_string(p));
 758         goto fail2;
 759     }
 760
 761     sender = dbus_message_get_sender(m);
 762
 763     pa_assert_se(r = dbus_message_new_method_return(m));
 764     pa_assert_se(dbus_connection_send(pa_dbus_connection_get(y->connection), r, NULL));
 765     dbus_message_unref(r);
 766
 767     d->transports[p] = t = pa_bluetooth_transport_new(d, sender, path, p, config, size);
 768     t->acquire = bluez5_transport_acquire_cb;
 769     t->release = bluez5_transport_release_cb;
 770     pa_bluetooth_transport_put(t);
 771
 772     pa_log_debug("Transport %s available for profile %s", t->path, pa_bluetooth_profile_to_string(t->profile));
 773
 774     return NULL;
 775
 776 fail:
 777     pa_log_error("Endpoint SetConfiguration(): invalid arguments");
 778
 779 fail2:
 780     pa_assert_se(r = dbus_message_new_error(m, "org.bluez.Error.InvalidArguments", "Unable to set configuration"));
 781     return r;
 782 }
 783
 784 static DBusMessage *endpoint_select_configuration(DBusConnection *conn, DBusMessage *m, void *userdata) {
 785     pa_bluetooth_discovery *y = userdata;
 786     a2dp_sbc_t *cap, config;
 787     uint8_t *pconf = (uint8_t *) &config;
 788     int i, size;
 789     DBusMessage *r;
 790     DBusError err;
 791
 792     static const struct {
 793         uint32_t rate;
 794         uint8_t cap;
 795     } freq_table[] = {
 796         { 16000U, SBC_SAMPLING_FREQ_16000 },
 797         { 32000U, SBC_SAMPLING_FREQ_32000 },
 798         { 44100U, SBC_SAMPLING_FREQ_44100 },
 799         { 48000U, SBC_SAMPLING_FREQ_48000 }
 800     };
 801
 802     dbus_error_init(&err);
 803
 804     if (!dbus_message_get_args(m, &err, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &cap, &size, DBUS_TYPE_INVALID)) {
 805         pa_log_error("Endpoint SelectConfiguration(): %s", err.message);
 806         dbus_error_free(&err);
 807         goto fail;
 808     }
 809
 810     if (size != sizeof(config)) {
 811         pa_log_error("Capabilities array has invalid size");
 812         goto fail;
 813     }
 814
 815     pa_zero(config);
 816
 817     /* Find the lowest freq that is at least as high as the requested sampling rate */
 818     for (i = 0; (unsigned) i < PA_ELEMENTSOF(freq_table); i++)
 819         if (freq_table[i].rate >= y->core->default_sample_spec.rate && (cap->frequency & freq_table[i].cap)) {
 820             config.frequency = freq_table[i].cap;
 821             break;
 822         }
 823
 824     if ((unsigned) i == PA_ELEMENTSOF(freq_table)) {
 825         for (--i; i >= 0; i--) {
 826             if (cap->frequency & freq_table[i].cap) {
 827                 config.frequency = freq_table[i].cap;
 828                 break;
 829             }
 830         }
 831
 832         if (i < 0) {
 833             pa_log_error("Not suitable sample rate");
 834             goto fail;
 835         }
 836     }
 837
 838     pa_assert((unsigned) i < PA_ELEMENTSOF(freq_table));
 839
 840     if (y->core->default_sample_spec.channels <= 1) {
 841         if (cap->channel_mode & SBC_CHANNEL_MODE_MONO)
 842             config.channel_mode = SBC_CHANNEL_MODE_MONO;
 843         else if (cap->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO)
 844             config.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
 845         else if (cap->channel_mode & SBC_CHANNEL_MODE_STEREO)
 846             config.channel_mode = SBC_CHANNEL_MODE_STEREO;
 847         else if (cap->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL)
 848             config.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
 849         else {
 850             pa_log_error("No supported channel modes");
 851             goto fail;
 852         }
 853     }
 854
 855     if (y->core->default_sample_spec.channels >= 2) {
 856         if (cap->channel_mode & SBC_CHANNEL_MODE_JOINT_STEREO)
 857             config.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
 858         else if (cap->channel_mode & SBC_CHANNEL_MODE_STEREO)
 859             config.channel_mode = SBC_CHANNEL_MODE_STEREO;
 860         else if (cap->channel_mode & SBC_CHANNEL_MODE_DUAL_CHANNEL)
 861             config.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
 862         else if (cap->channel_mode & SBC_CHANNEL_MODE_MONO)
 863             config.channel_mode = SBC_CHANNEL_MODE_MONO;
 864         else {
 865             pa_log_error("No supported channel modes");
 866             goto fail;
 867         }
 868     }
 869
 870     if (cap->block_length & SBC_BLOCK_LENGTH_16)
 871         config.block_length = SBC_BLOCK_LENGTH_16;
 872     else if (cap->block_length & SBC_BLOCK_LENGTH_12)
 873         config.block_length = SBC_BLOCK_LENGTH_12;
 874     else if (cap->block_length & SBC_BLOCK_LENGTH_8)
 875         config.block_length = SBC_BLOCK_LENGTH_8;
 876     else if (cap->block_length & SBC_BLOCK_LENGTH_4)
 877         config.block_length = SBC_BLOCK_LENGTH_4;
 878     else {
 879         pa_log_error("No supported block lengths");
 880         goto fail;
 881     }
 882
 883     if (cap->subbands & SBC_SUBBANDS_8)
 884         config.subbands = SBC_SUBBANDS_8;
 885     else if (cap->subbands & SBC_SUBBANDS_4)
 886         config.subbands = SBC_SUBBANDS_4;
 887     else {
 888         pa_log_error("No supported subbands");
 889         goto fail;
 890     }
 891
 892     if (cap->allocation_method & SBC_ALLOCATION_LOUDNESS)
 893         config.allocation_method = SBC_ALLOCATION_LOUDNESS;
 894     else if (cap->allocation_method & SBC_ALLOCATION_SNR)
 895         config.allocation_method = SBC_ALLOCATION_SNR;
 896
 897     config.min_bitpool = (uint8_t) PA_MAX(MIN_BITPOOL, cap->min_bitpool);
 898     config.max_bitpool = (uint8_t) PA_MIN(a2dp_default_bitpool(config.frequency, config.channel_mode), cap->max_bitpool);
 899
 900     if (config.min_bitpool > config.max_bitpool)
 901         goto fail;
 902
 903     pa_assert_se(r = dbus_message_new_method_return(m));
 904     pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &pconf, size, DBUS_TYPE_INVALID));
 905
 906     return r;
 907
 908 fail:
 909     pa_assert_se(r = dbus_message_new_error(m, "org.bluez.Error.InvalidArguments", "Unable to select configuration"));
 910     return r;
 911 }
 912
 913 static DBusMessage *endpoint_clear_configuration(DBusConnection *conn, DBusMessage *m, void *userdata) {
 914     pa_bluetooth_discovery *y = userdata;
 915     pa_bluetooth_transport *t;
 916     DBusMessage *r;
 917     DBusError err;
 918     const char *path;
 919
 920     dbus_error_init(&err);
 921
 922     if (!dbus_message_get_args(m, &err, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) {
 923         pa_log_error("Endpoint ClearConfiguration(): %s", err.message);
 924         dbus_error_free(&err);
 925         goto fail;
 926     }
 927
 928     if ((t = pa_hashmap_get(y->transports, path))) {
 929         pa_log_debug("Clearing transport %s profile %s", t->path, pa_bluetooth_profile_to_string(t->profile));
 930         transport_state_changed(t, PA_BLUETOOTH_TRANSPORT_STATE_DISCONNECTED);
 931         pa_bluetooth_transport_free(t);
 932     }
 933
 934     pa_assert_se(r = dbus_message_new_method_return(m));
 935
 936     return r;
 937
 938 fail:
 939     pa_assert_se(r = dbus_message_new_error(m, "org.bluez.Error.InvalidArguments", "Unable to clear configuration"));
 940     return r;
 941 }
 942
 943 static DBusMessage *endpoint_release(DBusConnection *conn, DBusMessage *m, void *userdata) {
 944     DBusMessage *r;
 945
 946     pa_assert_se(r = dbus_message_new_error(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE ".Error.NotImplemented",
 947                                             "Method not implemented"));
 948
 949     return r;
 950 }
 951
 952 static DBusHandlerResult endpoint_handler(DBusConnection *c, DBusMessage *m, void *userdata) {
 953     struct pa_bluetooth_discovery *y = userdata;
 954     DBusMessage *r = NULL;
 955     const char *path, *interface, *member;
 956
 957     pa_assert(y);
 958
 959     path = dbus_message_get_path(m);
 960     interface = dbus_message_get_interface(m);
 961     member = dbus_message_get_member(m);
 962
 963     pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
 964
 965     if (!pa_streq(path, A2DP_SOURCE_ENDPOINT) && !pa_streq(path, A2DP_SINK_ENDPOINT))
 966         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 967
 968     if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 969         const char *xml = ENDPOINT_INTROSPECT_XML;
 970
 971         pa_assert_se(r = dbus_message_new_method_return(m));
 972         pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID));
 973
 974     } else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "SetConfiguration"))
 975         r = endpoint_set_configuration(c, m, userdata);
 976     else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "SelectConfiguration"))
 977         r = endpoint_select_configuration(c, m, userdata);
 978     else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "ClearConfiguration"))
 979         r = endpoint_clear_configuration(c, m, userdata);
 980     else if (dbus_message_is_method_call(m, BLUEZ_MEDIA_ENDPOINT_INTERFACE, "Release"))
 981         r = endpoint_release(c, m, userdata);
 982     else
 983         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 984
 985     if (r) {
 986         pa_assert_se(dbus_connection_send(pa_dbus_connection_get(y->connection), r, NULL));
 987         dbus_message_unref(r);
 988     }
 989
 990     return DBUS_HANDLER_RESULT_HANDLED;
 991 }
 992
 993 static void endpoint_init(pa_bluetooth_discovery *y, pa_bluetooth_profile_t profile) {
 994     static const DBusObjectPathVTable vtable_endpoint = {
 995         .message_function = endpoint_handler,
 996     };
 997
 998     pa_assert(y);
 999
1000     switch(profile) {
1001         case PA_BLUETOOTH_PROFILE_A2DP_SINK:
1002             pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(y->connection), A2DP_SOURCE_ENDPOINT,
1003                                                               &vtable_endpoint, y));
1004             break;
1005         case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
1006             pa_assert_se(dbus_connection_register_object_path(pa_dbus_connection_get(y->connection), A2DP_SINK_ENDPOINT,
1007                                                               &vtable_endpoint, y));
1008             break;
1009         default:
1010             pa_assert_not_reached();
1011             break;
1012     }
1013 }
1014
1015 static void endpoint_done(pa_bluetooth_discovery *y, pa_bluetooth_profile_t profile) {
1016     pa_assert(y);
1017
1018     switch(profile) {
1019         case PA_BLUETOOTH_PROFILE_A2DP_SINK:
1020             dbus_connection_unregister_object_path(pa_dbus_connection_get(y->connection), A2DP_SOURCE_ENDPOINT);
1021             break;
1022         case PA_BLUETOOTH_PROFILE_A2DP_SOURCE:
1023             dbus_connection_unregister_object_path(pa_dbus_connection_get(y->connection), A2DP_SINK_ENDPOINT);
1024             break;
1025         default:
1026             pa_assert_not_reached();
1027             break;
1028     }
1029 }
1030
1031 pa_bluetooth_discovery* pa_bluetooth_discovery_get(pa_core *c) {
1032     pa_bluetooth_discovery *y;
1033     DBusError err;
1034     DBusConnection *conn;
1035     unsigned i;
1036
1037     if ((y = pa_shared_get(c, "bluetooth-discovery")))
1038         return pa_bluetooth_discovery_ref(y);
1039
1040     y = pa_xnew0(pa_bluetooth_discovery, 1);
1041     PA_REFCNT_INIT(y);
1042     y->core = c;
1043     y->adapters = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1044     y->devices = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1045     y->transports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
1046     PA_LLIST_HEAD_INIT(pa_dbus_pending, y->pending);
1047
1048     for (i = 0; i < PA_BLUETOOTH_HOOK_MAX; i++)
1049         pa_hook_init(&y->hooks[i], y);
1050
1051     pa_shared_set(c, "bluetooth-discovery", y);
1052
1053     dbus_error_init(&err);
1054
1055     if (!(y->connection = pa_dbus_bus_get(y->core, DBUS_BUS_SYSTEM, &err))) {
1056         pa_log_error("Failed to get D-Bus connection: %s", err.message);
1057         goto fail;
1058     }
1059
1060     conn = pa_dbus_connection_get(y->connection);
1061
1062     /* dynamic detection of bluetooth audio devices */
1063     if (!dbus_connection_add_filter(conn, filter_cb, y, NULL)) {
1064         pa_log_error("Failed to add filter function");
1065         goto fail;
1066     }
1067     y->filter_added = true;
1068
1069     if (pa_dbus_add_matches(conn, &err,
1070             "type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged'"
1071             ",arg0='" BLUEZ_SERVICE "'",
1072             "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',member='InterfacesAdded'",
1073             "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',"
1074             "member='InterfacesRemoved'",
1075             NULL) < 0) {
1076         pa_log_error("Failed to add D-Bus matches: %s", err.message);
1077         goto fail;
1078     }
1079     y->matches_added = true;
1080
1081     endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_SINK);
1082     endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_SOURCE);
1083
1084     get_managed_objects(y);
1085
1086     return y;
1087
1088 fail:
1089     pa_bluetooth_discovery_unref(y);
1090     dbus_error_free(&err);
1091
1092     return NULL;
1093 }
1094
1095 pa_bluetooth_discovery* pa_bluetooth_discovery_ref(pa_bluetooth_discovery *y) {
1096     pa_assert(y);
1097     pa_assert(PA_REFCNT_VALUE(y) > 0);
1098
1099     PA_REFCNT_INC(y);
1100
1101     return y;
1102 }
1103
1104 void pa_bluetooth_discovery_unref(pa_bluetooth_discovery *y) {
1105     pa_assert(y);
1106     pa_assert(PA_REFCNT_VALUE(y) > 0);
1107
1108     if (PA_REFCNT_DEC(y) > 0)
1109         return;
1110
1111     pa_dbus_free_pending_list(&y->pending);
1112
1113     if (y->devices) {
1114         device_remove_all(y);
1115         pa_hashmap_free(y->devices);
1116     }
1117
1118     if (y->adapters) {
1119         adapter_remove_all(y);
1120         pa_hashmap_free(y->adapters);
1121     }
1122
1123     if (y->transports) {
1124         pa_assert(pa_hashmap_isempty(y->transports));
1125         pa_hashmap_free(y->transports);
1126     }
1127
1128     if (y->connection) {
1129
1130         if (y->matches_added)
1131             pa_dbus_remove_matches(pa_dbus_connection_get(y->connection),
1132                 "type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',"
1133                 "arg0='" BLUEZ_SERVICE "'",
1134                 "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',"
1135                 "member='InterfacesAdded'",
1136                 "type='signal',sender='" BLUEZ_SERVICE "',interface='org.freedesktop.DBus.ObjectManager',"
1137                 "member='InterfacesRemoved'",
1138                 NULL);
1139
1140         if (y->filter_added)
1141             dbus_connection_remove_filter(pa_dbus_connection_get(y->connection), filter_cb, y);
1142
1143         endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_SINK);
1144         endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_SOURCE);
1145
1146         pa_dbus_connection_unref(y->connection);
1147     }
1148
1149     pa_shared_remove(y->core, "bluetooth-discovery");
1150     pa_xfree(y);
1151 }