src/modules/module-bt-discover.c

   1 /***
   2     This file is part of PulseAudio.
   3
   4     Copyright 2008 Joao 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 published
   8     by the Free Software Foundation; either version 2 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 #include <config.h>
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include <pulse/xmalloc.h>
  29 #include <pulsecore/module.h>
  30 #include <pulsecore/modargs.h>
  31 #include <pulsecore/macro.h>
  32 #include <pulsecore/llist.h>
  33
  34 #include "dbus-util.h"
  35 #include "module-bt-discover-symdef.h"
  36
  37 PA_MODULE_AUTHOR("Joao Paulo Rechi Vita");
  38 PA_MODULE_DESCRIPTION("Detect available bluetooth audio devices and load bluetooth audio drivers");
  39 PA_MODULE_VERSION(PACKAGE_VERSION);
  40 PA_MODULE_USAGE("");
  41
  42 #define HSP_HS_UUID             "00001108-0000-1000-8000-00805F9B34FB"
  43 #define HFP_HS_UUID             "0000111E-0000-1000-8000-00805F9B34FB"
  44 #define A2DP_SOURCE_UUID        "0000110A-0000-1000-8000-00805F9B34FB"
  45 #define A2DP_SINK_UUID          "0000110B-0000-1000-8000-00805F9B34FB"
  46
  47 struct uuid {
  48     char *uuid;
  49     PA_LLIST_FIELDS(struct uuid);
  50 };
  51
  52 struct device {
  53     char *name;
  54     char *object_path;
  55     int paired;
  56     struct adapter *adapter;
  57     char *alias;
  58     int connected;
  59     PA_LLIST_HEAD(struct uuid, uuid_list);
  60     char *address;
  61     int class;
  62     int trusted;
  63     PA_LLIST_FIELDS(struct device);
  64 };
  65
  66 struct adapter {
  67     char *object_path;
  68     char *mode;
  69     char *address;
  70     PA_LLIST_HEAD(struct device, device_list);
  71     PA_LLIST_FIELDS(struct adapter);
  72 };
  73
  74 struct userdata {
  75     pa_module *module;
  76     pa_dbus_connection *conn;
  77     PA_LLIST_HEAD(struct adapter, adapter_list);
  78 };
  79
  80 static struct uuid *uuid_new(const char *uuid) {
  81     struct uuid *node = pa_xnew(struct uuid, 1);
  82     node->uuid = pa_xstrdup(uuid);
  83     PA_LLIST_INIT(struct uuid, node);
  84     return node;
  85 }
  86
  87 static void uuid_free(struct uuid *uuid) {
  88     pa_xfree(uuid);
  89 }
  90
  91 static struct device *device_new(const char *device, struct adapter *adapter) {
  92     struct device *node = pa_xnew(struct device, 1);
  93     node->name = NULL;
  94     node->object_path = pa_xstrdup(device);
  95     node->paired = -1;
  96     node->adapter = adapter;
  97     node->alias = NULL;
  98     node->connected = -1;
  99     PA_LLIST_HEAD_INIT(struct uuid, node->uuid_list);
 100     node->address = NULL;
 101     node->class = -1;
 102     node->trusted = -1;
 103     PA_LLIST_INIT(struct device, node);
 104     return node;
 105 }
 106
 107 static void device_free(struct device *device) {
 108     struct uuid *uuid_list_i;
 109     while (device->uuid_list) {
 110         uuid_list_i = device->uuid_list;
 111         PA_LLIST_REMOVE(struct uuid, device->uuid_list, uuid_list_i);
 112         uuid_free(uuid_list_i);
 113     }
 114     pa_xfree(device);
 115 }
 116
 117 static struct adapter *adapter_new(const char *adapter) {
 118     struct adapter *node = pa_xnew(struct adapter, 1);
 119     node->object_path = pa_xstrdup(adapter);
 120     node->mode = NULL;
 121     node->address = NULL;
 122     PA_LLIST_HEAD_INIT(struct device, node->device_list);
 123     PA_LLIST_INIT(struct adapter, node);
 124     return node;
 125 }
 126
 127 static void adapter_free(struct adapter *adapter) {
 128     struct device *device_list_i;
 129     while (adapter->device_list) {
 130         device_list_i = adapter->device_list;
 131         PA_LLIST_REMOVE(struct device, adapter->device_list, device_list_i);
 132         device_free(device_list_i);
 133     }
 134     pa_xfree(adapter);
 135 }
 136
 137 static void print_devices(struct device *device_list) {
 138     struct device *device_list_i = device_list;
 139     while (device_list_i != NULL) {
 140         struct uuid *uuid_list_i = device_list_i->uuid_list;
 141         if (strcmp(device_list_i->object_path, "/DEVICE_HEAD") != 0) {
 142             pa_log("    [ %s ]", device_list_i->object_path);
 143             pa_log("        Name = %s", device_list_i->name);
 144             pa_log("        Paired = %d", device_list_i->paired);
 145             pa_log("        Adapter = %s", device_list_i->adapter->object_path);
 146             pa_log("        Alias = %s", device_list_i->alias);
 147             pa_log("        Connected = %d", device_list_i->connected);
 148             pa_log("        UUIDs = ");
 149             while (uuid_list_i != NULL) {
 150                 if (strcmp(uuid_list_i->uuid, "UUID_HEAD") != 0)
 151                     pa_log("            %s", uuid_list_i->uuid);
 152                 uuid_list_i = uuid_list_i->next;
 153             }
 154             pa_log("        Address = %s", device_list_i->address);
 155             pa_log("        Class = 0x%x", device_list_i->class);
 156             pa_log("        Trusted = %d", device_list_i->trusted);
 157         }
 158         device_list_i = device_list_i->next;
 159     }
 160 }
 161
 162 static void print_adapters(struct adapter *adapter_list) {
 163     struct adapter *adapter_list_i = adapter_list;
 164     while (adapter_list_i != NULL) {
 165         if (strcmp(adapter_list_i->object_path, "/ADAPTER_HEAD") != 0) {
 166             pa_log("[ %s ]", adapter_list_i->object_path);
 167             pa_log("    Mode = %s", adapter_list_i->mode);
 168             pa_log("    Address = %s", adapter_list_i->address);
 169             print_devices(adapter_list_i->device_list);
 170         }
 171         adapter_list_i = adapter_list_i->next;
 172     }
 173 }
 174
 175 static void detect_adapters(struct userdata *u) {
 176     DBusError e;
 177     DBusMessage *m = NULL, *r = NULL;
 178     DBusMessageIter arg_i, element_i, dict_i, variant_i;
 179     struct adapter *adapter_list_i;
 180     const char *key, *value;
 181
 182     pa_assert(u);
 183     dbus_error_init(&e);
 184
 185     /* get adapters */
 186     pa_assert_se(m = dbus_message_new_method_call("org.bluez", "/", "org.bluez.Manager", "ListAdapters"));
 187     r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(u->conn), m, -1, &e);
 188     if (!r) {
 189         pa_log("org.bluez.Manager.ListAdapters failed: %s", e.message);
 190         goto fail;
 191     }
 192     if (!dbus_message_iter_init(r, &arg_i)) {
 193         pa_log("org.bluez.Manager.ListAdapters reply has no arguments");
 194         goto fail;
 195     }
 196     if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
 197         pa_log("org.bluez.Manager.ListAdapters argument is not an array");
 198         goto fail;
 199     }
 200     dbus_message_iter_recurse(&arg_i, &element_i);
 201     while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
 202         if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_OBJECT_PATH) {
 203             struct adapter *node;
 204             dbus_message_iter_get_basic(&element_i, &value);
 205             node = adapter_new(value);
 206             PA_LLIST_PREPEND(struct adapter, u->adapter_list, node);
 207         }
 208         dbus_message_iter_next(&element_i);
 209     }
 210
 211     /* get adapter properties */
 212     adapter_list_i = u->adapter_list;
 213     while (adapter_list_i != NULL) {
 214         pa_assert_se(m = dbus_message_new_method_call("org.bluez", adapter_list_i->object_path, "org.bluez.Adapter", "GetProperties"));
 215         r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(u->conn), m, -1, &e);
 216         if (!r) {
 217             pa_log("org.bluez.Adapter.GetProperties failed: %s", e.message);
 218             goto fail;
 219         }
 220         if (!dbus_message_iter_init(r, &arg_i)) {
 221             pa_log("org.bluez.Adapter.GetProperties reply has no arguments");
 222             goto fail;
 223         }
 224         if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
 225             pa_log("org.bluez.Adapter.GetProperties argument is not an array");
 226             goto fail;
 227         }
 228         dbus_message_iter_recurse(&arg_i, &element_i);
 229         while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
 230             if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
 231                 dbus_message_iter_recurse(&element_i, &dict_i);
 232                 dbus_message_iter_get_basic(&dict_i, &key);
 233                 dbus_message_iter_next(&dict_i);
 234                 dbus_message_iter_recurse(&dict_i, &variant_i);
 235                 dbus_message_iter_get_basic(&variant_i, &value);
 236                 if (strcmp(key, "Mode") == 0)
 237                     adapter_list_i->mode = pa_xstrdup(value);
 238                 else if (strcmp(key, "Address") == 0)
 239                     adapter_list_i->address = pa_xstrdup(value);
 240             }
 241             dbus_message_iter_next(&element_i);
 242         }
 243         adapter_list_i = adapter_list_i->next;
 244     }
 245
 246 fail:
 247     if (m)
 248         dbus_message_unref(m);
 249     if (r)
 250         dbus_message_unref(r);
 251     dbus_error_free(&e);
 252 }
 253
 254 static void detect_devices(struct userdata *u) {
 255     DBusError e;
 256     DBusMessage *m = NULL, *r = NULL;
 257     DBusMessageIter arg_i, element_i, dict_i, variant_i;
 258     struct adapter *adapter_list_i;
 259     struct device *device_list_i;
 260     const char *key, *value;
 261     unsigned int uvalue;
 262
 263     pa_assert(u);
 264     dbus_error_init(&e);
 265
 266     /* get devices of each adapter */
 267     adapter_list_i = u->adapter_list;
 268     while (adapter_list_i != NULL) {
 269         pa_assert_se(m = dbus_message_new_method_call("org.bluez", adapter_list_i->object_path, "org.bluez.Adapter", "ListDevices"));
 270         r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(u->conn), m, -1, &e);
 271         if (!r) {
 272             pa_log("org.bluez.Adapter.ListDevices failed: %s", e.message);
 273             goto fail;
 274         }
 275         if (!dbus_message_iter_init(r, &arg_i)) {
 276             pa_log("org.bluez.Adapter.ListDevices reply has no arguments");
 277             goto fail;
 278         }
 279         if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
 280             pa_log("org.bluez.Adapter.ListDevices argument is not an array");
 281             goto fail;
 282         }
 283         dbus_message_iter_recurse(&arg_i, &element_i);
 284         while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
 285             if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_OBJECT_PATH) {
 286                 struct device *node;
 287                 dbus_message_iter_get_basic(&element_i, &value);
 288                 node = device_new(value, adapter_list_i);
 289                 PA_LLIST_PREPEND(struct device, adapter_list_i->device_list, node);
 290             }
 291             dbus_message_iter_next(&element_i);
 292         }
 293         adapter_list_i = adapter_list_i->next;
 294     }
 295
 296     /* get device properties */
 297     adapter_list_i = u->adapter_list;
 298     while (adapter_list_i != NULL) {
 299         device_list_i = adapter_list_i->device_list;
 300         while (device_list_i != NULL) {
 301             pa_assert_se(m = dbus_message_new_method_call("org.bluez", device_list_i->object_path, "org.bluez.Device", "GetProperties"));
 302             r = dbus_connection_send_with_reply_and_block(pa_dbus_connection_get(u->conn), m, -1, &e);
 303             if (!r) {
 304                 pa_log("org.bluez.Device.GetProperties failed: %s", e.message);
 305                 goto fail;
 306             }
 307             if (!dbus_message_iter_init(r, &arg_i)) {
 308                 pa_log("org.bluez.Device.GetProperties reply has no arguments");
 309                 goto fail;
 310             }
 311             if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
 312                 pa_log("org.bluez.Device.GetProperties argument is not an array");
 313                 goto fail;
 314             }
 315             dbus_message_iter_recurse(&arg_i, &element_i);
 316             while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
 317                 if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
 318                     dbus_message_iter_recurse(&element_i, &dict_i);
 319                     dbus_message_iter_get_basic(&dict_i, &key);
 320                     dbus_message_iter_next(&dict_i);
 321                     dbus_message_iter_recurse(&dict_i, &variant_i);
 322                     if (strcmp(key, "Name") == 0) {
 323                         dbus_message_iter_get_basic(&variant_i, &value);
 324                         device_list_i->name = pa_xstrdup(value);
 325                     }
 326                     else if (strcmp(key, "Paired") == 0) {
 327                         dbus_message_iter_get_basic(&variant_i, &uvalue);
 328                         device_list_i->paired = uvalue;
 329                     }
 330                     else if (strcmp(key, "Alias") == 0) {
 331                         dbus_message_iter_get_basic(&variant_i, &value);
 332                         device_list_i->alias = pa_xstrdup(value);
 333                     }
 334                     else if (strcmp(key, "Connected") == 0) {
 335                         dbus_message_iter_get_basic(&variant_i, &uvalue);
 336                         device_list_i->connected = uvalue;
 337                     }
 338                     else if (strcmp(key, "UUIDs") == 0) {
 339                         DBusMessageIter uuid_i;
 340                         pa_bool_t is_audio_device = FALSE;
 341                         dbus_message_iter_recurse(&variant_i, &uuid_i);
 342                         while (dbus_message_iter_get_arg_type(&uuid_i) != DBUS_TYPE_INVALID) {
 343                             struct uuid *node;
 344                             dbus_message_iter_get_basic(&uuid_i, &value);
 345                             node = uuid_new(value);
 346                             PA_LLIST_PREPEND(struct uuid, device_list_i->uuid_list, node);
 347                             if ( (strcasecmp(value, HSP_HS_UUID) == 0) || (strcasecmp(value, HFP_HS_UUID) == 0) ||
 348                                 (strcasecmp(value, A2DP_SOURCE_UUID) == 0) || (strcasecmp(value, A2DP_SINK_UUID) == 0) )
 349                                 is_audio_device = TRUE;
 350                             dbus_message_iter_next(&uuid_i);
 351                         }
 352                         if (!is_audio_device) {
 353                             /* remove the current device from the list */
 354                             PA_LLIST_REMOVE(struct device, adapter_list_i->device_list, device_list_i);
 355                             pa_xfree(device_list_i);
 356                             break;
 357                         }
 358                     }
 359                     else if (strcmp(key, "Address") == 0) {
 360                         dbus_message_iter_get_basic(&variant_i, &value);
 361                         device_list_i->address = pa_xstrdup(value);
 362                     }
 363                     else if (strcmp(key, "Class") == 0) {
 364                         dbus_message_iter_get_basic(&variant_i, &uvalue);
 365                         device_list_i->class = uvalue;
 366                     }
 367                     else if (strcmp(key, "Trusted") == 0) {
 368                         dbus_message_iter_get_basic(&variant_i, &uvalue);
 369                         device_list_i->trusted = uvalue;
 370                     }
 371                 }
 372                 dbus_message_iter_next(&element_i);
 373             }
 374             device_list_i = device_list_i->next;
 375         }
 376         adapter_list_i = adapter_list_i->next;
 377     }
 378
 379 fail:
 380     if (m)
 381         dbus_message_unref(m);
 382     if (r)
 383         dbus_message_unref(r);
 384     dbus_error_free(&e);
 385 }
 386
 387 static DBusHandlerResult filter_cb(DBusConnection *bus, DBusMessage *msg, void *userdata) {
 388     DBusMessageIter arg_i;
 389     DBusError err;
 390     const char *value;
 391     struct userdata *u;
 392
 393     pa_assert(bus);
 394     pa_assert(msg);
 395     pa_assert(userdata);
 396     u = userdata;
 397     dbus_error_init(&err);
 398
 399     pa_log("dbus: interface=%s, path=%s, member=%s\n",
 400             dbus_message_get_interface(msg),
 401             dbus_message_get_path(msg),
 402             dbus_message_get_member(msg));
 403
 404     if (dbus_message_is_signal(msg, "org.bluez.Manager", "AdapterAdded")) {
 405         if (!dbus_message_iter_init(msg, &arg_i))
 406             pa_log("dbus: message has no parameters");
 407         else if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_OBJECT_PATH)
 408             pa_log("dbus: argument is not object path");
 409         else {
 410             dbus_message_iter_get_basic(&arg_i, &value);
 411             pa_log("hcid: adapter %s added", value);
 412         }
 413     }
 414     else if (dbus_message_is_signal(msg, "org.bluez.Manager", "AdapterRemoved")) {
 415         if (!dbus_message_iter_init(msg, &arg_i))
 416             pa_log("dbus: message has no parameters");
 417         else if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_OBJECT_PATH)
 418             pa_log("dbus: argument is not object path");
 419         else {
 420             dbus_message_iter_get_basic(&arg_i, &value);
 421             pa_log("hcid: adapter %s removed", value);
 422         }
 423     }
 424     else if (dbus_message_is_signal(msg, "org.bluez.Adapter", "DeviceCreated")) {
 425         if (!dbus_message_iter_init(msg, &arg_i))
 426             pa_log("dbus: message has no parameters");
 427         else if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_OBJECT_PATH)
 428             pa_log("dbus: argument is not object path");
 429         else {
 430             dbus_message_iter_get_basic(&arg_i, &value);
 431             pa_log("hcid: device %s created", value);
 432         }
 433     }
 434     else if (dbus_message_is_signal(msg, "org.bluez.Adapter", "DeviceRemoved")) {
 435         if (!dbus_message_iter_init(msg, &arg_i))
 436             pa_log("dbus: message has no parameters");
 437         else if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_OBJECT_PATH)
 438             pa_log("dbus: argument is not object path");
 439         else {
 440             dbus_message_iter_get_basic(&arg_i, &value);
 441             pa_log("hcid: device %s removed", value);
 442         }
 443     }
 444
 445     dbus_error_free(&err);
 446     return DBUS_HANDLER_RESULT_HANDLED;
 447 }
 448
 449 void pa__done(pa_module* m) {
 450     struct userdata *u;
 451     struct adapter *adapter_list_i;
 452
 453     pa_assert(m);
 454
 455     if (!(u = m->userdata))
 456         return;
 457
 458     while (u->adapter_list) {
 459         adapter_list_i = u->adapter_list;
 460         PA_LLIST_REMOVE(struct adapter, u->adapter_list, adapter_list_i);
 461         adapter_free(adapter_list_i);
 462     }
 463
 464     pa_dbus_connection_unref(u->conn);
 465     pa_xfree(u);
 466     pa_log("Unloading module-bt-discover");
 467     return;
 468 }
 469
 470 int pa__init(pa_module* m) {
 471     pa_modargs *ma = NULL;
 472     DBusError err;
 473     struct adapter *adapter_list_i;
 474     struct device *device_list_i;
 475     struct userdata *u;
 476
 477     pa_assert(m);
 478     pa_log("Loading module-bt-discover");
 479     dbus_error_init(&err);
 480     m->userdata = u = pa_xnew0(struct userdata, 1);
 481     u->module = m;
 482     PA_LLIST_HEAD_INIT(struct adapter, u->adapter_list);
 483
 484     /* connect to the bus */
 485     u->conn = pa_dbus_bus_get(m->core, DBUS_BUS_SYSTEM, &err);
 486     if ( dbus_error_is_set(&err) || (u->conn == NULL) ) {
 487         pa_log("Failed to get D-Bus connection: %s", err.message);
 488         goto fail;
 489     }
 490
 491     /* static detection of bluetooth audio devices */
 492     detect_adapters(u);
 493     detect_devices(u);
 494
 495     print_adapters(u->adapter_list);
 496
 497     /* load device modules */
 498     adapter_list_i = u->adapter_list;
 499     while (adapter_list_i != NULL) {
 500         device_list_i = adapter_list_i->device_list;
 501         while (device_list_i != NULL) {
 502             pa_log("Loading module-bt-device for %s", device_list_i->name);
 503             /* TODO: call module */
 504             device_list_i = device_list_i->next;
 505         }
 506         adapter_list_i = adapter_list_i->next;
 507     }
 508
 509     /* dynamic detection of bluetooth audio devices */
 510     if (!dbus_connection_add_filter(pa_dbus_connection_get(u->conn), filter_cb, u, NULL)) {
 511         pa_log_error("Failed to add filter function");
 512         goto fail;
 513     }
 514     dbus_connection_flush(pa_dbus_connection_get(u->conn));
 515     dbus_bus_add_match(pa_dbus_connection_get(u->conn), "type='signal',interface='org.bluez.Manager'", &err);
 516     dbus_connection_flush(pa_dbus_connection_get(u->conn));
 517     if (dbus_error_is_set(&err)) {
 518         pa_log_error("Unable to subscribe to org.bluez.Manager signals: %s: %s", err.name, err.message);
 519         goto fail;
 520     }
 521     dbus_bus_add_match(pa_dbus_connection_get(u->conn), "type='signal',interface='org.bluez.Adapter'", &err);
 522     dbus_connection_flush(pa_dbus_connection_get(u->conn));
 523     if (dbus_error_is_set(&err)) {
 524         pa_log_error("Unable to subscribe to org.bluez.Adapter signals: %s: %s", err.name, err.message);
 525         goto fail;
 526     }
 527
 528     return 0;
 529
 530 fail:
 531     if (ma)
 532         pa_modargs_free(ma);
 533     dbus_error_free(&err);
 534     pa__done(m);
 535     return -1;
 536 }