projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Add disconnect managment command
[deliverable/linux.git] / net / bluetooth / mgmt.c
CommitLineData
0381101f
JH		 1/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2010 Nokia Corporation
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License version 2 as
7 published by the Free Software Foundation;
8
9 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
10 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
11 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
12 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
13 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17
18 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
19 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
20 SOFTWARE IS DISCLAIMED.
21*/
22
23/* Bluetooth HCI Management interface */
24
25#include <asm/uaccess.h>
26#include <asm/unaligned.h>
27
28#include <net/bluetooth/bluetooth.h>
29#include <net/bluetooth/hci_core.h>
30#include <net/bluetooth/mgmt.h>
31
02d98129
JH		 32#define MGMT_VERSION 0
33#define MGMT_REVISION 1
34
eec8d2bc
JH		 35struct pending_cmd {
36 struct list_head list;
37 __u16 opcode;
38 int index;
39 void *cmd;
40 struct sock *sk;
41};
42
43LIST_HEAD(cmd_list);
44
f7b64e69
JH		 45static int cmd_status(struct sock *sk, u16 cmd, u8 status)
46{
47 struct sk_buff *skb;
48 struct mgmt_hdr *hdr;
49 struct mgmt_ev_cmd_status *ev;
50
51 BT_DBG("sock %p", sk);
52
53 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev), GFP_ATOMIC);
54 if (!skb)
55 return -ENOMEM;
56
57 hdr = (void *) skb_put(skb, sizeof(*hdr));
58
59 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_STATUS);
60 hdr->len = cpu_to_le16(sizeof(*ev));
61
62 ev = (void *) skb_put(skb, sizeof(*ev));
63 ev->status = status;
64 put_unaligned_le16(cmd, &ev->opcode);
65
66 if (sock_queue_rcv_skb(sk, skb) < 0)
67 kfree_skb(skb);
68
69 return 0;
70}
71
02d98129
JH		 72static int read_version(struct sock *sk)
73{
74 struct sk_buff *skb;
75 struct mgmt_hdr *hdr;
76 struct mgmt_ev_cmd_complete *ev;
77 struct mgmt_rp_read_version *rp;
78
79 BT_DBG("sock %p", sk);
80
81 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(*rp), GFP_ATOMIC);
82 if (!skb)
83 return -ENOMEM;
84
85 hdr = (void *) skb_put(skb, sizeof(*hdr));
86 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
87 hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(*rp));
88
89 ev = (void *) skb_put(skb, sizeof(*ev));
90 put_unaligned_le16(MGMT_OP_READ_VERSION, &ev->opcode);
91
92 rp = (void *) skb_put(skb, sizeof(*rp));
93 rp->version = MGMT_VERSION;
94 put_unaligned_le16(MGMT_REVISION, &rp->revision);
95
96 if (sock_queue_rcv_skb(sk, skb) < 0)
97 kfree_skb(skb);
98
99 return 0;
100}
101
faba42eb
JH		 102static int read_index_list(struct sock *sk)
103{
104 struct sk_buff *skb;
105 struct mgmt_hdr *hdr;
106 struct mgmt_ev_cmd_complete *ev;
107 struct mgmt_rp_read_index_list *rp;
108 struct list_head *p;
109 size_t body_len;
110 u16 count;
111 int i;
112
113 BT_DBG("sock %p", sk);
114
115 read_lock(&hci_dev_list_lock);
116
117 count = 0;
118 list_for_each(p, &hci_dev_list) {
119 count++;
120 }
121
122 body_len = sizeof(*ev) + sizeof(*rp) + (2 * count);
123 skb = alloc_skb(sizeof(*hdr) + body_len, GFP_ATOMIC);
b2c60d42
JJ		 124 if (!skb) {
125 read_unlock(&hci_dev_list_lock);
faba42eb 126 return -ENOMEM;
b2c60d42 127 }
faba42eb
JH		 128
129 hdr = (void *) skb_put(skb, sizeof(*hdr));
130 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
131 hdr->len = cpu_to_le16(body_len);
132
133 ev = (void *) skb_put(skb, sizeof(*ev));
134 put_unaligned_le16(MGMT_OP_READ_INDEX_LIST, &ev->opcode);
135
136 rp = (void *) skb_put(skb, sizeof(*rp) + (2 * count));
137 put_unaligned_le16(count, &rp->num_controllers);
138
139 i = 0;
140 list_for_each(p, &hci_dev_list) {
141 struct hci_dev *d = list_entry(p, struct hci_dev, list);
ab81cbf9
JH		 142
143 hci_del_off_timer(d);
144
ebc99feb
JH		 145 set_bit(HCI_MGMT, &d->flags);
146
ab81cbf9
JH		 147 if (test_bit(HCI_SETUP, &d->flags))
148 continue;
149
faba42eb
JH		 150 put_unaligned_le16(d->id, &rp->index[i++]);
151 BT_DBG("Added hci%u", d->id);
152 }
153
154 read_unlock(&hci_dev_list_lock);
155
156 if (sock_queue_rcv_skb(sk, skb) < 0)
157 kfree_skb(skb);
158
159 return 0;
160}
161
f7b64e69 162static int read_controller_info(struct sock *sk, unsigned char *data, u16 len)
0381101f
JH		 163{
164 struct sk_buff *skb;
165 struct mgmt_hdr *hdr;
f7b64e69
JH		 166 struct mgmt_ev_cmd_complete *ev;
167 struct mgmt_rp_read_info *rp;
168 struct mgmt_cp_read_info *cp;
169 struct hci_dev *hdev;
170 u16 dev_id;
0381101f
JH		 171
172 BT_DBG("sock %p", sk);
173
f7b64e69
JH		 174 if (len != 2)
175 return cmd_status(sk, MGMT_OP_READ_INFO, EINVAL);
176
177 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(*rp), GFP_ATOMIC);
0381101f 178 if (!skb)
e41d8b4e 179 return -ENOMEM;
0381101f
JH		 180
181 hdr = (void *) skb_put(skb, sizeof(*hdr));
f7b64e69
JH		 182 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
183 hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(*rp));
0381101f
JH		 184
185 ev = (void *) skb_put(skb, sizeof(*ev));
f7b64e69
JH		 186 put_unaligned_le16(MGMT_OP_READ_INFO, &ev->opcode);
187
188 rp = (void *) skb_put(skb, sizeof(*rp));
189
190 cp = (void *) data;
191 dev_id = get_unaligned_le16(&cp->index);
192
193 BT_DBG("request for hci%u", dev_id);
194
195 hdev = hci_dev_get(dev_id);
196 if (!hdev) {
197 kfree_skb(skb);
198 return cmd_status(sk, MGMT_OP_READ_INFO, ENODEV);
199 }
200
ab81cbf9
JH		 201 hci_del_off_timer(hdev);
202
f7b64e69
JH		 203 hci_dev_lock_bh(hdev);
204
ebc99feb
JH		 205 set_bit(HCI_MGMT, &hdev->flags);
206
f7b64e69
JH		 207 put_unaligned_le16(hdev->id, &rp->index);
208 rp->type = hdev->dev_type;
209
210 rp->powered = test_bit(HCI_UP, &hdev->flags);
9fbcbb45 211 rp->connectable = test_bit(HCI_PSCAN, &hdev->flags);
f7b64e69
JH		 212 rp->discoverable = test_bit(HCI_ISCAN, &hdev->flags);
213 rp->pairable = test_bit(HCI_PSCAN, &hdev->flags);
214
215 if (test_bit(HCI_AUTH, &hdev->flags))
216 rp->sec_mode = 3;
217 else if (hdev->ssp_mode > 0)
218 rp->sec_mode = 4;
219 else
220 rp->sec_mode = 2;
221
222 bacpy(&rp->bdaddr, &hdev->bdaddr);
223 memcpy(rp->features, hdev->features, 8);
224 memcpy(rp->dev_class, hdev->dev_class, 3);
225 put_unaligned_le16(hdev->manufacturer, &rp->manufacturer);
226 rp->hci_ver = hdev->hci_ver;
227 put_unaligned_le16(hdev->hci_rev, &rp->hci_rev);
228
229 hci_dev_unlock_bh(hdev);
230 hci_dev_put(hdev);
0381101f
JH		 231
232 if (sock_queue_rcv_skb(sk, skb) < 0)
233 kfree_skb(skb);
e41d8b4e
JH		 234
235 return 0;
0381101f
JH		 236}
237
eec8d2bc
JH		 238static void mgmt_pending_free(struct pending_cmd *cmd)
239{
240 sock_put(cmd->sk);
241 kfree(cmd->cmd);
242 kfree(cmd);
243}
244
245static int mgmt_pending_add(struct sock *sk, u16 opcode, int index,
246 void *data, u16 len)
247{
248 struct pending_cmd *cmd;
249
250 cmd = kmalloc(sizeof(*cmd), GFP_ATOMIC);
251 if (!cmd)
252 return -ENOMEM;
253
254 cmd->opcode = opcode;
255 cmd->index = index;
256
257 cmd->cmd = kmalloc(len, GFP_ATOMIC);
258 if (!cmd->cmd) {
259 kfree(cmd);
260 return -ENOMEM;
261 }
262
263 memcpy(cmd->cmd, data, len);
264
265 cmd->sk = sk;
266 sock_hold(sk);
267
268 list_add(&cmd->list, &cmd_list);
269
270 return 0;
271}
272
273static void mgmt_pending_foreach(u16 opcode, int index,
274 void (*cb)(struct pending_cmd *cmd, void *data),
275 void *data)
276{
277 struct list_head *p, *n;
278
279 list_for_each_safe(p, n, &cmd_list) {
280 struct pending_cmd *cmd;
281
282 cmd = list_entry(p, struct pending_cmd, list);
283
284 if (cmd->opcode != opcode)
285 continue;
286
287 if (index >= 0 && cmd->index != index)
288 continue;
289
290 cb(cmd, data);
291 }
292}
293
294static struct pending_cmd *mgmt_pending_find(u16 opcode, int index)
295{
296 struct list_head *p;
297
298 list_for_each(p, &cmd_list) {
299 struct pending_cmd *cmd;
300
301 cmd = list_entry(p, struct pending_cmd, list);
302
303 if (cmd->opcode != opcode)
304 continue;
305
306 if (index >= 0 && cmd->index != index)
307 continue;
308
309 return cmd;
310 }
311
312 return NULL;
313}
314
73f22f62
JH		 315static void mgmt_pending_remove(u16 opcode, int index)
316{
317 struct pending_cmd *cmd;
318
319 cmd = mgmt_pending_find(opcode, index);
320 if (cmd == NULL)
321 return;
322
323 list_del(&cmd->list);
324 mgmt_pending_free(cmd);
325}
326
eec8d2bc
JH		 327static int set_powered(struct sock *sk, unsigned char *data, u16 len)
328{
72a734ec 329 struct mgmt_mode *cp;
eec8d2bc
JH		 330 struct hci_dev *hdev;
331 u16 dev_id;
332 int ret, up;
333
334 cp = (void *) data;
335 dev_id = get_unaligned_le16(&cp->index);
336
337 BT_DBG("request for hci%u", dev_id);
338
339 hdev = hci_dev_get(dev_id);
340 if (!hdev)
341 return cmd_status(sk, MGMT_OP_SET_POWERED, ENODEV);
342
343 hci_dev_lock_bh(hdev);
344
345 up = test_bit(HCI_UP, &hdev->flags);
72a734ec 346 if ((cp->val && up) || (!cp->val && !up)) {
eec8d2bc
JH		 347 ret = cmd_status(sk, MGMT_OP_SET_POWERED, EALREADY);
348 goto failed;
349 }
350
351 if (mgmt_pending_find(MGMT_OP_SET_POWERED, dev_id)) {
352 ret = cmd_status(sk, MGMT_OP_SET_POWERED, EBUSY);
353 goto failed;
354 }
355
356 ret = mgmt_pending_add(sk, MGMT_OP_SET_POWERED, dev_id, data, len);
357 if (ret < 0)
358 goto failed;
359
72a734ec 360 if (cp->val)
eec8d2bc
JH		 361 queue_work(hdev->workqueue, &hdev->power_on);
362 else
363 queue_work(hdev->workqueue, &hdev->power_off);
364
365 ret = 0;
366
367failed:
368 hci_dev_unlock_bh(hdev);
369 hci_dev_put(hdev);
370 return ret;
371}
372
73f22f62
JH		 373static int set_discoverable(struct sock *sk, unsigned char *data, u16 len)
374{
72a734ec 375 struct mgmt_mode *cp;
73f22f62
JH		 376 struct hci_dev *hdev;
377 u16 dev_id;
378 u8 scan;
379 int err;
380
381 cp = (void *) data;
382 dev_id = get_unaligned_le16(&cp->index);
383
384 BT_DBG("request for hci%u", dev_id);
385
386 hdev = hci_dev_get(dev_id);
387 if (!hdev)
388 return cmd_status(sk, MGMT_OP_SET_DISCOVERABLE, ENODEV);
389
390 hci_dev_lock_bh(hdev);
391
392 if (!test_bit(HCI_UP, &hdev->flags)) {
393 err = cmd_status(sk, MGMT_OP_SET_DISCOVERABLE, ENETDOWN);
394 goto failed;
395 }
396
397 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, dev_id) ||
9fbcbb45 398 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, dev_id)) {
73f22f62
JH		 399 err = cmd_status(sk, MGMT_OP_SET_DISCOVERABLE, EBUSY);
400 goto failed;
401 }
402
72a734ec 403 if (cp->val == test_bit(HCI_ISCAN, &hdev->flags) &&
73f22f62
JH		 404 test_bit(HCI_PSCAN, &hdev->flags)) {
405 err = cmd_status(sk, MGMT_OP_SET_DISCOVERABLE, EALREADY);
406 goto failed;
407 }
408
409 err = mgmt_pending_add(sk, MGMT_OP_SET_DISCOVERABLE, dev_id, data, len);
410 if (err < 0)
411 goto failed;
412
413 scan = SCAN_PAGE;
414
72a734ec 415 if (cp->val)
73f22f62
JH		 416 scan |= SCAN_INQUIRY;
417
418 err = hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
419 if (err < 0)
420 mgmt_pending_remove(MGMT_OP_SET_DISCOVERABLE, dev_id);
421
422failed:
423 hci_dev_unlock_bh(hdev);
424 hci_dev_put(hdev);
425
426 return err;
427}
428
9fbcbb45
JH		 429static int set_connectable(struct sock *sk, unsigned char *data, u16 len)
430{
72a734ec 431 struct mgmt_mode *cp;
9fbcbb45
JH		 432 struct hci_dev *hdev;
433 u16 dev_id;
434 u8 scan;
435 int err;
436
437 cp = (void *) data;
438 dev_id = get_unaligned_le16(&cp->index);
439
440 BT_DBG("request for hci%u", dev_id);
441
442 hdev = hci_dev_get(dev_id);
443 if (!hdev)
444 return cmd_status(sk, MGMT_OP_SET_CONNECTABLE, ENODEV);
445
446 hci_dev_lock_bh(hdev);
447
448 if (!test_bit(HCI_UP, &hdev->flags)) {
449 err = cmd_status(sk, MGMT_OP_SET_CONNECTABLE, ENETDOWN);
450 goto failed;
451 }
452
453 if (mgmt_pending_find(MGMT_OP_SET_DISCOVERABLE, dev_id) ||
454 mgmt_pending_find(MGMT_OP_SET_CONNECTABLE, dev_id)) {
455 err = cmd_status(sk, MGMT_OP_SET_CONNECTABLE, EBUSY);
456 goto failed;
457 }
458
72a734ec 459 if (cp->val == test_bit(HCI_PSCAN, &hdev->flags)) {
9fbcbb45
JH		 460 err = cmd_status(sk, MGMT_OP_SET_CONNECTABLE, EALREADY);
461 goto failed;
462 }
463
464 err = mgmt_pending_add(sk, MGMT_OP_SET_CONNECTABLE, dev_id, data, len);
465 if (err < 0)
466 goto failed;
467
72a734ec 468 if (cp->val)
9fbcbb45
JH		 469 scan = SCAN_PAGE;
470 else
471 scan = 0;
472
473 err = hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan);
474 if (err < 0)
475 mgmt_pending_remove(MGMT_OP_SET_CONNECTABLE, dev_id);
476
477failed:
478 hci_dev_unlock_bh(hdev);
479 hci_dev_put(hdev);
480
481 return err;
482}
483
c542a06c
JH		 484static int mgmt_event(u16 event, void *data, u16 data_len, struct sock *skip_sk)
485{
486 struct sk_buff *skb;
487 struct mgmt_hdr *hdr;
488
489 skb = alloc_skb(sizeof(*hdr) + data_len, GFP_ATOMIC);
490 if (!skb)
491 return -ENOMEM;
492
493 bt_cb(skb)->channel = HCI_CHANNEL_CONTROL;
494
495 hdr = (void *) skb_put(skb, sizeof(*hdr));
496 hdr->opcode = cpu_to_le16(event);
497 hdr->len = cpu_to_le16(data_len);
498
499 memcpy(skb_put(skb, data_len), data, data_len);
500
501 hci_send_to_sock(NULL, skb, skip_sk);
502 kfree_skb(skb);
503
504 return 0;
505}
506
053f0211
JH		 507static int send_mode_rsp(struct sock *sk, u16 opcode, u16 index, u8 val)
508{
509 struct mgmt_hdr *hdr;
510 struct mgmt_ev_cmd_complete *ev;
511 struct mgmt_mode *rp;
512 struct sk_buff *skb;
513
514 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(*rp), GFP_ATOMIC);
515 if (!skb)
516 return -ENOMEM;
517
518 hdr = (void *) skb_put(skb, sizeof(*hdr));
519 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
520 hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(*rp));
521
522 ev = (void *) skb_put(skb, sizeof(*ev));
523 put_unaligned_le16(opcode, &ev->opcode);
524
525 rp = (void *) skb_put(skb, sizeof(*rp));
526 put_unaligned_le16(index, &rp->index);
527 rp->val = val;
528
529 if (sock_queue_rcv_skb(sk, skb) < 0)
530 kfree_skb(skb);
531
532 return 0;
533}
534
c542a06c
JH		 535static int set_pairable(struct sock *sk, unsigned char *data, u16 len)
536{
537 struct mgmt_mode *cp, ev;
538 struct hci_dev *hdev;
539 u16 dev_id;
540 int err;
541
542 cp = (void *) data;
543 dev_id = get_unaligned_le16(&cp->index);
544
545 BT_DBG("request for hci%u", dev_id);
546
547 hdev = hci_dev_get(dev_id);
548 if (!hdev)
549 return cmd_status(sk, MGMT_OP_SET_PAIRABLE, ENODEV);
550
551 hci_dev_lock_bh(hdev);
552
553 if (cp->val)
554 set_bit(HCI_PAIRABLE, &hdev->flags);
555 else
556 clear_bit(HCI_PAIRABLE, &hdev->flags);
557
558 err = send_mode_rsp(sk, MGMT_OP_SET_PAIRABLE, dev_id, cp->val);
559 if (err < 0)
560 goto failed;
561
562 put_unaligned_le16(dev_id, &ev.index);
563 ev.val = cp->val;
564
565 err = mgmt_event(MGMT_EV_PAIRABLE, &ev, sizeof(ev), sk);
566
567failed:
568 hci_dev_unlock_bh(hdev);
569 hci_dev_put(hdev);
570
571 return err;
572}
573
1aff6f09 574static int index_rsp(struct sock *sk, u16 opcode, u16 index)
2aeb9a1a
JH		 575{
576 struct mgmt_hdr *hdr;
577 struct mgmt_ev_cmd_complete *ev;
578 struct sk_buff *skb;
579
580 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(index), GFP_ATOMIC);
581 if (!skb)
582 return -ENOMEM;
583
584 hdr = (void *) skb_put(skb, sizeof(*hdr));
585 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
586 hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(index));
587
588 ev = (void *) skb_put(skb, sizeof(*ev));
589 put_unaligned_le16(opcode, &ev->opcode);
590
591 put_unaligned_le16(index, skb_put(skb, sizeof(index)));
592
593 if (sock_queue_rcv_skb(sk, skb) < 0)
594 kfree_skb(skb);
595
596 return 0;
597}
598
1aff6f09
JH		 599static u8 get_service_classes(struct hci_dev *hdev)
600{
601 struct list_head *p;
602 u8 val = 0;
603
604 list_for_each(p, &hdev->uuids) {
605 struct bt_uuid *uuid = list_entry(p, struct bt_uuid, list);
606
607 val |= uuid->svc_hint;
608 }
609
610 return val;
611}
612
613static int update_class(struct hci_dev *hdev)
614{
615 u8 cod[3];
616
617 BT_DBG("%s", hdev->name);
618
619 if (test_bit(HCI_SERVICE_CACHE, &hdev->flags))
620 return 0;
621
622 cod[0] = hdev->minor_class;
623 cod[1] = hdev->major_class;
624 cod[2] = get_service_classes(hdev);
625
626 if (memcmp(cod, hdev->dev_class, 3) == 0)
627 return 0;
628
629 return hci_send_cmd(hdev, HCI_OP_WRITE_CLASS_OF_DEV, sizeof(cod), cod);
630}
631
2aeb9a1a
JH		 632static int add_uuid(struct sock *sk, unsigned char *data, u16 len)
633{
634 struct mgmt_cp_add_uuid *cp;
635 struct hci_dev *hdev;
636 struct bt_uuid *uuid;
637 u16 dev_id;
638 int err;
639
640 cp = (void *) data;
641 dev_id = get_unaligned_le16(&cp->index);
642
643 BT_DBG("request for hci%u", dev_id);
644
645 hdev = hci_dev_get(dev_id);
646 if (!hdev)
647 return cmd_status(sk, MGMT_OP_ADD_UUID, ENODEV);
648
649 hci_dev_lock_bh(hdev);
650
651 uuid = kmalloc(sizeof(*uuid), GFP_ATOMIC);
652 if (!uuid) {
653 err = -ENOMEM;
654 goto failed;
655 }
656
657 memcpy(uuid->uuid, cp->uuid, 16);
1aff6f09 658 uuid->svc_hint = cp->svc_hint;
2aeb9a1a
JH		 659
660 list_add(&uuid->list, &hdev->uuids);
661
1aff6f09
JH		 662 err = update_class(hdev);
663 if (err < 0)
664 goto failed;
665
666 err = index_rsp(sk, MGMT_OP_ADD_UUID, dev_id);
2aeb9a1a
JH		 667
668failed:
669 hci_dev_unlock_bh(hdev);
670 hci_dev_put(hdev);
671
672 return err;
673}
674
675static int remove_uuid(struct sock *sk, unsigned char *data, u16 len)
676{
677 struct list_head *p, *n;
678 struct mgmt_cp_add_uuid *cp;
679 struct hci_dev *hdev;
680 u8 bt_uuid_any[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
681 u16 dev_id;
682 int err, found;
683
684 cp = (void *) data;
685 dev_id = get_unaligned_le16(&cp->index);
686
687 BT_DBG("request for hci%u", dev_id);
688
689 hdev = hci_dev_get(dev_id);
690 if (!hdev)
691 return cmd_status(sk, MGMT_OP_REMOVE_UUID, ENODEV);
692
693 hci_dev_lock_bh(hdev);
694
695 if (memcmp(cp->uuid, bt_uuid_any, 16) == 0) {
696 err = hci_uuids_clear(hdev);
697 goto unlock;
698 }
699
700 found = 0;
701
702 list_for_each_safe(p, n, &hdev->uuids) {
703 struct bt_uuid *match = list_entry(p, struct bt_uuid, list);
704
705 if (memcmp(match->uuid, cp->uuid, 16) != 0)
706 continue;
707
708 list_del(&match->list);
709 found++;
710 }
711
712 if (found == 0) {
713 err = cmd_status(sk, MGMT_OP_REMOVE_UUID, ENOENT);
714 goto unlock;
715 }
716
1aff6f09
JH		 717 err = update_class(hdev);
718 if (err < 0)
719 goto unlock;
720
721 err = index_rsp(sk, MGMT_OP_REMOVE_UUID, dev_id);
2aeb9a1a
JH		 722
723unlock:
724 hci_dev_unlock_bh(hdev);
725 hci_dev_put(hdev);
726
727 return err;
728}
729
1aff6f09
JH		 730static int set_dev_class(struct sock *sk, unsigned char *data, u16 len)
731{
732 struct hci_dev *hdev;
733 struct mgmt_cp_set_dev_class *cp;
734 u16 dev_id;
735 int err;
736
737 cp = (void *) data;
738 dev_id = get_unaligned_le16(&cp->index);
739
740 BT_DBG("request for hci%u", dev_id);
741
742 hdev = hci_dev_get(dev_id);
743 if (!hdev)
744 return cmd_status(sk, MGMT_OP_SET_DEV_CLASS, ENODEV);
745
746 hci_dev_lock_bh(hdev);
747
748 hdev->major_class = cp->major;
749 hdev->minor_class = cp->minor;
750
751 err = update_class(hdev);
752
753 if (err == 0)
754 err = index_rsp(sk, MGMT_OP_SET_DEV_CLASS, dev_id);
755
756 hci_dev_unlock_bh(hdev);
757 hci_dev_put(hdev);
758
759 return err;
760}
761
762static int set_service_cache(struct sock *sk, unsigned char *data, u16 len)
763{
764 struct hci_dev *hdev;
765 struct mgmt_cp_set_service_cache *cp;
766 u16 dev_id;
767 int err;
768
769 cp = (void *) data;
770 dev_id = get_unaligned_le16(&cp->index);
771
772 hdev = hci_dev_get(dev_id);
773 if (!hdev)
774 return cmd_status(sk, MGMT_OP_SET_SERVICE_CACHE, ENODEV);
775
776 hci_dev_lock_bh(hdev);
777
778 BT_DBG("hci%u enable %d", dev_id, cp->enable);
779
780 if (cp->enable) {
781 set_bit(HCI_SERVICE_CACHE, &hdev->flags);
782 err = 0;
783 } else {
784 clear_bit(HCI_SERVICE_CACHE, &hdev->flags);
785 err = update_class(hdev);
786 }
787
788 if (err == 0)
789 err = index_rsp(sk, MGMT_OP_SET_SERVICE_CACHE, dev_id);
790
791 hci_dev_unlock_bh(hdev);
792 hci_dev_put(hdev);
793
794 return err;
795}
796
55ed8ca1
JH		 797static int load_keys(struct sock *sk, unsigned char *data, u16 len)
798{
799 struct hci_dev *hdev;
800 struct mgmt_cp_load_keys *cp;
801 u16 dev_id, key_count, expected_len;
802 int i;
803
804 cp = (void *) data;
805 dev_id = get_unaligned_le16(&cp->index);
806 key_count = get_unaligned_le16(&cp->key_count);
807
808 expected_len = sizeof(*cp) + key_count * sizeof(struct mgmt_key_info);
809 if (expected_len != len) {
810 BT_ERR("load_keys: expected %u bytes, got %u bytes",
811 len, expected_len);
812 return -EINVAL;
813 }
814
815 hdev = hci_dev_get(dev_id);
816 if (!hdev)
817 return cmd_status(sk, MGMT_OP_LOAD_KEYS, ENODEV);
818
819 BT_DBG("hci%u debug_keys %u key_count %u", dev_id, cp->debug_keys,
820 key_count);
821
822 hci_dev_lock_bh(hdev);
823
824 hci_link_keys_clear(hdev);
825
826 set_bit(HCI_LINK_KEYS, &hdev->flags);
827
828 if (cp->debug_keys)
829 set_bit(HCI_DEBUG_KEYS, &hdev->flags);
830 else
831 clear_bit(HCI_DEBUG_KEYS, &hdev->flags);
832
833 for (i = 0; i < key_count; i++) {
834 struct mgmt_key_info *key = &cp->keys[i];
835
836 hci_add_link_key(hdev, 0, &key->bdaddr, key->val, key->type,
837 key->pin_len);
838 }
839
840 hci_dev_unlock_bh(hdev);
841 hci_dev_put(hdev);
842
843 return 0;
844}
845
846static int remove_key(struct sock *sk, unsigned char *data, u16 len)
847{
848 struct hci_dev *hdev;
849 struct mgmt_cp_remove_key *cp;
850 struct hci_conn *conn;
851 u16 dev_id;
852 int err;
853
854 cp = (void *) data;
855 dev_id = get_unaligned_le16(&cp->index);
856
857 hdev = hci_dev_get(dev_id);
858 if (!hdev)
859 return cmd_status(sk, MGMT_OP_REMOVE_KEY, ENODEV);
860
861 hci_dev_lock_bh(hdev);
862
863 err = hci_remove_link_key(hdev, &cp->bdaddr);
864 if (err < 0) {
865 err = cmd_status(sk, MGMT_OP_REMOVE_KEY, -err);
866 goto unlock;
867 }
868
869 err = 0;
870
871 if (!test_bit(HCI_UP, &hdev->flags) || !cp->disconnect)
872 goto unlock;
873
874 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
875 if (conn) {
876 struct hci_cp_disconnect dc;
877
878 put_unaligned_le16(conn->handle, &dc.handle);
879 dc.reason = 0x13; /* Remote User Terminated Connection */
880 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, 0, NULL);
881 }
882
883unlock:
884 hci_dev_unlock_bh(hdev);
885 hci_dev_put(hdev);
886
887 return err;
888}
889
8962ee74
JH		 890static int disconnect(struct sock *sk, unsigned char *data, u16 len)
891{
892 struct hci_dev *hdev;
893 struct mgmt_cp_disconnect *cp;
894 struct hci_cp_disconnect dc;
895 struct hci_conn *conn;
896 u16 dev_id;
897 int err;
898
899 BT_DBG("");
900
901 cp = (void *) data;
902 dev_id = get_unaligned_le16(&cp->index);
903
904 hdev = hci_dev_get(dev_id);
905 if (!hdev)
906 return cmd_status(sk, MGMT_OP_DISCONNECT, ENODEV);
907
908 hci_dev_lock_bh(hdev);
909
910 if (!test_bit(HCI_UP, &hdev->flags)) {
911 err = cmd_status(sk, MGMT_OP_DISCONNECT, ENETDOWN);
912 goto failed;
913 }
914
915 if (mgmt_pending_find(MGMT_OP_DISCONNECT, dev_id)) {
916 err = cmd_status(sk, MGMT_OP_DISCONNECT, EBUSY);
917 goto failed;
918 }
919
920 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &cp->bdaddr);
921 if (!conn) {
922 err = cmd_status(sk, MGMT_OP_DISCONNECT, ENOTCONN);
923 goto failed;
924 }
925
926 err = mgmt_pending_add(sk, MGMT_OP_DISCONNECT, dev_id, data, len);
927 if (err < 0)
928 goto failed;
929
930 put_unaligned_le16(conn->handle, &dc.handle);
931 dc.reason = 0x13; /* Remote User Terminated Connection */
932
933 err = hci_send_cmd(hdev, HCI_OP_DISCONNECT, sizeof(dc), &dc);
934 if (err < 0)
935 mgmt_pending_remove(MGMT_OP_DISCONNECT, dev_id);
936
937failed:
938 hci_dev_unlock_bh(hdev);
939 hci_dev_put(hdev);
940
941 return err;
942}
943
0381101f
JH		 944int mgmt_control(struct sock *sk, struct msghdr *msg, size_t msglen)
945{
946 unsigned char *buf;
947 struct mgmt_hdr *hdr;
948 u16 opcode, len;
949 int err;
950
951 BT_DBG("got %zu bytes", msglen);
952
953 if (msglen < sizeof(*hdr))
954 return -EINVAL;
955
956 buf = kmalloc(msglen, GFP_ATOMIC);
957 if (!buf)
958 return -ENOMEM;
959
960 if (memcpy_fromiovec(buf, msg->msg_iov, msglen)) {
961 err = -EFAULT;
962 goto done;
963 }
964
965 hdr = (struct mgmt_hdr *) buf;
966 opcode = get_unaligned_le16(&hdr->opcode);
967 len = get_unaligned_le16(&hdr->len);
968
969 if (len != msglen - sizeof(*hdr)) {
970 err = -EINVAL;
971 goto done;
972 }
973
974 switch (opcode) {
02d98129
JH		 975 case MGMT_OP_READ_VERSION:
976 err = read_version(sk);
977 break;
faba42eb
JH		 978 case MGMT_OP_READ_INDEX_LIST:
979 err = read_index_list(sk);
980 break;
f7b64e69
JH		 981 case MGMT_OP_READ_INFO:
982 err = read_controller_info(sk, buf + sizeof(*hdr), len);
983 break;
eec8d2bc
JH		 984 case MGMT_OP_SET_POWERED:
985 err = set_powered(sk, buf + sizeof(*hdr), len);
986 break;
73f22f62
JH		 987 case MGMT_OP_SET_DISCOVERABLE:
988 err = set_discoverable(sk, buf + sizeof(*hdr), len);
989 break;
9fbcbb45
JH		 990 case MGMT_OP_SET_CONNECTABLE:
991 err = set_connectable(sk, buf + sizeof(*hdr), len);
992 break;
c542a06c
JH		 993 case MGMT_OP_SET_PAIRABLE:
994 err = set_pairable(sk, buf + sizeof(*hdr), len);
995 break;
2aeb9a1a
JH		 996 case MGMT_OP_ADD_UUID:
997 err = add_uuid(sk, buf + sizeof(*hdr), len);
998 break;
999 case MGMT_OP_REMOVE_UUID:
1000 err = remove_uuid(sk, buf + sizeof(*hdr), len);
1001 break;
1aff6f09
JH		 1002 case MGMT_OP_SET_DEV_CLASS:
1003 err = set_dev_class(sk, buf + sizeof(*hdr), len);
1004 break;
1005 case MGMT_OP_SET_SERVICE_CACHE:
1006 err = set_service_cache(sk, buf + sizeof(*hdr), len);
1007 break;
55ed8ca1
JH		 1008 case MGMT_OP_LOAD_KEYS:
1009 err = load_keys(sk, buf + sizeof(*hdr), len);
1010 break;
1011 case MGMT_OP_REMOVE_KEY:
1012 err = remove_key(sk, buf + sizeof(*hdr), len);
1013 break;
8962ee74
JH		 1014 case MGMT_OP_DISCONNECT:
1015 err = disconnect(sk, buf + sizeof(*hdr), len);
1016 break;
0381101f
JH		 1017 default:
1018 BT_DBG("Unknown op %u", opcode);
e41d8b4e 1019 err = cmd_status(sk, opcode, 0x01);
0381101f
JH		 1020 break;
1021 }
1022
e41d8b4e
JH		 1023 if (err < 0)
1024 goto done;
1025
0381101f
JH		 1026 err = msglen;
1027
1028done:
1029 kfree(buf);
1030 return err;
1031}
c71e97bf 1032
c71e97bf
JH		 1033int mgmt_index_added(u16 index)
1034{
1035 struct mgmt_ev_index_added ev;
1036
1037 put_unaligned_le16(index, &ev.index);
1038
eec8d2bc 1039 return mgmt_event(MGMT_EV_INDEX_ADDED, &ev, sizeof(ev), NULL);
c71e97bf
JH		 1040}
1041
1042int mgmt_index_removed(u16 index)
1043{
1044 struct mgmt_ev_index_added ev;
1045
1046 put_unaligned_le16(index, &ev.index);
1047
eec8d2bc
JH		 1048 return mgmt_event(MGMT_EV_INDEX_REMOVED, &ev, sizeof(ev), NULL);
1049}
1050
73f22f62 1051struct cmd_lookup {
72a734ec 1052 u8 val;
eec8d2bc
JH		 1053 struct sock *sk;
1054};
1055
72a734ec 1056static void mode_rsp(struct pending_cmd *cmd, void *data)
eec8d2bc 1057{
72a734ec 1058 struct mgmt_mode *cp = cmd->cmd;
73f22f62 1059 struct cmd_lookup *match = data;
eec8d2bc 1060
72a734ec 1061 if (cp->val != match->val)
eec8d2bc
JH		 1062 return;
1063
053f0211 1064 send_mode_rsp(cmd->sk, cmd->opcode, cmd->index, cp->val);
eec8d2bc
JH		 1065
1066 list_del(&cmd->list);
1067
1068 if (match->sk == NULL) {
1069 match->sk = cmd->sk;
1070 sock_hold(match->sk);
1071 }
1072
1073 mgmt_pending_free(cmd);
c71e97bf 1074}
5add6af8
JH		 1075
1076int mgmt_powered(u16 index, u8 powered)
1077{
72a734ec 1078 struct mgmt_mode ev;
73f22f62 1079 struct cmd_lookup match = { powered, NULL };
eec8d2bc 1080 int ret;
5add6af8 1081
72a734ec 1082 mgmt_pending_foreach(MGMT_OP_SET_POWERED, index, mode_rsp, &match);
5add6af8 1083
72a734ec
JH		 1084 put_unaligned_le16(index, &ev.index);
1085 ev.val = powered;
eec8d2bc
JH		 1086
1087 ret = mgmt_event(MGMT_EV_POWERED, &ev, sizeof(ev), match.sk);
1088
1089 if (match.sk)
1090 sock_put(match.sk);
1091
1092 return ret;
5add6af8 1093}
73f22f62 1094
73f22f62
JH		 1095int mgmt_discoverable(u16 index, u8 discoverable)
1096{
72a734ec 1097 struct mgmt_mode ev;
73f22f62
JH		 1098 struct cmd_lookup match = { discoverable, NULL };
1099 int ret;
1100
73f22f62 1101 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, index,
72a734ec
JH		 1102 mode_rsp, &match);
1103
1104 put_unaligned_le16(index, &ev.index);
1105 ev.val = discoverable;
73f22f62
JH		 1106
1107 ret = mgmt_event(MGMT_EV_DISCOVERABLE, &ev, sizeof(ev), match.sk);
1108
1109 if (match.sk)
1110 sock_put(match.sk);
1111
1112 return ret;
1113}
9fbcbb45 1114
9fbcbb45
JH		 1115int mgmt_connectable(u16 index, u8 connectable)
1116{
72a734ec 1117 struct mgmt_mode ev;
9fbcbb45
JH		 1118 struct cmd_lookup match = { connectable, NULL };
1119 int ret;
1120
72a734ec 1121 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, index, mode_rsp, &match);
9fbcbb45 1122
72a734ec
JH		 1123 put_unaligned_le16(index, &ev.index);
1124 ev.val = connectable;
9fbcbb45
JH		 1125
1126 ret = mgmt_event(MGMT_EV_CONNECTABLE, &ev, sizeof(ev), match.sk);
1127
1128 if (match.sk)
1129 sock_put(match.sk);
1130
1131 return ret;
1132}
55ed8ca1
JH		 1133
1134int mgmt_new_key(u16 index, struct link_key *key, u8 old_key_type)
1135{
1136 struct mgmt_ev_new_key ev;
1137
1138 memset(&ev, 0, sizeof(ev));
1139
1140 put_unaligned_le16(index, &ev.index);
1141
1142 bacpy(&ev.key.bdaddr, &key->bdaddr);
1143 ev.key.type = key->type;
1144 memcpy(ev.key.val, key->val, 16);
1145 ev.key.pin_len = key->pin_len;
1146 ev.old_key_type = old_key_type;
1147
1148 return mgmt_event(MGMT_EV_NEW_KEY, &ev, sizeof(ev), NULL);
1149}
f7520543
JH		 1150
1151int mgmt_connected(u16 index, bdaddr_t *bdaddr)
1152{
1153 struct mgmt_ev_connected ev;
1154
1155 put_unaligned_le16(index, &ev.index);
1156 bacpy(&ev.bdaddr, bdaddr);
1157
1158 return mgmt_event(MGMT_EV_CONNECTED, &ev, sizeof(ev), NULL);
1159}
1160
8962ee74
JH		 1161static void disconnect_rsp(struct pending_cmd *cmd, void *data)
1162{
1163 struct mgmt_cp_disconnect *cp = cmd->cmd;
1164 struct sock **sk = data;
1165 struct sk_buff *skb;
1166 struct mgmt_hdr *hdr;
1167 struct mgmt_ev_cmd_complete *ev;
1168 struct mgmt_rp_disconnect *rp;
1169
1170 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(*rp), GFP_ATOMIC);
1171 if (!skb)
1172 return;
1173
1174 hdr = (void *) skb_put(skb, sizeof(*hdr));
1175 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
1176 hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(*rp));
1177
1178 ev = (void *) skb_put(skb, sizeof(*ev));
1179 put_unaligned_le16(MGMT_OP_DISCONNECT, &ev->opcode);
1180
1181 rp = (void *) skb_put(skb, sizeof(*rp));
1182 put_unaligned_le16(cmd->index, &rp->index);
1183 bacpy(&rp->bdaddr, &cp->bdaddr);
1184
1185 if (sock_queue_rcv_skb(cmd->sk, skb) < 0)
1186 kfree_skb(skb);
1187
1188 *sk = cmd->sk;
1189 sock_hold(*sk);
1190
1191 list_del(&cmd->list);
1192 mgmt_pending_free(cmd);
1193}
1194
f7520543
JH		 1195int mgmt_disconnected(u16 index, bdaddr_t *bdaddr)
1196{
1197 struct mgmt_ev_disconnected ev;
8962ee74
JH		 1198 struct sock *sk = NULL;
1199 int err;
1200
1201 mgmt_pending_foreach(MGMT_OP_DISCONNECT, index, disconnect_rsp, &sk);
f7520543
JH		 1202
1203 put_unaligned_le16(index, &ev.index);
1204 bacpy(&ev.bdaddr, bdaddr);
1205
8962ee74
JH		 1206 err = mgmt_event(MGMT_EV_DISCONNECTED, &ev, sizeof(ev), sk);
1207
1208 if (sk)
1209 sock_put(sk);
1210
1211 return err;
1212}
1213
1214int mgmt_disconnect_failed(u16 index)
1215{
1216 struct pending_cmd *cmd;
1217 int err;
1218
1219 cmd = mgmt_pending_find(MGMT_OP_DISCONNECT, index);
1220 if (!cmd)
1221 return -ENOENT;
1222
1223 err = cmd_status(cmd->sk, MGMT_OP_DISCONNECT, EIO);
1224
1225 list_del(&cmd->list);
1226 mgmt_pending_free(cmd);
1227
1228 return err;
f7520543 1229}
Linux kernel - Deliverables
This page took 0.089049 seconds and 5 git commands to generate.