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