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/sched.h>
34 #include <linux/slab.h>
35 #include <linux/poll.h>
36 #include <linux/fcntl.h>
37 #include <linux/init.h>
38 #include <linux/skbuff.h>
39 #include <linux/workqueue.h>
40 #include <linux/interrupt.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 #ifndef CONFIG_BT_HCI_SOCK_DEBUG
57 /* ----- HCI socket interface ----- */
59 static inline int hci_test_bit(int nr, void *addr)
61 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
65 static struct hci_sec_filter hci_sec_filter = {
69 { 0x1000d9fe, 0x0000b00c },
74 { 0xbe000006, 0x00000001, 0x000000, 0x00 },
76 { 0x00005200, 0x00000000, 0x000000, 0x00 },
78 { 0xaab00200, 0x2b402aaa, 0x020154, 0x00 },
80 { 0x000002be, 0x00000000, 0x000000, 0x00 },
81 /* OGF_STATUS_PARAM */
82 { 0x000000ea, 0x00000000, 0x000000, 0x00 }
86 static struct bt_sock_list hci_sk_list = {
87 .lock = RW_LOCK_UNLOCKED
90 /* Send frame to RAW socket */
91 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
94 struct hlist_node *node;
96 BT_DBG("hdev %p len %d", hdev, skb->len);
98 read_lock(&hci_sk_list.lock);
99 sk_for_each(sk, node, &hci_sk_list.head) {
100 struct hci_filter *flt;
101 struct sk_buff *nskb;
103 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
106 /* Don't send frame to the socket it came from */
111 flt = &hci_pi(sk)->filter;
113 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
114 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
117 if (bt_cb(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), &bt_cb(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;
147 BT_DBG("sock %p sk %p", sock, sk);
152 hdev = hci_pi(sk)->hdev;
154 bt_sock_unlink(&hci_sk_list, sk);
157 atomic_dec(&hdev->promisc);
163 skb_queue_purge(&sk->sk_receive_queue);
164 skb_queue_purge(&sk->sk_write_queue);
170 /* Ioctls that require bound socket */
171 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
173 struct hci_dev *hdev = hci_pi(sk)->hdev;
180 if (!capable(CAP_NET_ADMIN))
183 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
187 set_bit(HCI_RAW, &hdev->flags);
189 clear_bit(HCI_RAW, &hdev->flags);
194 if (!capable(CAP_NET_ADMIN))
198 set_bit(HCI_SECMGR, &hdev->flags);
200 clear_bit(HCI_SECMGR, &hdev->flags);
205 return hci_get_conn_info(hdev, (void __user *)arg);
209 return hdev->ioctl(hdev, cmd, arg);
214 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
216 struct sock *sk = sock->sk;
217 void __user *argp = (void __user *)arg;
220 BT_DBG("cmd %x arg %lx", cmd, arg);
224 return hci_get_dev_list(argp);
227 return hci_get_dev_info(argp);
230 return hci_get_conn_list(argp);
233 if (!capable(CAP_NET_ADMIN))
235 return hci_dev_open(arg);
238 if (!capable(CAP_NET_ADMIN))
240 return hci_dev_close(arg);
243 if (!capable(CAP_NET_ADMIN))
245 return hci_dev_reset(arg);
248 if (!capable(CAP_NET_ADMIN))
250 return hci_dev_reset_stat(arg);
260 if (!capable(CAP_NET_ADMIN))
262 return hci_dev_cmd(cmd, argp);
265 return hci_inquiry(argp);
269 err = hci_sock_bound_ioctl(sk, cmd, arg);
275 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
277 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
278 struct sock *sk = sock->sk;
279 struct hci_dev *hdev = NULL;
282 BT_DBG("sock %p sk %p", sock, sk);
284 if (!haddr || haddr->hci_family != AF_BLUETOOTH)
289 if (hci_pi(sk)->hdev) {
294 if (haddr->hci_dev != HCI_DEV_NONE) {
295 if (!(hdev = hci_dev_get(haddr->hci_dev))) {
300 atomic_inc(&hdev->promisc);
303 hci_pi(sk)->hdev = hdev;
304 sk->sk_state = BT_BOUND;
311 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
313 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
314 struct sock *sk = sock->sk;
315 struct hci_dev *hdev = hci_pi(sk)->hdev;
317 BT_DBG("sock %p sk %p", sock, sk);
324 *addr_len = sizeof(*haddr);
325 haddr->hci_family = AF_BLUETOOTH;
326 haddr->hci_dev = hdev->id;
332 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
334 __u32 mask = hci_pi(sk)->cmsg_mask;
336 if (mask & HCI_CMSG_DIR) {
337 int incoming = bt_cb(skb)->incoming;
338 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
341 if (mask & HCI_CMSG_TSTAMP) {
344 skb_get_timestamp(skb, &tv);
345 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(tv), &tv);
349 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
350 struct msghdr *msg, size_t len, int flags)
352 int noblock = flags & MSG_DONTWAIT;
353 struct sock *sk = sock->sk;
357 BT_DBG("sock %p, sk %p", sock, sk);
359 if (flags & (MSG_OOB))
362 if (sk->sk_state == BT_CLOSED)
365 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
368 msg->msg_namelen = 0;
372 msg->msg_flags |= MSG_TRUNC;
376 skb->h.raw = skb->data;
377 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
379 hci_sock_cmsg(sk, msg, skb);
381 skb_free_datagram(sk, skb);
383 return err ? : copied;
386 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
387 struct msghdr *msg, size_t len)
389 struct sock *sk = sock->sk;
390 struct hci_dev *hdev;
394 BT_DBG("sock %p sk %p", sock, sk);
396 if (msg->msg_flags & MSG_OOB)
399 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
402 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
407 if (!(hdev = hci_pi(sk)->hdev)) {
412 if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
415 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
420 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
422 skb->dev = (void *) hdev;
424 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
425 u16 opcode = __le16_to_cpu(get_unaligned((__le16 *) skb->data));
426 u16 ogf = hci_opcode_ogf(opcode);
427 u16 ocf = hci_opcode_ocf(opcode);
429 if (((ogf > HCI_SFLT_MAX_OGF) ||
430 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
431 !capable(CAP_NET_RAW)) {
436 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
437 skb_queue_tail(&hdev->raw_q, skb);
440 skb_queue_tail(&hdev->cmd_q, skb);
444 if (!capable(CAP_NET_RAW)) {
449 skb_queue_tail(&hdev->raw_q, skb);
464 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
466 struct hci_ufilter uf = { .opcode = 0 };
467 struct sock *sk = sock->sk;
468 int err = 0, opt = 0;
470 BT_DBG("sk %p, opt %d", sk, optname);
476 if (get_user(opt, (int __user *)optval)) {
482 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
484 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
488 if (get_user(opt, (int __user *)optval)) {
494 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
496 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
500 len = min_t(unsigned int, len, sizeof(uf));
501 if (copy_from_user(&uf, optval, len)) {
506 if (!capable(CAP_NET_RAW)) {
507 uf.type_mask &= hci_sec_filter.type_mask;
508 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
509 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
513 struct hci_filter *f = &hci_pi(sk)->filter;
515 f->type_mask = uf.type_mask;
516 f->opcode = uf.opcode;
517 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
518 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
531 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
533 struct hci_ufilter uf;
534 struct sock *sk = sock->sk;
537 if (get_user(len, optlen))
542 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
547 if (put_user(opt, optval))
552 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
557 if (put_user(opt, optval))
563 struct hci_filter *f = &hci_pi(sk)->filter;
565 uf.type_mask = f->type_mask;
566 uf.opcode = f->opcode;
567 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
568 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
571 len = min_t(unsigned int, len, sizeof(uf));
572 if (copy_to_user(optval, &uf, len))
584 static const struct proto_ops hci_sock_ops = {
585 .family = PF_BLUETOOTH,
586 .owner = THIS_MODULE,
587 .release = hci_sock_release,
588 .bind = hci_sock_bind,
589 .getname = hci_sock_getname,
590 .sendmsg = hci_sock_sendmsg,
591 .recvmsg = hci_sock_recvmsg,
592 .ioctl = hci_sock_ioctl,
593 .poll = datagram_poll,
594 .listen = sock_no_listen,
595 .shutdown = sock_no_shutdown,
596 .setsockopt = hci_sock_setsockopt,
597 .getsockopt = hci_sock_getsockopt,
598 .connect = sock_no_connect,
599 .socketpair = sock_no_socketpair,
600 .accept = sock_no_accept,
604 static struct proto hci_sk_proto = {
606 .owner = THIS_MODULE,
607 .obj_size = sizeof(struct hci_pinfo)
610 static int hci_sock_create(struct socket *sock, int protocol)
614 BT_DBG("sock %p", sock);
616 if (sock->type != SOCK_RAW)
617 return -ESOCKTNOSUPPORT;
619 sock->ops = &hci_sock_ops;
621 sk = sk_alloc(PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto, 1);
625 sock_init_data(sock, sk);
627 sock_reset_flag(sk, SOCK_ZAPPED);
629 sk->sk_protocol = protocol;
631 sock->state = SS_UNCONNECTED;
632 sk->sk_state = BT_OPEN;
634 bt_sock_link(&hci_sk_list, sk);
638 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
640 struct hci_dev *hdev = (struct hci_dev *) ptr;
641 struct hci_ev_si_device ev;
643 BT_DBG("hdev %s event %ld", hdev->name, event);
645 /* Send event to sockets */
647 ev.dev_id = hdev->id;
648 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
650 if (event == HCI_DEV_UNREG) {
652 struct hlist_node *node;
654 /* Detach sockets from device */
655 read_lock(&hci_sk_list.lock);
656 sk_for_each(sk, node, &hci_sk_list.head) {
658 if (hci_pi(sk)->hdev == hdev) {
659 hci_pi(sk)->hdev = NULL;
661 sk->sk_state = BT_OPEN;
662 sk->sk_state_change(sk);
668 read_unlock(&hci_sk_list.lock);
674 static struct net_proto_family hci_sock_family_ops = {
675 .family = PF_BLUETOOTH,
676 .owner = THIS_MODULE,
677 .create = hci_sock_create,
680 static struct notifier_block hci_sock_nblock = {
681 .notifier_call = hci_sock_dev_event
684 int __init hci_sock_init(void)
688 err = proto_register(&hci_sk_proto, 0);
692 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
696 hci_register_notifier(&hci_sock_nblock);
698 BT_INFO("HCI socket layer initialized");
703 BT_ERR("HCI socket registration failed");
704 proto_unregister(&hci_sk_proto);
708 int __exit hci_sock_cleanup(void)
710 if (bt_sock_unregister(BTPROTO_HCI) < 0)
711 BT_ERR("HCI socket unregistration failed");
713 hci_unregister_notifier(&hci_sock_nblock);
715 proto_unregister(&hci_sk_proto);