« back to all changes in this revision
Viewing changes to src/adapter.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Mario Limonciello
- Date: 2008-10-07 12:10:29 UTC
- Revision ID: james.westby@ubuntu.com-20081007121029-4gup4fmmh2vfo5nh
Tags: upstream-4.12
Import upstream version 4.12
- files added:
- audio
- common
- compat
- cups
- doc
- gdbus
- include
- input
- lib
- network
- plugins
- rfcomm
- sbc
- scripts
- serial
- src
- test
- tools
added
removed
src/adapter.c
1
/*
2
*
3
* BlueZ - Bluetooth protocol stack for Linux
4
*
5
* Copyright (C) 2006-2007 Nokia Corporation
6
* Copyright (C) 2004-2008 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 <fcntl.h>
33
#include <unistd.h>
34
#include <stdlib.h>
35
#include <sys/ioctl.h>
36
37
#include <bluetooth/bluetooth.h>
38
#include <bluetooth/hci.h>
39
#include <bluetooth/hci_lib.h>
40
#include <bluetooth/l2cap.h>
41
#include <bluetooth/sdp.h>
42
#include <bluetooth/sdp_lib.h>
43
44
#include <glib.h>
45
#include <dbus/dbus.h>
46
#include <gdbus.h>
47
48
#include "logging.h"
49
#include "textfile.h"
50
51
#include "hcid.h"
52
#include "sdpd.h"
53
#include "sdp-xml.h"
54
#include "manager.h"
55
#include "adapter.h"
56
#include "device.h"
57
#include "dbus-common.h"
58
#include "dbus-hci.h"
59
#include "error.h"
60
#include "glib-helper.h"
61
#include "agent.h"
62
#include "storage.h"
63
64
#define NUM_ELEMENTS(table) (sizeof(table)/sizeof(const char *))
65
66
#define IO_CAPABILITY_DISPLAYONLY 0x00
67
#define IO_CAPABILITY_DISPLAYYESNO 0x01
68
#define IO_CAPABILITY_KEYBOARDONLY 0x02
69
#define IO_CAPABILITY_NOINPUTOUTPUT 0x03
70
#define IO_CAPABILITY_INVALID 0xFF
71
72
#define check_address(address) bachk(address)
73
74
static DBusConnection *connection = NULL;
75
static GSList *adapter_drivers = NULL;
76
77
struct session_req {
78
struct btd_adapter *adapter;
79
DBusConnection *conn; /* Connection reference */
80
DBusMessage *msg; /* Message reference */
81
guint id; /* Listener id */
82
uint8_t mode; /* Requested mode */
83
int refcount; /* Session refcount */
84
};
85
86
struct service_auth {
87
service_auth_cb cb;
88
void *user_data;
89
};
90
91
struct btd_adapter {
92
uint16_t dev_id;
93
int up;
94
char *path; /* adapter object path */
95
bdaddr_t bdaddr; /* adapter Bluetooth Address */
96
guint discov_timeout_id; /* discoverable timeout id */
97
uint32_t discov_timeout; /* discoverable time(msec) */
98
uint8_t scan_mode; /* scan mode: SCAN_DISABLED, SCAN_PAGE, SCAN_INQUIRY */
99
uint8_t mode; /* off, connectable, discoverable, limited */
100
uint8_t global_mode; /* last valid global mode */
101
int state; /* standard inq, periodic inq, name resloving */
102
GSList *found_devices;
103
GSList *oor_devices; /* out of range device list */
104
DBusMessage *discovery_cancel; /* discovery cancel message request */
105
GSList *passkey_agents;
106
struct agent *agent; /* For the new API */
107
GSList *active_conn;
108
struct bonding_request_info *bonding;
109
GSList *auth_reqs; /* Received and replied HCI
110
authentication requests */
111
GSList *devices; /* Devices structure pointers */
112
GSList *mode_sessions; /* Request Mode sessions */
113
GSList *disc_sessions; /* Discovery sessions */
114
guint scheduler_id; /* Scheduler handle */
115
116
struct hci_dev dev; /* hci info */
117
};
118
119
static inline DBusMessage *invalid_args(DBusMessage *msg)
120
{
121
return g_dbus_create_error(msg, ERROR_INTERFACE ".InvalidArguments",
122
"Invalid arguments in method call");
123
}
124
125
static inline DBusMessage *not_available(DBusMessage *msg)
126
{
127
return g_dbus_create_error(msg, ERROR_INTERFACE ".NotAvailable",
128
"Not Available");
129
}
130
131
static inline DBusMessage *adapter_not_ready(DBusMessage *msg)
132
{
133
return g_dbus_create_error(msg, ERROR_INTERFACE ".NotReady",
134
"Adapter is not ready");
135
}
136
137
static inline DBusMessage *no_such_adapter(DBusMessage *msg)
138
{
139
return g_dbus_create_error(msg, ERROR_INTERFACE ".NoSuchAdapter",
140
"No such adapter");
141
}
142
143
static inline DBusMessage *failed_strerror(DBusMessage *msg, int err)
144
{
145
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
146
strerror(err));
147
}
148
149
static inline DBusMessage *in_progress(DBusMessage *msg, const char *str)
150
{
151
return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress", str);
152
}
153
154
static inline DBusMessage *not_in_progress(DBusMessage *msg, const char *str)
155
{
156
return g_dbus_create_error(msg, ERROR_INTERFACE ".NotInProgress", str);
157
}
158
159
static inline DBusMessage *not_authorized(DBusMessage *msg)
160
{
161
return g_dbus_create_error(msg, ERROR_INTERFACE ".NotAuthorized",
162
"Not authorized");
163
}
164
165
static inline DBusMessage *unsupported_major_class(DBusMessage *msg)
166
{
167
return g_dbus_create_error(msg,
168
ERROR_INTERFACE ".UnsupportedMajorClass",
169
"Unsupported Major Class");
170
}
171
172
static DBusHandlerResult error_failed(DBusConnection *conn,
173
DBusMessage *msg, const char * desc)
174
{
175
return error_common_reply(conn, msg, ERROR_INTERFACE ".Failed", desc);
176
}
177
178
static DBusHandlerResult error_failed_errno(DBusConnection *conn,
179
DBusMessage *msg, int err)
180
{
181
const char *desc = strerror(err);
182
183
return error_failed(conn, msg, desc);
184
}
185
186
static DBusHandlerResult error_connection_attempt_failed(DBusConnection *conn,
187
DBusMessage *msg, int err)
188
{
189
return error_common_reply(conn, msg,
190
ERROR_INTERFACE ".ConnectionAttemptFailed",
191
err > 0 ? strerror(err) : "Connection attempt failed");
192
}
193
194
static void bonding_request_free(struct bonding_request_info *bonding)
195
{
196
struct btd_device *device;
197
char address[18];
198
struct agent *agent;
199
200
if (!bonding)
201
return;
202
203
if (bonding->msg)
204
dbus_message_unref(bonding->msg);
205
206
if (bonding->conn)
207
dbus_connection_unref(bonding->conn);
208
209
if (bonding->io)
210
g_io_channel_unref(bonding->io);
211
212
ba2str(&bonding->bdaddr, address);
213
214
device = adapter_find_device(bonding->adapter, address);
215
agent = device_get_agent(device);
216
217
if (device && agent) {
218
agent_destroy(agent, FALSE);
219
device_set_agent(device, NULL);
220
}
221
222
g_free(bonding);
223
}
224
225
static int active_conn_find_by_bdaddr(const void *data, const void *user_data)
226
{
227
const struct active_conn_info *con = data;
228
const bdaddr_t *bdaddr = user_data;
229
230
return bacmp(&con->bdaddr, bdaddr);
231
}
232
233
static int active_conn_find_by_handle(const void *data, const void *user_data)
234
{
235
const struct active_conn_info *dev = data;
236
const uint16_t *handle = user_data;
237
238
if (dev->handle == *handle)
239
return 0;
240
241
return -1;
242
}
243
244
static void send_out_of_range(const char *path, GSList *l)
245
{
246
while (l) {
247
const char *peer_addr = l->data;
248
249
g_dbus_emit_signal(connection, path,
250
ADAPTER_INTERFACE, "DeviceDisappeared",
251
DBUS_TYPE_STRING, &peer_addr,
252
DBUS_TYPE_INVALID);
253
254
l = l->next;
255
}
256
}
257
258
static int found_device_cmp(const struct remote_dev_info *d1,
259
const struct remote_dev_info *d2)
260
{
261
int ret;
262
263
if (bacmp(&d2->bdaddr, BDADDR_ANY)) {
264
ret = bacmp(&d1->bdaddr, &d2->bdaddr);
265
if (ret)
266
return ret;
267
}
268
269
if (d2->name_status != NAME_ANY) {
270
ret = (d1->name_status - d2->name_status);
271
if (ret)
272
return ret;
273
}
274
275
return 0;
276
}
277
278
static int auth_req_cmp(const void *p1, const void *p2)
279
{
280
const struct pending_auth_info *pb1 = p1;
281
const bdaddr_t *bda = p2;
282
283
return bda ? bacmp(&pb1->bdaddr, bda) : -1;
284
}
285
286
struct pending_auth_info *adapter_find_auth_request(struct btd_adapter *adapter,
287
bdaddr_t *dba)
288
{
289
GSList *l;
290
291
l = g_slist_find_custom(adapter->auth_reqs, dba, auth_req_cmp);
292
if (l)
293
return l->data;
294
295
return NULL;
296
}
297
298
void adapter_remove_auth_request(struct btd_adapter *adapter, bdaddr_t *dba)
299
{
300
GSList *l;
301
struct pending_auth_info *auth;
302
303
l = g_slist_find_custom(adapter->auth_reqs, dba, auth_req_cmp);
304
if (!l)
305
return;
306
307
auth = l->data;
308
309
adapter->auth_reqs = g_slist_remove(adapter->auth_reqs, auth);
310
311
g_free(auth);
312
}
313
314
struct pending_auth_info *adapter_new_auth_request(struct btd_adapter *adapter,
315
bdaddr_t *dba,
316
auth_type_t type)
317
{
318
struct pending_auth_info *info;
319
320
debug("hcid_dbus_new_auth_request");
321
322
info = g_new0(struct pending_auth_info, 1);
323
324
bacpy(&info->bdaddr, dba);
325
info->type = type;
326
adapter->auth_reqs = g_slist_append(adapter->auth_reqs, info);
327
328
if (adapter->bonding && !bacmp(dba, &adapter->bonding->bdaddr))
329
adapter->bonding->auth_active = 1;
330
331
return info;
332
}
333
334
int pending_remote_name_cancel(struct btd_adapter *adapter)
335
{
336
struct remote_dev_info *dev, match;
337
GSList *l;
338
int dd, err = 0;
339
340
/* find the pending remote name request */
341
memset(&match, 0, sizeof(struct remote_dev_info));
342
bacpy(&match.bdaddr, BDADDR_ANY);
343
match.name_status = NAME_REQUESTED;
344
345
l = g_slist_find_custom(adapter->found_devices, &match,
346
(GCompareFunc) found_device_cmp);
347
if (!l) /* no pending request */
348
return 0;
349
350
dd = hci_open_dev(adapter->dev_id);
351
if (dd < 0)
352
return -ENODEV;
353
354
dev = l->data;
355
356
if (hci_read_remote_name_cancel(dd, &dev->bdaddr,
357
HCI_REQ_TIMEOUT) < 0) {
358
error("Remote name cancel failed: %s(%d)", strerror(errno), errno);
359
err = -errno;
360
}
361
362
/* free discovered devices list */
363
g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL);
364
g_slist_free(adapter->found_devices);
365
adapter->found_devices = NULL;
366
367
hci_close_dev(dd);
368
return err;
369
}
370
371
static int auth_info_agent_cmp(const void *a, const void *b)
372
{
373
const struct pending_auth_info *auth = a;
374
const struct agent *agent = b;
375
376
if (auth->agent == agent)
377
return 0;
378
379
return -1;
380
}
381
382
static void device_agent_removed(struct agent *agent, void *user_data)
383
{
384
struct btd_device *device = user_data;
385
struct pending_auth_info *auth;
386
GSList *l;
387
struct btd_adapter *adapter;
388
389
adapter = device_get_adapter(device);
390
device_set_agent(device, NULL);
391
392
l = g_slist_find_custom(adapter->auth_reqs, agent,
393
auth_info_agent_cmp);
394
if (!l)
395
return;
396
397
auth = l->data;
398
auth->agent = NULL;
399
}
400
401
static struct bonding_request_info *bonding_request_new(DBusConnection *conn,
402
DBusMessage *msg,
403
struct btd_adapter *adapter,
404
const char *address,
405
const char *agent_path,
406
uint8_t capability)
407
{
408
struct bonding_request_info *bonding;
409
struct btd_device *device;
410
const char *name = dbus_message_get_sender(msg);
411
struct agent *agent;
412
char addr[18];
413
bdaddr_t bdaddr;
414
415
debug("bonding_request_new(%s)", address);
416
417
device = adapter_get_device(conn, adapter, address);
418
if (!device)
419
return NULL;
420
421
device_get_address(device, &bdaddr);
422
ba2str(&bdaddr, addr);
423
424
agent = agent_create(adapter, name, agent_path,
425
capability,
426
device_agent_removed,
427
device);
428
429
device_set_agent(device, agent);
430
431
debug("Temporary agent registered for hci%d/%s at %s:%s",
432
adapter->dev_id, addr, name,
433
agent_path);
434
435
bonding = g_new0(struct bonding_request_info, 1);
436
437
bonding->conn = dbus_connection_ref(conn);
438
bonding->msg = dbus_message_ref(msg);
439
bonding->adapter = adapter;
440
441
str2ba(address, &bonding->bdaddr);
442
443
return bonding;
444
}
445
446
static const char *mode2str(uint8_t mode)
447
{
448
switch(mode) {
449
case MODE_OFF:
450
return "off";
451
case MODE_CONNECTABLE:
452
return "connectable";
453
case MODE_DISCOVERABLE:
454
return "discoverable";
455
case MODE_LIMITED:
456
return "limited";
457
default:
458
return "unknown";
459
}
460
}
461
462
static uint8_t get_mode(const bdaddr_t *bdaddr, const char *mode)
463
{
464
if (strcasecmp("off", mode) == 0)
465
return MODE_OFF;
466
else if (strcasecmp("connectable", mode) == 0)
467
return MODE_CONNECTABLE;
468
else if (strcasecmp("discoverable", mode) == 0)
469
return MODE_DISCOVERABLE;
470
else if (strcasecmp("limited", mode) == 0)
471
return MODE_LIMITED;
472
else if (strcasecmp("on", mode) == 0) {
473
char onmode[14], srcaddr[18];
474
475
ba2str(bdaddr, srcaddr);
476
if (read_on_mode(srcaddr, onmode, sizeof(onmode)) < 0)
477
return MODE_CONNECTABLE;
478
479
return get_mode(bdaddr, onmode);
480
} else
481
return MODE_UNKNOWN;
482
}
483
484
static DBusMessage *set_mode(DBusConnection *conn, DBusMessage *msg,
485
uint8_t new_mode, void *data)
486
{
487
struct btd_adapter *adapter = data;
488
uint8_t scan_enable;
489
uint8_t current_scan = adapter->scan_mode;
490
gboolean limited;
491
int err, dd;
492
const char *mode;
493
494
switch (new_mode) {
495
case MODE_OFF:
496
scan_enable = SCAN_DISABLED;
497
break;
498
case MODE_CONNECTABLE:
499
scan_enable = SCAN_PAGE;
500
break;
501
case MODE_DISCOVERABLE:
502
case MODE_LIMITED:
503
scan_enable = (SCAN_PAGE | SCAN_INQUIRY);
504
break;
505
default:
506
return invalid_args(msg);
507
}
508
509
/* Do reverse resolution in case of "on" mode */
510
mode = mode2str(new_mode);
511
512
dd = hci_open_dev(adapter->dev_id);
513
if (dd < 0)
514
return no_such_adapter(msg);
515
516
if (!adapter->up &&
517
(main_opts.offmode == HCID_OFFMODE_NOSCAN ||
518
(main_opts.offmode == HCID_OFFMODE_DEVDOWN &&
519
scan_enable != SCAN_DISABLED))) {
520
/* Start HCI device */
521
if (ioctl(dd, HCIDEVUP, adapter->dev_id) == 0)
522
goto done; /* on success */
523
524
if (errno != EALREADY) {
525
err = errno;
526
error("Can't init device hci%d: %s (%d)\n",
527
adapter->dev_id, strerror(errno), errno);
528
529
hci_close_dev(dd);
530
return failed_strerror(msg, err);
531
}
532
}
533
534
if (adapter->up && scan_enable == SCAN_DISABLED &&
535
main_opts.offmode == HCID_OFFMODE_DEVDOWN) {
536
if (ioctl(dd, HCIDEVDOWN, adapter->dev_id) < 0) {
537
hci_close_dev(dd);
538
return failed_strerror(msg, errno);
539
}
540
541
goto done;
542
}
543
544
limited = (new_mode == MODE_LIMITED ? TRUE : FALSE);
545
err = set_limited_discoverable(dd, adapter->dev.class, limited);
546
if (err < 0) {
547
hci_close_dev(dd);
548
return failed_strerror(msg, -err);
549
}
550
551
if (current_scan != scan_enable) {
552
struct hci_request rq;
553
uint8_t status = 0;
554
555
memset(&rq, 0, sizeof(rq));
556
rq.ogf = OGF_HOST_CTL;
557
rq.ocf = OCF_WRITE_SCAN_ENABLE;
558
rq.cparam = &scan_enable;
559
rq.clen = sizeof(scan_enable);
560
rq.rparam = &status;
561
rq.rlen = sizeof(status);
562
rq.event = EVT_CMD_COMPLETE;
563
564
if (hci_send_req(dd, &rq, HCI_REQ_TIMEOUT) < 0) {
565
err = errno;
566
error("Sending write scan enable command failed: %s (%d)",
567
strerror(errno), errno);
568
hci_close_dev(dd);
569
return failed_strerror(msg, err);
570
}
571
572
if (status) {
573
error("Setting scan enable failed with status 0x%02x",
574
status);
575
hci_close_dev(dd);
576
return failed_strerror(msg, bt_error(status));
577
}
578
} else {
579
/* discoverable or limited */
580
if ((scan_enable & SCAN_INQUIRY) && (new_mode != adapter->mode)) {
581
if (adapter->discov_timeout_id) {
582
g_source_remove(adapter->discov_timeout_id);
583
adapter->discov_timeout_id = 0;
584
}
585
586
if (!adapter->mode_sessions && !adapter->discov_timeout)
587
adapter_set_discov_timeout(adapter,
588
adapter->discov_timeout * 1000);
589
}
590
}
591
done:
592
write_device_mode(&adapter->bdaddr, mode);
593
594
hci_close_dev(dd);
595
596
adapter->mode = new_mode;
597
598
return dbus_message_new_method_return(msg);
599
}
600
601
static DBusMessage *set_powered(DBusConnection *conn, DBusMessage *msg,
602
gboolean powered, void *data)
603
{
604
struct btd_adapter *adapter = data;
605
uint8_t mode;
606
607
mode = powered ? get_mode(&adapter->bdaddr, "on") : MODE_OFF;
608
609
if (mode == adapter->mode)
610
return dbus_message_new_method_return(msg);
611
612
return set_mode(conn, msg, mode, data);
613
}
614
615
static DBusMessage *set_discoverable(DBusConnection *conn, DBusMessage *msg,
616
gboolean discoverable, void *data)
617
{
618
struct btd_adapter *adapter = data;
619
const char *strmode;
620
uint8_t mode;
621
622
strmode = discoverable ? "discoverable" : "connectable";
623
mode = get_mode(&adapter->bdaddr, strmode);
624
625
if (mode == adapter->mode)
626
return dbus_message_new_method_return(msg);
627
628
return set_mode(conn, msg, mode, data);
629
}
630
631
static struct session_req *find_session(GSList *list, DBusMessage *msg)
632
{
633
GSList *l;
634
const char *sender = dbus_message_get_sender(msg);
635
636
for (l = list; l; l = l->next) {
637
struct session_req *req = l->data;
638
const char *name = dbus_message_get_sender(req->msg);
639
640
if (g_str_equal(name, sender))
641
return req;
642
}
643
644
return NULL;
645
}
646
647
static void session_remove(struct session_req *req)
648
{
649
struct btd_adapter *adapter = req->adapter;
650
651
if (req->mode) {
652
GSList *l;
653
uint8_t mode = adapter->global_mode;
654
655
adapter->mode_sessions = g_slist_remove(adapter->mode_sessions,
656
req);
657
658
for (l = adapter->mode_sessions; l; l = l->next) {
659
struct session_req *req = l->data;
660
661
if (req->mode > mode)
662
mode = req->mode;
663
}
664
665
if (mode == adapter->mode)
666
return;
667
668
debug("Switching to '%s' mode", mode2str(mode));
669
set_mode(req->conn, req->msg, mode, adapter);
670
} else {
671
adapter->disc_sessions = g_slist_remove(adapter->disc_sessions,
672
req);
673
674
if (adapter->disc_sessions)
675
return;
676
677
debug("Stopping discovery", mode2str(adapter->global_mode));
678
679
if (adapter->state & STD_INQUIRY)
680
cancel_discovery(adapter);
681
else if (adapter->scheduler_id)
682
g_source_remove(adapter->scheduler_id);
683
else
684
cancel_periodic_discovery(adapter);
685
}
686
687
}
688
689
static void session_free(struct session_req *req)
690
{
691
const char *sender = dbus_message_get_sender(req->msg);
692
693
info("%s session %p with %s deactivated",
694
req->mode ? "Mode" : "Discovery", req, sender);
695
696
session_remove(req);
697
698
dbus_message_unref(req->msg);
699
dbus_connection_unref(req->conn);
700
g_free(req);
701
}
702
703
static struct session_req *session_ref(struct session_req *req)
704
{
705
req->refcount++;
706
707
debug("session_ref(%p): ref=%d", req, req->refcount);
708
709
return req;
710
}
711
712
static void session_unref(struct session_req *req)
713
{
714
req->refcount--;
715
716
debug("session_unref(%p): ref=%d", req, req->refcount);
717
718
if (req->refcount)
719
return;
720
721
if (req->id)
722
g_dbus_remove_watch(req->conn, req->id);
723
724
session_free(req);
725
}
726
727
static struct session_req *create_session(struct btd_adapter *adapter,
728
DBusConnection *conn, DBusMessage *msg,
729
uint8_t mode, GDBusWatchFunction cb)
730
{
731
struct session_req *req;
732
const char *sender = dbus_message_get_sender(msg);
733
734
req = g_new0(struct session_req, 1);
735
req->adapter = adapter;
736
req->conn = dbus_connection_ref(conn);
737
req->msg = dbus_message_ref(msg);
738
req->mode = mode;
739
740
if (cb)
741
req->id = g_dbus_add_disconnect_watch(conn,
742
dbus_message_get_sender(msg),
743
cb, req, NULL);
744
745
info("%s session %p with %s activated",
746
req->mode ? "Mode" : "Discovery", req, sender);
747
748
return session_ref(req);
749
}
750
751
static void confirm_mode_cb(struct agent *agent, DBusError *err, void *data)
752
{
753
struct session_req *req = data;
754
DBusMessage *reply;
755
756
if (err && dbus_error_is_set(err)) {
757
reply = dbus_message_new_error(req->msg, err->name, err->message);
758
dbus_connection_send(req->conn, reply, NULL);
759
dbus_message_unref(reply);
760
goto cleanup;
761
}
762
763
reply = set_mode(req->conn, req->msg, req->mode, req->adapter);
764
dbus_connection_send(req->conn, reply, NULL);
765
dbus_message_unref(reply);
766
767
if (!find_session(req->adapter->mode_sessions, req->msg))
768
goto cleanup;
769
770
return;
771
772
cleanup:
773
session_unref(req);
774
}
775
776
static DBusMessage *confirm_mode(DBusConnection *conn, DBusMessage *msg,
777
const char *mode, void *data)
778
{
779
struct btd_adapter *adapter = data;
780
struct session_req *req;
781
int ret;
782
uint8_t umode;
783
784
if (!adapter->agent)
785
return dbus_message_new_method_return(msg);
786
787
umode = get_mode(&adapter->bdaddr, mode);
788
789
req = create_session(adapter, conn, msg, umode, NULL);
790
791
ret = agent_confirm_mode_change(adapter->agent, mode, confirm_mode_cb,
792
req);
793
if (ret < 0) {
794
session_unref(req);
795
return invalid_args(msg);
796
}
797
798
return NULL;
799
}
800
801
static DBusMessage *set_discoverable_timeout(DBusConnection *conn,
802
DBusMessage *msg,
803
uint32_t timeout,
804
void *data)
805
{
806
struct btd_adapter *adapter = data;
807
const char *path;
808
809
if (adapter->discov_timeout == timeout && timeout == 0)
810
return dbus_message_new_method_return(msg);
811
812
if (adapter->discov_timeout_id) {
813
g_source_remove(adapter->discov_timeout_id);
814
adapter->discov_timeout_id = 0;
815
}
816
817
if ((timeout != 0) && (adapter->scan_mode & SCAN_INQUIRY))
818
adapter_set_discov_timeout(adapter, timeout * 1000);
819
820
adapter->discov_timeout = timeout;
821
822
write_discoverable_timeout(&adapter->bdaddr, timeout);
823
824
path = dbus_message_get_path(msg);
825
826
dbus_connection_emit_property_changed(conn, path,
827
ADAPTER_INTERFACE,
828
"DiscoverableTimeout",
829
DBUS_TYPE_UINT32, &timeout);
830
831
return dbus_message_new_method_return(msg);
832
}
833
834
static void update_ext_inquiry_response(int dd, struct hci_dev *dev)
835
{
836
uint8_t fec = 0, data[240];
837
838
if (!(dev->features[6] & LMP_EXT_INQ))
839
return;
840
841
memset(data, 0, sizeof(data));
842
843
if (dev->ssp_mode > 0)
844
create_ext_inquiry_response((char *) dev->name, data);
845
846
if (hci_write_ext_inquiry_response(dd, fec, data,
847
HCI_REQ_TIMEOUT) < 0)
848
error("Can't write extended inquiry response: %s (%d)",
849
strerror(errno), errno);
850
}
851
852
static int adapter_set_name(struct btd_adapter *adapter, const char *name)
853
{
854
struct hci_dev *dev = &adapter->dev;
855
int dd, err;
856
857
write_local_name(&adapter->bdaddr, (char *) name);
858
859
if (!adapter->up)
860
return 0;
861
862
dd = hci_open_dev(adapter->dev_id);
863
if (dd < 0) {
864
err = errno;
865
error("Can't open device hci%d: %s (%d)",
866
adapter->dev_id, strerror(err), err);
867
return -err;
868
}
869
870
if (hci_write_local_name(dd, name, HCI_REQ_TIMEOUT) < 0) {
871
err = errno;
872
error("Can't write name for hci%d: %s (%d)",
873
adapter->dev_id, strerror(err), err);
874
hci_close_dev(dd);
875
return -err;
876
}
877
878
strncpy((char *) dev->name, name, 248);
879
880
update_ext_inquiry_response(dd, dev);
881
882
hci_close_dev(dd);
883
884
return 0;
885
}
886
887
static DBusMessage *set_name(DBusConnection *conn, DBusMessage *msg,
888
const char *name, void *data)
889
{
890
struct btd_adapter *adapter = data;
891
int ecode;
892
const char *path;
893
894
if (!g_utf8_validate(name, -1, NULL)) {
895
error("Name change failed: the supplied name isn't valid UTF-8");
896
return invalid_args(msg);
897
}
898
899
ecode = adapter_set_name(adapter, name);
900
if (ecode < 0)
901
return failed_strerror(msg, -ecode);
902
903
path = dbus_message_get_path(msg);
904
905
dbus_connection_emit_property_changed(conn, path,
906
ADAPTER_INTERFACE,
907
"Name", DBUS_TYPE_STRING,
908
&name);
909
910
return dbus_message_new_method_return(msg);
911
}
912
913
static void reply_authentication_failure(struct bonding_request_info *bonding)
914
{
915
DBusMessage *reply;
916
int status;
917
918
status = bonding->hci_status ?
919
bonding->hci_status : HCI_AUTHENTICATION_FAILURE;
920
921
reply = new_authentication_return(bonding->msg, status);
922
if (reply) {
923
dbus_connection_send(bonding->conn, reply, NULL);
924
dbus_message_unref(reply);
925
}
926
}
927
928
struct btd_device *adapter_find_device(struct btd_adapter *adapter, const char *dest)
929
{
930
struct btd_device *device;
931
GSList *l;
932
933
if (!adapter)
934
return NULL;
935
936
l = g_slist_find_custom(adapter->devices,
937
dest, (GCompareFunc) device_address_cmp);
938
if (!l)
939
return NULL;
940
941
device = l->data;
942
943
return device;
944
}
945
946
struct btd_device *adapter_create_device(DBusConnection *conn,
947
struct btd_adapter *adapter, const char *address)
948
{
949
struct btd_device *device;
950
951
debug("adapter_create_device(%s)", address);
952
953
device = device_create(conn, adapter, address);
954
if (!device)
955
return NULL;
956
957
device_set_temporary(device, TRUE);
958
959
adapter->devices = g_slist_append(adapter->devices, device);
960
961
return device;
962
}
963
964
static DBusMessage *remove_bonding(DBusConnection *conn, DBusMessage *msg,
965
const char *address, void *data)
966
{
967
struct btd_adapter *adapter = data;
968
struct btd_device *device;
969
char filename[PATH_MAX + 1];
970
char *str, srcaddr[18];
971
bdaddr_t dst;
972
GSList *l;
973
int dev, err;
974
gboolean paired;
975
976
str2ba(address, &dst);
977
ba2str(&adapter->bdaddr, srcaddr);
978
979
dev = hci_open_dev(adapter->dev_id);
980
if (dev < 0 && msg)
981
return no_such_adapter(msg);
982
983
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr,
984
"linkkeys");
985
986
/* textfile_del doesn't return an error when the key is not found */
987
str = textfile_caseget(filename, address);
988
paired = str ? TRUE : FALSE;
989
g_free(str);
990
991
if (!paired && msg) {
992
hci_close_dev(dev);
993
return g_dbus_create_error(msg,
994
ERROR_INTERFACE ".DoesNotExist",
995
"Bonding does not exist");
996
}
997
998
/* Delete the link key from storage */
999
if (textfile_casedel(filename, address) < 0 && msg) {
1000
hci_close_dev(dev);
1001
err = errno;
1002
return failed_strerror(msg, err);
1003
}
1004
1005
/* Delete the link key from the Bluetooth chip */
1006
hci_delete_stored_link_key(dev, &dst, 0, HCI_REQ_TIMEOUT);
1007
1008
/* find the connection */
1009
l = g_slist_find_custom(adapter->active_conn, &dst,
1010
active_conn_find_by_bdaddr);
1011
if (l) {
1012
struct active_conn_info *con = l->data;
1013
/* Send the HCI disconnect command */
1014
if ((hci_disconnect(dev, htobs(con->handle),
1015
HCI_OE_USER_ENDED_CONNECTION,
1016
HCI_REQ_TIMEOUT) < 0)
1017
&& msg){
1018
int err = errno;
1019
error("Disconnect failed");
1020
hci_close_dev(dev);
1021
return failed_strerror(msg, err);
1022
}
1023
}
1024
1025
hci_close_dev(dev);
1026
1027
device = adapter_find_device(adapter, address);
1028
if (!device)
1029
goto proceed;
1030
1031
if (paired) {
1032
gboolean paired = FALSE;
1033
1034
const gchar *dev_path = device_get_path(device);
1035
1036
dbus_connection_emit_property_changed(conn, dev_path,
1037
DEVICE_INTERFACE, "Paired",
1038
DBUS_TYPE_BOOLEAN, &paired);
1039
}
1040
1041
proceed:
1042
if(!msg)
1043
goto done;
1044
1045
return dbus_message_new_method_return(msg);
1046
1047
done:
1048
return NULL;
1049
}
1050
1051
1052
void adapter_remove_device(DBusConnection *conn, struct btd_adapter *adapter,
1053
struct btd_device *device)
1054
{
1055
bdaddr_t dst;
1056
const gchar *dev_path = device_get_path(device);
1057
struct agent *agent;
1058
char dstaddr[18];
1059
1060
device_get_address(device, &dst);
1061
ba2str(&dst, dstaddr);
1062
1063
delete_entry(&adapter->bdaddr, "profiles", dstaddr);
1064
adapter->devices = g_slist_remove(adapter->devices, device);
1065
1066
if (!device_is_temporary(device)) {
1067
remove_bonding(conn, NULL, dstaddr, adapter);
1068
1069
g_dbus_emit_signal(conn, adapter->path,
1070
ADAPTER_INTERFACE,
1071
"DeviceRemoved",
1072
DBUS_TYPE_OBJECT_PATH, &dev_path,
1073
DBUS_TYPE_INVALID);
1074
1075
adapter_update_devices(adapter);
1076
}
1077
1078
agent = device_get_agent(device);
1079
1080
if (agent) {
1081
agent_destroy(agent, FALSE);
1082
device_set_agent(device, NULL);
1083
}
1084
1085
device_remove(conn, device);
1086
}
1087
1088
struct btd_device *adapter_get_device(DBusConnection *conn,
1089
struct btd_adapter *adapter, const gchar *address)
1090
{
1091
struct btd_device *device;
1092
1093
debug("adapter_get_device(%s)", address);
1094
1095
if (!adapter)
1096
return NULL;
1097
1098
device = adapter_find_device(adapter, address);
1099
if (device)
1100
return device;
1101
1102
return adapter_create_device(conn, adapter, address);
1103
}
1104
1105
void remove_pending_device(struct btd_adapter *adapter)
1106
{
1107
struct btd_device *device;
1108
char address[18];
1109
1110
ba2str(&adapter->bonding->bdaddr, address);
1111
device = adapter_find_device(adapter, address);
1112
if (!device)
1113
return;
1114
1115
if (device_is_temporary(device))
1116
adapter_remove_device(adapter->bonding->conn, adapter, device);
1117
}
1118
1119
static gboolean create_bonding_conn_complete(GIOChannel *io, GIOCondition cond,
1120
struct btd_adapter *adapter)
1121
{
1122
struct hci_request rq;
1123
auth_requested_cp cp;
1124
evt_cmd_status rp;
1125
struct l2cap_conninfo cinfo;
1126
socklen_t len;
1127
int sk, dd, ret;
1128
1129
if (!adapter->bonding) {
1130
/* If we come here it implies a bug somewhere */
1131
debug("create_bonding_conn_complete: no pending bonding!");
1132
g_io_channel_close(io);
1133
return FALSE;
1134
}
1135
1136
if (cond & G_IO_NVAL) {
1137
DBusMessage *reply;
1138
reply = new_authentication_return(adapter->bonding->msg, 0x09);
1139
g_dbus_send_message(adapter->bonding->conn, reply);
1140
goto cleanup;
1141
}
1142
1143
if (cond & (G_IO_HUP | G_IO_ERR)) {
1144
debug("Hangup or error on bonding IO channel");
1145
1146
if (!adapter->bonding->auth_active)
1147
error_connection_attempt_failed(adapter->bonding->conn,
1148
adapter->bonding->msg,
1149
ENETDOWN);
1150
else
1151
reply_authentication_failure(adapter->bonding);
1152
1153
goto failed;
1154
}
1155
1156
sk = g_io_channel_unix_get_fd(io);
1157
1158
len = sizeof(ret);
1159
if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &ret, &len) < 0) {
1160
error("Can't get socket error: %s (%d)",
1161
strerror(errno), errno);
1162
error_failed_errno(adapter->bonding->conn, adapter->bonding->msg,
1163
errno);
1164
goto failed;
1165
}
1166
1167
if (ret != 0) {
1168
if (adapter->bonding->auth_active)
1169
reply_authentication_failure(adapter->bonding);
1170
else
1171
error_connection_attempt_failed(adapter->bonding->conn,
1172
adapter->bonding->msg,
1173
ret);
1174
goto failed;
1175
}
1176
1177
len = sizeof(cinfo);
1178
if (getsockopt(sk, SOL_L2CAP, L2CAP_CONNINFO, &cinfo, &len) < 0) {
1179
error("Can't get connection info: %s (%d)",
1180
strerror(errno), errno);
1181
error_failed_errno(adapter->bonding->conn, adapter->bonding->msg,
1182
errno);
1183
goto failed;
1184
}
1185
1186
dd = hci_open_dev(adapter->dev_id);
1187
if (dd < 0) {
1188
DBusMessage *reply = no_such_adapter(adapter->bonding->msg);
1189
g_dbus_send_message(adapter->bonding->conn, reply);
1190
goto failed;
1191
}
1192
1193
memset(&rp, 0, sizeof(rp));
1194
1195
memset(&cp, 0, sizeof(cp));
1196
cp.handle = htobs(cinfo.hci_handle);
1197
1198
memset(&rq, 0, sizeof(rq));
1199
rq.ogf = OGF_LINK_CTL;
1200
rq.ocf = OCF_AUTH_REQUESTED;
1201
rq.cparam = &cp;
1202
rq.clen = AUTH_REQUESTED_CP_SIZE;
1203
rq.rparam = &rp;
1204
rq.rlen = EVT_CMD_STATUS_SIZE;
1205
rq.event = EVT_CMD_STATUS;
1206
1207
if (hci_send_req(dd, &rq, HCI_REQ_TIMEOUT) < 0) {
1208
error("Unable to send HCI request: %s (%d)",
1209
strerror(errno), errno);
1210
error_failed_errno(adapter->bonding->conn, adapter->bonding->msg,
1211
errno);
1212
hci_close_dev(dd);
1213
goto failed;
1214
}
1215
1216
if (rp.status) {
1217
error("HCI_Authentication_Requested failed with status 0x%02x",
1218
rp.status);
1219
error_failed_errno(adapter->bonding->conn, adapter->bonding->msg,
1220
bt_error(rp.status));
1221
hci_close_dev(dd);
1222
goto failed;
1223
}
1224
1225
hci_close_dev(dd);
1226
1227
adapter->bonding->auth_active = 1;
1228
1229
adapter->bonding->io_id = g_io_add_watch(io,
1230
G_IO_NVAL | G_IO_HUP | G_IO_ERR,
1231
(GIOFunc) create_bonding_conn_complete,
1232
adapter);
1233
1234
return FALSE;
1235
1236
failed:
1237
g_io_channel_close(io);
1238
remove_pending_device(adapter);
1239
1240
cleanup:
1241
g_dbus_remove_watch(adapter->bonding->conn,
1242
adapter->bonding->listener_id);
1243
bonding_request_free(adapter->bonding);
1244
adapter->bonding = NULL;
1245
1246
return FALSE;
1247
}
1248
1249
static void cancel_auth_request(struct pending_auth_info *auth, int dev_id)
1250
{
1251
int dd;
1252
1253
if (auth->replied)
1254
return;
1255
1256
dd = hci_open_dev(dev_id);
1257
if (dd < 0) {
1258
error("hci_open_dev: %s (%d)", strerror(errno), errno);
1259
return;
1260
}
1261
1262
switch (auth->type) {
1263
case AUTH_TYPE_PINCODE:
1264
hci_send_cmd(dd, OGF_LINK_CTL, OCF_PIN_CODE_NEG_REPLY,
1265
6, &auth->bdaddr);
1266
break;
1267
case AUTH_TYPE_CONFIRM:
1268
hci_send_cmd(dd, OGF_LINK_CTL, OCF_USER_CONFIRM_NEG_REPLY,
1269
6, &auth->bdaddr);
1270
break;
1271
case AUTH_TYPE_PASSKEY:
1272
hci_send_cmd(dd, OGF_LINK_CTL, OCF_USER_PASSKEY_NEG_REPLY,
1273
6, &auth->bdaddr);
1274
break;
1275
case AUTH_TYPE_NOTIFY:
1276
/* User Notify doesn't require any reply */
1277
break;
1278
}
1279
1280
auth->replied = TRUE;
1281
1282
hci_close_dev(dd);
1283
}
1284
1285
static void cancel_bonding(struct btd_adapter *adapter, gboolean exited)
1286
{
1287
struct pending_auth_info *auth;
1288
struct bonding_request_info *bonding = adapter->bonding;
1289
1290
auth = adapter_find_auth_request(adapter, &adapter->bdaddr);
1291
if (auth) {
1292
cancel_auth_request(auth, adapter->dev_id);
1293
if (auth->agent)
1294
agent_cancel(auth->agent);
1295
adapter_remove_auth_request(adapter, &bonding->bdaddr);
1296
}
1297
1298
remove_pending_device(adapter);
1299
1300
if (bonding->io)
1301
g_io_channel_close(bonding->io);
1302
1303
if (exited) {
1304
if (bonding->io_id) {
1305
g_source_remove(bonding->io_id);
1306
bonding->io_id = 0;
1307
}
1308
bonding_request_free(bonding);
1309
adapter->bonding = NULL;
1310
1311
} else
1312
bonding->cancel = TRUE;
1313
}
1314
1315
static void create_bond_req_exit(void *user_data)
1316
{
1317
struct btd_adapter *adapter = user_data;
1318
1319
debug("CreateConnection requestor exited before bonding was completed");
1320
1321
cancel_bonding(adapter, TRUE);
1322
}
1323
1324
static DBusMessage *create_bonding(DBusConnection *conn, DBusMessage *msg,
1325
const char *address, const char *agent_path,
1326
uint8_t capability, void *data)
1327
{
1328
char filename[PATH_MAX + 1];
1329
char *str, srcaddr[18];
1330
struct btd_adapter *adapter = data;
1331
struct bonding_request_info *bonding;
1332
bdaddr_t dst;
1333
int sk;
1334
1335
str2ba(address, &dst);
1336
ba2str(&adapter->bdaddr, srcaddr);
1337
1338
/* check if there is a pending discover: requested by D-Bus/non clients */
1339
if (adapter->state & STD_INQUIRY)
1340
return in_progress(msg, "Discover in progress");
1341
1342
pending_remote_name_cancel(adapter);
1343
1344
if (adapter->bonding)
1345
return in_progress(msg, "Bonding in progress");
1346
1347
if (adapter_find_auth_request(adapter, &dst))
1348
return in_progress(msg, "Bonding in progress");
1349
1350
/* check if a link key already exists */
1351
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr,
1352
"linkkeys");
1353
1354
str = textfile_caseget(filename, address);
1355
if (str) {
1356
free(str);
1357
return g_dbus_create_error(msg,
1358
ERROR_INTERFACE ".AlreadyExists",
1359
"Bonding already exists");
1360
}
1361
1362
sk = l2raw_connect(&adapter->bdaddr, &dst);
1363
if (sk < 0)
1364
return g_dbus_create_error(msg,
1365
ERROR_INTERFACE ".ConnectionAttemptFailed",
1366
"Connection attempt failed");
1367
1368
bonding = bonding_request_new(conn, msg, adapter, address, agent_path,
1369
capability);
1370
if (!bonding) {
1371
close(sk);
1372
return NULL;
1373
}
1374
1375
bonding->io = g_io_channel_unix_new(sk);
1376
bonding->io_id = g_io_add_watch(bonding->io,
1377
G_IO_OUT | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
1378
(GIOFunc) create_bonding_conn_complete,
1379
adapter);
1380
1381
bonding->listener_id = g_dbus_add_disconnect_watch(conn,
1382
dbus_message_get_sender(msg),
1383
create_bond_req_exit, adapter,
1384
NULL);
1385
1386
adapter->bonding = bonding;
1387
1388
return NULL;
1389
}
1390
1391
int start_inquiry(struct btd_adapter *adapter)
1392
{
1393
inquiry_cp cp;
1394
evt_cmd_status rp;
1395
struct hci_request rq;
1396
uint8_t lap[3] = { 0x33, 0x8b, 0x9e };
1397
int dd, err;
1398
1399
pending_remote_name_cancel(adapter);
1400
1401
dd = hci_open_dev(adapter->dev_id);
1402
if (dd < 0)
1403
return dd;
1404
1405
memset(&cp, 0, sizeof(cp));
1406
memcpy(&cp.lap, lap, 3);
1407
cp.length = 0x08;
1408
cp.num_rsp = 0x00;
1409
1410
memset(&rq, 0, sizeof(rq));
1411
rq.ogf = OGF_LINK_CTL;
1412
rq.ocf = OCF_INQUIRY;
1413
rq.cparam = &cp;
1414
rq.clen = INQUIRY_CP_SIZE;
1415
rq.rparam = &rp;
1416
rq.rlen = EVT_CMD_STATUS_SIZE;
1417
rq.event = EVT_CMD_STATUS;
1418
1419
if (hci_send_req(dd, &rq, HCI_REQ_TIMEOUT) < 0) {
1420
err = errno;
1421
error("Unable to start inquiry: %s (%d)",
1422
strerror(err), err);
1423
hci_close_dev(dd);
1424
return -err;
1425
}
1426
1427
if (rp.status) {
1428
err = bt_error(rp.status);
1429
error("HCI_Inquiry command failed with status 0x%02x",
1430
rp.status);
1431
hci_close_dev(dd);
1432
return -err;
1433
}
1434
1435
hci_close_dev(dd);
1436
1437
adapter->state |= RESOLVE_NAME;
1438
1439
return 0;
1440
}
1441
1442
static int start_periodic_inquiry(struct btd_adapter *adapter)
1443
{
1444
periodic_inquiry_cp cp;
1445
struct hci_request rq;
1446
uint8_t lap[3] = { 0x33, 0x8b, 0x9e };
1447
uint8_t status;
1448
int dd, err;
1449
1450
dd = hci_open_dev(adapter->dev_id);
1451
if (dd < 0)
1452
return dd;
1453
1454
memset(&cp, 0, sizeof(cp));
1455
memcpy(&cp.lap, lap, 3);
1456
cp.max_period = htobs(24);
1457
cp.min_period = htobs(16);
1458
cp.length = 0x08;
1459
cp.num_rsp = 0x00;
1460
1461
memset(&rq, 0, sizeof(rq));
1462
rq.ogf = OGF_LINK_CTL;
1463
rq.ocf = OCF_PERIODIC_INQUIRY;
1464
rq.cparam = &cp;
1465
rq.clen = PERIODIC_INQUIRY_CP_SIZE;
1466
rq.rparam = &status;
1467
rq.rlen = sizeof(status);
1468
rq.event = EVT_CMD_COMPLETE;
1469
1470
if (hci_send_req(dd, &rq, HCI_REQ_TIMEOUT) < 0) {
1471
err = errno;
1472
error("Unable to start periodic inquiry: %s (%d)",
1473
strerror(err), err);
1474
hci_close_dev(dd);
1475
return -err;
1476
}
1477
1478
if (status) {
1479
err = bt_error(status);
1480
error("HCI_Periodic_Inquiry_Mode failed with status 0x%02x",
1481
status);
1482
hci_close_dev(dd);
1483
return -err;
1484
}
1485
1486
hci_close_dev(dd);
1487
1488
adapter->state |= RESOLVE_NAME;
1489
1490
return 0;
1491
}
1492
1493
static DBusMessage *adapter_start_discovery(DBusConnection *conn,
1494
DBusMessage *msg, void *data)
1495
{
1496
struct session_req *req;
1497
struct btd_adapter *adapter = data;
1498
int err;
1499
1500
if (!adapter->up)
1501
return adapter_not_ready(msg);
1502
1503
req = find_session(adapter->disc_sessions, msg);
1504
if (req) {
1505
session_ref(req);
1506
return dbus_message_new_method_return(msg);
1507
}
1508
1509
if (adapter->disc_sessions)
1510
goto done;
1511
1512
if (main_opts.inqmode)
1513
err = start_inquiry(adapter);
1514
else
1515
err = start_periodic_inquiry(adapter);
1516
1517
if (err < 0)
1518
return failed_strerror(msg, -err);
1519
1520
done:
1521
req = create_session(adapter, conn, msg, 0,
1522
(GDBusWatchFunction) session_free);
1523
1524
adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
1525
1526
return dbus_message_new_method_return(msg);
1527
}
1528
1529
static DBusMessage *adapter_stop_discovery(DBusConnection *conn,
1530
DBusMessage *msg, void *data)
1531
{
1532
struct btd_adapter *adapter = data;
1533
struct session_req *req;
1534
1535
if (!adapter->up)
1536
return adapter_not_ready(msg);
1537
1538
req = find_session(adapter->disc_sessions, msg);
1539
if (!req)
1540
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
1541
"Invalid discovery session");
1542
1543
session_unref(req);
1544
1545
return dbus_message_new_method_return(msg);
1546
}
1547
1548
struct remote_device_list_t {
1549
GSList *list;
1550
time_t time;
1551
};
1552
1553
static DBusMessage *get_properties(DBusConnection *conn,
1554
DBusMessage *msg, void *data)
1555
{
1556
struct btd_adapter *adapter = data;
1557
const char *property;
1558
DBusMessage *reply;
1559
DBusMessageIter iter;
1560
DBusMessageIter dict;
1561
char str[249], srcaddr[18];
1562
gboolean value;
1563
char **devices;
1564
int i;
1565
GSList *l;
1566
1567
ba2str(&adapter->bdaddr, srcaddr);
1568
1569
if (check_address(srcaddr) < 0)
1570
return adapter_not_ready(msg);
1571
1572
reply = dbus_message_new_method_return(msg);
1573
if (!reply)
1574
return NULL;
1575
1576
dbus_message_iter_init_append(reply, &iter);
1577
1578
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1579
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1580
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
1581
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
1582
1583
/* Address */
1584
property = srcaddr;
1585
dbus_message_iter_append_dict_entry(&dict, "Address",
1586
DBUS_TYPE_STRING, &property);
1587
1588
/* Name */
1589
memset(str, 0, sizeof(str));
1590
strncpy(str, (char *) adapter->dev.name, 248);
1591
property = str;
1592
1593
dbus_message_iter_append_dict_entry(&dict, "Name",
1594
DBUS_TYPE_STRING, &property);
1595
1596
/* Mode */
1597
property = mode2str(adapter->mode);
1598
1599
dbus_message_iter_append_dict_entry(&dict, "Mode",
1600
DBUS_TYPE_STRING, &property);
1601
1602
/* Powered */
1603
if (main_opts.offmode == HCID_OFFMODE_DEVDOWN)
1604
value = adapter->up ? TRUE : FALSE;
1605
else
1606
value = adapter->scan_mode == SCAN_DISABLED ? FALSE : TRUE;
1607
dbus_message_iter_append_dict_entry(&dict, "Powered",
1608
DBUS_TYPE_BOOLEAN, &value);
1609
1610
/* Discoverable */
1611
value = adapter->scan_mode & SCAN_INQUIRY ? TRUE : FALSE;
1612
dbus_message_iter_append_dict_entry(&dict, "Discoverable",
1613
DBUS_TYPE_BOOLEAN, &value);
1614
1615
/* DiscoverableTimeout */
1616
dbus_message_iter_append_dict_entry(&dict, "DiscoverableTimeout",
1617
DBUS_TYPE_UINT32, &adapter->discov_timeout);
1618
1619
if (adapter->state & PERIODIC_INQUIRY || adapter->state & STD_INQUIRY)
1620
value = TRUE;
1621
else
1622
value = FALSE;
1623
1624
/* Discovering */
1625
dbus_message_iter_append_dict_entry(&dict, "Discovering",
1626
DBUS_TYPE_BOOLEAN, &value);
1627
1628
/* Devices */
1629
devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
1630
for (i = 0, l = adapter->devices; l; l = l->next, i++) {
1631
struct btd_device *dev = l->data;
1632
devices[i] = (char *) device_get_path(dev);
1633
}
1634
dbus_message_iter_append_dict_entry(&dict, "Devices",
1635
DBUS_TYPE_ARRAY, &devices);
1636
g_free(devices);
1637
1638
dbus_message_iter_close_container(&iter, &dict);
1639
1640
return reply;
1641
}
1642
1643
static DBusMessage *set_property(DBusConnection *conn,
1644
DBusMessage *msg, void *data)
1645
{
1646
struct btd_adapter *adapter = data;
1647
DBusMessageIter iter;
1648
DBusMessageIter sub;
1649
const char *property;
1650
char srcaddr[18];
1651
1652
ba2str(&adapter->bdaddr, srcaddr);
1653
1654
if (!dbus_message_iter_init(msg, &iter))
1655
return invalid_args(msg);
1656
1657
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
1658
return invalid_args(msg);
1659
1660
dbus_message_iter_get_basic(&iter, &property);
1661
dbus_message_iter_next(&iter);
1662
1663
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
1664
return invalid_args(msg);
1665
dbus_message_iter_recurse(&iter, &sub);
1666
1667
if (g_str_equal("Name", property)) {
1668
const char *name;
1669
1670
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)
1671
return invalid_args(msg);
1672
dbus_message_iter_get_basic(&sub, &name);
1673
1674
return set_name(conn, msg, name, data);
1675
} else if (g_str_equal("Mode", property)) {
1676
const char *mode;
1677
1678
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)
1679
return invalid_args(msg);
1680
1681
dbus_message_iter_get_basic(&sub, &mode);
1682
1683
adapter->global_mode = get_mode(&adapter->bdaddr, mode);
1684
1685
if (adapter->global_mode == adapter->mode)
1686
return dbus_message_new_method_return(msg);
1687
1688
if (adapter->mode_sessions && adapter->global_mode < adapter->mode)
1689
return confirm_mode(conn, msg, mode, data);
1690
1691
return set_mode(conn, msg,
1692
get_mode(&adapter->bdaddr, mode), data);
1693
} else if (g_str_equal("Powered", property)) {
1694
gboolean powered;
1695
1696
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1697
return invalid_args(msg);
1698
1699
dbus_message_iter_get_basic(&sub, &powered);
1700
1701
return set_powered(conn, msg, powered, data);
1702
} else if (g_str_equal("Discoverable", property)) {
1703
gboolean discoverable;
1704
1705
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1706
return invalid_args(msg);
1707
1708
dbus_message_iter_get_basic(&sub, &discoverable);
1709
1710
return set_discoverable(conn, msg, discoverable, data);
1711
} else if (g_str_equal("DiscoverableTimeout", property)) {
1712
uint32_t timeout;
1713
1714
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
1715
return invalid_args(msg);
1716
1717
dbus_message_iter_get_basic(&sub, &timeout);
1718
1719
return set_discoverable_timeout(conn, msg, timeout, data);
1720
}
1721
1722
return invalid_args(msg);
1723
}
1724
1725
static DBusMessage *mode_request(DBusConnection *conn,
1726
DBusMessage *msg, const char *mode,
1727
void *data)
1728
{
1729
struct btd_adapter *adapter = data;
1730
struct session_req *req;
1731
uint8_t new_mode;
1732
int ret;
1733
char srcaddr[18];
1734
1735
ba2str(&adapter->bdaddr, srcaddr);
1736
1737
new_mode = get_mode(&adapter->bdaddr, mode);
1738
if (new_mode != MODE_CONNECTABLE && new_mode != MODE_DISCOVERABLE)
1739
return invalid_args(msg);
1740
1741
if (!adapter->agent)
1742
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
1743
"No agent registered");
1744
1745
if (!adapter->mode_sessions)
1746
adapter->global_mode = adapter->mode;
1747
1748
req = find_session(adapter->mode_sessions, msg);
1749
if (!req) {
1750
req = create_session(adapter, conn, msg, new_mode,
1751
(GDBusWatchFunction) session_free);
1752
adapter->mode_sessions = g_slist_append(adapter->mode_sessions,
1753
req);
1754
} else {
1755
req->mode = new_mode;
1756
adapter->mode_sessions = g_slist_append(adapter->mode_sessions,
1757
req);
1758
session_remove(req);
1759
return dbus_message_new_method_return(msg);
1760
}
1761
1762
/* No need to change mode */
1763
if (adapter->mode >= new_mode)
1764
return dbus_message_new_method_return(msg);
1765
1766
ret = agent_confirm_mode_change(adapter->agent, mode, confirm_mode_cb,
1767
req);
1768
if (ret < 0) {
1769
session_unref(req);
1770
return invalid_args(msg);
1771
}
1772
1773
return NULL;
1774
}
1775
1776
static DBusMessage *request_mode(DBusConnection *conn,
1777
DBusMessage *msg, void *data)
1778
{
1779
const char *mode;
1780
1781
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &mode,
1782
DBUS_TYPE_INVALID))
1783
return invalid_args(msg);
1784
1785
return mode_request(conn, msg, mode, data);
1786
}
1787
1788
static DBusMessage *request_session(DBusConnection *conn,
1789
DBusMessage *msg, void *data)
1790
{
1791
return mode_request(conn, msg, "connectable", data);
1792
}
1793
1794
static DBusMessage *release_session(DBusConnection *conn,
1795
DBusMessage *msg, void *data)
1796
{
1797
struct btd_adapter *adapter = data;
1798
struct session_req *req;
1799
1800
req = find_session(adapter->mode_sessions, msg);
1801
if (!req)
1802
return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
1803
"No Mode to release");
1804
1805
session_unref(req);
1806
1807
return dbus_message_new_method_return(msg);
1808
}
1809
1810
static DBusMessage *list_devices(DBusConnection *conn,
1811
DBusMessage *msg, void *data)
1812
{
1813
struct btd_adapter *adapter = data;
1814
DBusMessage *reply;
1815
GSList *l;
1816
DBusMessageIter iter;
1817
DBusMessageIter array_iter;
1818
const gchar *dev_path;
1819
1820
if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
1821
return invalid_args(msg);
1822
1823
reply = dbus_message_new_method_return(msg);
1824
if (!reply)
1825
return NULL;
1826
1827
dbus_message_iter_init_append(reply, &iter);
1828
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
1829
DBUS_TYPE_OBJECT_PATH_AS_STRING, &array_iter);
1830
1831
for (l = adapter->devices; l; l = l->next) {
1832
struct btd_device *device = l->data;
1833
1834
if (device_is_temporary(device))
1835
continue;
1836
1837
dev_path = device_get_path(device);
1838
1839
dbus_message_iter_append_basic(&array_iter,
1840
DBUS_TYPE_OBJECT_PATH, &dev_path);
1841
}
1842
1843
dbus_message_iter_close_container(&iter, &array_iter);
1844
1845
return reply;
1846
}
1847
1848
static DBusMessage *cancel_device_creation(DBusConnection *conn,
1849
DBusMessage *msg, void *data)
1850
{
1851
struct btd_adapter *adapter = data;
1852
struct bonding_request_info *bonding = adapter->bonding;
1853
const gchar *address;
1854
bdaddr_t bda;
1855
1856
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1857
DBUS_TYPE_INVALID) == FALSE)
1858
return invalid_args(msg);
1859
1860
if (check_address(address) < 0)
1861
return invalid_args(msg);
1862
1863
str2ba(address, &bda);
1864
1865
if (bonding && !bacmp(&bonding->bdaddr, &bda)) {
1866
if (!g_str_equal(dbus_message_get_sender(msg),
1867
dbus_message_get_sender(bonding->msg)))
1868
return not_authorized(msg);
1869
1870
debug("Canceling device creation for %s", address);
1871
cancel_bonding(adapter, FALSE);
1872
}
1873
1874
return dbus_message_new_method_return(msg);
1875
}
1876
1877
static DBusMessage *create_device(DBusConnection *conn,
1878
DBusMessage *msg, void *data)
1879
{
1880
struct btd_adapter *adapter = data;
1881
struct btd_device *device;
1882
const gchar *address;
1883
1884
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1885
DBUS_TYPE_INVALID) == FALSE)
1886
return invalid_args(msg);
1887
1888
if (check_address(address) < 0)
1889
return invalid_args(msg);
1890
1891
if (adapter_find_device(adapter, address))
1892
return g_dbus_create_error(msg,
1893
ERROR_INTERFACE ".AlreadyExists",
1894
"Device already exists");
1895
1896
debug("create_device(%s)", address);
1897
1898
device = device_create(conn, adapter, address);
1899
if (!device)
1900
return NULL;
1901
1902
device_set_temporary(device, FALSE);
1903
1904
device_browse(device, conn, msg, NULL);
1905
1906
adapter->devices = g_slist_append(adapter->devices, device);
1907
1908
return NULL;
1909
}
1910
1911
static uint8_t parse_io_capability(const char *capability)
1912
{
1913
if (g_str_equal(capability, ""))
1914
return IO_CAPABILITY_DISPLAYYESNO;
1915
if (g_str_equal(capability, "DisplayOnly"))
1916
return IO_CAPABILITY_DISPLAYONLY;
1917
if (g_str_equal(capability, "DisplayYesNo"))
1918
return IO_CAPABILITY_DISPLAYYESNO;
1919
if (g_str_equal(capability, "KeyboardOnly"))
1920
return IO_CAPABILITY_KEYBOARDONLY;
1921
if (g_str_equal(capability, "NoInputOutput"))
1922
return IO_CAPABILITY_NOINPUTOUTPUT;
1923
return IO_CAPABILITY_INVALID;
1924
}
1925
1926
static DBusMessage *create_paired_device(DBusConnection *conn,
1927
DBusMessage *msg, void *data)
1928
{
1929
const gchar *address, *agent_path, *capability;
1930
uint8_t cap;
1931
1932
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1933
DBUS_TYPE_OBJECT_PATH, &agent_path,
1934
DBUS_TYPE_STRING, &capability,
1935
DBUS_TYPE_INVALID) == FALSE)
1936
return invalid_args(msg);
1937
1938
if (check_address(address) < 0)
1939
return invalid_args(msg);
1940
1941
cap = parse_io_capability(capability);
1942
if (cap == IO_CAPABILITY_INVALID)
1943
return invalid_args(msg);
1944
1945
return create_bonding(conn, msg, address, agent_path, cap, data);
1946
}
1947
1948
static gint device_path_cmp(struct btd_device *device, const gchar *path)
1949
{
1950
const gchar *dev_path = device_get_path(device);
1951
1952
return strcasecmp(dev_path, path);
1953
}
1954
1955
static DBusMessage *remove_device(DBusConnection *conn,
1956
DBusMessage *msg, void *data)
1957
{
1958
struct btd_adapter *adapter = data;
1959
struct btd_device *device;
1960
const char *path;
1961
GSList *l;
1962
1963
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
1964
DBUS_TYPE_INVALID) == FALSE)
1965
return invalid_args(msg);
1966
1967
l = g_slist_find_custom(adapter->devices,
1968
path, (GCompareFunc) device_path_cmp);
1969
if (!l)
1970
return g_dbus_create_error(msg,
1971
ERROR_INTERFACE ".DoesNotExist",
1972
"Device does not exist");
1973
device = l->data;
1974
1975
if (device_is_temporary(device) || device_is_busy(device))
1976
return g_dbus_create_error(msg,
1977
ERROR_INTERFACE ".DoesNotExist",
1978
"Device creation in progress");
1979
1980
adapter_remove_device(conn, adapter, device);
1981
1982
return dbus_message_new_method_return(msg);
1983
}
1984
1985
static DBusMessage *find_device(DBusConnection *conn,
1986
DBusMessage *msg, void *data)
1987
{
1988
struct btd_adapter *adapter = data;
1989
struct btd_device *device;
1990
DBusMessage *reply;
1991
const gchar *address;
1992
GSList *l;
1993
const gchar *dev_path;
1994
1995
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &address,
1996
DBUS_TYPE_INVALID))
1997
return invalid_args(msg);
1998
1999
l = g_slist_find_custom(adapter->devices,
2000
address, (GCompareFunc) device_address_cmp);
2001
if (!l)
2002
return g_dbus_create_error(msg,
2003
ERROR_INTERFACE ".DoesNotExist",
2004
"Device does not exist");
2005
2006
device = l->data;
2007
2008
if (device_is_temporary(device))
2009
return g_dbus_create_error(msg,
2010
ERROR_INTERFACE ".DoesNotExist",
2011
"Device creation in progress");
2012
2013
reply = dbus_message_new_method_return(msg);
2014
if (!reply)
2015
return NULL;
2016
2017
dev_path = device_get_path(device);
2018
2019
dbus_message_append_args(reply,
2020
DBUS_TYPE_OBJECT_PATH, &dev_path,
2021
DBUS_TYPE_INVALID);
2022
2023
return reply;
2024
}
2025
2026
static void agent_removed(struct agent *agent, struct btd_adapter *adapter)
2027
{
2028
struct pending_auth_info *auth;
2029
GSList *l;
2030
2031
adapter->agent = NULL;
2032
2033
l = g_slist_find_custom(adapter->auth_reqs, agent,
2034
auth_info_agent_cmp);
2035
if (!l)
2036
return;
2037
2038
auth = l->data;
2039
auth->agent = NULL;
2040
}
2041
2042
static DBusMessage *register_agent(DBusConnection *conn,
2043
DBusMessage *msg, void *data)
2044
{
2045
const char *path, *name, *capability;
2046
struct agent *agent;
2047
struct btd_adapter *adapter = data;
2048
uint8_t cap;
2049
2050
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
2051
DBUS_TYPE_STRING, &capability, DBUS_TYPE_INVALID))
2052
return NULL;
2053
2054
if (adapter->agent)
2055
return g_dbus_create_error(msg,
2056
ERROR_INTERFACE ".AlreadyExists",
2057
"Agent already exists");
2058
2059
cap = parse_io_capability(capability);
2060
if (cap == IO_CAPABILITY_INVALID)
2061
return invalid_args(msg);
2062
2063
name = dbus_message_get_sender(msg);
2064
2065
agent = agent_create(adapter, name, path, cap,
2066
(agent_remove_cb) agent_removed, adapter);
2067
if (!agent)
2068
return g_dbus_create_error(msg,
2069
ERROR_INTERFACE ".Failed",
2070
"Failed to create a new agent");
2071
2072
adapter->agent = agent;
2073
2074
debug("Agent registered for hci%d at %s:%s", adapter->dev_id, name,
2075
path);
2076
2077
return dbus_message_new_method_return(msg);
2078
}
2079
2080
static DBusMessage *unregister_agent(DBusConnection *conn,
2081
DBusMessage *msg, void *data)
2082
{
2083
const char *path, *name;
2084
struct btd_adapter *adapter = data;
2085
2086
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
2087
DBUS_TYPE_INVALID))
2088
return NULL;
2089
2090
name = dbus_message_get_sender(msg);
2091
2092
if (!adapter->agent || !agent_matches(adapter->agent, name, path))
2093
return g_dbus_create_error(msg,
2094
ERROR_INTERFACE ".DoesNotExist",
2095
"No such agent");
2096
2097
agent_destroy(adapter->agent, FALSE);
2098
adapter->agent = NULL;
2099
2100
return dbus_message_new_method_return(msg);
2101
}
2102
2103
/* BlueZ 4.0 API */
2104
static GDBusMethodTable adapter_methods[] = {
2105
{ "GetProperties", "", "a{sv}",get_properties },
2106
{ "SetProperty", "sv", "", set_property,
2107
G_DBUS_METHOD_FLAG_ASYNC},
2108
{ "RequestMode", "s", "", request_mode,
2109
G_DBUS_METHOD_FLAG_ASYNC |
2110
G_DBUS_METHOD_FLAG_DEPRECATED},
2111
{ "ReleaseMode", "", "", release_session,
2112
G_DBUS_METHOD_FLAG_DEPRECATED},
2113
{ "RequestSession", "", "", request_session,
2114
G_DBUS_METHOD_FLAG_ASYNC},
2115
{ "ReleaseSession", "", "", release_session },
2116
{ "StartDiscovery", "", "", adapter_start_discovery },
2117
{ "StopDiscovery", "", "", adapter_stop_discovery,
2118
G_DBUS_METHOD_FLAG_ASYNC},
2119
{ "ListDevices", "", "ao", list_devices,
2120
G_DBUS_METHOD_FLAG_DEPRECATED},
2121
{ "CreateDevice", "s", "o", create_device,
2122
G_DBUS_METHOD_FLAG_ASYNC},
2123
{ "CreatePairedDevice", "sos", "o", create_paired_device,
2124
G_DBUS_METHOD_FLAG_ASYNC},
2125
{ "CancelDeviceCreation","s", "", cancel_device_creation },
2126
{ "RemoveDevice", "o", "", remove_device },
2127
{ "FindDevice", "s", "o", find_device },
2128
{ "RegisterAgent", "os", "", register_agent },
2129
{ "UnregisterAgent", "o", "", unregister_agent },
2130
{ }
2131
};
2132
2133
static GDBusSignalTable adapter_signals[] = {
2134
{ "DeviceCreated", "o" },
2135
{ "DeviceRemoved", "o" },
2136
{ "DeviceFound", "sa{sv}" },
2137
{ "PropertyChanged", "sv" },
2138
{ "DeviceDisappeared", "s" },
2139
{ }
2140
};
2141
2142
static inline uint8_t get_inquiry_mode(struct hci_dev *dev)
2143
{
2144
if (dev->features[6] & LMP_EXT_INQ)
2145
return 2;
2146
2147
if (dev->features[3] & LMP_RSSI_INQ)
2148
return 1;
2149
2150
if (dev->manufacturer == 11 &&
2151
dev->hci_rev == 0x00 && dev->lmp_subver == 0x0757)
2152
return 1;
2153
2154
if (dev->manufacturer == 15) {
2155
if (dev->hci_rev == 0x03 && dev->lmp_subver == 0x6963)
2156
return 1;
2157
if (dev->hci_rev == 0x09 && dev->lmp_subver == 0x6963)
2158
return 1;
2159
if (dev->hci_rev == 0x00 && dev->lmp_subver == 0x6965)
2160
return 1;
2161
}
2162
2163
if (dev->manufacturer == 31 &&
2164
dev->hci_rev == 0x2005 && dev->lmp_subver == 0x1805)
2165
return 1;
2166
2167
return 0;
2168
}
2169
2170
static int adapter_read_bdaddr(uint16_t dev_id, bdaddr_t *bdaddr)
2171
{
2172
int dd, err;
2173
2174
dd = hci_open_dev(dev_id);
2175
if (dd < 0) {
2176
err = errno;
2177
error("Can't open device hci%d: %s (%d)",
2178
dev_id, strerror(err), err);
2179
return -err;
2180
}
2181
2182
if (hci_read_bd_addr(dd, bdaddr, HCI_REQ_TIMEOUT) < 0) {
2183
err = errno;
2184
error("Can't read address for hci%d: %s (%d)",
2185
dev_id, strerror(err), err);
2186
hci_close_dev(dd);
2187
return -err;
2188
}
2189
2190
hci_close_dev(dd);
2191
2192
return 0;
2193
}
2194
2195
static int adapter_setup(struct btd_adapter *adapter, int dd)
2196
{
2197
struct hci_dev *dev = &adapter->dev;
2198
uint8_t events[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00 };
2199
uint8_t inqmode;
2200
int err;
2201
char name[249];
2202
2203
if (dev->hci_rev > 1) {
2204
if (dev->features[5] & LMP_SNIFF_SUBR)
2205
events[5] |= 0x20;
2206
2207
if (dev->features[5] & LMP_PAUSE_ENC)
2208
events[5] |= 0x80;
2209
2210
if (dev->features[6] & LMP_EXT_INQ)
2211
events[5] |= 0x40;
2212
2213
if (dev->features[6] & LMP_NFLUSH_PKTS)
2214
events[7] |= 0x01;
2215
2216
if (dev->features[7] & LMP_LSTO)
2217
events[6] |= 0x80;
2218
2219
if (dev->features[6] & LMP_SIMPLE_PAIR) {
2220
events[6] |= 0x01; /* IO Capability Request */
2221
events[6] |= 0x02; /* IO Capability Response */
2222
events[6] |= 0x04; /* User Confirmation Request */
2223
events[6] |= 0x08; /* User Passkey Request */
2224
events[6] |= 0x10; /* Remote OOB Data Request */
2225
events[6] |= 0x20; /* Simple Pairing Complete */
2226
events[7] |= 0x04; /* User Passkey Notification */
2227
events[7] |= 0x08; /* Keypress Notification */
2228
events[7] |= 0x10; /* Remote Host Supported Features Notification */
2229
}
2230
2231
hci_send_cmd(dd, OGF_HOST_CTL, OCF_SET_EVENT_MASK,
2232
sizeof(events), events);
2233
}
2234
2235
if (read_local_name(&adapter->bdaddr, name) == 0) {
2236
memcpy(dev->name, name, 248);
2237
hci_write_local_name(dd, name, HCI_REQ_TIMEOUT);
2238
}
2239
2240
update_ext_inquiry_response(dd, dev);
2241
2242
inqmode = get_inquiry_mode(dev);
2243
if (inqmode < 1)
2244
return 0;
2245
2246
if (hci_write_inquiry_mode(dd, inqmode, HCI_REQ_TIMEOUT) < 0) {
2247
err = errno;
2248
error("Can't write inquiry mode for %s: %s (%d)",
2249
adapter->path, strerror(err), err);
2250
hci_close_dev(dd);
2251
return -err;
2252
}
2253
2254
return 0;
2255
}
2256
2257
static int active_conn_append(GSList **list, bdaddr_t *bdaddr,
2258
uint16_t handle)
2259
{
2260
struct active_conn_info *dev;
2261
2262
dev = g_new0(struct active_conn_info, 1);
2263
2264
bacpy(&dev->bdaddr, bdaddr);
2265
dev->handle = handle;
2266
2267
*list = g_slist_append(*list, dev);
2268
return 0;
2269
}
2270
2271
static void create_stored_device_from_profiles(char *key, char *value,
2272
void *user_data)
2273
{
2274
struct btd_adapter *adapter = user_data;
2275
GSList *uuids = bt_string2list(value);
2276
struct btd_device *device;
2277
sdp_list_t *records;
2278
bdaddr_t dst;
2279
char srcaddr[18], dstaddr[18];
2280
2281
ba2str(&adapter->bdaddr, srcaddr);
2282
2283
if (g_slist_find_custom(adapter->devices,
2284
key, (GCompareFunc) device_address_cmp))
2285
return;
2286
2287
device = device_create(connection, adapter, key);
2288
if (!device)
2289
return;
2290
2291
device_set_temporary(device, FALSE);
2292
adapter->devices = g_slist_append(adapter->devices, device);
2293
2294
device_get_address(device, &dst);
2295
ba2str(&dst, dstaddr);
2296
2297
records = read_records(srcaddr, dstaddr);
2298
2299
device_probe_drivers(device, uuids, records);
2300
2301
if (records)
2302
sdp_list_free(records, (sdp_free_func_t) sdp_record_free);
2303
2304
g_slist_free(uuids);
2305
}
2306
2307
static void create_stored_device_from_linkkeys(char *key, char *value,
2308
void *user_data)
2309
{
2310
struct btd_adapter *adapter = user_data;
2311
struct btd_device *device;
2312
2313
if (g_slist_find_custom(adapter->devices,
2314
key, (GCompareFunc) device_address_cmp))
2315
return;
2316
2317
device = device_create(connection, adapter, key);
2318
if (device) {
2319
device_set_temporary(device, FALSE);
2320
adapter->devices = g_slist_append(adapter->devices, device);
2321
}
2322
}
2323
2324
static void load_devices(struct btd_adapter *adapter)
2325
{
2326
char filename[PATH_MAX + 1];
2327
char srcaddr[18];
2328
2329
ba2str(&adapter->bdaddr, srcaddr);
2330
2331
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "profiles");
2332
textfile_foreach(filename, create_stored_device_from_profiles, adapter);
2333
2334
create_name(filename, PATH_MAX, STORAGEDIR, srcaddr, "linkkeys");
2335
textfile_foreach(filename, create_stored_device_from_linkkeys, adapter);
2336
}
2337
2338
static void load_drivers(struct btd_adapter *adapter)
2339
{
2340
GSList *l;
2341
2342
for (l = adapter_drivers; l; l = l->next) {
2343
struct btd_adapter_driver *driver = l->data;
2344
2345
if (driver->probe)
2346
driver->probe(adapter);
2347
}
2348
}
2349
2350
static int get_discoverable_timeout(const char *src)
2351
{
2352
int timeout;
2353
2354
if (read_discoverable_timeout(src, &timeout) == 0)
2355
return timeout;
2356
2357
return main_opts.discovto;
2358
}
2359
2360
static void adapter_up(struct btd_adapter *adapter, int dd)
2361
{
2362
struct hci_conn_list_req *cl = NULL;
2363
struct hci_conn_info *ci;
2364
const char *pmode;
2365
char mode[14], srcaddr[18];
2366
int i;
2367
gboolean powered;
2368
gboolean discoverable;
2369
2370
ba2str(&adapter->bdaddr, srcaddr);
2371
2372
adapter->up = 1;
2373
adapter->discov_timeout = get_discoverable_timeout(srcaddr);
2374
adapter->state = DISCOVER_TYPE_NONE;
2375
2376
/* Set scan mode */
2377
if (read_device_mode(srcaddr, mode, sizeof(mode)) == 0) {
2378
if (!strcmp(mode, "off")) {
2379
if (main_opts.offmode == HCID_OFFMODE_NOSCAN) {
2380
adapter->mode = MODE_OFF;
2381
adapter->scan_mode= SCAN_DISABLED;
2382
} else if (main_opts.offmode == HCID_OFFMODE_DEVDOWN) {
2383
static gboolean restore_on_mode = FALSE;
2384
2385
if (!restore_on_mode) {
2386
ioctl(dd, HCIDEVDOWN, adapter->dev_id);
2387
restore_on_mode = TRUE;
2388
return;
2389
}
2390
2391
if (read_on_mode(srcaddr, mode, sizeof(mode)) < 0)
2392
write_device_mode(&adapter->bdaddr, mode);
2393
else
2394
write_device_mode(&adapter->bdaddr, "connectable");
2395
2396
adapter_up(adapter, dd);
2397
}
2398
} else if (!strcmp(mode, "connectable")) {
2399
adapter->mode = MODE_CONNECTABLE;
2400
adapter->scan_mode = SCAN_PAGE;
2401
} else if (!strcmp(mode, "discoverable")) {
2402
/* Set discoverable only if timeout is 0 */
2403
if (adapter->discov_timeout == 0) {
2404
adapter->mode = MODE_DISCOVERABLE;
2405
adapter->scan_mode = SCAN_PAGE | SCAN_INQUIRY;
2406
} else {
2407
adapter->mode = MODE_CONNECTABLE;
2408
adapter->scan_mode = SCAN_PAGE;
2409
}
2410
} else if (!strcmp(mode, "limited")) {
2411
/* Set discoverable only if timeout is 0 */
2412
if (adapter->discov_timeout == 0) {
2413
adapter->mode = MODE_LIMITED;
2414
adapter->scan_mode = SCAN_PAGE | SCAN_INQUIRY;
2415
} else {
2416
adapter->mode = MODE_CONNECTABLE;
2417
adapter->scan_mode = SCAN_PAGE;
2418
2419
}
2420
}
2421
}
2422
2423
hci_send_cmd(dd, OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE,
2424
1, &adapter->scan_mode);
2425
2426
if (adapter->mode == MODE_LIMITED)
2427
set_limited_discoverable(dd, adapter->dev.class, TRUE);
2428
2429
/*
2430
* retrieve the active connections: address the scenario where
2431
* the are active connections before the daemon've started
2432
*/
2433
2434
cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl));
2435
2436
cl->dev_id = adapter->dev_id;
2437
cl->conn_num = 10;
2438
ci = cl->conn_info;
2439
2440
if (ioctl(dd, HCIGETCONNLIST, cl) == 0) {
2441
for (i = 0; i < cl->conn_num; i++, ci++)
2442
active_conn_append(&adapter->active_conn,
2443
&ci->bdaddr, ci->handle);
2444
}
2445
g_free(cl);
2446
2447
pmode = mode2str(adapter->mode);
2448
2449
dbus_connection_emit_property_changed(connection, adapter->path,
2450
ADAPTER_INTERFACE, "Mode",
2451
DBUS_TYPE_STRING, &pmode);
2452
2453
powered = adapter->scan_mode == SCAN_DISABLED ? FALSE : TRUE;
2454
2455
dbus_connection_emit_property_changed(connection, adapter->path,
2456
ADAPTER_INTERFACE, "Powered",
2457
DBUS_TYPE_BOOLEAN, &powered);
2458
2459
discoverable = adapter->scan_mode == (SCAN_PAGE | SCAN_INQUIRY) ? TRUE
2460
: FALSE;
2461
2462
dbus_connection_emit_property_changed(connection, adapter->path,
2463
ADAPTER_INTERFACE, "Discoverable",
2464
DBUS_TYPE_BOOLEAN, &discoverable);
2465
2466
load_drivers(adapter);
2467
load_devices(adapter);
2468
}
2469
2470
int adapter_start(struct btd_adapter *adapter)
2471
{
2472
struct hci_dev *dev = &adapter->dev;
2473
struct hci_dev_info di;
2474
struct hci_version ver;
2475
uint8_t features[8];
2476
int dd, err;
2477
char name[249];
2478
2479
if (hci_devinfo(adapter->dev_id, &di) < 0)
2480
return -errno;
2481
2482
if (hci_test_bit(HCI_RAW, &di.flags)) {
2483
dev->ignore = 1;
2484
return -1;
2485
}
2486
2487
if (!bacmp(&di.bdaddr, BDADDR_ANY)) {
2488
int err;
2489
2490
debug("Adapter %s without an address", adapter->path);
2491
2492
err = adapter_read_bdaddr(adapter->dev_id, &di.bdaddr);
2493
if (err < 0)
2494
return err;
2495
}
2496
2497
bacpy(&adapter->bdaddr, &di.bdaddr);
2498
memcpy(dev->features, di.features, 8);
2499
2500
dd = hci_open_dev(adapter->dev_id);
2501
if (dd < 0) {
2502
err = errno;
2503
error("Can't open adapter %s: %s (%d)",
2504
adapter->path, strerror(err), err);
2505
return -err;
2506
}
2507
2508
if (hci_read_local_version(dd, &ver, HCI_REQ_TIMEOUT) < 0) {
2509
err = errno;
2510
error("Can't read version info for %s: %s (%d)",
2511
adapter->path, strerror(err), err);
2512
hci_close_dev(dd);
2513
return -err;
2514
}
2515
2516
dev->hci_rev = ver.hci_rev;
2517
dev->lmp_ver = ver.lmp_ver;
2518
dev->lmp_subver = ver.lmp_subver;
2519
dev->manufacturer = ver.manufacturer;
2520
2521
if (hci_read_local_features(dd, features, HCI_REQ_TIMEOUT) < 0) {
2522
err = errno;
2523
error("Can't read features for %s: %s (%d)",
2524
adapter->path, strerror(err), err);
2525
hci_close_dev(dd);
2526
return -err;
2527
}
2528
2529
memcpy(dev->features, features, 8);
2530
2531
if (hci_read_class_of_dev(dd, dev->class, HCI_REQ_TIMEOUT) < 0) {
2532
err = errno;
2533
error("Can't read class of adapter on %s: %s (%d)",
2534
adapter->path, strerror(err), err);
2535
hci_close_dev(dd);
2536
return -err;
2537
}
2538
2539
if (hci_read_local_name(dd, sizeof(name), name, HCI_REQ_TIMEOUT) < 0) {
2540
err = errno;
2541
error("Can't read local name on %s: %s (%d)",
2542
adapter->path, strerror(err), err);
2543
hci_close_dev(dd);
2544
return -err;
2545
}
2546
2547
memcpy(dev->name, name, 248);
2548
2549
if (!(features[6] & LMP_SIMPLE_PAIR))
2550
goto setup;
2551
2552
if (ioctl(dd, HCIGETAUTHINFO, NULL) < 0 && errno != EINVAL)
2553
hci_write_simple_pairing_mode(dd, 0x01, HCI_REQ_TIMEOUT);
2554
2555
if (hci_read_simple_pairing_mode(dd, &dev->ssp_mode,
2556
HCI_REQ_TIMEOUT) < 0) {
2557
err = errno;
2558
error("Can't read simple pairing mode on %s: %s (%d)",
2559
adapter->path, strerror(err), err);
2560
hci_close_dev(dd);
2561
return -err;
2562
}
2563
2564
setup:
2565
hci_send_cmd(dd, OGF_LINK_POLICY,
2566
OCF_READ_DEFAULT_LINK_POLICY, 0, NULL);
2567
2568
if (hci_test_bit(HCI_INQUIRY, &di.flags))
2569
adapter->state |= STD_INQUIRY;
2570
else
2571
adapter->state &= ~STD_INQUIRY;
2572
2573
adapter_setup(adapter, dd);
2574
adapter_up(adapter, dd);
2575
2576
hci_close_dev(dd);
2577
2578
info("Adapter %s has been enabled", adapter->path);
2579
2580
return 0;
2581
}
2582
2583
static void reply_pending_requests(struct btd_adapter *adapter)
2584
{
2585
DBusMessage *reply;
2586
2587
if (!adapter)
2588
return;
2589
2590
/* pending bonding */
2591
if (adapter->bonding) {
2592
reply = new_authentication_return(adapter->bonding->msg,
2593
HCI_OE_USER_ENDED_CONNECTION);
2594
g_dbus_send_message(connection, reply);
2595
remove_pending_device(adapter);
2596
2597
g_dbus_remove_watch(adapter->bonding->conn,
2598
adapter->bonding->listener_id);
2599
2600
if (adapter->bonding->io_id)
2601
g_source_remove(adapter->bonding->io_id);
2602
if (adapter->bonding->io)
2603
g_io_channel_close(adapter->bonding->io);
2604
bonding_request_free(adapter->bonding);
2605
adapter->bonding = NULL;
2606
}
2607
2608
if (adapter->state & STD_INQUIRY) {
2609
/* Cancel inquiry initiated by D-Bus client */
2610
if (adapter->disc_sessions)
2611
cancel_discovery(adapter);
2612
}
2613
2614
if (adapter->state & PERIODIC_INQUIRY) {
2615
/* Stop periodic inquiry initiated by D-Bus client */
2616
if (adapter->disc_sessions)
2617
cancel_periodic_discovery(adapter);
2618
}
2619
}
2620
2621
static void unload_drivers(struct btd_adapter *adapter)
2622
{
2623
GSList *l;
2624
2625
for (l = adapter_drivers; l; l = l->next) {
2626
struct btd_adapter_driver *driver = l->data;
2627
2628
if (driver->remove)
2629
driver->remove(adapter);
2630
}
2631
}
2632
2633
int adapter_stop(struct btd_adapter *adapter)
2634
{
2635
const char *mode = "off";
2636
gboolean powered, discoverable;
2637
2638
/* cancel pending timeout */
2639
if (adapter->discov_timeout_id) {
2640
g_source_remove(adapter->discov_timeout_id);
2641
adapter->discov_timeout_id = 0;
2642
}
2643
2644
/* check pending requests */
2645
reply_pending_requests(adapter);
2646
2647
if (adapter->disc_sessions) {
2648
g_slist_foreach(adapter->disc_sessions, (GFunc) session_free,
2649
NULL);
2650
g_slist_free(adapter->disc_sessions);
2651
adapter->disc_sessions = NULL;
2652
}
2653
2654
if (adapter->found_devices) {
2655
g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL);
2656
g_slist_free(adapter->found_devices);
2657
adapter->found_devices = NULL;
2658
}
2659
2660
if (adapter->oor_devices) {
2661
g_slist_foreach(adapter->oor_devices, (GFunc) free, NULL);
2662
g_slist_free(adapter->oor_devices);
2663
adapter->oor_devices = NULL;
2664
}
2665
2666
if (adapter->auth_reqs) {
2667
g_slist_foreach(adapter->auth_reqs, (GFunc) g_free, NULL);
2668
g_slist_free(adapter->auth_reqs);
2669
adapter->auth_reqs = NULL;
2670
}
2671
2672
if (adapter->active_conn) {
2673
g_slist_foreach(adapter->active_conn, (GFunc) g_free, NULL);
2674
g_slist_free(adapter->active_conn);
2675
adapter->active_conn = NULL;
2676
}
2677
2678
dbus_connection_emit_property_changed(connection, adapter->path,
2679
ADAPTER_INTERFACE, "Mode",
2680
DBUS_TYPE_STRING, &mode);
2681
2682
powered = FALSE;
2683
2684
dbus_connection_emit_property_changed(connection, adapter->path,
2685
ADAPTER_INTERFACE, "Powered",
2686
DBUS_TYPE_BOOLEAN, &powered);
2687
2688
if (adapter->scan_mode == (SCAN_PAGE | SCAN_INQUIRY)) {
2689
discoverable = FALSE;
2690
2691
dbus_connection_emit_property_changed(connection, adapter->path,
2692
ADAPTER_INTERFACE, "Discoverable",
2693
DBUS_TYPE_BOOLEAN, &discoverable);
2694
}
2695
2696
adapter->up = 0;
2697
adapter->scan_mode = SCAN_DISABLED;
2698
adapter->mode = MODE_OFF;
2699
adapter->state = DISCOVER_TYPE_NONE;
2700
2701
unload_drivers(adapter);
2702
2703
info("Adapter %s has been disabled", adapter->path);
2704
2705
return 0;
2706
}
2707
2708
int adapter_update(struct btd_adapter *adapter)
2709
{
2710
struct hci_dev *dev = &adapter->dev;
2711
int dd;
2712
2713
if (dev->ignore)
2714
return 0;
2715
2716
dd = hci_open_dev(adapter->dev_id);
2717
if (dd < 0) {
2718
int err = errno;
2719
error("Can't open adapter %s: %s (%d)",
2720
adapter->path, strerror(err), err);
2721
return -err;
2722
}
2723
2724
update_ext_inquiry_response(dd, dev);
2725
2726
hci_close_dev(dd);
2727
2728
return 0;
2729
}
2730
2731
int adapter_get_class(struct btd_adapter *adapter, uint8_t *cls)
2732
{
2733
struct hci_dev *dev = &adapter->dev;
2734
2735
memcpy(cls, dev->class, 3);
2736
2737
return 0;
2738
}
2739
2740
int adapter_set_class(struct btd_adapter *adapter, uint8_t *cls)
2741
{
2742
struct hci_dev *dev = &adapter->dev;
2743
2744
memcpy(dev->class, cls, 3);
2745
2746
return 0;
2747
}
2748
2749
int adapter_update_ssp_mode(struct btd_adapter *adapter, int dd, uint8_t mode)
2750
{
2751
struct hci_dev *dev = &adapter->dev;
2752
2753
dev->ssp_mode = mode;
2754
2755
update_ext_inquiry_response(dd, dev);
2756
2757
hci_close_dev(dd);
2758
2759
return 0;
2760
}
2761
2762
static void adapter_free(gpointer user_data)
2763
{
2764
struct btd_adapter *adapter = user_data;
2765
2766
agent_destroy(adapter->agent, FALSE);
2767
adapter->agent = NULL;
2768
2769
g_free(adapter->path);
2770
g_free(adapter);
2771
2772
return;
2773
}
2774
2775
struct btd_adapter *adapter_create(DBusConnection *conn, int id)
2776
{
2777
char path[MAX_PATH_LENGTH];
2778
struct btd_adapter *adapter;
2779
2780
if (!connection)
2781
connection = conn;
2782
2783
snprintf(path, sizeof(path), "%s/hci%d", "/org/bluez", id);
2784
2785
adapter = g_try_new0(struct btd_adapter, 1);
2786
if (!adapter) {
2787
error("Failed to alloc memory to D-Bus path register data (%s)",
2788
path);
2789
return NULL;
2790
}
2791
2792
adapter->dev_id = id;
2793
adapter->state |= RESOLVE_NAME;
2794
adapter->path = g_strdup(path);
2795
2796
if (!g_dbus_register_interface(conn, path, ADAPTER_INTERFACE,
2797
adapter_methods, adapter_signals, NULL,
2798
adapter, adapter_free)) {
2799
error("Adapter interface init failed on path %s", path);
2800
adapter_free(adapter);
2801
return NULL;
2802
}
2803
2804
return adapter;
2805
}
2806
2807
void adapter_remove(struct btd_adapter *adapter)
2808
{
2809
GSList *l;
2810
char *path = g_strdup(adapter->path);
2811
2812
debug("Removing adapter %s", path);
2813
2814
for (l = adapter->devices; l; l = l->next)
2815
device_remove(connection, l->data);
2816
g_slist_free(adapter->devices);
2817
2818
g_dbus_unregister_interface(connection, path, ADAPTER_INTERFACE);
2819
2820
g_free(path);
2821
}
2822
2823
uint16_t adapter_get_dev_id(struct btd_adapter *adapter)
2824
{
2825
return adapter->dev_id;
2826
}
2827
2828
const gchar *adapter_get_path(struct btd_adapter *adapter)
2829
{
2830
if (!adapter)
2831
return NULL;
2832
2833
return adapter->path;
2834
}
2835
2836
void adapter_get_address(struct btd_adapter *adapter, bdaddr_t *bdaddr)
2837
{
2838
bacpy(bdaddr, &adapter->bdaddr);
2839
}
2840
2841
static gboolean discov_timeout_handler(void *data)
2842
{
2843
struct btd_adapter *adapter = data;
2844
struct hci_request rq;
2845
int dd;
2846
uint8_t scan_enable = adapter->scan_mode;
2847
uint8_t status = 0;
2848
gboolean retval = TRUE;
2849
uint16_t dev_id = adapter->dev_id;
2850
2851
scan_enable &= ~SCAN_INQUIRY;
2852
2853
dd = hci_open_dev(dev_id);
2854
if (dd < 0) {
2855
error("HCI device open failed: hci%d", dev_id);
2856
return TRUE;
2857
}
2858
2859
memset(&rq, 0, sizeof(rq));
2860
rq.ogf = OGF_HOST_CTL;
2861
rq.ocf = OCF_WRITE_SCAN_ENABLE;
2862
rq.cparam = &scan_enable;
2863
rq.clen = sizeof(scan_enable);
2864
rq.rparam = &status;
2865
rq.rlen = sizeof(status);
2866
rq.event = EVT_CMD_COMPLETE;
2867
2868
if (hci_send_req(dd, &rq, HCI_REQ_TIMEOUT) < 0) {
2869
error("Sending write scan enable command to hci%d failed: %s (%d)",
2870
dev_id, strerror(errno), errno);
2871
goto failed;
2872
}
2873
if (status) {
2874
error("Setting scan enable failed with status 0x%02x", status);
2875
goto failed;
2876
}
2877
2878
set_limited_discoverable(dd, adapter->dev.class, FALSE);
2879
2880
adapter_remove_discov_timeout(adapter);
2881
retval = FALSE;
2882
2883
failed:
2884
if (dd >= 0)
2885
hci_close_dev(dd);
2886
2887
return retval;
2888
}
2889
2890
void adapter_set_discov_timeout(struct btd_adapter *adapter, guint interval)
2891
{
2892
if (!adapter)
2893
return;
2894
2895
if (adapter->discov_timeout_id) {
2896
error("Timeout already added for adapter %s", adapter->path);
2897
return;
2898
}
2899
2900
adapter->discov_timeout_id = g_timeout_add(interval, discov_timeout_handler, adapter);
2901
}
2902
2903
void adapter_remove_discov_timeout(struct btd_adapter *adapter)
2904
{
2905
if (!adapter)
2906
return;
2907
2908
if(adapter->discov_timeout_id == 0)
2909
return;
2910
2911
g_source_remove(adapter->discov_timeout_id);
2912
adapter->discov_timeout_id = 0;
2913
}
2914
2915
void adapter_set_scan_mode(struct btd_adapter *adapter, uint8_t scan_mode)
2916
{
2917
if (!adapter)
2918
return;
2919
2920
adapter->scan_mode = scan_mode;
2921
}
2922
2923
uint8_t adapter_get_scan_mode(struct btd_adapter *adapter)
2924
{
2925
return adapter->scan_mode;
2926
}
2927
2928
void adapter_set_mode(struct btd_adapter *adapter, uint8_t mode)
2929
{
2930
if (!adapter)
2931
return;
2932
2933
adapter->mode = mode;
2934
}
2935
2936
uint8_t adapter_get_mode(struct btd_adapter *adapter)
2937
{
2938
return adapter->mode;
2939
}
2940
2941
void adapter_set_state(struct btd_adapter *adapter, int state)
2942
{
2943
gboolean discov_active = FALSE;
2944
const char *path = adapter->path;
2945
2946
if (adapter->state == state)
2947
return;
2948
2949
if (state & PERIODIC_INQUIRY || state & STD_INQUIRY)
2950
discov_active = TRUE;
2951
else if (adapter->disc_sessions && main_opts.inqmode)
2952
adapter->scheduler_id = g_timeout_add(main_opts.inqmode * 1000,
2953
(GSourceFunc) start_inquiry, adapter);
2954
2955
if (!discov_active && adapter->found_devices) {
2956
g_slist_foreach(adapter->found_devices, (GFunc) g_free, NULL);
2957
g_slist_free(adapter->found_devices);
2958
adapter->found_devices = NULL;
2959
}
2960
2961
if (!discov_active && adapter->oor_devices) {
2962
g_slist_foreach(adapter->oor_devices, (GFunc) g_free, NULL);
2963
g_slist_free(adapter->oor_devices);
2964
adapter->oor_devices = NULL;
2965
}
2966
2967
dbus_connection_emit_property_changed(connection, path,
2968
ADAPTER_INTERFACE, "Discovering",
2969
DBUS_TYPE_BOOLEAN, &discov_active);
2970
2971
adapter->state = state;
2972
}
2973
2974
int adapter_get_state(struct btd_adapter *adapter)
2975
{
2976
return adapter->state;
2977
}
2978
2979
struct remote_dev_info *adapter_search_found_devices(struct btd_adapter *adapter,
2980
struct remote_dev_info *match)
2981
{
2982
GSList *l;
2983
2984
l = g_slist_find_custom(adapter->found_devices, match,
2985
(GCompareFunc) found_device_cmp);
2986
if (l)
2987
return l->data;
2988
2989
return NULL;
2990
}
2991
2992
int dev_rssi_cmp(struct remote_dev_info *d1, struct remote_dev_info *d2)
2993
{
2994
int rssi1, rssi2;
2995
2996
rssi1 = d1->rssi < 0 ? -d1->rssi : d1->rssi;
2997
rssi2 = d2->rssi < 0 ? -d2->rssi : d2->rssi;
2998
2999
return rssi1 - rssi2;
3000
}
3001
3002
int adapter_add_found_device(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3003
int8_t rssi, name_status_t name_status)
3004
{
3005
struct remote_dev_info *dev, match;
3006
3007
memset(&match, 0, sizeof(struct remote_dev_info));
3008
bacpy(&match.bdaddr, bdaddr);
3009
match.name_status = NAME_ANY;
3010
3011
/* ignore repeated entries */
3012
dev = adapter_search_found_devices(adapter, &match);
3013
if (dev) {
3014
/* device found, update the attributes */
3015
if (rssi != 0)
3016
dev->rssi = rssi;
3017
3018
/* Get remote name can be received while inquiring.
3019
* Keep in mind that multiple inquiry result events can
3020
* be received from the same remote device.
3021
*/
3022
if (name_status != NAME_NOT_REQUIRED)
3023
dev->name_status = name_status;
3024
3025
adapter->found_devices = g_slist_sort(adapter->found_devices,
3026
(GCompareFunc) dev_rssi_cmp);
3027
3028
return -EALREADY;
3029
}
3030
3031
dev = g_new0(struct remote_dev_info, 1);
3032
3033
bacpy(&dev->bdaddr, bdaddr);
3034
dev->rssi = rssi;
3035
dev->name_status = name_status;
3036
3037
adapter->found_devices = g_slist_insert_sorted(adapter->found_devices,
3038
dev, (GCompareFunc) dev_rssi_cmp);
3039
3040
return 0;
3041
}
3042
3043
int adapter_remove_found_device(struct btd_adapter *adapter, bdaddr_t *bdaddr)
3044
{
3045
struct remote_dev_info *dev, match;
3046
3047
memset(&match, 0, sizeof(struct remote_dev_info));
3048
bacpy(&match.bdaddr, bdaddr);
3049
3050
dev = adapter_search_found_devices(adapter, &match);
3051
if (!dev)
3052
return -1;
3053
3054
adapter->found_devices = g_slist_remove(adapter->found_devices, dev);
3055
g_free(dev);
3056
3057
return 0;
3058
}
3059
3060
void adapter_update_oor_devices(struct btd_adapter *adapter)
3061
{
3062
GSList *l = adapter->found_devices;
3063
struct remote_dev_info *dev;
3064
bdaddr_t tmp;
3065
3066
send_out_of_range(adapter->path, adapter->oor_devices);
3067
3068
g_slist_foreach(adapter->oor_devices, (GFunc) free, NULL);
3069
g_slist_free(adapter->oor_devices);
3070
adapter->oor_devices = NULL;
3071
3072
while (l) {
3073
dev = l->data;
3074
baswap(&tmp, &dev->bdaddr);
3075
adapter->oor_devices = g_slist_append(adapter->oor_devices,
3076
batostr(&tmp));
3077
l = l->next;
3078
}
3079
}
3080
3081
void adapter_remove_oor_device(struct btd_adapter *adapter, char *peer_addr)
3082
{
3083
GSList *l;
3084
3085
l = g_slist_find_custom(adapter->oor_devices, peer_addr,
3086
(GCompareFunc) strcmp);
3087
if (l) {
3088
char *dev = l->data;
3089
adapter->oor_devices = g_slist_remove(adapter->oor_devices,
3090
dev);
3091
g_free(dev);
3092
}
3093
}
3094
3095
void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
3096
{
3097
const gchar *path = adapter_get_path(adapter);
3098
const char *mode;
3099
gboolean powered, discoverable;
3100
3101
switch (scan_mode) {
3102
case SCAN_DISABLED:
3103
mode = "off";
3104
adapter_set_mode(adapter, MODE_OFF);
3105
powered = FALSE;
3106
discoverable = FALSE;
3107
break;
3108
case SCAN_PAGE:
3109
mode = "connectable";
3110
adapter_set_mode(adapter, MODE_CONNECTABLE);
3111
powered = TRUE;
3112
discoverable = FALSE;
3113
break;
3114
case (SCAN_PAGE | SCAN_INQUIRY):
3115
powered = TRUE;
3116
discoverable = TRUE;
3117
if (adapter_get_mode(adapter) == MODE_LIMITED) {
3118
mode = "limited";
3119
} else {
3120
adapter_set_mode(adapter, MODE_DISCOVERABLE);
3121
mode = "discoverable";
3122
}
3123
if (adapter->discov_timeout != 0)
3124
adapter_set_discov_timeout(adapter,
3125
adapter->discov_timeout * 1000);
3126
break;
3127
case SCAN_INQUIRY:
3128
/* Address the scenario where a low-level application like
3129
* hciconfig changed the scan mode */
3130
if (adapter->discov_timeout != 0)
3131
adapter_set_discov_timeout(adapter,
3132
adapter->discov_timeout * 1000);
3133
3134
/* ignore, this event should not be sent */
3135
default:
3136
/* ignore, reserved */
3137
return;
3138
}
3139
3140
dbus_connection_emit_property_changed(connection, path,
3141
ADAPTER_INTERFACE, "Mode",
3142
DBUS_TYPE_STRING, &mode);
3143
3144
if (powered == FALSE || adapter->scan_mode == SCAN_DISABLED) {
3145
dbus_connection_emit_property_changed(connection, path,
3146
ADAPTER_INTERFACE, "Powered",
3147
DBUS_TYPE_BOOLEAN, &powered);
3148
}
3149
3150
dbus_connection_emit_property_changed(connection, path,
3151
ADAPTER_INTERFACE, "Discoverable",
3152
DBUS_TYPE_BOOLEAN, &discoverable);
3153
3154
adapter_set_scan_mode(adapter, scan_mode);
3155
}
3156
3157
struct agent *adapter_get_agent(struct btd_adapter *adapter)
3158
{
3159
if (!adapter || !adapter->agent)
3160
return NULL;
3161
3162
return adapter->agent;
3163
}
3164
3165
void adapter_add_active_conn(struct btd_adapter *adapter, bdaddr_t *bdaddr,
3166
uint16_t handle)
3167
{
3168
struct active_conn_info *dev;
3169
3170
if (!adapter)
3171
return;
3172
3173
dev = g_new0(struct active_conn_info, 1);
3174
3175
bacpy(&dev->bdaddr, bdaddr);
3176
dev->handle = handle;
3177
3178
adapter->active_conn = g_slist_append(adapter->active_conn, dev);
3179
}
3180
3181
void adapter_remove_active_conn(struct btd_adapter *adapter,
3182
struct active_conn_info *dev)
3183
{
3184
if (!adapter || !adapter->active_conn)
3185
return;
3186
3187
adapter->active_conn = g_slist_remove(adapter->active_conn, dev);
3188
g_free(dev);
3189
}
3190
3191
struct active_conn_info *adapter_search_active_conn_by_bdaddr(struct btd_adapter *adapter,
3192
bdaddr_t *bda)
3193
{
3194
GSList *l;
3195
3196
if (!adapter || !adapter->active_conn)
3197
return NULL;
3198
3199
l = g_slist_find_custom(adapter->active_conn, &bda,
3200
active_conn_find_by_bdaddr);
3201
if (l)
3202
return l->data;
3203
3204
return NULL;
3205
}
3206
3207
struct active_conn_info *adapter_search_active_conn_by_handle(struct btd_adapter *adapter,
3208
uint16_t handle)
3209
{
3210
GSList *l;
3211
3212
if (!adapter || !adapter->active_conn)
3213
return NULL;
3214
3215
l = g_slist_find_custom(adapter->active_conn, &handle,
3216
active_conn_find_by_handle);
3217
if (l)
3218
return l->data;
3219
3220
return NULL;
3221
}
3222
3223
void adapter_free_bonding_request(struct btd_adapter *adapter)
3224
{
3225
g_dbus_remove_watch(connection, adapter->bonding->listener_id);
3226
3227
if (adapter->bonding->io_id)
3228
g_source_remove(adapter->bonding->io_id);
3229
3230
if (adapter->bonding->io)
3231
g_io_channel_close(adapter->bonding->io);
3232
3233
bonding_request_free(adapter->bonding);
3234
3235
adapter->bonding = NULL;
3236
}
3237
3238
struct bonding_request_info *adapter_get_bonding_info(struct btd_adapter *adapter)
3239
{
3240
if (!adapter)
3241
return NULL;
3242
3243
return adapter->bonding;
3244
}
3245
3246
gboolean adapter_has_discov_sessions(struct btd_adapter *adapter)
3247
{
3248
if (!adapter || !adapter->disc_sessions)
3249
return FALSE;
3250
3251
return TRUE;
3252
}
3253
3254
int btd_register_adapter_driver(struct btd_adapter_driver *driver)
3255
{
3256
adapter_drivers = g_slist_append(adapter_drivers, driver);
3257
3258
return 0;
3259
}
3260
3261
void btd_unregister_adapter_driver(struct btd_adapter_driver *driver)
3262
{
3263
adapter_drivers = g_slist_remove(adapter_drivers, driver);
3264
}
3265
3266
static void agent_auth_cb(struct agent *agent, DBusError *derr, void *user_data)
3267
{
3268
struct service_auth *auth = user_data;
3269
3270
auth->cb(derr, auth->user_data);
3271
3272
g_free(auth);
3273
}
3274
3275
int btd_request_authorization(const bdaddr_t *src, const bdaddr_t *dst,
3276
const char *uuid, service_auth_cb cb, void *user_data)
3277
{
3278
struct service_auth *auth;
3279
struct btd_adapter *adapter;
3280
struct btd_device *device;
3281
struct agent *agent;
3282
char address[18];
3283
gboolean trusted;
3284
const gchar *dev_path;
3285
3286
if (src == NULL || dst == NULL)
3287
return -EINVAL;
3288
3289
adapter = manager_find_adapter(src);
3290
if (!adapter)
3291
return -EPERM;
3292
3293
/* Device connected? */
3294
if (!g_slist_find_custom(adapter->active_conn,
3295
dst, active_conn_find_by_bdaddr))
3296
return -ENOTCONN;
3297
3298
ba2str(dst, address);
3299
trusted = read_trust(src, address, GLOBAL_TRUST);
3300
3301
if (trusted) {
3302
cb(NULL, user_data);
3303
return 0;
3304
}
3305
3306
device = adapter_find_device(adapter, address);
3307
if (!device)
3308
return -EPERM;
3309
3310
agent = device_get_agent(device);
3311
3312
if (!agent)
3313
agent = adapter->agent;
3314
3315
if (!agent)
3316
return -EPERM;
3317
3318
auth = g_try_new0(struct service_auth, 1);
3319
if (!auth)
3320
return -ENOMEM;
3321
3322
auth->cb = cb;
3323
auth->user_data = user_data;
3324
3325
dev_path = device_get_path(device);
3326
3327
return agent_authorize(agent, dev_path, uuid, agent_auth_cb, auth);
3328
}
3329
3330
int btd_cancel_authorization(const bdaddr_t *src, const bdaddr_t *dst)
3331
{
3332
struct btd_adapter *adapter = manager_find_adapter(src);
3333
struct btd_device *device;
3334
struct agent *agent;
3335
char address[18];
3336
3337
if (!adapter)
3338
return -EPERM;
3339
3340
ba2str(dst, address);
3341
device = adapter_find_device(adapter, address);
3342
if (!device)
3343
return -EPERM;
3344
3345
/*
3346
* FIXME: Cancel fails if authorization is requested to adapter's
3347
* agent and in the meanwhile CreatePairedDevice is called.
3348
*/
3349
3350
agent = device_get_agent(device);
3351
3352
if (!agent)
3353
agent = adapter->agent;
3354
3355
if (!agent)
3356
return -EPERM;
3357
3358
return agent_cancel(agent);
3359
}
3360
3361
void adapter_update_devices(struct btd_adapter *adapter)
3362
{
3363
char **devices;
3364
int i;
3365
GSList *l;
3366
3367
/* Devices */
3368
devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
3369
for (i = 0, l = adapter->devices; l; l = l->next, i++) {
3370
struct btd_device *dev = l->data;
3371
devices[i] = (char *) device_get_path(dev);
3372
}
3373
3374
dbus_connection_emit_property_changed(connection, adapter->path,
3375
ADAPTER_INTERFACE, "Devices",
3376
DBUS_TYPE_ARRAY, &devices);
3377
g_free(devices);
3378
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1