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