projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/ide-2.6
[linux-block.git] / net / bluetooth / hci_conn.c
CommitLineData
8e87d142 1/*
1da177e4 2 BlueZ - Bluetooth protocol stack for Linux
2d0a0346 3 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
1da177e4
LT		 4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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 version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142
YH		 15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4
LT		 18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
8e87d142
YH		 20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4
LT		 22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI connection handling. */
26
1da177e4
LT		 27#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
1da177e4
LT		 32#include <linux/slab.h>
33#include <linux/poll.h>
34#include <linux/fcntl.h>
35#include <linux/init.h>
36#include <linux/skbuff.h>
37#include <linux/interrupt.h>
38#include <linux/notifier.h>
39#include <net/sock.h>
40
41#include <asm/system.h>
70f23020 42#include <linux/uaccess.h>
1da177e4
LT		 43#include <asm/unaligned.h>
44
45#include <net/bluetooth/bluetooth.h>
46#include <net/bluetooth/hci_core.h>
47
fcd89c09
VT		 48static void hci_le_connect(struct hci_conn *conn)
49{
50 struct hci_dev *hdev = conn->hdev;
51 struct hci_cp_le_create_conn cp;
52
53 conn->state = BT_CONNECT;
54 conn->out = 1;
b92a6223 55 conn->link_mode |= HCI_LM_MASTER;
fcd89c09
VT		 56
57 memset(&cp, 0, sizeof(cp));
58 cp.scan_interval = cpu_to_le16(0x0004);
59 cp.scan_window = cpu_to_le16(0x0004);
60 bacpy(&cp.peer_addr, &conn->dst);
61 cp.conn_interval_min = cpu_to_le16(0x0008);
62 cp.conn_interval_max = cpu_to_le16(0x0100);
63 cp.supervision_timeout = cpu_to_le16(0x0064);
64 cp.min_ce_len = cpu_to_le16(0x0001);
65 cp.max_ce_len = cpu_to_le16(0x0001);
66
67 hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
68}
69
70static void hci_le_connect_cancel(struct hci_conn *conn)
71{
72 hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
73}
74
4c67bc74 75void hci_acl_connect(struct hci_conn *conn)
1da177e4
LT		 76{
77 struct hci_dev *hdev = conn->hdev;
78 struct inquiry_entry *ie;
79 struct hci_cp_create_conn cp;
80
81 BT_DBG("%p", conn);
82
83 conn->state = BT_CONNECT;
a8746417
MH		 84 conn->out = 1;
85
1da177e4
LT		 86 conn->link_mode = HCI_LM_MASTER;
87
4c67bc74
MH		 88 conn->attempt++;
89
e4e8e37c
MH		 90 conn->link_policy = hdev->link_policy;
91
1da177e4
LT		 92 memset(&cp, 0, sizeof(cp));
93 bacpy(&cp.bdaddr, &conn->dst);
94 cp.pscan_rep_mode = 0x02;
95
70f23020
AE		 96 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
97 if (ie) {
41a96212
MH		 98 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
99 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
100 cp.pscan_mode = ie->data.pscan_mode;
101 cp.clock_offset = ie->data.clock_offset |
102 cpu_to_le16(0x8000);
103 }
104
1da177e4 105 memcpy(conn->dev_class, ie->data.dev_class, 3);
41a96212 106 conn->ssp_mode = ie->data.ssp_mode;
1da177e4
LT		 107 }
108
a8746417 109 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1da177e4 110 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
b6a0dc82 111 cp.role_switch = 0x01;
1da177e4 112 else
b6a0dc82 113 cp.role_switch = 0x00;
4c67bc74 114
a9de9248 115 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
1da177e4
LT		 116}
117
6ac59344
MH		 118static void hci_acl_connect_cancel(struct hci_conn *conn)
119{
120 struct hci_cp_create_conn_cancel cp;
121
122 BT_DBG("%p", conn);
123
124 if (conn->hdev->hci_ver < 2)
125 return;
126
127 bacpy(&cp.bdaddr, &conn->dst);
a9de9248 128 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
6ac59344
MH		 129}
130
1da177e4
LT		 131void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
132{
133 struct hci_cp_disconnect cp;
134
135 BT_DBG("%p", conn);
136
137 conn->state = BT_DISCONN;
138
aca3192c 139 cp.handle = cpu_to_le16(conn->handle);
1da177e4 140 cp.reason = reason;
a9de9248 141 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
1da177e4
LT		 142}
143
144void hci_add_sco(struct hci_conn *conn, __u16 handle)
145{
146 struct hci_dev *hdev = conn->hdev;
147 struct hci_cp_add_sco cp;
148
149 BT_DBG("%p", conn);
150
151 conn->state = BT_CONNECT;
152 conn->out = 1;
153
efc7688b
MH		 154 conn->attempt++;
155
aca3192c 156 cp.handle = cpu_to_le16(handle);
a8746417 157 cp.pkt_type = cpu_to_le16(conn->pkt_type);
1da177e4 158
a9de9248 159 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
1da177e4
LT		 160}
161
b6a0dc82
MH		 162void hci_setup_sync(struct hci_conn *conn, __u16 handle)
163{
164 struct hci_dev *hdev = conn->hdev;
165 struct hci_cp_setup_sync_conn cp;
166
167 BT_DBG("%p", conn);
168
169 conn->state = BT_CONNECT;
170 conn->out = 1;
171
efc7688b
MH		 172 conn->attempt++;
173
b6a0dc82 174 cp.handle = cpu_to_le16(handle);
a8746417 175 cp.pkt_type = cpu_to_le16(conn->pkt_type);
b6a0dc82
MH		 176
177 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
178 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
179 cp.max_latency = cpu_to_le16(0xffff);
180 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
181 cp.retrans_effort = 0xff;
182
183 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
184}
185
2ce603eb
CT		 186void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
187 u16 latency, u16 to_multiplier)
188{
189 struct hci_cp_le_conn_update cp;
190 struct hci_dev *hdev = conn->hdev;
191
192 memset(&cp, 0, sizeof(cp));
193
194 cp.handle = cpu_to_le16(conn->handle);
195 cp.conn_interval_min = cpu_to_le16(min);
196 cp.conn_interval_max = cpu_to_le16(max);
197 cp.conn_latency = cpu_to_le16(latency);
198 cp.supervision_timeout = cpu_to_le16(to_multiplier);
199 cp.min_ce_len = cpu_to_le16(0x0001);
200 cp.max_ce_len = cpu_to_le16(0x0001);
201
202 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
203}
204EXPORT_SYMBOL(hci_le_conn_update);
205
e73439d8
MH		 206/* Device _must_ be locked */
207void hci_sco_setup(struct hci_conn *conn, __u8 status)
208{
209 struct hci_conn *sco = conn->link;
210
211 BT_DBG("%p", conn);
212
213 if (!sco)
214 return;
215
216 if (!status) {
217 if (lmp_esco_capable(conn->hdev))
218 hci_setup_sync(sco, conn->handle);
219 else
220 hci_add_sco(sco, conn->handle);
221 } else {
222 hci_proto_connect_cfm(sco, status);
223 hci_conn_del(sco);
224 }
225}
226
1da177e4
LT		 227static void hci_conn_timeout(unsigned long arg)
228{
04837f64
MH		 229 struct hci_conn *conn = (void *) arg;
230 struct hci_dev *hdev = conn->hdev;
2950f21a 231 __u8 reason;
1da177e4
LT		 232
233 BT_DBG("conn %p state %d", conn, conn->state);
234
235 if (atomic_read(&conn->refcnt))
236 return;
237
238 hci_dev_lock(hdev);
6ac59344
MH		 239
240 switch (conn->state) {
241 case BT_CONNECT:
769be974 242 case BT_CONNECT2:
fcd89c09
VT		 243 if (conn->out) {
244 if (conn->type == ACL_LINK)
245 hci_acl_connect_cancel(conn);
246 else if (conn->type == LE_LINK)
247 hci_le_connect_cancel(conn);
248 }
6ac59344 249 break;
769be974 250 case BT_CONFIG:
8e87d142 251 case BT_CONNECTED:
2950f21a
MH		 252 reason = hci_proto_disconn_ind(conn);
253 hci_acl_disconn(conn, reason);
6ac59344
MH		 254 break;
255 default:
1da177e4 256 conn->state = BT_CLOSED;
6ac59344
MH		 257 break;
258 }
259
1da177e4 260 hci_dev_unlock(hdev);
1da177e4
LT		 261}
262
04837f64 263static void hci_conn_idle(unsigned long arg)
1da177e4 264{
04837f64
MH		 265 struct hci_conn *conn = (void *) arg;
266
267 BT_DBG("conn %p mode %d", conn, conn->mode);
268
269 hci_conn_enter_sniff_mode(conn);
1da177e4
LT		 270}
271
9f61656a
JH		 272static void hci_conn_auto_accept(unsigned long arg)
273{
274 struct hci_conn *conn = (void *) arg;
275 struct hci_dev *hdev = conn->hdev;
276
277 hci_dev_lock(hdev);
278
279 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
280 &conn->dst);
281
282 hci_dev_unlock(hdev);
283}
284
1da177e4
LT		 285struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
286{
287 struct hci_conn *conn;
288
289 BT_DBG("%s dst %s", hdev->name, batostr(dst));
290
04837f64
MH		 291 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
292 if (!conn)
1da177e4 293 return NULL;
1da177e4
LT		 294
295 bacpy(&conn->dst, dst);
a8746417
MH		 296 conn->hdev = hdev;
297 conn->type = type;
298 conn->mode = HCI_CM_ACTIVE;
299 conn->state = BT_OPEN;
93f19c9f 300 conn->auth_type = HCI_AT_GENERAL_BONDING;
17fa4b9d 301 conn->io_capability = hdev->io_capability;
a9583556 302 conn->remote_auth = 0xff;
13d39315 303 conn->key_type = 0xff;
1da177e4 304
04837f64 305 conn->power_save = 1;
052b30b0 306 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
04837f64 307
a8746417
MH		 308 switch (type) {
309 case ACL_LINK:
310 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
311 break;
312 case SCO_LINK:
313 if (lmp_esco_capable(hdev))
efc7688b
MH		 314 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
315 (hdev->esco_type & EDR_ESCO_MASK);
a8746417
MH		 316 else
317 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
318 break;
319 case ESCO_LINK:
efc7688b 320 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
a8746417
MH		 321 break;
322 }
323
1da177e4 324 skb_queue_head_init(&conn->data_q);
04837f64 325
b24b8a24
PE		 326 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
327 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
9f61656a
JH		 328 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
329 (unsigned long) conn);
1da177e4
LT		 330
331 atomic_set(&conn->refcnt, 0);
332
333 hci_dev_hold(hdev);
334
335 tasklet_disable(&hdev->tx_task);
336
337 hci_conn_hash_add(hdev, conn);
338 if (hdev->notify)
339 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
340
9eba32b8
MH		 341 atomic_set(&conn->devref, 0);
342
a67e899c
MH		 343 hci_conn_init_sysfs(conn);
344
1da177e4
LT		 345 tasklet_enable(&hdev->tx_task);
346
347 return conn;
348}
349
350int hci_conn_del(struct hci_conn *conn)
351{
352 struct hci_dev *hdev = conn->hdev;
353
354 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
355
04837f64
MH		 356 del_timer(&conn->idle_timer);
357
358 del_timer(&conn->disc_timer);
1da177e4 359
9f61656a
JH		 360 del_timer(&conn->auto_accept_timer);
361
5b7f9909 362 if (conn->type == ACL_LINK) {
1da177e4
LT		 363 struct hci_conn *sco = conn->link;
364 if (sco)
365 sco->link = NULL;
366
367 /* Unacked frames */
368 hdev->acl_cnt += conn->sent;
6ed58ec5
VT		 369 } else if (conn->type == LE_LINK) {
370 if (hdev->le_pkts)
371 hdev->le_cnt += conn->sent;
372 else
373 hdev->acl_cnt += conn->sent;
5b7f9909
MH		 374 } else {
375 struct hci_conn *acl = conn->link;
376 if (acl) {
377 acl->link = NULL;
378 hci_conn_put(acl);
379 }
1da177e4
LT		 380 }
381
382 tasklet_disable(&hdev->tx_task);
7d0db0a3 383
1da177e4
LT		 384 hci_conn_hash_del(hdev, conn);
385 if (hdev->notify)
386 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
7d0db0a3 387
1da177e4 388 tasklet_enable(&hdev->tx_task);
7d0db0a3 389
1da177e4 390 skb_queue_purge(&conn->data_q);
1da177e4 391
9eba32b8 392 hci_conn_put_device(conn);
2ae9a6be 393
384943ec
MH		 394 hci_dev_put(hdev);
395
1da177e4
LT		 396 return 0;
397}
398
399struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
400{
401 int use_src = bacmp(src, BDADDR_ANY);
402 struct hci_dev *hdev = NULL;
403 struct list_head *p;
404
405 BT_DBG("%s -> %s", batostr(src), batostr(dst));
406
407 read_lock_bh(&hci_dev_list_lock);
408
409 list_for_each(p, &hci_dev_list) {
410 struct hci_dev *d = list_entry(p, struct hci_dev, list);
411
412 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
413 continue;
414
8e87d142 415 /* Simple routing:
1da177e4
LT		 416 * No source address - find interface with bdaddr != dst
417 * Source address - find interface with bdaddr == src
418 */
419
420 if (use_src) {
421 if (!bacmp(&d->bdaddr, src)) {
422 hdev = d; break;
423 }
424 } else {
425 if (bacmp(&d->bdaddr, dst)) {
426 hdev = d; break;
427 }
428 }
429 }
430
431 if (hdev)
432 hdev = hci_dev_hold(hdev);
433
434 read_unlock_bh(&hci_dev_list_lock);
435 return hdev;
436}
437EXPORT_SYMBOL(hci_get_route);
438
fcd89c09 439/* Create SCO, ACL or LE connection.
1da177e4 440 * Device _must_ be locked */
8c1b2355 441struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type)
1da177e4
LT		 442{
443 struct hci_conn *acl;
5b7f9909 444 struct hci_conn *sco;
fcd89c09 445 struct hci_conn *le;
1da177e4
LT		 446
447 BT_DBG("%s dst %s", hdev->name, batostr(dst));
448
fcd89c09
VT		 449 if (type == LE_LINK) {
450 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
15c4794f 451 if (le)
30e76272 452 return ERR_PTR(-EBUSY);
15c4794f 453 le = hci_conn_add(hdev, LE_LINK, dst);
fcd89c09 454 if (!le)
30e76272 455 return ERR_PTR(-ENOMEM);
fcd89c09
VT		 456 if (le->state == BT_OPEN)
457 hci_le_connect(le);
458
459 hci_conn_hold(le);
460
461 return le;
462 }
463
70f23020
AE		 464 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
465 if (!acl) {
466 acl = hci_conn_add(hdev, ACL_LINK, dst);
467 if (!acl)
1da177e4
LT		 468 return NULL;
469 }
470
471 hci_conn_hold(acl);
472
09ab6f4c 473 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
765c2a96
JH		 474 acl->sec_level = BT_SECURITY_LOW;
475 acl->pending_sec_level = sec_level;
09ab6f4c 476 acl->auth_type = auth_type;
1da177e4 477 hci_acl_connect(acl);
09ab6f4c 478 }
1da177e4 479
5b7f9909
MH		 480 if (type == ACL_LINK)
481 return acl;
1da177e4 482
70f23020
AE		 483 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
484 if (!sco) {
485 sco = hci_conn_add(hdev, type, dst);
486 if (!sco) {
5b7f9909
MH		 487 hci_conn_put(acl);
488 return NULL;
1da177e4 489 }
5b7f9909 490 }
1da177e4 491
5b7f9909
MH		 492 acl->link = sco;
493 sco->link = acl;
1da177e4 494
5b7f9909 495 hci_conn_hold(sco);
1da177e4 496
5b7f9909 497 if (acl->state == BT_CONNECTED &&
b6a0dc82 498 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
c390216b
NP		 499 acl->power_save = 1;
500 hci_conn_enter_active_mode(acl);
501
e73439d8
MH		 502 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->pend)) {
503 /* defer SCO setup until mode change completed */
504 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->pend);
505 return sco;
506 }
507
508 hci_sco_setup(acl, 0x00);
b6a0dc82 509 }
5b7f9909
MH		 510
511 return sco;
1da177e4
LT		 512}
513EXPORT_SYMBOL(hci_connect);
514
e7c29cb1
MH		 515/* Check link security requirement */
516int hci_conn_check_link_mode(struct hci_conn *conn)
517{
518 BT_DBG("conn %p", conn);
519
520 if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
521 !(conn->link_mode & HCI_LM_ENCRYPT))
522 return 0;
523
524 return 1;
525}
526EXPORT_SYMBOL(hci_conn_check_link_mode);
527
1da177e4 528/* Authenticate remote device */
0684e5f9 529static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
1da177e4
LT		 530{
531 BT_DBG("conn %p", conn);
532
765c2a96
JH		 533 if (conn->pending_sec_level > sec_level)
534 sec_level = conn->pending_sec_level;
535
96a31833 536 if (sec_level > conn->sec_level)
765c2a96 537 conn->pending_sec_level = sec_level;
96a31833 538 else if (conn->link_mode & HCI_LM_AUTH)
1da177e4
LT		 539 return 1;
540
65cf686e
JH		 541 /* Make sure we preserve an existing MITM requirement*/
542 auth_type |= (conn->auth_type & 0x01);
543
96a31833
MH		 544 conn->auth_type = auth_type;
545
1da177e4
LT		 546 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
547 struct hci_cp_auth_requested cp;
aca3192c 548 cp.handle = cpu_to_le16(conn->handle);
40be492f
MH		 549 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
550 sizeof(cp), &cp);
1da177e4 551 }
8c1b2355 552
1da177e4
LT		 553 return 0;
554}
1da177e4 555
13d39315
WR		 556/* Encrypt the the link */
557static void hci_conn_encrypt(struct hci_conn *conn)
558{
559 BT_DBG("conn %p", conn);
560
561 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
562 struct hci_cp_set_conn_encrypt cp;
563 cp.handle = cpu_to_le16(conn->handle);
564 cp.encrypt = 0x01;
565 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
566 &cp);
567 }
568}
569
8c1b2355 570/* Enable security */
0684e5f9 571int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
1da177e4
LT		 572{
573 BT_DBG("conn %p", conn);
574
13d39315 575 /* For sdp we don't need the link key. */
8c1b2355
MH		 576 if (sec_level == BT_SECURITY_SDP)
577 return 1;
578
13d39315
WR		 579 /* For non 2.1 devices and low security level we don't need the link
580 key. */
3fdca1e1
MH		 581 if (sec_level == BT_SECURITY_LOW &&
582 (!conn->ssp_mode || !conn->hdev->ssp_mode))
583 return 1;
8c1b2355 584
13d39315
WR		 585 /* For other security levels we need the link key. */
586 if (!(conn->link_mode & HCI_LM_AUTH))
587 goto auth;
588
589 /* An authenticated combination key has sufficient security for any
590 security level. */
591 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
592 goto encrypt;
593
594 /* An unauthenticated combination key has sufficient security for
595 security level 1 and 2. */
596 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
597 (sec_level == BT_SECURITY_MEDIUM ||
598 sec_level == BT_SECURITY_LOW))
599 goto encrypt;
600
601 /* A combination key has always sufficient security for the security
602 levels 1 or 2. High security level requires the combination key
603 is generated using maximum PIN code length (16).
604 For pre 2.1 units. */
605 if (conn->key_type == HCI_LK_COMBINATION &&
606 (sec_level != BT_SECURITY_HIGH ||
607 conn->pin_length == 16))
608 goto encrypt;
609
610auth:
1da177e4
LT		 611 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
612 return 0;
613
13d39315
WR		 614 hci_conn_auth(conn, sec_level, auth_type);
615 return 0;
616
617encrypt:
618 if (conn->link_mode & HCI_LM_ENCRYPT)
619 return 1;
8c1b2355 620
13d39315 621 hci_conn_encrypt(conn);
1da177e4
LT		 622 return 0;
623}
8c1b2355 624EXPORT_SYMBOL(hci_conn_security);
1da177e4 625
b3b1b061
WR		 626/* Check secure link requirement */
627int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
628{
629 BT_DBG("conn %p", conn);
630
631 if (sec_level != BT_SECURITY_HIGH)
632 return 1; /* Accept if non-secure is required */
633
634 if (conn->key_type == HCI_LK_AUTH_COMBINATION ||
635 (conn->key_type == HCI_LK_COMBINATION &&
636 conn->pin_length == 16))
637 return 1;
638
639 return 0; /* Reject not secure link */
640}
641EXPORT_SYMBOL(hci_conn_check_secure);
642
1da177e4
LT		 643/* Change link key */
644int hci_conn_change_link_key(struct hci_conn *conn)
645{
646 BT_DBG("conn %p", conn);
647
648 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
649 struct hci_cp_change_conn_link_key cp;
aca3192c 650 cp.handle = cpu_to_le16(conn->handle);
40be492f
MH		 651 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
652 sizeof(cp), &cp);
1da177e4 653 }
8c1b2355 654
1da177e4
LT		 655 return 0;
656}
657EXPORT_SYMBOL(hci_conn_change_link_key);
658
659/* Switch role */
8c1b2355 660int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
1da177e4
LT		 661{
662 BT_DBG("conn %p", conn);
663
664 if (!role && conn->link_mode & HCI_LM_MASTER)
665 return 1;
666
667 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
668 struct hci_cp_switch_role cp;
669 bacpy(&cp.bdaddr, &conn->dst);
670 cp.role = role;
a9de9248 671 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
1da177e4 672 }
8c1b2355 673
1da177e4
LT		 674 return 0;
675}
676EXPORT_SYMBOL(hci_conn_switch_role);
677
04837f64
MH		 678/* Enter active mode */
679void hci_conn_enter_active_mode(struct hci_conn *conn)
680{
681 struct hci_dev *hdev = conn->hdev;
682
683 BT_DBG("conn %p mode %d", conn, conn->mode);
684
685 if (test_bit(HCI_RAW, &hdev->flags))
686 return;
687
688 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
689 goto timer;
690
691 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
692 struct hci_cp_exit_sniff_mode cp;
aca3192c 693 cp.handle = cpu_to_le16(conn->handle);
a9de9248 694 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
04837f64
MH		 695 }
696
697timer:
698 if (hdev->idle_timeout > 0)
699 mod_timer(&conn->idle_timer,
700 jiffies + msecs_to_jiffies(hdev->idle_timeout));
701}
702
703/* Enter sniff mode */
704void hci_conn_enter_sniff_mode(struct hci_conn *conn)
705{
706 struct hci_dev *hdev = conn->hdev;
707
708 BT_DBG("conn %p mode %d", conn, conn->mode);
709
710 if (test_bit(HCI_RAW, &hdev->flags))
711 return;
712
713 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
714 return;
715
716 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
717 return;
718
719 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
720 struct hci_cp_sniff_subrate cp;
aca3192c
YH		 721 cp.handle = cpu_to_le16(conn->handle);
722 cp.max_latency = cpu_to_le16(0);
723 cp.min_remote_timeout = cpu_to_le16(0);
724 cp.min_local_timeout = cpu_to_le16(0);
a9de9248 725 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
04837f64
MH		 726 }
727
728 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
729 struct hci_cp_sniff_mode cp;
aca3192c
YH		 730 cp.handle = cpu_to_le16(conn->handle);
731 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
732 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
733 cp.attempt = cpu_to_le16(4);
734 cp.timeout = cpu_to_le16(1);
a9de9248 735 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
04837f64
MH		 736 }
737}
738
1da177e4
LT		 739/* Drop all connection on the device */
740void hci_conn_hash_flush(struct hci_dev *hdev)
741{
742 struct hci_conn_hash *h = &hdev->conn_hash;
743 struct list_head *p;
744
745 BT_DBG("hdev %s", hdev->name);
746
747 p = h->list.next;
748 while (p != &h->list) {
749 struct hci_conn *c;
750
751 c = list_entry(p, struct hci_conn, list);
752 p = p->next;
753
754 c->state = BT_CLOSED;
755
2950f21a 756 hci_proto_disconn_cfm(c, 0x16);
1da177e4
LT		 757 hci_conn_del(c);
758 }
759}
760
a9de9248
MH		 761/* Check pending connect attempts */
762void hci_conn_check_pending(struct hci_dev *hdev)
763{
764 struct hci_conn *conn;
765
766 BT_DBG("hdev %s", hdev->name);
767
768 hci_dev_lock(hdev);
769
770 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
771 if (conn)
772 hci_acl_connect(conn);
773
774 hci_dev_unlock(hdev);
775}
776
9eba32b8
MH		 777void hci_conn_hold_device(struct hci_conn *conn)
778{
779 atomic_inc(&conn->devref);
780}
781EXPORT_SYMBOL(hci_conn_hold_device);
782
783void hci_conn_put_device(struct hci_conn *conn)
784{
785 if (atomic_dec_and_test(&conn->devref))
786 hci_conn_del_sysfs(conn);
787}
788EXPORT_SYMBOL(hci_conn_put_device);
789
1da177e4
LT		 790int hci_get_conn_list(void __user *arg)
791{
792 struct hci_conn_list_req req, *cl;
793 struct hci_conn_info *ci;
794 struct hci_dev *hdev;
795 struct list_head *p;
796 int n = 0, size, err;
797
798 if (copy_from_user(&req, arg, sizeof(req)))
799 return -EFAULT;
800
801 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
802 return -EINVAL;
803
804 size = sizeof(req) + req.conn_num * sizeof(*ci);
805
70f23020
AE		 806 cl = kmalloc(size, GFP_KERNEL);
807 if (!cl)
1da177e4
LT		 808 return -ENOMEM;
809
70f23020
AE		 810 hdev = hci_dev_get(req.dev_id);
811 if (!hdev) {
1da177e4
LT		 812 kfree(cl);
813 return -ENODEV;
814 }
815
816 ci = cl->conn_info;
817
818 hci_dev_lock_bh(hdev);
819 list_for_each(p, &hdev->conn_hash.list) {
820 register struct hci_conn *c;
821 c = list_entry(p, struct hci_conn, list);
822
823 bacpy(&(ci + n)->bdaddr, &c->dst);
824 (ci + n)->handle = c->handle;
825 (ci + n)->type = c->type;
826 (ci + n)->out = c->out;
827 (ci + n)->state = c->state;
828 (ci + n)->link_mode = c->link_mode;
829 if (++n >= req.conn_num)
830 break;
831 }
832 hci_dev_unlock_bh(hdev);
833
834 cl->dev_id = hdev->id;
835 cl->conn_num = n;
836 size = sizeof(req) + n * sizeof(*ci);
837
838 hci_dev_put(hdev);
839
840 err = copy_to_user(arg, cl, size);
841 kfree(cl);
842
843 return err ? -EFAULT : 0;
844}
845
846int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
847{
848 struct hci_conn_info_req req;
849 struct hci_conn_info ci;
850 struct hci_conn *conn;
851 char __user *ptr = arg + sizeof(req);
852
853 if (copy_from_user(&req, arg, sizeof(req)))
854 return -EFAULT;
855
856 hci_dev_lock_bh(hdev);
857 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
858 if (conn) {
859 bacpy(&ci.bdaddr, &conn->dst);
860 ci.handle = conn->handle;
861 ci.type = conn->type;
862 ci.out = conn->out;
863 ci.state = conn->state;
864 ci.link_mode = conn->link_mode;
865 }
866 hci_dev_unlock_bh(hdev);
867
868 if (!conn)
869 return -ENOENT;
870
871 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
872}
40be492f
MH		 873
874int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
875{
876 struct hci_auth_info_req req;
877 struct hci_conn *conn;
878
879 if (copy_from_user(&req, arg, sizeof(req)))
880 return -EFAULT;
881
882 hci_dev_lock_bh(hdev);
883 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
884 if (conn)
885 req.type = conn->auth_type;
886 hci_dev_unlock_bh(hdev);
887
888 if (!conn)
889 return -ENOENT;
890
891 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
892}
Linux 6.x block layer and io_uring tree(s)