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.
26 * BlueZ HCI socket layer.
28 * $Id: hci_sock.c,v 1.5 2002/07/22 20:32:54 maxk Exp $
31 #include <linux/config.h>
32 #include <linux/module.h>
34 #include <linux/types.h>
35 #include <linux/errno.h>
36 #include <linux/kernel.h>
37 #include <linux/major.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/poll.h>
41 #include <linux/fcntl.h>
42 #include <linux/init.h>
43 #include <linux/skbuff.h>
44 #include <linux/tqueue.h>
45 #include <linux/interrupt.h>
46 #include <linux/socket.h>
47 #include <linux/ioctl.h>
50 #include <asm/system.h>
51 #include <asm/uaccess.h>
52 #include <asm/unaligned.h>
54 #include <net/bluetooth/bluetooth.h>
55 #include <net/bluetooth/hci_core.h>
57 #ifndef HCI_SOCK_DEBUG
59 #define BT_DBG( A... )
62 /* ----- HCI socket interface ----- */
65 static struct hci_sec_filter hci_sec_filter = {
69 { 0x1000d9fe, 0x0000300c },
74 { 0xbe000006, 0x00000001, 0x0000, 0x00 },
76 { 0x00005200, 0x00000000, 0x0000, 0x00 },
78 { 0xaab00200, 0x2b402aaa, 0x0154, 0x00 },
80 { 0x000002be, 0x00000000, 0x0000, 0x00 },
81 /* OGF_STATUS_PARAM */
82 { 0x000000ea, 0x00000000, 0x0000, 0x00 }
86 static struct bluez_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)
95 BT_DBG("hdev %p len %d", hdev, skb->len);
97 read_lock(&hci_sk_list.lock);
98 for (sk = hci_sk_list.head; sk; sk = sk->next) {
99 struct hci_filter *flt;
100 struct sk_buff *nskb;
102 if (sk->state != BT_BOUND || hci_pi(sk)->hdev != hdev)
105 /* Don't send frame to the socket it came from */
110 flt = &hci_pi(sk)->filter;
112 if (!hci_test_bit((skb->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
115 if (skb->pkt_type == HCI_EVENT_PKT) {
116 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
118 if (!hci_test_bit(evt, &flt->event_mask))
121 if (flt->opcode && ((evt == EVT_CMD_COMPLETE &&
122 flt->opcode != *(__u16 *)(skb->data + 3)) ||
123 (evt == EVT_CMD_STATUS &&
124 flt->opcode != *(__u16 *)(skb->data + 4))))
128 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
131 /* Put type byte before the data */
132 memcpy(skb_push(nskb, 1), &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 = hci_pi(sk)->hdev;
145 BT_DBG("sock %p sk %p", sock, sk);
150 bluez_sock_unlink(&hci_sk_list, sk);
153 atomic_dec(&hdev->promisc);
159 skb_queue_purge(&sk->receive_queue);
160 skb_queue_purge(&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, 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;
203 BT_DBG("cmd %x arg %lx", cmd, arg);
207 return hci_get_dev_list(arg);
210 return hci_get_dev_info(arg);
213 return hci_get_conn_list(arg);
216 if (!capable(CAP_NET_ADMIN))
218 return hci_dev_open(arg);
221 if (!capable(CAP_NET_ADMIN))
223 return hci_dev_close(arg);
226 if (!capable(CAP_NET_ADMIN))
228 return hci_dev_reset(arg);
231 if (!capable(CAP_NET_ADMIN))
233 return hci_dev_reset_stat(arg);
243 if (!capable(CAP_NET_ADMIN))
245 return hci_dev_cmd(cmd, arg);
248 return hci_inquiry(arg);
252 err = hci_sock_bound_ioctl(sk, cmd, arg);
258 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
260 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
261 struct sock *sk = sock->sk;
262 struct hci_dev *hdev = NULL;
265 BT_DBG("sock %p sk %p", sock, sk);
267 if (!haddr || haddr->hci_family != AF_BLUETOOTH)
272 if (hci_pi(sk)->hdev) {
277 if (haddr->hci_dev != HCI_DEV_NONE) {
278 if (!(hdev = hci_dev_get(haddr->hci_dev))) {
283 atomic_inc(&hdev->promisc);
286 hci_pi(sk)->hdev = hdev;
287 sk->state = BT_BOUND;
294 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
296 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
297 struct sock *sk = sock->sk;
299 BT_DBG("sock %p sk %p", sock, sk);
303 *addr_len = sizeof(*haddr);
304 haddr->hci_family = AF_BLUETOOTH;
305 haddr->hci_dev = hci_pi(sk)->hdev->id;
311 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
313 __u32 mask = hci_pi(sk)->cmsg_mask;
315 if (mask & HCI_CMSG_DIR)
316 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(int), &bluez_cb(skb)->incomming);
318 if (mask & HCI_CMSG_TSTAMP)
319 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(skb->stamp), &skb->stamp);
322 static int hci_sock_recvmsg(struct socket *sock, struct msghdr *msg, int len, int flags, struct scm_cookie *scm)
324 int noblock = flags & MSG_DONTWAIT;
325 struct sock *sk = sock->sk;
329 BT_DBG("sock %p, sk %p", sock, sk);
331 if (flags & (MSG_OOB))
334 if (sk->state == BT_CLOSED)
337 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
340 msg->msg_namelen = 0;
344 msg->msg_flags |= MSG_TRUNC;
348 skb->h.raw = skb->data;
349 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
351 hci_sock_cmsg(sk, msg, skb);
353 skb_free_datagram(sk, skb);
355 return err ? : copied;
358 static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg, int len,
359 struct scm_cookie *scm)
361 struct sock *sk = sock->sk;
362 struct hci_dev *hdev;
366 BT_DBG("sock %p sk %p", sock, sk);
368 if (msg->msg_flags & MSG_OOB)
371 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
379 if (!(hdev = hci_pi(sk)->hdev)) {
384 if (!(skb = bluez_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
387 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
392 skb->pkt_type = *((unsigned char *) skb->data);
394 skb->dev = (void *) hdev;
396 if (skb->pkt_type == HCI_COMMAND_PKT) {
397 u16 opcode = __le16_to_cpu(get_unaligned((u16 *)skb->data));
398 u16 ogf = cmd_opcode_ogf(opcode);
399 u16 ocf = cmd_opcode_ocf(opcode);
401 if (((ogf > HCI_SFLT_MAX_OGF) ||
402 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
403 !capable(CAP_NET_RAW)) {
408 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
409 skb_queue_tail(&hdev->raw_q, skb);
412 skb_queue_tail(&hdev->cmd_q, skb);
416 if (!capable(CAP_NET_RAW)) {
421 skb_queue_tail(&hdev->raw_q, skb);
436 int hci_sock_setsockopt(struct socket *sock, int level, int optname, char *optval, int len)
438 struct sock *sk = sock->sk;
439 struct hci_filter flt = { opcode: 0 };
440 int err = 0, opt = 0;
442 BT_DBG("sk %p, opt %d", sk, optname);
448 if (get_user(opt, (int *)optval)) {
454 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
456 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
460 if (get_user(opt, (int *)optval)) {
466 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
468 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
472 memcpy(&flt, &hci_pi(sk)->filter, len);
474 len = MIN(len, sizeof(struct hci_filter));
475 if (copy_from_user(&flt, optval, len)) {
480 if (!capable(CAP_NET_RAW)) {
481 flt.type_mask &= hci_sec_filter.type_mask;
482 flt.event_mask[0] &= hci_sec_filter.event_mask[0];
483 flt.event_mask[1] &= hci_sec_filter.event_mask[1];
486 memcpy(&hci_pi(sk)->filter, &flt, len);
498 int hci_sock_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
500 struct sock *sk = sock->sk;
503 if (get_user(len, optlen))
508 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
513 if (put_user(opt, optval))
518 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
523 if (put_user(opt, optval))
528 len = MIN(len, sizeof(struct hci_filter));
529 if (copy_to_user(optval, &hci_pi(sk)->filter, len))
541 struct proto_ops hci_sock_ops = {
542 family: PF_BLUETOOTH,
543 release: hci_sock_release,
545 getname: hci_sock_getname,
546 sendmsg: hci_sock_sendmsg,
547 recvmsg: hci_sock_recvmsg,
548 ioctl: hci_sock_ioctl,
550 listen: sock_no_listen,
551 shutdown: sock_no_shutdown,
552 setsockopt: hci_sock_setsockopt,
553 getsockopt: hci_sock_getsockopt,
554 connect: sock_no_connect,
555 socketpair: sock_no_socketpair,
556 accept: sock_no_accept,
560 static int hci_sock_create(struct socket *sock, int protocol)
564 BT_DBG("sock %p", sock);
566 if (sock->type != SOCK_RAW)
567 return -ESOCKTNOSUPPORT;
569 sock->ops = &hci_sock_ops;
571 if (!(sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, 1)))
574 sock->state = SS_UNCONNECTED;
575 sock_init_data(sock, sk);
577 memset(&sk->protinfo, 0, sizeof(struct hci_pinfo));
579 sk->protocol = protocol;
582 bluez_sock_link(&hci_sk_list, sk);
588 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
590 struct hci_dev *hdev = (struct hci_dev *) ptr;
593 BT_DBG("hdev %s event %ld", hdev->name, event);
595 /* Send event to sockets */
597 sd.dev_id = hdev->id;
598 hci_si_event(NULL, EVT_SI_DEVICE, EVT_SI_DEVICE_SIZE, &sd);
600 if (event == HCI_DEV_UNREG) {
603 /* Detach sockets from device */
604 read_lock(&hci_sk_list.lock);
605 for (sk = hci_sk_list.head; sk; sk = sk->next) {
607 if (hci_pi(sk)->hdev == hdev) {
608 hci_pi(sk)->hdev = NULL;
611 sk->state_change(sk);
617 read_unlock(&hci_sk_list.lock);
623 struct net_proto_family hci_sock_family_ops = {
624 family: PF_BLUETOOTH,
625 create: hci_sock_create
628 struct notifier_block hci_sock_nblock = {
629 notifier_call: hci_sock_dev_event
632 int hci_sock_init(void)
634 if (bluez_sock_register(BTPROTO_HCI, &hci_sock_family_ops)) {
635 BT_ERR("Can't register HCI socket");
639 hci_register_notifier(&hci_sock_nblock);
643 int hci_sock_cleanup(void)
645 if (bluez_sock_unregister(BTPROTO_HCI))
646 BT_ERR("Can't unregister HCI socket");
648 hci_unregister_notifier(&hci_sock_nblock);