« back to all changes in this revision
Viewing changes to plugins/hciops.c
- browse files at revision 1.2.2
- compare with another revision
- download diff
- download tarball
- view history from revision 1.2.2
- Committer: Bazaar Package Importer
- Author(s): Nobuhiro Iwamatsu
- Date: 2010-12-02 12:17:48 UTC
- mfrom: (1.3.7 upstream)
- mto: (1.1.23 upstream) (6.2.2 experimental)
- mto: This revision was merged to the branch mainline in revision 51.
- Revision ID: james.westby@ubuntu.com-20101202121748-9y64u4vc3vmk1wvl
Import upstream version 4.81
- files added:
- Makefile.tools
- attrib
- btio
- health
- tracer
- files removed:
- audio/Makefile.am
- client
- common
- include
- rfcomm
- files modified:
- AUTHORS
added
removed
plugins/hciops.c
1
/*
2
*
3
* BlueZ - Bluetooth protocol stack for Linux
4
*
5
* Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
6
*
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either version 2 of the License, or
10
* (at your option) any later version.
11
*
12
* This program is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with this program; if not, write to the Free Software
19
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20
*
21
*/
22
23
#ifdef HAVE_CONFIG_H
24
#include <config.h>
25
#endif
26
27
#include <stdio.h>
28
#include <errno.h>
29
#include <unistd.h>
30
#include <stdlib.h>
31
#include <sys/types.h>
32
#include <sys/ioctl.h>
33
#include <sys/wait.h>
34
35
#include <bluetooth/bluetooth.h>
36
#include <bluetooth/hci.h>
37
#include <bluetooth/hci_lib.h>
38
39
#include <glib.h>
40
41
#include "hcid.h"
42
#include "sdpd.h"
43
#include "adapter.h"
44
#include "plugin.h"
45
#include "log.h"
46
#include "storage.h"
47
#include "event.h"
48
#include "device.h"
49
#include "manager.h"
50
51
static int child_pipe[2] = { -1, -1 };
52
53
static guint child_io_id = 0;
54
static guint ctl_io_id = 0;
55
56
/* Commands sent by kernel on starting an adapter */
57
enum {
58
PENDING_BDADDR,
59
PENDING_VERSION,
60
PENDING_FEATURES,
61
PENDING_NAME,
62
};
63
64
#define SK(index) devs[(index)].sk
65
#define BDADDR(index) devs[(index)].bdaddr
66
#define FEATURES(index) devs[(index)].features
67
#define VER(index) devs[(index)].ver
68
#define UP(index) devs[(index)].up
69
#define PENDING(index) devs[(index)].pending
70
#define CHANNEL(index) devs[(index)].channel
71
#define WATCH_ID(index) devs[(index)].watch_id
72
#define PIN_LENGTH(index) devs[(index)].pin_length
73
74
static int max_dev = -1;
75
static struct dev_info {
76
int sk;
77
bdaddr_t bdaddr;
78
uint8_t features[8];
79
struct hci_version ver;
80
81
gboolean up;
82
unsigned long pending;
83
84
GIOChannel *channel;
85
guint watch_id;
86
int pin_length;
87
} *devs = NULL;
88
89
static int ignore_device(struct hci_dev_info *di)
90
{
91
return hci_test_bit(HCI_RAW, &di->flags) || di->type >> 4 != HCI_BREDR;
92
}
93
94
static void init_dev_info(int index, int sk)
95
{
96
memset(&devs[index], 0, sizeof(struct dev_info));
97
SK(index) = sk;
98
PIN_LENGTH(index) = -1;
99
}
100
101
/* Async HCI command handling with callback support */
102
103
struct hci_cmd_data {
104
bt_hci_result_t cb;
105
uint16_t handle;
106
uint16_t ocf;
107
gpointer caller_data;
108
};
109
110
static gboolean hci_event_watch(GIOChannel *io,
111
GIOCondition cond, gpointer user_data)
112
{
113
unsigned char buf[HCI_MAX_EVENT_SIZE], *body;
114
struct hci_cmd_data *cmd = user_data;
115
evt_cmd_status *evt_status;
116
evt_auth_complete *evt_auth;
117
evt_encrypt_change *evt_enc;
118
hci_event_hdr *hdr;
119
set_conn_encrypt_cp cp;
120
int dd;
121
uint16_t ocf;
122
uint8_t status = HCI_OE_POWER_OFF;
123
124
if (cond & G_IO_NVAL) {
125
cmd->cb(status, cmd->caller_data);
126
return FALSE;
127
}
128
129
if (cond & (G_IO_ERR | G_IO_HUP))
130
goto failed;
131
132
dd = g_io_channel_unix_get_fd(io);
133
134
if (read(dd, buf, sizeof(buf)) < 0)
135
goto failed;
136
137
hdr = (hci_event_hdr *) (buf + 1);
138
body = buf + (1 + HCI_EVENT_HDR_SIZE);
139
140
switch (hdr->evt) {
141
case EVT_CMD_STATUS:
142
evt_status = (evt_cmd_status *) body;
143
ocf = cmd_opcode_ocf(evt_status->opcode);
144
if (ocf != cmd->ocf)
145
return TRUE;
146
switch (ocf) {
147
case OCF_AUTH_REQUESTED:
148
case OCF_SET_CONN_ENCRYPT:
149
if (evt_status->status != 0) {
150
/* Baseband rejected command */
151
status = evt_status->status;
152
goto failed;
153
}
154
break;
155
default:
156
return TRUE;
157
}
158
/* Wait for the next event */
159
return TRUE;
160
case EVT_AUTH_COMPLETE:
161
evt_auth = (evt_auth_complete *) body;
162
if (evt_auth->handle != cmd->handle) {
163
/* Skipping */
164
return TRUE;
165
}
166
167
if (evt_auth->status != 0x00) {
168
status = evt_auth->status;
169
/* Abort encryption */
170
goto failed;
171
}
172
173
memset(&cp, 0, sizeof(cp));
174
cp.handle = cmd->handle;
175
cp.encrypt = 1;
176
177
cmd->ocf = OCF_SET_CONN_ENCRYPT;
178
179
if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT,
180
SET_CONN_ENCRYPT_CP_SIZE, &cp) < 0) {
181
status = HCI_COMMAND_DISALLOWED;
182
goto failed;
183
}
184
/* Wait for encrypt change event */
185
return TRUE;
186
case EVT_ENCRYPT_CHANGE:
187
evt_enc = (evt_encrypt_change *) body;
188
if (evt_enc->handle != cmd->handle)
189
return TRUE;
190
191
/* Procedure finished: reporting status */
192
status = evt_enc->status;
193
break;
194
default:
195
/* Skipping */
196
return TRUE;
197
}
198
199
failed:
200
cmd->cb(status, cmd->caller_data);
201
g_io_channel_shutdown(io, TRUE, NULL);
202
203
return FALSE;
204
}
205
206
static int write_inq_mode(int index, uint8_t mode)
207
{
208
write_inquiry_mode_cp cp;
209
210
memset(&cp, 0, sizeof(cp));
211
cp.mode = mode;
212
213
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_INQUIRY_MODE,
214
WRITE_INQUIRY_MODE_CP_SIZE, &cp) < 0)
215
return -errno;
216
217
return 0;
218
}
219
220
static uint8_t get_inquiry_mode(int index)
221
{
222
if (FEATURES(index)[6] & LMP_EXT_INQ)
223
return 2;
224
225
if (FEATURES(index)[3] & LMP_RSSI_INQ)
226
return 1;
227
228
if (VER(index).manufacturer == 11 && VER(index).hci_rev == 0x00 &&
229
VER(index).lmp_subver == 0x0757)
230
return 1;
231
232
if (VER(index).manufacturer == 15) {
233
if (VER(index).hci_rev == 0x03 &&
234
VER(index).lmp_subver == 0x6963)
235
return 1;
236
if (VER(index).hci_rev == 0x09 &&
237
VER(index).lmp_subver == 0x6963)
238
return 1;
239
if (VER(index).hci_rev == 0x00 &&
240
VER(index).lmp_subver == 0x6965)
241
return 1;
242
}
243
244
if (VER(index).manufacturer == 31 && VER(index).hci_rev == 0x2005 &&
245
VER(index).lmp_subver == 0x1805)
246
return 1;
247
248
return 0;
249
}
250
251
static int init_ssp_mode(int index)
252
{
253
write_simple_pairing_mode_cp cp;
254
255
if (ioctl(SK(index), HCIGETAUTHINFO, NULL) < 0 && errno == EINVAL)
256
return 0;
257
258
memset(&cp, 0, sizeof(cp));
259
cp.mode = 0x01;
260
261
if (hci_send_cmd(SK(index), OGF_HOST_CTL,
262
OCF_WRITE_SIMPLE_PAIRING_MODE,
263
WRITE_SIMPLE_PAIRING_MODE_CP_SIZE, &cp) < 0)
264
return -errno;
265
266
return 0;
267
}
268
269
static void start_adapter(int index)
270
{
271
uint8_t events[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00 };
272
uint8_t inqmode;
273
274
if (VER(index).lmp_ver > 1) {
275
if (FEATURES(index)[5] & LMP_SNIFF_SUBR)
276
events[5] |= 0x20;
277
278
if (FEATURES(index)[5] & LMP_PAUSE_ENC)
279
events[5] |= 0x80;
280
281
if (FEATURES(index)[6] & LMP_EXT_INQ)
282
events[5] |= 0x40;
283
284
if (FEATURES(index)[6] & LMP_NFLUSH_PKTS)
285
events[7] |= 0x01;
286
287
if (FEATURES(index)[7] & LMP_LSTO)
288
events[6] |= 0x80;
289
290
if (FEATURES(index)[6] & LMP_SIMPLE_PAIR) {
291
events[6] |= 0x01; /* IO Capability Request */
292
events[6] |= 0x02; /* IO Capability Response */
293
events[6] |= 0x04; /* User Confirmation Request */
294
events[6] |= 0x08; /* User Passkey Request */
295
events[6] |= 0x10; /* Remote OOB Data Request */
296
events[6] |= 0x20; /* Simple Pairing Complete */
297
events[7] |= 0x04; /* User Passkey Notification */
298
events[7] |= 0x08; /* Keypress Notification */
299
events[7] |= 0x10; /* Remote Host Supported
300
* Features Notification */
301
}
302
303
if (FEATURES(index)[4] & LMP_LE)
304
events[7] |= 0x20; /* LE Meta-Event */
305
306
hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_SET_EVENT_MASK,
307
sizeof(events), events);
308
}
309
310
if (FEATURES(index)[6] & LMP_SIMPLE_PAIR)
311
init_ssp_mode(index);
312
313
inqmode = get_inquiry_mode(index);
314
if (inqmode)
315
write_inq_mode(index, inqmode);
316
317
if (FEATURES(index)[7] & LMP_INQ_TX_PWR)
318
hci_send_cmd(SK(index), OGF_HOST_CTL,
319
OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL, 0, NULL);
320
321
manager_start_adapter(index);
322
}
323
324
static int hciops_encrypt_link(int index, bdaddr_t *dst, bt_hci_result_t cb,
325
gpointer user_data)
326
{
327
GIOChannel *io;
328
struct hci_cmd_data *cmd;
329
struct hci_conn_info_req *cr;
330
auth_requested_cp cp;
331
struct hci_filter nf;
332
int dd, err;
333
uint32_t link_mode;
334
uint16_t handle;
335
336
dd = hci_open_dev(index);
337
if (dd < 0)
338
return -errno;
339
340
cr = g_malloc0(sizeof(*cr) + sizeof(struct hci_conn_info));
341
cr->type = ACL_LINK;
342
bacpy(&cr->bdaddr, dst);
343
344
err = ioctl(dd, HCIGETCONNINFO, cr);
345
link_mode = cr->conn_info->link_mode;
346
handle = cr->conn_info->handle;
347
g_free(cr);
348
349
if (err < 0) {
350
err = -errno;
351
goto fail;
352
}
353
354
if (link_mode & HCI_LM_ENCRYPT) {
355
err = -EALREADY;
356
goto fail;
357
}
358
359
memset(&cp, 0, sizeof(cp));
360
cp.handle = htobs(handle);
361
362
if (hci_send_cmd(dd, OGF_LINK_CTL, OCF_AUTH_REQUESTED,
363
AUTH_REQUESTED_CP_SIZE, &cp) < 0) {
364
err = -errno;
365
goto fail;
366
}
367
368
cmd = g_new0(struct hci_cmd_data, 1);
369
cmd->handle = handle;
370
cmd->ocf = OCF_AUTH_REQUESTED;
371
cmd->cb = cb;
372
cmd->caller_data = user_data;
373
374
hci_filter_clear(&nf);
375
hci_filter_set_ptype(HCI_EVENT_PKT, &nf);
376
hci_filter_set_event(EVT_CMD_STATUS, &nf);
377
hci_filter_set_event(EVT_AUTH_COMPLETE, &nf);
378
hci_filter_set_event(EVT_ENCRYPT_CHANGE, &nf);
379
380
if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0) {
381
err = -errno;
382
g_free(cmd);
383
goto fail;
384
}
385
386
io = g_io_channel_unix_new(dd);
387
g_io_channel_set_close_on_unref(io, FALSE);
388
g_io_add_watch_full(io, G_PRIORITY_DEFAULT,
389
G_IO_HUP | G_IO_ERR | G_IO_NVAL | G_IO_IN,
390
hci_event_watch, cmd, g_free);
391
g_io_channel_unref(io);
392
393
return 0;
394
395
fail:
396
close(dd);
397
return err;
398
}
399
400
/* End async HCI command handling */
401
402
/* Start of HCI event callbacks */
403
404
static int get_handle(int index, bdaddr_t *dba, uint16_t *handle)
405
{
406
struct hci_conn_list_req *cl;
407
struct hci_conn_info *ci;
408
int i;
409
410
cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl));
411
412
cl->dev_id = index;
413
cl->conn_num = 10;
414
ci = cl->conn_info;
415
416
if (ioctl(SK(index), HCIGETCONNLIST, (void *) cl) < 0) {
417
g_free(cl);
418
return -EIO;
419
}
420
421
for (i = 0; i < cl->conn_num; i++, ci++) {
422
if (bacmp(&ci->bdaddr, dba) == 0) {
423
*handle = ci->handle;
424
g_free(cl);
425
return 0;
426
}
427
}
428
429
g_free(cl);
430
431
return -ENOENT;
432
}
433
434
static inline int get_bdaddr(int index, uint16_t handle, bdaddr_t *dba)
435
{
436
struct hci_conn_list_req *cl;
437
struct hci_conn_info *ci;
438
int i;
439
440
cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl));
441
442
cl->dev_id = index;
443
cl->conn_num = 10;
444
ci = cl->conn_info;
445
446
if (ioctl(SK(index), HCIGETCONNLIST, (void *) cl) < 0) {
447
g_free(cl);
448
return -EIO;
449
}
450
451
for (i = 0; i < cl->conn_num; i++, ci++)
452
if (ci->handle == handle) {
453
bacpy(dba, &ci->bdaddr);
454
g_free(cl);
455
return 0;
456
}
457
458
g_free(cl);
459
460
return -ENOENT;
461
}
462
463
static inline void update_lastseen(bdaddr_t *sba, bdaddr_t *dba)
464
{
465
time_t t;
466
struct tm *tm;
467
468
t = time(NULL);
469
tm = gmtime(&t);
470
471
write_lastseen_info(sba, dba, tm);
472
}
473
474
static inline void update_lastused(bdaddr_t *sba, bdaddr_t *dba)
475
{
476
time_t t;
477
struct tm *tm;
478
479
t = time(NULL);
480
tm = gmtime(&t);
481
482
write_lastused_info(sba, dba, tm);
483
}
484
485
/* Link Key handling */
486
487
static void link_key_request(int index, bdaddr_t *dba)
488
{
489
struct btd_adapter *adapter;
490
struct btd_device *device;
491
struct hci_auth_info_req req;
492
unsigned char key[16];
493
char da[18];
494
uint8_t type;
495
int err;
496
497
ba2str(dba, da);
498
DBG("hci%d dba %s", index, da);
499
500
adapter = manager_find_adapter(&BDADDR(index));
501
if (adapter)
502
device = adapter_find_device(adapter, da);
503
else
504
device = NULL;
505
506
memset(&req, 0, sizeof(req));
507
bacpy(&req.bdaddr, dba);
508
509
err = ioctl(SK(index), HCIGETAUTHINFO, (unsigned long) &req);
510
if (err < 0) {
511
if (errno != EINVAL)
512
DBG("HCIGETAUTHINFO failed %s (%d)",
513
strerror(errno), errno);
514
req.type = 0x00;
515
}
516
517
DBG("kernel auth requirements = 0x%02x", req.type);
518
519
if (main_opts.debug_keys && device &&
520
device_get_debug_key(device, key))
521
type = 0x03;
522
else if (read_link_key(&BDADDR(index), dba, key, &type) < 0 ||
523
type == 0x03) {
524
/* Link key not found */
525
hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_LINK_KEY_NEG_REPLY,
526
6, dba);
527
return;
528
}
529
530
/* Link key found */
531
532
DBG("link key type 0x%02x", type);
533
534
/* Don't use unauthenticated combination keys if MITM is
535
* required */
536
if (type == 0x04 && req.type != 0xff && (req.type & 0x01))
537
hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_LINK_KEY_NEG_REPLY,
538
6, dba);
539
else {
540
link_key_reply_cp lr;
541
542
memcpy(lr.link_key, key, 16);
543
bacpy(&lr.bdaddr, dba);
544
545
hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_LINK_KEY_REPLY,
546
LINK_KEY_REPLY_CP_SIZE, &lr);
547
}
548
}
549
550
static void link_key_notify(int index, void *ptr)
551
{
552
evt_link_key_notify *evt = ptr;
553
bdaddr_t *dba = &evt->bdaddr;
554
char da[18];
555
int err;
556
unsigned char old_key[16];
557
uint8_t old_key_type;
558
559
ba2str(dba, da);
560
DBG("hci%d dba %s type %d", index, da, evt->key_type);
561
562
err = read_link_key(&BDADDR(index), dba, old_key, &old_key_type);
563
if (err < 0)
564
old_key_type = 0xff;
565
566
err = btd_event_link_key_notify(&BDADDR(index), dba, evt->link_key,
567
evt->key_type, PIN_LENGTH(index),
568
old_key_type);
569
PIN_LENGTH(index) = -1;
570
571
if (err < 0) {
572
uint16_t handle;
573
574
if (err == -ENODEV)
575
btd_event_bonding_process_complete(&BDADDR(index), dba,
576
HCI_OE_LOW_RESOURCES);
577
else
578
btd_event_bonding_process_complete(&BDADDR(index), dba,
579
HCI_MEMORY_FULL);
580
581
if (get_handle(index, dba, &handle) == 0) {
582
disconnect_cp cp;
583
584
memset(&cp, 0, sizeof(cp));
585
cp.handle = htobs(handle);
586
cp.reason = HCI_OE_LOW_RESOURCES;
587
588
hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_DISCONNECT,
589
DISCONNECT_CP_SIZE, &cp);
590
}
591
}
592
}
593
594
static void return_link_keys(int index, void *ptr)
595
{
596
evt_return_link_keys *evt = ptr;
597
uint8_t num = evt->num_keys;
598
unsigned char key[16];
599
char da[18];
600
bdaddr_t dba;
601
int i;
602
603
DBG("hci%d num_keys %u", index, num);
604
605
ptr++;
606
607
for (i = 0; i < num; i++) {
608
bacpy(&dba, ptr); ba2str(&dba, da);
609
memcpy(key, ptr + 6, 16);
610
611
DBG("hci%d returned key for %s", index, da);
612
613
btd_event_returned_link_key(&BDADDR(index), &dba);
614
615
ptr += 22;
616
}
617
}
618
619
/* Simple Pairing handling */
620
621
static void user_confirm_request(int index, void *ptr)
622
{
623
evt_user_confirm_request *req = ptr;
624
625
DBG("hci%d", index);
626
627
if (btd_event_user_confirm(&BDADDR(index), &req->bdaddr,
628
btohl(req->passkey)) < 0)
629
hci_send_cmd(SK(index), OGF_LINK_CTL,
630
OCF_USER_CONFIRM_NEG_REPLY, 6, ptr);
631
}
632
633
static void user_passkey_request(int index, void *ptr)
634
{
635
evt_user_passkey_request *req = ptr;
636
637
DBG("hci%d", index);
638
639
if (btd_event_user_passkey(&BDADDR(index), &req->bdaddr) < 0)
640
hci_send_cmd(SK(index), OGF_LINK_CTL,
641
OCF_USER_PASSKEY_NEG_REPLY, 6, ptr);
642
}
643
644
static void user_passkey_notify(int index, void *ptr)
645
{
646
evt_user_passkey_notify *req = ptr;
647
648
DBG("hci%d", index);
649
650
btd_event_user_notify(&BDADDR(index), &req->bdaddr,
651
btohl(req->passkey));
652
}
653
654
static void remote_oob_data_request(int index, void *ptr)
655
{
656
DBG("hci%d", index);
657
hci_send_cmd(SK(index), OGF_LINK_CTL,
658
OCF_REMOTE_OOB_DATA_NEG_REPLY, 6, ptr);
659
}
660
661
static void io_capa_request(int index, void *ptr)
662
{
663
bdaddr_t *dba = ptr;
664
char da[18];
665
uint8_t cap, auth;
666
667
ba2str(dba, da);
668
DBG("hci%d IO capability request for %s", index, da);
669
670
if (btd_event_get_io_cap(&BDADDR(index), dba, &cap, &auth) < 0) {
671
io_capability_neg_reply_cp cp;
672
memset(&cp, 0, sizeof(cp));
673
bacpy(&cp.bdaddr, dba);
674
cp.reason = HCI_PAIRING_NOT_ALLOWED;
675
hci_send_cmd(SK(index), OGF_LINK_CTL,
676
OCF_IO_CAPABILITY_NEG_REPLY,
677
IO_CAPABILITY_NEG_REPLY_CP_SIZE, &cp);
678
} else {
679
io_capability_reply_cp cp;
680
memset(&cp, 0, sizeof(cp));
681
bacpy(&cp.bdaddr, dba);
682
cp.capability = cap;
683
cp.oob_data = 0x00;
684
cp.authentication = auth;
685
hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_IO_CAPABILITY_REPLY,
686
IO_CAPABILITY_REPLY_CP_SIZE, &cp);
687
}
688
}
689
690
static void io_capa_response(int index, void *ptr)
691
{
692
evt_io_capability_response *evt = ptr;
693
char da[18];
694
695
ba2str(&evt->bdaddr, da);
696
DBG("hci%d IO capability response from %s", index, da);
697
698
btd_event_set_io_cap(&BDADDR(index), &evt->bdaddr,
699
evt->capability, evt->authentication);
700
}
701
702
/* PIN code handling */
703
704
static void pin_code_request(int index, bdaddr_t *dba)
705
{
706
pin_code_reply_cp pr;
707
struct hci_conn_info_req *cr;
708
struct hci_conn_info *ci;
709
char da[18], pin[17];
710
int pinlen;
711
712
memset(&pr, 0, sizeof(pr));
713
bacpy(&pr.bdaddr, dba);
714
715
ba2str(dba, da);
716
DBG("hci%d PIN request for %s", index, da);
717
718
cr = g_malloc0(sizeof(*cr) + sizeof(*ci));
719
720
bacpy(&cr->bdaddr, dba);
721
cr->type = ACL_LINK;
722
if (ioctl(SK(index), HCIGETCONNINFO, (unsigned long) cr) < 0) {
723
error("Can't get conn info: %s (%d)", strerror(errno), errno);
724
goto reject;
725
}
726
ci = cr->conn_info;
727
728
memset(pin, 0, sizeof(pin));
729
pinlen = read_pin_code(&BDADDR(index), dba, pin);
730
731
if (pinlen > 0) {
732
PIN_LENGTH(index) = pinlen;
733
memcpy(pr.pin_code, pin, pinlen);
734
pr.pin_len = pinlen;
735
hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_PIN_CODE_REPLY,
736
PIN_CODE_REPLY_CP_SIZE, &pr);
737
} else {
738
/* Request PIN from passkey agent */
739
if (btd_event_request_pin(&BDADDR(index), ci) < 0)
740
goto reject;
741
}
742
743
g_free(cr);
744
745
return;
746
747
reject:
748
g_free(cr);
749
750
hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_PIN_CODE_NEG_REPLY, 6, dba);
751
}
752
753
static void start_inquiry(bdaddr_t *local, uint8_t status, gboolean periodic)
754
{
755
struct btd_adapter *adapter;
756
int state;
757
758
/* Don't send the signal if the cmd failed */
759
if (status) {
760
error("Inquiry Failed with status 0x%02x", status);
761
return;
762
}
763
764
adapter = manager_find_adapter(local);
765
if (!adapter) {
766
error("Unable to find matching adapter");
767
return;
768
}
769
770
state = adapter_get_state(adapter);
771
772
if (periodic)
773
state |= STATE_PINQ;
774
else
775
state |= STATE_STDINQ;
776
777
adapter_set_state(adapter, state);
778
}
779
780
static void inquiry_complete(bdaddr_t *local, uint8_t status,
781
gboolean periodic)
782
{
783
struct btd_adapter *adapter;
784
int state;
785
786
/* Don't send the signal if the cmd failed */
787
if (status) {
788
error("Inquiry Failed with status 0x%02x", status);
789
return;
790
}
791
792
adapter = manager_find_adapter(local);
793
if (!adapter) {
794
error("Unable to find matching adapter");
795
return;
796
}
797
798
state = adapter_get_state(adapter);
799
state &= ~(STATE_STDINQ | STATE_PINQ);
800
adapter_set_state(adapter, state);
801
}
802
803
static inline void remote_features_notify(int index, void *ptr)
804
{
805
evt_remote_host_features_notify *evt = ptr;
806
807
if (evt->features[0] & 0x01)
808
btd_event_set_legacy_pairing(&BDADDR(index), &evt->bdaddr,
809
FALSE);
810
else
811
btd_event_set_legacy_pairing(&BDADDR(index), &evt->bdaddr,
812
TRUE);
813
814
write_features_info(&BDADDR(index), &evt->bdaddr, NULL, evt->features);
815
}
816
817
static void write_le_host_complete(bdaddr_t *sba, uint8_t status)
818
{
819
struct btd_adapter *adapter;
820
821
if (status)
822
return;
823
824
adapter = manager_find_adapter(sba);
825
if (!adapter) {
826
error("No matching adapter found");
827
return;
828
}
829
830
btd_adapter_read_local_ext_features(adapter);
831
}
832
833
static void read_local_version_complete(int index,
834
const read_local_version_rp *rp)
835
{
836
if (rp->status)
837
return;
838
839
VER(index).manufacturer = btohs(bt_get_unaligned(&rp->manufacturer));
840
VER(index).hci_ver = rp->hci_ver;
841
VER(index).hci_rev = btohs(bt_get_unaligned(&rp->hci_rev));
842
VER(index).lmp_ver = rp->lmp_ver;
843
VER(index).lmp_subver = btohs(bt_get_unaligned(&rp->lmp_subver));
844
845
if (!PENDING(index))
846
return;
847
848
hci_clear_bit(PENDING_VERSION, &PENDING(index));
849
850
DBG("Got version for hci%d", index);
851
852
if (!PENDING(index) && UP(index))
853
start_adapter(index);
854
}
855
856
static void read_local_features_complete(int index,
857
const read_local_features_rp *rp)
858
{
859
if (rp->status)
860
return;
861
862
memcpy(FEATURES(index), rp->features, 8);
863
864
if (!PENDING(index))
865
return;
866
867
hci_clear_bit(PENDING_FEATURES, &PENDING(index));
868
869
DBG("Got features for hci%d", index);
870
871
if (!PENDING(index) && UP(index))
872
start_adapter(index);
873
}
874
875
static void update_name(int index, const char *name)
876
{
877
struct btd_adapter *adapter;
878
879
adapter = manager_find_adapter(&BDADDR(index));
880
if (adapter)
881
adapter_update_local_name(adapter, name);
882
}
883
884
static void read_local_name_complete(int index, read_local_name_rp *rp)
885
{
886
DBG("hci%d status %u", index, rp->status);
887
888
if (rp->status)
889
return;
890
891
if (!PENDING(index)) {
892
update_name(index, (char *) rp->name);
893
return;
894
}
895
896
hci_clear_bit(PENDING_NAME, &PENDING(index));
897
898
DBG("Got name for hci%d", index);
899
900
if (!UP(index))
901
return;
902
903
/* Even though it shouldn't happen (assuming the kernel behaves
904
* properly) it seems like we might miss the very first
905
* initialization commands that the kernel sends. So check for
906
* it here (since read_local_name is one of the last init
907
* commands) and resend the first ones if we haven't seen
908
* their results yet */
909
910
if (hci_test_bit(PENDING_FEATURES, &PENDING(index)))
911
hci_send_cmd(SK(index), OGF_INFO_PARAM,
912
OCF_READ_LOCAL_FEATURES, 0, NULL);
913
914
if (hci_test_bit(PENDING_VERSION, &PENDING(index)))
915
hci_send_cmd(SK(index), OGF_INFO_PARAM,
916
OCF_READ_LOCAL_VERSION, 0, NULL);
917
918
if (!PENDING(index))
919
start_adapter(index);
920
}
921
922
static void read_tx_power_complete(int index, void *ptr)
923
{
924
read_inq_response_tx_power_level_rp *rp = ptr;
925
struct btd_adapter *adapter;
926
927
DBG("hci%d status %u", index, rp->status);
928
929
if (rp->status)
930
return;
931
932
adapter = manager_find_adapter(&BDADDR(index));
933
if (!adapter) {
934
error("No matching adapter found");
935
return;
936
}
937
938
adapter_update_tx_power(adapter, rp->level);
939
}
940
941
static void read_simple_pairing_mode_complete(int index, void *ptr)
942
{
943
read_simple_pairing_mode_rp *rp = ptr;
944
struct btd_adapter *adapter;
945
946
DBG("hci%d status %u", index, rp->status);
947
948
if (rp->status)
949
return;
950
951
adapter = manager_find_adapter(&BDADDR(index));
952
if (!adapter) {
953
error("No matching adapter found");
954
return;
955
}
956
957
adapter_update_ssp_mode(adapter, rp->mode);
958
}
959
960
static void read_local_ext_features_complete(int index,
961
const read_local_ext_features_rp *rp)
962
{
963
struct btd_adapter *adapter;
964
965
DBG("hci%d status %u", index, rp->status);
966
967
if (rp->status)
968
return;
969
970
adapter = manager_find_adapter(&BDADDR(index));
971
if (!adapter) {
972
error("No matching adapter found");
973
return;
974
}
975
976
/* Local Extended feature page number is 1 */
977
if (rp->page_num != 1)
978
return;
979
980
btd_adapter_update_local_ext_features(adapter, rp->features);
981
}
982
983
static void read_bd_addr_complete(int index, read_bd_addr_rp *rp)
984
{
985
DBG("hci%d status %u", index, rp->status);
986
987
if (rp->status)
988
return;
989
990
bacpy(&BDADDR(index), &rp->bdaddr);
991
992
if (!PENDING(index))
993
return;
994
995
hci_clear_bit(PENDING_BDADDR, &PENDING(index));
996
997
DBG("Got bdaddr for hci%d", index);
998
999
if (!PENDING(index) && UP(index))
1000
start_adapter(index);
1001
}
1002
1003
static inline void cmd_status(int index, void *ptr)
1004
{
1005
evt_cmd_status *evt = ptr;
1006
uint16_t opcode = btohs(evt->opcode);
1007
1008
if (opcode == cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY))
1009
start_inquiry(&BDADDR(index), evt->status, FALSE);
1010
}
1011
1012
static void read_scan_complete(int index, uint8_t status, void *ptr)
1013
{
1014
struct btd_adapter *adapter;
1015
read_scan_enable_rp *rp = ptr;
1016
1017
DBG("hci%d status %u", index, status);
1018
1019
adapter = manager_find_adapter(&BDADDR(index));
1020
1021
if (!adapter) {
1022
error("Unable to find matching adapter");
1023
return;
1024
}
1025
1026
adapter_mode_changed(adapter, rp->enable);
1027
}
1028
1029
static inline void cmd_complete(int index, void *ptr)
1030
{
1031
evt_cmd_complete *evt = ptr;
1032
uint16_t opcode = btohs(evt->opcode);
1033
uint8_t status = *((uint8_t *) ptr + EVT_CMD_COMPLETE_SIZE);
1034
1035
switch (opcode) {
1036
case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_VERSION):
1037
ptr += sizeof(evt_cmd_complete);
1038
read_local_version_complete(index, ptr);
1039
break;
1040
case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_FEATURES):
1041
ptr += sizeof(evt_cmd_complete);
1042
read_local_features_complete(index, ptr);
1043
break;
1044
case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_LOCAL_EXT_FEATURES):
1045
ptr += sizeof(evt_cmd_complete);
1046
read_local_ext_features_complete(index, ptr);
1047
break;
1048
case cmd_opcode_pack(OGF_INFO_PARAM, OCF_READ_BD_ADDR):
1049
ptr += sizeof(evt_cmd_complete);
1050
read_bd_addr_complete(index, ptr);
1051
break;
1052
case cmd_opcode_pack(OGF_LINK_CTL, OCF_PERIODIC_INQUIRY):
1053
start_inquiry(&BDADDR(index), status, TRUE);
1054
break;
1055
case cmd_opcode_pack(OGF_LINK_CTL, OCF_EXIT_PERIODIC_INQUIRY):
1056
inquiry_complete(&BDADDR(index), status, TRUE);
1057
break;
1058
case cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY_CANCEL):
1059
inquiry_complete(&BDADDR(index), status, FALSE);
1060
break;
1061
case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_LE_HOST_SUPPORTED):
1062
write_le_host_complete(&BDADDR(index), status);
1063
break;
1064
case cmd_opcode_pack(OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE):
1065
btd_event_le_set_scan_enable_complete(&BDADDR(index), status);
1066
break;
1067
case cmd_opcode_pack(OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME):
1068
if (!status)
1069
hci_send_cmd(SK(index), OGF_HOST_CTL,
1070
OCF_READ_LOCAL_NAME, 0, 0);
1071
break;
1072
case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE):
1073
btd_event_setscan_enable_complete(&BDADDR(index));
1074
break;
1075
case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SCAN_ENABLE):
1076
ptr += sizeof(evt_cmd_complete);
1077
read_scan_complete(index, status, ptr);
1078
break;
1079
case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV):
1080
adapter_set_class_complete(&BDADDR(index), status);
1081
break;
1082
case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SIMPLE_PAIRING_MODE):
1083
if (!status)
1084
hci_send_cmd(SK(index), OGF_HOST_CTL,
1085
OCF_READ_SIMPLE_PAIRING_MODE, 0, NULL);
1086
break;
1087
case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SIMPLE_PAIRING_MODE):
1088
ptr += sizeof(evt_cmd_complete);
1089
read_simple_pairing_mode_complete(index, ptr);
1090
break;
1091
case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_LOCAL_NAME):
1092
ptr += sizeof(evt_cmd_complete);
1093
read_local_name_complete(index, ptr);
1094
break;
1095
case cmd_opcode_pack(OGF_HOST_CTL,
1096
OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL):
1097
ptr += sizeof(evt_cmd_complete);
1098
read_tx_power_complete(index, ptr);
1099
break;
1100
};
1101
}
1102
1103
static inline void remote_name_information(int index, void *ptr)
1104
{
1105
evt_remote_name_req_complete *evt = ptr;
1106
char name[MAX_NAME_LENGTH + 1];
1107
1108
DBG("hci%d status %u", index, evt->status);
1109
1110
memset(name, 0, sizeof(name));
1111
1112
if (!evt->status)
1113
memcpy(name, evt->name, MAX_NAME_LENGTH);
1114
1115
btd_event_remote_name(&BDADDR(index), &evt->bdaddr, evt->status, name);
1116
}
1117
1118
static inline void remote_version_information(int index, void *ptr)
1119
{
1120
evt_read_remote_version_complete *evt = ptr;
1121
bdaddr_t dba;
1122
1123
DBG("hci%d status %u", index, evt->status);
1124
1125
if (evt->status)
1126
return;
1127
1128
if (get_bdaddr(index, btohs(evt->handle), &dba) < 0)
1129
return;
1130
1131
write_version_info(&BDADDR(index), &dba, btohs(evt->manufacturer),
1132
evt->lmp_ver, btohs(evt->lmp_subver));
1133
}
1134
1135
static inline void inquiry_result(int index, int plen, void *ptr)
1136
{
1137
uint8_t num = *(uint8_t *) ptr++;
1138
int i;
1139
1140
for (i = 0; i < num; i++) {
1141
inquiry_info *info = ptr;
1142
uint32_t class = info->dev_class[0] |
1143
(info->dev_class[1] << 8) |
1144
(info->dev_class[2] << 16);
1145
1146
btd_event_inquiry_result(&BDADDR(index), &info->bdaddr, class,
1147
0, NULL);
1148
1149
update_lastseen(&BDADDR(index), &info->bdaddr);
1150
1151
ptr += INQUIRY_INFO_SIZE;
1152
}
1153
}
1154
1155
static inline void inquiry_result_with_rssi(int index, int plen, void *ptr)
1156
{
1157
uint8_t num = *(uint8_t *) ptr++;
1158
int i;
1159
1160
if (!num)
1161
return;
1162
1163
if ((plen - 1) / num == INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE) {
1164
for (i = 0; i < num; i++) {
1165
inquiry_info_with_rssi_and_pscan_mode *info = ptr;
1166
uint32_t class = info->dev_class[0]
1167
| (info->dev_class[1] << 8)
1168
| (info->dev_class[2] << 16);
1169
1170
btd_event_inquiry_result(&BDADDR(index), &info->bdaddr,
1171
class, info->rssi, NULL);
1172
1173
update_lastseen(&BDADDR(index), &info->bdaddr);
1174
1175
ptr += INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE;
1176
}
1177
} else {
1178
for (i = 0; i < num; i++) {
1179
inquiry_info_with_rssi *info = ptr;
1180
uint32_t class = info->dev_class[0]
1181
| (info->dev_class[1] << 8)
1182
| (info->dev_class[2] << 16);
1183
1184
btd_event_inquiry_result(&BDADDR(index), &info->bdaddr,
1185
class, info->rssi, NULL);
1186
1187
update_lastseen(&BDADDR(index), &info->bdaddr);
1188
1189
ptr += INQUIRY_INFO_WITH_RSSI_SIZE;
1190
}
1191
}
1192
}
1193
1194
static inline void extended_inquiry_result(int index, int plen, void *ptr)
1195
{
1196
uint8_t num = *(uint8_t *) ptr++;
1197
int i;
1198
1199
for (i = 0; i < num; i++) {
1200
extended_inquiry_info *info = ptr;
1201
uint32_t class = info->dev_class[0]
1202
| (info->dev_class[1] << 8)
1203
| (info->dev_class[2] << 16);
1204
1205
btd_event_inquiry_result(&BDADDR(index), &info->bdaddr, class,
1206
info->rssi, info->data);
1207
1208
update_lastseen(&BDADDR(index), &info->bdaddr);
1209
1210
ptr += EXTENDED_INQUIRY_INFO_SIZE;
1211
}
1212
}
1213
1214
static inline void remote_features_information(int index, void *ptr)
1215
{
1216
evt_read_remote_features_complete *evt = ptr;
1217
bdaddr_t dba;
1218
1219
DBG("hci%d status %u", index, evt->status);
1220
1221
if (evt->status)
1222
return;
1223
1224
if (get_bdaddr(index, btohs(evt->handle), &dba) < 0)
1225
return;
1226
1227
write_features_info(&BDADDR(index), &dba, evt->features, NULL);
1228
}
1229
1230
static inline void conn_complete(int index, void *ptr)
1231
{
1232
evt_conn_complete *evt = ptr;
1233
char filename[PATH_MAX];
1234
char local_addr[18], peer_addr[18], *str;
1235
struct btd_adapter *adapter;
1236
1237
adapter = manager_find_adapter(&BDADDR(index));
1238
if (!adapter) {
1239
error("Unable to find matching adapter");
1240
return;
1241
}
1242
1243
if (evt->link_type != ACL_LINK)
1244
return;
1245
1246
btd_event_conn_complete(&BDADDR(index), evt->status,
1247
btohs(evt->handle), &evt->bdaddr);
1248
1249
if (evt->status)
1250
return;
1251
1252
update_lastused(&BDADDR(index), &evt->bdaddr);
1253
1254
/* check if the remote version needs be requested */
1255
ba2str(&BDADDR(index), local_addr);
1256
ba2str(&evt->bdaddr, peer_addr);
1257
1258
create_name(filename, sizeof(filename), STORAGEDIR, local_addr,
1259
"manufacturers");
1260
1261
str = textfile_get(filename, peer_addr);
1262
if (!str)
1263
btd_adapter_get_remote_version(adapter, btohs(evt->handle),
1264
TRUE);
1265
else
1266
free(str);
1267
}
1268
1269
static inline void le_conn_complete(int index, void *ptr)
1270
{
1271
evt_le_connection_complete *evt = ptr;
1272
char filename[PATH_MAX];
1273
char local_addr[18], peer_addr[18], *str;
1274
struct btd_adapter *adapter;
1275
1276
adapter = manager_find_adapter(&BDADDR(index));
1277
if (!adapter) {
1278
error("Unable to find matching adapter");
1279
return;
1280
}
1281
1282
btd_event_conn_complete(&BDADDR(index), evt->status,
1283
btohs(evt->handle), &evt->peer_bdaddr);
1284
1285
if (evt->status)
1286
return;
1287
1288
update_lastused(&BDADDR(index), &evt->peer_bdaddr);
1289
1290
/* check if the remote version needs be requested */
1291
ba2str(&BDADDR(index), local_addr);
1292
ba2str(&evt->peer_bdaddr, peer_addr);
1293
1294
create_name(filename, sizeof(filename), STORAGEDIR, local_addr,
1295
"manufacturers");
1296
1297
str = textfile_get(filename, peer_addr);
1298
if (!str)
1299
btd_adapter_get_remote_version(adapter, btohs(evt->handle),
1300
TRUE);
1301
else
1302
free(str);
1303
}
1304
1305
static inline void disconn_complete(int index, void *ptr)
1306
{
1307
evt_disconn_complete *evt = ptr;
1308
1309
btd_event_disconn_complete(&BDADDR(index), evt->status,
1310
btohs(evt->handle), evt->reason);
1311
}
1312
1313
static inline void auth_complete(int index, void *ptr)
1314
{
1315
evt_auth_complete *evt = ptr;
1316
bdaddr_t dba;
1317
1318
DBG("hci%d status %u", index, evt->status);
1319
1320
if (get_bdaddr(index, btohs(evt->handle), &dba) < 0)
1321
return;
1322
1323
btd_event_bonding_process_complete(&BDADDR(index), &dba, evt->status);
1324
}
1325
1326
static inline void simple_pairing_complete(int index, void *ptr)
1327
{
1328
evt_simple_pairing_complete *evt = ptr;
1329
1330
DBG("hci%d status %u", index, evt->status);
1331
1332
btd_event_simple_pairing_complete(&BDADDR(index), &evt->bdaddr,
1333
evt->status);
1334
}
1335
1336
static inline void conn_request(int index, void *ptr)
1337
{
1338
evt_conn_request *evt = ptr;
1339
uint32_t class = evt->dev_class[0] | (evt->dev_class[1] << 8)
1340
| (evt->dev_class[2] << 16);
1341
1342
btd_event_remote_class(&BDADDR(index), &evt->bdaddr, class);
1343
}
1344
1345
static inline void le_advertising_report(int index, evt_le_meta_event *meta)
1346
{
1347
le_advertising_info *info;
1348
uint8_t num, i;
1349
1350
num = meta->data[0];
1351
info = (le_advertising_info *) (meta->data + 1);
1352
1353
for (i = 0; i < num; i++) {
1354
btd_event_advertising_report(&BDADDR(index), info);
1355
info = (le_advertising_info *) (info->data + info->length + 1);
1356
}
1357
}
1358
1359
static inline void le_metaevent(int index, void *ptr)
1360
{
1361
evt_le_meta_event *meta = ptr;
1362
1363
DBG("hci%d LE Meta Event %u", index, meta->subevent);
1364
1365
switch (meta->subevent) {
1366
case EVT_LE_ADVERTISING_REPORT:
1367
le_advertising_report(index, meta);
1368
break;
1369
1370
case EVT_LE_CONN_COMPLETE:
1371
le_conn_complete(index, meta->data);
1372
break;
1373
}
1374
}
1375
1376
static void stop_hci_dev(int index)
1377
{
1378
GIOChannel *chan = CHANNEL(index);
1379
1380
if (!chan)
1381
return;
1382
1383
info("Stopping hci%d event socket", index);
1384
1385
g_source_remove(WATCH_ID(index));
1386
g_io_channel_unref(CHANNEL(index));
1387
hci_close_dev(SK(index));
1388
init_dev_info(index, -1);
1389
}
1390
1391
static gboolean io_security_event(GIOChannel *chan, GIOCondition cond,
1392
gpointer data)
1393
{
1394
unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr = buf;
1395
int type, index = GPOINTER_TO_INT(data);
1396
struct hci_dev_info di;
1397
size_t len;
1398
hci_event_hdr *eh;
1399
GIOError err;
1400
evt_cmd_status *evt;
1401
1402
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
1403
stop_hci_dev(index);
1404
return FALSE;
1405
}
1406
1407
if ((err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len))) {
1408
if (err == G_IO_ERROR_AGAIN)
1409
return TRUE;
1410
stop_hci_dev(index);
1411
return FALSE;
1412
}
1413
1414
type = *ptr++;
1415
1416
if (type != HCI_EVENT_PKT)
1417
return TRUE;
1418
1419
eh = (hci_event_hdr *) ptr;
1420
ptr += HCI_EVENT_HDR_SIZE;
1421
1422
memset(&di, 0, sizeof(di));
1423
if (hci_devinfo(index, &di) == 0) {
1424
bacpy(&BDADDR(index), &di.bdaddr);
1425
1426
if (ignore_device(&di))
1427
return TRUE;
1428
}
1429
1430
switch (eh->evt) {
1431
case EVT_CMD_STATUS:
1432
cmd_status(index, ptr);
1433
break;
1434
1435
case EVT_CMD_COMPLETE:
1436
cmd_complete(index, ptr);
1437
break;
1438
1439
case EVT_REMOTE_NAME_REQ_COMPLETE:
1440
remote_name_information(index, ptr);
1441
break;
1442
1443
case EVT_READ_REMOTE_VERSION_COMPLETE:
1444
remote_version_information(index, ptr);
1445
break;
1446
1447
case EVT_READ_REMOTE_FEATURES_COMPLETE:
1448
remote_features_information(index, ptr);
1449
break;
1450
1451
case EVT_REMOTE_HOST_FEATURES_NOTIFY:
1452
remote_features_notify(index, ptr);
1453
break;
1454
1455
case EVT_INQUIRY_COMPLETE:
1456
evt = (evt_cmd_status *) ptr;
1457
inquiry_complete(&BDADDR(index), evt->status, FALSE);
1458
break;
1459
1460
case EVT_INQUIRY_RESULT:
1461
inquiry_result(index, eh->plen, ptr);
1462
break;
1463
1464
case EVT_INQUIRY_RESULT_WITH_RSSI:
1465
inquiry_result_with_rssi(index, eh->plen, ptr);
1466
break;
1467
1468
case EVT_EXTENDED_INQUIRY_RESULT:
1469
extended_inquiry_result(index, eh->plen, ptr);
1470
break;
1471
1472
case EVT_CONN_COMPLETE:
1473
conn_complete(index, ptr);
1474
break;
1475
1476
case EVT_DISCONN_COMPLETE:
1477
disconn_complete(index, ptr);
1478
break;
1479
1480
case EVT_AUTH_COMPLETE:
1481
auth_complete(index, ptr);
1482
break;
1483
1484
case EVT_SIMPLE_PAIRING_COMPLETE:
1485
simple_pairing_complete(index, ptr);
1486
break;
1487
1488
case EVT_CONN_REQUEST:
1489
conn_request(index, ptr);
1490
break;
1491
case EVT_LE_META_EVENT:
1492
le_metaevent(index, ptr);
1493
break;
1494
case EVT_PIN_CODE_REQ:
1495
pin_code_request(index, (bdaddr_t *) ptr);
1496
break;
1497
1498
case EVT_LINK_KEY_REQ:
1499
link_key_request(index, (bdaddr_t *) ptr);
1500
break;
1501
1502
case EVT_LINK_KEY_NOTIFY:
1503
link_key_notify(index, ptr);
1504
break;
1505
1506
case EVT_RETURN_LINK_KEYS:
1507
return_link_keys(index, ptr);
1508
break;
1509
1510
case EVT_IO_CAPABILITY_REQUEST:
1511
io_capa_request(index, ptr);
1512
break;
1513
1514
case EVT_IO_CAPABILITY_RESPONSE:
1515
io_capa_response(index, ptr);
1516
break;
1517
1518
case EVT_USER_CONFIRM_REQUEST:
1519
user_confirm_request(index, ptr);
1520
break;
1521
1522
case EVT_USER_PASSKEY_REQUEST:
1523
user_passkey_request(index, ptr);
1524
break;
1525
1526
case EVT_USER_PASSKEY_NOTIFY:
1527
user_passkey_notify(index, ptr);
1528
break;
1529
1530
case EVT_REMOTE_OOB_DATA_REQUEST:
1531
remote_oob_data_request(index, ptr);
1532
break;
1533
}
1534
1535
return TRUE;
1536
}
1537
1538
static void start_hci_dev(int index)
1539
{
1540
GIOChannel *chan = CHANNEL(index);
1541
GIOCondition cond;
1542
struct hci_filter flt;
1543
1544
if (chan)
1545
return;
1546
1547
info("Listening for HCI events on hci%d", index);
1548
1549
/* Set filter */
1550
hci_filter_clear(&flt);
1551
hci_filter_set_ptype(HCI_EVENT_PKT, &flt);
1552
hci_filter_set_event(EVT_CMD_STATUS, &flt);
1553
hci_filter_set_event(EVT_CMD_COMPLETE, &flt);
1554
hci_filter_set_event(EVT_PIN_CODE_REQ, &flt);
1555
hci_filter_set_event(EVT_LINK_KEY_REQ, &flt);
1556
hci_filter_set_event(EVT_LINK_KEY_NOTIFY, &flt);
1557
hci_filter_set_event(EVT_RETURN_LINK_KEYS, &flt);
1558
hci_filter_set_event(EVT_IO_CAPABILITY_REQUEST, &flt);
1559
hci_filter_set_event(EVT_IO_CAPABILITY_RESPONSE, &flt);
1560
hci_filter_set_event(EVT_USER_CONFIRM_REQUEST, &flt);
1561
hci_filter_set_event(EVT_USER_PASSKEY_REQUEST, &flt);
1562
hci_filter_set_event(EVT_REMOTE_OOB_DATA_REQUEST, &flt);
1563
hci_filter_set_event(EVT_USER_PASSKEY_NOTIFY, &flt);
1564
hci_filter_set_event(EVT_KEYPRESS_NOTIFY, &flt);
1565
hci_filter_set_event(EVT_SIMPLE_PAIRING_COMPLETE, &flt);
1566
hci_filter_set_event(EVT_AUTH_COMPLETE, &flt);
1567
hci_filter_set_event(EVT_REMOTE_NAME_REQ_COMPLETE, &flt);
1568
hci_filter_set_event(EVT_READ_REMOTE_VERSION_COMPLETE, &flt);
1569
hci_filter_set_event(EVT_READ_REMOTE_FEATURES_COMPLETE, &flt);
1570
hci_filter_set_event(EVT_REMOTE_HOST_FEATURES_NOTIFY, &flt);
1571
hci_filter_set_event(EVT_INQUIRY_COMPLETE, &flt);
1572
hci_filter_set_event(EVT_INQUIRY_RESULT, &flt);
1573
hci_filter_set_event(EVT_INQUIRY_RESULT_WITH_RSSI, &flt);
1574
hci_filter_set_event(EVT_EXTENDED_INQUIRY_RESULT, &flt);
1575
hci_filter_set_event(EVT_CONN_REQUEST, &flt);
1576
hci_filter_set_event(EVT_CONN_COMPLETE, &flt);
1577
hci_filter_set_event(EVT_DISCONN_COMPLETE, &flt);
1578
hci_filter_set_event(EVT_LE_META_EVENT, &flt);
1579
if (setsockopt(SK(index), SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {
1580
error("Can't set filter on hci%d: %s (%d)",
1581
index, strerror(errno), errno);
1582
return;
1583
}
1584
1585
chan = g_io_channel_unix_new(SK(index));
1586
cond = G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR;
1587
WATCH_ID(index) = g_io_add_watch_full(chan, G_PRIORITY_LOW, cond,
1588
io_security_event,
1589
GINT_TO_POINTER(index), NULL);
1590
CHANNEL(index) = chan;
1591
PIN_LENGTH(index) = -1;
1592
1593
}
1594
1595
/* End of HCI event callbacks */
1596
1597
static gboolean child_exit(GIOChannel *io, GIOCondition cond, void *user_data)
1598
{
1599
int status, fd = g_io_channel_unix_get_fd(io);
1600
pid_t child_pid;
1601
1602
if (read(fd, &child_pid, sizeof(child_pid)) != sizeof(child_pid)) {
1603
error("child_exit: unable to read child pid from pipe");
1604
return TRUE;
1605
}
1606
1607
if (waitpid(child_pid, &status, 0) != child_pid)
1608
error("waitpid(%d) failed", child_pid);
1609
else
1610
DBG("child %d exited", child_pid);
1611
1612
return TRUE;
1613
}
1614
1615
static void at_child_exit(void)
1616
{
1617
pid_t pid = getpid();
1618
1619
if (write(child_pipe[1], &pid, sizeof(pid)) != sizeof(pid))
1620
error("unable to write to child pipe");
1621
}
1622
1623
static void device_devup_setup(int index)
1624
{
1625
struct hci_dev_info di;
1626
uint16_t policy;
1627
read_stored_link_key_cp cp;
1628
1629
DBG("hci%d", index);
1630
1631
if (hci_devinfo(index, &di) < 0)
1632
return;
1633
1634
if (ignore_device(&di))
1635
return;
1636
1637
bacpy(&BDADDR(index), &di.bdaddr);
1638
memcpy(FEATURES(index), di.features, 8);
1639
1640
/* Set page timeout */
1641
if ((main_opts.flags & (1 << HCID_SET_PAGETO))) {
1642
write_page_timeout_cp cp;
1643
1644
cp.timeout = htobs(main_opts.pageto);
1645
hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_PAGE_TIMEOUT,
1646
WRITE_PAGE_TIMEOUT_CP_SIZE, &cp);
1647
}
1648
1649
/* Set default link policy */
1650
policy = htobs(main_opts.link_policy);
1651
hci_send_cmd(SK(index), OGF_LINK_POLICY,
1652
OCF_WRITE_DEFAULT_LINK_POLICY, 2, &policy);
1653
1654
bacpy(&cp.bdaddr, BDADDR_ANY);
1655
cp.read_all = 1;
1656
hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_READ_STORED_LINK_KEY,
1657
READ_STORED_LINK_KEY_CP_SIZE, (void *) &cp);
1658
1659
if (!PENDING(index))
1660
start_adapter(index);
1661
}
1662
1663
static void init_pending(int index)
1664
{
1665
hci_set_bit(PENDING_BDADDR, &PENDING(index));
1666
hci_set_bit(PENDING_VERSION, &PENDING(index));
1667
hci_set_bit(PENDING_FEATURES, &PENDING(index));
1668
hci_set_bit(PENDING_NAME, &PENDING(index));
1669
}
1670
1671
static void init_device(int index)
1672
{
1673
struct hci_dev_req dr;
1674
struct hci_dev_info di;
1675
int dd;
1676
pid_t pid;
1677
1678
DBG("hci%d", index);
1679
1680
dd = hci_open_dev(index);
1681
if (dd < 0) {
1682
error("Unable to open hci%d: %s (%d)", index,
1683
strerror(errno), errno);
1684
return;
1685
}
1686
1687
if (index > max_dev) {
1688
max_dev = index;
1689
devs = g_realloc(devs, sizeof(devs[0]) * (max_dev + 1));
1690
}
1691
1692
init_dev_info(index, dd);
1693
init_pending(index);
1694
start_hci_dev(index);
1695
1696
/* Do initialization in the separate process */
1697
pid = fork();
1698
switch (pid) {
1699
case 0:
1700
atexit(at_child_exit);
1701
break;
1702
case -1:
1703
error("Fork failed. Can't init device hci%d: %s (%d)",
1704
index, strerror(errno), errno);
1705
default:
1706
DBG("child %d forked", pid);
1707
return;
1708
}
1709
1710
memset(&dr, 0, sizeof(dr));
1711
dr.dev_id = index;
1712
1713
/* Set link mode */
1714
dr.dev_opt = main_opts.link_mode;
1715
if (ioctl(dd, HCISETLINKMODE, (unsigned long) &dr) < 0)
1716
error("Can't set link mode on hci%d: %s (%d)",
1717
index, strerror(errno), errno);
1718
1719
/* Set link policy for BR/EDR HCI devices */
1720
if (hci_devinfo(index, &di) < 0)
1721
goto fail;
1722
1723
if (!ignore_device(&di)) {
1724
dr.dev_opt = main_opts.link_policy;
1725
if (ioctl(dd, HCISETLINKPOL, (unsigned long) &dr) < 0 &&
1726
errno != ENETDOWN) {
1727
error("Can't set link policy on hci%d: %s (%d)",
1728
index, strerror(errno), errno);
1729
}
1730
}
1731
1732
/* Start HCI device */
1733
if (ioctl(dd, HCIDEVUP, index) < 0 && errno != EALREADY) {
1734
error("Can't init device hci%d: %s (%d)",
1735
index, strerror(errno), errno);
1736
goto fail;
1737
}
1738
1739
hci_close_dev(dd);
1740
exit(0);
1741
1742
fail:
1743
hci_close_dev(dd);
1744
exit(1);
1745
}
1746
1747
static void device_devreg_setup(int index)
1748
{
1749
struct hci_dev_info di;
1750
gboolean devup;
1751
1752
DBG("hci%d", index);
1753
1754
init_device(index);
1755
1756
memset(&di, 0, sizeof(di));
1757
1758
if (hci_devinfo(index, &di) < 0)
1759
return;
1760
1761
devup = hci_test_bit(HCI_UP, &di.flags);
1762
1763
if (!ignore_device(&di))
1764
manager_register_adapter(index, devup);
1765
}
1766
1767
static void device_event(int event, int index)
1768
{
1769
switch (event) {
1770
case HCI_DEV_REG:
1771
info("HCI dev %d registered", index);
1772
device_devreg_setup(index);
1773
break;
1774
1775
case HCI_DEV_UNREG:
1776
info("HCI dev %d unregistered", index);
1777
stop_hci_dev(index);
1778
manager_unregister_adapter(index);
1779
break;
1780
1781
case HCI_DEV_UP:
1782
info("HCI dev %d up", index);
1783
UP(index) = TRUE;
1784
device_devup_setup(index);
1785
break;
1786
1787
case HCI_DEV_DOWN:
1788
info("HCI dev %d down", index);
1789
UP(index) = FALSE;
1790
if (!PENDING(index)) {
1791
manager_stop_adapter(index);
1792
init_pending(index);
1793
}
1794
break;
1795
}
1796
}
1797
1798
static gboolean init_known_adapters(gpointer user_data)
1799
{
1800
struct hci_dev_list_req *dl;
1801
struct hci_dev_req *dr;
1802
int i, err, ctl = GPOINTER_TO_INT(user_data);
1803
size_t req_size;
1804
1805
DBG("");
1806
1807
req_size = HCI_MAX_DEV * sizeof(struct hci_dev_req) + sizeof(uint16_t);
1808
1809
dl = g_try_malloc0(req_size);
1810
if (!dl) {
1811
error("Can't allocate devlist buffer");
1812
return FALSE;
1813
}
1814
1815
dl->dev_num = HCI_MAX_DEV;
1816
dr = dl->dev_req;
1817
1818
if (ioctl(ctl, HCIGETDEVLIST, dl) < 0) {
1819
err = -errno;
1820
error("Can't get device list: %s (%d)", strerror(-err), -err);
1821
g_free(dl);
1822
return FALSE;
1823
}
1824
1825
for (i = 0; i < dl->dev_num; i++, dr++) {
1826
device_event(HCI_DEV_REG, dr->dev_id);
1827
1828
if (!hci_test_bit(HCI_UP, &dr->dev_opt))
1829
continue;
1830
1831
PENDING(dr->dev_id) = 0;
1832
hci_set_bit(PENDING_VERSION, &PENDING(dr->dev_id));
1833
hci_send_cmd(SK(dr->dev_id), OGF_INFO_PARAM,
1834
OCF_READ_LOCAL_VERSION, 0, NULL);
1835
device_event(HCI_DEV_UP, dr->dev_id);
1836
}
1837
1838
g_free(dl);
1839
1840
return FALSE;
1841
}
1842
1843
static gboolean io_stack_event(GIOChannel *chan, GIOCondition cond,
1844
gpointer data)
1845
{
1846
unsigned char buf[HCI_MAX_FRAME_SIZE], *ptr;
1847
evt_stack_internal *si;
1848
evt_si_device *sd;
1849
hci_event_hdr *eh;
1850
int type;
1851
size_t len;
1852
GIOError err;
1853
1854
ptr = buf;
1855
1856
err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len);
1857
if (err) {
1858
if (err == G_IO_ERROR_AGAIN)
1859
return TRUE;
1860
1861
error("Read from control socket failed: %s (%d)",
1862
strerror(errno), errno);
1863
return FALSE;
1864
}
1865
1866
type = *ptr++;
1867
1868
if (type != HCI_EVENT_PKT)
1869
return TRUE;
1870
1871
eh = (hci_event_hdr *) ptr;
1872
if (eh->evt != EVT_STACK_INTERNAL)
1873
return TRUE;
1874
1875
ptr += HCI_EVENT_HDR_SIZE;
1876
1877
si = (evt_stack_internal *) ptr;
1878
switch (si->type) {
1879
case EVT_SI_DEVICE:
1880
sd = (void *) &si->data;
1881
device_event(sd->event, sd->dev_id);
1882
break;
1883
}
1884
1885
return TRUE;
1886
}
1887
1888
static int hciops_setup(void)
1889
{
1890
struct sockaddr_hci addr;
1891
struct hci_filter flt;
1892
GIOChannel *ctl_io, *child_io;
1893
int sock, err;
1894
1895
DBG("");
1896
1897
if (child_pipe[0] != -1)
1898
return -EALREADY;
1899
1900
if (pipe(child_pipe) < 0) {
1901
err = -errno;
1902
error("pipe(): %s (%d)", strerror(-err), -err);
1903
return err;
1904
}
1905
1906
child_io = g_io_channel_unix_new(child_pipe[0]);
1907
g_io_channel_set_close_on_unref(child_io, TRUE);
1908
child_io_id = g_io_add_watch(child_io,
1909
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
1910
child_exit, NULL);
1911
g_io_channel_unref(child_io);
1912
1913
/* Create and bind HCI socket */
1914
sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
1915
if (sock < 0) {
1916
err = -errno;
1917
error("Can't open HCI socket: %s (%d)", strerror(-err),
1918
-err);
1919
return err;
1920
}
1921
1922
/* Set filter */
1923
hci_filter_clear(&flt);
1924
hci_filter_set_ptype(HCI_EVENT_PKT, &flt);
1925
hci_filter_set_event(EVT_STACK_INTERNAL, &flt);
1926
if (setsockopt(sock, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {
1927
err = -errno;
1928
error("Can't set filter: %s (%d)", strerror(-err), -err);
1929
return err;
1930
}
1931
1932
memset(&addr, 0, sizeof(addr));
1933
addr.hci_family = AF_BLUETOOTH;
1934
addr.hci_dev = HCI_DEV_NONE;
1935
if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1936
err = -errno;
1937
error("Can't bind HCI socket: %s (%d)", strerror(-err), -err);
1938
return err;
1939
}
1940
1941
ctl_io = g_io_channel_unix_new(sock);
1942
g_io_channel_set_close_on_unref(ctl_io, TRUE);
1943
1944
ctl_io_id = g_io_add_watch(ctl_io, G_IO_IN, io_stack_event, NULL);
1945
1946
g_io_channel_unref(ctl_io);
1947
1948
g_idle_add(init_known_adapters, GINT_TO_POINTER(sock));
1949
1950
return 0;
1951
}
1952
1953
static void hciops_cleanup(void)
1954
{
1955
int i;
1956
1957
DBG("");
1958
1959
for (i = 0; i <= max_dev; i++) {
1960
if (SK(i) >= 0)
1961
hci_close_dev(SK(i));
1962
}
1963
1964
g_free(devs);
1965
devs = NULL;
1966
max_dev = -1;
1967
1968
if (child_io_id) {
1969
g_source_remove(child_io_id);
1970
child_io_id = 0;
1971
}
1972
1973
if (ctl_io_id) {
1974
g_source_remove(ctl_io_id);
1975
ctl_io_id = 0;
1976
}
1977
1978
if (child_pipe[0] >= 0) {
1979
close(child_pipe[0]);
1980
child_pipe[0] = -1;
1981
}
1982
1983
if (child_pipe[1] >= 0) {
1984
close(child_pipe[1]);
1985
child_pipe[1] = -1;
1986
}
1987
}
1988
1989
static int hciops_start(int index)
1990
{
1991
int err;
1992
1993
DBG("hci%d", index);
1994
1995
if (ioctl(SK(index), HCIDEVUP, index) == 0)
1996
return 0;
1997
1998
if (errno == EALREADY)
1999
return 0;
2000
2001
err = -errno;
2002
error("Can't init device hci%d: %s (%d)",
2003
index, strerror(-err), -err);
2004
2005
return err;
2006
}
2007
2008
static int hciops_stop(int index)
2009
{
2010
int err = 0;
2011
2012
DBG("hci%d", index);
2013
2014
if (ioctl(SK(index), HCIDEVDOWN, index) == 0)
2015
goto done; /* on success */
2016
2017
if (errno != EALREADY) {
2018
err = -errno;
2019
error("Can't stop device hci%d: %s (%d)",
2020
index, strerror(-err), -err);
2021
}
2022
2023
done:
2024
return err;
2025
}
2026
2027
static int hciops_powered(int index, gboolean powered)
2028
{
2029
uint8_t mode = SCAN_DISABLED;
2030
2031
DBG("hci%d powered %d", index, powered);
2032
2033
if (powered)
2034
return hciops_start(index);
2035
2036
if (hci_send_cmd(SK(index), OGF_HOST_CTL,
2037
OCF_WRITE_SCAN_ENABLE, 1, &mode) < 0)
2038
return -errno;
2039
2040
return hciops_stop(index);
2041
}
2042
2043
static int hciops_connectable(int index)
2044
{
2045
uint8_t mode = SCAN_PAGE;
2046
2047
DBG("hci%d", index);
2048
2049
if (hci_send_cmd(SK(index), OGF_HOST_CTL,
2050
OCF_WRITE_SCAN_ENABLE, 1, &mode) < 0)
2051
return -errno;
2052
2053
return 0;
2054
}
2055
2056
static int hciops_discoverable(int index)
2057
{
2058
uint8_t mode = (SCAN_PAGE | SCAN_INQUIRY);
2059
2060
DBG("hci%d", index);
2061
2062
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE,
2063
1, &mode) < 0)
2064
return -errno;
2065
2066
return 0;
2067
}
2068
2069
static int hciops_set_class(int index, uint32_t class)
2070
{
2071
write_class_of_dev_cp cp;
2072
2073
DBG("hci%d class 0x%06x", index, class);
2074
2075
memcpy(cp.dev_class, &class, 3);
2076
2077
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_CLASS_OF_DEV,
2078
WRITE_CLASS_OF_DEV_CP_SIZE, &cp) < 0)
2079
return -errno;
2080
2081
return 0;
2082
}
2083
2084
static int hciops_set_limited_discoverable(int index, uint32_t class,
2085
gboolean limited)
2086
{
2087
int num = (limited ? 2 : 1);
2088
uint8_t lap[] = { 0x33, 0x8b, 0x9e, 0x00, 0x8b, 0x9e };
2089
write_current_iac_lap_cp cp;
2090
2091
DBG("hci%d, class %06x limited %d", index, class, limited);
2092
2093
/*
2094
* 1: giac
2095
* 2: giac + liac
2096
*/
2097
memset(&cp, 0, sizeof(cp));
2098
cp.num_current_iac = num;
2099
memcpy(&cp.lap, lap, num * 3);
2100
2101
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_CURRENT_IAC_LAP,
2102
(num * 3 + 1), &cp) < 0)
2103
return -errno;
2104
2105
return hciops_set_class(index, class);
2106
}
2107
2108
static int hciops_start_inquiry(int index, uint8_t length, gboolean periodic)
2109
{
2110
uint8_t lap[3] = { 0x33, 0x8b, 0x9e };
2111
int err;
2112
2113
DBG("hci%d length %u periodic %d", index, length, periodic);
2114
2115
if (periodic) {
2116
periodic_inquiry_cp cp;
2117
2118
memset(&cp, 0, sizeof(cp));
2119
memcpy(&cp.lap, lap, 3);
2120
cp.max_period = htobs(24);
2121
cp.min_period = htobs(16);
2122
cp.length = length;
2123
cp.num_rsp = 0x00;
2124
2125
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2126
OCF_PERIODIC_INQUIRY,
2127
PERIODIC_INQUIRY_CP_SIZE, &cp);
2128
} else {
2129
inquiry_cp inq_cp;
2130
2131
memset(&inq_cp, 0, sizeof(inq_cp));
2132
memcpy(&inq_cp.lap, lap, 3);
2133
inq_cp.length = length;
2134
inq_cp.num_rsp = 0x00;
2135
2136
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2137
OCF_INQUIRY, INQUIRY_CP_SIZE, &inq_cp);
2138
}
2139
2140
if (err < 0)
2141
err = -errno;
2142
2143
return err;
2144
}
2145
2146
static int hciops_stop_inquiry(int index)
2147
{
2148
struct hci_dev_info di;
2149
int err;
2150
2151
DBG("hci%d", index);
2152
2153
if (hci_devinfo(index, &di) < 0)
2154
return -errno;
2155
2156
if (hci_test_bit(HCI_INQUIRY, &di.flags))
2157
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2158
OCF_INQUIRY_CANCEL, 0, 0);
2159
else
2160
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2161
OCF_EXIT_PERIODIC_INQUIRY, 0, 0);
2162
if (err < 0)
2163
err = -errno;
2164
2165
return err;
2166
}
2167
2168
static int le_set_scan_enable(int index, uint8_t enable)
2169
{
2170
le_set_scan_enable_cp cp;
2171
2172
DBG("hci%d enable %u", index, enable);
2173
2174
memset(&cp, 0, sizeof(cp));
2175
cp.enable = enable;
2176
cp.filter_dup = 0;
2177
2178
if (hci_send_cmd(SK(index), OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE,
2179
LE_SET_SCAN_ENABLE_CP_SIZE, &cp) < 0)
2180
return -errno;
2181
2182
return 0;
2183
}
2184
2185
static int hciops_start_scanning(int index)
2186
{
2187
le_set_scan_parameters_cp cp;
2188
2189
DBG("hci%d", index);
2190
2191
memset(&cp, 0, sizeof(cp));
2192
cp.type = 0x01; /* Active scanning */
2193
cp.interval = htobs(0x0010);
2194
cp.window = htobs(0x0010);
2195
cp.own_bdaddr_type = 0; /* Public address */
2196
cp.filter = 0; /* Accept all adv packets */
2197
2198
if (hci_send_cmd(SK(index), OGF_LE_CTL, OCF_LE_SET_SCAN_PARAMETERS,
2199
LE_SET_SCAN_PARAMETERS_CP_SIZE, &cp) < 0)
2200
return -errno;
2201
2202
return le_set_scan_enable(index, 1);
2203
}
2204
2205
static int hciops_stop_scanning(int index)
2206
{
2207
DBG("hci%d", index);
2208
2209
return le_set_scan_enable(index, 0);
2210
}
2211
2212
static int hciops_resolve_name(int index, bdaddr_t *bdaddr)
2213
{
2214
remote_name_req_cp cp;
2215
char addr[18];
2216
2217
ba2str(bdaddr, addr);
2218
DBG("hci%d dba %s", index, addr);
2219
2220
memset(&cp, 0, sizeof(cp));
2221
bacpy(&cp.bdaddr, bdaddr);
2222
cp.pscan_rep_mode = 0x02;
2223
2224
if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_REMOTE_NAME_REQ,
2225
REMOTE_NAME_REQ_CP_SIZE, &cp) < 0)
2226
return -errno;
2227
2228
return 0;
2229
}
2230
2231
static int hciops_set_name(int index, const char *name)
2232
{
2233
change_local_name_cp cp;
2234
2235
DBG("hci%d, name %s", index, name);
2236
2237
memset(&cp, 0, sizeof(cp));
2238
strncpy((char *) cp.name, name, sizeof(cp.name));
2239
2240
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_CHANGE_LOCAL_NAME,
2241
CHANGE_LOCAL_NAME_CP_SIZE, &cp) < 0)
2242
return -errno;
2243
2244
return 0;
2245
}
2246
2247
static int hciops_cancel_resolve_name(int index, bdaddr_t *bdaddr)
2248
{
2249
remote_name_req_cancel_cp cp;
2250
char addr[18];
2251
2252
ba2str(bdaddr, addr);
2253
DBG("hci%d dba %s", index, addr);
2254
2255
memset(&cp, 0, sizeof(cp));
2256
bacpy(&cp.bdaddr, bdaddr);
2257
2258
if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_REMOTE_NAME_REQ_CANCEL,
2259
REMOTE_NAME_REQ_CANCEL_CP_SIZE, &cp) < 0)
2260
return -errno;
2261
2262
return 0;
2263
}
2264
2265
static int hciops_fast_connectable(int index, gboolean enable)
2266
{
2267
write_page_activity_cp cp;
2268
uint8_t type;
2269
2270
DBG("hci%d enable %d", index, enable);
2271
2272
if (enable) {
2273
type = PAGE_SCAN_TYPE_INTERLACED;
2274
cp.interval = 0x0024; /* 22.5 msec page scan interval */
2275
} else {
2276
type = PAGE_SCAN_TYPE_STANDARD; /* default */
2277
cp.interval = 0x0800; /* default 1.28 sec page scan */
2278
}
2279
2280
cp.window = 0x0012; /* default 11.25 msec page scan window */
2281
2282
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_WRITE_PAGE_ACTIVITY,
2283
WRITE_PAGE_ACTIVITY_CP_SIZE, &cp) < 0)
2284
return -errno;
2285
else if (hci_send_cmd(SK(index), OGF_HOST_CTL,
2286
OCF_WRITE_PAGE_SCAN_TYPE, 1, &type) < 0)
2287
return -errno;
2288
2289
return 0;
2290
}
2291
2292
static int hciops_read_clock(int index, int handle, int which, int timeout,
2293
uint32_t *clock, uint16_t *accuracy)
2294
{
2295
DBG("hci%d handle %d which %d timeout %d", index, handle, which,
2296
timeout);
2297
2298
if (hci_read_clock(SK(index), handle, which, clock, accuracy,
2299
timeout) < 0)
2300
return -errno;
2301
2302
return 0;
2303
}
2304
2305
static int hciops_conn_handle(int index, const bdaddr_t *bdaddr, int *handle)
2306
{
2307
int err;
2308
struct hci_conn_info_req *cr;
2309
char addr[18];
2310
2311
ba2str(bdaddr, addr);
2312
DBG("hci%d dba %s", index, addr);
2313
2314
cr = g_malloc0(sizeof(*cr) + sizeof(struct hci_conn_info));
2315
bacpy(&cr->bdaddr, bdaddr);
2316
cr->type = ACL_LINK;
2317
2318
if (ioctl(SK(index), HCIGETCONNINFO, (unsigned long) cr) < 0) {
2319
err = -errno;
2320
goto fail;
2321
}
2322
2323
err = 0;
2324
*handle = htobs(cr->conn_info->handle);
2325
2326
fail:
2327
g_free(cr);
2328
return err;
2329
}
2330
2331
static int hciops_write_eir_data(int index, uint8_t *data)
2332
{
2333
write_ext_inquiry_response_cp cp;
2334
2335
DBG("hci%d", index);
2336
2337
memset(&cp, 0, sizeof(cp));
2338
memcpy(cp.data, data, 240);
2339
2340
if (hci_send_cmd(SK(index), OGF_HOST_CTL,
2341
OCF_WRITE_EXT_INQUIRY_RESPONSE,
2342
WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE, &cp) < 0)
2343
return -errno;
2344
2345
return 0;
2346
}
2347
2348
static int hciops_read_bdaddr(int index, bdaddr_t *bdaddr)
2349
{
2350
DBG("hci%d", index);
2351
bacpy(bdaddr, &BDADDR(index));
2352
return 0;
2353
}
2354
2355
static int hciops_block_device(int index, bdaddr_t *bdaddr)
2356
{
2357
char addr[18];
2358
2359
ba2str(bdaddr, addr);
2360
DBG("hci%d dba %s", index, addr);
2361
2362
if (ioctl(SK(index), HCIBLOCKADDR, bdaddr) < 0)
2363
return -errno;
2364
2365
return 0;
2366
}
2367
2368
static int hciops_unblock_device(int index, bdaddr_t *bdaddr)
2369
{
2370
char addr[18];
2371
2372
ba2str(bdaddr, addr);
2373
DBG("hci%d dba %s", index, addr);
2374
2375
if (ioctl(SK(index), HCIUNBLOCKADDR, bdaddr) < 0)
2376
return -errno;
2377
2378
return 0;
2379
}
2380
2381
static int hciops_get_conn_list(int index, GSList **conns)
2382
{
2383
struct hci_conn_list_req *cl;
2384
struct hci_conn_info *ci;
2385
int err, i;
2386
2387
DBG("hci%d", index);
2388
2389
cl = g_malloc0(10 * sizeof(*ci) + sizeof(*cl));
2390
2391
cl->dev_id = index;
2392
cl->conn_num = 10;
2393
ci = cl->conn_info;
2394
2395
if (ioctl(SK(index), HCIGETCONNLIST, cl) < 0) {
2396
err = -errno;
2397
goto fail;
2398
}
2399
2400
err = 0;
2401
*conns = NULL;
2402
2403
for (i = 0; i < cl->conn_num; i++, ci++)
2404
*conns = g_slist_append(*conns, g_memdup(ci, sizeof(*ci)));
2405
2406
fail:
2407
g_free(cl);
2408
return err;
2409
}
2410
2411
static int hciops_read_local_version(int index, struct hci_version *ver)
2412
{
2413
DBG("hci%d", index);
2414
memcpy(ver, &VER(index), sizeof(*ver));
2415
return 0;
2416
}
2417
2418
static int hciops_read_local_features(int index, uint8_t *features)
2419
{
2420
DBG("hci%d", index);
2421
memcpy(features, FEATURES(index), 8);
2422
return 0;
2423
}
2424
2425
static int hciops_read_local_ext_features(int index)
2426
{
2427
uint8_t page_num = 1;
2428
2429
DBG("hci%d", index);
2430
2431
if (hci_send_cmd(SK(index), OGF_INFO_PARAM,
2432
OCF_READ_LOCAL_EXT_FEATURES, 1, &page_num) < 0)
2433
return -errno;
2434
2435
return 0;
2436
}
2437
2438
static int hciops_read_link_policy(int index)
2439
{
2440
DBG("hci%d", index);
2441
2442
if (hci_send_cmd(SK(index), OGF_LINK_POLICY,
2443
OCF_READ_DEFAULT_LINK_POLICY, 0, NULL) < 0)
2444
return -errno;
2445
2446
return 0;
2447
}
2448
2449
static int hciops_disconnect(int index, uint16_t handle)
2450
{
2451
disconnect_cp cp;
2452
2453
DBG("hci%d handle %u", index, handle);
2454
2455
memset(&cp, 0, sizeof(cp));
2456
cp.handle = htobs(handle);
2457
cp.reason = HCI_OE_USER_ENDED_CONNECTION;
2458
2459
if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_DISCONNECT,
2460
DISCONNECT_CP_SIZE, &cp) < 0)
2461
return -errno;
2462
2463
return 0;
2464
}
2465
2466
static int hciops_remove_bonding(int index, bdaddr_t *bdaddr)
2467
{
2468
delete_stored_link_key_cp cp;
2469
char addr[18];
2470
2471
ba2str(bdaddr, addr);
2472
DBG("hci%d dba %s", index, addr);
2473
2474
memset(&cp, 0, sizeof(cp));
2475
bacpy(&cp.bdaddr, bdaddr);
2476
2477
/* Delete the link key from the Bluetooth chip */
2478
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_DELETE_STORED_LINK_KEY,
2479
DELETE_STORED_LINK_KEY_CP_SIZE, &cp) < 0)
2480
return -errno;
2481
2482
return 0;
2483
}
2484
2485
static int hciops_request_authentication(int index, uint16_t handle)
2486
{
2487
auth_requested_cp cp;
2488
2489
DBG("hci%d handle %u", index, handle);
2490
2491
memset(&cp, 0, sizeof(cp));
2492
cp.handle = htobs(handle);
2493
2494
if (hci_send_cmd(SK(index), OGF_LINK_CTL, OCF_AUTH_REQUESTED,
2495
AUTH_REQUESTED_CP_SIZE, &cp) < 0)
2496
return -errno;
2497
2498
return 0;
2499
}
2500
2501
static int hciops_pincode_reply(int index, bdaddr_t *bdaddr, const char *pin)
2502
{
2503
char addr[18];
2504
int err;
2505
2506
ba2str(bdaddr, addr);
2507
DBG("hci%d dba %s", index, addr);
2508
2509
if (pin) {
2510
pin_code_reply_cp pr;
2511
size_t len = strlen(pin);
2512
2513
PIN_LENGTH(index) = len;
2514
2515
memset(&pr, 0, sizeof(pr));
2516
bacpy(&pr.bdaddr, bdaddr);
2517
memcpy(pr.pin_code, pin, len);
2518
pr.pin_len = len;
2519
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2520
OCF_PIN_CODE_REPLY,
2521
PIN_CODE_REPLY_CP_SIZE, &pr);
2522
} else
2523
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2524
OCF_PIN_CODE_NEG_REPLY, 6, bdaddr);
2525
2526
if (err < 0)
2527
err = -errno;
2528
2529
return err;
2530
}
2531
2532
static int hciops_confirm_reply(int index, bdaddr_t *bdaddr, gboolean success)
2533
{
2534
user_confirm_reply_cp cp;
2535
char addr[18];
2536
int err;
2537
2538
ba2str(bdaddr, addr);
2539
DBG("hci%d dba %s success %d", index, addr, success);
2540
2541
memset(&cp, 0, sizeof(cp));
2542
bacpy(&cp.bdaddr, bdaddr);
2543
2544
if (success)
2545
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2546
OCF_USER_CONFIRM_REPLY,
2547
USER_CONFIRM_REPLY_CP_SIZE, &cp);
2548
else
2549
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2550
OCF_USER_CONFIRM_NEG_REPLY,
2551
USER_CONFIRM_REPLY_CP_SIZE, &cp);
2552
2553
if (err < 0)
2554
err = -errno;
2555
2556
return err;
2557
}
2558
2559
static int hciops_passkey_reply(int index, bdaddr_t *bdaddr, uint32_t passkey)
2560
{
2561
char addr[18];
2562
int err;
2563
2564
ba2str(bdaddr, addr);
2565
DBG("hci%d dba %s", index, addr);
2566
2567
if (passkey != INVALID_PASSKEY) {
2568
user_passkey_reply_cp cp;
2569
2570
memset(&cp, 0, sizeof(cp));
2571
bacpy(&cp.bdaddr, bdaddr);
2572
cp.passkey = passkey;
2573
2574
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2575
OCF_USER_PASSKEY_REPLY,
2576
USER_PASSKEY_REPLY_CP_SIZE, &cp);
2577
} else
2578
err = hci_send_cmd(SK(index), OGF_LINK_CTL,
2579
OCF_USER_PASSKEY_NEG_REPLY, 6, bdaddr);
2580
2581
if (err < 0)
2582
err = -errno;
2583
2584
return err;
2585
}
2586
2587
static int hciops_get_auth_info(int index, bdaddr_t *bdaddr, uint8_t *auth)
2588
{
2589
struct hci_auth_info_req req;
2590
char addr[18];
2591
2592
ba2str(bdaddr, addr);
2593
DBG("hci%d dba %s", index, addr);
2594
2595
memset(&req, 0, sizeof(req));
2596
bacpy(&req.bdaddr, bdaddr);
2597
2598
if (ioctl(SK(index), HCIGETAUTHINFO, (unsigned long) &req) < 0)
2599
return -errno;
2600
2601
if (auth)
2602
*auth = req.type;
2603
2604
return 0;
2605
}
2606
2607
static int hciops_read_scan_enable(int index)
2608
{
2609
DBG("hci%d", index);
2610
2611
if (hci_send_cmd(SK(index), OGF_HOST_CTL, OCF_READ_SCAN_ENABLE,
2612
0, NULL) < 0)
2613
return -errno;
2614
2615
return 0;
2616
}
2617
2618
static int hciops_write_le_host(int index, uint8_t le, uint8_t simul)
2619
{
2620
write_le_host_supported_cp cp;
2621
2622
DBG("hci%d le %u simul %u", index, le, simul);
2623
2624
memset(&cp, 0, sizeof(cp));
2625
cp.le = le;
2626
cp.simul = simul;
2627
2628
if (hci_send_cmd(SK(index), OGF_HOST_CTL,
2629
OCF_WRITE_LE_HOST_SUPPORTED,
2630
WRITE_LE_HOST_SUPPORTED_CP_SIZE, &cp) < 0)
2631
return -errno;
2632
2633
return 0;
2634
}
2635
2636
struct remote_version_req {
2637
int index;
2638
uint16_t handle;
2639
};
2640
2641
static gboolean get_remote_version(gpointer user_data)
2642
{
2643
struct remote_version_req *req = user_data;
2644
read_remote_version_cp cp;
2645
2646
DBG("hci%d handle %u", req->index, req->handle);
2647
2648
memset(&cp, 0, sizeof(cp));
2649
cp.handle = htobs(req->handle);
2650
2651
hci_send_cmd(SK(req->index), OGF_LINK_CTL, OCF_READ_REMOTE_VERSION,
2652
READ_REMOTE_VERSION_CP_SIZE, &cp);
2653
2654
return FALSE;
2655
}
2656
2657
static int hciops_get_remote_version(int index, uint16_t handle,
2658
gboolean delayed)
2659
{
2660
struct remote_version_req *req;
2661
2662
DBG("hci%d handle %u delayed %d", index, handle, delayed);
2663
2664
req = g_new0(struct remote_version_req, 1);
2665
req->handle = handle;
2666
req->index = index;
2667
2668
if (!delayed) {
2669
get_remote_version(req);
2670
g_free(req);
2671
return 0;
2672
}
2673
2674
g_timeout_add_seconds_full(G_PRIORITY_DEFAULT, 1, get_remote_version,
2675
req, g_free);
2676
2677
return 0;
2678
}
2679
2680
static struct btd_adapter_ops hci_ops = {
2681
.setup = hciops_setup,
2682
.cleanup = hciops_cleanup,
2683
.start = hciops_start,
2684
.stop = hciops_stop,
2685
.set_powered = hciops_powered,
2686
.set_connectable = hciops_connectable,
2687
.set_discoverable = hciops_discoverable,
2688
.set_limited_discoverable = hciops_set_limited_discoverable,
2689
.start_inquiry = hciops_start_inquiry,
2690
.stop_inquiry = hciops_stop_inquiry,
2691
.start_scanning = hciops_start_scanning,
2692
.stop_scanning = hciops_stop_scanning,
2693
.resolve_name = hciops_resolve_name,
2694
.cancel_resolve_name = hciops_cancel_resolve_name,
2695
.set_name = hciops_set_name,
2696
.set_class = hciops_set_class,
2697
.set_fast_connectable = hciops_fast_connectable,
2698
.read_clock = hciops_read_clock,
2699
.get_conn_handle = hciops_conn_handle,
2700
.write_eir_data = hciops_write_eir_data,
2701
.read_bdaddr = hciops_read_bdaddr,
2702
.block_device = hciops_block_device,
2703
.unblock_device = hciops_unblock_device,
2704
.get_conn_list = hciops_get_conn_list,
2705
.read_local_version = hciops_read_local_version,
2706
.read_local_features = hciops_read_local_features,
2707
.read_local_ext_features = hciops_read_local_ext_features,
2708
.read_link_policy = hciops_read_link_policy,
2709
.disconnect = hciops_disconnect,
2710
.remove_bonding = hciops_remove_bonding,
2711
.request_authentication = hciops_request_authentication,
2712
.pincode_reply = hciops_pincode_reply,
2713
.confirm_reply = hciops_confirm_reply,
2714
.passkey_reply = hciops_passkey_reply,
2715
.get_auth_info = hciops_get_auth_info,
2716
.read_scan_enable = hciops_read_scan_enable,
2717
.write_le_host = hciops_write_le_host,
2718
.get_remote_version = hciops_get_remote_version,
2719
.encrypt_link = hciops_encrypt_link,
2720
};
2721
2722
static int hciops_init(void)
2723
{
2724
DBG("");
2725
return btd_register_adapter_ops(&hci_ops, FALSE);
2726
}
2727
2728
static void hciops_exit(void)
2729
{
2730
DBG("");
2731
btd_adapter_cleanup_ops(&hci_ops);
2732
}
2733
2734
BLUETOOTH_PLUGIN_DEFINE(hciops, VERSION,
2735
BLUETOOTH_PLUGIN_PRIORITY_LOW, hciops_init, hciops_exit)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1