blob: 5fdfc9a67d390fbf9cc00190f289f877cde88074 [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
3 Copyright (C) 2000-2001 Qualcomm Incorporated
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
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>
42#include <asm/uaccess.h>
43#include <asm/unaligned.h>
44
45#include <net/bluetooth/bluetooth.h>
46#include <net/bluetooth/hci_core.h>
47
48#ifndef CONFIG_BT_HCI_CORE_DEBUG
49#undef BT_DBG
50#define BT_DBG(D...)
51#endif
52
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020053void hci_acl_connect(struct hci_conn *conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -070054{
55 struct hci_dev *hdev = conn->hdev;
56 struct inquiry_entry *ie;
57 struct hci_cp_create_conn cp;
58
59 BT_DBG("%p", conn);
60
61 conn->state = BT_CONNECT;
62 conn->out = 1;
63 conn->link_mode = HCI_LM_MASTER;
64
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020065 conn->attempt++;
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 memset(&cp, 0, sizeof(cp));
68 bacpy(&cp.bdaddr, &conn->dst);
69 cp.pscan_rep_mode = 0x02;
70
71 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst)) &&
72 inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
73 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
74 cp.pscan_mode = ie->data.pscan_mode;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -070075 cp.clock_offset = ie->data.clock_offset | cpu_to_le16(0x8000);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 memcpy(conn->dev_class, ie->data.dev_class, 3);
77 }
78
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -070079 cp.pkt_type = cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
81 cp.role_switch = 0x01;
82 else
83 cp.role_switch = 0x00;
Marcel Holtmann4c67bc72006-10-15 17:30:56 +020084
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CREATE_CONN, sizeof(cp), &cp);
86}
87
Marcel Holtmann6ac59342006-09-26 09:43:48 +020088static void hci_acl_connect_cancel(struct hci_conn *conn)
89{
90 struct hci_cp_create_conn_cancel cp;
91
92 BT_DBG("%p", conn);
93
94 if (conn->hdev->hci_ver < 2)
95 return;
96
97 bacpy(&cp.bdaddr, &conn->dst);
98 hci_send_cmd(conn->hdev, OGF_LINK_CTL,
99 OCF_CREATE_CONN_CANCEL, sizeof(cp), &cp);
100}
101
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
103{
104 struct hci_cp_disconnect cp;
105
106 BT_DBG("%p", conn);
107
108 conn->state = BT_DISCONN;
109
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700110 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 cp.reason = reason;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200112 hci_send_cmd(conn->hdev, OGF_LINK_CTL,
113 OCF_DISCONNECT, sizeof(cp), &cp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114}
115
116void hci_add_sco(struct hci_conn *conn, __u16 handle)
117{
118 struct hci_dev *hdev = conn->hdev;
119 struct hci_cp_add_sco cp;
120
121 BT_DBG("%p", conn);
122
123 conn->state = BT_CONNECT;
124 conn->out = 1;
125
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700126 cp.handle = cpu_to_le16(handle);
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200127 cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ADD_SCO, sizeof(cp), &cp);
130}
131
132static void hci_conn_timeout(unsigned long arg)
133{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200134 struct hci_conn *conn = (void *) arg;
135 struct hci_dev *hdev = conn->hdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
137 BT_DBG("conn %p state %d", conn, conn->state);
138
139 if (atomic_read(&conn->refcnt))
140 return;
141
142 hci_dev_lock(hdev);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200143
144 switch (conn->state) {
145 case BT_CONNECT:
146 hci_acl_connect_cancel(conn);
147 break;
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900148 case BT_CONNECTED:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 hci_acl_disconn(conn, 0x13);
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200150 break;
151 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 conn->state = BT_CLOSED;
Marcel Holtmann6ac59342006-09-26 09:43:48 +0200153 break;
154 }
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 hci_dev_unlock(hdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157}
158
Marcel Holtmann04837f62006-07-03 10:02:33 +0200159static void hci_conn_idle(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
Marcel Holtmann04837f62006-07-03 10:02:33 +0200161 struct hci_conn *conn = (void *) arg;
162
163 BT_DBG("conn %p mode %d", conn, conn->mode);
164
165 hci_conn_enter_sniff_mode(conn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166}
167
168struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
169{
170 struct hci_conn *conn;
171
172 BT_DBG("%s dst %s", hdev->name, batostr(dst));
173
Marcel Holtmann04837f62006-07-03 10:02:33 +0200174 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
175 if (!conn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178 bacpy(&conn->dst, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 conn->hdev = hdev;
Marcel Holtmann04837f62006-07-03 10:02:33 +0200180 conn->type = type;
181 conn->mode = HCI_CM_ACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 conn->state = BT_OPEN;
183
Marcel Holtmann04837f62006-07-03 10:02:33 +0200184 conn->power_save = 1;
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 skb_queue_head_init(&conn->data_q);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200187
188 init_timer(&conn->disc_timer);
189 conn->disc_timer.function = hci_conn_timeout;
190 conn->disc_timer.data = (unsigned long) conn;
191
192 init_timer(&conn->idle_timer);
193 conn->idle_timer.function = hci_conn_idle;
194 conn->idle_timer.data = (unsigned long) conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
196 atomic_set(&conn->refcnt, 0);
197
198 hci_dev_hold(hdev);
199
200 tasklet_disable(&hdev->tx_task);
201
202 hci_conn_hash_add(hdev, conn);
203 if (hdev->notify)
204 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
205
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200206 hci_conn_add_sysfs(conn);
207
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 tasklet_enable(&hdev->tx_task);
209
210 return conn;
211}
212
213int hci_conn_del(struct hci_conn *conn)
214{
215 struct hci_dev *hdev = conn->hdev;
216
217 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
218
Marcel Holtmann04837f62006-07-03 10:02:33 +0200219 del_timer(&conn->idle_timer);
220
221 del_timer(&conn->disc_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200223 if (conn->type == ACL_LINK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 struct hci_conn *sco = conn->link;
225 if (sco)
226 sco->link = NULL;
227
228 /* Unacked frames */
229 hdev->acl_cnt += conn->sent;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200230 } else {
231 struct hci_conn *acl = conn->link;
232 if (acl) {
233 acl->link = NULL;
234 hci_conn_put(acl);
235 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 }
237
238 tasklet_disable(&hdev->tx_task);
239
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200240 hci_conn_del_sysfs(conn);
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 hci_conn_hash_del(hdev, conn);
243 if (hdev->notify)
244 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
245
246 tasklet_enable(&hdev->tx_task);
247
248 skb_queue_purge(&conn->data_q);
249
250 hci_dev_put(hdev);
251
Marcel Holtmannb219e3a2006-07-06 12:38:46 +0200252 /* will free via device release */
253 put_device(&conn->dev);
254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 return 0;
256}
257
258struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
259{
260 int use_src = bacmp(src, BDADDR_ANY);
261 struct hci_dev *hdev = NULL;
262 struct list_head *p;
263
264 BT_DBG("%s -> %s", batostr(src), batostr(dst));
265
266 read_lock_bh(&hci_dev_list_lock);
267
268 list_for_each(p, &hci_dev_list) {
269 struct hci_dev *d = list_entry(p, struct hci_dev, list);
270
271 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
272 continue;
273
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900274 /* Simple routing:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 * No source address - find interface with bdaddr != dst
276 * Source address - find interface with bdaddr == src
277 */
278
279 if (use_src) {
280 if (!bacmp(&d->bdaddr, src)) {
281 hdev = d; break;
282 }
283 } else {
284 if (bacmp(&d->bdaddr, dst)) {
285 hdev = d; break;
286 }
287 }
288 }
289
290 if (hdev)
291 hdev = hci_dev_hold(hdev);
292
293 read_unlock_bh(&hci_dev_list_lock);
294 return hdev;
295}
296EXPORT_SYMBOL(hci_get_route);
297
298/* Create SCO or ACL connection.
299 * Device _must_ be locked */
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200300struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301{
302 struct hci_conn *acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200303 struct hci_conn *sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 BT_DBG("%s dst %s", hdev->name, batostr(dst));
306
307 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
308 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
309 return NULL;
310 }
311
312 hci_conn_hold(acl);
313
314 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
315 hci_acl_connect(acl);
316
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200317 if (type == ACL_LINK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 return acl;
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200319
320 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
321 if (!(sco = hci_conn_add(hdev, type, dst))) {
322 hci_conn_put(acl);
323 return NULL;
324 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 }
Marcel Holtmann5b7f9902007-07-11 09:51:55 +0200326
327 acl->link = sco;
328 sco->link = acl;
329
330 hci_conn_hold(sco);
331
332 if (acl->state == BT_CONNECTED &&
333 (sco->state == BT_OPEN || sco->state == BT_CLOSED))
334 hci_add_sco(sco, acl->handle);
335
336 return sco;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337}
338EXPORT_SYMBOL(hci_connect);
339
340/* Authenticate remote device */
341int hci_conn_auth(struct hci_conn *conn)
342{
343 BT_DBG("conn %p", conn);
344
345 if (conn->link_mode & HCI_LM_AUTH)
346 return 1;
347
348 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
349 struct hci_cp_auth_requested cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700350 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_AUTH_REQUESTED, sizeof(cp), &cp);
352 }
353 return 0;
354}
355EXPORT_SYMBOL(hci_conn_auth);
356
357/* Enable encryption */
358int hci_conn_encrypt(struct hci_conn *conn)
359{
360 BT_DBG("conn %p", conn);
361
362 if (conn->link_mode & HCI_LM_ENCRYPT)
363 return 1;
364
365 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
366 return 0;
367
368 if (hci_conn_auth(conn)) {
369 struct hci_cp_set_conn_encrypt cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700370 cp.handle = cpu_to_le16(conn->handle);
YOSHIFUJI Hideaki8e87d142007-02-09 23:24:33 +0900371 cp.encrypt = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
373 }
374 return 0;
375}
376EXPORT_SYMBOL(hci_conn_encrypt);
377
378/* Change link key */
379int hci_conn_change_link_key(struct hci_conn *conn)
380{
381 BT_DBG("conn %p", conn);
382
383 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
384 struct hci_cp_change_conn_link_key cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700385 cp.handle = cpu_to_le16(conn->handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
387 }
388 return 0;
389}
390EXPORT_SYMBOL(hci_conn_change_link_key);
391
392/* Switch role */
393int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
394{
395 BT_DBG("conn %p", conn);
396
397 if (!role && conn->link_mode & HCI_LM_MASTER)
398 return 1;
399
400 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
401 struct hci_cp_switch_role cp;
402 bacpy(&cp.bdaddr, &conn->dst);
403 cp.role = role;
404 hci_send_cmd(conn->hdev, OGF_LINK_POLICY, OCF_SWITCH_ROLE, sizeof(cp), &cp);
405 }
406 return 0;
407}
408EXPORT_SYMBOL(hci_conn_switch_role);
409
Marcel Holtmann04837f62006-07-03 10:02:33 +0200410/* Enter active mode */
411void hci_conn_enter_active_mode(struct hci_conn *conn)
412{
413 struct hci_dev *hdev = conn->hdev;
414
415 BT_DBG("conn %p mode %d", conn, conn->mode);
416
417 if (test_bit(HCI_RAW, &hdev->flags))
418 return;
419
420 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
421 goto timer;
422
423 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
424 struct hci_cp_exit_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700425 cp.handle = cpu_to_le16(conn->handle);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200426 hci_send_cmd(hdev, OGF_LINK_POLICY,
427 OCF_EXIT_SNIFF_MODE, sizeof(cp), &cp);
428 }
429
430timer:
431 if (hdev->idle_timeout > 0)
432 mod_timer(&conn->idle_timer,
433 jiffies + msecs_to_jiffies(hdev->idle_timeout));
434}
435
436/* Enter sniff mode */
437void hci_conn_enter_sniff_mode(struct hci_conn *conn)
438{
439 struct hci_dev *hdev = conn->hdev;
440
441 BT_DBG("conn %p mode %d", conn, conn->mode);
442
443 if (test_bit(HCI_RAW, &hdev->flags))
444 return;
445
446 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
447 return;
448
449 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
450 return;
451
452 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
453 struct hci_cp_sniff_subrate cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700454 cp.handle = cpu_to_le16(conn->handle);
455 cp.max_latency = cpu_to_le16(0);
456 cp.min_remote_timeout = cpu_to_le16(0);
457 cp.min_local_timeout = cpu_to_le16(0);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200458 hci_send_cmd(hdev, OGF_LINK_POLICY,
459 OCF_SNIFF_SUBRATE, sizeof(cp), &cp);
460 }
461
462 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
463 struct hci_cp_sniff_mode cp;
YOSHIFUJI Hideakiaca31922007-03-25 20:12:50 -0700464 cp.handle = cpu_to_le16(conn->handle);
465 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
466 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
467 cp.attempt = cpu_to_le16(4);
468 cp.timeout = cpu_to_le16(1);
Marcel Holtmann04837f62006-07-03 10:02:33 +0200469 hci_send_cmd(hdev, OGF_LINK_POLICY,
470 OCF_SNIFF_MODE, sizeof(cp), &cp);
471 }
472}
473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474/* Drop all connection on the device */
475void hci_conn_hash_flush(struct hci_dev *hdev)
476{
477 struct hci_conn_hash *h = &hdev->conn_hash;
478 struct list_head *p;
479
480 BT_DBG("hdev %s", hdev->name);
481
482 p = h->list.next;
483 while (p != &h->list) {
484 struct hci_conn *c;
485
486 c = list_entry(p, struct hci_conn, list);
487 p = p->next;
488
489 c->state = BT_CLOSED;
490
491 hci_proto_disconn_ind(c, 0x16);
492 hci_conn_del(c);
493 }
494}
495
496int hci_get_conn_list(void __user *arg)
497{
498 struct hci_conn_list_req req, *cl;
499 struct hci_conn_info *ci;
500 struct hci_dev *hdev;
501 struct list_head *p;
502 int n = 0, size, err;
503
504 if (copy_from_user(&req, arg, sizeof(req)))
505 return -EFAULT;
506
507 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
508 return -EINVAL;
509
510 size = sizeof(req) + req.conn_num * sizeof(*ci);
511
Jesper Juhl12fe2c52006-01-10 13:08:21 -0800512 if (!(cl = kmalloc(size, GFP_KERNEL)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return -ENOMEM;
514
515 if (!(hdev = hci_dev_get(req.dev_id))) {
516 kfree(cl);
517 return -ENODEV;
518 }
519
520 ci = cl->conn_info;
521
522 hci_dev_lock_bh(hdev);
523 list_for_each(p, &hdev->conn_hash.list) {
524 register struct hci_conn *c;
525 c = list_entry(p, struct hci_conn, list);
526
527 bacpy(&(ci + n)->bdaddr, &c->dst);
528 (ci + n)->handle = c->handle;
529 (ci + n)->type = c->type;
530 (ci + n)->out = c->out;
531 (ci + n)->state = c->state;
532 (ci + n)->link_mode = c->link_mode;
533 if (++n >= req.conn_num)
534 break;
535 }
536 hci_dev_unlock_bh(hdev);
537
538 cl->dev_id = hdev->id;
539 cl->conn_num = n;
540 size = sizeof(req) + n * sizeof(*ci);
541
542 hci_dev_put(hdev);
543
544 err = copy_to_user(arg, cl, size);
545 kfree(cl);
546
547 return err ? -EFAULT : 0;
548}
549
550int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
551{
552 struct hci_conn_info_req req;
553 struct hci_conn_info ci;
554 struct hci_conn *conn;
555 char __user *ptr = arg + sizeof(req);
556
557 if (copy_from_user(&req, arg, sizeof(req)))
558 return -EFAULT;
559
560 hci_dev_lock_bh(hdev);
561 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
562 if (conn) {
563 bacpy(&ci.bdaddr, &conn->dst);
564 ci.handle = conn->handle;
565 ci.type = conn->type;
566 ci.out = conn->out;
567 ci.state = conn->state;
568 ci.link_mode = conn->link_mode;
569 }
570 hci_dev_unlock_bh(hdev);
571
572 if (!conn)
573 return -ENOENT;
574
575 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
576}