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 sockets. */
26 #include <linux/compat.h>
27 #include <linux/export.h>
28 #include <linux/utsname.h>
29 #include <linux/sched.h>
30 #include <asm/unaligned.h>
31
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/hci_mon.h>
35 #include <net/bluetooth/mgmt.h>
36
37 #include "mgmt_util.h"
38
39 static LIST_HEAD(mgmt_chan_list);
40 static DEFINE_MUTEX(mgmt_chan_list_lock);
41
42 static DEFINE_IDA(sock_cookie_ida);
43
44 static atomic_t monitor_promisc = ATOMIC_INIT(0);
45
46 /* ----- HCI socket interface ----- */
47
48 /* Socket info */
49 #define hci_pi(sk) ((struct hci_pinfo *) sk)
50
51 struct hci_pinfo {
52 struct bt_sock bt;
53 struct hci_dev *hdev;
54 struct hci_filter filter;
55 __u8 cmsg_mask;
56 unsigned short channel;
57 unsigned long flags;
58 __u32 cookie;
59 char comm[TASK_COMM_LEN];
60 };
61
hci_hdev_from_sock(struct sock * sk)62 static struct hci_dev *hci_hdev_from_sock(struct sock *sk)
63 {
64 struct hci_dev *hdev = hci_pi(sk)->hdev;
65
66 if (!hdev)
67 return ERR_PTR(-EBADFD);
68 if (hci_dev_test_flag(hdev, HCI_UNREGISTER))
69 return ERR_PTR(-EPIPE);
70 return hdev;
71 }
72
hci_sock_set_flag(struct sock * sk,int nr)73 void hci_sock_set_flag(struct sock *sk, int nr)
74 {
75 set_bit(nr, &hci_pi(sk)->flags);
76 }
77
hci_sock_clear_flag(struct sock * sk,int nr)78 void hci_sock_clear_flag(struct sock *sk, int nr)
79 {
80 clear_bit(nr, &hci_pi(sk)->flags);
81 }
82
hci_sock_test_flag(struct sock * sk,int nr)83 int hci_sock_test_flag(struct sock *sk, int nr)
84 {
85 return test_bit(nr, &hci_pi(sk)->flags);
86 }
87
hci_sock_get_channel(struct sock * sk)88 unsigned short hci_sock_get_channel(struct sock *sk)
89 {
90 return hci_pi(sk)->channel;
91 }
92
hci_sock_get_cookie(struct sock * sk)93 u32 hci_sock_get_cookie(struct sock *sk)
94 {
95 return hci_pi(sk)->cookie;
96 }
97
hci_sock_gen_cookie(struct sock * sk)98 static bool hci_sock_gen_cookie(struct sock *sk)
99 {
100 int id = hci_pi(sk)->cookie;
101
102 if (!id) {
103 id = ida_simple_get(&sock_cookie_ida, 1, 0, GFP_KERNEL);
104 if (id < 0)
105 id = 0xffffffff;
106
107 hci_pi(sk)->cookie = id;
108 get_task_comm(hci_pi(sk)->comm, current);
109 return true;
110 }
111
112 return false;
113 }
114
hci_sock_free_cookie(struct sock * sk)115 static void hci_sock_free_cookie(struct sock *sk)
116 {
117 int id = hci_pi(sk)->cookie;
118
119 if (id) {
120 hci_pi(sk)->cookie = 0xffffffff;
121 ida_simple_remove(&sock_cookie_ida, id);
122 }
123 }
124
hci_test_bit(int nr,const void * addr)125 static inline int hci_test_bit(int nr, const void *addr)
126 {
127 return *((const __u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
128 }
129
130 /* Security filter */
131 #define HCI_SFLT_MAX_OGF 5
132
133 struct hci_sec_filter {
134 __u32 type_mask;
135 __u32 event_mask[2];
136 __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
137 };
138
139 static const struct hci_sec_filter hci_sec_filter = {
140 /* Packet types */
141 0x10,
142 /* Events */
143 { 0x1000d9fe, 0x0000b00c },
144 /* Commands */
145 {
146 { 0x0 },
147 /* OGF_LINK_CTL */
148 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
149 /* OGF_LINK_POLICY */
150 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
151 /* OGF_HOST_CTL */
152 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
153 /* OGF_INFO_PARAM */
154 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
155 /* OGF_STATUS_PARAM */
156 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
157 }
158 };
159
160 static struct bt_sock_list hci_sk_list = {
161 .lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
162 };
163
is_filtered_packet(struct sock * sk,struct sk_buff * skb)164 static bool is_filtered_packet(struct sock *sk, struct sk_buff *skb)
165 {
166 struct hci_filter *flt;
167 int flt_type, flt_event;
168
169 /* Apply filter */
170 flt = &hci_pi(sk)->filter;
171
172 flt_type = hci_skb_pkt_type(skb) & HCI_FLT_TYPE_BITS;
173
174 if (!test_bit(flt_type, &flt->type_mask))
175 return true;
176
177 /* Extra filter for event packets only */
178 if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT)
179 return false;
180
181 flt_event = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
182
183 if (!hci_test_bit(flt_event, &flt->event_mask))
184 return true;
185
186 /* Check filter only when opcode is set */
187 if (!flt->opcode)
188 return false;
189
190 if (flt_event == HCI_EV_CMD_COMPLETE &&
191 flt->opcode != get_unaligned((__le16 *)(skb->data + 3)))
192 return true;
193
194 if (flt_event == HCI_EV_CMD_STATUS &&
195 flt->opcode != get_unaligned((__le16 *)(skb->data + 4)))
196 return true;
197
198 return false;
199 }
200
201 /* Send frame to RAW socket */
hci_send_to_sock(struct hci_dev * hdev,struct sk_buff * skb)202 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
203 {
204 struct sock *sk;
205 struct sk_buff *skb_copy = NULL;
206
207 BT_DBG("hdev %p len %d", hdev, skb->len);
208
209 read_lock(&hci_sk_list.lock);
210
211 sk_for_each(sk, &hci_sk_list.head) {
212 struct sk_buff *nskb;
213
214 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
215 continue;
216
217 /* Don't send frame to the socket it came from */
218 if (skb->sk == sk)
219 continue;
220
221 if (hci_pi(sk)->channel == HCI_CHANNEL_RAW) {
222 if (hci_skb_pkt_type(skb) != HCI_COMMAND_PKT &&
223 hci_skb_pkt_type(skb) != HCI_EVENT_PKT &&
224 hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT &&
225 hci_skb_pkt_type(skb) != HCI_SCODATA_PKT &&
226 hci_skb_pkt_type(skb) != HCI_ISODATA_PKT)
227 continue;
228 if (is_filtered_packet(sk, skb))
229 continue;
230 } else if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
231 if (!bt_cb(skb)->incoming)
232 continue;
233 if (hci_skb_pkt_type(skb) != HCI_EVENT_PKT &&
234 hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT &&
235 hci_skb_pkt_type(skb) != HCI_SCODATA_PKT &&
236 hci_skb_pkt_type(skb) != HCI_ISODATA_PKT)
237 continue;
238 } else {
239 /* Don't send frame to other channel types */
240 continue;
241 }
242
243 if (!skb_copy) {
244 /* Create a private copy with headroom */
245 skb_copy = __pskb_copy_fclone(skb, 1, GFP_ATOMIC, true);
246 if (!skb_copy)
247 continue;
248
249 /* Put type byte before the data */
250 memcpy(skb_push(skb_copy, 1), &hci_skb_pkt_type(skb), 1);
251 }
252
253 nskb = skb_clone(skb_copy, GFP_ATOMIC);
254 if (!nskb)
255 continue;
256
257 if (sock_queue_rcv_skb(sk, nskb))
258 kfree_skb(nskb);
259 }
260
261 read_unlock(&hci_sk_list.lock);
262
263 kfree_skb(skb_copy);
264 }
265
266 /* Send frame to sockets with specific channel */
__hci_send_to_channel(unsigned short channel,struct sk_buff * skb,int flag,struct sock * skip_sk)267 static void __hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
268 int flag, struct sock *skip_sk)
269 {
270 struct sock *sk;
271
272 BT_DBG("channel %u len %d", channel, skb->len);
273
274 sk_for_each(sk, &hci_sk_list.head) {
275 struct sk_buff *nskb;
276
277 /* Ignore socket without the flag set */
278 if (!hci_sock_test_flag(sk, flag))
279 continue;
280
281 /* Skip the original socket */
282 if (sk == skip_sk)
283 continue;
284
285 if (sk->sk_state != BT_BOUND)
286 continue;
287
288 if (hci_pi(sk)->channel != channel)
289 continue;
290
291 nskb = skb_clone(skb, GFP_ATOMIC);
292 if (!nskb)
293 continue;
294
295 if (sock_queue_rcv_skb(sk, nskb))
296 kfree_skb(nskb);
297 }
298
299 }
300
hci_send_to_channel(unsigned short channel,struct sk_buff * skb,int flag,struct sock * skip_sk)301 void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
302 int flag, struct sock *skip_sk)
303 {
304 read_lock(&hci_sk_list.lock);
305 __hci_send_to_channel(channel, skb, flag, skip_sk);
306 read_unlock(&hci_sk_list.lock);
307 }
308
309 /* Send frame to monitor socket */
hci_send_to_monitor(struct hci_dev * hdev,struct sk_buff * skb)310 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb)
311 {
312 struct sk_buff *skb_copy = NULL;
313 struct hci_mon_hdr *hdr;
314 __le16 opcode;
315
316 if (!atomic_read(&monitor_promisc))
317 return;
318
319 BT_DBG("hdev %p len %d", hdev, skb->len);
320
321 switch (hci_skb_pkt_type(skb)) {
322 case HCI_COMMAND_PKT:
323 opcode = cpu_to_le16(HCI_MON_COMMAND_PKT);
324 break;
325 case HCI_EVENT_PKT:
326 opcode = cpu_to_le16(HCI_MON_EVENT_PKT);
327 break;
328 case HCI_ACLDATA_PKT:
329 if (bt_cb(skb)->incoming)
330 opcode = cpu_to_le16(HCI_MON_ACL_RX_PKT);
331 else
332 opcode = cpu_to_le16(HCI_MON_ACL_TX_PKT);
333 break;
334 case HCI_SCODATA_PKT:
335 if (bt_cb(skb)->incoming)
336 opcode = cpu_to_le16(HCI_MON_SCO_RX_PKT);
337 else
338 opcode = cpu_to_le16(HCI_MON_SCO_TX_PKT);
339 break;
340 case HCI_ISODATA_PKT:
341 if (bt_cb(skb)->incoming)
342 opcode = cpu_to_le16(HCI_MON_ISO_RX_PKT);
343 else
344 opcode = cpu_to_le16(HCI_MON_ISO_TX_PKT);
345 break;
346 case HCI_DIAG_PKT:
347 opcode = cpu_to_le16(HCI_MON_VENDOR_DIAG);
348 break;
349 default:
350 return;
351 }
352
353 /* Create a private copy with headroom */
354 skb_copy = __pskb_copy_fclone(skb, HCI_MON_HDR_SIZE, GFP_ATOMIC, true);
355 if (!skb_copy)
356 return;
357
358 /* Put header before the data */
359 hdr = skb_push(skb_copy, HCI_MON_HDR_SIZE);
360 hdr->opcode = opcode;
361 hdr->index = cpu_to_le16(hdev->id);
362 hdr->len = cpu_to_le16(skb->len);
363
364 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb_copy,
365 HCI_SOCK_TRUSTED, NULL);
366 kfree_skb(skb_copy);
367 }
368
hci_send_monitor_ctrl_event(struct hci_dev * hdev,u16 event,void * data,u16 data_len,ktime_t tstamp,int flag,struct sock * skip_sk)369 void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
370 void *data, u16 data_len, ktime_t tstamp,
371 int flag, struct sock *skip_sk)
372 {
373 struct sock *sk;
374 __le16 index;
375
376 if (hdev)
377 index = cpu_to_le16(hdev->id);
378 else
379 index = cpu_to_le16(MGMT_INDEX_NONE);
380
381 read_lock(&hci_sk_list.lock);
382
383 sk_for_each(sk, &hci_sk_list.head) {
384 struct hci_mon_hdr *hdr;
385 struct sk_buff *skb;
386
387 if (hci_pi(sk)->channel != HCI_CHANNEL_CONTROL)
388 continue;
389
390 /* Ignore socket without the flag set */
391 if (!hci_sock_test_flag(sk, flag))
392 continue;
393
394 /* Skip the original socket */
395 if (sk == skip_sk)
396 continue;
397
398 skb = bt_skb_alloc(6 + data_len, GFP_ATOMIC);
399 if (!skb)
400 continue;
401
402 put_unaligned_le32(hci_pi(sk)->cookie, skb_put(skb, 4));
403 put_unaligned_le16(event, skb_put(skb, 2));
404
405 if (data)
406 skb_put_data(skb, data, data_len);
407
408 skb->tstamp = tstamp;
409
410 hdr = skb_push(skb, HCI_MON_HDR_SIZE);
411 hdr->opcode = cpu_to_le16(HCI_MON_CTRL_EVENT);
412 hdr->index = index;
413 hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
414
415 __hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
416 HCI_SOCK_TRUSTED, NULL);
417 kfree_skb(skb);
418 }
419
420 read_unlock(&hci_sk_list.lock);
421 }
422
create_monitor_event(struct hci_dev * hdev,int event)423 static struct sk_buff *create_monitor_event(struct hci_dev *hdev, int event)
424 {
425 struct hci_mon_hdr *hdr;
426 struct hci_mon_new_index *ni;
427 struct hci_mon_index_info *ii;
428 struct sk_buff *skb;
429 __le16 opcode;
430
431 switch (event) {
432 case HCI_DEV_REG:
433 skb = bt_skb_alloc(HCI_MON_NEW_INDEX_SIZE, GFP_ATOMIC);
434 if (!skb)
435 return NULL;
436
437 ni = skb_put(skb, HCI_MON_NEW_INDEX_SIZE);
438 ni->type = hdev->dev_type;
439 ni->bus = hdev->bus;
440 bacpy(&ni->bdaddr, &hdev->bdaddr);
441 memcpy(ni->name, hdev->name, 8);
442
443 opcode = cpu_to_le16(HCI_MON_NEW_INDEX);
444 break;
445
446 case HCI_DEV_UNREG:
447 skb = bt_skb_alloc(0, GFP_ATOMIC);
448 if (!skb)
449 return NULL;
450
451 opcode = cpu_to_le16(HCI_MON_DEL_INDEX);
452 break;
453
454 case HCI_DEV_SETUP:
455 if (hdev->manufacturer == 0xffff)
456 return NULL;
457 fallthrough;
458
459 case HCI_DEV_UP:
460 skb = bt_skb_alloc(HCI_MON_INDEX_INFO_SIZE, GFP_ATOMIC);
461 if (!skb)
462 return NULL;
463
464 ii = skb_put(skb, HCI_MON_INDEX_INFO_SIZE);
465 bacpy(&ii->bdaddr, &hdev->bdaddr);
466 ii->manufacturer = cpu_to_le16(hdev->manufacturer);
467
468 opcode = cpu_to_le16(HCI_MON_INDEX_INFO);
469 break;
470
471 case HCI_DEV_OPEN:
472 skb = bt_skb_alloc(0, GFP_ATOMIC);
473 if (!skb)
474 return NULL;
475
476 opcode = cpu_to_le16(HCI_MON_OPEN_INDEX);
477 break;
478
479 case HCI_DEV_CLOSE:
480 skb = bt_skb_alloc(0, GFP_ATOMIC);
481 if (!skb)
482 return NULL;
483
484 opcode = cpu_to_le16(HCI_MON_CLOSE_INDEX);
485 break;
486
487 default:
488 return NULL;
489 }
490
491 __net_timestamp(skb);
492
493 hdr = skb_push(skb, HCI_MON_HDR_SIZE);
494 hdr->opcode = opcode;
495 hdr->index = cpu_to_le16(hdev->id);
496 hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
497
498 return skb;
499 }
500
create_monitor_ctrl_open(struct sock * sk)501 static struct sk_buff *create_monitor_ctrl_open(struct sock *sk)
502 {
503 struct hci_mon_hdr *hdr;
504 struct sk_buff *skb;
505 u16 format;
506 u8 ver[3];
507 u32 flags;
508
509 /* No message needed when cookie is not present */
510 if (!hci_pi(sk)->cookie)
511 return NULL;
512
513 switch (hci_pi(sk)->channel) {
514 case HCI_CHANNEL_RAW:
515 format = 0x0000;
516 ver[0] = BT_SUBSYS_VERSION;
517 put_unaligned_le16(BT_SUBSYS_REVISION, ver + 1);
518 break;
519 case HCI_CHANNEL_USER:
520 format = 0x0001;
521 ver[0] = BT_SUBSYS_VERSION;
522 put_unaligned_le16(BT_SUBSYS_REVISION, ver + 1);
523 break;
524 case HCI_CHANNEL_CONTROL:
525 format = 0x0002;
526 mgmt_fill_version_info(ver);
527 break;
528 default:
529 /* No message for unsupported format */
530 return NULL;
531 }
532
533 skb = bt_skb_alloc(14 + TASK_COMM_LEN , GFP_ATOMIC);
534 if (!skb)
535 return NULL;
536
537 flags = hci_sock_test_flag(sk, HCI_SOCK_TRUSTED) ? 0x1 : 0x0;
538
539 put_unaligned_le32(hci_pi(sk)->cookie, skb_put(skb, 4));
540 put_unaligned_le16(format, skb_put(skb, 2));
541 skb_put_data(skb, ver, sizeof(ver));
542 put_unaligned_le32(flags, skb_put(skb, 4));
543 skb_put_u8(skb, TASK_COMM_LEN);
544 skb_put_data(skb, hci_pi(sk)->comm, TASK_COMM_LEN);
545
546 __net_timestamp(skb);
547
548 hdr = skb_push(skb, HCI_MON_HDR_SIZE);
549 hdr->opcode = cpu_to_le16(HCI_MON_CTRL_OPEN);
550 if (hci_pi(sk)->hdev)
551 hdr->index = cpu_to_le16(hci_pi(sk)->hdev->id);
552 else
553 hdr->index = cpu_to_le16(HCI_DEV_NONE);
554 hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
555
556 return skb;
557 }
558
create_monitor_ctrl_close(struct sock * sk)559 static struct sk_buff *create_monitor_ctrl_close(struct sock *sk)
560 {
561 struct hci_mon_hdr *hdr;
562 struct sk_buff *skb;
563
564 /* No message needed when cookie is not present */
565 if (!hci_pi(sk)->cookie)
566 return NULL;
567
568 switch (hci_pi(sk)->channel) {
569 case HCI_CHANNEL_RAW:
570 case HCI_CHANNEL_USER:
571 case HCI_CHANNEL_CONTROL:
572 break;
573 default:
574 /* No message for unsupported format */
575 return NULL;
576 }
577
578 skb = bt_skb_alloc(4, GFP_ATOMIC);
579 if (!skb)
580 return NULL;
581
582 put_unaligned_le32(hci_pi(sk)->cookie, skb_put(skb, 4));
583
584 __net_timestamp(skb);
585
586 hdr = skb_push(skb, HCI_MON_HDR_SIZE);
587 hdr->opcode = cpu_to_le16(HCI_MON_CTRL_CLOSE);
588 if (hci_pi(sk)->hdev)
589 hdr->index = cpu_to_le16(hci_pi(sk)->hdev->id);
590 else
591 hdr->index = cpu_to_le16(HCI_DEV_NONE);
592 hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
593
594 return skb;
595 }
596
create_monitor_ctrl_command(struct sock * sk,u16 index,u16 opcode,u16 len,const void * buf)597 static struct sk_buff *create_monitor_ctrl_command(struct sock *sk, u16 index,
598 u16 opcode, u16 len,
599 const void *buf)
600 {
601 struct hci_mon_hdr *hdr;
602 struct sk_buff *skb;
603
604 skb = bt_skb_alloc(6 + len, GFP_ATOMIC);
605 if (!skb)
606 return NULL;
607
608 put_unaligned_le32(hci_pi(sk)->cookie, skb_put(skb, 4));
609 put_unaligned_le16(opcode, skb_put(skb, 2));
610
611 if (buf)
612 skb_put_data(skb, buf, len);
613
614 __net_timestamp(skb);
615
616 hdr = skb_push(skb, HCI_MON_HDR_SIZE);
617 hdr->opcode = cpu_to_le16(HCI_MON_CTRL_COMMAND);
618 hdr->index = cpu_to_le16(index);
619 hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
620
621 return skb;
622 }
623
624 static void __printf(2, 3)
send_monitor_note(struct sock * sk,const char * fmt,...)625 send_monitor_note(struct sock *sk, const char *fmt, ...)
626 {
627 size_t len;
628 struct hci_mon_hdr *hdr;
629 struct sk_buff *skb;
630 va_list args;
631
632 va_start(args, fmt);
633 len = vsnprintf(NULL, 0, fmt, args);
634 va_end(args);
635
636 skb = bt_skb_alloc(len + 1, GFP_ATOMIC);
637 if (!skb)
638 return;
639
640 va_start(args, fmt);
641 vsprintf(skb_put(skb, len), fmt, args);
642 *(u8 *)skb_put(skb, 1) = 0;
643 va_end(args);
644
645 __net_timestamp(skb);
646
647 hdr = (void *)skb_push(skb, HCI_MON_HDR_SIZE);
648 hdr->opcode = cpu_to_le16(HCI_MON_SYSTEM_NOTE);
649 hdr->index = cpu_to_le16(HCI_DEV_NONE);
650 hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
651
652 if (sock_queue_rcv_skb(sk, skb))
653 kfree_skb(skb);
654 }
655
send_monitor_replay(struct sock * sk)656 static void send_monitor_replay(struct sock *sk)
657 {
658 struct hci_dev *hdev;
659
660 read_lock(&hci_dev_list_lock);
661
662 list_for_each_entry(hdev, &hci_dev_list, list) {
663 struct sk_buff *skb;
664
665 skb = create_monitor_event(hdev, HCI_DEV_REG);
666 if (!skb)
667 continue;
668
669 if (sock_queue_rcv_skb(sk, skb))
670 kfree_skb(skb);
671
672 if (!test_bit(HCI_RUNNING, &hdev->flags))
673 continue;
674
675 skb = create_monitor_event(hdev, HCI_DEV_OPEN);
676 if (!skb)
677 continue;
678
679 if (sock_queue_rcv_skb(sk, skb))
680 kfree_skb(skb);
681
682 if (test_bit(HCI_UP, &hdev->flags))
683 skb = create_monitor_event(hdev, HCI_DEV_UP);
684 else if (hci_dev_test_flag(hdev, HCI_SETUP))
685 skb = create_monitor_event(hdev, HCI_DEV_SETUP);
686 else
687 skb = NULL;
688
689 if (skb) {
690 if (sock_queue_rcv_skb(sk, skb))
691 kfree_skb(skb);
692 }
693 }
694
695 read_unlock(&hci_dev_list_lock);
696 }
697
send_monitor_control_replay(struct sock * mon_sk)698 static void send_monitor_control_replay(struct sock *mon_sk)
699 {
700 struct sock *sk;
701
702 read_lock(&hci_sk_list.lock);
703
704 sk_for_each(sk, &hci_sk_list.head) {
705 struct sk_buff *skb;
706
707 skb = create_monitor_ctrl_open(sk);
708 if (!skb)
709 continue;
710
711 if (sock_queue_rcv_skb(mon_sk, skb))
712 kfree_skb(skb);
713 }
714
715 read_unlock(&hci_sk_list.lock);
716 }
717
718 /* Generate internal stack event */
hci_si_event(struct hci_dev * hdev,int type,int dlen,void * data)719 static void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
720 {
721 struct hci_event_hdr *hdr;
722 struct hci_ev_stack_internal *ev;
723 struct sk_buff *skb;
724
725 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
726 if (!skb)
727 return;
728
729 hdr = skb_put(skb, HCI_EVENT_HDR_SIZE);
730 hdr->evt = HCI_EV_STACK_INTERNAL;
731 hdr->plen = sizeof(*ev) + dlen;
732
733 ev = skb_put(skb, sizeof(*ev) + dlen);
734 ev->type = type;
735 memcpy(ev->data, data, dlen);
736
737 bt_cb(skb)->incoming = 1;
738 __net_timestamp(skb);
739
740 hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
741 hci_send_to_sock(hdev, skb);
742 kfree_skb(skb);
743 }
744
hci_sock_dev_event(struct hci_dev * hdev,int event)745 void hci_sock_dev_event(struct hci_dev *hdev, int event)
746 {
747 BT_DBG("hdev %s event %d", hdev->name, event);
748
749 if (atomic_read(&monitor_promisc)) {
750 struct sk_buff *skb;
751
752 /* Send event to monitor */
753 skb = create_monitor_event(hdev, event);
754 if (skb) {
755 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
756 HCI_SOCK_TRUSTED, NULL);
757 kfree_skb(skb);
758 }
759 }
760
761 if (event <= HCI_DEV_DOWN) {
762 struct hci_ev_si_device ev;
763
764 /* Send event to sockets */
765 ev.event = event;
766 ev.dev_id = hdev->id;
767 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
768 }
769
770 if (event == HCI_DEV_UNREG) {
771 struct sock *sk;
772
773 /* Wake up sockets using this dead device */
774 read_lock(&hci_sk_list.lock);
775 sk_for_each(sk, &hci_sk_list.head) {
776 if (hci_pi(sk)->hdev == hdev) {
777 sk->sk_err = EPIPE;
778 sk->sk_state_change(sk);
779 }
780 }
781 read_unlock(&hci_sk_list.lock);
782 }
783 }
784
__hci_mgmt_chan_find(unsigned short channel)785 static struct hci_mgmt_chan *__hci_mgmt_chan_find(unsigned short channel)
786 {
787 struct hci_mgmt_chan *c;
788
789 list_for_each_entry(c, &mgmt_chan_list, list) {
790 if (c->channel == channel)
791 return c;
792 }
793
794 return NULL;
795 }
796
hci_mgmt_chan_find(unsigned short channel)797 static struct hci_mgmt_chan *hci_mgmt_chan_find(unsigned short channel)
798 {
799 struct hci_mgmt_chan *c;
800
801 mutex_lock(&mgmt_chan_list_lock);
802 c = __hci_mgmt_chan_find(channel);
803 mutex_unlock(&mgmt_chan_list_lock);
804
805 return c;
806 }
807
hci_mgmt_chan_register(struct hci_mgmt_chan * c)808 int hci_mgmt_chan_register(struct hci_mgmt_chan *c)
809 {
810 if (c->channel < HCI_CHANNEL_CONTROL)
811 return -EINVAL;
812
813 mutex_lock(&mgmt_chan_list_lock);
814 if (__hci_mgmt_chan_find(c->channel)) {
815 mutex_unlock(&mgmt_chan_list_lock);
816 return -EALREADY;
817 }
818
819 list_add_tail(&c->list, &mgmt_chan_list);
820
821 mutex_unlock(&mgmt_chan_list_lock);
822
823 return 0;
824 }
825 EXPORT_SYMBOL(hci_mgmt_chan_register);
826
hci_mgmt_chan_unregister(struct hci_mgmt_chan * c)827 void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c)
828 {
829 mutex_lock(&mgmt_chan_list_lock);
830 list_del(&c->list);
831 mutex_unlock(&mgmt_chan_list_lock);
832 }
833 EXPORT_SYMBOL(hci_mgmt_chan_unregister);
834
hci_sock_release(struct socket * sock)835 static int hci_sock_release(struct socket *sock)
836 {
837 struct sock *sk = sock->sk;
838 struct hci_dev *hdev;
839 struct sk_buff *skb;
840
841 BT_DBG("sock %p sk %p", sock, sk);
842
843 if (!sk)
844 return 0;
845
846 lock_sock(sk);
847
848 switch (hci_pi(sk)->channel) {
849 case HCI_CHANNEL_MONITOR:
850 atomic_dec(&monitor_promisc);
851 break;
852 case HCI_CHANNEL_RAW:
853 case HCI_CHANNEL_USER:
854 case HCI_CHANNEL_CONTROL:
855 /* Send event to monitor */
856 skb = create_monitor_ctrl_close(sk);
857 if (skb) {
858 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
859 HCI_SOCK_TRUSTED, NULL);
860 kfree_skb(skb);
861 }
862
863 hci_sock_free_cookie(sk);
864 break;
865 }
866
867 bt_sock_unlink(&hci_sk_list, sk);
868
869 hdev = hci_pi(sk)->hdev;
870 if (hdev) {
871 if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
872 /* When releasing a user channel exclusive access,
873 * call hci_dev_do_close directly instead of calling
874 * hci_dev_close to ensure the exclusive access will
875 * be released and the controller brought back down.
876 *
877 * The checking of HCI_AUTO_OFF is not needed in this
878 * case since it will have been cleared already when
879 * opening the user channel.
880 */
881 hci_dev_do_close(hdev);
882 hci_dev_clear_flag(hdev, HCI_USER_CHANNEL);
883 mgmt_index_added(hdev);
884 }
885
886 atomic_dec(&hdev->promisc);
887 hci_dev_put(hdev);
888 }
889
890 sock_orphan(sk);
891
892 skb_queue_purge(&sk->sk_receive_queue);
893 skb_queue_purge(&sk->sk_write_queue);
894
895 release_sock(sk);
896 sock_put(sk);
897 return 0;
898 }
899
hci_sock_blacklist_add(struct hci_dev * hdev,void __user * arg)900 static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
901 {
902 bdaddr_t bdaddr;
903 int err;
904
905 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
906 return -EFAULT;
907
908 hci_dev_lock(hdev);
909
910 err = hci_bdaddr_list_add(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
911
912 hci_dev_unlock(hdev);
913
914 return err;
915 }
916
hci_sock_blacklist_del(struct hci_dev * hdev,void __user * arg)917 static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg)
918 {
919 bdaddr_t bdaddr;
920 int err;
921
922 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
923 return -EFAULT;
924
925 hci_dev_lock(hdev);
926
927 err = hci_bdaddr_list_del(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
928
929 hci_dev_unlock(hdev);
930
931 return err;
932 }
933
934 /* Ioctls that require bound socket */
hci_sock_bound_ioctl(struct sock * sk,unsigned int cmd,unsigned long arg)935 static int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd,
936 unsigned long arg)
937 {
938 struct hci_dev *hdev = hci_hdev_from_sock(sk);
939
940 if (IS_ERR(hdev))
941 return PTR_ERR(hdev);
942
943 if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL))
944 return -EBUSY;
945
946 if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED))
947 return -EOPNOTSUPP;
948
949 if (hdev->dev_type != HCI_PRIMARY)
950 return -EOPNOTSUPP;
951
952 switch (cmd) {
953 case HCISETRAW:
954 if (!capable(CAP_NET_ADMIN))
955 return -EPERM;
956 return -EOPNOTSUPP;
957
958 case HCIGETCONNINFO:
959 return hci_get_conn_info(hdev, (void __user *)arg);
960
961 case HCIGETAUTHINFO:
962 return hci_get_auth_info(hdev, (void __user *)arg);
963
964 case HCIBLOCKADDR:
965 if (!capable(CAP_NET_ADMIN))
966 return -EPERM;
967 return hci_sock_blacklist_add(hdev, (void __user *)arg);
968
969 case HCIUNBLOCKADDR:
970 if (!capable(CAP_NET_ADMIN))
971 return -EPERM;
972 return hci_sock_blacklist_del(hdev, (void __user *)arg);
973 }
974
975 return -ENOIOCTLCMD;
976 }
977
hci_sock_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)978 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd,
979 unsigned long arg)
980 {
981 void __user *argp = (void __user *)arg;
982 struct sock *sk = sock->sk;
983 int err;
984
985 BT_DBG("cmd %x arg %lx", cmd, arg);
986
987 lock_sock(sk);
988
989 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
990 err = -EBADFD;
991 goto done;
992 }
993
994 /* When calling an ioctl on an unbound raw socket, then ensure
995 * that the monitor gets informed. Ensure that the resulting event
996 * is only send once by checking if the cookie exists or not. The
997 * socket cookie will be only ever generated once for the lifetime
998 * of a given socket.
999 */
1000 if (hci_sock_gen_cookie(sk)) {
1001 struct sk_buff *skb;
1002
1003 /* Perform careful checks before setting the HCI_SOCK_TRUSTED
1004 * flag. Make sure that not only the current task but also
1005 * the socket opener has the required capability, since
1006 * privileged programs can be tricked into making ioctl calls
1007 * on HCI sockets, and the socket should not be marked as
1008 * trusted simply because the ioctl caller is privileged.
1009 */
1010 if (sk_capable(sk, CAP_NET_ADMIN))
1011 hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
1012
1013 /* Send event to monitor */
1014 skb = create_monitor_ctrl_open(sk);
1015 if (skb) {
1016 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1017 HCI_SOCK_TRUSTED, NULL);
1018 kfree_skb(skb);
1019 }
1020 }
1021
1022 release_sock(sk);
1023
1024 switch (cmd) {
1025 case HCIGETDEVLIST:
1026 return hci_get_dev_list(argp);
1027
1028 case HCIGETDEVINFO:
1029 return hci_get_dev_info(argp);
1030
1031 case HCIGETCONNLIST:
1032 return hci_get_conn_list(argp);
1033
1034 case HCIDEVUP:
1035 if (!capable(CAP_NET_ADMIN))
1036 return -EPERM;
1037 return hci_dev_open(arg);
1038
1039 case HCIDEVDOWN:
1040 if (!capable(CAP_NET_ADMIN))
1041 return -EPERM;
1042 return hci_dev_close(arg);
1043
1044 case HCIDEVRESET:
1045 if (!capable(CAP_NET_ADMIN))
1046 return -EPERM;
1047 return hci_dev_reset(arg);
1048
1049 case HCIDEVRESTAT:
1050 if (!capable(CAP_NET_ADMIN))
1051 return -EPERM;
1052 return hci_dev_reset_stat(arg);
1053
1054 case HCISETSCAN:
1055 case HCISETAUTH:
1056 case HCISETENCRYPT:
1057 case HCISETPTYPE:
1058 case HCISETLINKPOL:
1059 case HCISETLINKMODE:
1060 case HCISETACLMTU:
1061 case HCISETSCOMTU:
1062 if (!capable(CAP_NET_ADMIN))
1063 return -EPERM;
1064 return hci_dev_cmd(cmd, argp);
1065
1066 case HCIINQUIRY:
1067 return hci_inquiry(argp);
1068 }
1069
1070 lock_sock(sk);
1071
1072 err = hci_sock_bound_ioctl(sk, cmd, arg);
1073
1074 done:
1075 release_sock(sk);
1076 return err;
1077 }
1078
1079 #ifdef CONFIG_COMPAT
hci_sock_compat_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)1080 static int hci_sock_compat_ioctl(struct socket *sock, unsigned int cmd,
1081 unsigned long arg)
1082 {
1083 switch (cmd) {
1084 case HCIDEVUP:
1085 case HCIDEVDOWN:
1086 case HCIDEVRESET:
1087 case HCIDEVRESTAT:
1088 return hci_sock_ioctl(sock, cmd, arg);
1089 }
1090
1091 return hci_sock_ioctl(sock, cmd, (unsigned long)compat_ptr(arg));
1092 }
1093 #endif
1094
hci_sock_bind(struct socket * sock,struct sockaddr * addr,int addr_len)1095 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr,
1096 int addr_len)
1097 {
1098 struct sockaddr_hci haddr;
1099 struct sock *sk = sock->sk;
1100 struct hci_dev *hdev = NULL;
1101 struct sk_buff *skb;
1102 int len, err = 0;
1103
1104 BT_DBG("sock %p sk %p", sock, sk);
1105
1106 if (!addr)
1107 return -EINVAL;
1108
1109 memset(&haddr, 0, sizeof(haddr));
1110 len = min_t(unsigned int, sizeof(haddr), addr_len);
1111 memcpy(&haddr, addr, len);
1112
1113 if (haddr.hci_family != AF_BLUETOOTH)
1114 return -EINVAL;
1115
1116 lock_sock(sk);
1117
1118 /* Allow detaching from dead device and attaching to alive device, if
1119 * the caller wants to re-bind (instead of close) this socket in
1120 * response to hci_sock_dev_event(HCI_DEV_UNREG) notification.
1121 */
1122 hdev = hci_pi(sk)->hdev;
1123 if (hdev && hci_dev_test_flag(hdev, HCI_UNREGISTER)) {
1124 hci_pi(sk)->hdev = NULL;
1125 sk->sk_state = BT_OPEN;
1126 hci_dev_put(hdev);
1127 }
1128 hdev = NULL;
1129
1130 if (sk->sk_state == BT_BOUND) {
1131 err = -EALREADY;
1132 goto done;
1133 }
1134
1135 switch (haddr.hci_channel) {
1136 case HCI_CHANNEL_RAW:
1137 if (hci_pi(sk)->hdev) {
1138 err = -EALREADY;
1139 goto done;
1140 }
1141
1142 if (haddr.hci_dev != HCI_DEV_NONE) {
1143 hdev = hci_dev_get(haddr.hci_dev);
1144 if (!hdev) {
1145 err = -ENODEV;
1146 goto done;
1147 }
1148
1149 atomic_inc(&hdev->promisc);
1150 }
1151
1152 hci_pi(sk)->channel = haddr.hci_channel;
1153
1154 if (!hci_sock_gen_cookie(sk)) {
1155 /* In the case when a cookie has already been assigned,
1156 * then there has been already an ioctl issued against
1157 * an unbound socket and with that triggerd an open
1158 * notification. Send a close notification first to
1159 * allow the state transition to bounded.
1160 */
1161 skb = create_monitor_ctrl_close(sk);
1162 if (skb) {
1163 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1164 HCI_SOCK_TRUSTED, NULL);
1165 kfree_skb(skb);
1166 }
1167 }
1168
1169 if (capable(CAP_NET_ADMIN))
1170 hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
1171
1172 hci_pi(sk)->hdev = hdev;
1173
1174 /* Send event to monitor */
1175 skb = create_monitor_ctrl_open(sk);
1176 if (skb) {
1177 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1178 HCI_SOCK_TRUSTED, NULL);
1179 kfree_skb(skb);
1180 }
1181 break;
1182
1183 case HCI_CHANNEL_USER:
1184 if (hci_pi(sk)->hdev) {
1185 err = -EALREADY;
1186 goto done;
1187 }
1188
1189 if (haddr.hci_dev == HCI_DEV_NONE) {
1190 err = -EINVAL;
1191 goto done;
1192 }
1193
1194 if (!capable(CAP_NET_ADMIN)) {
1195 err = -EPERM;
1196 goto done;
1197 }
1198
1199 hdev = hci_dev_get(haddr.hci_dev);
1200 if (!hdev) {
1201 err = -ENODEV;
1202 goto done;
1203 }
1204
1205 if (test_bit(HCI_INIT, &hdev->flags) ||
1206 hci_dev_test_flag(hdev, HCI_SETUP) ||
1207 hci_dev_test_flag(hdev, HCI_CONFIG) ||
1208 (!hci_dev_test_flag(hdev, HCI_AUTO_OFF) &&
1209 test_bit(HCI_UP, &hdev->flags))) {
1210 err = -EBUSY;
1211 hci_dev_put(hdev);
1212 goto done;
1213 }
1214
1215 if (hci_dev_test_and_set_flag(hdev, HCI_USER_CHANNEL)) {
1216 err = -EUSERS;
1217 hci_dev_put(hdev);
1218 goto done;
1219 }
1220
1221 mgmt_index_removed(hdev);
1222
1223 err = hci_dev_open(hdev->id);
1224 if (err) {
1225 if (err == -EALREADY) {
1226 /* In case the transport is already up and
1227 * running, clear the error here.
1228 *
1229 * This can happen when opening a user
1230 * channel and HCI_AUTO_OFF grace period
1231 * is still active.
1232 */
1233 err = 0;
1234 } else {
1235 hci_dev_clear_flag(hdev, HCI_USER_CHANNEL);
1236 mgmt_index_added(hdev);
1237 hci_dev_put(hdev);
1238 goto done;
1239 }
1240 }
1241
1242 hci_pi(sk)->channel = haddr.hci_channel;
1243
1244 if (!hci_sock_gen_cookie(sk)) {
1245 /* In the case when a cookie has already been assigned,
1246 * this socket will transition from a raw socket into
1247 * a user channel socket. For a clean transition, send
1248 * the close notification first.
1249 */
1250 skb = create_monitor_ctrl_close(sk);
1251 if (skb) {
1252 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1253 HCI_SOCK_TRUSTED, NULL);
1254 kfree_skb(skb);
1255 }
1256 }
1257
1258 /* The user channel is restricted to CAP_NET_ADMIN
1259 * capabilities and with that implicitly trusted.
1260 */
1261 hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
1262
1263 hci_pi(sk)->hdev = hdev;
1264
1265 /* Send event to monitor */
1266 skb = create_monitor_ctrl_open(sk);
1267 if (skb) {
1268 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1269 HCI_SOCK_TRUSTED, NULL);
1270 kfree_skb(skb);
1271 }
1272
1273 atomic_inc(&hdev->promisc);
1274 break;
1275
1276 case HCI_CHANNEL_MONITOR:
1277 if (haddr.hci_dev != HCI_DEV_NONE) {
1278 err = -EINVAL;
1279 goto done;
1280 }
1281
1282 if (!capable(CAP_NET_RAW)) {
1283 err = -EPERM;
1284 goto done;
1285 }
1286
1287 hci_pi(sk)->channel = haddr.hci_channel;
1288
1289 /* The monitor interface is restricted to CAP_NET_RAW
1290 * capabilities and with that implicitly trusted.
1291 */
1292 hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
1293
1294 send_monitor_note(sk, "Linux version %s (%s)",
1295 init_utsname()->release,
1296 init_utsname()->machine);
1297 send_monitor_note(sk, "Bluetooth subsystem version %u.%u",
1298 BT_SUBSYS_VERSION, BT_SUBSYS_REVISION);
1299 send_monitor_replay(sk);
1300 send_monitor_control_replay(sk);
1301
1302 atomic_inc(&monitor_promisc);
1303 break;
1304
1305 case HCI_CHANNEL_LOGGING:
1306 if (haddr.hci_dev != HCI_DEV_NONE) {
1307 err = -EINVAL;
1308 goto done;
1309 }
1310
1311 if (!capable(CAP_NET_ADMIN)) {
1312 err = -EPERM;
1313 goto done;
1314 }
1315
1316 hci_pi(sk)->channel = haddr.hci_channel;
1317 break;
1318
1319 default:
1320 if (!hci_mgmt_chan_find(haddr.hci_channel)) {
1321 err = -EINVAL;
1322 goto done;
1323 }
1324
1325 if (haddr.hci_dev != HCI_DEV_NONE) {
1326 err = -EINVAL;
1327 goto done;
1328 }
1329
1330 /* Users with CAP_NET_ADMIN capabilities are allowed
1331 * access to all management commands and events. For
1332 * untrusted users the interface is restricted and
1333 * also only untrusted events are sent.
1334 */
1335 if (capable(CAP_NET_ADMIN))
1336 hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
1337
1338 hci_pi(sk)->channel = haddr.hci_channel;
1339
1340 /* At the moment the index and unconfigured index events
1341 * are enabled unconditionally. Setting them on each
1342 * socket when binding keeps this functionality. They
1343 * however might be cleared later and then sending of these
1344 * events will be disabled, but that is then intentional.
1345 *
1346 * This also enables generic events that are safe to be
1347 * received by untrusted users. Example for such events
1348 * are changes to settings, class of device, name etc.
1349 */
1350 if (hci_pi(sk)->channel == HCI_CHANNEL_CONTROL) {
1351 if (!hci_sock_gen_cookie(sk)) {
1352 /* In the case when a cookie has already been
1353 * assigned, this socket will transtion from
1354 * a raw socket into a control socket. To
1355 * allow for a clean transtion, send the
1356 * close notification first.
1357 */
1358 skb = create_monitor_ctrl_close(sk);
1359 if (skb) {
1360 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1361 HCI_SOCK_TRUSTED, NULL);
1362 kfree_skb(skb);
1363 }
1364 }
1365
1366 /* Send event to monitor */
1367 skb = create_monitor_ctrl_open(sk);
1368 if (skb) {
1369 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1370 HCI_SOCK_TRUSTED, NULL);
1371 kfree_skb(skb);
1372 }
1373
1374 hci_sock_set_flag(sk, HCI_MGMT_INDEX_EVENTS);
1375 hci_sock_set_flag(sk, HCI_MGMT_UNCONF_INDEX_EVENTS);
1376 hci_sock_set_flag(sk, HCI_MGMT_OPTION_EVENTS);
1377 hci_sock_set_flag(sk, HCI_MGMT_SETTING_EVENTS);
1378 hci_sock_set_flag(sk, HCI_MGMT_DEV_CLASS_EVENTS);
1379 hci_sock_set_flag(sk, HCI_MGMT_LOCAL_NAME_EVENTS);
1380 }
1381 break;
1382 }
1383
1384 sk->sk_state = BT_BOUND;
1385
1386 done:
1387 release_sock(sk);
1388 return err;
1389 }
1390
hci_sock_getname(struct socket * sock,struct sockaddr * addr,int peer)1391 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr,
1392 int peer)
1393 {
1394 struct sockaddr_hci *haddr = (struct sockaddr_hci *)addr;
1395 struct sock *sk = sock->sk;
1396 struct hci_dev *hdev;
1397 int err = 0;
1398
1399 BT_DBG("sock %p sk %p", sock, sk);
1400
1401 if (peer)
1402 return -EOPNOTSUPP;
1403
1404 lock_sock(sk);
1405
1406 hdev = hci_hdev_from_sock(sk);
1407 if (IS_ERR(hdev)) {
1408 err = PTR_ERR(hdev);
1409 goto done;
1410 }
1411
1412 haddr->hci_family = AF_BLUETOOTH;
1413 haddr->hci_dev = hdev->id;
1414 haddr->hci_channel= hci_pi(sk)->channel;
1415 err = sizeof(*haddr);
1416
1417 done:
1418 release_sock(sk);
1419 return err;
1420 }
1421
hci_sock_cmsg(struct sock * sk,struct msghdr * msg,struct sk_buff * skb)1422 static void hci_sock_cmsg(struct sock *sk, struct msghdr *msg,
1423 struct sk_buff *skb)
1424 {
1425 __u8 mask = hci_pi(sk)->cmsg_mask;
1426
1427 if (mask & HCI_CMSG_DIR) {
1428 int incoming = bt_cb(skb)->incoming;
1429 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming),
1430 &incoming);
1431 }
1432
1433 if (mask & HCI_CMSG_TSTAMP) {
1434 #ifdef CONFIG_COMPAT
1435 struct old_timeval32 ctv;
1436 #endif
1437 struct __kernel_old_timeval tv;
1438 void *data;
1439 int len;
1440
1441 skb_get_timestamp(skb, &tv);
1442
1443 data = &tv;
1444 len = sizeof(tv);
1445 #ifdef CONFIG_COMPAT
1446 if (!COMPAT_USE_64BIT_TIME &&
1447 (msg->msg_flags & MSG_CMSG_COMPAT)) {
1448 ctv.tv_sec = tv.tv_sec;
1449 ctv.tv_usec = tv.tv_usec;
1450 data = &ctv;
1451 len = sizeof(ctv);
1452 }
1453 #endif
1454
1455 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
1456 }
1457 }
1458
hci_sock_recvmsg(struct socket * sock,struct msghdr * msg,size_t len,int flags)1459 static int hci_sock_recvmsg(struct socket *sock, struct msghdr *msg,
1460 size_t len, int flags)
1461 {
1462 int noblock = flags & MSG_DONTWAIT;
1463 struct sock *sk = sock->sk;
1464 struct sk_buff *skb;
1465 int copied, err;
1466 unsigned int skblen;
1467
1468 BT_DBG("sock %p, sk %p", sock, sk);
1469
1470 if (flags & MSG_OOB)
1471 return -EOPNOTSUPP;
1472
1473 if (hci_pi(sk)->channel == HCI_CHANNEL_LOGGING)
1474 return -EOPNOTSUPP;
1475
1476 if (sk->sk_state == BT_CLOSED)
1477 return 0;
1478
1479 skb = skb_recv_datagram(sk, flags, noblock, &err);
1480 if (!skb)
1481 return err;
1482
1483 skblen = skb->len;
1484 copied = skb->len;
1485 if (len < copied) {
1486 msg->msg_flags |= MSG_TRUNC;
1487 copied = len;
1488 }
1489
1490 skb_reset_transport_header(skb);
1491 err = skb_copy_datagram_msg(skb, 0, msg, copied);
1492
1493 switch (hci_pi(sk)->channel) {
1494 case HCI_CHANNEL_RAW:
1495 hci_sock_cmsg(sk, msg, skb);
1496 break;
1497 case HCI_CHANNEL_USER:
1498 case HCI_CHANNEL_MONITOR:
1499 sock_recv_timestamp(msg, sk, skb);
1500 break;
1501 default:
1502 if (hci_mgmt_chan_find(hci_pi(sk)->channel))
1503 sock_recv_timestamp(msg, sk, skb);
1504 break;
1505 }
1506
1507 skb_free_datagram(sk, skb);
1508
1509 if (flags & MSG_TRUNC)
1510 copied = skblen;
1511
1512 return err ? : copied;
1513 }
1514
hci_mgmt_cmd(struct hci_mgmt_chan * chan,struct sock * sk,struct msghdr * msg,size_t msglen)1515 static int hci_mgmt_cmd(struct hci_mgmt_chan *chan, struct sock *sk,
1516 struct msghdr *msg, size_t msglen)
1517 {
1518 void *buf;
1519 u8 *cp;
1520 struct mgmt_hdr *hdr;
1521 u16 opcode, index, len;
1522 struct hci_dev *hdev = NULL;
1523 const struct hci_mgmt_handler *handler;
1524 bool var_len, no_hdev;
1525 int err;
1526
1527 BT_DBG("got %zu bytes", msglen);
1528
1529 if (msglen < sizeof(*hdr))
1530 return -EINVAL;
1531
1532 buf = kmalloc(msglen, GFP_KERNEL);
1533 if (!buf)
1534 return -ENOMEM;
1535
1536 if (memcpy_from_msg(buf, msg, msglen)) {
1537 err = -EFAULT;
1538 goto done;
1539 }
1540
1541 hdr = buf;
1542 opcode = __le16_to_cpu(hdr->opcode);
1543 index = __le16_to_cpu(hdr->index);
1544 len = __le16_to_cpu(hdr->len);
1545
1546 if (len != msglen - sizeof(*hdr)) {
1547 err = -EINVAL;
1548 goto done;
1549 }
1550
1551 if (chan->channel == HCI_CHANNEL_CONTROL) {
1552 struct sk_buff *skb;
1553
1554 /* Send event to monitor */
1555 skb = create_monitor_ctrl_command(sk, index, opcode, len,
1556 buf + sizeof(*hdr));
1557 if (skb) {
1558 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
1559 HCI_SOCK_TRUSTED, NULL);
1560 kfree_skb(skb);
1561 }
1562 }
1563
1564 if (opcode >= chan->handler_count ||
1565 chan->handlers[opcode].func == NULL) {
1566 BT_DBG("Unknown op %u", opcode);
1567 err = mgmt_cmd_status(sk, index, opcode,
1568 MGMT_STATUS_UNKNOWN_COMMAND);
1569 goto done;
1570 }
1571
1572 handler = &chan->handlers[opcode];
1573
1574 if (!hci_sock_test_flag(sk, HCI_SOCK_TRUSTED) &&
1575 !(handler->flags & HCI_MGMT_UNTRUSTED)) {
1576 err = mgmt_cmd_status(sk, index, opcode,
1577 MGMT_STATUS_PERMISSION_DENIED);
1578 goto done;
1579 }
1580
1581 if (index != MGMT_INDEX_NONE) {
1582 hdev = hci_dev_get(index);
1583 if (!hdev) {
1584 err = mgmt_cmd_status(sk, index, opcode,
1585 MGMT_STATUS_INVALID_INDEX);
1586 goto done;
1587 }
1588
1589 if (hci_dev_test_flag(hdev, HCI_SETUP) ||
1590 hci_dev_test_flag(hdev, HCI_CONFIG) ||
1591 hci_dev_test_flag(hdev, HCI_USER_CHANNEL)) {
1592 err = mgmt_cmd_status(sk, index, opcode,
1593 MGMT_STATUS_INVALID_INDEX);
1594 goto done;
1595 }
1596
1597 if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED) &&
1598 !(handler->flags & HCI_MGMT_UNCONFIGURED)) {
1599 err = mgmt_cmd_status(sk, index, opcode,
1600 MGMT_STATUS_INVALID_INDEX);
1601 goto done;
1602 }
1603 }
1604
1605 if (!(handler->flags & HCI_MGMT_HDEV_OPTIONAL)) {
1606 no_hdev = (handler->flags & HCI_MGMT_NO_HDEV);
1607 if (no_hdev != !hdev) {
1608 err = mgmt_cmd_status(sk, index, opcode,
1609 MGMT_STATUS_INVALID_INDEX);
1610 goto done;
1611 }
1612 }
1613
1614 var_len = (handler->flags & HCI_MGMT_VAR_LEN);
1615 if ((var_len && len < handler->data_len) ||
1616 (!var_len && len != handler->data_len)) {
1617 err = mgmt_cmd_status(sk, index, opcode,
1618 MGMT_STATUS_INVALID_PARAMS);
1619 goto done;
1620 }
1621
1622 if (hdev && chan->hdev_init)
1623 chan->hdev_init(sk, hdev);
1624
1625 cp = buf + sizeof(*hdr);
1626
1627 err = handler->func(sk, hdev, cp, len);
1628 if (err < 0)
1629 goto done;
1630
1631 err = msglen;
1632
1633 done:
1634 if (hdev)
1635 hci_dev_put(hdev);
1636
1637 kfree(buf);
1638 return err;
1639 }
1640
hci_logging_frame(struct sock * sk,struct msghdr * msg,int len)1641 static int hci_logging_frame(struct sock *sk, struct msghdr *msg, int len)
1642 {
1643 struct hci_mon_hdr *hdr;
1644 struct sk_buff *skb;
1645 struct hci_dev *hdev;
1646 u16 index;
1647 int err;
1648
1649 /* The logging frame consists at minimum of the standard header,
1650 * the priority byte, the ident length byte and at least one string
1651 * terminator NUL byte. Anything shorter are invalid packets.
1652 */
1653 if (len < sizeof(*hdr) + 3)
1654 return -EINVAL;
1655
1656 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
1657 if (!skb)
1658 return err;
1659
1660 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1661 err = -EFAULT;
1662 goto drop;
1663 }
1664
1665 hdr = (void *)skb->data;
1666
1667 if (__le16_to_cpu(hdr->len) != len - sizeof(*hdr)) {
1668 err = -EINVAL;
1669 goto drop;
1670 }
1671
1672 if (__le16_to_cpu(hdr->opcode) == 0x0000) {
1673 __u8 priority = skb->data[sizeof(*hdr)];
1674 __u8 ident_len = skb->data[sizeof(*hdr) + 1];
1675
1676 /* Only the priorities 0-7 are valid and with that any other
1677 * value results in an invalid packet.
1678 *
1679 * The priority byte is followed by an ident length byte and
1680 * the NUL terminated ident string. Check that the ident
1681 * length is not overflowing the packet and also that the
1682 * ident string itself is NUL terminated. In case the ident
1683 * length is zero, the length value actually doubles as NUL
1684 * terminator identifier.
1685 *
1686 * The message follows the ident string (if present) and
1687 * must be NUL terminated. Otherwise it is not a valid packet.
1688 */
1689 if (priority > 7 || skb->data[len - 1] != 0x00 ||
1690 ident_len > len - sizeof(*hdr) - 3 ||
1691 skb->data[sizeof(*hdr) + ident_len + 1] != 0x00) {
1692 err = -EINVAL;
1693 goto drop;
1694 }
1695 } else {
1696 err = -EINVAL;
1697 goto drop;
1698 }
1699
1700 index = __le16_to_cpu(hdr->index);
1701
1702 if (index != MGMT_INDEX_NONE) {
1703 hdev = hci_dev_get(index);
1704 if (!hdev) {
1705 err = -ENODEV;
1706 goto drop;
1707 }
1708 } else {
1709 hdev = NULL;
1710 }
1711
1712 hdr->opcode = cpu_to_le16(HCI_MON_USER_LOGGING);
1713
1714 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb, HCI_SOCK_TRUSTED, NULL);
1715 err = len;
1716
1717 if (hdev)
1718 hci_dev_put(hdev);
1719
1720 drop:
1721 kfree_skb(skb);
1722 return err;
1723 }
1724
hci_sock_sendmsg(struct socket * sock,struct msghdr * msg,size_t len)1725 static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg,
1726 size_t len)
1727 {
1728 struct sock *sk = sock->sk;
1729 struct hci_mgmt_chan *chan;
1730 struct hci_dev *hdev;
1731 struct sk_buff *skb;
1732 int err;
1733
1734 BT_DBG("sock %p sk %p", sock, sk);
1735
1736 if (msg->msg_flags & MSG_OOB)
1737 return -EOPNOTSUPP;
1738
1739 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE|
1740 MSG_CMSG_COMPAT))
1741 return -EINVAL;
1742
1743 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
1744 return -EINVAL;
1745
1746 lock_sock(sk);
1747
1748 switch (hci_pi(sk)->channel) {
1749 case HCI_CHANNEL_RAW:
1750 case HCI_CHANNEL_USER:
1751 break;
1752 case HCI_CHANNEL_MONITOR:
1753 err = -EOPNOTSUPP;
1754 goto done;
1755 case HCI_CHANNEL_LOGGING:
1756 err = hci_logging_frame(sk, msg, len);
1757 goto done;
1758 default:
1759 mutex_lock(&mgmt_chan_list_lock);
1760 chan = __hci_mgmt_chan_find(hci_pi(sk)->channel);
1761 if (chan)
1762 err = hci_mgmt_cmd(chan, sk, msg, len);
1763 else
1764 err = -EINVAL;
1765
1766 mutex_unlock(&mgmt_chan_list_lock);
1767 goto done;
1768 }
1769
1770 hdev = hci_hdev_from_sock(sk);
1771 if (IS_ERR(hdev)) {
1772 err = PTR_ERR(hdev);
1773 goto done;
1774 }
1775
1776 if (!test_bit(HCI_UP, &hdev->flags)) {
1777 err = -ENETDOWN;
1778 goto done;
1779 }
1780
1781 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
1782 if (!skb)
1783 goto done;
1784
1785 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1786 err = -EFAULT;
1787 goto drop;
1788 }
1789
1790 hci_skb_pkt_type(skb) = skb->data[0];
1791 skb_pull(skb, 1);
1792
1793 if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
1794 /* No permission check is needed for user channel
1795 * since that gets enforced when binding the socket.
1796 *
1797 * However check that the packet type is valid.
1798 */
1799 if (hci_skb_pkt_type(skb) != HCI_COMMAND_PKT &&
1800 hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT &&
1801 hci_skb_pkt_type(skb) != HCI_SCODATA_PKT &&
1802 hci_skb_pkt_type(skb) != HCI_ISODATA_PKT) {
1803 err = -EINVAL;
1804 goto drop;
1805 }
1806
1807 skb_queue_tail(&hdev->raw_q, skb);
1808 queue_work(hdev->workqueue, &hdev->tx_work);
1809 } else if (hci_skb_pkt_type(skb) == HCI_COMMAND_PKT) {
1810 u16 opcode = get_unaligned_le16(skb->data);
1811 u16 ogf = hci_opcode_ogf(opcode);
1812 u16 ocf = hci_opcode_ocf(opcode);
1813
1814 if (((ogf > HCI_SFLT_MAX_OGF) ||
1815 !hci_test_bit(ocf & HCI_FLT_OCF_BITS,
1816 &hci_sec_filter.ocf_mask[ogf])) &&
1817 !capable(CAP_NET_RAW)) {
1818 err = -EPERM;
1819 goto drop;
1820 }
1821
1822 /* Since the opcode has already been extracted here, store
1823 * a copy of the value for later use by the drivers.
1824 */
1825 hci_skb_opcode(skb) = opcode;
1826
1827 if (ogf == 0x3f) {
1828 skb_queue_tail(&hdev->raw_q, skb);
1829 queue_work(hdev->workqueue, &hdev->tx_work);
1830 } else {
1831 /* Stand-alone HCI commands must be flagged as
1832 * single-command requests.
1833 */
1834 bt_cb(skb)->hci.req_flags |= HCI_REQ_START;
1835
1836 skb_queue_tail(&hdev->cmd_q, skb);
1837 queue_work(hdev->workqueue, &hdev->cmd_work);
1838 }
1839 } else {
1840 if (!capable(CAP_NET_RAW)) {
1841 err = -EPERM;
1842 goto drop;
1843 }
1844
1845 if (hci_skb_pkt_type(skb) != HCI_ACLDATA_PKT &&
1846 hci_skb_pkt_type(skb) != HCI_SCODATA_PKT &&
1847 hci_skb_pkt_type(skb) != HCI_ISODATA_PKT) {
1848 err = -EINVAL;
1849 goto drop;
1850 }
1851
1852 skb_queue_tail(&hdev->raw_q, skb);
1853 queue_work(hdev->workqueue, &hdev->tx_work);
1854 }
1855
1856 err = len;
1857
1858 done:
1859 release_sock(sk);
1860 return err;
1861
1862 drop:
1863 kfree_skb(skb);
1864 goto done;
1865 }
1866
hci_sock_setsockopt(struct socket * sock,int level,int optname,sockptr_t optval,unsigned int len)1867 static int hci_sock_setsockopt(struct socket *sock, int level, int optname,
1868 sockptr_t optval, unsigned int len)
1869 {
1870 struct hci_ufilter uf = { .opcode = 0 };
1871 struct sock *sk = sock->sk;
1872 int err = 0, opt = 0;
1873
1874 BT_DBG("sk %p, opt %d", sk, optname);
1875
1876 if (level != SOL_HCI)
1877 return -ENOPROTOOPT;
1878
1879 lock_sock(sk);
1880
1881 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
1882 err = -EBADFD;
1883 goto done;
1884 }
1885
1886 switch (optname) {
1887 case HCI_DATA_DIR:
1888 if (copy_from_sockptr(&opt, optval, sizeof(opt))) {
1889 err = -EFAULT;
1890 break;
1891 }
1892
1893 if (opt)
1894 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
1895 else
1896 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
1897 break;
1898
1899 case HCI_TIME_STAMP:
1900 if (copy_from_sockptr(&opt, optval, sizeof(opt))) {
1901 err = -EFAULT;
1902 break;
1903 }
1904
1905 if (opt)
1906 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
1907 else
1908 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
1909 break;
1910
1911 case HCI_FILTER:
1912 {
1913 struct hci_filter *f = &hci_pi(sk)->filter;
1914
1915 uf.type_mask = f->type_mask;
1916 uf.opcode = f->opcode;
1917 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
1918 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
1919 }
1920
1921 len = min_t(unsigned int, len, sizeof(uf));
1922 if (copy_from_sockptr(&uf, optval, len)) {
1923 err = -EFAULT;
1924 break;
1925 }
1926
1927 if (!capable(CAP_NET_RAW)) {
1928 uf.type_mask &= hci_sec_filter.type_mask;
1929 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
1930 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
1931 }
1932
1933 {
1934 struct hci_filter *f = &hci_pi(sk)->filter;
1935
1936 f->type_mask = uf.type_mask;
1937 f->opcode = uf.opcode;
1938 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
1939 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
1940 }
1941 break;
1942
1943 default:
1944 err = -ENOPROTOOPT;
1945 break;
1946 }
1947
1948 done:
1949 release_sock(sk);
1950 return err;
1951 }
1952
hci_sock_getsockopt(struct socket * sock,int level,int optname,char __user * optval,int __user * optlen)1953 static int hci_sock_getsockopt(struct socket *sock, int level, int optname,
1954 char __user *optval, int __user *optlen)
1955 {
1956 struct hci_ufilter uf;
1957 struct sock *sk = sock->sk;
1958 int len, opt, err = 0;
1959
1960 BT_DBG("sk %p, opt %d", sk, optname);
1961
1962 if (level != SOL_HCI)
1963 return -ENOPROTOOPT;
1964
1965 if (get_user(len, optlen))
1966 return -EFAULT;
1967
1968 lock_sock(sk);
1969
1970 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
1971 err = -EBADFD;
1972 goto done;
1973 }
1974
1975 switch (optname) {
1976 case HCI_DATA_DIR:
1977 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
1978 opt = 1;
1979 else
1980 opt = 0;
1981
1982 if (put_user(opt, optval))
1983 err = -EFAULT;
1984 break;
1985
1986 case HCI_TIME_STAMP:
1987 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
1988 opt = 1;
1989 else
1990 opt = 0;
1991
1992 if (put_user(opt, optval))
1993 err = -EFAULT;
1994 break;
1995
1996 case HCI_FILTER:
1997 {
1998 struct hci_filter *f = &hci_pi(sk)->filter;
1999
2000 memset(&uf, 0, sizeof(uf));
2001 uf.type_mask = f->type_mask;
2002 uf.opcode = f->opcode;
2003 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
2004 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
2005 }
2006
2007 len = min_t(unsigned int, len, sizeof(uf));
2008 if (copy_to_user(optval, &uf, len))
2009 err = -EFAULT;
2010 break;
2011
2012 default:
2013 err = -ENOPROTOOPT;
2014 break;
2015 }
2016
2017 done:
2018 release_sock(sk);
2019 return err;
2020 }
2021
2022 static const struct proto_ops hci_sock_ops = {
2023 .family = PF_BLUETOOTH,
2024 .owner = THIS_MODULE,
2025 .release = hci_sock_release,
2026 .bind = hci_sock_bind,
2027 .getname = hci_sock_getname,
2028 .sendmsg = hci_sock_sendmsg,
2029 .recvmsg = hci_sock_recvmsg,
2030 .ioctl = hci_sock_ioctl,
2031 #ifdef CONFIG_COMPAT
2032 .compat_ioctl = hci_sock_compat_ioctl,
2033 #endif
2034 .poll = datagram_poll,
2035 .listen = sock_no_listen,
2036 .shutdown = sock_no_shutdown,
2037 .setsockopt = hci_sock_setsockopt,
2038 .getsockopt = hci_sock_getsockopt,
2039 .connect = sock_no_connect,
2040 .socketpair = sock_no_socketpair,
2041 .accept = sock_no_accept,
2042 .mmap = sock_no_mmap
2043 };
2044
2045 static struct proto hci_sk_proto = {
2046 .name = "HCI",
2047 .owner = THIS_MODULE,
2048 .obj_size = sizeof(struct hci_pinfo)
2049 };
2050
hci_sock_create(struct net * net,struct socket * sock,int protocol,int kern)2051 static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
2052 int kern)
2053 {
2054 struct sock *sk;
2055
2056 BT_DBG("sock %p", sock);
2057
2058 if (sock->type != SOCK_RAW)
2059 return -ESOCKTNOSUPPORT;
2060
2061 sock->ops = &hci_sock_ops;
2062
2063 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto, kern);
2064 if (!sk)
2065 return -ENOMEM;
2066
2067 sock_init_data(sock, sk);
2068
2069 sock_reset_flag(sk, SOCK_ZAPPED);
2070
2071 sk->sk_protocol = protocol;
2072
2073 sock->state = SS_UNCONNECTED;
2074 sk->sk_state = BT_OPEN;
2075
2076 bt_sock_link(&hci_sk_list, sk);
2077 return 0;
2078 }
2079
2080 static const struct net_proto_family hci_sock_family_ops = {
2081 .family = PF_BLUETOOTH,
2082 .owner = THIS_MODULE,
2083 .create = hci_sock_create,
2084 };
2085
hci_sock_init(void)2086 int __init hci_sock_init(void)
2087 {
2088 int err;
2089
2090 BUILD_BUG_ON(sizeof(struct sockaddr_hci) > sizeof(struct sockaddr));
2091
2092 err = proto_register(&hci_sk_proto, 0);
2093 if (err < 0)
2094 return err;
2095
2096 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
2097 if (err < 0) {
2098 BT_ERR("HCI socket registration failed");
2099 goto error;
2100 }
2101
2102 err = bt_procfs_init(&init_net, "hci", &hci_sk_list, NULL);
2103 if (err < 0) {
2104 BT_ERR("Failed to create HCI proc file");
2105 bt_sock_unregister(BTPROTO_HCI);
2106 goto error;
2107 }
2108
2109 BT_INFO("HCI socket layer initialized");
2110
2111 return 0;
2112
2113 error:
2114 proto_unregister(&hci_sk_proto);
2115 return err;
2116 }
2117
hci_sock_cleanup(void)2118 void hci_sock_cleanup(void)
2119 {
2120 bt_procfs_cleanup(&init_net, "hci");
2121 bt_sock_unregister(BTPROTO_HCI);
2122 proto_unregister(&hci_sk_proto);
2123 }
2124