2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
25 /* Bluetooth HCI sockets. */
27 #include <linux/module.h>
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>
45 #include <asm/system.h>
46 #include <asm/uaccess.h>
47 #include <asm/unaligned.h>
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
52 /* ----- HCI socket interface ----- */
54 static inline int hci_test_bit(int nr, void *addr)
56 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
60 static struct hci_sec_filter hci_sec_filter = {
64 { 0x1000d9fe, 0x0000b00c },
69 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
71 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
73 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
75 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
76 /* OGF_STATUS_PARAM */
77 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
81 static struct bt_sock_list hci_sk_list = {
82 .lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
85 /* Send frame to RAW socket */
86 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
89 struct hlist_node *node;
91 BT_DBG("hdev %p len %d", hdev, skb->len);
93 read_lock(&hci_sk_list.lock);
94 sk_for_each(sk, node, &hci_sk_list.head) {
95 struct hci_filter *flt;
98 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
101 /* Don't send frame to the socket it came from */
106 flt = &hci_pi(sk)->filter;
108 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
109 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
112 if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
113 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
115 if (!hci_test_bit(evt, &flt->event_mask))
119 ((evt == HCI_EV_CMD_COMPLETE &&
121 get_unaligned((__le16 *)(skb->data + 3))) ||
122 (evt == HCI_EV_CMD_STATUS &&
124 get_unaligned((__le16 *)(skb->data + 4)))))
128 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
131 /* Put type byte before the data */
132 memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
134 if (sock_queue_rcv_skb(sk, nskb))
137 read_unlock(&hci_sk_list.lock);
140 static int hci_sock_release(struct socket *sock)
142 struct sock *sk = sock->sk;
143 struct hci_dev *hdev;
145 BT_DBG("sock %p sk %p", sock, sk);
150 hdev = hci_pi(sk)->hdev;
152 bt_sock_unlink(&hci_sk_list, sk);
155 atomic_dec(&hdev->promisc);
161 skb_queue_purge(&sk->sk_receive_queue);
162 skb_queue_purge(&sk->sk_write_queue);
168 struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr)
171 struct bdaddr_list *blacklist = &hdev->blacklist;
173 list_for_each(p, &blacklist->list) {
174 struct bdaddr_list *b;
176 b = list_entry(p, struct bdaddr_list, list);
178 if (bacmp(bdaddr, &b->bdaddr) == 0)
185 static int hci_blacklist_add(struct hci_dev *hdev, void __user *arg)
188 struct bdaddr_list *entry;
190 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
193 if (bacmp(&bdaddr, BDADDR_ANY) == 0)
196 if (hci_blacklist_lookup(hdev, &bdaddr))
199 entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL);
203 bacpy(&entry->bdaddr, &bdaddr);
205 list_add(&entry->list, &hdev->blacklist.list);
210 int hci_blacklist_clear(struct hci_dev *hdev)
212 struct list_head *p, *n;
213 struct bdaddr_list *blacklist = &hdev->blacklist;
215 list_for_each_safe(p, n, &blacklist->list) {
216 struct bdaddr_list *b;
218 b = list_entry(p, struct bdaddr_list, list);
227 static int hci_blacklist_del(struct hci_dev *hdev, void __user *arg)
230 struct bdaddr_list *entry;
232 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
235 if (bacmp(&bdaddr, BDADDR_ANY) == 0)
236 return hci_blacklist_clear(hdev);
238 entry = hci_blacklist_lookup(hdev, &bdaddr);
242 list_del(&entry->list);
248 /* Ioctls that require bound socket */
249 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
251 struct hci_dev *hdev = hci_pi(sk)->hdev;
258 if (!capable(CAP_NET_ADMIN))
261 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
265 set_bit(HCI_RAW, &hdev->flags);
267 clear_bit(HCI_RAW, &hdev->flags);
272 return hci_get_conn_info(hdev, (void __user *) arg);
275 return hci_get_auth_info(hdev, (void __user *) arg);
278 if (!capable(CAP_NET_ADMIN))
280 return hci_blacklist_add(hdev, (void __user *) arg);
283 if (!capable(CAP_NET_ADMIN))
285 return hci_blacklist_del(hdev, (void __user *) arg);
289 return hdev->ioctl(hdev, cmd, arg);
294 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
296 struct sock *sk = sock->sk;
297 void __user *argp = (void __user *) arg;
300 BT_DBG("cmd %x arg %lx", cmd, arg);
304 return hci_get_dev_list(argp);
307 return hci_get_dev_info(argp);
310 return hci_get_conn_list(argp);
313 if (!capable(CAP_NET_ADMIN))
315 return hci_dev_open(arg);
318 if (!capable(CAP_NET_ADMIN))
320 return hci_dev_close(arg);
323 if (!capable(CAP_NET_ADMIN))
325 return hci_dev_reset(arg);
328 if (!capable(CAP_NET_ADMIN))
330 return hci_dev_reset_stat(arg);
340 if (!capable(CAP_NET_ADMIN))
342 return hci_dev_cmd(cmd, argp);
345 return hci_inquiry(argp);
349 err = hci_sock_bound_ioctl(sk, cmd, arg);
355 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
357 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
358 struct sock *sk = sock->sk;
359 struct hci_dev *hdev = NULL;
362 BT_DBG("sock %p sk %p", sock, sk);
364 if (!haddr || haddr->hci_family != AF_BLUETOOTH)
369 if (hci_pi(sk)->hdev) {
374 if (haddr->hci_dev != HCI_DEV_NONE) {
375 if (!(hdev = hci_dev_get(haddr->hci_dev))) {
380 atomic_inc(&hdev->promisc);
383 hci_pi(sk)->hdev = hdev;
384 sk->sk_state = BT_BOUND;
391 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
393 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
394 struct sock *sk = sock->sk;
395 struct hci_dev *hdev = hci_pi(sk)->hdev;
397 BT_DBG("sock %p sk %p", sock, sk);
404 *addr_len = sizeof(*haddr);
405 haddr->hci_family = AF_BLUETOOTH;
406 haddr->hci_dev = hdev->id;
412 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
414 __u32 mask = hci_pi(sk)->cmsg_mask;
416 if (mask & HCI_CMSG_DIR) {
417 int incoming = bt_cb(skb)->incoming;
418 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
421 if (mask & HCI_CMSG_TSTAMP) {
423 struct compat_timeval ctv;
429 skb_get_timestamp(skb, &tv);
434 if (msg->msg_flags & MSG_CMSG_COMPAT) {
435 ctv.tv_sec = tv.tv_sec;
436 ctv.tv_usec = tv.tv_usec;
442 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
446 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
447 struct msghdr *msg, size_t len, int flags)
449 int noblock = flags & MSG_DONTWAIT;
450 struct sock *sk = sock->sk;
454 BT_DBG("sock %p, sk %p", sock, sk);
456 if (flags & (MSG_OOB))
459 if (sk->sk_state == BT_CLOSED)
462 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
465 msg->msg_namelen = 0;
469 msg->msg_flags |= MSG_TRUNC;
473 skb_reset_transport_header(skb);
474 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
476 hci_sock_cmsg(sk, msg, skb);
478 skb_free_datagram(sk, skb);
480 return err ? : copied;
483 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
484 struct msghdr *msg, size_t len)
486 struct sock *sk = sock->sk;
487 struct hci_dev *hdev;
491 BT_DBG("sock %p sk %p", sock, sk);
493 if (msg->msg_flags & MSG_OOB)
496 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
499 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
504 if (!(hdev = hci_pi(sk)->hdev)) {
509 if (!test_bit(HCI_UP, &hdev->flags)) {
514 if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
517 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
522 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
524 skb->dev = (void *) hdev;
526 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
527 u16 opcode = get_unaligned_le16(skb->data);
528 u16 ogf = hci_opcode_ogf(opcode);
529 u16 ocf = hci_opcode_ocf(opcode);
531 if (((ogf > HCI_SFLT_MAX_OGF) ||
532 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
533 !capable(CAP_NET_RAW)) {
538 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
539 skb_queue_tail(&hdev->raw_q, skb);
540 tasklet_schedule(&hdev->tx_task);
542 skb_queue_tail(&hdev->cmd_q, skb);
543 tasklet_schedule(&hdev->cmd_task);
546 if (!capable(CAP_NET_RAW)) {
551 skb_queue_tail(&hdev->raw_q, skb);
552 tasklet_schedule(&hdev->tx_task);
566 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len)
568 struct hci_ufilter uf = { .opcode = 0 };
569 struct sock *sk = sock->sk;
570 int err = 0, opt = 0;
572 BT_DBG("sk %p, opt %d", sk, optname);
578 if (get_user(opt, (int __user *)optval)) {
584 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
586 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
590 if (get_user(opt, (int __user *)optval)) {
596 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
598 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
603 struct hci_filter *f = &hci_pi(sk)->filter;
605 uf.type_mask = f->type_mask;
606 uf.opcode = f->opcode;
607 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
608 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
611 len = min_t(unsigned int, len, sizeof(uf));
612 if (copy_from_user(&uf, optval, len)) {
617 if (!capable(CAP_NET_RAW)) {
618 uf.type_mask &= hci_sec_filter.type_mask;
619 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
620 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
624 struct hci_filter *f = &hci_pi(sk)->filter;
626 f->type_mask = uf.type_mask;
627 f->opcode = uf.opcode;
628 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
629 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
642 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
644 struct hci_ufilter uf;
645 struct sock *sk = sock->sk;
648 if (get_user(len, optlen))
653 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
658 if (put_user(opt, optval))
663 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
668 if (put_user(opt, optval))
674 struct hci_filter *f = &hci_pi(sk)->filter;
676 uf.type_mask = f->type_mask;
677 uf.opcode = f->opcode;
678 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
679 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
682 len = min_t(unsigned int, len, sizeof(uf));
683 if (copy_to_user(optval, &uf, len))
695 static const struct proto_ops hci_sock_ops = {
696 .family = PF_BLUETOOTH,
697 .owner = THIS_MODULE,
698 .release = hci_sock_release,
699 .bind = hci_sock_bind,
700 .getname = hci_sock_getname,
701 .sendmsg = hci_sock_sendmsg,
702 .recvmsg = hci_sock_recvmsg,
703 .ioctl = hci_sock_ioctl,
704 .poll = datagram_poll,
705 .listen = sock_no_listen,
706 .shutdown = sock_no_shutdown,
707 .setsockopt = hci_sock_setsockopt,
708 .getsockopt = hci_sock_getsockopt,
709 .connect = sock_no_connect,
710 .socketpair = sock_no_socketpair,
711 .accept = sock_no_accept,
715 static struct proto hci_sk_proto = {
717 .owner = THIS_MODULE,
718 .obj_size = sizeof(struct hci_pinfo)
721 static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
726 BT_DBG("sock %p", sock);
728 if (sock->type != SOCK_RAW)
729 return -ESOCKTNOSUPPORT;
731 sock->ops = &hci_sock_ops;
733 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
737 sock_init_data(sock, sk);
739 sock_reset_flag(sk, SOCK_ZAPPED);
741 sk->sk_protocol = protocol;
743 sock->state = SS_UNCONNECTED;
744 sk->sk_state = BT_OPEN;
746 bt_sock_link(&hci_sk_list, sk);
750 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
752 struct hci_dev *hdev = (struct hci_dev *) ptr;
753 struct hci_ev_si_device ev;
755 BT_DBG("hdev %s event %ld", hdev->name, event);
757 /* Send event to sockets */
759 ev.dev_id = hdev->id;
760 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
762 if (event == HCI_DEV_UNREG) {
764 struct hlist_node *node;
766 /* Detach sockets from device */
767 read_lock(&hci_sk_list.lock);
768 sk_for_each(sk, node, &hci_sk_list.head) {
770 bh_lock_sock_nested(sk);
771 if (hci_pi(sk)->hdev == hdev) {
772 hci_pi(sk)->hdev = NULL;
774 sk->sk_state = BT_OPEN;
775 sk->sk_state_change(sk);
782 read_unlock(&hci_sk_list.lock);
788 static const struct net_proto_family hci_sock_family_ops = {
789 .family = PF_BLUETOOTH,
790 .owner = THIS_MODULE,
791 .create = hci_sock_create,
794 static struct notifier_block hci_sock_nblock = {
795 .notifier_call = hci_sock_dev_event
798 int __init hci_sock_init(void)
802 err = proto_register(&hci_sk_proto, 0);
806 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
810 hci_register_notifier(&hci_sock_nblock);
812 BT_INFO("HCI socket layer initialized");
817 BT_ERR("HCI socket registration failed");
818 proto_unregister(&hci_sk_proto);
822 void __exit hci_sock_cleanup(void)
824 if (bt_sock_unregister(BTPROTO_HCI) < 0)
825 BT_ERR("HCI socket unregistration failed");
827 hci_unregister_notifier(&hci_sock_nblock);
829 proto_unregister(&hci_sk_proto);