]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - net/bluetooth/mgmt.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Add get_connections managment interface command
[mirror_ubuntu-zesty-kernel.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
2784eb41
JH		 944static int get_connections(struct sock *sk, unsigned char *data, u16 len)
945{
946 struct sk_buff *skb;
947 struct mgmt_hdr *hdr;
948 struct mgmt_cp_get_connections *cp;
949 struct mgmt_ev_cmd_complete *ev;
950 struct mgmt_rp_get_connections *rp;
951 struct hci_dev *hdev;
952 struct list_head *p;
953 size_t body_len;
954 u16 dev_id, count;
955 int i, err;
956
957 BT_DBG("");
958
959 cp = (void *) data;
960 dev_id = get_unaligned_le16(&cp->index);
961
962 hdev = hci_dev_get(dev_id);
963 if (!hdev)
964 return cmd_status(sk, MGMT_OP_GET_CONNECTIONS, ENODEV);
965
966 hci_dev_lock_bh(hdev);
967
968 count = 0;
969 list_for_each(p, &hdev->conn_hash.list) {
970 count++;
971 }
972
973 body_len = sizeof(*ev) + sizeof(*rp) + (count * sizeof(bdaddr_t));
974 skb = alloc_skb(sizeof(*hdr) + body_len, GFP_ATOMIC);
975 if (!skb) {
976 err = -ENOMEM;
977 goto unlock;
978 }
979
980 hdr = (void *) skb_put(skb, sizeof(*hdr));
981 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
982 hdr->len = cpu_to_le16(body_len);
983
984 ev = (void *) skb_put(skb, sizeof(*ev));
985 put_unaligned_le16(MGMT_OP_GET_CONNECTIONS, &ev->opcode);
986
987 rp = (void *) skb_put(skb, sizeof(*rp) + (count * sizeof(bdaddr_t)));
988 put_unaligned_le16(dev_id, &rp->index);
989 put_unaligned_le16(count, &rp->conn_count);
990
991 read_lock(&hci_dev_list_lock);
992
993 i = 0;
994 list_for_each(p, &hdev->conn_hash.list) {
995 struct hci_conn *c = list_entry(p, struct hci_conn, list);
996
997 bacpy(&rp->conn[i++], &c->dst);
998 }
999
1000 read_unlock(&hci_dev_list_lock);
1001
1002 if (sock_queue_rcv_skb(sk, skb) < 0)
1003 kfree_skb(skb);
1004
1005 err = 0;
1006
1007unlock:
1008 hci_dev_unlock_bh(hdev);
1009 hci_dev_put(hdev);
1010 return err;
1011}
1012
0381101f
JH		 1013int mgmt_control(struct sock *sk, struct msghdr *msg, size_t msglen)
1014{
1015 unsigned char *buf;
1016 struct mgmt_hdr *hdr;
1017 u16 opcode, len;
1018 int err;
1019
1020 BT_DBG("got %zu bytes", msglen);
1021
1022 if (msglen < sizeof(*hdr))
1023 return -EINVAL;
1024
1025 buf = kmalloc(msglen, GFP_ATOMIC);
1026 if (!buf)
1027 return -ENOMEM;
1028
1029 if (memcpy_fromiovec(buf, msg->msg_iov, msglen)) {
1030 err = -EFAULT;
1031 goto done;
1032 }
1033
1034 hdr = (struct mgmt_hdr *) buf;
1035 opcode = get_unaligned_le16(&hdr->opcode);
1036 len = get_unaligned_le16(&hdr->len);
1037
1038 if (len != msglen - sizeof(*hdr)) {
1039 err = -EINVAL;
1040 goto done;
1041 }
1042
1043 switch (opcode) {
02d98129
JH		 1044 case MGMT_OP_READ_VERSION:
1045 err = read_version(sk);
1046 break;
faba42eb
JH		 1047 case MGMT_OP_READ_INDEX_LIST:
1048 err = read_index_list(sk);
1049 break;
f7b64e69
JH		 1050 case MGMT_OP_READ_INFO:
1051 err = read_controller_info(sk, buf + sizeof(*hdr), len);
1052 break;
eec8d2bc
JH		 1053 case MGMT_OP_SET_POWERED:
1054 err = set_powered(sk, buf + sizeof(*hdr), len);
1055 break;
73f22f62
JH		 1056 case MGMT_OP_SET_DISCOVERABLE:
1057 err = set_discoverable(sk, buf + sizeof(*hdr), len);
1058 break;
9fbcbb45
JH		 1059 case MGMT_OP_SET_CONNECTABLE:
1060 err = set_connectable(sk, buf + sizeof(*hdr), len);
1061 break;
c542a06c
JH		 1062 case MGMT_OP_SET_PAIRABLE:
1063 err = set_pairable(sk, buf + sizeof(*hdr), len);
1064 break;
2aeb9a1a
JH		 1065 case MGMT_OP_ADD_UUID:
1066 err = add_uuid(sk, buf + sizeof(*hdr), len);
1067 break;
1068 case MGMT_OP_REMOVE_UUID:
1069 err = remove_uuid(sk, buf + sizeof(*hdr), len);
1070 break;
1aff6f09
JH		 1071 case MGMT_OP_SET_DEV_CLASS:
1072 err = set_dev_class(sk, buf + sizeof(*hdr), len);
1073 break;
1074 case MGMT_OP_SET_SERVICE_CACHE:
1075 err = set_service_cache(sk, buf + sizeof(*hdr), len);
1076 break;
55ed8ca1
JH		 1077 case MGMT_OP_LOAD_KEYS:
1078 err = load_keys(sk, buf + sizeof(*hdr), len);
1079 break;
1080 case MGMT_OP_REMOVE_KEY:
1081 err = remove_key(sk, buf + sizeof(*hdr), len);
1082 break;
8962ee74
JH		 1083 case MGMT_OP_DISCONNECT:
1084 err = disconnect(sk, buf + sizeof(*hdr), len);
1085 break;
2784eb41
JH		 1086 case MGMT_OP_GET_CONNECTIONS:
1087 err = get_connections(sk, buf + sizeof(*hdr), len);
1088 break;
0381101f
JH		 1089 default:
1090 BT_DBG("Unknown op %u", opcode);
e41d8b4e 1091 err = cmd_status(sk, opcode, 0x01);
0381101f
JH		 1092 break;
1093 }
1094
e41d8b4e
JH		 1095 if (err < 0)
1096 goto done;
1097
0381101f
JH		 1098 err = msglen;
1099
1100done:
1101 kfree(buf);
1102 return err;
1103}
c71e97bf 1104
c71e97bf
JH		 1105int mgmt_index_added(u16 index)
1106{
1107 struct mgmt_ev_index_added ev;
1108
1109 put_unaligned_le16(index, &ev.index);
1110
eec8d2bc 1111 return mgmt_event(MGMT_EV_INDEX_ADDED, &ev, sizeof(ev), NULL);
c71e97bf
JH		 1112}
1113
1114int mgmt_index_removed(u16 index)
1115{
1116 struct mgmt_ev_index_added ev;
1117
1118 put_unaligned_le16(index, &ev.index);
1119
eec8d2bc
JH		 1120 return mgmt_event(MGMT_EV_INDEX_REMOVED, &ev, sizeof(ev), NULL);
1121}
1122
73f22f62 1123struct cmd_lookup {
72a734ec 1124 u8 val;
eec8d2bc
JH		 1125 struct sock *sk;
1126};
1127
72a734ec 1128static void mode_rsp(struct pending_cmd *cmd, void *data)
eec8d2bc 1129{
72a734ec 1130 struct mgmt_mode *cp = cmd->cmd;
73f22f62 1131 struct cmd_lookup *match = data;
eec8d2bc 1132
72a734ec 1133 if (cp->val != match->val)
eec8d2bc
JH		 1134 return;
1135
053f0211 1136 send_mode_rsp(cmd->sk, cmd->opcode, cmd->index, cp->val);
eec8d2bc
JH		 1137
1138 list_del(&cmd->list);
1139
1140 if (match->sk == NULL) {
1141 match->sk = cmd->sk;
1142 sock_hold(match->sk);
1143 }
1144
1145 mgmt_pending_free(cmd);
c71e97bf 1146}
5add6af8
JH		 1147
1148int mgmt_powered(u16 index, u8 powered)
1149{
72a734ec 1150 struct mgmt_mode ev;
73f22f62 1151 struct cmd_lookup match = { powered, NULL };
eec8d2bc 1152 int ret;
5add6af8 1153
72a734ec 1154 mgmt_pending_foreach(MGMT_OP_SET_POWERED, index, mode_rsp, &match);
5add6af8 1155
72a734ec
JH		 1156 put_unaligned_le16(index, &ev.index);
1157 ev.val = powered;
eec8d2bc
JH		 1158
1159 ret = mgmt_event(MGMT_EV_POWERED, &ev, sizeof(ev), match.sk);
1160
1161 if (match.sk)
1162 sock_put(match.sk);
1163
1164 return ret;
5add6af8 1165}
73f22f62 1166
73f22f62
JH		 1167int mgmt_discoverable(u16 index, u8 discoverable)
1168{
72a734ec 1169 struct mgmt_mode ev;
73f22f62
JH		 1170 struct cmd_lookup match = { discoverable, NULL };
1171 int ret;
1172
73f22f62 1173 mgmt_pending_foreach(MGMT_OP_SET_DISCOVERABLE, index,
72a734ec
JH		 1174 mode_rsp, &match);
1175
1176 put_unaligned_le16(index, &ev.index);
1177 ev.val = discoverable;
73f22f62
JH		 1178
1179 ret = mgmt_event(MGMT_EV_DISCOVERABLE, &ev, sizeof(ev), match.sk);
1180
1181 if (match.sk)
1182 sock_put(match.sk);
1183
1184 return ret;
1185}
9fbcbb45 1186
9fbcbb45
JH		 1187int mgmt_connectable(u16 index, u8 connectable)
1188{
72a734ec 1189 struct mgmt_mode ev;
9fbcbb45
JH		 1190 struct cmd_lookup match = { connectable, NULL };
1191 int ret;
1192
72a734ec 1193 mgmt_pending_foreach(MGMT_OP_SET_CONNECTABLE, index, mode_rsp, &match);
9fbcbb45 1194
72a734ec
JH		 1195 put_unaligned_le16(index, &ev.index);
1196 ev.val = connectable;
9fbcbb45
JH		 1197
1198 ret = mgmt_event(MGMT_EV_CONNECTABLE, &ev, sizeof(ev), match.sk);
1199
1200 if (match.sk)
1201 sock_put(match.sk);
1202
1203 return ret;
1204}
55ed8ca1
JH		 1205
1206int mgmt_new_key(u16 index, struct link_key *key, u8 old_key_type)
1207{
1208 struct mgmt_ev_new_key ev;
1209
1210 memset(&ev, 0, sizeof(ev));
1211
1212 put_unaligned_le16(index, &ev.index);
1213
1214 bacpy(&ev.key.bdaddr, &key->bdaddr);
1215 ev.key.type = key->type;
1216 memcpy(ev.key.val, key->val, 16);
1217 ev.key.pin_len = key->pin_len;
1218 ev.old_key_type = old_key_type;
1219
1220 return mgmt_event(MGMT_EV_NEW_KEY, &ev, sizeof(ev), NULL);
1221}
f7520543
JH		 1222
1223int mgmt_connected(u16 index, bdaddr_t *bdaddr)
1224{
1225 struct mgmt_ev_connected ev;
1226
1227 put_unaligned_le16(index, &ev.index);
1228 bacpy(&ev.bdaddr, bdaddr);
1229
1230 return mgmt_event(MGMT_EV_CONNECTED, &ev, sizeof(ev), NULL);
1231}
1232
8962ee74
JH		 1233static void disconnect_rsp(struct pending_cmd *cmd, void *data)
1234{
1235 struct mgmt_cp_disconnect *cp = cmd->cmd;
1236 struct sock **sk = data;
1237 struct sk_buff *skb;
1238 struct mgmt_hdr *hdr;
1239 struct mgmt_ev_cmd_complete *ev;
1240 struct mgmt_rp_disconnect *rp;
1241
1242 skb = alloc_skb(sizeof(*hdr) + sizeof(*ev) + sizeof(*rp), GFP_ATOMIC);
1243 if (!skb)
1244 return;
1245
1246 hdr = (void *) skb_put(skb, sizeof(*hdr));
1247 hdr->opcode = cpu_to_le16(MGMT_EV_CMD_COMPLETE);
1248 hdr->len = cpu_to_le16(sizeof(*ev) + sizeof(*rp));
1249
1250 ev = (void *) skb_put(skb, sizeof(*ev));
1251 put_unaligned_le16(MGMT_OP_DISCONNECT, &ev->opcode);
1252
1253 rp = (void *) skb_put(skb, sizeof(*rp));
1254 put_unaligned_le16(cmd->index, &rp->index);
1255 bacpy(&rp->bdaddr, &cp->bdaddr);
1256
1257 if (sock_queue_rcv_skb(cmd->sk, skb) < 0)
1258 kfree_skb(skb);
1259
1260 *sk = cmd->sk;
1261 sock_hold(*sk);
1262
1263 list_del(&cmd->list);
1264 mgmt_pending_free(cmd);
1265}
1266
f7520543
JH		 1267int mgmt_disconnected(u16 index, bdaddr_t *bdaddr)
1268{
1269 struct mgmt_ev_disconnected ev;
8962ee74
JH		 1270 struct sock *sk = NULL;
1271 int err;
1272
1273 mgmt_pending_foreach(MGMT_OP_DISCONNECT, index, disconnect_rsp, &sk);
f7520543
JH		 1274
1275 put_unaligned_le16(index, &ev.index);
1276 bacpy(&ev.bdaddr, bdaddr);
1277
8962ee74
JH		 1278 err = mgmt_event(MGMT_EV_DISCONNECTED, &ev, sizeof(ev), sk);
1279
1280 if (sk)
1281 sock_put(sk);
1282
1283 return err;
1284}
1285
1286int mgmt_disconnect_failed(u16 index)
1287{
1288 struct pending_cmd *cmd;
1289 int err;
1290
1291 cmd = mgmt_pending_find(MGMT_OP_DISCONNECT, index);
1292 if (!cmd)
1293 return -ENOENT;
1294
1295 err = cmd_status(cmd->sk, MGMT_OP_DISCONNECT, EIO);
1296
1297 list_del(&cmd->list);
1298 mgmt_pending_free(cmd);
1299
1300 return err;
f7520543 1301}
17d5c04c
JH		 1302
1303int mgmt_connect_failed(u16 index, bdaddr_t *bdaddr, u8 status)
1304{
1305 struct mgmt_ev_connect_failed ev;
1306
1307 put_unaligned_le16(index, &ev.index);
1308 bacpy(&ev.bdaddr, bdaddr);
1309 ev.status = status;
1310
1311 return mgmt_event(MGMT_EV_CONNECT_FAILED, &ev, sizeof(ev), NULL);
1312}
ubuntu-zesty-kernel mirror