« back to all changes in this revision
Viewing changes to .pc/force-adapter-class.patch/src/adapter.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Simon Fels
- Date: 2015-09-11 09:01:46 UTC
- Revision ID: morphis@gravedo.de-20150911090146-4c0ln9s7ec3xf0nx
Import package bluez_4.101-0ubuntu25.1~overlay4 from stable phone overlay PPA
- files added:
- .bzr-builddeb
- .pc
- .pc/01_lower_sink_ranking.patch
- .pc/01_lower_sink_ranking.patch/audio
- .pc/02_disable_hal.patch
- .pc/02_disable_hal.patch/audio
- .pc/03-Fix-return-code-of-hid2hci.patch
- .pc/03-Fix-return-code-of-hid2hci.patch/tools
- .pc/06-alsalib.patch
- .pc/09_fix_ftbfs_with_c99.patch
- .pc/09_fix_ftbfs_with_c99.patch/lib
- .pc/12_check_device_before_removing_from_devices.patch
- .pc/12_check_device_before_removing_from_devices.patch/audio
- .pc/13_reset_default_adapter_id.patch
- .pc/13_reset_default_adapter_id.patch/src
- .pc/avrcp.patch
- .pc/avrcp.patch/audio
- .pc/dinovo_edge_keyboard.patch
- .pc/dinovo_edge_keyboard.patch/scripts
- .pc/dont_enable_discoverable_during_init_with_if_valid_timeout.patch
- .pc/dont_enable_discoverable_during_init_with_if_valid_timeout.patch/plugins
- .pc/dont_overwrite_default_discoverable_timeout.patch
- .pc/dont_overwrite_default_discoverable_timeout.patch/src
- .pc/dynamic-main-conf-loading.patch
- .pc/dynamic-main-conf-loading.patch/src
- .pc/enable_audio_profiles.patch
- .pc/enable_audio_profiles.patch/audio
- .pc/fix_hcigetconninfo.patch
- .pc/fix_hcigetconninfo.patch/plugins
- .pc/fix_hcigetconninfo.patch/tools
- .pc/force-adapter-class.patch
- .pc/force-adapter-class.patch/src
- .pc/git-2f92669-permit_concurrent_ag_hf.patch
- .pc/git-2f92669-permit_concurrent_ag_hf.patch/audio
- .pc/git-57170b3-fix_network_connect_method.patch
- .pc/git-57170b3-fix_network_connect_method.patch/network
- .pc/git-a66a557-gdbus_missing_flags.patch
- .pc/git-a66a557-gdbus_missing_flags.patch/attrib
- .pc/git-a66a557-gdbus_missing_flags.patch/audio
- .pc/git-a66a557-gdbus_missing_flags.patch/src
- .pc/git-b57c64f-network-null-deref.patch
- .pc/git-b57c64f-network-null-deref.patch/network
- .pc/git-ea793cb-input_io_channel_watches.patch
- .pc/git-ea793cb-input_io_channel_watches.patch/input
- .pc/hid-reconnect-mode.patch
- .pc/hid-reconnect-mode.patch/input
- .pc/migrate_scripts_python3.patch
- .pc/migrate_scripts_python3.patch/test
- .pc/reauthentication-after-link-key-rejection.patch
- .pc/reauthentication-after-link-key-rejection.patch/src
- .pc/recalculate_telephony_signal_strength.patch
- .pc/recalculate_telephony_signal_strength.patch/audio
- .pc/restart_on_error.patch
- .pc/restart_on_error.patch/src
- .pc/sbc_mmx.patch
- .pc/sbc_mmx.patch/sbc
- .pc/sco_watch_hup_workaround_mako.patch
- .pc/sco_watch_hup_workaround_mako.patch/audio
- .pc/ssp_parameter.patch
- .pc/ssp_parameter.patch/doc
- .pc/ssp_parameter.patch/lib
- .pc/ssp_parameter.patch/plugins
- .pc/ssp_parameter.patch/src
- .pc/ssp_parameter.patch/test
- .pc/telephony_ofono_add_watch.patch
- .pc/telephony_ofono_add_watch.patch/audio
- .pc/telephony_ofono_disable_inband_default.patch
- .pc/telephony_ofono_disable_inband_default.patch/audio
- .pc/unquote-hostname.patch
- .pc/unquote-hostname.patch/plugins
- .pc/use_correct_signal_strength.patch
- .pc/use_correct_signal_strength.patch/audio
- alert
- attrib
- audio
- btio
- compat
- cups
- debian
- debian/patches
- debian/source
- debian/tests
- deviceinfo
- doc
- emulator
- gdbus
- health
- input
- lib
- mgmt
- monitor
- network
- plugins
- proximity
- sap
- sbc
- scripts
- serial
- src
- test
- thermometer
- time
- tools
- unit
added
removed
.pc/force-adapter-class.patch/src/adapter.c
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
#define _GNU_SOURCE
30
#include <stdio.h>
31
#include <errno.h>
32
#include <unistd.h>
33
#include <stdlib.h>
34
#include <sys/ioctl.h>
35
36
#include <bluetooth/bluetooth.h>
37
#include <bluetooth/uuid.h>
38
#include <bluetooth/sdp.h>
39
#include <bluetooth/sdp_lib.h>
40
41
#include <glib.h>
42
#include <dbus/dbus.h>
43
#include <gdbus.h>
44
45
#include "log.h"
46
#include "textfile.h"
47
48
#include "hcid.h"
49
#include "sdpd.h"
50
#include "adapter.h"
51
#include "manager.h"
52
#include "device.h"
53
#include "dbus-common.h"
54
#include "error.h"
55
#include "glib-helper.h"
56
#include "agent.h"
57
#include "storage.h"
58
#include "gattrib.h"
59
#include "att.h"
60
#include "gatt.h"
61
#include "attrib-server.h"
62
#include "eir.h"
63
64
/* Flags Descriptions */
65
#define EIR_LIM_DISC 0x01 /* LE Limited Discoverable Mode */
66
#define EIR_GEN_DISC 0x02 /* LE General Discoverable Mode */
67
#define EIR_BREDR_UNSUP 0x04 /* BR/EDR Not Supported */
68
#define EIR_SIM_CONTROLLER 0x08 /* Simultaneous LE and BR/EDR to Same
69
Device Capable (Controller) */
70
#define EIR_SIM_HOST 0x10 /* Simultaneous LE and BR/EDR to Same
71
Device Capable (Host) */
72
73
#define IO_CAPABILITY_DISPLAYONLY 0x00
74
#define IO_CAPABILITY_DISPLAYYESNO 0x01
75
#define IO_CAPABILITY_KEYBOARDONLY 0x02
76
#define IO_CAPABILITY_NOINPUTNOOUTPUT 0x03
77
#define IO_CAPABILITY_KEYBOARDDISPLAY 0x04
78
#define IO_CAPABILITY_INVALID 0xFF
79
80
#define check_address(address) bachk(address)
81
82
#define OFF_TIMER 3
83
84
static DBusConnection *connection = NULL;
85
static GSList *adapter_drivers = NULL;
86
87
static GSList *ops_candidates = NULL;
88
89
const struct btd_adapter_ops *adapter_ops = NULL;
90
91
struct session_req {
92
struct btd_adapter *adapter;
93
DBusConnection *conn; /* Connection reference */
94
DBusMessage *msg; /* Unreplied message ref */
95
char *owner; /* Bus name of the owner */
96
guint id; /* Listener id */
97
uint8_t mode; /* Requested mode */
98
int refcount; /* Session refcount */
99
gboolean got_reply; /* Agent reply received */
100
};
101
102
struct service_auth {
103
service_auth_cb cb;
104
void *user_data;
105
struct btd_device *device;
106
struct btd_adapter *adapter;
107
};
108
109
struct btd_adapter {
110
uint16_t dev_id;
111
gboolean up;
112
char *path; /* adapter object path */
113
bdaddr_t bdaddr; /* adapter Bluetooth Address */
114
uint32_t dev_class; /* Class of Device */
115
char *name; /* adapter name */
116
gboolean allow_name_changes; /* whether the adapter name can be changed */
117
guint stop_discov_id; /* stop inquiry/scanning id */
118
uint32_t discov_timeout; /* discoverable time(sec) */
119
guint pairable_timeout_id; /* pairable timeout id */
120
uint32_t pairable_timeout; /* pairable time(sec) */
121
uint8_t scan_mode; /* scan mode: SCAN_DISABLED, SCAN_PAGE,
122
* SCAN_INQUIRY */
123
uint8_t mode; /* off, connectable, discoverable,
124
* limited */
125
uint8_t global_mode; /* last valid global mode */
126
struct session_req *pending_mode;
127
int state; /* standard inq, periodic inq, name
128
* resolving, suspended discovery */
129
GSList *found_devices;
130
GSList *oor_devices; /* out of range device list */
131
struct agent *agent; /* For the new API */
132
guint auth_idle_id; /* Ongoing authorization */
133
GSList *connections; /* Connected devices */
134
GSList *devices; /* Devices structure pointers */
135
GSList *mode_sessions; /* Request Mode sessions */
136
GSList *disc_sessions; /* Discovery sessions */
137
guint discov_id; /* Discovery timer */
138
gboolean discovering; /* Discovery active */
139
gboolean discov_suspended; /* Discovery suspended */
140
guint auto_timeout_id; /* Automatic connections timeout */
141
sdp_list_t *services; /* Services associated to adapter */
142
143
gboolean pairable; /* pairable state */
144
gboolean initialized;
145
146
gboolean off_requested; /* DEVDOWN ioctl was called */
147
148
gint ref;
149
150
guint off_timer;
151
152
GSList *powered_callbacks;
153
GSList *pin_callbacks;
154
155
GSList *loaded_drivers;
156
};
157
158
static void dev_info_free(void *data)
159
{
160
struct remote_dev_info *dev = data;
161
162
g_free(dev->name);
163
g_free(dev->alias);
164
g_slist_free_full(dev->services, g_free);
165
g_strfreev(dev->uuids);
166
g_free(dev);
167
}
168
169
int btd_adapter_set_class(struct btd_adapter *adapter, uint8_t major,
170
uint8_t minor)
171
{
172
return adapter_ops->set_dev_class(adapter->dev_id, major, minor);
173
}
174
175
static const char *mode2str(uint8_t mode)
176
{
177
switch(mode) {
178
case MODE_OFF:
179
return "off";
180
case MODE_CONNECTABLE:
181
return "connectable";
182
case MODE_DISCOVERABLE:
183
return "discoverable";
184
default:
185
return "unknown";
186
}
187
}
188
189
static uint8_t get_mode(const bdaddr_t *bdaddr, const char *mode)
190
{
191
if (strcasecmp("off", mode) == 0)
192
return MODE_OFF;
193
else if (strcasecmp("connectable", mode) == 0)
194
return MODE_CONNECTABLE;
195
else if (strcasecmp("discoverable", mode) == 0)
196
return MODE_DISCOVERABLE;
197
else if (strcasecmp("on", mode) == 0) {
198
char onmode[14], srcaddr[18];
199
200
ba2str(bdaddr, srcaddr);
201
if (read_on_mode(srcaddr, onmode, sizeof(onmode)) < 0)
202
return MODE_CONNECTABLE;
203
204
return get_mode(bdaddr, onmode);
205
} else
206
return MODE_UNKNOWN;
207
}
208
209
static struct session_req *session_ref(struct session_req *req)
210
{
211
req->refcount++;
212
213
DBG("%p: ref=%d", req, req->refcount);
214
215
return req;
216
}
217
218
static struct session_req *create_session(struct btd_adapter *adapter,
219
DBusConnection *conn, DBusMessage *msg,
220
uint8_t mode, GDBusWatchFunction cb)
221
{
222
const char *sender = dbus_message_get_sender(msg);
223
struct session_req *req;
224
225
req = g_new0(struct session_req, 1);
226
req->adapter = adapter;
227
req->conn = dbus_connection_ref(conn);
228
req->msg = dbus_message_ref(msg);
229
req->mode = mode;
230
231
if (cb == NULL)
232
return session_ref(req);
233
234
req->owner = g_strdup(sender);
235
req->id = g_dbus_add_disconnect_watch(conn, sender, cb, req, NULL);
236
237
info("%s session %p with %s activated",
238
req->mode ? "Mode" : "Discovery", req, sender);
239
240
return session_ref(req);
241
}
242
243
static int adapter_set_mode(struct btd_adapter *adapter, uint8_t mode)
244
{
245
int err;
246
247
if (mode == MODE_CONNECTABLE)
248
err = adapter_ops->set_discoverable(adapter->dev_id, FALSE, 0);
249
else
250
err = adapter_ops->set_discoverable(adapter->dev_id, TRUE,
251
adapter->discov_timeout);
252
253
return err;
254
}
255
256
static struct session_req *find_session_by_msg(GSList *list, const DBusMessage *msg)
257
{
258
for (; list; list = list->next) {
259
struct session_req *req = list->data;
260
261
if (req->msg == msg)
262
return req;
263
}
264
265
return NULL;
266
}
267
268
static int set_mode(struct btd_adapter *adapter, uint8_t new_mode,
269
DBusMessage *msg)
270
{
271
int err;
272
const char *modestr;
273
274
if (adapter->pending_mode != NULL)
275
return -EALREADY;
276
277
if (!adapter->up && new_mode != MODE_OFF) {
278
err = adapter_ops->set_powered(adapter->dev_id, TRUE);
279
if (err < 0)
280
return err;
281
282
goto done;
283
}
284
285
if (adapter->up && new_mode == MODE_OFF) {
286
err = adapter_ops->set_powered(adapter->dev_id, FALSE);
287
if (err < 0)
288
return err;
289
290
adapter->off_requested = TRUE;
291
292
goto done;
293
}
294
295
if (new_mode == adapter->mode)
296
return 0;
297
298
err = adapter_set_mode(adapter, new_mode);
299
300
if (err < 0)
301
return err;
302
303
done:
304
modestr = mode2str(new_mode);
305
write_device_mode(&adapter->bdaddr, modestr);
306
307
DBG("%s", modestr);
308
309
if (msg != NULL) {
310
struct session_req *req;
311
312
req = find_session_by_msg(adapter->mode_sessions, msg);
313
if (req) {
314
adapter->pending_mode = req;
315
session_ref(req);
316
} else
317
/* Wait for mode change to reply */
318
adapter->pending_mode = create_session(adapter,
319
connection, msg, new_mode, NULL);
320
} else
321
/* Nothing to reply just write the new mode */
322
adapter->mode = new_mode;
323
324
return 0;
325
}
326
327
static DBusMessage *set_discoverable(DBusConnection *conn, DBusMessage *msg,
328
gboolean discoverable, void *data)
329
{
330
struct btd_adapter *adapter = data;
331
uint8_t mode;
332
int err;
333
334
mode = discoverable ? MODE_DISCOVERABLE : MODE_CONNECTABLE;
335
336
if (mode == adapter->mode) {
337
adapter->global_mode = mode;
338
return dbus_message_new_method_return(msg);
339
}
340
341
err = set_mode(adapter, mode, msg);
342
if (err < 0)
343
return btd_error_failed(msg, strerror(-err));
344
345
return NULL;
346
}
347
348
static DBusMessage *set_powered(DBusConnection *conn, DBusMessage *msg,
349
gboolean powered, void *data)
350
{
351
struct btd_adapter *adapter = data;
352
uint8_t mode;
353
int err;
354
355
if (powered) {
356
mode = get_mode(&adapter->bdaddr, "on");
357
return set_discoverable(conn, msg, mode == MODE_DISCOVERABLE,
358
data);
359
}
360
361
mode = MODE_OFF;
362
363
if (mode == adapter->mode) {
364
adapter->global_mode = mode;
365
return dbus_message_new_method_return(msg);
366
}
367
368
err = set_mode(adapter, mode, msg);
369
if (err < 0)
370
return btd_error_failed(msg, strerror(-err));
371
372
return NULL;
373
}
374
375
static DBusMessage *set_pairable(DBusConnection *conn, DBusMessage *msg,
376
gboolean pairable, void *data)
377
{
378
struct btd_adapter *adapter = data;
379
int err;
380
381
if (adapter->scan_mode == SCAN_DISABLED)
382
return btd_error_not_ready(msg);
383
384
if (pairable == adapter->pairable)
385
goto done;
386
387
if (!(adapter->scan_mode & SCAN_INQUIRY))
388
goto store;
389
390
err = set_mode(adapter, MODE_DISCOVERABLE, NULL);
391
if (err < 0 && msg)
392
return btd_error_failed(msg, strerror(-err));
393
394
store:
395
adapter_ops->set_pairable(adapter->dev_id, pairable);
396
397
done:
398
return msg ? dbus_message_new_method_return(msg) : NULL;
399
}
400
401
static gboolean pairable_timeout_handler(void *data)
402
{
403
set_pairable(NULL, NULL, FALSE, data);
404
405
return FALSE;
406
}
407
408
static void adapter_set_pairable_timeout(struct btd_adapter *adapter,
409
guint interval)
410
{
411
if (adapter->pairable_timeout_id) {
412
g_source_remove(adapter->pairable_timeout_id);
413
adapter->pairable_timeout_id = 0;
414
}
415
416
if (interval == 0)
417
return;
418
419
adapter->pairable_timeout_id = g_timeout_add_seconds(interval,
420
pairable_timeout_handler,
421
adapter);
422
}
423
424
void btd_adapter_pairable_changed(struct btd_adapter *adapter,
425
gboolean pairable)
426
{
427
adapter->pairable = pairable;
428
429
write_device_pairable(&adapter->bdaddr, pairable);
430
431
emit_property_changed(connection, adapter->path,
432
ADAPTER_INTERFACE, "Pairable",
433
DBUS_TYPE_BOOLEAN, &pairable);
434
435
if (pairable && adapter->pairable_timeout)
436
adapter_set_pairable_timeout(adapter,
437
adapter->pairable_timeout);
438
}
439
440
static struct session_req *find_session(GSList *list, const char *sender)
441
{
442
for (; list; list = list->next) {
443
struct session_req *req = list->data;
444
445
if (g_str_equal(req->owner, sender))
446
return req;
447
}
448
449
return NULL;
450
}
451
452
static uint8_t get_needed_mode(struct btd_adapter *adapter, uint8_t mode)
453
{
454
GSList *l;
455
456
if (adapter->global_mode > mode)
457
mode = adapter->global_mode;
458
459
for (l = adapter->mode_sessions; l; l = l->next) {
460
struct session_req *req = l->data;
461
462
if (req->mode > mode)
463
mode = req->mode;
464
}
465
466
return mode;
467
}
468
469
static GSList *remove_bredr(GSList *all)
470
{
471
GSList *l, *le;
472
473
for (l = all, le = NULL; l; l = l->next) {
474
struct remote_dev_info *dev = l->data;
475
if (dev->bdaddr_type == BDADDR_BREDR) {
476
dev_info_free(dev);
477
continue;
478
}
479
480
le = g_slist_append(le, dev);
481
}
482
483
g_slist_free(all);
484
485
return le;
486
}
487
488
/* Called when a session gets removed or the adapter is stopped */
489
static void stop_discovery(struct btd_adapter *adapter)
490
{
491
adapter->found_devices = remove_bredr(adapter->found_devices);
492
493
if (adapter->oor_devices) {
494
g_slist_free(adapter->oor_devices);
495
adapter->oor_devices = NULL;
496
}
497
498
/* Reset if suspended, otherwise remove timer (software scheduler)
499
* or request inquiry to stop */
500
if (adapter->discov_suspended) {
501
adapter->discov_suspended = FALSE;
502
return;
503
}
504
505
if (adapter->discov_id > 0) {
506
g_source_remove(adapter->discov_id);
507
adapter->discov_id = 0;
508
return;
509
}
510
511
if (adapter->up)
512
adapter_ops->stop_discovery(adapter->dev_id);
513
}
514
515
static void session_remove(struct session_req *req)
516
{
517
struct btd_adapter *adapter = req->adapter;
518
519
/* Ignore set_mode session */
520
if (req->owner == NULL)
521
return;
522
523
DBG("%s session %p with %s deactivated",
524
req->mode ? "Mode" : "Discovery", req, req->owner);
525
526
if (req->mode) {
527
uint8_t mode;
528
529
adapter->mode_sessions = g_slist_remove(adapter->mode_sessions,
530
req);
531
532
mode = get_needed_mode(adapter, adapter->global_mode);
533
534
if (mode == adapter->mode)
535
return;
536
537
DBG("Switching to '%s' mode", mode2str(mode));
538
539
set_mode(adapter, mode, NULL);
540
} else {
541
adapter->disc_sessions = g_slist_remove(adapter->disc_sessions,
542
req);
543
544
if (adapter->disc_sessions)
545
return;
546
547
DBG("Stopping discovery");
548
549
stop_discovery(adapter);
550
}
551
}
552
553
static void session_free(void *data)
554
{
555
struct session_req *req = data;
556
557
if (req->id)
558
g_dbus_remove_watch(req->conn, req->id);
559
560
if (req->msg) {
561
dbus_message_unref(req->msg);
562
if (!req->got_reply && req->mode && req->adapter->agent)
563
agent_cancel(req->adapter->agent);
564
}
565
566
if (req->conn)
567
dbus_connection_unref(req->conn);
568
g_free(req->owner);
569
g_free(req);
570
}
571
572
static void session_owner_exit(DBusConnection *conn, void *user_data)
573
{
574
struct session_req *req = user_data;
575
576
req->id = 0;
577
578
session_remove(req);
579
session_free(req);
580
}
581
582
static void session_unref(struct session_req *req)
583
{
584
req->refcount--;
585
586
DBG("%p: ref=%d", req, req->refcount);
587
588
if (req->refcount)
589
return;
590
591
session_remove(req);
592
session_free(req);
593
}
594
595
static void confirm_mode_cb(struct agent *agent, DBusError *derr, void *data)
596
{
597
struct session_req *req = data;
598
int err;
599
DBusMessage *reply;
600
601
req->got_reply = TRUE;
602
603
if (derr && dbus_error_is_set(derr)) {
604
reply = dbus_message_new_error(req->msg, derr->name,
605
derr->message);
606
g_dbus_send_message(req->conn, reply);
607
session_unref(req);
608
return;
609
}
610
611
err = set_mode(req->adapter, req->mode, req->msg);
612
if (err < 0)
613
reply = btd_error_failed(req->msg, strerror(-err));
614
else if (!req->adapter->pending_mode)
615
reply = dbus_message_new_method_return(req->msg);
616
else
617
reply = NULL;
618
619
if (reply) {
620
/*
621
* Send reply immediately only if there was an error changing
622
* mode, or change is not needed. Otherwise, reply is sent in
623
* set_mode_complete.
624
*/
625
g_dbus_send_message(req->conn, reply);
626
627
dbus_message_unref(req->msg);
628
req->msg = NULL;
629
}
630
631
if (!find_session(req->adapter->mode_sessions, req->owner))
632
session_unref(req);
633
}
634
635
static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
636
DBusMessage *msg,
637
uint32_t timeout,
638
void *data)
639
{
640
struct btd_adapter *adapter = data;
641
const char *path;
642
643
if (adapter->discov_timeout == timeout && timeout == 0)
644
return dbus_message_new_method_return(msg);
645
646
if (adapter->scan_mode & SCAN_INQUIRY)
647
adapter_ops->set_discoverable(adapter->dev_id, TRUE, timeout);
648
649
adapter->discov_timeout = timeout;
650
651
write_discoverable_timeout(&adapter->bdaddr, timeout);
652
653
path = dbus_message_get_path(msg);
654
655
emit_property_changed(conn, path,
656
ADAPTER_INTERFACE, "DiscoverableTimeout",
657
DBUS_TYPE_UINT32, &timeout);
658
659
return dbus_message_new_method_return(msg);
660
}
661
662
static DBusMessage *set_pairable_timeout(DBusConnection *conn,
663
DBusMessage *msg,
664
uint32_t timeout,
665
void *data)
666
{
667
struct btd_adapter *adapter = data;
668
const char *path;
669
670
if (adapter->pairable_timeout == timeout && timeout == 0)
671
return dbus_message_new_method_return(msg);
672
673
if (adapter->pairable)
674
adapter_set_pairable_timeout(adapter, timeout);
675
676
adapter->pairable_timeout = timeout;
677
678
write_pairable_timeout(&adapter->bdaddr, timeout);
679
680
path = dbus_message_get_path(msg);
681
682
emit_property_changed(conn, path,
683
ADAPTER_INTERFACE, "PairableTimeout",
684
DBUS_TYPE_UINT32, &timeout);
685
686
return dbus_message_new_method_return(msg);
687
}
688
689
void btd_adapter_class_changed(struct btd_adapter *adapter, uint32_t new_class)
690
{
691
uint8_t class[3];
692
693
class[2] = (new_class >> 16) & 0xff;
694
class[1] = (new_class >> 8) & 0xff;
695
class[0] = new_class & 0xff;
696
697
write_local_class(&adapter->bdaddr, class);
698
699
adapter->dev_class = new_class;
700
701
if (main_opts.gatt_enabled) {
702
/* Removes service class */
703
class[1] = class[1] & 0x1f;
704
attrib_gap_set(adapter, GATT_CHARAC_APPEARANCE, class, 2);
705
}
706
707
emit_property_changed(connection, adapter->path,
708
ADAPTER_INTERFACE, "Class",
709
DBUS_TYPE_UINT32, &new_class);
710
}
711
712
void adapter_name_changed(struct btd_adapter *adapter, const char *name)
713
{
714
if (g_strcmp0(adapter->name, name) == 0)
715
return;
716
717
g_free(adapter->name);
718
adapter->name = g_strdup(name);
719
720
if (connection)
721
emit_property_changed(connection, adapter->path,
722
ADAPTER_INTERFACE, "Name",
723
DBUS_TYPE_STRING, &name);
724
725
if (main_opts.gatt_enabled)
726
attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
727
(const uint8_t *) name, strlen(name));
728
}
729
730
int adapter_set_name(struct btd_adapter *adapter, const char *name)
731
{
732
char maxname[MAX_NAME_LENGTH + 1];
733
734
if (g_strcmp0(adapter->name, name) == 0)
735
return 0;
736
737
memset(maxname, 0, sizeof(maxname));
738
strncpy(maxname, name, MAX_NAME_LENGTH);
739
if (!g_utf8_validate(maxname, -1, NULL)) {
740
error("Name change failed: supplied name isn't valid UTF-8");
741
return -EINVAL;
742
}
743
744
if (adapter->up) {
745
int err = adapter_ops->set_name(adapter->dev_id, maxname);
746
if (err < 0)
747
return err;
748
} else {
749
g_free(adapter->name);
750
adapter->name = g_strdup(maxname);
751
}
752
753
write_local_name(&adapter->bdaddr, maxname);
754
755
return 0;
756
}
757
758
static DBusMessage *set_name(DBusConnection *conn, DBusMessage *msg,
759
const char *name, void *data)
760
{
761
struct btd_adapter *adapter = data;
762
int ret;
763
764
if (adapter->allow_name_changes == FALSE)
765
return btd_error_failed(msg, strerror(EPERM));
766
767
ret = adapter_set_name(adapter, name);
768
if (ret == -EINVAL)
769
return btd_error_invalid_args(msg);
770
else if (ret < 0)
771
return btd_error_failed(msg, strerror(-ret));
772
773
return dbus_message_new_method_return(msg);
774
}
775
776
struct btd_device *adapter_find_device(struct btd_adapter *adapter,
777
const char *dest)
778
{
779
struct btd_device *device;
780
GSList *l;
781
782
if (!adapter)
783
return NULL;
784
785
l = g_slist_find_custom(adapter->devices, dest,
786
(GCompareFunc) device_address_cmp);
787
if (!l)
788
return NULL;
789
790
device = l->data;
791
792
return device;
793
}
794
795
static void adapter_update_devices(struct btd_adapter *adapter)
796
{
797
char **devices;
798
int i;
799
GSList *l;
800
801
/* Devices */
802
devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
803
for (i = 0, l = adapter->devices; l; l = l->next, i++) {
804
struct btd_device *dev = l->data;
805
devices[i] = (char *) device_get_path(dev);
806
}
807
808
emit_array_property_changed(connection, adapter->path,
809
ADAPTER_INTERFACE, "Devices",
810
DBUS_TYPE_OBJECT_PATH, &devices, i);
811
g_free(devices);
812
}
813
814
static void adapter_emit_uuids_updated(struct btd_adapter *adapter)
815
{
816
char **uuids;
817
int i;
818
sdp_list_t *list;
819
820
if (!adapter->initialized)
821
return;
822
823
uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
824
825
for (i = 0, list = adapter->services; list; list = list->next) {
826
char *uuid;
827
sdp_record_t *rec = list->data;
828
829
uuid = bt_uuid2string(&rec->svclass);
830
if (uuid)
831
uuids[i++] = uuid;
832
}
833
834
emit_array_property_changed(connection, adapter->path,
835
ADAPTER_INTERFACE, "UUIDs", DBUS_TYPE_STRING, &uuids, i);
836
837
g_strfreev(uuids);
838
}
839
840
static uint8_t get_uuid_mask(uuid_t *uuid)
841
{
842
if (uuid->type != SDP_UUID16)
843
return 0;
844
845
switch (uuid->value.uuid16) {
846
case DIALUP_NET_SVCLASS_ID:
847
case CIP_SVCLASS_ID:
848
return 0x42; /* Telephony & Networking */
849
case IRMC_SYNC_SVCLASS_ID:
850
case OBEX_OBJPUSH_SVCLASS_ID:
851
case OBEX_FILETRANS_SVCLASS_ID:
852
case IRMC_SYNC_CMD_SVCLASS_ID:
853
case PBAP_PSE_SVCLASS_ID:
854
return 0x10; /* Object Transfer */
855
case HEADSET_SVCLASS_ID:
856
case HANDSFREE_SVCLASS_ID:
857
return 0x20; /* Audio */
858
case CORDLESS_TELEPHONY_SVCLASS_ID:
859
case INTERCOM_SVCLASS_ID:
860
case FAX_SVCLASS_ID:
861
case SAP_SVCLASS_ID:
862
/*
863
* Setting the telephony bit for the handsfree audio gateway
864
* role is not required by the HFP specification, but the
865
* Nokia 616 carkit is just plain broken! It will refuse
866
* pairing without this bit set.
867
*/
868
case HANDSFREE_AGW_SVCLASS_ID:
869
return 0x40; /* Telephony */
870
case AUDIO_SOURCE_SVCLASS_ID:
871
case VIDEO_SOURCE_SVCLASS_ID:
872
return 0x08; /* Capturing */
873
case AUDIO_SINK_SVCLASS_ID:
874
case VIDEO_SINK_SVCLASS_ID:
875
return 0x04; /* Rendering */
876
case PANU_SVCLASS_ID:
877
case NAP_SVCLASS_ID:
878
case GN_SVCLASS_ID:
879
return 0x02; /* Networking */
880
default:
881
return 0;
882
}
883
}
884
885
static int uuid_cmp(const void *a, const void *b)
886
{
887
const sdp_record_t *rec = a;
888
const uuid_t *uuid = b;
889
890
return sdp_uuid_cmp(&rec->svclass, uuid);
891
}
892
893
void adapter_service_insert(struct btd_adapter *adapter, void *r)
894
{
895
sdp_record_t *rec = r;
896
gboolean new_uuid;
897
898
if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
899
new_uuid = TRUE;
900
else
901
new_uuid = FALSE;
902
903
adapter->services = sdp_list_insert_sorted(adapter->services, rec,
904
record_sort);
905
906
if (new_uuid) {
907
uint8_t svc_hint = get_uuid_mask(&rec->svclass);
908
adapter_ops->add_uuid(adapter->dev_id, &rec->svclass, svc_hint);
909
}
910
911
adapter_emit_uuids_updated(adapter);
912
}
913
914
void adapter_service_remove(struct btd_adapter *adapter, void *r)
915
{
916
sdp_record_t *rec = r;
917
918
adapter->services = sdp_list_remove(adapter->services, rec);
919
920
if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
921
adapter_ops->remove_uuid(adapter->dev_id, &rec->svclass);
922
923
adapter_emit_uuids_updated(adapter);
924
}
925
926
static struct btd_device *adapter_create_device(DBusConnection *conn,
927
struct btd_adapter *adapter,
928
const char *address,
929
uint8_t bdaddr_type)
930
{
931
struct btd_device *device;
932
const char *path;
933
934
DBG("%s", address);
935
936
device = device_create(conn, adapter, address, bdaddr_type);
937
if (!device)
938
return NULL;
939
940
device_set_temporary(device, TRUE);
941
942
adapter->devices = g_slist_append(adapter->devices, device);
943
944
path = device_get_path(device);
945
g_dbus_emit_signal(conn, adapter->path,
946
ADAPTER_INTERFACE, "DeviceCreated",
947
DBUS_TYPE_OBJECT_PATH, &path,
948
DBUS_TYPE_INVALID);
949
950
adapter_update_devices(adapter);
951
952
return device;
953
}
954
955
void adapter_remove_device(DBusConnection *conn, struct btd_adapter *adapter,
956
struct btd_device *device,
957
gboolean remove_storage)
958
{
959
const gchar *dev_path = device_get_path(device);
960
struct agent *agent;
961
962
adapter->devices = g_slist_remove(adapter->devices, device);
963
adapter->connections = g_slist_remove(adapter->connections, device);
964
965
adapter_update_devices(adapter);
966
967
g_dbus_emit_signal(conn, adapter->path,
968
ADAPTER_INTERFACE, "DeviceRemoved",
969
DBUS_TYPE_OBJECT_PATH, &dev_path,
970
DBUS_TYPE_INVALID);
971
972
agent = device_get_agent(device);
973
974
if (agent && device_is_authorizing(device))
975
agent_cancel(agent);
976
977
device_remove(device, remove_storage);
978
}
979
980
struct btd_device *adapter_get_device(DBusConnection *conn,
981
struct btd_adapter *adapter,
982
const gchar *address)
983
{
984
struct btd_device *device;
985
986
DBG("%s", address);
987
988
if (!adapter)
989
return NULL;
990
991
device = adapter_find_device(adapter, address);
992
if (device)
993
return device;
994
995
return adapter_create_device(conn, adapter, address,
996
BDADDR_BREDR);
997
}
998
999
static gboolean discovery_cb(gpointer user_data)
1000
{
1001
struct btd_adapter *adapter = user_data;
1002
int err;
1003
1004
adapter->discov_id = 0;
1005
1006
err = adapter_ops->start_discovery(adapter->dev_id);
1007
if (err < 0)
1008
error("start_discovery: %s (%d)", strerror(-err), -err);
1009
1010
return FALSE;
1011
}
1012
1013
static DBusMessage *adapter_start_discovery(DBusConnection *conn,
1014
DBusMessage *msg, void *data)
1015
{
1016
struct session_req *req;
1017
struct btd_adapter *adapter = data;
1018
const char *sender = dbus_message_get_sender(msg);
1019
int err;
1020
1021
if (!adapter->up)
1022
return btd_error_not_ready(msg);
1023
1024
req = find_session(adapter->disc_sessions, sender);
1025
if (req) {
1026
session_ref(req);
1027
return dbus_message_new_method_return(msg);
1028
}
1029
1030
if (adapter->disc_sessions)
1031
goto done;
1032
1033
g_slist_free_full(adapter->found_devices, dev_info_free);
1034
adapter->found_devices = NULL;
1035
1036
g_slist_free(adapter->oor_devices);
1037
adapter->oor_devices = NULL;
1038
1039
if (adapter->discov_suspended)
1040
goto done;
1041
1042
err = adapter_ops->start_discovery(adapter->dev_id);
1043
if (err < 0)
1044
return btd_error_failed(msg, strerror(-err));
1045
1046
done:
1047
req = create_session(adapter, conn, msg, 0,
1048
session_owner_exit);
1049
1050
adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
1051
1052
return dbus_message_new_method_return(msg);
1053
}
1054
1055
static DBusMessage *adapter_stop_discovery(DBusConnection *conn,
1056
DBusMessage *msg, void *data)
1057
{
1058
struct btd_adapter *adapter = data;
1059
struct session_req *req;
1060
const char *sender = dbus_message_get_sender(msg);
1061
1062
if (!adapter->up)
1063
return btd_error_not_ready(msg);
1064
1065
req = find_session(adapter->disc_sessions, sender);
1066
if (!req)
1067
return btd_error_failed(msg, "Invalid discovery session");
1068
1069
session_unref(req);
1070
info("Stopping discovery");
1071
return dbus_message_new_method_return(msg);
1072
}
1073
1074
static DBusMessage *get_properties(DBusConnection *conn,
1075
DBusMessage *msg, void *data)
1076
{
1077
struct btd_adapter *adapter = data;
1078
const char *property;
1079
DBusMessage *reply;
1080
DBusMessageIter iter;
1081
DBusMessageIter dict;
1082
char srcaddr[18];
1083
gboolean value;
1084
char **devices, **uuids;
1085
int i;
1086
GSList *l;
1087
sdp_list_t *list;
1088
1089
ba2str(&adapter->bdaddr, srcaddr);
1090
1091
if (check_address(srcaddr) < 0)
1092
return btd_error_invalid_args(msg);
1093
1094
reply = dbus_message_new_method_return(msg);
1095
if (!reply)
1096
return NULL;
1097
1098
dbus_message_iter_init_append(reply, &iter);
1099
1100
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1101
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1102
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1103
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1104
1105
/* Address */
1106
property = srcaddr;
1107
dict_append_entry(&dict, "Address", DBUS_TYPE_STRING, &property);
1108
1109
/* Name */
1110
property = adapter->name ? : "";
1111
1112
dict_append_entry(&dict, "Name", DBUS_TYPE_STRING, &property);
1113
1114
/* Class */
1115
dict_append_entry(&dict, "Class",
1116
DBUS_TYPE_UINT32, &adapter->dev_class);
1117
1118
/* Powered */
1119
value = (adapter->up && !adapter->off_requested) ? TRUE : FALSE;
1120
dict_append_entry(&dict, "Powered", DBUS_TYPE_BOOLEAN, &value);
1121
1122
/* Discoverable */
1123
value = adapter->scan_mode & SCAN_INQUIRY ? TRUE : FALSE;
1124
dict_append_entry(&dict, "Discoverable", DBUS_TYPE_BOOLEAN, &value);
1125
1126
/* Pairable */
1127
dict_append_entry(&dict, "Pairable", DBUS_TYPE_BOOLEAN,
1128
&adapter->pairable);
1129
1130
/* DiscoverableTimeout */
1131
dict_append_entry(&dict, "DiscoverableTimeout",
1132
DBUS_TYPE_UINT32, &adapter->discov_timeout);
1133
1134
/* PairableTimeout */
1135
dict_append_entry(&dict, "PairableTimeout",
1136
DBUS_TYPE_UINT32, &adapter->pairable_timeout);
1137
1138
1139
/* Discovering */
1140
dict_append_entry(&dict, "Discovering", DBUS_TYPE_BOOLEAN,
1141
&adapter->discovering);
1142
1143
/* Devices */
1144
devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
1145
for (i = 0, l = adapter->devices; l; l = l->next, i++) {
1146
struct btd_device *dev = l->data;
1147
devices[i] = (char *) device_get_path(dev);
1148
}
1149
dict_append_array(&dict, "Devices", DBUS_TYPE_OBJECT_PATH,
1150
&devices, i);
1151
g_free(devices);
1152
1153
/* UUIDs */
1154
uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
1155
1156
for (i = 0, list = adapter->services; list; list = list->next) {
1157
sdp_record_t *rec = list->data;
1158
char *uuid;
1159
1160
uuid = bt_uuid2string(&rec->svclass);
1161
if (uuid)
1162
uuids[i++] = uuid;
1163
}
1164
1165
dict_append_array(&dict, "UUIDs", DBUS_TYPE_STRING, &uuids, i);
1166
1167
g_strfreev(uuids);
1168
1169
dbus_message_iter_close_container(&iter, &dict);
1170
1171
return reply;
1172
}
1173
1174
static DBusMessage *set_property(DBusConnection *conn,
1175
DBusMessage *msg, void *data)
1176
{
1177
DBusMessageIter iter;
1178
DBusMessageIter sub;
1179
const char *property;
1180
1181
if (!dbus_message_iter_init(msg, &iter))
1182
return btd_error_invalid_args(msg);
1183
1184
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
1185
return btd_error_invalid_args(msg);
1186
1187
dbus_message_iter_get_basic(&iter, &property);
1188
dbus_message_iter_next(&iter);
1189
1190
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
1191
return btd_error_invalid_args(msg);
1192
dbus_message_iter_recurse(&iter, &sub);
1193
1194
if (g_str_equal("Name", property)) {
1195
const char *name;
1196
1197
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)
1198
return btd_error_invalid_args(msg);
1199
dbus_message_iter_get_basic(&sub, &name);
1200
1201
return set_name(conn, msg, name, data);
1202
} else if (g_str_equal("Powered", property)) {
1203
gboolean powered;
1204
1205
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1206
return btd_error_invalid_args(msg);
1207
1208
dbus_message_iter_get_basic(&sub, &powered);
1209
1210
return set_powered(conn, msg, powered, data);
1211
} else if (g_str_equal("Discoverable", property)) {
1212
gboolean discoverable;
1213
1214
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1215
return btd_error_invalid_args(msg);
1216
1217
dbus_message_iter_get_basic(&sub, &discoverable);
1218
1219
return set_discoverable(conn, msg, discoverable, data);
1220
} else if (g_str_equal("DiscoverableTimeout", property)) {
1221
uint32_t timeout;
1222
1223
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
1224
return btd_error_invalid_args(msg);
1225
1226
dbus_message_iter_get_basic(&sub, &timeout);
1227
1228
return set_discoverable_timeout(conn, msg, timeout, data);
1229
} else if (g_str_equal("Pairable", property)) {
1230
gboolean pairable;
1231
1232
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1233
return btd_error_invalid_args(msg);
1234
1235
dbus_message_iter_get_basic(&sub, &pairable);
1236
1237
return set_pairable(conn, msg, pairable, data);
1238
} else if (g_str_equal("PairableTimeout", property)) {
1239
uint32_t timeout;
1240
1241
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
1242
return btd_error_invalid_args(msg);
1243
1244
dbus_message_iter_get_basic(&sub, &timeout);
1245
1246
return set_pairable_timeout(conn, msg, timeout, data);
1247
}
1248
1249
return btd_error_invalid_args(msg);
1250
}
1251
1252
static DBusMessage *request_session(DBusConnection *conn,
1253
DBusMessage *msg, void *data)
1254
{
1255
struct btd_adapter *adapter = data;
1256
struct session_req *req;
1257
const char *sender = dbus_message_get_sender(msg);
1258
uint8_t new_mode;
1259
int err;
1260
1261
if (!adapter->agent)
1262
return btd_error_agent_not_available(msg);
1263
1264
if (!adapter->mode_sessions)
1265
adapter->global_mode = adapter->mode;
1266
1267
new_mode = get_mode(&adapter->bdaddr, "on");
1268
1269
req = find_session(adapter->mode_sessions, sender);
1270
if (req) {
1271
session_ref(req);
1272
return dbus_message_new_method_return(msg);
1273
} else {
1274
req = create_session(adapter, conn, msg, new_mode,
1275
session_owner_exit);
1276
adapter->mode_sessions = g_slist_append(adapter->mode_sessions,
1277
req);
1278
}
1279
1280
/* No need to change mode */
1281
if (adapter->mode >= new_mode)
1282
return dbus_message_new_method_return(msg);
1283
1284
err = agent_confirm_mode_change(adapter->agent, mode2str(new_mode),
1285
confirm_mode_cb, req, NULL);
1286
if (err < 0) {
1287
session_unref(req);
1288
return btd_error_failed(msg, strerror(-err));
1289
}
1290
1291
return NULL;
1292
}
1293
1294
static DBusMessage *release_session(DBusConnection *conn,
1295
DBusMessage *msg, void *data)
1296
{
1297
struct btd_adapter *adapter = data;
1298
struct session_req *req;
1299
const char *sender = dbus_message_get_sender(msg);
1300
1301
req = find_session(adapter->mode_sessions, sender);
1302
if (!req)
1303
return btd_error_failed(msg, "Invalid Session");
1304
1305
session_unref(req);
1306
1307
return dbus_message_new_method_return(msg);
1308
}
1309
1310
static DBusMessage *list_devices(DBusConnection *conn,
1311
DBusMessage *msg, void *data)
1312
{
1313
struct btd_adapter *adapter = data;
1314
DBusMessage *reply;
1315
GSList *l;
1316
DBusMessageIter iter;
1317
DBusMessageIter array_iter;
1318
const gchar *dev_path;
1319
1320
reply = dbus_message_new_method_return(msg);
1321
if (!reply)
1322
return NULL;
1323
1324
dbus_message_iter_init_append(reply, &iter);
1325
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1326
DBUS_TYPE_OBJECT_PATH_AS_STRING, &array_iter);
1327
1328
for (l = adapter->devices; l; l = l->next) {
1329
struct btd_device *device = l->data;
1330
1331
dev_path = device_get_path(device);
1332
1333
dbus_message_iter_append_basic(&array_iter,
1334
DBUS_TYPE_OBJECT_PATH, &dev_path);
1335
}
1336
1337
dbus_message_iter_close_container(&iter, &array_iter);
1338
1339
return reply;
1340
}
1341
1342
static DBusMessage *cancel_device_creation(DBusConnection *conn,
1343
DBusMessage *msg, void *data)
1344
{
1345
struct btd_adapter *adapter = data;
1346
const gchar *address, *sender = dbus_message_get_sender(msg);
1347
struct btd_device *device;
1348
1349
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1350
DBUS_TYPE_INVALID) == FALSE)
1351
return btd_error_invalid_args(msg);
1352
1353
if (check_address(address) < 0)
1354
return btd_error_invalid_args(msg);
1355
1356
device = adapter_find_device(adapter, address);
1357
if (!device || !device_is_creating(device, NULL))
1358
return btd_error_does_not_exist(msg);
1359
1360
if (!device_is_creating(device, sender))
1361
return btd_error_not_authorized(msg);
1362
1363
device_set_temporary(device, TRUE);
1364
1365
if (device_is_connected(device)) {
1366
device_request_disconnect(device, msg);
1367
return NULL;
1368
}
1369
1370
adapter_remove_device(conn, adapter, device, TRUE);
1371
1372
return dbus_message_new_method_return(msg);
1373
}
1374
1375
static struct btd_device *create_device_internal(DBusConnection *conn,
1376
struct btd_adapter *adapter,
1377
const char *address, int *err)
1378
{
1379
struct remote_dev_info *dev;
1380
struct btd_device *device;
1381
bdaddr_t addr;
1382
uint8_t bdaddr_type;
1383
1384
str2ba(address, &addr);
1385
1386
dev = adapter_search_found_devices(adapter, &addr);
1387
if (dev)
1388
bdaddr_type = dev->bdaddr_type;
1389
else
1390
bdaddr_type = BDADDR_BREDR;
1391
1392
device = adapter_create_device(conn, adapter, address, bdaddr_type);
1393
if (!device && err)
1394
*err = -ENOMEM;
1395
1396
return device;
1397
}
1398
1399
static DBusMessage *create_device(DBusConnection *conn,
1400
DBusMessage *msg, void *data)
1401
{
1402
struct btd_adapter *adapter = data;
1403
struct btd_device *device;
1404
const gchar *address;
1405
DBusMessage *reply;
1406
int err;
1407
1408
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1409
DBUS_TYPE_INVALID) == FALSE)
1410
return btd_error_invalid_args(msg);
1411
1412
if (check_address(address) < 0)
1413
return btd_error_invalid_args(msg);
1414
1415
if (!adapter->up)
1416
return btd_error_not_ready(msg);
1417
1418
if (adapter_find_device(adapter, address))
1419
return btd_error_already_exists(msg);
1420
1421
DBG("%s", address);
1422
1423
device = create_device_internal(conn, adapter, address, &err);
1424
if (!device)
1425
goto failed;
1426
1427
if (device_is_bredr(device))
1428
err = device_browse_sdp(device, conn, msg, NULL, FALSE);
1429
else
1430
err = device_browse_primary(device, conn, msg, FALSE);
1431
1432
if (err < 0) {
1433
adapter_remove_device(conn, adapter, device, TRUE);
1434
return btd_error_failed(msg, strerror(-err));
1435
}
1436
1437
return NULL;
1438
1439
failed:
1440
if (err == -ENOTCONN) {
1441
/* Device is not connectable */
1442
const char *path = device_get_path(device);
1443
1444
reply = dbus_message_new_method_return(msg);
1445
1446
dbus_message_append_args(reply,
1447
DBUS_TYPE_OBJECT_PATH, &path,
1448
DBUS_TYPE_INVALID);
1449
} else
1450
reply = btd_error_failed(msg, strerror(-err));
1451
1452
return reply;
1453
}
1454
1455
static uint8_t parse_io_capability(const char *capability)
1456
{
1457
if (g_str_equal(capability, ""))
1458
return IO_CAPABILITY_DISPLAYYESNO;
1459
if (g_str_equal(capability, "DisplayOnly"))
1460
return IO_CAPABILITY_DISPLAYONLY;
1461
if (g_str_equal(capability, "DisplayYesNo"))
1462
return IO_CAPABILITY_DISPLAYYESNO;
1463
if (g_str_equal(capability, "KeyboardOnly"))
1464
return IO_CAPABILITY_KEYBOARDONLY;
1465
if (g_str_equal(capability, "NoInputNoOutput"))
1466
return IO_CAPABILITY_NOINPUTNOOUTPUT;
1467
if (g_str_equal(capability, "KeyboardDisplay"))
1468
return IO_CAPABILITY_KEYBOARDDISPLAY;
1469
return IO_CAPABILITY_INVALID;
1470
}
1471
1472
static DBusMessage *create_paired_device(DBusConnection *conn,
1473
DBusMessage *msg, void *data)
1474
{
1475
struct btd_adapter *adapter = data;
1476
struct btd_device *device;
1477
const gchar *address, *agent_path, *capability, *sender;
1478
uint8_t cap;
1479
int err;
1480
1481
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1482
DBUS_TYPE_OBJECT_PATH, &agent_path,
1483
DBUS_TYPE_STRING, &capability,
1484
DBUS_TYPE_INVALID) == FALSE)
1485
return btd_error_invalid_args(msg);
1486
1487
if (check_address(address) < 0)
1488
return btd_error_invalid_args(msg);
1489
1490
if (!adapter->up)
1491
return btd_error_not_ready(msg);
1492
1493
sender = dbus_message_get_sender(msg);
1494
if (adapter->agent &&
1495
agent_matches(adapter->agent, sender, agent_path)) {
1496
error("Refusing adapter agent usage as device specific one");
1497
return btd_error_invalid_args(msg);
1498
}
1499
1500
cap = parse_io_capability(capability);
1501
if (cap == IO_CAPABILITY_INVALID)
1502
return btd_error_invalid_args(msg);
1503
1504
device = adapter_find_device(adapter, address);
1505
if (!device) {
1506
device = create_device_internal(conn, adapter, address, &err);
1507
if (!device)
1508
return btd_error_failed(msg, strerror(-err));
1509
}
1510
1511
return device_create_bonding(device, conn, msg, agent_path, cap);
1512
}
1513
1514
static gint device_path_cmp(struct btd_device *device, const gchar *path)
1515
{
1516
const gchar *dev_path = device_get_path(device);
1517
1518
return strcasecmp(dev_path, path);
1519
}
1520
1521
static DBusMessage *remove_device(DBusConnection *conn, DBusMessage *msg,
1522
void *data)
1523
{
1524
struct btd_adapter *adapter = data;
1525
struct btd_device *device;
1526
const char *path;
1527
GSList *l;
1528
1529
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1530
DBUS_TYPE_INVALID) == FALSE)
1531
return btd_error_invalid_args(msg);
1532
1533
l = g_slist_find_custom(adapter->devices,
1534
path, (GCompareFunc) device_path_cmp);
1535
if (!l)
1536
return btd_error_does_not_exist(msg);
1537
1538
device = l->data;
1539
1540
if (device_is_temporary(device) || device_is_busy(device))
1541
return g_dbus_create_error(msg,
1542
ERROR_INTERFACE ".DoesNotExist",
1543
"Device creation in progress");
1544
1545
device_set_temporary(device, TRUE);
1546
1547
if (!device_is_connected(device)) {
1548
adapter_remove_device(conn, adapter, device, TRUE);
1549
return dbus_message_new_method_return(msg);
1550
}
1551
1552
device_request_disconnect(device, msg);
1553
return NULL;
1554
}
1555
1556
static DBusMessage *find_device(DBusConnection *conn, DBusMessage *msg,
1557
void *data)
1558
{
1559
struct btd_adapter *adapter = data;
1560
struct btd_device *device;
1561
DBusMessage *reply;
1562
const gchar *address;
1563
GSList *l;
1564
const gchar *dev_path;
1565
1566
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1567
DBUS_TYPE_INVALID))
1568
return btd_error_invalid_args(msg);
1569
1570
l = g_slist_find_custom(adapter->devices,
1571
address, (GCompareFunc) device_address_cmp);
1572
if (!l)
1573
return btd_error_does_not_exist(msg);
1574
1575
device = l->data;
1576
1577
reply = dbus_message_new_method_return(msg);
1578
if (!reply)
1579
return NULL;
1580
1581
dev_path = device_get_path(device);
1582
1583
dbus_message_append_args(reply,
1584
DBUS_TYPE_OBJECT_PATH, &dev_path,
1585
DBUS_TYPE_INVALID);
1586
1587
return reply;
1588
}
1589
1590
static void agent_removed(struct agent *agent, struct btd_adapter *adapter)
1591
{
1592
adapter_ops->set_io_capability(adapter->dev_id,
1593
IO_CAPABILITY_NOINPUTNOOUTPUT);
1594
1595
adapter->agent = NULL;
1596
}
1597
1598
static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg,
1599
void *data)
1600
{
1601
const char *path, *name, *capability;
1602
struct btd_adapter *adapter = data;
1603
uint8_t cap;
1604
1605
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1606
DBUS_TYPE_STRING, &capability, DBUS_TYPE_INVALID))
1607
return NULL;
1608
1609
if (adapter->agent)
1610
return btd_error_already_exists(msg);
1611
1612
cap = parse_io_capability(capability);
1613
if (cap == IO_CAPABILITY_INVALID)
1614
return btd_error_invalid_args(msg);
1615
1616
name = dbus_message_get_sender(msg);
1617
1618
adapter->agent = agent_create(adapter, name, path, cap,
1619
(agent_remove_cb) agent_removed, adapter);
1620
1621
DBG("Agent registered for hci%d at %s:%s", adapter->dev_id, name,
1622
path);
1623
1624
adapter_ops->set_io_capability(adapter->dev_id, cap);
1625
1626
return dbus_message_new_method_return(msg);
1627
}
1628
1629
static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg,
1630
void *data)
1631
{
1632
const char *path, *name;
1633
struct btd_adapter *adapter = data;
1634
1635
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1636
DBUS_TYPE_INVALID))
1637
return NULL;
1638
1639
name = dbus_message_get_sender(msg);
1640
1641
if (!adapter->agent || !agent_matches(adapter->agent, name, path))
1642
return btd_error_does_not_exist(msg);
1643
1644
agent_free(adapter->agent);
1645
adapter->agent = NULL;
1646
1647
return dbus_message_new_method_return(msg);
1648
}
1649
1650
static const GDBusMethodTable adapter_methods[] = {
1651
{ GDBUS_METHOD("GetProperties",
1652
NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
1653
get_properties) },
1654
{ GDBUS_ASYNC_METHOD("SetProperty",
1655
GDBUS_ARGS({ "name", "s" }, { "value", "v" }), NULL,
1656
set_property) },
1657
{ GDBUS_ASYNC_METHOD("RequestSession", NULL, NULL,
1658
request_session) },
1659
{ GDBUS_METHOD("ReleaseSession", NULL, NULL,
1660
release_session) },
1661
{ GDBUS_METHOD("StartDiscovery", NULL, NULL,
1662
adapter_start_discovery) },
1663
{ GDBUS_ASYNC_METHOD("StopDiscovery", NULL, NULL,
1664
adapter_stop_discovery) },
1665
{ GDBUS_DEPRECATED_METHOD("ListDevices",
1666
NULL, GDBUS_ARGS({ "devices", "ao" }),
1667
list_devices) },
1668
{ GDBUS_ASYNC_METHOD("CreateDevice",
1669
GDBUS_ARGS({ "address", "s" }),
1670
GDBUS_ARGS({ "device", "o" }),
1671
create_device) },
1672
{ GDBUS_ASYNC_METHOD("CreatePairedDevice",
1673
GDBUS_ARGS({ "address", "s" }, { "agent", "o" },
1674
{ "capability", "s" }),
1675
GDBUS_ARGS({ "device", "o" }),
1676
create_paired_device) },
1677
{ GDBUS_ASYNC_METHOD("CancelDeviceCreation",
1678
GDBUS_ARGS({ "address", "s" }), NULL,
1679
cancel_device_creation) },
1680
{ GDBUS_ASYNC_METHOD("RemoveDevice",
1681
GDBUS_ARGS({ "device", "o" }), NULL,
1682
remove_device) },
1683
{ GDBUS_METHOD("FindDevice",
1684
GDBUS_ARGS({ "address", "s" }),
1685
GDBUS_ARGS({ "device", "o" }),
1686
find_device) },
1687
{ GDBUS_METHOD("RegisterAgent",
1688
GDBUS_ARGS({ "agent", "o" },
1689
{ "capability", "s" }), NULL,
1690
register_agent) },
1691
{ GDBUS_METHOD("UnregisterAgent",
1692
GDBUS_ARGS({ "agent", "o" }), NULL,
1693
unregister_agent) },
1694
{ }
1695
};
1696
1697
static const GDBusSignalTable adapter_signals[] = {
1698
{ GDBUS_SIGNAL("PropertyChanged",
1699
GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
1700
{ GDBUS_SIGNAL("DeviceCreated",
1701
GDBUS_ARGS({ "device", "o" })) },
1702
{ GDBUS_SIGNAL("DeviceRemoved",
1703
GDBUS_ARGS({ "device", "o" })) },
1704
{ GDBUS_SIGNAL("DeviceFound",
1705
GDBUS_ARGS({ "address", "s" },
1706
{ "values", "a{sv}" })) },
1707
{ GDBUS_SIGNAL("DeviceDisappeared",
1708
GDBUS_ARGS({ "address", "s" })) },
1709
{ }
1710
};
1711
1712
static void create_stored_device_from_profiles(char *key, char *value,
1713
void *user_data)
1714
{
1715
struct btd_adapter *adapter = user_data;
1716
GSList *list, *uuids = bt_string2list(value);
1717
struct btd_device *device;
1718
1719
if (g_slist_find_custom(adapter->devices,
1720
key, (GCompareFunc) device_address_cmp))
1721
return;
1722
1723
device = device_create(connection, adapter, key, BDADDR_BREDR);
1724
if (!device)
1725
return;
1726
1727
device_set_temporary(device, FALSE);
1728
adapter->devices = g_slist_append(adapter->devices, device);
1729
1730
list = device_services_from_record(device, uuids);
1731
if (list)
1732
device_register_services(connection, device, list, ATT_PSM);
1733
1734
device_probe_drivers(device, uuids);
1735
1736
g_slist_free_full(uuids, g_free);
1737
}
1738
1739
struct adapter_keys {
1740
struct btd_adapter *adapter;
1741
GSList *keys;
1742
};
1743
1744
static int str2buf(const char *str, uint8_t *buf, size_t blen)
1745
{
1746
int i, dlen;
1747
1748
if (str == NULL)
1749
return -EINVAL;
1750
1751
memset(buf, 0, blen);
1752
1753
dlen = MIN((strlen(str) / 2), blen);
1754
1755
for (i = 0; i < dlen; i++)
1756
sscanf(str + (i * 2), "%02hhX", &buf[i]);
1757
1758
return 0;
1759
}
1760
1761
static struct link_key_info *get_key_info(const char *addr, const char *value)
1762
{
1763
struct link_key_info *info;
1764
char tmp[3];
1765
long int l;
1766
1767
if (strlen(value) < 36) {
1768
error("Unexpectedly short (%zu) link key line", strlen(value));
1769
return NULL;
1770
}
1771
1772
info = g_new0(struct link_key_info, 1);
1773
1774
str2ba(addr, &info->bdaddr);
1775
1776
str2buf(value, info->key, sizeof(info->key));
1777
1778
memcpy(tmp, value + 33, 2);
1779
info->type = (uint8_t) strtol(tmp, NULL, 10);
1780
1781
memcpy(tmp, value + 35, 2);
1782
l = strtol(tmp, NULL, 10);
1783
if (l < 0)
1784
l = 0;
1785
info->pin_len = l;
1786
1787
return info;
1788
}
1789
1790
static struct smp_ltk_info *get_ltk_info(const char *addr, uint8_t bdaddr_type,
1791
const char *value)
1792
{
1793
struct smp_ltk_info *ltk;
1794
char *ptr;
1795
int i, ret;
1796
1797
if (strlen(value) < 60) {
1798
error("Unexpectedly short (%zu) LTK", strlen(value));
1799
return NULL;
1800
}
1801
1802
ltk = g_new0(struct smp_ltk_info, 1);
1803
1804
str2ba(addr, <k->bdaddr);
1805
1806
ltk->bdaddr_type = bdaddr_type;
1807
1808
str2buf(value, ltk->val, sizeof(ltk->val));
1809
1810
ptr = (char *) value + 2 * sizeof(ltk->val) + 1;
1811
1812
ret = sscanf(ptr, " %hhd %hhd %hhd %hd %n",
1813
<k->authenticated, <k->master, <k->enc_size,
1814
<k->ediv, &i);
1815
if (ret < 2) {
1816
g_free(ltk);
1817
return NULL;
1818
}
1819
ptr += i;
1820
1821
str2buf(ptr, ltk->rand, sizeof(ltk->rand));
1822
1823
return ltk;
1824
}
1825
1826
static void create_stored_device_from_linkkeys(char *key, char *value,
1827
void *user_data)
1828
{
1829
struct adapter_keys *keys = user_data;
1830
struct btd_adapter *adapter = keys->adapter;
1831
struct btd_device *device;
1832
struct link_key_info *info;
1833
1834
info = get_key_info(key, value);
1835
if (info)
1836
keys->keys = g_slist_append(keys->keys, info);
1837
1838
if (g_slist_find_custom(adapter->devices, key,
1839
(GCompareFunc) device_address_cmp))
1840
return;
1841
1842
device = device_create(connection, adapter, key, BDADDR_BREDR);
1843
if (device) {
1844
device_set_temporary(device, FALSE);
1845
adapter->devices = g_slist_append(adapter->devices, device);
1846
}
1847
}
1848
1849
static void create_stored_device_from_ltks(char *key, char *value,
1850
void *user_data)
1851
{
1852
struct adapter_keys *keys = user_data;
1853
struct btd_adapter *adapter = keys->adapter;
1854
struct btd_device *device;
1855
struct smp_ltk_info *info;
1856
char address[18], srcaddr[18];
1857
uint8_t bdaddr_type;
1858
bdaddr_t src;
1859
1860
if (sscanf(key, "%17s#%hhu", address, &bdaddr_type) < 2)
1861
return;
1862
1863
info = get_ltk_info(address, bdaddr_type, value);
1864
if (info == NULL)
1865
return;
1866
1867
keys->keys = g_slist_append(keys->keys, info);
1868
1869
if (g_slist_find_custom(adapter->devices, address,
1870
(GCompareFunc) device_address_cmp))
1871
return;
1872
1873
adapter_get_address(adapter, &src);
1874
ba2str(&src, srcaddr);
1875
1876
if (g_strcmp0(srcaddr, address) == 0)
1877
return;
1878
1879
device = device_create(connection, adapter, address, bdaddr_type);
1880
if (device) {
1881
device_set_temporary(device, FALSE);
1882
adapter->devices = g_slist_append(adapter->devices, device);
1883
}
1884
}
1885
1886
static void create_stored_device_from_blocked(char *key, char *value,
1887
void *user_data)
1888
{
1889
struct btd_adapter *adapter = user_data;
1890
struct btd_device *device;
1891
1892
if (g_slist_find_custom(adapter->devices,
1893
key, (GCompareFunc) device_address_cmp))
1894
return;
1895
1896
device = device_create(connection, adapter, key, BDADDR_BREDR);
1897
if (device) {
1898
device_set_temporary(device, FALSE);
1899
adapter->devices = g_slist_append(adapter->devices, device);
1900
}
1901
}
1902
1903
static GSList *string_to_primary_list(char *str)
1904
{
1905
GSList *l = NULL;
1906
char **services;
1907
int i;
1908
1909
if (str == NULL)
1910
return NULL;
1911
1912
services = g_strsplit(str, " ", 0);
1913
if (services == NULL)
1914
return NULL;
1915
1916
for (i = 0; services[i]; i++) {
1917
struct gatt_primary *prim;
1918
int ret;
1919
1920
prim = g_new0(struct gatt_primary, 1);
1921
1922
ret = sscanf(services[i], "%04hX#%04hX#%s", &prim->range.start,
1923
&prim->range.end, prim->uuid);
1924
1925
if (ret < 3) {
1926
g_free(prim);
1927
continue;
1928
}
1929
1930
l = g_slist_append(l, prim);
1931
}
1932
1933
g_strfreev(services);
1934
1935
return l;
1936
}
1937
1938
static void create_stored_device_from_primaries(char *key, char *value,
1939
void *user_data)
1940
{
1941
struct btd_adapter *adapter = user_data;
1942
struct btd_device *device;
1943
GSList *services, *uuids, *l;
1944
char address[18];
1945
uint8_t bdaddr_type;
1946
1947
if (sscanf(key, "%17s#%hhu", address, &bdaddr_type) < 2)
1948
return;
1949
1950
if (g_slist_find_custom(adapter->devices,
1951
address, (GCompareFunc) device_address_cmp))
1952
return;
1953
1954
device = device_create(connection, adapter, address, bdaddr_type);
1955
if (!device)
1956
return;
1957
1958
device_set_temporary(device, FALSE);
1959
adapter->devices = g_slist_append(adapter->devices, device);
1960
1961
services = string_to_primary_list(value);
1962
if (services == NULL)
1963
return;
1964
1965
for (l = services, uuids = NULL; l; l = l->next) {
1966
struct gatt_primary *prim = l->data;
1967
uuids = g_slist_append(uuids, prim->uuid);
1968
}
1969
1970
device_register_services(connection, device, services, -1);
1971
1972
device_probe_drivers(device, uuids);
1973
1974
g_slist_free(uuids);
1975
}
1976
1977
static void smp_key_free(void *data)
1978
{
1979
struct smp_ltk_info *info = data;
1980
1981
g_free(info);
1982
}
1983
1984
static void load_devices(struct btd_adapter *adapter)
1985
{
1986
char filename[PATH_MAX + 1];
1987
char srcaddr[18];
1988
struct adapter_keys keys = { adapter, NULL };
1989
int err;
1990
1991
ba2str(&adapter->bdaddr, srcaddr);
1992
1993
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "profiles");
1994
textfile_foreach(filename, create_stored_device_from_profiles,
1995
adapter);
1996
1997
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "primaries");
1998
textfile_foreach(filename, create_stored_device_from_primaries,
1999
adapter);
2000
2001
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "linkkeys");
2002
textfile_foreach(filename, create_stored_device_from_linkkeys, &keys);
2003
2004
err = adapter_ops->load_keys(adapter->dev_id, keys.keys,
2005
main_opts.debug_keys);
2006
if (err < 0)
2007
error("Unable to load keys to adapter_ops: %s (%d)",
2008
strerror(-err), -err);
2009
2010
g_slist_free_full(keys.keys, g_free);
2011
keys.keys = NULL;
2012
2013
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "longtermkeys");
2014
textfile_foreach(filename, create_stored_device_from_ltks, &keys);
2015
2016
err = adapter_ops->load_ltks(adapter->dev_id, keys.keys);
2017
if (err < 0)
2018
error("Unable to load keys to adapter_ops: %s (%d)",
2019
strerror(-err), -err);
2020
g_slist_free_full(keys.keys, smp_key_free);
2021
keys.keys = NULL;
2022
2023
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "blocked");
2024
textfile_foreach(filename, create_stored_device_from_blocked, adapter);
2025
}
2026
2027
int btd_adapter_block_address(struct btd_adapter *adapter, bdaddr_t *bdaddr,
2028
uint8_t bdaddr_type)
2029
{
2030
return adapter_ops->block_device(adapter->dev_id, bdaddr, bdaddr_type);
2031
}
2032
2033
int btd_adapter_unblock_address(struct btd_adapter *adapter, bdaddr_t *bdaddr,
2034
uint8_t bdaddr_type)
2035
{
2036
return adapter_ops->unblock_device(adapter->dev_id, bdaddr,
2037
bdaddr_type);
2038
}
2039
2040
static void clear_blocked(struct btd_adapter *adapter)
2041
{
2042
int err;
2043
2044
err = adapter_ops->unblock_device(adapter->dev_id, BDADDR_ANY, 0);
2045
if (err < 0)
2046
error("Clearing blocked list failed: %s (%d)",
2047
strerror(-err), -err);
2048
}
2049
2050
static void probe_driver(struct btd_adapter *adapter, gpointer user_data)
2051
{
2052
struct btd_adapter_driver *driver = user_data;
2053
int err;
2054
2055
if (driver->probe == NULL)
2056
return;
2057
2058
err = driver->probe(adapter);
2059
if (err < 0) {
2060
error("%s: %s (%d)", driver->name, strerror(-err), -err);
2061
return;
2062
}
2063
2064
adapter->loaded_drivers = g_slist_prepend(adapter->loaded_drivers,
2065
driver);
2066
}
2067
2068
static void load_drivers(struct btd_adapter *adapter)
2069
{
2070
GSList *l;
2071
2072
for (l = adapter_drivers; l; l = l->next)
2073
probe_driver(adapter, l->data);
2074
}
2075
2076
static void load_connections(struct btd_adapter *adapter)
2077
{
2078
GSList *l, *conns;
2079
int err;
2080
2081
err = adapter_ops->get_conn_list(adapter->dev_id, &conns);
2082
if (err < 0) {
2083
error("Unable to fetch existing connections: %s (%d)",
2084
strerror(-err), -err);
2085
return;
2086
}
2087
2088
for (l = conns; l != NULL; l = g_slist_next(l)) {
2089
bdaddr_t *bdaddr = l->data;
2090
struct btd_device *device;
2091
char address[18];
2092
2093
ba2str(bdaddr, address);
2094
DBG("Adding existing connection to %s", address);
2095
2096
device = adapter_get_device(connection, adapter, address);
2097
if (device)
2098
adapter_add_connection(adapter, device);
2099
}
2100
2101
g_slist_free_full(conns, g_free);
2102
}
2103
2104
static int get_discoverable_timeout(const char *src)
2105
{
2106
int timeout;
2107
2108
if (read_discoverable_timeout(src, &timeout) == 0)
2109
return timeout;
2110
2111
return main_opts.discovto;
2112
}
2113
2114
static int get_pairable_timeout(const char *src)
2115
{
2116
int timeout;
2117
2118
if (read_pairable_timeout(src, &timeout) == 0)
2119
return timeout;
2120
2121
return main_opts.pairto;
2122
}
2123
2124
static void call_adapter_powered_callbacks(struct btd_adapter *adapter,
2125
gboolean powered)
2126
{
2127
GSList *l;
2128
2129
for (l = adapter->powered_callbacks; l; l = l->next) {
2130
btd_adapter_powered_cb cb = l->data;
2131
2132
cb(adapter, powered);
2133
}
2134
}
2135
2136
static void emit_device_disappeared(gpointer data, gpointer user_data)
2137
{
2138
struct remote_dev_info *dev = data;
2139
struct btd_adapter *adapter = user_data;
2140
char address[18];
2141
const char *paddr = address;
2142
2143
ba2str(&dev->bdaddr, address);
2144
2145
g_dbus_emit_signal(connection, adapter->path,
2146
ADAPTER_INTERFACE, "DeviceDisappeared",
2147
DBUS_TYPE_STRING, &paddr,
2148
DBUS_TYPE_INVALID);
2149
2150
adapter->found_devices = g_slist_remove(adapter->found_devices, dev);
2151
}
2152
2153
void btd_adapter_get_mode(struct btd_adapter *adapter, uint8_t *mode,
2154
uint8_t *on_mode,
2155
uint16_t *discoverable_timeout,
2156
gboolean *pairable)
2157
{
2158
char str[14], address[18];
2159
2160
ba2str(&adapter->bdaddr, address);
2161
2162
if (mode) {
2163
if (main_opts.remember_powered == FALSE)
2164
*mode = main_opts.mode;
2165
else if (read_device_mode(address, str, sizeof(str)) == 0)
2166
*mode = get_mode(&adapter->bdaddr, str);
2167
else
2168
*mode = main_opts.mode;
2169
}
2170
2171
if (on_mode)
2172
*on_mode = get_mode(&adapter->bdaddr, "on");
2173
2174
if (discoverable_timeout)
2175
*discoverable_timeout = get_discoverable_timeout(address);
2176
2177
if (pairable)
2178
*pairable = adapter->pairable;
2179
}
2180
2181
void btd_adapter_get_class(struct btd_adapter *adapter, uint8_t *major,
2182
uint8_t *minor)
2183
{
2184
uint8_t cls[3];
2185
2186
if (read_local_class(&adapter->bdaddr, cls) < 0) {
2187
uint32_t class = htobl(main_opts.class);
2188
memcpy(cls, &class, 3);
2189
}
2190
2191
*major = cls[1];
2192
*minor = cls[0];
2193
}
2194
2195
const char *btd_adapter_get_name(struct btd_adapter *adapter)
2196
{
2197
return adapter->name;
2198
}
2199
2200
void btd_adapter_start(struct btd_adapter *adapter)
2201
{
2202
char address[18];
2203
gboolean powered;
2204
2205
ba2str(&adapter->bdaddr, address);
2206
2207
adapter->dev_class = 0;
2208
adapter->off_requested = FALSE;
2209
adapter->up = TRUE;
2210
adapter->discov_timeout = get_discoverable_timeout(address);
2211
adapter->pairable_timeout = get_pairable_timeout(address);
2212
adapter->off_timer = 0;
2213
2214
if (adapter->scan_mode & SCAN_INQUIRY)
2215
adapter->mode = MODE_DISCOVERABLE;
2216
else
2217
adapter->mode = MODE_CONNECTABLE;
2218
2219
powered = TRUE;
2220
emit_property_changed(connection, adapter->path,
2221
ADAPTER_INTERFACE, "Powered",
2222
DBUS_TYPE_BOOLEAN, &powered);
2223
2224
call_adapter_powered_callbacks(adapter, TRUE);
2225
2226
adapter_ops->disable_cod_cache(adapter->dev_id);
2227
2228
info("Adapter %s has been enabled", adapter->path);
2229
}
2230
2231
static void reply_pending_requests(struct btd_adapter *adapter)
2232
{
2233
GSList *l;
2234
2235
if (!adapter)
2236
return;
2237
2238
/* pending bonding */
2239
for (l = adapter->devices; l; l = l->next) {
2240
struct btd_device *device = l->data;
2241
2242
if (device_is_bonding(device, NULL))
2243
device_cancel_bonding(device,
2244
HCI_OE_USER_ENDED_CONNECTION);
2245
}
2246
}
2247
2248
static void remove_driver(gpointer data, gpointer user_data)
2249
{
2250
struct btd_adapter_driver *driver = data;
2251
struct btd_adapter *adapter = user_data;
2252
2253
if (driver->remove)
2254
driver->remove(adapter);
2255
}
2256
2257
static void unload_drivers(struct btd_adapter *adapter)
2258
{
2259
g_slist_foreach(adapter->loaded_drivers, remove_driver, adapter);
2260
g_slist_free(adapter->loaded_drivers);
2261
adapter->loaded_drivers = NULL;
2262
}
2263
2264
static void set_mode_complete(struct btd_adapter *adapter)
2265
{
2266
struct session_req *pending;
2267
const char *modestr;
2268
int err;
2269
2270
DBG("");
2271
2272
if (adapter->mode == MODE_OFF) {
2273
g_slist_free_full(adapter->mode_sessions, session_free);
2274
adapter->mode_sessions = NULL;
2275
}
2276
2277
if (adapter->pending_mode == NULL)
2278
return;
2279
2280
pending = adapter->pending_mode;
2281
adapter->pending_mode = NULL;
2282
2283
err = (pending->mode != adapter->mode) ? -EINVAL : 0;
2284
2285
if (pending->msg != NULL) {
2286
DBusMessage *msg = pending->msg;
2287
DBusMessage *reply;
2288
2289
if (err < 0)
2290
reply = btd_error_failed(msg, strerror(-err));
2291
else {
2292
if (strcmp(dbus_message_get_member(msg),
2293
"SetProperty") == 0)
2294
adapter->global_mode = adapter->mode;
2295
reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
2296
}
2297
2298
g_dbus_send_message(connection, reply);
2299
}
2300
2301
modestr = mode2str(adapter->mode);
2302
2303
DBG("%s", modestr);
2304
2305
/* restore if the mode doesn't matches the pending */
2306
if (err != 0) {
2307
write_device_mode(&adapter->bdaddr, modestr);
2308
error("unable to set mode: %s", mode2str(pending->mode));
2309
}
2310
2311
session_unref(pending);
2312
}
2313
2314
int btd_adapter_stop(struct btd_adapter *adapter)
2315
{
2316
gboolean prop_false = FALSE;
2317
2318
/* check pending requests */
2319
reply_pending_requests(adapter);
2320
2321
adapter->up = FALSE;
2322
2323
stop_discovery(adapter);
2324
2325
if (adapter->disc_sessions) {
2326
g_slist_free_full(adapter->disc_sessions, session_free);
2327
adapter->disc_sessions = NULL;
2328
}
2329
2330
while (adapter->connections) {
2331
struct btd_device *device = adapter->connections->data;
2332
adapter_remove_connection(adapter, device);
2333
}
2334
2335
if (adapter->scan_mode == (SCAN_PAGE | SCAN_INQUIRY))
2336
emit_property_changed(connection, adapter->path,
2337
ADAPTER_INTERFACE, "Discoverable",
2338
DBUS_TYPE_BOOLEAN, &prop_false);
2339
2340
if ((adapter->scan_mode & SCAN_PAGE) && adapter->pairable == TRUE)
2341
emit_property_changed(connection, adapter->path,
2342
ADAPTER_INTERFACE, "Pairable",
2343
DBUS_TYPE_BOOLEAN, &prop_false);
2344
2345
if (adapter->discovering)
2346
emit_property_changed(connection, adapter->path,
2347
ADAPTER_INTERFACE, "Discovering",
2348
DBUS_TYPE_BOOLEAN, &prop_false);
2349
2350
emit_property_changed(connection, adapter->path, ADAPTER_INTERFACE,
2351
"Powered", DBUS_TYPE_BOOLEAN, &prop_false);
2352
2353
adapter->discovering = FALSE;
2354
adapter->scan_mode = SCAN_DISABLED;
2355
adapter->mode = MODE_OFF;
2356
adapter->off_requested = FALSE;
2357
2358
call_adapter_powered_callbacks(adapter, FALSE);
2359
2360
info("Adapter %s has been disabled", adapter->path);
2361
2362
set_mode_complete(adapter);
2363
2364
return 0;
2365
}
2366
2367
static void off_timer_remove(struct btd_adapter *adapter)
2368
{
2369
g_source_remove(adapter->off_timer);
2370
adapter->off_timer = 0;
2371
}
2372
2373
static void adapter_free(gpointer user_data)
2374
{
2375
struct btd_adapter *adapter = user_data;
2376
2377
agent_free(adapter->agent);
2378
adapter->agent = NULL;
2379
2380
DBG("%p", adapter);
2381
2382
if (adapter->auth_idle_id)
2383
g_source_remove(adapter->auth_idle_id);
2384
2385
if (adapter->off_timer)
2386
off_timer_remove(adapter);
2387
2388
sdp_list_free(adapter->services, NULL);
2389
2390
g_slist_free_full(adapter->found_devices, dev_info_free);
2391
2392
g_slist_free(adapter->oor_devices);
2393
2394
g_free(adapter->path);
2395
g_free(adapter->name);
2396
g_free(adapter);
2397
}
2398
2399
struct btd_adapter *btd_adapter_ref(struct btd_adapter *adapter)
2400
{
2401
adapter->ref++;
2402
2403
DBG("%p: ref=%d", adapter, adapter->ref);
2404
2405
return adapter;
2406
}
2407
2408
void btd_adapter_unref(struct btd_adapter *adapter)
2409
{
2410
gchar *path;
2411
2412
adapter->ref--;
2413
2414
DBG("%p: ref=%d", adapter, adapter->ref);
2415
2416
if (adapter->ref > 0)
2417
return;
2418
2419
path = g_strdup(adapter->path);
2420
2421
g_dbus_unregister_interface(connection, path, ADAPTER_INTERFACE);
2422
2423
g_free(path);
2424
}
2425
2426
gboolean adapter_init(struct btd_adapter *adapter, gboolean up)
2427
{
2428
adapter->up = up;
2429
2430
adapter->allow_name_changes = TRUE;
2431
2432
adapter_ops->read_bdaddr(adapter->dev_id, &adapter->bdaddr);
2433
2434
if (bacmp(&adapter->bdaddr, BDADDR_ANY) == 0) {
2435
error("No address available for hci%d", adapter->dev_id);
2436
return FALSE;
2437
}
2438
2439
sdp_init_services_list(&adapter->bdaddr);
2440
2441
if (main_opts.gatt_enabled)
2442
btd_adapter_gatt_server_start(adapter);
2443
2444
load_drivers(adapter);
2445
clear_blocked(adapter);
2446
load_devices(adapter);
2447
2448
/* Set pairable mode */
2449
if (read_device_pairable(&adapter->bdaddr, &adapter->pairable) < 0)
2450
adapter->pairable = TRUE;
2451
2452
/* retrieve the active connections: address the scenario where
2453
* the are active connections before the daemon've started */
2454
load_connections(adapter);
2455
2456
adapter->initialized = TRUE;
2457
2458
return TRUE;
2459
}
2460
2461
struct btd_adapter *adapter_create(DBusConnection *conn, int id)
2462
{
2463
char path[MAX_PATH_LENGTH];
2464
struct btd_adapter *adapter;
2465
const char *base_path = manager_get_base_path();
2466
2467
if (!connection)
2468
connection = conn;
2469
2470
adapter = g_try_new0(struct btd_adapter, 1);
2471
if (!adapter) {
2472
error("adapter_create: failed to alloc memory for hci%d", id);
2473
return NULL;
2474
}
2475
2476
adapter->dev_id = id;
2477
2478
snprintf(path, sizeof(path), "%s/hci%d", base_path, id);
2479
adapter->path = g_strdup(path);
2480
2481
if (!g_dbus_register_interface(conn, path, ADAPTER_INTERFACE,
2482
adapter_methods, adapter_signals, NULL,
2483
adapter, adapter_free)) {
2484
error("Adapter interface init failed on path %s", path);
2485
adapter_free(adapter);
2486
return NULL;
2487
}
2488
2489
return btd_adapter_ref(adapter);
2490
}
2491
2492
void adapter_remove(struct btd_adapter *adapter)
2493
{
2494
GSList *l;
2495
2496
DBG("Removing adapter %s", adapter->path);
2497
2498
for (l = adapter->devices; l; l = l->next)
2499
device_remove(l->data, FALSE);
2500
g_slist_free(adapter->devices);
2501
2502
unload_drivers(adapter);
2503
if (main_opts.gatt_enabled)
2504
btd_adapter_gatt_server_stop(adapter);
2505
2506
g_slist_free(adapter->pin_callbacks);
2507
2508
/* Return adapter to down state if it was not up on init */
2509
adapter_ops->restore_powered(adapter->dev_id);
2510
}
2511
2512
uint16_t adapter_get_dev_id(struct btd_adapter *adapter)
2513
{
2514
return adapter->dev_id;
2515
}
2516
2517
const gchar *adapter_get_path(struct btd_adapter *adapter)
2518
{
2519
if (!adapter)
2520
return NULL;
2521
2522
return adapter->path;
2523
}
2524
2525
void adapter_get_address(struct btd_adapter *adapter, bdaddr_t *bdaddr)
2526
{
2527
bacpy(bdaddr, &adapter->bdaddr);
2528
}
2529
2530
void adapter_set_allow_name_changes(struct btd_adapter *adapter,
2531
gboolean allow_name_changes)
2532
{
2533
adapter->allow_name_changes = allow_name_changes;
2534
}
2535
2536
void adapter_set_discovering(struct btd_adapter *adapter,
2537
gboolean discovering)
2538
{
2539
const char *path = adapter->path;
2540
2541
adapter->discovering = discovering;
2542
2543
emit_property_changed(connection, path,
2544
ADAPTER_INTERFACE, "Discovering",
2545
DBUS_TYPE_BOOLEAN, &discovering);
2546
2547
if (discovering)
2548
return;
2549
2550
g_slist_foreach(adapter->oor_devices, emit_device_disappeared, adapter);
2551
g_slist_free_full(adapter->oor_devices, dev_info_free);
2552
adapter->oor_devices = g_slist_copy(adapter->found_devices);
2553
2554
if (!adapter_has_discov_sessions(adapter) || adapter->discov_suspended)
2555
return;
2556
2557
DBG("hci%u restarting discovery, disc_sessions %u", adapter->dev_id,
2558
g_slist_length(adapter->disc_sessions));
2559
2560
adapter->discov_id = g_idle_add(discovery_cb, adapter);
2561
}
2562
2563
static void suspend_discovery(struct btd_adapter *adapter)
2564
{
2565
if (adapter->disc_sessions == NULL || adapter->discov_suspended)
2566
return;
2567
2568
DBG("Suspending discovery");
2569
2570
if (adapter->oor_devices) {
2571
g_slist_free(adapter->oor_devices);
2572
adapter->oor_devices = NULL;
2573
}
2574
2575
adapter->discov_suspended = TRUE;
2576
2577
if (adapter->discov_id > 0) {
2578
g_source_remove(adapter->discov_id);
2579
adapter->discov_id = 0;
2580
} else
2581
adapter_ops->stop_discovery(adapter->dev_id);
2582
}
2583
2584
static int found_device_cmp(gconstpointer a, gconstpointer b)
2585
{
2586
const struct remote_dev_info *d = a;
2587
const bdaddr_t *bdaddr = b;
2588
2589
if (bacmp(bdaddr, BDADDR_ANY) == 0)
2590
return 0;
2591
2592
return bacmp(&d->bdaddr, bdaddr);
2593
}
2594
2595
struct remote_dev_info *adapter_search_found_devices(struct btd_adapter *adapter,
2596
bdaddr_t *bdaddr)
2597
{
2598
GSList *l;
2599
2600
l = g_slist_find_custom(adapter->found_devices, bdaddr,
2601
found_device_cmp);
2602
if (l)
2603
return l->data;
2604
2605
return NULL;
2606
}
2607
2608
static int dev_rssi_cmp(struct remote_dev_info *d1, struct remote_dev_info *d2)
2609
{
2610
int rssi1, rssi2;
2611
2612
rssi1 = d1->rssi < 0 ? -d1->rssi : d1->rssi;
2613
rssi2 = d2->rssi < 0 ? -d2->rssi : d2->rssi;
2614
2615
return rssi1 - rssi2;
2616
}
2617
2618
static void append_dict_valist(DBusMessageIter *iter,
2619
const char *first_key,
2620
va_list var_args)
2621
{
2622
DBusMessageIter dict;
2623
const char *key;
2624
int type;
2625
int n_elements;
2626
void *val;
2627
2628
dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
2629
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2630
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
2631
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
2632
2633
key = first_key;
2634
while (key) {
2635
type = va_arg(var_args, int);
2636
val = va_arg(var_args, void *);
2637
if (type == DBUS_TYPE_ARRAY) {
2638
n_elements = va_arg(var_args, int);
2639
if (n_elements > 0)
2640
dict_append_array(&dict, key, DBUS_TYPE_STRING,
2641
val, n_elements);
2642
} else
2643
dict_append_entry(&dict, key, type, val);
2644
key = va_arg(var_args, char *);
2645
}
2646
2647
dbus_message_iter_close_container(iter, &dict);
2648
}
2649
2650
static void emit_device_found(const char *path, const char *address,
2651
const char *first_key, ...)
2652
{
2653
DBusMessage *signal;
2654
DBusMessageIter iter;
2655
va_list var_args;
2656
2657
signal = dbus_message_new_signal(path, ADAPTER_INTERFACE,
2658
"DeviceFound");
2659
if (!signal) {
2660
error("Unable to allocate new %s.DeviceFound signal",
2661
ADAPTER_INTERFACE);
2662
return;
2663
}
2664
dbus_message_iter_init_append(signal, &iter);
2665
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &address);
2666
2667
va_start(var_args, first_key);
2668
append_dict_valist(&iter, first_key, var_args);
2669
va_end(var_args);
2670
2671
g_dbus_send_message(connection, signal);
2672
}
2673
2674
static char **strlist2array(GSList *list)
2675
{
2676
unsigned int i, n;
2677
char **array;
2678
2679
if (list == NULL)
2680
return NULL;
2681
2682
n = g_slist_length(list);
2683
array = g_new0(char *, n + 1);
2684
2685
for (i = 0; list; list = list->next, i++)
2686
array[i] = g_strdup((const gchar *) list->data);
2687
2688
return array;
2689
}
2690
2691
void adapter_emit_device_found(struct btd_adapter *adapter,
2692
struct remote_dev_info *dev)
2693
{
2694
struct btd_device *device;
2695
char peer_addr[18], local_addr[18];
2696
const char *icon, *paddr = peer_addr;
2697
dbus_bool_t paired = FALSE, trusted = FALSE;
2698
dbus_int16_t rssi = dev->rssi;
2699
char *alias;
2700
size_t uuid_count;
2701
2702
ba2str(&dev->bdaddr, peer_addr);
2703
ba2str(&adapter->bdaddr, local_addr);
2704
2705
device = adapter_find_device(adapter, paddr);
2706
if (device) {
2707
paired = device_is_paired(device);
2708
trusted = device_is_trusted(device);
2709
}
2710
2711
/* The uuids string array is updated only if necessary */
2712
uuid_count = g_slist_length(dev->services);
2713
if (dev->services && dev->uuid_count != uuid_count) {
2714
g_strfreev(dev->uuids);
2715
dev->uuids = strlist2array(dev->services);
2716
dev->uuid_count = uuid_count;
2717
}
2718
2719
if (!dev->alias) {
2720
if (!dev->name) {
2721
alias = g_strdup(peer_addr);
2722
g_strdelimit(alias, ":", '-');
2723
} else
2724
alias = g_strdup(dev->name);
2725
} else
2726
alias = g_strdup(dev->alias);
2727
2728
if (dev->bdaddr_type != BDADDR_BREDR) {
2729
gboolean broadcaster;
2730
uint16_t app;
2731
2732
if (dev->flags & (EIR_LIM_DISC | EIR_GEN_DISC))
2733
broadcaster = FALSE;
2734
else
2735
broadcaster = TRUE;
2736
2737
dev->legacy = FALSE;
2738
2739
if (read_remote_appearance(&adapter->bdaddr, &dev->bdaddr,
2740
dev->bdaddr_type, &app) == 0)
2741
icon = gap_appearance_to_icon(app);
2742
else
2743
icon = NULL;
2744
2745
emit_device_found(adapter->path, paddr,
2746
"Address", DBUS_TYPE_STRING, &paddr,
2747
"Class", DBUS_TYPE_UINT32, &dev->class,
2748
"Icon", DBUS_TYPE_STRING, &icon,
2749
"RSSI", DBUS_TYPE_INT16, &rssi,
2750
"Name", DBUS_TYPE_STRING, &dev->name,
2751
"Alias", DBUS_TYPE_STRING, &alias,
2752
"LegacyPairing", DBUS_TYPE_BOOLEAN, &dev->legacy,
2753
"Paired", DBUS_TYPE_BOOLEAN, &paired,
2754
"Broadcaster", DBUS_TYPE_BOOLEAN, &broadcaster,
2755
"UUIDs", DBUS_TYPE_ARRAY, &dev->uuids, uuid_count,
2756
NULL);
2757
} else {
2758
icon = class_to_icon(dev->class);
2759
2760
emit_device_found(adapter->path, paddr,
2761
"Address", DBUS_TYPE_STRING, &paddr,
2762
"Class", DBUS_TYPE_UINT32, &dev->class,
2763
"Icon", DBUS_TYPE_STRING, &icon,
2764
"RSSI", DBUS_TYPE_INT16, &rssi,
2765
"Name", DBUS_TYPE_STRING, &dev->name,
2766
"Alias", DBUS_TYPE_STRING, &alias,
2767
"LegacyPairing", DBUS_TYPE_BOOLEAN, &dev->legacy,
2768
"Paired", DBUS_TYPE_BOOLEAN, &paired,
2769
"Trusted", DBUS_TYPE_BOOLEAN, &trusted,
2770
"UUIDs", DBUS_TYPE_ARRAY, &dev->uuids, uuid_count,
2771
NULL);
2772
}
2773
2774
g_free(alias);
2775
}
2776
2777
static struct remote_dev_info *found_device_new(const bdaddr_t *bdaddr,
2778
uint8_t bdaddr_type, const char *name,
2779
const char *alias, uint32_t class,
2780
gboolean legacy, int flags)
2781
{
2782
struct remote_dev_info *dev;
2783
2784
dev = g_new0(struct remote_dev_info, 1);
2785
bacpy(&dev->bdaddr, bdaddr);
2786
dev->bdaddr_type = bdaddr_type;
2787
dev->name = g_strdup(name);
2788
dev->alias = g_strdup(alias);
2789
dev->class = class;
2790
dev->legacy = legacy;
2791
if (flags >= 0)
2792
dev->flags = flags;
2793
2794
return dev;
2795
}
2796
2797
static void remove_same_uuid(gpointer data, gpointer user_data)
2798
{
2799
struct remote_dev_info *dev = user_data;
2800
GSList *l;
2801
2802
for (l = dev->services; l; l = l->next) {
2803
char *current_uuid = l->data;
2804
char *new_uuid = data;
2805
2806
if (strcmp(current_uuid, new_uuid) == 0) {
2807
g_free(current_uuid);
2808
dev->services = g_slist_delete_link(dev->services, l);
2809
break;
2810
}
2811
}
2812
}
2813
2814
static void dev_prepend_uuid(gpointer data, gpointer user_data)
2815
{
2816
struct remote_dev_info *dev = user_data;
2817
char *new_uuid = data;
2818
2819
dev->services = g_slist_prepend(dev->services, g_strdup(new_uuid));
2820
}
2821
2822
static gboolean pairing_is_legacy(bdaddr_t *local, bdaddr_t *peer,
2823
const uint8_t *eir, const char *name)
2824
{
2825
unsigned char features[8];
2826
2827
if (eir)
2828
return FALSE;
2829
2830
if (name == NULL)
2831
return TRUE;
2832
2833
if (read_remote_features(local, peer, NULL, features) < 0)
2834
return TRUE;
2835
2836
if (features[0] & 0x01)
2837
return FALSE;
2838
else
2839
return TRUE;
2840
}
2841
2842
static char *read_stored_data(bdaddr_t *local, bdaddr_t *peer, const char *file)
2843
{
2844
char local_addr[18], peer_addr[18], filename[PATH_MAX + 1];
2845
2846
ba2str(local, local_addr);
2847
ba2str(peer, peer_addr);
2848
2849
create_name(filename, PATH_MAX, STORAGEDIR, local_addr, file);
2850
2851
return textfile_get(filename, peer_addr);
2852
}
2853
2854
void adapter_update_found_devices(struct btd_adapter *adapter,
2855
bdaddr_t *bdaddr, uint8_t bdaddr_type,
2856
int8_t rssi, uint8_t confirm_name,
2857
uint8_t *data, uint8_t data_len)
2858
{
2859
struct remote_dev_info *dev;
2860
struct eir_data eir_data;
2861
char *alias, *name;
2862
gboolean legacy, name_known;
2863
uint32_t dev_class;
2864
int err;
2865
2866
memset(&eir_data, 0, sizeof(eir_data));
2867
err = eir_parse(&eir_data, data, data_len);
2868
if (err < 0) {
2869
error("Error parsing EIR data: %s (%d)", strerror(-err), -err);
2870
return;
2871
}
2872
2873
dev_class = eir_data.dev_class[0] | (eir_data.dev_class[1] << 8) |
2874
(eir_data.dev_class[2] << 16);
2875
if (dev_class != 0)
2876
write_remote_class(&adapter->bdaddr, bdaddr, dev_class);
2877
2878
if (eir_data.appearance != 0)
2879
write_remote_appearance(&adapter->bdaddr, bdaddr, bdaddr_type,
2880
eir_data.appearance);
2881
2882
if (eir_data.name != NULL && eir_data.name_complete)
2883
write_device_name(&adapter->bdaddr, bdaddr, eir_data.name);
2884
2885
dev = adapter_search_found_devices(adapter, bdaddr);
2886
if (dev) {
2887
adapter->oor_devices = g_slist_remove(adapter->oor_devices,
2888
dev);
2889
2890
/* If an existing device had no name but the newly received EIR
2891
* data has (complete or not), we want to present it to the
2892
* user. */
2893
if (dev->name == NULL && eir_data.name != NULL) {
2894
dev->name = g_strdup(eir_data.name);
2895
goto done;
2896
}
2897
2898
if (dev->rssi != rssi)
2899
goto done;
2900
2901
eir_data_free(&eir_data);
2902
2903
return;
2904
}
2905
2906
/* New device in the discovery session */
2907
2908
name = read_stored_data(&adapter->bdaddr, bdaddr, "names");
2909
2910
if (bdaddr_type == BDADDR_BREDR) {
2911
legacy = pairing_is_legacy(&adapter->bdaddr, bdaddr, data,
2912
name);
2913
2914
if (!name && main_opts.name_resolv &&
2915
adapter_has_discov_sessions(adapter))
2916
name_known = FALSE;
2917
else
2918
name_known = TRUE;
2919
} else {
2920
legacy = FALSE;
2921
name_known = TRUE;
2922
}
2923
2924
if (confirm_name)
2925
adapter_ops->confirm_name(adapter->dev_id, bdaddr, bdaddr_type,
2926
name_known);
2927
2928
alias = read_stored_data(&adapter->bdaddr, bdaddr, "aliases");
2929
2930
dev = found_device_new(bdaddr, bdaddr_type, name, alias, dev_class,
2931
legacy, eir_data.flags);
2932
free(name);
2933
free(alias);
2934
2935
adapter->found_devices = g_slist_prepend(adapter->found_devices, dev);
2936
2937
done:
2938
dev->rssi = rssi;
2939
2940
adapter->found_devices = g_slist_sort(adapter->found_devices,
2941
(GCompareFunc) dev_rssi_cmp);
2942
2943
g_slist_foreach(eir_data.services, remove_same_uuid, dev);
2944
g_slist_foreach(eir_data.services, dev_prepend_uuid, dev);
2945
2946
adapter_emit_device_found(adapter, dev);
2947
2948
eir_data_free(&eir_data);
2949
}
2950
2951
void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
2952
{
2953
const gchar *path = adapter_get_path(adapter);
2954
gboolean discoverable, pairable;
2955
2956
DBG("old 0x%02x new 0x%02x", adapter->scan_mode, scan_mode);
2957
2958
if (adapter->scan_mode == scan_mode)
2959
return;
2960
2961
switch (scan_mode) {
2962
case SCAN_DISABLED:
2963
adapter->mode = MODE_OFF;
2964
discoverable = FALSE;
2965
pairable = FALSE;
2966
break;
2967
case SCAN_PAGE:
2968
adapter->mode = MODE_CONNECTABLE;
2969
discoverable = FALSE;
2970
pairable = adapter->pairable;
2971
break;
2972
case (SCAN_PAGE | SCAN_INQUIRY):
2973
adapter->mode = MODE_DISCOVERABLE;
2974
discoverable = TRUE;
2975
pairable = adapter->pairable;
2976
break;
2977
default:
2978
/* ignore, reserved */
2979
return;
2980
}
2981
2982
/* If page scanning gets toggled emit the Pairable property */
2983
if ((adapter->scan_mode & SCAN_PAGE) != (scan_mode & SCAN_PAGE))
2984
emit_property_changed(connection, adapter->path,
2985
ADAPTER_INTERFACE, "Pairable",
2986
DBUS_TYPE_BOOLEAN, &pairable);
2987
2988
emit_property_changed(connection, path,
2989
ADAPTER_INTERFACE, "Discoverable",
2990
DBUS_TYPE_BOOLEAN, &discoverable);
2991
2992
adapter->scan_mode = scan_mode;
2993
2994
set_mode_complete(adapter);
2995
}
2996
2997
struct agent *adapter_get_agent(struct btd_adapter *adapter)
2998
{
2999
if (!adapter)
3000
return NULL;
3001
3002
return adapter->agent;
3003
}
3004
3005
void adapter_add_connection(struct btd_adapter *adapter,
3006
struct btd_device *device)
3007
{
3008
if (g_slist_find(adapter->connections, device)) {
3009
error("Device is already marked as connected");
3010
return;
3011
}
3012
3013
device_add_connection(device, connection);
3014
3015
adapter->connections = g_slist_append(adapter->connections, device);
3016
}
3017
3018
void adapter_remove_connection(struct btd_adapter *adapter,
3019
struct btd_device *device)
3020
{
3021
DBG("");
3022
3023
if (!g_slist_find(adapter->connections, device)) {
3024
error("No matching connection for device");
3025
return;
3026
}
3027
3028
device_remove_connection(device, connection);
3029
3030
adapter->connections = g_slist_remove(adapter->connections, device);
3031
3032
if (device_is_authenticating(device))
3033
device_cancel_authentication(device, TRUE);
3034
3035
if (device_is_temporary(device)) {
3036
const char *path = device_get_path(device);
3037
3038
DBG("Removing temporary device %s", path);
3039
adapter_remove_device(connection, adapter, device, TRUE);
3040
}
3041
}
3042
3043
gboolean adapter_has_discov_sessions(struct btd_adapter *adapter)
3044
{
3045
if (!adapter || !adapter->disc_sessions)
3046
return FALSE;
3047
3048
return TRUE;
3049
}
3050
3051
int btd_register_adapter_driver(struct btd_adapter_driver *driver)
3052
{
3053
adapter_drivers = g_slist_append(adapter_drivers, driver);
3054
3055
if (driver->probe == NULL)
3056
return 0;
3057
3058
manager_foreach_adapter(probe_driver, driver);
3059
3060
return 0;
3061
}
3062
3063
static void unload_driver(struct btd_adapter *adapter, gpointer data)
3064
{
3065
adapter->loaded_drivers = g_slist_remove(adapter->loaded_drivers, data);
3066
}
3067
3068
void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
3069
{
3070
adapter_drivers = g_slist_remove(adapter_drivers, driver);
3071
3072
manager_foreach_adapter(unload_driver, driver);
3073
}
3074
3075
static void agent_auth_cb(struct agent *agent, DBusError *derr,
3076
void *user_data)
3077
{
3078
struct service_auth *auth = user_data;
3079
3080
device_set_authorizing(auth->device, FALSE);
3081
3082
auth->cb(derr, auth->user_data);
3083
}
3084
3085
static gboolean auth_idle_cb(gpointer user_data)
3086
{
3087
struct service_auth *auth = user_data;
3088
struct btd_adapter *adapter = auth->adapter;
3089
3090
adapter->auth_idle_id = 0;
3091
3092
auth->cb(NULL, auth->user_data);
3093
3094
return FALSE;
3095
}
3096
3097
static int adapter_authorize(struct btd_adapter *adapter, const bdaddr_t *dst,
3098
const char *uuid, service_auth_cb cb,
3099
void *user_data)
3100
{
3101
struct service_auth *auth;
3102
struct btd_device *device;
3103
struct agent *agent;
3104
char address[18];
3105
const gchar *dev_path;
3106
int err;
3107
3108
ba2str(dst, address);
3109
device = adapter_find_device(adapter, address);
3110
if (!device)
3111
return -EPERM;
3112
3113
/* Device connected? */
3114
if (!g_slist_find(adapter->connections, device))
3115
error("Authorization request for non-connected device!?");
3116
3117
if (adapter->auth_idle_id)
3118
return -EBUSY;
3119
3120
auth = g_try_new0(struct service_auth, 1);
3121
if (!auth)
3122
return -ENOMEM;
3123
3124
auth->cb = cb;
3125
auth->user_data = user_data;
3126
auth->device = device;
3127
auth->adapter = adapter;
3128
3129
if (device_is_trusted(device) == TRUE) {
3130
adapter->auth_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
3131
auth_idle_cb, auth,
3132
g_free);
3133
return 0;
3134
}
3135
3136
agent = device_get_agent(device);
3137
if (!agent) {
3138
warn("Can't find device agent");
3139
g_free(auth);
3140
return -EPERM;
3141
}
3142
3143
dev_path = device_get_path(device);
3144
3145
err = agent_authorize(agent, dev_path, uuid, agent_auth_cb, auth, g_free);
3146
if (err < 0)
3147
g_free(auth);
3148
else
3149
device_set_authorizing(device, TRUE);
3150
3151
return err;
3152
}
3153
3154
int btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
3155
const char *uuid, service_auth_cb cb,
3156
void *user_data)
3157
{
3158
struct btd_adapter *adapter;
3159
GSList *l;
3160
3161
if (bacmp(src, BDADDR_ANY) != 0) {
3162
adapter = manager_find_adapter(src);
3163
if (!adapter)
3164
return -EPERM;
3165
3166
return adapter_authorize(adapter, dst, uuid, cb, user_data);
3167
}
3168
3169
for (l = manager_get_adapters(); l != NULL; l = g_slist_next(l)) {
3170
int err;
3171
3172
adapter = l->data;
3173
3174
err = adapter_authorize(adapter, dst, uuid, cb, user_data);
3175
if (err == 0)
3176
return 0;
3177
}
3178
3179
return -EPERM;
3180
}
3181
3182
int btd_cancel_authorization(const bdaddr_t *src, const bdaddr_t *dst)
3183
{
3184
struct btd_adapter *adapter = manager_find_adapter(src);
3185
struct btd_device *device;
3186
struct agent *agent;
3187
char address[18];
3188
int err;
3189
3190
if (!adapter)
3191
return -EPERM;
3192
3193
ba2str(dst, address);
3194
device = adapter_find_device(adapter, address);
3195
if (!device)
3196
return -EPERM;
3197
3198
if (adapter->auth_idle_id) {
3199
g_source_remove(adapter->auth_idle_id);
3200
adapter->auth_idle_id = 0;
3201
return 0;
3202
}
3203
3204
/*
3205
* FIXME: Cancel fails if authorization is requested to adapter's
3206
* agent and in the meanwhile CreatePairedDevice is called.
3207
*/
3208
3209
agent = device_get_agent(device);
3210
if (!agent)
3211
return -EPERM;
3212
3213
err = agent_cancel(agent);
3214
3215
if (err == 0)
3216
device_set_authorizing(device, FALSE);
3217
3218
return err;
3219
}
3220
3221
static gchar *adapter_any_path = NULL;
3222
static int adapter_any_refcount = 0;
3223
3224
const char *adapter_any_get_path(void)
3225
{
3226
return adapter_any_path;
3227
}
3228
3229
const char *btd_adapter_any_request_path(void)
3230
{
3231
if (adapter_any_refcount++ > 0)
3232
return adapter_any_path;
3233
3234
adapter_any_path = g_strdup_printf("%s/any", manager_get_base_path());
3235
3236
return adapter_any_path;
3237
}
3238
3239
void btd_adapter_any_release_path(void)
3240
{
3241
adapter_any_refcount--;
3242
3243
if (adapter_any_refcount > 0)
3244
return;
3245
3246
g_free(adapter_any_path);
3247
adapter_any_path = NULL;
3248
}
3249
3250
gboolean adapter_powering_down(struct btd_adapter *adapter)
3251
{
3252
return adapter->off_requested;
3253
}
3254
3255
int btd_adapter_restore_powered(struct btd_adapter *adapter)
3256
{
3257
char mode[14], address[18];
3258
3259
if (!adapter_ops)
3260
return -EINVAL;
3261
3262
if (!main_opts.remember_powered)
3263
return -EINVAL;
3264
3265
if (adapter->up)
3266
return 0;
3267
3268
ba2str(&adapter->bdaddr, address);
3269
if (read_device_mode(address, mode, sizeof(mode)) == 0 &&
3270
g_str_equal(mode, "off"))
3271
return 0;
3272
3273
return adapter_ops->set_powered(adapter->dev_id, TRUE);
3274
}
3275
3276
static gboolean switch_off_timeout(gpointer user_data)
3277
{
3278
struct btd_adapter *adapter = user_data;
3279
3280
adapter_ops->set_powered(adapter->dev_id, FALSE);
3281
adapter->off_timer = 0;
3282
3283
return FALSE;
3284
}
3285
3286
int btd_adapter_switch_online(struct btd_adapter *adapter)
3287
{
3288
if (!adapter_ops)
3289
return -EINVAL;
3290
3291
if (adapter->up)
3292
return -EALREADY;
3293
3294
if (adapter->off_timer)
3295
off_timer_remove(adapter);
3296
3297
return adapter_ops->set_powered(adapter->dev_id, TRUE);
3298
}
3299
3300
int btd_adapter_switch_offline(struct btd_adapter *adapter)
3301
{
3302
if (!adapter_ops)
3303
return -EINVAL;
3304
3305
if (!adapter->up)
3306
return -EALREADY;
3307
3308
if (adapter->off_timer)
3309
return 0;
3310
3311
adapter->global_mode = MODE_OFF;
3312
3313
if (adapter->connections == NULL)
3314
return adapter_ops->set_powered(adapter->dev_id, FALSE);
3315
3316
g_slist_foreach(adapter->connections,
3317
(GFunc) device_request_disconnect, NULL);
3318
3319
adapter->off_timer = g_timeout_add_seconds(OFF_TIMER,
3320
switch_off_timeout, adapter);
3321
3322
return 0;
3323
}
3324
3325
static gboolean disable_auto(gpointer user_data)
3326
{
3327
struct btd_adapter *adapter = user_data;
3328
GSList *l;
3329
3330
for (l = adapter->devices; l; l = l->next) {
3331
struct btd_device *device = l->data;
3332
3333
device_set_auto_connect(device, FALSE);
3334
}
3335
3336
adapter->auto_timeout_id = 0;
3337
3338
return FALSE;
3339
}
3340
3341
static void set_auto_connect(gpointer data, gpointer user_data)
3342
{
3343
struct btd_device *device = data;
3344
3345
device_set_auto_connect(device, TRUE);
3346
}
3347
3348
void btd_adapter_enable_auto_connect(struct btd_adapter *adapter)
3349
{
3350
if (!adapter->up)
3351
return;
3352
3353
DBG("Enabling automatic connections");
3354
3355
if (adapter->auto_timeout_id)
3356
return;
3357
3358
g_slist_foreach(adapter->devices, set_auto_connect, NULL);
3359
3360
adapter->auto_timeout_id = g_timeout_add_seconds(main_opts.autoto,
3361
disable_auto, adapter);
3362
}
3363
3364
void btd_adapter_register_pin_cb(struct btd_adapter *adapter,
3365
btd_adapter_pin_cb_t cb)
3366
{
3367
adapter->pin_callbacks = g_slist_prepend(adapter->pin_callbacks, cb);
3368
}
3369
3370
void btd_adapter_unregister_pin_cb(struct btd_adapter *adapter,
3371
btd_adapter_pin_cb_t cb)
3372
{
3373
adapter->pin_callbacks = g_slist_remove(adapter->pin_callbacks, cb);
3374
}
3375
3376
ssize_t btd_adapter_get_pin(struct btd_adapter *adapter, struct btd_device *dev,
3377
char *pin_buf, gboolean *display)
3378
{
3379
GSList *l;
3380
btd_adapter_pin_cb_t cb;
3381
bdaddr_t sba, dba;
3382
ssize_t ret;
3383
3384
for (l = adapter->pin_callbacks; l != NULL; l = g_slist_next(l)) {
3385
cb = l->data;
3386
ret = cb(adapter, dev, pin_buf, display);
3387
if (ret > 0)
3388
return ret;
3389
}
3390
3391
adapter_get_address(adapter, &sba);
3392
device_get_address(dev, &dba, NULL);
3393
3394
return read_pin_code(&sba, &dba, pin_buf);
3395
}
3396
3397
int btd_register_adapter_ops(struct btd_adapter_ops *ops, gboolean priority)
3398
{
3399
if (ops->setup == NULL)
3400
return -EINVAL;
3401
3402
if (priority)
3403
ops_candidates = g_slist_prepend(ops_candidates, ops);
3404
else
3405
ops_candidates = g_slist_append(ops_candidates, ops);
3406
3407
return 0;
3408
}
3409
3410
void btd_adapter_cleanup_ops(struct btd_adapter_ops *ops)
3411
{
3412
ops_candidates = g_slist_remove(ops_candidates, ops);
3413
ops->cleanup();
3414
3415
if (adapter_ops == ops)
3416
adapter_ops = NULL;
3417
}
3418
3419
int adapter_ops_setup(void)
3420
{
3421
GSList *l;
3422
int ret;
3423
3424
if (!ops_candidates)
3425
return -EINVAL;
3426
3427
for (l = ops_candidates; l != NULL; l = g_slist_next(l)) {
3428
struct btd_adapter_ops *ops = l->data;
3429
3430
ret = ops->setup();
3431
if (ret < 0)
3432
continue;
3433
3434
adapter_ops = ops;
3435
break;
3436
}
3437
3438
return ret;
3439
}
3440
3441
void btd_adapter_register_powered_callback(struct btd_adapter *adapter,
3442
btd_adapter_powered_cb cb)
3443
{
3444
adapter->powered_callbacks =
3445
g_slist_append(adapter->powered_callbacks, cb);
3446
}
3447
3448
void btd_adapter_unregister_powered_callback(struct btd_adapter *adapter,
3449
btd_adapter_powered_cb cb)
3450
{
3451
adapter->powered_callbacks =
3452
g_slist_remove(adapter->powered_callbacks, cb);
3453
}
3454
3455
int btd_adapter_set_fast_connectable(struct btd_adapter *adapter,
3456
gboolean enable)
3457
{
3458
if (!adapter_ops)
3459
return -EINVAL;
3460
3461
if (!adapter->up)
3462
return -EINVAL;
3463
3464
return adapter_ops->set_fast_connectable(adapter->dev_id, enable);
3465
}
3466
3467
int btd_adapter_read_clock(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3468
int which, int timeout, uint32_t *clock,
3469
uint16_t *accuracy)
3470
{
3471
if (!adapter_ops)
3472
return -EINVAL;
3473
3474
if (!adapter->up)
3475
return -EINVAL;
3476
3477
return adapter_ops->read_clock(adapter->dev_id, bdaddr, which,
3478
timeout, clock, accuracy);
3479
}
3480
3481
int btd_adapter_disconnect_device(struct btd_adapter *adapter,
3482
bdaddr_t *bdaddr, uint8_t bdaddr_type)
3483
3484
{
3485
return adapter_ops->disconnect(adapter->dev_id, bdaddr, bdaddr_type);
3486
}
3487
3488
int btd_adapter_remove_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3489
uint8_t bdaddr_type)
3490
{
3491
return adapter_ops->remove_bonding(adapter->dev_id, bdaddr,
3492
bdaddr_type);
3493
}
3494
3495
int btd_adapter_pincode_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3496
const char *pin, size_t pin_len)
3497
{
3498
return adapter_ops->pincode_reply(adapter->dev_id, bdaddr, pin,
3499
pin_len);
3500
}
3501
3502
int btd_adapter_confirm_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3503
uint8_t bdaddr_type, gboolean success)
3504
{
3505
return adapter_ops->confirm_reply(adapter->dev_id, bdaddr, bdaddr_type,
3506
success);
3507
}
3508
3509
int btd_adapter_passkey_reply(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3510
uint8_t bdaddr_type, uint32_t passkey)
3511
{
3512
return adapter_ops->passkey_reply(adapter->dev_id, bdaddr, bdaddr_type,
3513
passkey);
3514
}
3515
3516
int btd_adapter_encrypt_link(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3517
bt_hci_result_t cb, gpointer user_data)
3518
{
3519
return adapter_ops->encrypt_link(adapter->dev_id, bdaddr, cb, user_data);
3520
}
3521
3522
int btd_adapter_set_did(struct btd_adapter *adapter, uint16_t vendor,
3523
uint16_t product, uint16_t version,
3524
uint16_t source)
3525
{
3526
return adapter_ops->set_did(adapter->dev_id, vendor, product, version,
3527
source);
3528
}
3529
3530
int adapter_create_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3531
uint8_t addr_type, uint8_t io_cap)
3532
{
3533
suspend_discovery(adapter);
3534
return adapter_ops->create_bonding(adapter->dev_id, bdaddr,
3535
addr_type, io_cap);
3536
}
3537
3538
int adapter_cancel_bonding(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3539
{
3540
return adapter_ops->cancel_bonding(adapter->dev_id, bdaddr);
3541
}
3542
3543
void adapter_bonding_complete(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3544
uint8_t status)
3545
{
3546
struct btd_device *device;
3547
char addr[18];
3548
3549
ba2str(bdaddr, addr);
3550
if (status == 0)
3551
device = adapter_get_device(connection, adapter, addr);
3552
else
3553
device = adapter_find_device(adapter, addr);
3554
3555
if (device != NULL)
3556
device_bonding_complete(device, status);
3557
3558
if (adapter->discov_suspended) {
3559
adapter->discov_suspended = FALSE;
3560
adapter_ops->start_discovery(adapter->dev_id);
3561
}
3562
}
3563
3564
int btd_adapter_read_local_oob_data(struct btd_adapter *adapter)
3565
{
3566
return adapter_ops->read_local_oob_data(adapter->dev_id);
3567
}
3568
3569
int btd_adapter_add_remote_oob_data(struct btd_adapter *adapter,
3570
bdaddr_t *bdaddr, uint8_t *hash, uint8_t *randomizer)
3571
{
3572
return adapter_ops->add_remote_oob_data(adapter->dev_id, bdaddr, hash,
3573
randomizer);
3574
}
3575
3576
int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
3577
bdaddr_t *bdaddr)
3578
{
3579
return adapter_ops->remove_remote_oob_data(adapter->dev_id, bdaddr);
3580
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1