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 #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, 0x00000000, 0x00 },
76 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
78 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
80 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
81 /* OGF_STATUS_PARAM */
82 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
86 static struct bt_sock_list hci_sk_list
= {
87 .lock
= __RW_LOCK_UNLOCKED(hci_sk_list
.lock
)
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
))
124 ((evt
== HCI_EV_CMD_COMPLETE
&&
126 get_unaligned((__le16
*)(skb
->data
+ 3))) ||
127 (evt
== HCI_EV_CMD_STATUS
&&
129 get_unaligned((__le16
*)(skb
->data
+ 4)))))
133 if (!(nskb
= skb_clone(skb
, GFP_ATOMIC
)))
136 /* Put type byte before the data */
137 memcpy(skb_push(nskb
, 1), &bt_cb(nskb
)->pkt_type
, 1);
139 if (sock_queue_rcv_skb(sk
, nskb
))
142 read_unlock(&hci_sk_list
.lock
);
145 static int hci_sock_release(struct socket
*sock
)
147 struct sock
*sk
= sock
->sk
;
148 struct hci_dev
*hdev
;
150 BT_DBG("sock %p sk %p", sock
, sk
);
155 hdev
= hci_pi(sk
)->hdev
;
157 bt_sock_unlink(&hci_sk_list
, sk
);
160 atomic_dec(&hdev
->promisc
);
166 skb_queue_purge(&sk
->sk_receive_queue
);
167 skb_queue_purge(&sk
->sk_write_queue
);
173 /* Ioctls that require bound socket */
174 static inline int hci_sock_bound_ioctl(struct sock
*sk
, unsigned int cmd
, unsigned long arg
)
176 struct hci_dev
*hdev
= hci_pi(sk
)->hdev
;
183 if (!capable(CAP_NET_ADMIN
))
186 if (test_bit(HCI_QUIRK_RAW_DEVICE
, &hdev
->quirks
))
190 set_bit(HCI_RAW
, &hdev
->flags
);
192 clear_bit(HCI_RAW
, &hdev
->flags
);
197 if (!capable(CAP_NET_ADMIN
))
201 set_bit(HCI_SECMGR
, &hdev
->flags
);
203 clear_bit(HCI_SECMGR
, &hdev
->flags
);
208 return hci_get_conn_info(hdev
, (void __user
*)arg
);
212 return hdev
->ioctl(hdev
, cmd
, arg
);
217 static int hci_sock_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
219 struct sock
*sk
= sock
->sk
;
220 void __user
*argp
= (void __user
*)arg
;
223 BT_DBG("cmd %x arg %lx", cmd
, arg
);
227 return hci_get_dev_list(argp
);
230 return hci_get_dev_info(argp
);
233 return hci_get_conn_list(argp
);
236 if (!capable(CAP_NET_ADMIN
))
238 return hci_dev_open(arg
);
241 if (!capable(CAP_NET_ADMIN
))
243 return hci_dev_close(arg
);
246 if (!capable(CAP_NET_ADMIN
))
248 return hci_dev_reset(arg
);
251 if (!capable(CAP_NET_ADMIN
))
253 return hci_dev_reset_stat(arg
);
263 if (!capable(CAP_NET_ADMIN
))
265 return hci_dev_cmd(cmd
, argp
);
268 return hci_inquiry(argp
);
272 err
= hci_sock_bound_ioctl(sk
, cmd
, arg
);
278 static int hci_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int addr_len
)
280 struct sockaddr_hci
*haddr
= (struct sockaddr_hci
*) addr
;
281 struct sock
*sk
= sock
->sk
;
282 struct hci_dev
*hdev
= NULL
;
285 BT_DBG("sock %p sk %p", sock
, sk
);
287 if (!haddr
|| haddr
->hci_family
!= AF_BLUETOOTH
)
292 if (hci_pi(sk
)->hdev
) {
297 if (haddr
->hci_dev
!= HCI_DEV_NONE
) {
298 if (!(hdev
= hci_dev_get(haddr
->hci_dev
))) {
303 atomic_inc(&hdev
->promisc
);
306 hci_pi(sk
)->hdev
= hdev
;
307 sk
->sk_state
= BT_BOUND
;
314 static int hci_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *addr_len
, int peer
)
316 struct sockaddr_hci
*haddr
= (struct sockaddr_hci
*) addr
;
317 struct sock
*sk
= sock
->sk
;
318 struct hci_dev
*hdev
= hci_pi(sk
)->hdev
;
320 BT_DBG("sock %p sk %p", sock
, sk
);
327 *addr_len
= sizeof(*haddr
);
328 haddr
->hci_family
= AF_BLUETOOTH
;
329 haddr
->hci_dev
= hdev
->id
;
335 static inline void hci_sock_cmsg(struct sock
*sk
, struct msghdr
*msg
, struct sk_buff
*skb
)
337 __u32 mask
= hci_pi(sk
)->cmsg_mask
;
339 if (mask
& HCI_CMSG_DIR
) {
340 int incoming
= bt_cb(skb
)->incoming
;
341 put_cmsg(msg
, SOL_HCI
, HCI_CMSG_DIR
, sizeof(incoming
), &incoming
);
344 if (mask
& HCI_CMSG_TSTAMP
) {
349 skb_get_timestamp(skb
, &tv
);
354 if (msg
->msg_flags
& MSG_CMSG_COMPAT
) {
355 struct compat_timeval ctv
;
356 ctv
.tv_sec
= tv
.tv_sec
;
357 ctv
.tv_usec
= tv
.tv_usec
;
363 put_cmsg(msg
, SOL_HCI
, HCI_CMSG_TSTAMP
, len
, data
);
367 static int hci_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
368 struct msghdr
*msg
, size_t len
, int flags
)
370 int noblock
= flags
& MSG_DONTWAIT
;
371 struct sock
*sk
= sock
->sk
;
375 BT_DBG("sock %p, sk %p", sock
, sk
);
377 if (flags
& (MSG_OOB
))
380 if (sk
->sk_state
== BT_CLOSED
)
383 if (!(skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
)))
386 msg
->msg_namelen
= 0;
390 msg
->msg_flags
|= MSG_TRUNC
;
394 skb_reset_transport_header(skb
);
395 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
397 hci_sock_cmsg(sk
, msg
, skb
);
399 skb_free_datagram(sk
, skb
);
401 return err
? : copied
;
404 static int hci_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
405 struct msghdr
*msg
, size_t len
)
407 struct sock
*sk
= sock
->sk
;
408 struct hci_dev
*hdev
;
412 BT_DBG("sock %p sk %p", sock
, sk
);
414 if (msg
->msg_flags
& MSG_OOB
)
417 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_NOSIGNAL
|MSG_ERRQUEUE
))
420 if (len
< 4 || len
> HCI_MAX_FRAME_SIZE
)
425 if (!(hdev
= hci_pi(sk
)->hdev
)) {
430 if (!(skb
= bt_skb_send_alloc(sk
, len
, msg
->msg_flags
& MSG_DONTWAIT
, &err
)))
433 if (memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
)) {
438 bt_cb(skb
)->pkt_type
= *((unsigned char *) skb
->data
);
440 skb
->dev
= (void *) hdev
;
442 if (bt_cb(skb
)->pkt_type
== HCI_COMMAND_PKT
) {
443 u16 opcode
= get_unaligned_le16(skb
->data
);
444 u16 ogf
= hci_opcode_ogf(opcode
);
445 u16 ocf
= hci_opcode_ocf(opcode
);
447 if (((ogf
> HCI_SFLT_MAX_OGF
) ||
448 !hci_test_bit(ocf
& HCI_FLT_OCF_BITS
, &hci_sec_filter
.ocf_mask
[ogf
])) &&
449 !capable(CAP_NET_RAW
)) {
454 if (test_bit(HCI_RAW
, &hdev
->flags
) || (ogf
== 0x3f)) {
455 skb_queue_tail(&hdev
->raw_q
, skb
);
458 skb_queue_tail(&hdev
->cmd_q
, skb
);
462 if (!capable(CAP_NET_RAW
)) {
467 skb_queue_tail(&hdev
->raw_q
, skb
);
482 static int hci_sock_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int len
)
484 struct hci_ufilter uf
= { .opcode
= 0 };
485 struct sock
*sk
= sock
->sk
;
486 int err
= 0, opt
= 0;
488 BT_DBG("sk %p, opt %d", sk
, optname
);
494 if (get_user(opt
, (int __user
*)optval
)) {
500 hci_pi(sk
)->cmsg_mask
|= HCI_CMSG_DIR
;
502 hci_pi(sk
)->cmsg_mask
&= ~HCI_CMSG_DIR
;
506 if (get_user(opt
, (int __user
*)optval
)) {
512 hci_pi(sk
)->cmsg_mask
|= HCI_CMSG_TSTAMP
;
514 hci_pi(sk
)->cmsg_mask
&= ~HCI_CMSG_TSTAMP
;
519 struct hci_filter
*f
= &hci_pi(sk
)->filter
;
521 uf
.type_mask
= f
->type_mask
;
522 uf
.opcode
= f
->opcode
;
523 uf
.event_mask
[0] = *((u32
*) f
->event_mask
+ 0);
524 uf
.event_mask
[1] = *((u32
*) f
->event_mask
+ 1);
527 len
= min_t(unsigned int, len
, sizeof(uf
));
528 if (copy_from_user(&uf
, optval
, len
)) {
533 if (!capable(CAP_NET_RAW
)) {
534 uf
.type_mask
&= hci_sec_filter
.type_mask
;
535 uf
.event_mask
[0] &= *((u32
*) hci_sec_filter
.event_mask
+ 0);
536 uf
.event_mask
[1] &= *((u32
*) hci_sec_filter
.event_mask
+ 1);
540 struct hci_filter
*f
= &hci_pi(sk
)->filter
;
542 f
->type_mask
= uf
.type_mask
;
543 f
->opcode
= uf
.opcode
;
544 *((u32
*) f
->event_mask
+ 0) = uf
.event_mask
[0];
545 *((u32
*) f
->event_mask
+ 1) = uf
.event_mask
[1];
558 static int hci_sock_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
560 struct hci_ufilter uf
;
561 struct sock
*sk
= sock
->sk
;
564 if (get_user(len
, optlen
))
569 if (hci_pi(sk
)->cmsg_mask
& HCI_CMSG_DIR
)
574 if (put_user(opt
, optval
))
579 if (hci_pi(sk
)->cmsg_mask
& HCI_CMSG_TSTAMP
)
584 if (put_user(opt
, optval
))
590 struct hci_filter
*f
= &hci_pi(sk
)->filter
;
592 uf
.type_mask
= f
->type_mask
;
593 uf
.opcode
= f
->opcode
;
594 uf
.event_mask
[0] = *((u32
*) f
->event_mask
+ 0);
595 uf
.event_mask
[1] = *((u32
*) f
->event_mask
+ 1);
598 len
= min_t(unsigned int, len
, sizeof(uf
));
599 if (copy_to_user(optval
, &uf
, len
))
611 static const struct proto_ops hci_sock_ops
= {
612 .family
= PF_BLUETOOTH
,
613 .owner
= THIS_MODULE
,
614 .release
= hci_sock_release
,
615 .bind
= hci_sock_bind
,
616 .getname
= hci_sock_getname
,
617 .sendmsg
= hci_sock_sendmsg
,
618 .recvmsg
= hci_sock_recvmsg
,
619 .ioctl
= hci_sock_ioctl
,
620 .poll
= datagram_poll
,
621 .listen
= sock_no_listen
,
622 .shutdown
= sock_no_shutdown
,
623 .setsockopt
= hci_sock_setsockopt
,
624 .getsockopt
= hci_sock_getsockopt
,
625 .connect
= sock_no_connect
,
626 .socketpair
= sock_no_socketpair
,
627 .accept
= sock_no_accept
,
631 static struct proto hci_sk_proto
= {
633 .owner
= THIS_MODULE
,
634 .obj_size
= sizeof(struct hci_pinfo
)
637 static int hci_sock_create(struct net
*net
, struct socket
*sock
, int protocol
)
641 BT_DBG("sock %p", sock
);
643 if (sock
->type
!= SOCK_RAW
)
644 return -ESOCKTNOSUPPORT
;
646 sock
->ops
= &hci_sock_ops
;
648 sk
= sk_alloc(net
, PF_BLUETOOTH
, GFP_ATOMIC
, &hci_sk_proto
);
652 sock_init_data(sock
, sk
);
654 sock_reset_flag(sk
, SOCK_ZAPPED
);
656 sk
->sk_protocol
= protocol
;
658 sock
->state
= SS_UNCONNECTED
;
659 sk
->sk_state
= BT_OPEN
;
661 bt_sock_link(&hci_sk_list
, sk
);
665 static int hci_sock_dev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
667 struct hci_dev
*hdev
= (struct hci_dev
*) ptr
;
668 struct hci_ev_si_device ev
;
670 BT_DBG("hdev %s event %ld", hdev
->name
, event
);
672 /* Send event to sockets */
674 ev
.dev_id
= hdev
->id
;
675 hci_si_event(NULL
, HCI_EV_SI_DEVICE
, sizeof(ev
), &ev
);
677 if (event
== HCI_DEV_UNREG
) {
679 struct hlist_node
*node
;
681 /* Detach sockets from device */
682 read_lock(&hci_sk_list
.lock
);
683 sk_for_each(sk
, node
, &hci_sk_list
.head
) {
685 bh_lock_sock_nested(sk
);
686 if (hci_pi(sk
)->hdev
== hdev
) {
687 hci_pi(sk
)->hdev
= NULL
;
689 sk
->sk_state
= BT_OPEN
;
690 sk
->sk_state_change(sk
);
697 read_unlock(&hci_sk_list
.lock
);
703 static struct net_proto_family hci_sock_family_ops
= {
704 .family
= PF_BLUETOOTH
,
705 .owner
= THIS_MODULE
,
706 .create
= hci_sock_create
,
709 static struct notifier_block hci_sock_nblock
= {
710 .notifier_call
= hci_sock_dev_event
713 int __init
hci_sock_init(void)
717 err
= proto_register(&hci_sk_proto
, 0);
721 err
= bt_sock_register(BTPROTO_HCI
, &hci_sock_family_ops
);
725 hci_register_notifier(&hci_sock_nblock
);
727 BT_INFO("HCI socket layer initialized");
732 BT_ERR("HCI socket registration failed");
733 proto_unregister(&hci_sk_proto
);
737 void __exit
hci_sock_cleanup(void)
739 if (bt_sock_unregister(BTPROTO_HCI
) < 0)
740 BT_ERR("HCI socket unregistration failed");
742 hci_unregister_notifier(&hci_sock_nblock
);
744 proto_unregister(&hci_sk_proto
);