1 /* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2006-2007 Nokia Corporation 6 * Copyright (C) 2004-2009 Marcel Holtmann <marcel (at) holtmann.org> 7 * 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * 23 */ 24 25 #ifdef HAVE_CONFIG_H 26 #include <config.h> 27 #endif 28 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <stdarg.h> 32 #include <errno.h> 33 #include <unistd.h> 34 #include <fcntl.h> 35 #include <stdint.h> 36 #include <sys/stat.h> 37 #include <dirent.h> 38 #include <ctype.h> 39 #include <signal.h> 40 41 #include <bluetooth/bluetooth.h> 42 #include <bluetooth/hci.h> 43 #include <bluetooth/hci_lib.h> 44 #include <bluetooth/rfcomm.h> 45 #include <bluetooth/sdp.h> 46 #include <bluetooth/sdp_lib.h> 47 48 #include <glib.h> 49 #include <dbus/dbus.h> 50 #include <gdbus.h> 51 52 #include "glib-helper.h" 53 #include "btio.h" 54 #include "../src/manager.h" 55 #include "../src/adapter.h" 56 #include "../src/device.h" 57 58 #include "logging.h" 59 #include "textfile.h" 60 #include "ipc.h" 61 #include "device.h" 62 #include "error.h" 63 #include "avdtp.h" 64 #include "a2dp.h" 65 #include "headset.h" 66 #include "gateway.h" 67 #include "sink.h" 68 #include "source.h" 69 #include "control.h" 70 #include "manager.h" 71 #include "sdpd.h" 72 #include "telephony.h" 73 74 typedef enum { 75 HEADSET = 1 << 0, 76 GATEWAY = 1 << 1, 77 SINK = 1 << 2, 78 SOURCE = 1 << 3, 79 CONTROL = 1 << 4, 80 TARGET = 1 << 5, 81 INVALID = 1 << 6 82 } audio_service_type; 83 84 typedef enum { 85 GENERIC_AUDIO = 0, 86 ADVANCED_AUDIO, 87 AV_REMOTE, 88 GET_RECORDS 89 } audio_sdp_state_t; 90 91 struct audio_adapter { 92 struct btd_adapter *btd_adapter; 93 uint32_t hsp_ag_record_id; 94 uint32_t hfp_ag_record_id; 95 uint32_t hfp_hs_record_id; 96 GIOChannel *hsp_ag_server; 97 GIOChannel *hfp_ag_server; 98 GIOChannel *hfp_hs_server; 99 gint ref; 100 }; 101 102 static gboolean auto_connect = TRUE; 103 static int max_connected_headsets = 1; 104 static DBusConnection *connection = NULL; 105 static GKeyFile *config = NULL; 106 static GSList *adapters = NULL; 107 static GSList *devices = NULL; 108 109 static struct enabled_interfaces enabled = { 110 .hfp = TRUE, 111 .headset = TRUE, 112 .gateway = FALSE, 113 .sink = TRUE, 114 .source = FALSE, 115 .control = TRUE, 116 }; 117 118 static struct audio_adapter *find_adapter(GSList *list, 119 struct btd_adapter *btd_adapter) 120 { 121 GSList *l; 122 123 for (l = list; l; l = l->next) { 124 struct audio_adapter *adapter = l->data; 125 126 if (adapter->btd_adapter == btd_adapter) 127 return adapter; 128 } 129 130 return NULL; 131 } 132 133 gboolean server_is_enabled(bdaddr_t *src, uint16_t svc) 134 { 135 switch (svc) { 136 case HEADSET_SVCLASS_ID: 137 return enabled.headset; 138 case HEADSET_AGW_SVCLASS_ID: 139 return FALSE; 140 case HANDSFREE_SVCLASS_ID: 141 return enabled.headset && enabled.hfp; 142 case HANDSFREE_AGW_SVCLASS_ID: 143 return enabled.gateway; 144 case AUDIO_SINK_SVCLASS_ID: 145 return enabled.sink; 146 case AUDIO_SOURCE_SVCLASS_ID: 147 return enabled.source; 148 case AV_REMOTE_TARGET_SVCLASS_ID: 149 case AV_REMOTE_SVCLASS_ID: 150 return enabled.control; 151 default: 152 return FALSE; 153 } 154 } 155 156 static void handle_uuid(const char *uuidstr, struct audio_device *device) 157 { 158 uuid_t uuid; 159 uint16_t uuid16; 160 161 if (bt_string2uuid(&uuid, uuidstr) < 0) { 162 error("%s not detected as an UUID-128", uuidstr); 163 return; 164 } 165 166 if (!sdp_uuid128_to_uuid(&uuid) && uuid.type != SDP_UUID16) { 167 error("Could not convert %s to a UUID-16", uuidstr); 168 return; 169 } 170 171 uuid16 = uuid.value.uuid16; 172 173 if (!server_is_enabled(&device->src, uuid16)) { 174 debug("audio handle_uuid: server not enabled for %s (0x%04x)", 175 uuidstr, uuid16); 176 return; 177 } 178 179 switch (uuid16) { 180 case HEADSET_SVCLASS_ID: 181 debug("Found Headset record"); 182 if (device->headset) 183 headset_update(device, uuid16, uuidstr); 184 else 185 device->headset = headset_init(device, uuid16, 186 uuidstr); 187 break; 188 case HEADSET_AGW_SVCLASS_ID: 189 debug("Found Headset AG record"); 190 break; 191 case HANDSFREE_SVCLASS_ID: 192 debug("Found Handsfree record"); 193 if (device->headset) 194 headset_update(device, uuid16, uuidstr); 195 else 196 device->headset = headset_init(device, uuid16, 197 uuidstr); 198 break; 199 case HANDSFREE_AGW_SVCLASS_ID: 200 debug("Found Handsfree AG record"); 201 if (device->gateway == NULL) 202 device->gateway = gateway_init(device); 203 break; 204 case AUDIO_SINK_SVCLASS_ID: 205 debug("Found Audio Sink"); 206 if (device->sink == NULL) 207 device->sink = sink_init(device); 208 break; 209 case AUDIO_SOURCE_SVCLASS_ID: 210 debug("Found Audio Source"); 211 if (device->source == NULL) 212 device->source = source_init(device); 213 break; 214 case AV_REMOTE_SVCLASS_ID: 215 case AV_REMOTE_TARGET_SVCLASS_ID: 216 debug("Found AV %s", uuid16 == AV_REMOTE_SVCLASS_ID ? 217 "Remote" : "Target"); 218 if (device->control) 219 control_update(device, uuid16); 220 else 221 device->control = control_init(device, uuid16); 222 if (device->sink && sink_is_active(device)) 223 avrcp_connect(device); 224 break; 225 default: 226 debug("Unrecognized UUID: 0x%04X", uuid16); 227 break; 228 } 229 } 230 231 static sdp_record_t *hsp_ag_record(uint8_t ch) 232 { 233 sdp_list_t *svclass_id, *pfseq, *apseq, *root; 234 uuid_t root_uuid, svclass_uuid, ga_svclass_uuid; 235 uuid_t l2cap_uuid, rfcomm_uuid; 236 sdp_profile_desc_t profile; 237 sdp_record_t *record; 238 sdp_list_t *aproto, *proto[2]; 239 sdp_data_t *channel; 240 241 record = sdp_record_alloc(); 242 if (!record) 243 return NULL; 244 245 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); 246 root = sdp_list_append(0, &root_uuid); 247 sdp_set_browse_groups(record, root); 248 249 sdp_uuid16_create(&svclass_uuid, HEADSET_AGW_SVCLASS_ID); 250 svclass_id = sdp_list_append(0, &svclass_uuid); 251 sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID); 252 svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid); 253 sdp_set_service_classes(record, svclass_id); 254 255 sdp_uuid16_create(&profile.uuid, HEADSET_PROFILE_ID); 256 profile.version = 0x0102; 257 pfseq = sdp_list_append(0, &profile); 258 sdp_set_profile_descs(record, pfseq); 259 260 sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); 261 proto[0] = sdp_list_append(0, &l2cap_uuid); 262 apseq = sdp_list_append(0, proto[0]); 263 264 sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); 265 proto[1] = sdp_list_append(0, &rfcomm_uuid); 266 channel = sdp_data_alloc(SDP_UINT8, &ch); 267 proto[1] = sdp_list_append(proto[1], channel); 268 apseq = sdp_list_append(apseq, proto[1]); 269 270 aproto = sdp_list_append(0, apseq); 271 sdp_set_access_protos(record, aproto); 272 273 sdp_set_info_attr(record, "Headset Audio Gateway", 0, 0); 274 275 sdp_data_free(channel); 276 sdp_list_free(proto[0], 0); 277 sdp_list_free(proto[1], 0); 278 sdp_list_free(apseq, 0); 279 sdp_list_free(pfseq, 0); 280 sdp_list_free(aproto, 0); 281 sdp_list_free(root, 0); 282 sdp_list_free(svclass_id, 0); 283 284 return record; 285 } 286 287 static sdp_record_t *hfp_hs_record(uint8_t ch) 288 { 289 sdp_list_t *svclass_id, *pfseq, *apseq, *root; 290 uuid_t root_uuid, svclass_uuid, ga_svclass_uuid; 291 uuid_t l2cap_uuid, rfcomm_uuid; 292 sdp_profile_desc_t profile; 293 sdp_record_t *record; 294 sdp_list_t *aproto, *proto[2]; 295 sdp_data_t *channel; 296 297 record = sdp_record_alloc(); 298 if (!record) 299 return NULL; 300 301 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); 302 root = sdp_list_append(0, &root_uuid); 303 sdp_set_browse_groups(record, root); 304 305 sdp_uuid16_create(&svclass_uuid, HANDSFREE_SVCLASS_ID); 306 svclass_id = sdp_list_append(0, &svclass_uuid); 307 sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID); 308 svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid); 309 sdp_set_service_classes(record, svclass_id); 310 311 sdp_uuid16_create(&profile.uuid, HANDSFREE_PROFILE_ID); 312 profile.version = 0x0100; 313 pfseq = sdp_list_append(0, &profile); 314 sdp_set_profile_descs(record, pfseq); 315 316 sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); 317 proto[0] = sdp_list_append(0, &l2cap_uuid); 318 apseq = sdp_list_append(0, proto[0]); 319 320 sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); 321 proto[1] = sdp_list_append(0, &rfcomm_uuid); 322 channel = sdp_data_alloc(SDP_UINT8, &ch); 323 proto[1] = sdp_list_append(proto[1], channel); 324 apseq = sdp_list_append(apseq, proto[1]); 325 326 aproto = sdp_list_append(0, apseq); 327 sdp_set_access_protos(record, aproto); 328 329 sdp_set_info_attr(record, "Hands-Free", 0, 0); 330 331 sdp_data_free(channel); 332 sdp_list_free(proto[0], 0); 333 sdp_list_free(proto[1], 0); 334 sdp_list_free(apseq, 0); 335 sdp_list_free(pfseq, 0); 336 sdp_list_free(aproto, 0); 337 sdp_list_free(root, 0); 338 sdp_list_free(svclass_id, 0); 339 340 return record; 341 } 342 343 static sdp_record_t *hfp_ag_record(uint8_t ch, uint32_t feat) 344 { 345 sdp_list_t *svclass_id, *pfseq, *apseq, *root; 346 uuid_t root_uuid, svclass_uuid, ga_svclass_uuid; 347 uuid_t l2cap_uuid, rfcomm_uuid; 348 sdp_profile_desc_t profile; 349 sdp_list_t *aproto, *proto[2]; 350 sdp_record_t *record; 351 sdp_data_t *channel, *features; 352 uint8_t netid = 0x01; 353 uint16_t sdpfeat; 354 sdp_data_t *network = sdp_data_alloc(SDP_UINT8, &netid); 355 356 record = sdp_record_alloc(); 357 if (!record) 358 return NULL; 359 360 sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); 361 root = sdp_list_append(0, &root_uuid); 362 sdp_set_browse_groups(record, root); 363 364 sdp_uuid16_create(&svclass_uuid, HANDSFREE_AGW_SVCLASS_ID); 365 svclass_id = sdp_list_append(0, &svclass_uuid); 366 sdp_uuid16_create(&ga_svclass_uuid, GENERIC_AUDIO_SVCLASS_ID); 367 svclass_id = sdp_list_append(svclass_id, &ga_svclass_uuid); 368 sdp_set_service_classes(record, svclass_id); 369 370 sdp_uuid16_create(&profile.uuid, HANDSFREE_PROFILE_ID); 371 profile.version = 0x0105; 372 pfseq = sdp_list_append(0, &profile); 373 sdp_set_profile_descs(record, pfseq); 374 375 sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); 376 proto[0] = sdp_list_append(0, &l2cap_uuid); 377 apseq = sdp_list_append(0, proto[0]); 378 379 sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); 380 proto[1] = sdp_list_append(0, &rfcomm_uuid); 381 channel = sdp_data_alloc(SDP_UINT8, &ch); 382 proto[1] = sdp_list_append(proto[1], channel); 383 apseq = sdp_list_append(apseq, proto[1]); 384 385 sdpfeat = (uint16_t) feat & 0xF; 386 features = sdp_data_alloc(SDP_UINT16, &sdpfeat); 387 sdp_attr_add(record, SDP_ATTR_SUPPORTED_FEATURES, features); 388 389 aproto = sdp_list_append(0, apseq); 390 sdp_set_access_protos(record, aproto); 391 392 sdp_set_info_attr(record, "Hands-Free Audio Gateway", 0, 0); 393 394 sdp_attr_add(record, SDP_ATTR_EXTERNAL_NETWORK, network); 395 396 sdp_data_free(channel); 397 sdp_list_free(proto[0], 0); 398 sdp_list_free(proto[1], 0); 399 sdp_list_free(apseq, 0); 400 sdp_list_free(pfseq, 0); 401 sdp_list_free(aproto, 0); 402 sdp_list_free(root, 0); 403 sdp_list_free(svclass_id, 0); 404 405 return record; 406 } 407 408 static void headset_auth_cb(DBusError *derr, void *user_data) 409 { 410 struct audio_device *device = user_data; 411 GError *err = NULL; 412 GIOChannel *io; 413 414 if (derr && dbus_error_is_set(derr)) { 415 error("Access denied: %s", derr->message); 416 headset_set_state(device, HEADSET_STATE_DISCONNECTED); 417 return; 418 } 419 420 io = headset_get_rfcomm(device); 421 422 if (!bt_io_accept(io, headset_connect_cb, device, NULL, &err)) { 423 error("bt_io_accept: %s", err->message); 424 g_error_free(err); 425 headset_set_state(device, HEADSET_STATE_DISCONNECTED); 426 return; 427 } 428 } 429 430 static void ag_confirm(GIOChannel *chan, gpointer data) 431 { 432 const char *server_uuid, *remote_uuid; 433 struct audio_device *device; 434 gboolean hfp_active; 435 bdaddr_t src, dst; 436 int perr; 437 GError *err = NULL; 438 uint8_t ch; 439 440 bt_io_get(chan, BT_IO_RFCOMM, &err, 441 BT_IO_OPT_SOURCE_BDADDR, &src, 442 BT_IO_OPT_DEST_BDADDR, &dst, 443 BT_IO_OPT_CHANNEL, &ch, 444 BT_IO_OPT_INVALID); 445 if (err) { 446 error("%s", err->message); 447 g_error_free(err); 448 goto drop; 449 } 450 451 if (ch == DEFAULT_HS_AG_CHANNEL) { 452 hfp_active = FALSE; 453 server_uuid = HSP_AG_UUID; 454 remote_uuid = HSP_HS_UUID; 455 } else { 456 hfp_active = TRUE; 457 server_uuid = HFP_AG_UUID; 458 remote_uuid = HFP_HS_UUID; 459 } 460 461 device = manager_get_device(&src, &dst, TRUE); 462 if (!device) 463 goto drop; 464 465 if (!manager_allow_headset_connection(device)) { 466 debug("Refusing headset: too many existing connections"); 467 goto drop; 468 } 469 470 if (!device->headset) { 471 btd_device_add_uuid(device->btd_dev, remote_uuid); 472 if (!device->headset) 473 goto drop; 474 } 475 476 if (headset_get_state(device) > HEADSET_STATE_DISCONNECTED) { 477 debug("Refusing new connection since one already exists"); 478 goto drop; 479 } 480 481 set_hfp_active(device, hfp_active); 482 483 if (headset_connect_rfcomm(device, chan) < 0) { 484 error("headset_connect_rfcomm failed"); 485 goto drop; 486 } 487 488 headset_set_state(device, HEADSET_STATE_CONNECT_IN_PROGRESS); 489 490 perr = audio_device_request_authorization(device, server_uuid, 491 headset_auth_cb, device); 492 if (perr < 0) { 493 debug("Authorization denied: %s", strerror(-perr)); 494 headset_set_state(device, HEADSET_STATE_DISCONNECTED); 495 return; 496 } 497 498 device->auto_connect = auto_connect; 499 500 return; 501 502 drop: 503 g_io_channel_shutdown(chan, TRUE, NULL); 504 } 505 506 static void gateway_auth_cb(DBusError *derr, void *user_data) 507 { 508 struct audio_device *device = user_data; 509 510 if (derr && dbus_error_is_set(derr)) 511 error("Access denied: %s", derr->message); 512 else { 513 char ag_address[18]; 514 515 ba2str(&device->dst, ag_address); 516 debug("Accepted AG connection from %s for %s", 517 ag_address, device->path); 518 519 gateway_start_service(device); 520 } 521 } 522 523 static void hf_io_cb(GIOChannel *chan, gpointer data) 524 { 525 bdaddr_t src, dst; 526 GError *err = NULL; 527 uint8_t ch; 528 const char *server_uuid, *remote_uuid; 529 uint16_t svclass; 530 struct audio_device *device; 531 int perr; 532 533 bt_io_get(chan, BT_IO_RFCOMM, &err, 534 BT_IO_OPT_SOURCE_BDADDR, &src, 535 BT_IO_OPT_DEST_BDADDR, &dst, 536 BT_IO_OPT_CHANNEL, &ch, 537 BT_IO_OPT_INVALID); 538 539 if (err) { 540 error("%s", err->message); 541 g_error_free(err); 542 return; 543 } 544 545 server_uuid = HFP_HS_UUID; 546 remote_uuid = HFP_AG_UUID; 547 svclass = HANDSFREE_AGW_SVCLASS_ID; 548 549 device = manager_get_device(&src, &dst, TRUE); 550 if (!device) 551 goto drop; 552 553 if (!device->gateway) { 554 btd_device_add_uuid(device->btd_dev, remote_uuid); 555 if (!device->gateway) 556 goto drop; 557 } 558 559 if (gateway_is_connected(device)) { 560 debug("Refusing new connection since one already exists"); 561 goto drop; 562 } 563 564 if (gateway_connect_rfcomm(device, chan) < 0) { 565 error("Allocating new GIOChannel failed!"); 566 goto drop; 567 } 568 569 perr = audio_device_request_authorization(device, server_uuid, 570 gateway_auth_cb, device); 571 if (perr < 0) { 572 debug("Authorization denied!"); 573 goto drop; 574 } 575 576 return; 577 578 drop: 579 g_io_channel_shutdown(chan, TRUE, NULL); 580 g_io_channel_unref(chan); 581 return; 582 } 583 584 static int headset_server_init(struct audio_adapter *adapter) 585 { 586 uint8_t chan = DEFAULT_HS_AG_CHANNEL; 587 sdp_record_t *record; 588 gboolean master = TRUE; 589 GError *err = NULL; 590 uint32_t features; 591 GIOChannel *io; 592 bdaddr_t src; 593 594 if (config) { 595 gboolean tmp; 596 597 tmp = g_key_file_get_boolean(config, "General", "Master", 598 &err); 599 if (err) { 600 debug("audio.conf: %s", err->message); 601 g_clear_error(&err); 602 } else 603 master = tmp; 604 } 605 606 adapter_get_address(adapter->btd_adapter, &src); 607 608 io = bt_io_listen(BT_IO_RFCOMM, NULL, ag_confirm, adapter, NULL, &err, 609 BT_IO_OPT_SOURCE_BDADDR, &src, 610 BT_IO_OPT_CHANNEL, chan, 611 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM, 612 BT_IO_OPT_MASTER, master, 613 BT_IO_OPT_INVALID); 614 if (!io) 615 goto failed; 616 617 adapter->hsp_ag_server = io; 618 619 record = hsp_ag_record(chan); 620 if (!record) { 621 error("Unable to allocate new service record"); 622 goto failed; 623 } 624 625 if (add_record_to_server(&src, record) < 0) { 626 error("Unable to register HS AG service record"); 627 sdp_record_free(record); 628 goto failed; 629 } 630 adapter->hsp_ag_record_id = record->handle; 631 632 features = headset_config_init(config); 633 634 if (!enabled.hfp) 635 return 0; 636 637 chan = DEFAULT_HF_AG_CHANNEL; 638 639 io = bt_io_listen(BT_IO_RFCOMM, NULL, ag_confirm, adapter, NULL, &err, 640 BT_IO_OPT_SOURCE_BDADDR, &src, 641 BT_IO_OPT_CHANNEL, chan, 642 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM, 643 BT_IO_OPT_MASTER, master, 644 BT_IO_OPT_INVALID); 645 if (!io) 646 goto failed; 647 648 adapter->hfp_ag_server = io; 649 650 record = hfp_ag_record(chan, features); 651 if (!record) { 652 error("Unable to allocate new service record"); 653 goto failed; 654 } 655 656 if (add_record_to_server(&src, record) < 0) { 657 error("Unable to register HF AG service record"); 658 sdp_record_free(record); 659 goto failed; 660 } 661 adapter->hfp_ag_record_id = record->handle; 662 663 return 0; 664 665 failed: 666 error("%s", err->message); 667 g_error_free(err); 668 if (adapter->hsp_ag_server) { 669 g_io_channel_shutdown(adapter->hsp_ag_server, TRUE, NULL); 670 g_io_channel_unref(adapter->hsp_ag_server); 671 adapter->hsp_ag_server = NULL; 672 } 673 674 if (adapter->hfp_ag_server) { 675 g_io_channel_shutdown(adapter->hfp_ag_server, TRUE, NULL); 676 g_io_channel_unref(adapter->hfp_ag_server); 677 adapter->hfp_ag_server = NULL; 678 } 679 680 return -1; 681 } 682 683 static int gateway_server_init(struct audio_adapter *adapter) 684 { 685 uint8_t chan = DEFAULT_HFP_HS_CHANNEL; 686 sdp_record_t *record; 687 gboolean master = TRUE; 688 GError *err = NULL; 689 GIOChannel *io; 690 bdaddr_t src; 691 692 if (config) { 693 gboolean tmp; 694 695 tmp = g_key_file_get_boolean(config, "General", "Master", 696 &err); 697 if (err) { 698 debug("audio.conf: %s", err->message); 699 g_clear_error(&err); 700 } else 701 master = tmp; 702 } 703 704 adapter_get_address(adapter->btd_adapter, &src); 705 706 io = bt_io_listen(BT_IO_RFCOMM, NULL, hf_io_cb, adapter, NULL, &err, 707 BT_IO_OPT_SOURCE_BDADDR, &src, 708 BT_IO_OPT_CHANNEL, chan, 709 BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM, 710 BT_IO_OPT_MASTER, master, 711 BT_IO_OPT_INVALID); 712 if (!io) { 713 error("%s", err->message); 714 g_error_free(err); 715 return -1; 716 } 717 718 adapter->hfp_hs_server = io; 719 record = hfp_hs_record(chan); 720 if (!record) { 721 error("Unable to allocate new service record"); 722 return -1; 723 } 724 725 if (add_record_to_server(&src, record) < 0) { 726 error("Unable to register HFP HS service record"); 727 sdp_record_free(record); 728 g_io_channel_unref(adapter->hfp_hs_server); 729 adapter->hfp_hs_server = NULL; 730 return -1; 731 } 732 733 adapter->hfp_hs_record_id = record->handle; 734 735 return 0; 736 } 737 738 static int audio_probe(struct btd_device *device, GSList *uuids) 739 { 740 struct btd_adapter *adapter = device_get_adapter(device); 741 bdaddr_t src, dst; 742 struct audio_device *audio_dev; 743 744 adapter_get_address(adapter, &src); 745 device_get_address(device, &dst); 746 747 audio_dev = manager_get_device(&src, &dst, TRUE); 748 if (!audio_dev) { 749 debug("audio_probe: unable to get a device object"); 750 return -1; 751 } 752 753 g_slist_foreach(uuids, (GFunc) handle_uuid, audio_dev); 754 755 return 0; 756 } 757 758 static void audio_remove(struct btd_device *device) 759 { 760 struct audio_device *dev; 761 const char *path; 762 763 path = device_get_path(device); 764 765 dev = manager_find_device(path, NULL, NULL, NULL, FALSE); 766 if (!dev) 767 return; 768 769 devices = g_slist_remove(devices, dev); 770 771 audio_device_unregister(dev); 772 } 773 774 static struct audio_adapter *audio_adapter_ref(struct audio_adapter *adp) 775 { 776 adp->ref++; 777 778 debug("audio_adapter_ref(%p): ref=%d", adp, adp->ref); 779 780 return adp; 781 } 782 783 static void audio_adapter_unref(struct audio_adapter *adp) 784 { 785 adp->ref--; 786 787 debug("audio_adapter_unref(%p): ref=%d", adp, adp->ref); 788 789 if (adp->ref > 0) 790 return; 791 792 adapters = g_slist_remove(adapters, adp); 793 btd_adapter_unref(adp->btd_adapter); 794 g_free(adp); 795 } 796 797 static struct audio_adapter *audio_adapter_create(struct btd_adapter *adapter) 798 { 799 struct audio_adapter *adp; 800 801 adp = g_new0(struct audio_adapter, 1); 802 adp->btd_adapter = btd_adapter_ref(adapter); 803 804 return audio_adapter_ref(adp); 805 } 806 807 static struct audio_adapter *audio_adapter_get(struct btd_adapter *adapter) 808 { 809 struct audio_adapter *adp; 810 811 adp = find_adapter(adapters, adapter); 812 if (!adp) { 813 adp = audio_adapter_create(adapter); 814 if (!adp) 815 return NULL; 816 adapters = g_slist_append(adapters, adp); 817 } else 818 audio_adapter_ref(adp); 819 820 return adp; 821 } 822 823 static int headset_server_probe(struct btd_adapter *adapter) 824 { 825 struct audio_adapter *adp; 826 const gchar *path = adapter_get_path(adapter); 827 int ret; 828 829 DBG("path %s", path); 830 831 adp = audio_adapter_get(adapter); 832 if (!adp) 833 return -EINVAL; 834 835 ret = headset_server_init(adp); 836 if (ret < 0) { 837 audio_adapter_unref(adp); 838 return ret; 839 } 840 841 return 0; 842 } 843 844 static void headset_server_remove(struct btd_adapter *adapter) 845 { 846 struct audio_adapter *adp; 847 const gchar *path = adapter_get_path(adapter); 848 849 DBG("path %s", path); 850 851 adp = find_adapter(adapters, adapter); 852 if (!adp) 853 return; 854 855 if (adp->hsp_ag_record_id) { 856 remove_record_from_server(adp->hsp_ag_record_id); 857 adp->hsp_ag_record_id = 0; 858 } 859 860 if (adp->hsp_ag_server) { 861 g_io_channel_shutdown(adp->hsp_ag_server, TRUE, NULL); 862 g_io_channel_unref(adp->hsp_ag_server); 863 adp->hsp_ag_server = NULL; 864 } 865 866 if (adp->hfp_ag_record_id) { 867 remove_record_from_server(adp->hfp_ag_record_id); 868 adp->hfp_ag_record_id = 0; 869 } 870 871 if (adp->hfp_ag_server) { 872 g_io_channel_shutdown(adp->hfp_ag_server, TRUE, NULL); 873 g_io_channel_unref(adp->hfp_ag_server); 874 adp->hfp_ag_server = NULL; 875 } 876 877 audio_adapter_unref(adp); 878 } 879 880 static int gateway_server_probe(struct btd_adapter *adapter) 881 { 882 struct audio_adapter *adp; 883 const gchar *path = adapter_get_path(adapter); 884 int ret; 885 886 DBG("path %s", path); 887 888 adp = audio_adapter_get(adapter); 889 if (!adp) 890 return -EINVAL; 891 892 ret = gateway_server_init(adp); 893 if (ret < 0) { 894 audio_adapter_ref(adp); 895 return ret; 896 } 897 898 return 0; 899 } 900 901 static void gateway_server_remove(struct btd_adapter *adapter) 902 { 903 struct audio_adapter *adp; 904 const gchar *path = adapter_get_path(adapter); 905 906 DBG("path %s", path); 907 908 adp = find_adapter(adapters, adapter); 909 if (!adp) 910 return; 911 912 if (adp->hfp_hs_record_id) { 913 remove_record_from_server(adp->hfp_hs_record_id); 914 adp->hfp_hs_record_id = 0; 915 } 916 917 if (adp->hfp_hs_server) { 918 g_io_channel_unref(adp->hfp_hs_server); 919 adp->hfp_hs_server = NULL; 920 } 921 922 audio_adapter_ref(adp); 923 } 924 925 static int a2dp_server_probe(struct btd_adapter *adapter) 926 { 927 struct audio_adapter *adp; 928 const gchar *path = adapter_get_path(adapter); 929 bdaddr_t src; 930 int ret; 931 932 DBG("path %s", path); 933 934 adp = audio_adapter_get(adapter); 935 if (!adp) 936 return -EINVAL; 937 938 adapter_get_address(adapter, &src); 939 940 ret = a2dp_register(connection, &src, config); 941 if (ret < 0) { 942 audio_adapter_unref(adp); 943 return ret; 944 } 945 946 return 0; 947 } 948 949 static void a2dp_server_remove(struct btd_adapter *adapter) 950 { 951 struct audio_adapter *adp; 952 const gchar *path = adapter_get_path(adapter); 953 bdaddr_t src; 954 955 DBG("path %s", path); 956 957 adp = find_adapter(adapters, adapter); 958 if (!adp) 959 return; 960 961 adapter_get_address(adapter, &src); 962 a2dp_unregister(&src); 963 audio_adapter_unref(adp); 964 } 965 966 static int avrcp_server_probe(struct btd_adapter *adapter) 967 { 968 struct audio_adapter *adp; 969 const gchar *path = adapter_get_path(adapter); 970 bdaddr_t src; 971 972 DBG("path %s", path); 973 974 adp = audio_adapter_get(adapter); 975 if (!adp) 976 return -EINVAL; 977 978 adapter_get_address(adapter, &src); 979 980 return avrcp_register(connection, &src, config); 981 } 982 983 static void avrcp_server_remove(struct btd_adapter *adapter) 984 { 985 struct audio_adapter *adp; 986 const gchar *path = adapter_get_path(adapter); 987 bdaddr_t src; 988 989 DBG("path %s", path); 990 991 adp = find_adapter(adapters, adapter); 992 if (!adp) 993 return; 994 995 adapter_get_address(adapter, &src); 996 avrcp_unregister(&src); 997 audio_adapter_unref(adp); 998 } 999 1000 static struct btd_device_driver audio_driver = { 1001 .name = "audio", 1002 .uuids = BTD_UUIDS(HSP_HS_UUID, HFP_HS_UUID, HSP_AG_UUID, HFP_AG_UUID, 1003 ADVANCED_AUDIO_UUID, A2DP_SOURCE_UUID, A2DP_SINK_UUID, 1004 AVRCP_TARGET_UUID, AVRCP_REMOTE_UUID), 1005 .probe = audio_probe, 1006 .remove = audio_remove, 1007 }; 1008 1009 static struct btd_adapter_driver headset_server_driver = { 1010 .name = "audio-headset", 1011 .probe = headset_server_probe, 1012 .remove = headset_server_remove, 1013 }; 1014 1015 static struct btd_adapter_driver gateway_server_driver = { 1016 .name = "audio-gateway", 1017 .probe = gateway_server_probe, 1018 .remove = gateway_server_remove, 1019 }; 1020 1021 static struct btd_adapter_driver a2dp_server_driver = { 1022 .name = "audio-a2dp", 1023 .probe = a2dp_server_probe, 1024 .remove = a2dp_server_remove, 1025 }; 1026 1027 static struct btd_adapter_driver avrcp_server_driver = { 1028 .name = "audio-control", 1029 .probe = avrcp_server_probe, 1030 .remove = avrcp_server_remove, 1031 }; 1032 1033 int audio_manager_init(DBusConnection *conn, GKeyFile *conf, 1034 gboolean *enable_sco) 1035 { 1036 char **list; 1037 int i; 1038 gboolean b; 1039 GError *err = NULL; 1040 1041 connection = dbus_connection_ref(conn); 1042 1043 if (!conf) 1044 goto proceed; 1045 1046 config = conf; 1047 1048 list = g_key_file_get_string_list(config, "General", "Enable", 1049 NULL, NULL); 1050 for (i = 0; list && list[i] != NULL; i++) { 1051 if (g_str_equal(list[i], "Headset")) 1052 enabled.headset = TRUE; 1053 else if (g_str_equal(list[i], "Gateway")) 1054 enabled.gateway = TRUE; 1055 else if (g_str_equal(list[i], "Sink")) 1056 enabled.sink = TRUE; 1057 else if (g_str_equal(list[i], "Source")) 1058 enabled.source = TRUE; 1059 else if (g_str_equal(list[i], "Control")) 1060 enabled.control = TRUE; 1061 } 1062 g_strfreev(list); 1063 1064 list = g_key_file_get_string_list(config, "General", "Disable", 1065 NULL, NULL); 1066 for (i = 0; list && list[i] != NULL; i++) { 1067 if (g_str_equal(list[i], "Headset")) 1068 enabled.headset = FALSE; 1069 else if (g_str_equal(list[i], "Gateway")) 1070 enabled.gateway = FALSE; 1071 else if (g_str_equal(list[i], "Sink")) 1072 enabled.sink = FALSE; 1073 else if (g_str_equal(list[i], "Source")) 1074 enabled.source = FALSE; 1075 else if (g_str_equal(list[i], "Control")) 1076 enabled.control = FALSE; 1077 } 1078 g_strfreev(list); 1079 1080 b = g_key_file_get_boolean(config, "General", "AutoConnect", &err); 1081 if (err) { 1082 debug("audio.conf: %s", err->message); 1083 g_clear_error(&err); 1084 } else 1085 auto_connect = b; 1086 1087 b = g_key_file_get_boolean(config, "Headset", "HFP", 1088 &err); 1089 if (err) 1090 g_clear_error(&err); 1091 else 1092 enabled.hfp = b; 1093 1094 err = NULL; 1095 i = g_key_file_get_integer(config, "Headset", "MaxConnected", 1096 &err); 1097 if (err) { 1098 debug("audio.conf: %s", err->message); 1099 g_clear_error(&err); 1100 } else 1101 max_connected_headsets = i; 1102 1103 proceed: 1104 if (enabled.headset) { 1105 telephony_init(); 1106 btd_register_adapter_driver(&headset_server_driver); 1107 } 1108 1109 if (enabled.gateway) 1110 btd_register_adapter_driver(&gateway_server_driver); 1111 1112 if (enabled.source || enabled.sink) 1113 btd_register_adapter_driver(&a2dp_server_driver); 1114 1115 if (enabled.control) 1116 btd_register_adapter_driver(&avrcp_server_driver); 1117 1118 btd_register_device_driver(&audio_driver); 1119 1120 *enable_sco = (enabled.gateway || enabled.headset); 1121 1122 return 0; 1123 } 1124 1125 void audio_manager_exit(void) 1126 { 1127 /* Bail out early if we haven't been initialized */ 1128 if (connection == NULL) 1129 return; 1130 1131 dbus_connection_unref(connection); 1132 connection = NULL; 1133 1134 if (config) { 1135 g_key_file_free(config); 1136 config = NULL; 1137 } 1138 1139 if (enabled.headset) { 1140 btd_unregister_adapter_driver(&headset_server_driver); 1141 telephony_exit(); 1142 } 1143 1144 if (enabled.gateway) 1145 btd_unregister_adapter_driver(&gateway_server_driver); 1146 1147 if (enabled.source || enabled.sink) 1148 btd_unregister_adapter_driver(&a2dp_server_driver); 1149 1150 if (enabled.control) 1151 btd_unregister_adapter_driver(&avrcp_server_driver); 1152 1153 btd_unregister_device_driver(&audio_driver); 1154 } 1155 1156 struct audio_device *manager_find_device(const char *path, 1157 const bdaddr_t *src, 1158 const bdaddr_t *dst, 1159 const char *interface, 1160 gboolean connected) 1161 { 1162 GSList *l; 1163 1164 for (l = devices; l != NULL; l = l->next) { 1165 struct audio_device *dev = l->data; 1166 1167 if ((path && (strcmp(path, "")) && strcmp(dev->path, path))) 1168 continue; 1169 1170 if ((src && bacmp(src, BDADDR_ANY)) && bacmp(&dev->src, src)) 1171 continue; 1172 1173 if ((dst && bacmp(dst, BDADDR_ANY)) && bacmp(&dev->dst, dst)) 1174 continue; 1175 1176 if (interface && !strcmp(AUDIO_HEADSET_INTERFACE, interface) 1177 && !dev->headset) 1178 continue; 1179 1180 if (interface && !strcmp(AUDIO_GATEWAY_INTERFACE, interface) 1181 && !dev->gateway) 1182 continue; 1183 1184 if (interface && !strcmp(AUDIO_SINK_INTERFACE, interface) 1185 && !dev->sink) 1186 continue; 1187 1188 if (interface && !strcmp(AUDIO_SOURCE_INTERFACE, interface) 1189 && !dev->source) 1190 continue; 1191 1192 if (interface && !strcmp(AUDIO_CONTROL_INTERFACE, interface) 1193 && !dev->control) 1194 continue; 1195 1196 if (connected && !audio_device_is_active(dev, interface)) 1197 continue; 1198 1199 return dev; 1200 } 1201 1202 return NULL; 1203 } 1204 1205 struct audio_device *manager_get_device(const bdaddr_t *src, 1206 const bdaddr_t *dst, 1207 gboolean create) 1208 { 1209 struct audio_device *dev; 1210 struct btd_adapter *adapter; 1211 struct btd_device *device; 1212 char addr[18]; 1213 const char *path; 1214 1215 dev = manager_find_device(NULL, src, dst, NULL, FALSE); 1216 if (dev) 1217 return dev; 1218 1219 if (!create) 1220 return NULL; 1221 1222 ba2str(src, addr); 1223 1224 adapter = manager_find_adapter(src); 1225 if (!adapter) { 1226 error("Unable to get a btd_adapter object for %s", 1227 addr); 1228 return NULL; 1229 } 1230 1231 ba2str(dst, addr); 1232 1233 device = adapter_get_device(connection, adapter, addr); 1234 if (!device) { 1235 error("Unable to get btd_device object for %s", addr); 1236 return NULL; 1237 } 1238 1239 path = device_get_path(device); 1240 1241 dev = audio_device_register(connection, device, path, src, dst); 1242 if (!dev) 1243 return NULL; 1244 1245 devices = g_slist_append(devices, dev); 1246 1247 return dev; 1248 } 1249 1250 gboolean manager_allow_headset_connection(struct audio_device *device) 1251 { 1252 GSList *l; 1253 int connected = 0; 1254 1255 for (l = devices; l != NULL; l = l->next) { 1256 struct audio_device *dev = l->data; 1257 struct headset *hs = dev->headset; 1258 1259 if (dev == device) 1260 continue; 1261 1262 if (bacmp(&dev->src, &device->src)) 1263 continue; 1264 1265 if (!hs) 1266 continue; 1267 1268 if (headset_get_state(dev) > HEADSET_STATE_DISCONNECTED) 1269 connected++; 1270 1271 if (connected >= max_connected_headsets) 1272 return FALSE; 1273 } 1274 1275 return TRUE; 1276 } 1277
