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/config.h>
28 #include <linux/module.h>
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/major.h>
34 #include <linux/sched.h>
35 #include <linux/slab.h>
36 #include <linux/poll.h>
37 #include <linux/fcntl.h>
38 #include <linux/init.h>
39 #include <linux/skbuff.h>
40 #include <linux/workqueue.h>
41 #include <linux/interrupt.h>
42 #include <linux/socket.h>
43 #include <linux/ioctl.h>
46 #include <asm/system.h>
47 #include <asm/uaccess.h>
48 #include <asm/unaligned.h>
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
53 #ifndef CONFIG_BT_HCI_SOCK_DEBUG
58 /* ----- HCI socket interface ----- */
60 static inline int hci_test_bit(int nr, void *addr)
62 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
66 static struct hci_sec_filter hci_sec_filter = {
70 { 0x1000d9fe, 0x0000300c },
75 { 0xbe000006, 0x00000001, 0x0000, 0x00 },
77 { 0x00005200, 0x00000000, 0x0000, 0x00 },
79 { 0xaab00200, 0x2b402aaa, 0x0154, 0x00 },
81 { 0x000002be, 0x00000000, 0x0000, 0x00 },
82 /* OGF_STATUS_PARAM */
83 { 0x000000ea, 0x00000000, 0x0000, 0x00 }
87 static struct bt_sock_list hci_sk_list = {
88 .lock = RW_LOCK_UNLOCKED
91 /* Send frame to RAW socket */
92 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
95 struct hlist_node *node;
97 BT_DBG("hdev %p len %d", hdev, skb->len);
99 read_lock(&hci_sk_list.lock);
100 sk_for_each(sk, node, &hci_sk_list.head) {
101 struct hci_filter *flt;
102 struct sk_buff *nskb;
104 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
107 /* Don't send frame to the socket it came from */
112 flt = &hci_pi(sk)->filter;
114 if (!test_bit((skb->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
117 if (skb->pkt_type == HCI_EVENT_PKT) {
118 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
120 if (!hci_test_bit(evt, &flt->event_mask))
123 if (flt->opcode && ((evt == HCI_EV_CMD_COMPLETE &&
124 flt->opcode != *(__u16 *)(skb->data + 3)) ||
125 (evt == HCI_EV_CMD_STATUS &&
126 flt->opcode != *(__u16 *)(skb->data + 4))))
130 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
133 /* Put type byte before the data */
134 memcpy(skb_push(nskb, 1), &nskb->pkt_type, 1);
136 if (sock_queue_rcv_skb(sk, nskb))
139 read_unlock(&hci_sk_list.lock);
142 static int hci_sock_release(struct socket *sock)
144 struct sock *sk = sock->sk;
145 struct hci_dev *hdev = hci_pi(sk)->hdev;
147 BT_DBG("sock %p sk %p", sock, sk);
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 /* Ioctls that require bound socket */
169 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
171 struct hci_dev *hdev = hci_pi(sk)->hdev;
178 if (!capable(CAP_NET_ADMIN))
182 set_bit(HCI_RAW, &hdev->flags);
184 clear_bit(HCI_RAW, &hdev->flags);
189 return hci_get_conn_info(hdev, (void __user *)arg);
193 return hdev->ioctl(hdev, cmd, arg);
198 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
200 struct sock *sk = sock->sk;
201 void __user *argp = (void __user *)arg;
204 BT_DBG("cmd %x arg %lx", cmd, arg);
208 return hci_get_dev_list(argp);
211 return hci_get_dev_info(argp);
214 return hci_get_conn_list(argp);
217 if (!capable(CAP_NET_ADMIN))
219 return hci_dev_open(arg);
222 if (!capable(CAP_NET_ADMIN))
224 return hci_dev_close(arg);
227 if (!capable(CAP_NET_ADMIN))
229 return hci_dev_reset(arg);
232 if (!capable(CAP_NET_ADMIN))
234 return hci_dev_reset_stat(arg);
244 if (!capable(CAP_NET_ADMIN))
246 return hci_dev_cmd(cmd, argp);
249 return hci_inquiry(argp);
253 err = hci_sock_bound_ioctl(sk, cmd, arg);
259 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
261 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
262 struct sock *sk = sock->sk;
263 struct hci_dev *hdev = NULL;
266 BT_DBG("sock %p sk %p", sock, sk);
268 if (!haddr || haddr->hci_family != AF_BLUETOOTH)
273 if (hci_pi(sk)->hdev) {
278 if (haddr->hci_dev != HCI_DEV_NONE) {
279 if (!(hdev = hci_dev_get(haddr->hci_dev))) {
284 atomic_inc(&hdev->promisc);
287 hci_pi(sk)->hdev = hdev;
288 sk->sk_state = BT_BOUND;
295 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
297 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
298 struct sock *sk = sock->sk;
300 BT_DBG("sock %p sk %p", sock, sk);
304 *addr_len = sizeof(*haddr);
305 haddr->hci_family = AF_BLUETOOTH;
306 haddr->hci_dev = hci_pi(sk)->hdev->id;
312 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
314 __u32 mask = hci_pi(sk)->cmsg_mask;
316 if (mask & HCI_CMSG_DIR)
317 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(int), &bt_cb(skb)->incoming);
319 if (mask & HCI_CMSG_TSTAMP)
320 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(skb->stamp), &skb->stamp);
323 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
324 struct msghdr *msg, size_t len, int flags)
326 int noblock = flags & MSG_DONTWAIT;
327 struct sock *sk = sock->sk;
331 BT_DBG("sock %p, sk %p", sock, sk);
333 if (flags & (MSG_OOB))
336 if (sk->sk_state == BT_CLOSED)
339 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
342 msg->msg_namelen = 0;
346 msg->msg_flags |= MSG_TRUNC;
350 skb->h.raw = skb->data;
351 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
353 hci_sock_cmsg(sk, msg, skb);
355 skb_free_datagram(sk, skb);
357 return err ? : copied;
360 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
361 struct msghdr *msg, size_t len)
363 struct sock *sk = sock->sk;
364 struct hci_dev *hdev;
368 BT_DBG("sock %p sk %p", sock, sk);
370 if (msg->msg_flags & MSG_OOB)
373 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
376 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
381 if (!(hdev = hci_pi(sk)->hdev)) {
386 if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
389 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
394 skb->pkt_type = *((unsigned char *) skb->data);
396 skb->dev = (void *) hdev;
398 if (skb->pkt_type == HCI_COMMAND_PKT) {
399 u16 opcode = __le16_to_cpu(get_unaligned((u16 *)skb->data));
400 u16 ogf = hci_opcode_ogf(opcode);
401 u16 ocf = hci_opcode_ocf(opcode);
403 if (((ogf > HCI_SFLT_MAX_OGF) ||
404 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
405 !capable(CAP_NET_RAW)) {
410 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
411 skb_queue_tail(&hdev->raw_q, skb);
414 skb_queue_tail(&hdev->cmd_q, skb);
418 if (!capable(CAP_NET_RAW)) {
423 skb_queue_tail(&hdev->raw_q, skb);
438 int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
440 struct hci_ufilter uf = { .opcode = 0 };
441 struct sock *sk = sock->sk;
442 int err = 0, opt = 0;
444 BT_DBG("sk %p, opt %d", sk, optname);
450 if (get_user(opt, (int __user *)optval)) {
456 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
458 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
462 if (get_user(opt, (int __user *)optval)) {
468 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
470 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
474 len = min_t(unsigned int, len, sizeof(uf));
475 if (copy_from_user(&uf, optval, len)) {
480 if (!capable(CAP_NET_RAW)) {
481 uf.type_mask &= hci_sec_filter.type_mask;
482 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
483 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
487 struct hci_filter *f = &hci_pi(sk)->filter;
489 f->type_mask = uf.type_mask;
490 f->opcode = uf.opcode;
491 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
492 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
505 int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
507 struct hci_ufilter uf;
508 struct sock *sk = sock->sk;
511 if (get_user(len, optlen))
516 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
521 if (put_user(opt, optval))
526 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
531 if (put_user(opt, optval))
537 struct hci_filter *f = &hci_pi(sk)->filter;
539 uf.type_mask = f->type_mask;
540 uf.opcode = f->opcode;
541 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
542 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
545 len = min_t(unsigned int, len, sizeof(uf));
546 if (copy_to_user(optval, &uf, len))
558 struct proto_ops hci_sock_ops = {
559 .family = PF_BLUETOOTH,
560 .owner = THIS_MODULE,
561 .release = hci_sock_release,
562 .bind = hci_sock_bind,
563 .getname = hci_sock_getname,
564 .sendmsg = hci_sock_sendmsg,
565 .recvmsg = hci_sock_recvmsg,
566 .ioctl = hci_sock_ioctl,
567 .poll = datagram_poll,
568 .listen = sock_no_listen,
569 .shutdown = sock_no_shutdown,
570 .setsockopt = hci_sock_setsockopt,
571 .getsockopt = hci_sock_getsockopt,
572 .connect = sock_no_connect,
573 .socketpair = sock_no_socketpair,
574 .accept = sock_no_accept,
578 static int hci_sock_create(struct socket *sock, int protocol)
582 BT_DBG("sock %p", sock);
584 if (sock->type != SOCK_RAW)
585 return -ESOCKTNOSUPPORT;
587 sock->ops = &hci_sock_ops;
589 sk = bt_sock_alloc(sock, protocol, sizeof(struct hci_pinfo), GFP_KERNEL);
593 sk_set_owner(sk, THIS_MODULE);
595 sock->state = SS_UNCONNECTED;
596 sk->sk_state = BT_OPEN;
598 bt_sock_link(&hci_sk_list, sk);
602 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
604 struct hci_dev *hdev = (struct hci_dev *) ptr;
605 struct hci_ev_si_device ev;
607 BT_DBG("hdev %s event %ld", hdev->name, event);
609 /* Send event to sockets */
611 ev.dev_id = hdev->id;
612 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
614 if (event == HCI_DEV_UNREG) {
616 struct hlist_node *node;
618 /* Detach sockets from device */
619 read_lock(&hci_sk_list.lock);
620 sk_for_each(sk, node, &hci_sk_list.head) {
622 if (hci_pi(sk)->hdev == hdev) {
623 hci_pi(sk)->hdev = NULL;
625 sk->sk_state = BT_OPEN;
626 sk->sk_state_change(sk);
632 read_unlock(&hci_sk_list.lock);
638 struct net_proto_family hci_sock_family_ops = {
639 .family = PF_BLUETOOTH,
640 .owner = THIS_MODULE,
641 .create = hci_sock_create,
644 struct notifier_block hci_sock_nblock = {
645 .notifier_call = hci_sock_dev_event
648 int __init hci_sock_init(void)
650 if (bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops)) {
651 BT_ERR("HCI socket registration failed");
655 hci_register_notifier(&hci_sock_nblock);
657 BT_INFO("HCI socket layer initialized");
662 int __exit hci_sock_cleanup(void)
664 if (bt_sock_unregister(BTPROTO_HCI))
665 BT_ERR("HCI socket unregistration failed");
667 hci_unregister_notifier(&hci_sock_nblock);