projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[CRYPTO] padlock-aes: Use generic setkey function
[deliverable/linux.git] / net / bluetooth / hci_conn.c
1 /*
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/module.h>
28
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/kernel.h>
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>
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
53 void hci_acl_connect(struct hci_conn *conn)
54 {
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
65 conn->attempt++;
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, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
86 }
87
88 static 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, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
99 }
100
101 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
102 {
103 struct hci_cp_disconnect cp;
104
105 BT_DBG("%p", conn);
106
107 conn->state = BT_DISCONN;
108
109 cp.handle = cpu_to_le16(conn->handle);
110 cp.reason = reason;
111 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
112 }
113
114 void hci_add_sco(struct hci_conn *conn, __u16 handle)
115 {
116 struct hci_dev *hdev = conn->hdev;
117 struct hci_cp_add_sco cp;
118
119 BT_DBG("%p", conn);
120
121 conn->state = BT_CONNECT;
122 conn->out = 1;
123
124 cp.handle = cpu_to_le16(handle);
125 cp.pkt_type = cpu_to_le16(hdev->pkt_type & SCO_PTYPE_MASK);
126
127 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
128 }
129
130 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
131 {
132 struct hci_dev *hdev = conn->hdev;
133 struct hci_cp_setup_sync_conn cp;
134
135 BT_DBG("%p", conn);
136
137 conn->state = BT_CONNECT;
138 conn->out = 1;
139
140 cp.handle = cpu_to_le16(handle);
141 cp.pkt_type = cpu_to_le16(hdev->esco_type);
142
143 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
144 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
145 cp.max_latency = cpu_to_le16(0xffff);
146 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
147 cp.retrans_effort = 0xff;
148
149 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
150 }
151
152 static void hci_conn_timeout(unsigned long arg)
153 {
154 struct hci_conn *conn = (void *) arg;
155 struct hci_dev *hdev = conn->hdev;
156
157 BT_DBG("conn %p state %d", conn, conn->state);
158
159 if (atomic_read(&conn->refcnt))
160 return;
161
162 hci_dev_lock(hdev);
163
164 switch (conn->state) {
165 case BT_CONNECT:
166 if (conn->type == ACL_LINK)
167 hci_acl_connect_cancel(conn);
168 else
169 hci_acl_disconn(conn, 0x13);
170 break;
171 case BT_CONNECTED:
172 hci_acl_disconn(conn, 0x13);
173 break;
174 default:
175 conn->state = BT_CLOSED;
176 break;
177 }
178
179 hci_dev_unlock(hdev);
180 }
181
182 static void hci_conn_idle(unsigned long arg)
183 {
184 struct hci_conn *conn = (void *) arg;
185
186 BT_DBG("conn %p mode %d", conn, conn->mode);
187
188 hci_conn_enter_sniff_mode(conn);
189 }
190
191 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
192 {
193 struct hci_conn *conn;
194
195 BT_DBG("%s dst %s", hdev->name, batostr(dst));
196
197 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
198 if (!conn)
199 return NULL;
200
201 bacpy(&conn->dst, dst);
202 conn->hdev = hdev;
203 conn->type = type;
204 conn->mode = HCI_CM_ACTIVE;
205 conn->state = BT_OPEN;
206
207 conn->power_save = 1;
208
209 skb_queue_head_init(&conn->data_q);
210
211 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
212 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
213
214 atomic_set(&conn->refcnt, 0);
215
216 hci_dev_hold(hdev);
217
218 tasklet_disable(&hdev->tx_task);
219
220 hci_conn_hash_add(hdev, conn);
221 if (hdev->notify)
222 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
223
224 hci_conn_add_sysfs(conn);
225
226 tasklet_enable(&hdev->tx_task);
227
228 return conn;
229 }
230
231 int hci_conn_del(struct hci_conn *conn)
232 {
233 struct hci_dev *hdev = conn->hdev;
234
235 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
236
237 del_timer(&conn->idle_timer);
238
239 del_timer(&conn->disc_timer);
240
241 if (conn->type == ACL_LINK) {
242 struct hci_conn *sco = conn->link;
243 if (sco)
244 sco->link = NULL;
245
246 /* Unacked frames */
247 hdev->acl_cnt += conn->sent;
248 } else {
249 struct hci_conn *acl = conn->link;
250 if (acl) {
251 acl->link = NULL;
252 hci_conn_put(acl);
253 }
254 }
255
256 tasklet_disable(&hdev->tx_task);
257 hci_conn_hash_del(hdev, conn);
258 if (hdev->notify)
259 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
260 tasklet_enable(&hdev->tx_task);
261 skb_queue_purge(&conn->data_q);
262 hci_conn_del_sysfs(conn);
263
264 return 0;
265 }
266
267 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
268 {
269 int use_src = bacmp(src, BDADDR_ANY);
270 struct hci_dev *hdev = NULL;
271 struct list_head *p;
272
273 BT_DBG("%s -> %s", batostr(src), batostr(dst));
274
275 read_lock_bh(&hci_dev_list_lock);
276
277 list_for_each(p, &hci_dev_list) {
278 struct hci_dev *d = list_entry(p, struct hci_dev, list);
279
280 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
281 continue;
282
283 /* Simple routing:
284 * No source address - find interface with bdaddr != dst
285 * Source address - find interface with bdaddr == src
286 */
287
288 if (use_src) {
289 if (!bacmp(&d->bdaddr, src)) {
290 hdev = d; break;
291 }
292 } else {
293 if (bacmp(&d->bdaddr, dst)) {
294 hdev = d; break;
295 }
296 }
297 }
298
299 if (hdev)
300 hdev = hci_dev_hold(hdev);
301
302 read_unlock_bh(&hci_dev_list_lock);
303 return hdev;
304 }
305 EXPORT_SYMBOL(hci_get_route);
306
307 /* Create SCO or ACL connection.
308 * Device _must_ be locked */
309 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst)
310 {
311 struct hci_conn *acl;
312 struct hci_conn *sco;
313
314 BT_DBG("%s dst %s", hdev->name, batostr(dst));
315
316 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
317 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
318 return NULL;
319 }
320
321 hci_conn_hold(acl);
322
323 if (acl->state == BT_OPEN || acl->state == BT_CLOSED)
324 hci_acl_connect(acl);
325
326 if (type == ACL_LINK)
327 return acl;
328
329 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
330 if (!(sco = hci_conn_add(hdev, type, dst))) {
331 hci_conn_put(acl);
332 return NULL;
333 }
334 }
335
336 acl->link = sco;
337 sco->link = acl;
338
339 hci_conn_hold(sco);
340
341 if (acl->state == BT_CONNECTED &&
342 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
343 if (lmp_esco_capable(hdev))
344 hci_setup_sync(sco, acl->handle);
345 else
346 hci_add_sco(sco, acl->handle);
347 }
348
349 return sco;
350 }
351 EXPORT_SYMBOL(hci_connect);
352
353 /* Authenticate remote device */
354 int hci_conn_auth(struct hci_conn *conn)
355 {
356 BT_DBG("conn %p", conn);
357
358 if (conn->link_mode & HCI_LM_AUTH)
359 return 1;
360
361 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
362 struct hci_cp_auth_requested cp;
363 cp.handle = cpu_to_le16(conn->handle);
364 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED, sizeof(cp), &cp);
365 }
366 return 0;
367 }
368 EXPORT_SYMBOL(hci_conn_auth);
369
370 /* Enable encryption */
371 int hci_conn_encrypt(struct hci_conn *conn)
372 {
373 BT_DBG("conn %p", conn);
374
375 if (conn->link_mode & HCI_LM_ENCRYPT)
376 return 1;
377
378 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
379 return 0;
380
381 if (hci_conn_auth(conn)) {
382 struct hci_cp_set_conn_encrypt cp;
383 cp.handle = cpu_to_le16(conn->handle);
384 cp.encrypt = 1;
385 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT, sizeof(cp), &cp);
386 }
387 return 0;
388 }
389 EXPORT_SYMBOL(hci_conn_encrypt);
390
391 /* Change link key */
392 int hci_conn_change_link_key(struct hci_conn *conn)
393 {
394 BT_DBG("conn %p", conn);
395
396 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
397 struct hci_cp_change_conn_link_key cp;
398 cp.handle = cpu_to_le16(conn->handle);
399 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY, sizeof(cp), &cp);
400 }
401 return 0;
402 }
403 EXPORT_SYMBOL(hci_conn_change_link_key);
404
405 /* Switch role */
406 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role)
407 {
408 BT_DBG("conn %p", conn);
409
410 if (!role && conn->link_mode & HCI_LM_MASTER)
411 return 1;
412
413 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
414 struct hci_cp_switch_role cp;
415 bacpy(&cp.bdaddr, &conn->dst);
416 cp.role = role;
417 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
418 }
419 return 0;
420 }
421 EXPORT_SYMBOL(hci_conn_switch_role);
422
423 /* Enter active mode */
424 void hci_conn_enter_active_mode(struct hci_conn *conn)
425 {
426 struct hci_dev *hdev = conn->hdev;
427
428 BT_DBG("conn %p mode %d", conn, conn->mode);
429
430 if (test_bit(HCI_RAW, &hdev->flags))
431 return;
432
433 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
434 goto timer;
435
436 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
437 struct hci_cp_exit_sniff_mode cp;
438 cp.handle = cpu_to_le16(conn->handle);
439 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
440 }
441
442 timer:
443 if (hdev->idle_timeout > 0)
444 mod_timer(&conn->idle_timer,
445 jiffies + msecs_to_jiffies(hdev->idle_timeout));
446 }
447
448 /* Enter sniff mode */
449 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
450 {
451 struct hci_dev *hdev = conn->hdev;
452
453 BT_DBG("conn %p mode %d", conn, conn->mode);
454
455 if (test_bit(HCI_RAW, &hdev->flags))
456 return;
457
458 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
459 return;
460
461 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
462 return;
463
464 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
465 struct hci_cp_sniff_subrate cp;
466 cp.handle = cpu_to_le16(conn->handle);
467 cp.max_latency = cpu_to_le16(0);
468 cp.min_remote_timeout = cpu_to_le16(0);
469 cp.min_local_timeout = cpu_to_le16(0);
470 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
471 }
472
473 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
474 struct hci_cp_sniff_mode cp;
475 cp.handle = cpu_to_le16(conn->handle);
476 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
477 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
478 cp.attempt = cpu_to_le16(4);
479 cp.timeout = cpu_to_le16(1);
480 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
481 }
482 }
483
484 /* Drop all connection on the device */
485 void hci_conn_hash_flush(struct hci_dev *hdev)
486 {
487 struct hci_conn_hash *h = &hdev->conn_hash;
488 struct list_head *p;
489
490 BT_DBG("hdev %s", hdev->name);
491
492 p = h->list.next;
493 while (p != &h->list) {
494 struct hci_conn *c;
495
496 c = list_entry(p, struct hci_conn, list);
497 p = p->next;
498
499 c->state = BT_CLOSED;
500
501 hci_proto_disconn_ind(c, 0x16);
502 hci_conn_del(c);
503 }
504 }
505
506 /* Check pending connect attempts */
507 void hci_conn_check_pending(struct hci_dev *hdev)
508 {
509 struct hci_conn *conn;
510
511 BT_DBG("hdev %s", hdev->name);
512
513 hci_dev_lock(hdev);
514
515 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
516 if (conn)
517 hci_acl_connect(conn);
518
519 hci_dev_unlock(hdev);
520 }
521
522 int hci_get_conn_list(void __user *arg)
523 {
524 struct hci_conn_list_req req, *cl;
525 struct hci_conn_info *ci;
526 struct hci_dev *hdev;
527 struct list_head *p;
528 int n = 0, size, err;
529
530 if (copy_from_user(&req, arg, sizeof(req)))
531 return -EFAULT;
532
533 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
534 return -EINVAL;
535
536 size = sizeof(req) + req.conn_num * sizeof(*ci);
537
538 if (!(cl = kmalloc(size, GFP_KERNEL)))
539 return -ENOMEM;
540
541 if (!(hdev = hci_dev_get(req.dev_id))) {
542 kfree(cl);
543 return -ENODEV;
544 }
545
546 ci = cl->conn_info;
547
548 hci_dev_lock_bh(hdev);
549 list_for_each(p, &hdev->conn_hash.list) {
550 register struct hci_conn *c;
551 c = list_entry(p, struct hci_conn, list);
552
553 bacpy(&(ci + n)->bdaddr, &c->dst);
554 (ci + n)->handle = c->handle;
555 (ci + n)->type = c->type;
556 (ci + n)->out = c->out;
557 (ci + n)->state = c->state;
558 (ci + n)->link_mode = c->link_mode;
559 if (++n >= req.conn_num)
560 break;
561 }
562 hci_dev_unlock_bh(hdev);
563
564 cl->dev_id = hdev->id;
565 cl->conn_num = n;
566 size = sizeof(req) + n * sizeof(*ci);
567
568 hci_dev_put(hdev);
569
570 err = copy_to_user(arg, cl, size);
571 kfree(cl);
572
573 return err ? -EFAULT : 0;
574 }
575
576 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
577 {
578 struct hci_conn_info_req req;
579 struct hci_conn_info ci;
580 struct hci_conn *conn;
581 char __user *ptr = arg + sizeof(req);
582
583 if (copy_from_user(&req, arg, sizeof(req)))
584 return -EFAULT;
585
586 hci_dev_lock_bh(hdev);
587 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
588 if (conn) {
589 bacpy(&ci.bdaddr, &conn->dst);
590 ci.handle = conn->handle;
591 ci.type = conn->type;
592 ci.out = conn->out;
593 ci.state = conn->state;
594 ci.link_mode = conn->link_mode;
595 }
596 hci_dev_unlock_bh(hdev);
597
598 if (!conn)
599 return -ENOENT;
600
601 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
602 }
Linux kernel - Deliverables
This page took 0.064504 seconds and 5 git commands to generate.