blob: a31244e58888c39d4cab34eb082c36b53fe40ec9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 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
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
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI connection handling. */
26
27#include <linux/config.h>
28#include <linux/module.h>
29
30#include <linux/types.h>
31#include <linux/errno.h>
32#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/sched.h>
34#include <linux/slab.h>
35#include <linux/poll.h>
36#include <linux/fcntl.h>
37#include <linux/init.h>
38#include <linux/skbuff.h>
39#include <linux/interrupt.h>
40#include <linux/notifier.h>
41#include <net/sock.h>
42
43#include <asm/system.h>
44#include <asm/uaccess.h>
45#include <asm/unaligned.h>
46
47#include <net/bluetooth/bluetooth.h>
48#include <net/bluetooth/hci_core.h>
49
50#ifndef CONFIG_BT_HCI_CORE_DEBUG
51#undef BT_DBG
52#define BT_DBG(D...)
53#endif
54
55static void hci_acl_connect(struct hci_conn *conn)
56{
57 struct hci_dev *hdev = conn->hdev;
58 struct inquiry_entry *ie;
59 struct hci_cp_create_conn cp;
60
61 BT_DBG("%p", conn);
62
63 conn->state = BT_CONNECT;
64 conn->out = 1;
65 conn->link_mode = HCI_LM_MASTER;
66
67 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;
75 cp.clock_offset = ie->data.clock_offset | __cpu_to_le16(0x8000);
76 memcpy(conn->dev_class, ie->data.dev_class, 3);
77 }
78
79 cp.pkt_type = __cpu_to_le16(hdev->pkt_type & ACL_PTYPE_MASK);
80 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
81 cp.role_switch = 0x01;
82 else
83 cp.role_switch = 0x00;
84
85 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_CREATE_CONN, sizeof(cp), &cp);
86}
87
88void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
89{
90 struct hci_cp_disconnect cp;
91
92 BT_DBG("%p", conn);
93
94 conn->state = BT_DISCONN;
95
96 cp.handle = __cpu_to_le16(conn->handle);
97 cp.reason = reason;
98 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_DISCONNECT, sizeof(cp), &cp);
99}
100
101void hci_add_sco(struct hci_conn *conn, __u16 handle)
102{
103 struct hci_dev *hdev = conn->hdev;
104 struct hci_cp_add_sco cp;
105
106 BT_DBG("%p", conn);
107
108 conn->state = BT_CONNECT;
109 conn->out = 1;
110
111 cp.pkt_type = __cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
112 cp.handle = __cpu_to_le16(handle);
113
114 hci_send_cmd(hdev, OGF_LINK_CTL, OCF_ADD_SCO, sizeof(cp), &cp);
115}
116
117static void hci_conn_timeout(unsigned long arg)
118{
119 struct hci_conn *conn = (void *)arg;
120 struct hci_dev *hdev = conn->hdev;
121
122 BT_DBG("conn %p state %d", conn, conn->state);
123
124 if (atomic_read(&conn->refcnt))
125 return;
126
127 hci_dev_lock(hdev);
128 if (conn->state == BT_CONNECTED)
129 hci_acl_disconn(conn, 0x13);
130 else
131 conn->state = BT_CLOSED;
132 hci_dev_unlock(hdev);
133 return;
134}
135
136static void hci_conn_init_timer(struct hci_conn *conn)
137{
138 init_timer(&conn->timer);
139 conn->timer.function = hci_conn_timeout;
140 conn->timer.data = (unsigned long)conn;
141}
142
143struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
144{
145 struct hci_conn *conn;
146
147 BT_DBG("%s dst %s", hdev->name, batostr(dst));
148
149 if (!(conn = kmalloc(sizeof(struct hci_conn), GFP_ATOMIC)))
150 return NULL;
151 memset(conn, 0, sizeof(struct hci_conn));
152
153 bacpy(&conn->dst, dst);
154 conn->type = type;
155 conn->hdev = hdev;
156 conn->state = BT_OPEN;
157
158 skb_queue_head_init(&conn->data_q);
159 hci_conn_init_timer(conn);
160
161 atomic_set(&conn->refcnt, 0);
162
163 hci_dev_hold(hdev);
164
165 tasklet_disable(&hdev->tx_task);
166
167 hci_conn_hash_add(hdev, conn);
168 if (hdev->notify)
169 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
170
171 tasklet_enable(&hdev->tx_task);
172
173 return conn;
174}
175
176int hci_conn_del(struct hci_conn *conn)
177{
178 struct hci_dev *hdev = conn->hdev;
179
180 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
181
182 hci_conn_del_timer(conn);
183
184 if (conn->type == SCO_LINK) {
185 struct hci_conn *acl = conn->link;
186 if (acl) {
187 acl->link = NULL;
188 hci_conn_put(acl);
189 }
190 } else {
191 struct hci_conn *sco = conn->link;
192 if (sco)
193 sco->link = NULL;
194
195 /* Unacked frames */
196 hdev->acl_cnt += conn->sent;
197 }
198
199 tasklet_disable(&hdev->tx_task);
200
201 hci_conn_hash_del(hdev, conn);
202 if (hdev->notify)
203 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
204
205 tasklet_enable(&hdev->tx_task);
206
207 skb_queue_purge(&conn->data_q);
208
209 hci_dev_put(hdev);
210
211 kfree(conn);
212 return 0;
213}
214
215struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
216{
217 int use_src = bacmp(src, BDADDR_ANY);
218 struct hci_dev *hdev = NULL;
219 struct list_head *p;
220
221 BT_DBG("%s -> %s", batostr(src), batostr(dst));
222
223 read_lock_bh(&hci_dev_list_lock);
224
225 list_for_each(p, &hci_dev_list) {
226 struct hci_dev *d = list_entry(p, struct hci_dev, list);
227
228 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
229 continue;
230
231 /* Simple routing:
232 * No source address - find interface with bdaddr != dst
233 * Source address - find interface with bdaddr == src
234 */
235
236 if (use_src) {
237 if (!bacmp(&d->bdaddr, src)) {
238 hdev = d; break;
239 }
240 } else {
241 if (bacmp(&d->bdaddr, dst)) {
242 hdev = d; break;
243 }
244 }
245 }
246
247 if (hdev)
248 hdev = hci_dev_hold(hdev);
249
250 read_unlock_bh(&hci_dev_list_lock);
251 return hdev;
252}
253EXPORT_SYMBOL(hci_get_route);
254
255/* Create SCO or ACL connection.
256 * Device _must_ be locked */
257struct hci_conn * hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
258{
259 struct hci_conn *acl;
260
261 BT_DBG("%s dst %s", hdev->name, batostr(dst));
262
263 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
264 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
265 return NULL;
266 }
267
268 hci_conn_hold(acl);
269
270 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
271 hci_acl_connect(acl);
272
273 if (type == SCO_LINK) {
274 struct hci_conn *sco;
275
276 if (!(sco = hci_conn_hash_lookup_ba(hdev, SCO_LINK, dst))) {
277 if (!(sco = hci_conn_add(hdev, SCO_LINK, dst))) {
278 hci_conn_put(acl);
279 return NULL;
280 }
281 }
282 acl->link = sco;
283 sco->link = acl;
284
285 hci_conn_hold(sco);
286
287 if (acl->state == BT_CONNECTED &&
288 (sco->state == BT_OPEN || sco->state == BT_CLOSED))
289 hci_add_sco(sco, acl->handle);
290
291 return sco;
292 } else {
293 return acl;
294 }
295}
296EXPORT_SYMBOL(hci_connect);
297
298/* Authenticate remote device */
299int hci_conn_auth(struct hci_conn *conn)
300{
301 BT_DBG("conn %p", conn);
302
303 if (conn->link_mode & HCI_LM_AUTH)
304 return 1;
305
306 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
307 struct hci_cp_auth_requested cp;
308 cp.handle = __cpu_to_le16(conn->handle);
309 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_AUTH_REQUESTED, sizeof(cp), &cp);
310 }
311 return 0;
312}
313EXPORT_SYMBOL(hci_conn_auth);
314
315/* Enable encryption */
316int hci_conn_encrypt(struct hci_conn *conn)
317{
318 BT_DBG("conn %p", conn);
319
320 if (conn->link_mode & HCI_LM_ENCRYPT)
321 return 1;
322
323 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
324 return 0;
325
326 if (hci_conn_auth(conn)) {
327 struct hci_cp_set_conn_encrypt cp;
328 cp.handle = __cpu_to_le16(conn->handle);
329 cp.encrypt = 1;
330 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_SET_CONN_ENCRYPT, sizeof(cp), &cp);
331 }
332 return 0;
333}
334EXPORT_SYMBOL(hci_conn_encrypt);
335
336/* Change link key */
337int hci_conn_change_link_key(struct hci_conn *conn)
338{
339 BT_DBG("conn %p", conn);
340
341 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
342 struct hci_cp_change_conn_link_key cp;
343 cp.handle = __cpu_to_le16(conn->handle);
344 hci_send_cmd(conn->hdev, OGF_LINK_CTL, OCF_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
345 }
346 return 0;
347}
348EXPORT_SYMBOL(hci_conn_change_link_key);
349
350/* Switch role */
351int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
352{
353 BT_DBG("conn %p", conn);
354
355 if (!role && conn->link_mode & HCI_LM_MASTER)
356 return 1;
357
358 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
359 struct hci_cp_switch_role cp;
360 bacpy(&cp.bdaddr, &conn->dst);
361 cp.role = role;
362 hci_send_cmd(conn->hdev, OGF_LINK_POLICY, OCF_SWITCH_ROLE, sizeof(cp), &cp);
363 }
364 return 0;
365}
366EXPORT_SYMBOL(hci_conn_switch_role);
367
368/* Drop all connection on the device */
369void hci_conn_hash_flush(struct hci_dev *hdev)
370{
371 struct hci_conn_hash *h = &hdev->conn_hash;
372 struct list_head *p;
373
374 BT_DBG("hdev %s", hdev->name);
375
376 p = h->list.next;
377 while (p != &h->list) {
378 struct hci_conn *c;
379
380 c = list_entry(p, struct hci_conn, list);
381 p = p->next;
382
383 c->state = BT_CLOSED;
384
385 hci_proto_disconn_ind(c, 0x16);
386 hci_conn_del(c);
387 }
388}
389
390int hci_get_conn_list(void __user *arg)
391{
392 struct hci_conn_list_req req, *cl;
393 struct hci_conn_info *ci;
394 struct hci_dev *hdev;
395 struct list_head *p;
396 int n = 0, size, err;
397
398 if (copy_from_user(&req, arg, sizeof(req)))
399 return -EFAULT;
400
401 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
402 return -EINVAL;
403
404 size = sizeof(req) + req.conn_num * sizeof(*ci);
405
406 if (!(cl = (void *) kmalloc(size, GFP_KERNEL)))
407 return -ENOMEM;
408
409 if (!(hdev = hci_dev_get(req.dev_id))) {
410 kfree(cl);
411 return -ENODEV;
412 }
413
414 ci = cl->conn_info;
415
416 hci_dev_lock_bh(hdev);
417 list_for_each(p, &hdev->conn_hash.list) {
418 register struct hci_conn *c;
419 c = list_entry(p, struct hci_conn, list);
420
421 bacpy(&(ci + n)->bdaddr, &c->dst);
422 (ci + n)->handle = c->handle;
423 (ci + n)->type = c->type;
424 (ci + n)->out = c->out;
425 (ci + n)->state = c->state;
426 (ci + n)->link_mode = c->link_mode;
427 if (++n >= req.conn_num)
428 break;
429 }
430 hci_dev_unlock_bh(hdev);
431
432 cl->dev_id = hdev->id;
433 cl->conn_num = n;
434 size = sizeof(req) + n * sizeof(*ci);
435
436 hci_dev_put(hdev);
437
438 err = copy_to_user(arg, cl, size);
439 kfree(cl);
440
441 return err ? -EFAULT : 0;
442}
443
444int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
445{
446 struct hci_conn_info_req req;
447 struct hci_conn_info ci;
448 struct hci_conn *conn;
449 char __user *ptr = arg + sizeof(req);
450
451 if (copy_from_user(&req, arg, sizeof(req)))
452 return -EFAULT;
453
454 hci_dev_lock_bh(hdev);
455 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
456 if (conn) {
457 bacpy(&ci.bdaddr, &conn->dst);
458 ci.handle = conn->handle;
459 ci.type = conn->type;
460 ci.out = conn->out;
461 ci.state = conn->state;
462 ci.link_mode = conn->link_mode;
463 }
464 hci_dev_unlock_bh(hdev);
465
466 if (!conn)
467 return -ENOENT;
468
469 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
470}