?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://github.com/dtor/input
[linux-btrfs-devel.git] / net / bluetooth / hci_sock.c
blobff02cf5e77ccdd576d2f42f78f2c4715e3a47d5e
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
27 #include <linux/module.h>
28
29 #include <linux/types.h>
30 #include <linux/capability.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/slab.h>
34 #include <linux/poll.h>
35 #include <linux/fcntl.h>
36 #include <linux/init.h>
37 #include <linux/skbuff.h>
38 #include <linux/workqueue.h>
39 #include <linux/interrupt.h>
40 #include <linux/compat.h>
41 #include <linux/socket.h>
42 #include <linux/ioctl.h>
43 #include <net/sock.h>
44
45 #include <asm/system.h>
46 #include <linux/uaccess.h>
47 #include <asm/unaligned.h>
48
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
51
52 static int enable_mgmt;
53
54 /* ----- HCI socket interface ----- */
55
56 static inline int hci_test_bit(int nr, void *addr)
57 {
58 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
59 }
60
61 /* Security filter */
62 static struct hci_sec_filter hci_sec_filter = {
63 /* Packet types */
64 0x10,
65 /* Events */
66 { 0x1000d9fe, 0x0000b00c },
67 /* Commands */
68 {
69 { 0x0 },
70 /* OGF_LINK_CTL */
71 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
72 /* OGF_LINK_POLICY */
73 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
74 /* OGF_HOST_CTL */
75 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
76 /* OGF_INFO_PARAM */
77 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
78 /* OGF_STATUS_PARAM */
79 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
80 }
81 };
82
83 static struct bt_sock_list hci_sk_list = {
84 .lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
85 };
86
87 /* Send frame to RAW socket */
88 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb,
89 struct sock *skip_sk)
90 {
91 struct sock *sk;
92 struct hlist_node *node;
93
94 BT_DBG("hdev %p len %d", hdev, skb->len);
95
96 read_lock(&hci_sk_list.lock);
97 sk_for_each(sk, node, &hci_sk_list.head) {
98 struct hci_filter *flt;
99 struct sk_buff *nskb;
100
101 if (sk == skip_sk)
102 continue;
103
104 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
105 continue;
106
107 /* Don't send frame to the socket it came from */
108 if (skb->sk == sk)
109 continue;
110
111 if (bt_cb(skb)->channel != hci_pi(sk)->channel)
112 continue;
113
114 if (bt_cb(skb)->channel == HCI_CHANNEL_CONTROL)
115 goto clone;
116
117 /* Apply filter */
118 flt = &hci_pi(sk)->filter;
119
120 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
121 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
122 continue;
123
124 if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
125 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
126
127 if (!hci_test_bit(evt, &flt->event_mask))
128 continue;
129
130 if (flt->opcode &&
131 ((evt == HCI_EV_CMD_COMPLETE &&
132 flt->opcode !=
133 get_unaligned((__le16 *)(skb->data + 3))) ||
134 (evt == HCI_EV_CMD_STATUS &&
135 flt->opcode !=
136 get_unaligned((__le16 *)(skb->data + 4)))))
137 continue;
138 }
139
140 clone:
141 nskb = skb_clone(skb, GFP_ATOMIC);
142 if (!nskb)
143 continue;
144
145 /* Put type byte before the data */
146 if (bt_cb(skb)->channel == HCI_CHANNEL_RAW)
147 memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
148
149 if (sock_queue_rcv_skb(sk, nskb))
150 kfree_skb(nskb);
151 }
152 read_unlock(&hci_sk_list.lock);
153 }
154
155 static int hci_sock_release(struct socket *sock)
156 {
157 struct sock *sk = sock->sk;
158 struct hci_dev *hdev;
159
160 BT_DBG("sock %p sk %p", sock, sk);
161
162 if (!sk)
163 return 0;
164
165 hdev = hci_pi(sk)->hdev;
166
167 bt_sock_unlink(&hci_sk_list, sk);
168
169 if (hdev) {
170 atomic_dec(&hdev->promisc);
171 hci_dev_put(hdev);
172 }
173
174 sock_orphan(sk);
175
176 skb_queue_purge(&sk->sk_receive_queue);
177 skb_queue_purge(&sk->sk_write_queue);
178
179 sock_put(sk);
180 return 0;
181 }
182
183 static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
184 {
185 bdaddr_t bdaddr;
186
187 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
188 return -EFAULT;
189
190 return hci_blacklist_add(hdev, &bdaddr);
191 }
192
193 static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg)
194 {
195 bdaddr_t bdaddr;
196
197 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
198 return -EFAULT;
199
200 return hci_blacklist_del(hdev, &bdaddr);
201 }
202
203 /* Ioctls that require bound socket */
204 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
205 {
206 struct hci_dev *hdev = hci_pi(sk)->hdev;
207
208 if (!hdev)
209 return -EBADFD;
210
211 switch (cmd) {
212 case HCISETRAW:
213 if (!capable(CAP_NET_ADMIN))
214 return -EACCES;
215
216 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
217 return -EPERM;
218
219 if (arg)
220 set_bit(HCI_RAW, &hdev->flags);
221 else
222 clear_bit(HCI_RAW, &hdev->flags);
223
224 return 0;
225
226 case HCIGETCONNINFO:
227 return hci_get_conn_info(hdev, (void __user *) arg);
228
229 case HCIGETAUTHINFO:
230 return hci_get_auth_info(hdev, (void __user *) arg);
231
232 case HCIBLOCKADDR:
233 if (!capable(CAP_NET_ADMIN))
234 return -EACCES;
235 return hci_sock_blacklist_add(hdev, (void __user *) arg);
236
237 case HCIUNBLOCKADDR:
238 if (!capable(CAP_NET_ADMIN))
239 return -EACCES;
240 return hci_sock_blacklist_del(hdev, (void __user *) arg);
241
242 default:
243 if (hdev->ioctl)
244 return hdev->ioctl(hdev, cmd, arg);
245 return -EINVAL;
246 }
247 }
248
249 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
250 {
251 struct sock *sk = sock->sk;
252 void __user *argp = (void __user *) arg;
253 int err;
254
255 BT_DBG("cmd %x arg %lx", cmd, arg);
256
257 switch (cmd) {
258 case HCIGETDEVLIST:
259 return hci_get_dev_list(argp);
260
261 case HCIGETDEVINFO:
262 return hci_get_dev_info(argp);
263
264 case HCIGETCONNLIST:
265 return hci_get_conn_list(argp);
266
267 case HCIDEVUP:
268 if (!capable(CAP_NET_ADMIN))
269 return -EACCES;
270 return hci_dev_open(arg);
271
272 case HCIDEVDOWN:
273 if (!capable(CAP_NET_ADMIN))
274 return -EACCES;
275 return hci_dev_close(arg);
276
277 case HCIDEVRESET:
278 if (!capable(CAP_NET_ADMIN))
279 return -EACCES;
280 return hci_dev_reset(arg);
281
282 case HCIDEVRESTAT:
283 if (!capable(CAP_NET_ADMIN))
284 return -EACCES;
285 return hci_dev_reset_stat(arg);
286
287 case HCISETSCAN:
288 case HCISETAUTH:
289 case HCISETENCRYPT:
290 case HCISETPTYPE:
291 case HCISETLINKPOL:
292 case HCISETLINKMODE:
293 case HCISETACLMTU:
294 case HCISETSCOMTU:
295 if (!capable(CAP_NET_ADMIN))
296 return -EACCES;
297 return hci_dev_cmd(cmd, argp);
298
299 case HCIINQUIRY:
300 return hci_inquiry(argp);
301
302 default:
303 lock_sock(sk);
304 err = hci_sock_bound_ioctl(sk, cmd, arg);
305 release_sock(sk);
306 return err;
307 }
308 }
309
310 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
311 {
312 struct sockaddr_hci haddr;
313 struct sock *sk = sock->sk;
314 struct hci_dev *hdev = NULL;
315 int len, err = 0;
316
317 BT_DBG("sock %p sk %p", sock, sk);
318
319 if (!addr)
320 return -EINVAL;
321
322 memset(&haddr, 0, sizeof(haddr));
323 len = min_t(unsigned int, sizeof(haddr), addr_len);
324 memcpy(&haddr, addr, len);
325
326 if (haddr.hci_family != AF_BLUETOOTH)
327 return -EINVAL;
328
329 if (haddr.hci_channel > HCI_CHANNEL_CONTROL)
330 return -EINVAL;
331
332 if (haddr.hci_channel == HCI_CHANNEL_CONTROL && !enable_mgmt)
333 return -EINVAL;
334
335 lock_sock(sk);
336
337 if (sk->sk_state == BT_BOUND || hci_pi(sk)->hdev) {
338 err = -EALREADY;
339 goto done;
340 }
341
342 if (haddr.hci_dev != HCI_DEV_NONE) {
343 hdev = hci_dev_get(haddr.hci_dev);
344 if (!hdev) {
345 err = -ENODEV;
346 goto done;
347 }
348
349 atomic_inc(&hdev->promisc);
350 }
351
352 hci_pi(sk)->channel = haddr.hci_channel;
353 hci_pi(sk)->hdev = hdev;
354 sk->sk_state = BT_BOUND;
355
356 done:
357 release_sock(sk);
358 return err;
359 }
360
361 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
362 {
363 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
364 struct sock *sk = sock->sk;
365 struct hci_dev *hdev = hci_pi(sk)->hdev;
366
367 BT_DBG("sock %p sk %p", sock, sk);
368
369 if (!hdev)
370 return -EBADFD;
371
372 lock_sock(sk);
373
374 *addr_len = sizeof(*haddr);
375 haddr->hci_family = AF_BLUETOOTH;
376 haddr->hci_dev = hdev->id;
377
378 release_sock(sk);
379 return 0;
380 }
381
382 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
383 {
384 __u32 mask = hci_pi(sk)->cmsg_mask;
385
386 if (mask & HCI_CMSG_DIR) {
387 int incoming = bt_cb(skb)->incoming;
388 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
389 }
390
391 if (mask & HCI_CMSG_TSTAMP) {
392 #ifdef CONFIG_COMPAT
393 struct compat_timeval ctv;
394 #endif
395 struct timeval tv;
396 void *data;
397 int len;
398
399 skb_get_timestamp(skb, &tv);
400
401 data = &tv;
402 len = sizeof(tv);
403 #ifdef CONFIG_COMPAT
404 if (msg->msg_flags & MSG_CMSG_COMPAT) {
405 ctv.tv_sec = tv.tv_sec;
406 ctv.tv_usec = tv.tv_usec;
407 data = &ctv;
408 len = sizeof(ctv);
409 }
410 #endif
411
412 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
413 }
414 }
415
416 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
417 struct msghdr *msg, size_t len, int flags)
418 {
419 int noblock = flags & MSG_DONTWAIT;
420 struct sock *sk = sock->sk;
421 struct sk_buff *skb;
422 int copied, err;
423
424 BT_DBG("sock %p, sk %p", sock, sk);
425
426 if (flags & (MSG_OOB))
427 return -EOPNOTSUPP;
428
429 if (sk->sk_state == BT_CLOSED)
430 return 0;
431
432 skb = skb_recv_datagram(sk, flags, noblock, &err);
433 if (!skb)
434 return err;
435
436 msg->msg_namelen = 0;
437
438 copied = skb->len;
439 if (len < copied) {
440 msg->msg_flags |= MSG_TRUNC;
441 copied = len;
442 }
443
444 skb_reset_transport_header(skb);
445 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
446
447 hci_sock_cmsg(sk, msg, skb);
448
449 skb_free_datagram(sk, skb);
450
451 return err ? : copied;
452 }
453
454 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
455 struct msghdr *msg, size_t len)
456 {
457 struct sock *sk = sock->sk;
458 struct hci_dev *hdev;
459 struct sk_buff *skb;
460 int err;
461
462 BT_DBG("sock %p sk %p", sock, sk);
463
464 if (msg->msg_flags & MSG_OOB)
465 return -EOPNOTSUPP;
466
467 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
468 return -EINVAL;
469
470 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
471 return -EINVAL;
472
473 lock_sock(sk);
474
475 switch (hci_pi(sk)->channel) {
476 case HCI_CHANNEL_RAW:
477 break;
478 case HCI_CHANNEL_CONTROL:
479 err = mgmt_control(sk, msg, len);
480 goto done;
481 default:
482 err = -EINVAL;
483 goto done;
484 }
485
486 hdev = hci_pi(sk)->hdev;
487 if (!hdev) {
488 err = -EBADFD;
489 goto done;
490 }
491
492 if (!test_bit(HCI_UP, &hdev->flags)) {
493 err = -ENETDOWN;
494 goto done;
495 }
496
497 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
498 if (!skb)
499 goto done;
500
501 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
502 err = -EFAULT;
503 goto drop;
504 }
505
506 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
507 skb_pull(skb, 1);
508 skb->dev = (void *) hdev;
509
510 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
511 u16 opcode = get_unaligned_le16(skb->data);
512 u16 ogf = hci_opcode_ogf(opcode);
513 u16 ocf = hci_opcode_ocf(opcode);
514
515 if (((ogf > HCI_SFLT_MAX_OGF) ||
516 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
517 !capable(CAP_NET_RAW)) {
518 err = -EPERM;
519 goto drop;
520 }
521
522 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
523 skb_queue_tail(&hdev->raw_q, skb);
524 tasklet_schedule(&hdev->tx_task);
525 } else {
526 skb_queue_tail(&hdev->cmd_q, skb);
527 tasklet_schedule(&hdev->cmd_task);
528 }
529 } else {
530 if (!capable(CAP_NET_RAW)) {
531 err = -EPERM;
532 goto drop;
533 }
534
535 skb_queue_tail(&hdev->raw_q, skb);
536 tasklet_schedule(&hdev->tx_task);
537 }
538
539 err = len;
540
541 done:
542 release_sock(sk);
543 return err;
544
545 drop:
546 kfree_skb(skb);
547 goto done;
548 }
549
550 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len)
551 {
552 struct hci_ufilter uf = { .opcode = 0 };
553 struct sock *sk = sock->sk;
554 int err = 0, opt = 0;
555
556 BT_DBG("sk %p, opt %d", sk, optname);
557
558 lock_sock(sk);
559
560 switch (optname) {
561 case HCI_DATA_DIR:
562 if (get_user(opt, (int __user *)optval)) {
563 err = -EFAULT;
564 break;
565 }
566
567 if (opt)
568 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
569 else
570 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
571 break;
572
573 case HCI_TIME_STAMP:
574 if (get_user(opt, (int __user *)optval)) {
575 err = -EFAULT;
576 break;
577 }
578
579 if (opt)
580 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
581 else
582 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
583 break;
584
585 case HCI_FILTER:
586 {
587 struct hci_filter *f = &hci_pi(sk)->filter;
588
589 uf.type_mask = f->type_mask;
590 uf.opcode = f->opcode;
591 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
592 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
593 }
594
595 len = min_t(unsigned int, len, sizeof(uf));
596 if (copy_from_user(&uf, optval, len)) {
597 err = -EFAULT;
598 break;
599 }
600
601 if (!capable(CAP_NET_RAW)) {
602 uf.type_mask &= hci_sec_filter.type_mask;
603 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
604 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
605 }
606
607 {
608 struct hci_filter *f = &hci_pi(sk)->filter;
609
610 f->type_mask = uf.type_mask;
611 f->opcode = uf.opcode;
612 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
613 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
614 }
615 break;
616
617 default:
618 err = -ENOPROTOOPT;
619 break;
620 }
621
622 release_sock(sk);
623 return err;
624 }
625
626 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
627 {
628 struct hci_ufilter uf;
629 struct sock *sk = sock->sk;
630 int len, opt;
631
632 if (get_user(len, optlen))
633 return -EFAULT;
634
635 switch (optname) {
636 case HCI_DATA_DIR:
637 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
638 opt = 1;
639 else
640 opt = 0;
641
642 if (put_user(opt, optval))
643 return -EFAULT;
644 break;
645
646 case HCI_TIME_STAMP:
647 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
648 opt = 1;
649 else
650 opt = 0;
651
652 if (put_user(opt, optval))
653 return -EFAULT;
654 break;
655
656 case HCI_FILTER:
657 {
658 struct hci_filter *f = &hci_pi(sk)->filter;
659
660 uf.type_mask = f->type_mask;
661 uf.opcode = f->opcode;
662 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
663 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
664 }
665
666 len = min_t(unsigned int, len, sizeof(uf));
667 if (copy_to_user(optval, &uf, len))
668 return -EFAULT;
669 break;
670
671 default:
672 return -ENOPROTOOPT;
673 break;
674 }
675
676 return 0;
677 }
678
679 static const struct proto_ops hci_sock_ops = {
680 .family = PF_BLUETOOTH,
681 .owner = THIS_MODULE,
682 .release = hci_sock_release,
683 .bind = hci_sock_bind,
684 .getname = hci_sock_getname,
685 .sendmsg = hci_sock_sendmsg,
686 .recvmsg = hci_sock_recvmsg,
687 .ioctl = hci_sock_ioctl,
688 .poll = datagram_poll,
689 .listen = sock_no_listen,
690 .shutdown = sock_no_shutdown,
691 .setsockopt = hci_sock_setsockopt,
692 .getsockopt = hci_sock_getsockopt,
693 .connect = sock_no_connect,
694 .socketpair = sock_no_socketpair,
695 .accept = sock_no_accept,
696 .mmap = sock_no_mmap
697 };
698
699 static struct proto hci_sk_proto = {
700 .name = "HCI",
701 .owner = THIS_MODULE,
702 .obj_size = sizeof(struct hci_pinfo)
703 };
704
705 static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
706 int kern)
707 {
708 struct sock *sk;
709
710 BT_DBG("sock %p", sock);
711
712 if (sock->type != SOCK_RAW)
713 return -ESOCKTNOSUPPORT;
714
715 sock->ops = &hci_sock_ops;
716
717 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
718 if (!sk)
719 return -ENOMEM;
720
721 sock_init_data(sock, sk);
722
723 sock_reset_flag(sk, SOCK_ZAPPED);
724
725 sk->sk_protocol = protocol;
726
727 sock->state = SS_UNCONNECTED;
728 sk->sk_state = BT_OPEN;
729
730 bt_sock_link(&hci_sk_list, sk);
731 return 0;
732 }
733
734 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
735 {
736 struct hci_dev *hdev = (struct hci_dev *) ptr;
737 struct hci_ev_si_device ev;
738
739 BT_DBG("hdev %s event %ld", hdev->name, event);
740
741 /* Send event to sockets */
742 ev.event = event;
743 ev.dev_id = hdev->id;
744 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
745
746 if (event == HCI_DEV_UNREG) {
747 struct sock *sk;
748 struct hlist_node *node;
749
750 /* Detach sockets from device */
751 read_lock(&hci_sk_list.lock);
752 sk_for_each(sk, node, &hci_sk_list.head) {
753 local_bh_disable();
754 bh_lock_sock_nested(sk);
755 if (hci_pi(sk)->hdev == hdev) {
756 hci_pi(sk)->hdev = NULL;
757 sk->sk_err = EPIPE;
758 sk->sk_state = BT_OPEN;
759 sk->sk_state_change(sk);
760
761 hci_dev_put(hdev);
762 }
763 bh_unlock_sock(sk);
764 local_bh_enable();
765 }
766 read_unlock(&hci_sk_list.lock);
767 }
768
769 return NOTIFY_DONE;
770 }
771
772 static const struct net_proto_family hci_sock_family_ops = {
773 .family = PF_BLUETOOTH,
774 .owner = THIS_MODULE,
775 .create = hci_sock_create,
776 };
777
778 static struct notifier_block hci_sock_nblock = {
779 .notifier_call = hci_sock_dev_event
780 };
781
782 int __init hci_sock_init(void)
783 {
784 int err;
785
786 err = proto_register(&hci_sk_proto, 0);
787 if (err < 0)
788 return err;
789
790 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
791 if (err < 0)
792 goto error;
793
794 hci_register_notifier(&hci_sock_nblock);
795
796 BT_INFO("HCI socket layer initialized");
797
798 return 0;
799
800 error:
801 BT_ERR("HCI socket registration failed");
802 proto_unregister(&hci_sk_proto);
803 return err;
804 }
805
806 void hci_sock_cleanup(void)
807 {
808 if (bt_sock_unregister(BTPROTO_HCI) < 0)
809 BT_ERR("HCI socket unregistration failed");
810
811 hci_unregister_notifier(&hci_sock_nblock);
812
813 proto_unregister(&hci_sk_proto);
814 }
815
816 module_param(enable_mgmt, bool, 0644);
817 MODULE_PARM_DESC(enable_mgmt, "Enable Management interface");
Linux Btrfs Development