blob: c1c597e3e198e9ffba26dd4dcf2e59e2ffc923c3 [file] [log] [blame]
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +09001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 BlueZ - Bluetooth protocol stack for Linux
Ron Shaffer2d0a0342010-05-28 11:53:46 -04003 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
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
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090015 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +090020 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI connection handling. */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
28
29#include <linux/types.h>
30#include <linux/errno.h>
31#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#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>
Andrei Emeltchenko70f230202010-12-01 16:58:25 +020042#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <asm/unaligned.h>
44
45#include <net/bluetooth/bluetooth.h>
46#include <net/bluetooth/hci_core.h>
47
Ville Tervofcd89c02011-02-10 22:38:47 -030048static 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;
Vinicius Costa Gomesb92a6222011-02-10 22:38:52 -030055 conn->link_mode |= HCI_LM_MASTER;
Vinicius Costa Gomes7b5c0d52011-06-09 18:50:50 -030056 conn->sec_level = BT_SECURITY_LOW;
Ville Tervofcd89c02011-02-10 22:38:47 -030057
58 memset(&cp, 0, sizeof(cp));
Anderson Lizardo0e833912011-07-27 18:40:09 -030059 cp.scan_interval = cpu_to_le16(0x0060);
60 cp.scan_window = cpu_to_le16(0x0030);
Ville Tervofcd89c02011-02-10 22:38:47 -030061 bacpy(&cp.peer_addr, &conn->dst);
Andre Guedes6d3ce0e72011-05-31 14:20:57 -030062 cp.peer_addr_type = conn->dst_type;
Anderson Lizardo0e833912011-07-27 18:40:09 -030063 cp.conn_interval_min = cpu_to_le16(0x0028);
64 cp.conn_interval_max = cpu_to_le16(0x0038);
65 cp.supervision_timeout = cpu_to_le16(0x002a);
66 cp.min_ce_len = cpu_to_le16(0x0000);
67 cp.max_ce_len = cpu_to_le16(0x0000);
Ville Tervofcd89c02011-02-10 22:38:47 -030068
69 hci_send_cmd(hdev, HCI_OP_LE_CREATE_CONN, sizeof(cp), &cp);
70}
71
72static void hci_le_connect_cancel(struct hci_conn *conn)
73{
74 hci_send_cmd(conn->hdev, HCI_OP_LE_CREATE_CONN_CANCEL, 0, NULL);
75}
76
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020077void hci_acl_connect(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -070078{
79 struct hci_dev *hdev = conn->hdev;
80 struct inquiry_entry *ie;
81 struct hci_cp_create_conn cp;
82
83 BT_DBG("%p", conn);
84
85 conn->state = BT_CONNECT;
Marcel Holtmanna8746412008-07-14 20:13:46 +020086 conn->out = 1;
87
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 conn->link_mode = HCI_LM_MASTER;
89
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020090 conn->attempt++;
91
Marcel Holtmanne4e8e372008-07-14 20:13:47 +020092 conn->link_policy = hdev->link_policy;
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 memset(&cp, 0, sizeof(cp));
95 bacpy(&cp.bdaddr, &conn->dst);
96 cp.pscan_rep_mode = 0x02;
97
Andrei Emeltchenko70f230202010-12-01 16:58:25 +020098 ie = hci_inquiry_cache_lookup(hdev, &conn->dst);
99 if (ie) {
Marcel Holtmann41a96212008-07-14 20:13:48 +0200100 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
101 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
102 cp.pscan_mode = ie->data.pscan_mode;
103 cp.clock_offset = ie->data.clock_offset |
104 cpu_to_le16(0x8000);
105 }
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 memcpy(conn->dev_class, ie->data.dev_class, 3);
Marcel Holtmann41a96212008-07-14 20:13:48 +0200108 conn->ssp_mode = ie->data.ssp_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 }
110
Marcel Holtmanna8746412008-07-14 20:13:46 +0200111 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200113 cp.role_switch = 0x01;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 else
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200115 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +0200116
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200117 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200120static void hci_acl_connect_cancel(struct hci_conn *conn)
121{
122 struct hci_cp_create_conn_cancel cp;
123
124 BT_DBG("%p", conn);
125
126 if (conn->hdev->hci_ver < 2)
127 return;
128
129 bacpy(&cp.bdaddr, &conn->dst);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200130 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200131}
132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
134{
135 struct hci_cp_disconnect cp;
136
137 BT_DBG("%p", conn);
138
139 conn->state = BT_DISCONN;
140
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700141 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 cp.reason = reason;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200143 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144}
145
146void hci_add_sco(struct hci_conn *conn, __u16 handle)
147{
148 struct hci_dev *hdev = conn->hdev;
149 struct hci_cp_add_sco cp;
150
151 BT_DBG("%p", conn);
152
153 conn->state = BT_CONNECT;
154 conn->out = 1;
155
Marcel Holtmannefc76882009-02-06 09:13:37 +0100156 conn->attempt++;
157
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700158 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200159 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200161 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200164void hci_setup_sync(struct hci_conn *conn, __u16 handle)
165{
166 struct hci_dev *hdev = conn->hdev;
167 struct hci_cp_setup_sync_conn cp;
168
169 BT_DBG("%p", conn);
170
171 conn->state = BT_CONNECT;
172 conn->out = 1;
173
Marcel Holtmannefc76882009-02-06 09:13:37 +0100174 conn->attempt++;
175
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200176 cp.handle = cpu_to_le16(handle);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200177 cp.pkt_type = cpu_to_le16(conn->pkt_type);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200178
179 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
180 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
181 cp.max_latency = cpu_to_le16(0xffff);
182 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
183 cp.retrans_effort = 0xff;
184
185 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
186}
187
Claudio Takahasi2ce603e2011-02-16 20:44:53 -0200188void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
189 u16 latency, u16 to_multiplier)
190{
191 struct hci_cp_le_conn_update cp;
192 struct hci_dev *hdev = conn->hdev;
193
194 memset(&cp, 0, sizeof(cp));
195
196 cp.handle = cpu_to_le16(conn->handle);
197 cp.conn_interval_min = cpu_to_le16(min);
198 cp.conn_interval_max = cpu_to_le16(max);
199 cp.conn_latency = cpu_to_le16(latency);
200 cp.supervision_timeout = cpu_to_le16(to_multiplier);
201 cp.min_ce_len = cpu_to_le16(0x0001);
202 cp.max_ce_len = cpu_to_le16(0x0001);
203
204 hci_send_cmd(hdev, HCI_OP_LE_CONN_UPDATE, sizeof(cp), &cp);
205}
206EXPORT_SYMBOL(hci_le_conn_update);
207
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300208void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
209 __u8 ltk[16])
210{
211 struct hci_dev *hdev = conn->hdev;
212 struct hci_cp_le_start_enc cp;
213
214 BT_DBG("%p", conn);
215
216 memset(&cp, 0, sizeof(cp));
217
218 cp.handle = cpu_to_le16(conn->handle);
219 memcpy(cp.ltk, ltk, sizeof(cp.ltk));
220 cp.ediv = ediv;
Anderson Briglia51beabd2011-09-19 14:41:09 -0400221 memcpy(cp.rand, rand, sizeof(cp.rand));
Vinicius Costa Gomesa7a595f2011-06-09 18:50:47 -0300222
223 hci_send_cmd(hdev, HCI_OP_LE_START_ENC, sizeof(cp), &cp);
224}
225EXPORT_SYMBOL(hci_le_start_enc);
226
227void hci_le_ltk_reply(struct hci_conn *conn, u8 ltk[16])
228{
229 struct hci_dev *hdev = conn->hdev;
230 struct hci_cp_le_ltk_reply cp;
231
232 BT_DBG("%p", conn);
233
234 memset(&cp, 0, sizeof(cp));
235
236 cp.handle = cpu_to_le16(conn->handle);
237 memcpy(cp.ltk, ltk, sizeof(ltk));
238
239 hci_send_cmd(hdev, HCI_OP_LE_LTK_REPLY, sizeof(cp), &cp);
240}
241EXPORT_SYMBOL(hci_le_ltk_reply);
242
243void hci_le_ltk_neg_reply(struct hci_conn *conn)
244{
245 struct hci_dev *hdev = conn->hdev;
246 struct hci_cp_le_ltk_neg_reply cp;
247
248 BT_DBG("%p", conn);
249
250 memset(&cp, 0, sizeof(cp));
251
252 cp.handle = cpu_to_le16(conn->handle);
253
254 hci_send_cmd(hdev, HCI_OP_LE_LTK_NEG_REPLY, sizeof(cp), &cp);
255}
256
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400257/* Device _must_ be locked */
258void hci_sco_setup(struct hci_conn *conn, __u8 status)
259{
260 struct hci_conn *sco = conn->link;
261
262 BT_DBG("%p", conn);
263
264 if (!sco)
265 return;
266
267 if (!status) {
268 if (lmp_esco_capable(conn->hdev))
269 hci_setup_sync(sco, conn->handle);
270 else
271 hci_add_sco(sco, conn->handle);
272 } else {
273 hci_proto_connect_cfm(sco, status);
274 hci_conn_del(sco);
275 }
276}
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278static void hci_conn_timeout(unsigned long arg)
279{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200280 struct hci_conn *conn = (void *) arg;
281 struct hci_dev *hdev = conn->hdev;
Marcel Holtmann2950f212009-02-12 14:02:50 +0100282 __u8 reason;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 BT_DBG("conn %p state %d", conn, conn->state);
285
286 if (atomic_read(&conn->refcnt))
287 return;
288
289 hci_dev_lock(hdev);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200290
291 switch (conn->state) {
292 case BT_CONNECT:
Marcel Holtmann769be972008-07-14 20:13:49 +0200293 case BT_CONNECT2:
Ville Tervofcd89c02011-02-10 22:38:47 -0300294 if (conn->out) {
295 if (conn->type == ACL_LINK)
296 hci_acl_connect_cancel(conn);
297 else if (conn->type == LE_LINK)
298 hci_le_connect_cancel(conn);
299 }
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200300 break;
Marcel Holtmann769be972008-07-14 20:13:49 +0200301 case BT_CONFIG:
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900302 case BT_CONNECTED:
Marcel Holtmann2950f212009-02-12 14:02:50 +0100303 reason = hci_proto_disconn_ind(conn);
304 hci_acl_disconn(conn, reason);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200305 break;
306 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200308 break;
309 }
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312}
313
Marcel Holtmann04837f62006-07-03 10:02:33 +0200314static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200316 struct hci_conn *conn = (void *) arg;
317
318 BT_DBG("conn %p mode %d", conn, conn->mode);
319
320 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321}
322
Johan Hedberg9f616562011-04-28 11:28:54 -0700323static void hci_conn_auto_accept(unsigned long arg)
324{
325 struct hci_conn *conn = (void *) arg;
326 struct hci_dev *hdev = conn->hdev;
327
328 hci_dev_lock(hdev);
329
330 hci_send_cmd(hdev, HCI_OP_USER_CONFIRM_REPLY, sizeof(conn->dst),
331 &conn->dst);
332
333 hci_dev_unlock(hdev);
334}
335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
337{
338 struct hci_conn *conn;
339
340 BT_DBG("%s dst %s", hdev->name, batostr(dst));
341
Marcel Holtmann04837f62006-07-03 10:02:33 +0200342 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
343 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 bacpy(&conn->dst, dst);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200347 conn->hdev = hdev;
348 conn->type = type;
349 conn->mode = HCI_CM_ACTIVE;
350 conn->state = BT_OPEN;
Andrei Emeltchenko93f19c92009-09-03 12:34:19 +0300351 conn->auth_type = HCI_AT_GENERAL_BONDING;
Johan Hedberg17fa4b92011-01-25 13:28:33 +0200352 conn->io_capability = hdev->io_capability;
Johan Hedberga9583552011-02-19 12:06:01 -0300353 conn->remote_auth = 0xff;
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200354 conn->key_type = 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Marcel Holtmann04837f62006-07-03 10:02:33 +0200356 conn->power_save = 1;
Marcel Holtmann052b30b2009-04-26 20:01:22 +0200357 conn->disc_timeout = HCI_DISCONN_TIMEOUT;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200358
Marcel Holtmanna8746412008-07-14 20:13:46 +0200359 switch (type) {
360 case ACL_LINK:
361 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
362 break;
363 case SCO_LINK:
364 if (lmp_esco_capable(hdev))
Marcel Holtmannefc76882009-02-06 09:13:37 +0100365 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
366 (hdev->esco_type & EDR_ESCO_MASK);
Marcel Holtmanna8746412008-07-14 20:13:46 +0200367 else
368 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
369 break;
370 case ESCO_LINK:
Marcel Holtmannefc76882009-02-06 09:13:37 +0100371 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
Marcel Holtmanna8746412008-07-14 20:13:46 +0200372 break;
373 }
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200376
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -0800377 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
378 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
Johan Hedberg9f616562011-04-28 11:28:54 -0700379 setup_timer(&conn->auto_accept_timer, hci_conn_auto_accept,
380 (unsigned long) conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382 atomic_set(&conn->refcnt, 0);
383
384 hci_dev_hold(hdev);
385
386 tasklet_disable(&hdev->tx_task);
387
388 hci_conn_hash_add(hdev, conn);
389 if (hdev->notify)
390 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
391
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700392 atomic_set(&conn->devref, 0);
393
Marcel Holtmanna67e8992009-05-02 18:24:06 -0700394 hci_conn_init_sysfs(conn);
395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 tasklet_enable(&hdev->tx_task);
397
398 return conn;
399}
400
401int hci_conn_del(struct hci_conn *conn)
402{
403 struct hci_dev *hdev = conn->hdev;
404
405 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
406
Marcel Holtmann04837f62006-07-03 10:02:33 +0200407 del_timer(&conn->idle_timer);
408
409 del_timer(&conn->disc_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Johan Hedberg9f616562011-04-28 11:28:54 -0700411 del_timer(&conn->auto_accept_timer);
412
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200413 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 struct hci_conn *sco = conn->link;
415 if (sco)
416 sco->link = NULL;
417
418 /* Unacked frames */
419 hdev->acl_cnt += conn->sent;
Ville Tervo6ed58ec2011-02-10 22:38:48 -0300420 } else if (conn->type == LE_LINK) {
421 if (hdev->le_pkts)
422 hdev->le_cnt += conn->sent;
423 else
424 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200425 } else {
426 struct hci_conn *acl = conn->link;
427 if (acl) {
428 acl->link = NULL;
429 hci_conn_put(acl);
430 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 }
432
433 tasklet_disable(&hdev->tx_task);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 hci_conn_hash_del(hdev, conn);
436 if (hdev->notify)
437 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 tasklet_enable(&hdev->tx_task);
Marcel Holtmann7d0db0a2008-07-14 20:13:51 +0200440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 skb_queue_purge(&conn->data_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700443 hci_conn_put_device(conn);
Dave Young2ae9a6b2009-02-21 16:13:34 +0800444
Marcel Holtmann384943e2009-05-08 18:20:43 -0700445 hci_dev_put(hdev);
446
Tomas Targownik163f4da2011-06-30 16:30:44 -0300447 if (conn->handle == 0)
448 kfree(conn);
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 return 0;
451}
452
453struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
454{
455 int use_src = bacmp(src, BDADDR_ANY);
456 struct hci_dev *hdev = NULL;
457 struct list_head *p;
458
459 BT_DBG("%s -> %s", batostr(src), batostr(dst));
460
461 read_lock_bh(&hci_dev_list_lock);
462
463 list_for_each(p, &hci_dev_list) {
464 struct hci_dev *d = list_entry(p, struct hci_dev, list);
465
466 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
467 continue;
468
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900469 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 * No source address - find interface with bdaddr != dst
471 * Source address - find interface with bdaddr == src
472 */
473
474 if (use_src) {
475 if (!bacmp(&d->bdaddr, src)) {
476 hdev = d; break;
477 }
478 } else {
479 if (bacmp(&d->bdaddr, dst)) {
480 hdev = d; break;
481 }
482 }
483 }
484
485 if (hdev)
486 hdev = hci_dev_hold(hdev);
487
488 read_unlock_bh(&hci_dev_list_lock);
489 return hdev;
490}
491EXPORT_SYMBOL(hci_get_route);
492
Ville Tervofcd89c02011-02-10 22:38:47 -0300493/* Create SCO, ACL or LE connection.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 * Device _must_ be locked */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100495struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
497 struct hci_conn *acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200498 struct hci_conn *sco;
Ville Tervofcd89c02011-02-10 22:38:47 -0300499 struct hci_conn *le;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 BT_DBG("%s dst %s", hdev->name, batostr(dst));
502
Ville Tervofcd89c02011-02-10 22:38:47 -0300503 if (type == LE_LINK) {
Andre Guedeseda42b52011-05-31 14:20:56 -0300504 struct adv_entry *entry;
505
Ville Tervofcd89c02011-02-10 22:38:47 -0300506 le = hci_conn_hash_lookup_ba(hdev, LE_LINK, dst);
Anderson Briglia15c47942011-02-21 15:09:23 -0300507 if (le)
Ville Tervo30e76272011-02-22 16:10:53 -0300508 return ERR_PTR(-EBUSY);
Andre Guedeseda42b52011-05-31 14:20:56 -0300509
510 entry = hci_find_adv_entry(hdev, dst);
511 if (!entry)
512 return ERR_PTR(-EHOSTUNREACH);
513
Anderson Briglia15c47942011-02-21 15:09:23 -0300514 le = hci_conn_add(hdev, LE_LINK, dst);
Ville Tervofcd89c02011-02-10 22:38:47 -0300515 if (!le)
Ville Tervo30e76272011-02-22 16:10:53 -0300516 return ERR_PTR(-ENOMEM);
Andre Guedes893d6752011-05-31 14:20:55 -0300517
Andre Guedeseda42b52011-05-31 14:20:56 -0300518 le->dst_type = entry->bdaddr_type;
519
Andre Guedes893d6752011-05-31 14:20:55 -0300520 hci_le_connect(le);
Ville Tervofcd89c02011-02-10 22:38:47 -0300521
522 hci_conn_hold(le);
523
524 return le;
525 }
526
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200527 acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst);
528 if (!acl) {
529 acl = hci_conn_add(hdev, ACL_LINK, dst);
530 if (!acl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 return NULL;
532 }
533
534 hci_conn_hold(acl);
535
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200536 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
Johan Hedberg765c2a92011-01-19 12:06:52 +0530537 acl->sec_level = BT_SECURITY_LOW;
538 acl->pending_sec_level = sec_level;
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200539 acl->auth_type = auth_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 hci_acl_connect(acl);
Marcel Holtmann09ab6f42008-09-09 07:19:20 +0200541 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200543 if (type == ACL_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 return acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200545
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200546 sco = hci_conn_hash_lookup_ba(hdev, type, dst);
547 if (!sco) {
548 sco = hci_conn_add(hdev, type, dst);
549 if (!sco) {
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200550 hci_conn_put(acl);
551 return NULL;
552 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200554
555 acl->link = sco;
556 sco->link = acl;
557
558 hci_conn_hold(sco);
559
560 if (acl->state == BT_CONNECTED &&
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200561 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
Nick Pellyc3902162009-11-13 14:16:32 -0800562 acl->power_save = 1;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700563 hci_conn_enter_active_mode(acl, BT_POWER_FORCE_ACTIVE_ON);
Nick Pellyc3902162009-11-13 14:16:32 -0800564
Marcel Holtmanne73439d2010-07-26 10:06:00 -0400565 if (test_bit(HCI_CONN_MODE_CHANGE_PEND, &acl->pend)) {
566 /* defer SCO setup until mode change completed */
567 set_bit(HCI_CONN_SCO_SETUP_PEND, &acl->pend);
568 return sco;
569 }
570
571 hci_sco_setup(acl, 0x00);
Marcel Holtmannb6a0dc82007-10-20 14:55:10 +0200572 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200573
574 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575}
576EXPORT_SYMBOL(hci_connect);
577
Marcel Holtmanne7c29cb2008-09-09 07:19:20 +0200578/* Check link security requirement */
579int hci_conn_check_link_mode(struct hci_conn *conn)
580{
581 BT_DBG("conn %p", conn);
582
583 if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
584 !(conn->link_mode & HCI_LM_ENCRYPT))
585 return 0;
586
587 return 1;
588}
589EXPORT_SYMBOL(hci_conn_check_link_mode);
590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591/* Authenticate remote device */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100592static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
594 BT_DBG("conn %p", conn);
595
Johan Hedberg765c2a92011-01-19 12:06:52 +0530596 if (conn->pending_sec_level > sec_level)
597 sec_level = conn->pending_sec_level;
598
Marcel Holtmann96a31832009-02-12 16:23:03 +0100599 if (sec_level > conn->sec_level)
Johan Hedberg765c2a92011-01-19 12:06:52 +0530600 conn->pending_sec_level = sec_level;
Marcel Holtmann96a31832009-02-12 16:23:03 +0100601 else if (conn->link_mode & HCI_LM_AUTH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 return 1;
603
Johan Hedberg65cf6862011-01-19 12:06:49 +0530604 /* Make sure we preserve an existing MITM requirement*/
605 auth_type |= (conn->auth_type & 0x01);
606
Marcel Holtmann96a31832009-02-12 16:23:03 +0100607 conn->auth_type = auth_type;
608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
610 struct hci_cp_auth_requested cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700611 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200612 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
613 sizeof(cp), &cp);
Waldemar Rymarkiewicz19f8def2011-05-31 15:49:25 +0200614 if (conn->key_type != 0xff)
615 set_bit(HCI_CONN_REAUTH_PEND, &conn->pend);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 return 0;
619}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200621/* Encrypt the the link */
622static void hci_conn_encrypt(struct hci_conn *conn)
623{
624 BT_DBG("conn %p", conn);
625
626 if (!test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend)) {
627 struct hci_cp_set_conn_encrypt cp;
628 cp.handle = cpu_to_le16(conn->handle);
629 cp.encrypt = 0x01;
630 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp),
631 &cp);
632 }
633}
634
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100635/* Enable security */
Marcel Holtmann0684e5f2009-02-09 02:48:38 +0100636int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637{
638 BT_DBG("conn %p", conn);
639
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200640 /* For sdp we don't need the link key. */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100641 if (sec_level == BT_SECURITY_SDP)
642 return 1;
643
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200644 /* For non 2.1 devices and low security level we don't need the link
645 key. */
Marcel Holtmann3fdca1e2009-04-28 09:04:55 -0700646 if (sec_level == BT_SECURITY_LOW &&
647 (!conn->ssp_mode || !conn->hdev->ssp_mode))
648 return 1;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100649
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200650 /* For other security levels we need the link key. */
651 if (!(conn->link_mode & HCI_LM_AUTH))
652 goto auth;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200654 /* An authenticated combination key has sufficient security for any
655 security level. */
656 if (conn->key_type == HCI_LK_AUTH_COMBINATION)
657 goto encrypt;
658
659 /* An unauthenticated combination key has sufficient security for
660 security level 1 and 2. */
661 if (conn->key_type == HCI_LK_UNAUTH_COMBINATION &&
662 (sec_level == BT_SECURITY_MEDIUM ||
663 sec_level == BT_SECURITY_LOW))
664 goto encrypt;
665
666 /* A combination key has always sufficient security for the security
667 levels 1 or 2. High security level requires the combination key
668 is generated using maximum PIN code length (16).
669 For pre 2.1 units. */
670 if (conn->key_type == HCI_LK_COMBINATION &&
671 (sec_level != BT_SECURITY_HIGH ||
672 conn->pin_length == 16))
673 goto encrypt;
674
675auth:
Ilia Kolomisnky33060542011-06-15 06:52:26 +0300676 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 return 0;
678
Luiz Augusto von Dentz6fdf6582011-06-13 15:37:35 +0300679 if (!hci_conn_auth(conn, sec_level, auth_type))
680 return 0;
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100681
Waldemar Rymarkiewicz13d39312011-04-28 12:07:55 +0200682encrypt:
683 if (conn->link_mode & HCI_LM_ENCRYPT)
684 return 1;
685
686 hci_conn_encrypt(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 return 0;
688}
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100689EXPORT_SYMBOL(hci_conn_security);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200691/* Check secure link requirement */
692int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level)
693{
694 BT_DBG("conn %p", conn);
695
696 if (sec_level != BT_SECURITY_HIGH)
697 return 1; /* Accept if non-secure is required */
698
Waldemar Rymarkiewiczef4177e2011-06-02 14:24:52 +0200699 if (conn->sec_level == BT_SECURITY_HIGH)
Waldemar Rymarkiewiczb3b1b062011-05-06 09:42:31 +0200700 return 1;
701
702 return 0; /* Reject not secure link */
703}
704EXPORT_SYMBOL(hci_conn_check_secure);
705
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706/* Change link key */
707int hci_conn_change_link_key(struct hci_conn *conn)
708{
709 BT_DBG("conn %p", conn);
710
711 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
712 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700713 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann40be4922008-07-14 20:13:50 +0200714 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
715 sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 return 0;
719}
720EXPORT_SYMBOL(hci_conn_change_link_key);
721
722/* Switch role */
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100723int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
725 BT_DBG("conn %p", conn);
726
727 if (!role && conn->link_mode & HCI_LM_MASTER)
728 return 1;
729
730 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
731 struct hci_cp_switch_role cp;
732 bacpy(&cp.bdaddr, &conn->dst);
733 cp.role = role;
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200734 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 }
Marcel Holtmann8c1b2352009-01-15 21:58:04 +0100736
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 return 0;
738}
739EXPORT_SYMBOL(hci_conn_switch_role);
740
Marcel Holtmann04837f62006-07-03 10:02:33 +0200741/* Enter active mode */
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700742void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200743{
744 struct hci_dev *hdev = conn->hdev;
745
746 BT_DBG("conn %p mode %d", conn, conn->mode);
747
748 if (test_bit(HCI_RAW, &hdev->flags))
749 return;
750
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700751 if (conn->mode != HCI_CM_SNIFF)
752 goto timer;
753
754 if (!conn->power_save && !force_active)
Marcel Holtmann04837f62006-07-03 10:02:33 +0200755 goto timer;
756
757 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
758 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700759 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200760 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200761 }
762
763timer:
764 if (hdev->idle_timeout > 0)
765 mod_timer(&conn->idle_timer,
766 jiffies + msecs_to_jiffies(hdev->idle_timeout));
767}
768
769/* Enter sniff mode */
770void hci_conn_enter_sniff_mode(struct hci_conn *conn)
771{
772 struct hci_dev *hdev = conn->hdev;
773
774 BT_DBG("conn %p mode %d", conn, conn->mode);
775
776 if (test_bit(HCI_RAW, &hdev->flags))
777 return;
778
779 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
780 return;
781
782 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
783 return;
784
785 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
786 struct hci_cp_sniff_subrate cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700787 cp.handle = cpu_to_le16(conn->handle);
788 cp.max_latency = cpu_to_le16(0);
789 cp.min_remote_timeout = cpu_to_le16(0);
790 cp.min_local_timeout = cpu_to_le16(0);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200791 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200792 }
793
794 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
795 struct hci_cp_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700796 cp.handle = cpu_to_le16(conn->handle);
797 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
798 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
799 cp.attempt = cpu_to_le16(4);
800 cp.timeout = cpu_to_le16(1);
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200801 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200802 }
803}
804
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805/* Drop all connection on the device */
806void hci_conn_hash_flush(struct hci_dev *hdev)
807{
808 struct hci_conn_hash *h = &hdev->conn_hash;
809 struct list_head *p;
810
811 BT_DBG("hdev %s", hdev->name);
812
813 p = h->list.next;
814 while (p != &h->list) {
815 struct hci_conn *c;
816
817 c = list_entry(p, struct hci_conn, list);
818 p = p->next;
819
820 c->state = BT_CLOSED;
821
Marcel Holtmann2950f212009-02-12 14:02:50 +0100822 hci_proto_disconn_cfm(c, 0x16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 hci_conn_del(c);
824 }
825}
826
Marcel Holtmanna9de9242007-10-20 13:33:56 +0200827/* Check pending connect attempts */
828void hci_conn_check_pending(struct hci_dev *hdev)
829{
830 struct hci_conn *conn;
831
832 BT_DBG("hdev %s", hdev->name);
833
834 hci_dev_lock(hdev);
835
836 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
837 if (conn)
838 hci_acl_connect(conn);
839
840 hci_dev_unlock(hdev);
841}
842
Marcel Holtmann9eba32b2009-08-22 14:19:26 -0700843void hci_conn_hold_device(struct hci_conn *conn)
844{
845 atomic_inc(&conn->devref);
846}
847EXPORT_SYMBOL(hci_conn_hold_device);
848
849void hci_conn_put_device(struct hci_conn *conn)
850{
851 if (atomic_dec_and_test(&conn->devref))
852 hci_conn_del_sysfs(conn);
853}
854EXPORT_SYMBOL(hci_conn_put_device);
855
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856int hci_get_conn_list(void __user *arg)
857{
858 struct hci_conn_list_req req, *cl;
859 struct hci_conn_info *ci;
860 struct hci_dev *hdev;
861 struct list_head *p;
862 int n = 0, size, err;
863
864 if (copy_from_user(&req, arg, sizeof(req)))
865 return -EFAULT;
866
867 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
868 return -EINVAL;
869
870 size = sizeof(req) + req.conn_num * sizeof(*ci);
871
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200872 cl = kmalloc(size, GFP_KERNEL);
873 if (!cl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return -ENOMEM;
875
Andrei Emeltchenko70f230202010-12-01 16:58:25 +0200876 hdev = hci_dev_get(req.dev_id);
877 if (!hdev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 kfree(cl);
879 return -ENODEV;
880 }
881
882 ci = cl->conn_info;
883
884 hci_dev_lock_bh(hdev);
885 list_for_each(p, &hdev->conn_hash.list) {
886 register struct hci_conn *c;
887 c = list_entry(p, struct hci_conn, list);
888
889 bacpy(&(ci + n)->bdaddr, &c->dst);
890 (ci + n)->handle = c->handle;
891 (ci + n)->type = c->type;
892 (ci + n)->out = c->out;
893 (ci + n)->state = c->state;
894 (ci + n)->link_mode = c->link_mode;
895 if (++n >= req.conn_num)
896 break;
897 }
898 hci_dev_unlock_bh(hdev);
899
900 cl->dev_id = hdev->id;
901 cl->conn_num = n;
902 size = sizeof(req) + n * sizeof(*ci);
903
904 hci_dev_put(hdev);
905
906 err = copy_to_user(arg, cl, size);
907 kfree(cl);
908
909 return err ? -EFAULT : 0;
910}
911
912int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
913{
914 struct hci_conn_info_req req;
915 struct hci_conn_info ci;
916 struct hci_conn *conn;
917 char __user *ptr = arg + sizeof(req);
918
919 if (copy_from_user(&req, arg, sizeof(req)))
920 return -EFAULT;
921
922 hci_dev_lock_bh(hdev);
923 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
924 if (conn) {
925 bacpy(&ci.bdaddr, &conn->dst);
926 ci.handle = conn->handle;
927 ci.type = conn->type;
928 ci.out = conn->out;
929 ci.state = conn->state;
930 ci.link_mode = conn->link_mode;
931 }
932 hci_dev_unlock_bh(hdev);
933
934 if (!conn)
935 return -ENOENT;
936
937 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
938}
Marcel Holtmann40be4922008-07-14 20:13:50 +0200939
940int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
941{
942 struct hci_auth_info_req req;
943 struct hci_conn *conn;
944
945 if (copy_from_user(&req, arg, sizeof(req)))
946 return -EFAULT;
947
948 hci_dev_lock_bh(hdev);
949 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
950 if (conn)
951 req.type = conn->auth_type;
952 hci_dev_unlock_bh(hdev);
953
954 if (!conn)
955 return -ENOENT;
956
957 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
958}