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 <linux/uaccess.h>
47 #include <asm/unaligned.h>
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
52 static bool enable_mgmt;
54 /* ----- HCI socket interface ----- */
56 static inline int hci_test_bit(int nr, void *addr)
58 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
62 static struct hci_sec_filter hci_sec_filter = {
66 { 0x1000d9fe, 0x0000b00c },
71 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
73 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
75 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
77 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
78 /* OGF_STATUS_PARAM */
79 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
83 static struct bt_sock_list hci_sk_list = {
84 .lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
87 /* Send frame to RAW socket */
88 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
91 struct hlist_node *node;
93 BT_DBG("hdev %p len %d", hdev, skb->len);
95 read_lock(&hci_sk_list.lock);
97 sk_for_each(sk, node, &hci_sk_list.head) {
98 struct hci_filter *flt;
101 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
104 /* Don't send frame to the socket it came from */
108 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW)
112 flt = &hci_pi(sk)->filter;
114 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
115 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
118 if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
119 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
121 if (!hci_test_bit(evt, &flt->event_mask))
125 ((evt == HCI_EV_CMD_COMPLETE &&
127 get_unaligned((__le16 *)(skb->data + 3))) ||
128 (evt == HCI_EV_CMD_STATUS &&
130 get_unaligned((__le16 *)(skb->data + 4)))))
134 nskb = skb_clone(skb, GFP_ATOMIC);
138 /* Put type byte before the data */
139 memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
141 if (sock_queue_rcv_skb(sk, nskb))
145 read_unlock(&hci_sk_list.lock);
148 /* Send frame to control socket */
149 void hci_send_to_control(struct sk_buff *skb, struct sock *skip_sk)
152 struct hlist_node *node;
154 BT_DBG("len %d", skb->len);
156 read_lock(&hci_sk_list.lock);
158 sk_for_each(sk, node, &hci_sk_list.head) {
159 struct sk_buff *nskb;
161 /* Skip the original socket */
165 if (sk->sk_state != BT_BOUND)
168 if (hci_pi(sk)->channel != HCI_CHANNEL_CONTROL)
171 nskb = skb_clone(skb, GFP_ATOMIC);
175 if (sock_queue_rcv_skb(sk, nskb))
179 read_unlock(&hci_sk_list.lock);
182 static int hci_sock_release(struct socket *sock)
184 struct sock *sk = sock->sk;
185 struct hci_dev *hdev;
187 BT_DBG("sock %p sk %p", sock, sk);
192 hdev = hci_pi(sk)->hdev;
194 bt_sock_unlink(&hci_sk_list, sk);
197 atomic_dec(&hdev->promisc);
203 skb_queue_purge(&sk->sk_receive_queue);
204 skb_queue_purge(&sk->sk_write_queue);
210 static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
215 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
220 err = hci_blacklist_add(hdev, &bdaddr, 0);
222 hci_dev_unlock(hdev);
227 static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg)
232 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
237 err = hci_blacklist_del(hdev, &bdaddr, 0);
239 hci_dev_unlock(hdev);
244 /* Ioctls that require bound socket */
245 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
247 struct hci_dev *hdev = hci_pi(sk)->hdev;
254 if (!capable(CAP_NET_ADMIN))
257 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
261 set_bit(HCI_RAW, &hdev->flags);
263 clear_bit(HCI_RAW, &hdev->flags);
268 return hci_get_conn_info(hdev, (void __user *) arg);
271 return hci_get_auth_info(hdev, (void __user *) arg);
274 if (!capable(CAP_NET_ADMIN))
276 return hci_sock_blacklist_add(hdev, (void __user *) arg);
279 if (!capable(CAP_NET_ADMIN))
281 return hci_sock_blacklist_del(hdev, (void __user *) arg);
285 return hdev->ioctl(hdev, cmd, arg);
290 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
292 struct sock *sk = sock->sk;
293 void __user *argp = (void __user *) arg;
296 BT_DBG("cmd %x arg %lx", cmd, arg);
300 return hci_get_dev_list(argp);
303 return hci_get_dev_info(argp);
306 return hci_get_conn_list(argp);
309 if (!capable(CAP_NET_ADMIN))
311 return hci_dev_open(arg);
314 if (!capable(CAP_NET_ADMIN))
316 return hci_dev_close(arg);
319 if (!capable(CAP_NET_ADMIN))
321 return hci_dev_reset(arg);
324 if (!capable(CAP_NET_ADMIN))
326 return hci_dev_reset_stat(arg);
336 if (!capable(CAP_NET_ADMIN))
338 return hci_dev_cmd(cmd, argp);
341 return hci_inquiry(argp);
345 err = hci_sock_bound_ioctl(sk, cmd, arg);
351 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
353 struct sockaddr_hci haddr;
354 struct sock *sk = sock->sk;
355 struct hci_dev *hdev = NULL;
358 BT_DBG("sock %p sk %p", sock, sk);
363 memset(&haddr, 0, sizeof(haddr));
364 len = min_t(unsigned int, sizeof(haddr), addr_len);
365 memcpy(&haddr, addr, len);
367 if (haddr.hci_family != AF_BLUETOOTH)
370 if (haddr.hci_channel > HCI_CHANNEL_CONTROL)
373 if (haddr.hci_channel == HCI_CHANNEL_CONTROL) {
376 set_bit(HCI_PI_MGMT_INIT, &hci_pi(sk)->flags);
381 if (sk->sk_state == BT_BOUND || hci_pi(sk)->hdev) {
386 if (haddr.hci_dev != HCI_DEV_NONE) {
387 hdev = hci_dev_get(haddr.hci_dev);
393 atomic_inc(&hdev->promisc);
396 hci_pi(sk)->channel = haddr.hci_channel;
397 hci_pi(sk)->hdev = hdev;
398 sk->sk_state = BT_BOUND;
405 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
407 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
408 struct sock *sk = sock->sk;
409 struct hci_dev *hdev = hci_pi(sk)->hdev;
411 BT_DBG("sock %p sk %p", sock, sk);
418 *addr_len = sizeof(*haddr);
419 haddr->hci_family = AF_BLUETOOTH;
420 haddr->hci_dev = hdev->id;
426 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
428 __u32 mask = hci_pi(sk)->cmsg_mask;
430 if (mask & HCI_CMSG_DIR) {
431 int incoming = bt_cb(skb)->incoming;
432 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
435 if (mask & HCI_CMSG_TSTAMP) {
437 struct compat_timeval ctv;
443 skb_get_timestamp(skb, &tv);
448 if (msg->msg_flags & MSG_CMSG_COMPAT) {
449 ctv.tv_sec = tv.tv_sec;
450 ctv.tv_usec = tv.tv_usec;
456 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
460 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
461 struct msghdr *msg, size_t len, int flags)
463 int noblock = flags & MSG_DONTWAIT;
464 struct sock *sk = sock->sk;
468 BT_DBG("sock %p, sk %p", sock, sk);
470 if (flags & (MSG_OOB))
473 if (sk->sk_state == BT_CLOSED)
476 skb = skb_recv_datagram(sk, flags, noblock, &err);
480 msg->msg_namelen = 0;
484 msg->msg_flags |= MSG_TRUNC;
488 skb_reset_transport_header(skb);
489 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
491 switch (hci_pi(sk)->channel) {
492 case HCI_CHANNEL_RAW:
493 hci_sock_cmsg(sk, msg, skb);
497 skb_free_datagram(sk, skb);
499 return err ? : copied;
502 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
503 struct msghdr *msg, size_t len)
505 struct sock *sk = sock->sk;
506 struct hci_dev *hdev;
510 BT_DBG("sock %p sk %p", sock, sk);
512 if (msg->msg_flags & MSG_OOB)
515 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
518 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
523 switch (hci_pi(sk)->channel) {
524 case HCI_CHANNEL_RAW:
526 case HCI_CHANNEL_CONTROL:
527 err = mgmt_control(sk, msg, len);
534 hdev = hci_pi(sk)->hdev;
540 if (!test_bit(HCI_UP, &hdev->flags)) {
545 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
549 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
554 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
556 skb->dev = (void *) hdev;
558 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
559 u16 opcode = get_unaligned_le16(skb->data);
560 u16 ogf = hci_opcode_ogf(opcode);
561 u16 ocf = hci_opcode_ocf(opcode);
563 if (((ogf > HCI_SFLT_MAX_OGF) ||
564 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
565 !capable(CAP_NET_RAW)) {
570 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
571 skb_queue_tail(&hdev->raw_q, skb);
572 queue_work(hdev->workqueue, &hdev->tx_work);
574 skb_queue_tail(&hdev->cmd_q, skb);
575 queue_work(hdev->workqueue, &hdev->cmd_work);
578 if (!capable(CAP_NET_RAW)) {
583 skb_queue_tail(&hdev->raw_q, skb);
584 queue_work(hdev->workqueue, &hdev->tx_work);
598 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len)
600 struct hci_ufilter uf = { .opcode = 0 };
601 struct sock *sk = sock->sk;
602 int err = 0, opt = 0;
604 BT_DBG("sk %p, opt %d", sk, optname);
608 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
615 if (get_user(opt, (int __user *)optval)) {
621 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
623 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
627 if (get_user(opt, (int __user *)optval)) {
633 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
635 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
640 struct hci_filter *f = &hci_pi(sk)->filter;
642 uf.type_mask = f->type_mask;
643 uf.opcode = f->opcode;
644 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
645 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
648 len = min_t(unsigned int, len, sizeof(uf));
649 if (copy_from_user(&uf, optval, len)) {
654 if (!capable(CAP_NET_RAW)) {
655 uf.type_mask &= hci_sec_filter.type_mask;
656 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
657 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
661 struct hci_filter *f = &hci_pi(sk)->filter;
663 f->type_mask = uf.type_mask;
664 f->opcode = uf.opcode;
665 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
666 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
680 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
682 struct hci_ufilter uf;
683 struct sock *sk = sock->sk;
684 int len, opt, err = 0;
686 BT_DBG("sk %p, opt %d", sk, optname);
688 if (get_user(len, optlen))
693 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
700 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
705 if (put_user(opt, optval))
710 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
715 if (put_user(opt, optval))
721 struct hci_filter *f = &hci_pi(sk)->filter;
723 uf.type_mask = f->type_mask;
724 uf.opcode = f->opcode;
725 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
726 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
729 len = min_t(unsigned int, len, sizeof(uf));
730 if (copy_to_user(optval, &uf, len))
744 static const struct proto_ops hci_sock_ops = {
745 .family = PF_BLUETOOTH,
746 .owner = THIS_MODULE,
747 .release = hci_sock_release,
748 .bind = hci_sock_bind,
749 .getname = hci_sock_getname,
750 .sendmsg = hci_sock_sendmsg,
751 .recvmsg = hci_sock_recvmsg,
752 .ioctl = hci_sock_ioctl,
753 .poll = datagram_poll,
754 .listen = sock_no_listen,
755 .shutdown = sock_no_shutdown,
756 .setsockopt = hci_sock_setsockopt,
757 .getsockopt = hci_sock_getsockopt,
758 .connect = sock_no_connect,
759 .socketpair = sock_no_socketpair,
760 .accept = sock_no_accept,
764 static struct proto hci_sk_proto = {
766 .owner = THIS_MODULE,
767 .obj_size = sizeof(struct hci_pinfo)
770 static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
775 BT_DBG("sock %p", sock);
777 if (sock->type != SOCK_RAW)
778 return -ESOCKTNOSUPPORT;
780 sock->ops = &hci_sock_ops;
782 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
786 sock_init_data(sock, sk);
788 sock_reset_flag(sk, SOCK_ZAPPED);
790 sk->sk_protocol = protocol;
792 sock->state = SS_UNCONNECTED;
793 sk->sk_state = BT_OPEN;
795 bt_sock_link(&hci_sk_list, sk);
799 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
801 struct hci_dev *hdev = (struct hci_dev *) ptr;
802 struct hci_ev_si_device ev;
804 BT_DBG("hdev %s event %ld", hdev->name, event);
806 /* Send event to sockets */
808 ev.dev_id = hdev->id;
809 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
811 if (event == HCI_DEV_UNREG) {
813 struct hlist_node *node;
815 /* Detach sockets from device */
816 read_lock(&hci_sk_list.lock);
817 sk_for_each(sk, node, &hci_sk_list.head) {
818 bh_lock_sock_nested(sk);
819 if (hci_pi(sk)->hdev == hdev) {
820 hci_pi(sk)->hdev = NULL;
822 sk->sk_state = BT_OPEN;
823 sk->sk_state_change(sk);
829 read_unlock(&hci_sk_list.lock);
835 static const struct net_proto_family hci_sock_family_ops = {
836 .family = PF_BLUETOOTH,
837 .owner = THIS_MODULE,
838 .create = hci_sock_create,
841 static struct notifier_block hci_sock_nblock = {
842 .notifier_call = hci_sock_dev_event
845 int __init hci_sock_init(void)
849 err = proto_register(&hci_sk_proto, 0);
853 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
857 hci_register_notifier(&hci_sock_nblock);
859 BT_INFO("HCI socket layer initialized");
864 BT_ERR("HCI socket registration failed");
865 proto_unregister(&hci_sk_proto);
869 void hci_sock_cleanup(void)
871 if (bt_sock_unregister(BTPROTO_HCI) < 0)
872 BT_ERR("HCI socket unregistration failed");
874 hci_unregister_notifier(&hci_sock_nblock);
876 proto_unregister(&hci_sk_proto);
879 module_param(enable_mgmt, bool, 0644);
880 MODULE_PARM_DESC(enable_mgmt, "Enable Management interface");