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 /* ----- HCI socket interface ----- */
54 static inline int hci_test_bit(int nr
, void *addr
)
56 return *((__u32
*) addr
+ (nr
>> 5)) & ((__u32
) 1 << (nr
& 31));
60 static struct hci_sec_filter hci_sec_filter
= {
64 { 0x1000d9fe, 0x0000b00c },
69 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
71 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
73 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
75 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
76 /* OGF_STATUS_PARAM */
77 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
81 static struct bt_sock_list hci_sk_list
= {
82 .lock
= __RW_LOCK_UNLOCKED(hci_sk_list
.lock
)
85 /* Send frame to RAW socket */
86 void hci_send_to_sock(struct hci_dev
*hdev
, struct sk_buff
*skb
)
89 struct hlist_node
*node
;
91 BT_DBG("hdev %p len %d", hdev
, skb
->len
);
93 read_lock(&hci_sk_list
.lock
);
94 sk_for_each(sk
, node
, &hci_sk_list
.head
) {
95 struct hci_filter
*flt
;
98 if (sk
->sk_state
!= BT_BOUND
|| hci_pi(sk
)->hdev
!= hdev
)
101 /* Don't send frame to the socket it came from */
106 flt
= &hci_pi(sk
)->filter
;
108 if (!test_bit((bt_cb(skb
)->pkt_type
== HCI_VENDOR_PKT
) ?
109 0 : (bt_cb(skb
)->pkt_type
& HCI_FLT_TYPE_BITS
), &flt
->type_mask
))
112 if (bt_cb(skb
)->pkt_type
== HCI_EVENT_PKT
) {
113 register int evt
= (*(__u8
*)skb
->data
& HCI_FLT_EVENT_BITS
);
115 if (!hci_test_bit(evt
, &flt
->event_mask
))
119 ((evt
== HCI_EV_CMD_COMPLETE
&&
121 get_unaligned((__le16
*)(skb
->data
+ 3))) ||
122 (evt
== HCI_EV_CMD_STATUS
&&
124 get_unaligned((__le16
*)(skb
->data
+ 4)))))
128 if (!(nskb
= skb_clone(skb
, GFP_ATOMIC
)))
131 /* Put type byte before the data */
132 memcpy(skb_push(nskb
, 1), &bt_cb(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
;
145 BT_DBG("sock %p sk %p", sock
, sk
);
150 hdev
= hci_pi(sk
)->hdev
;
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
))
181 if (test_bit(HCI_QUIRK_RAW_DEVICE
, &hdev
->quirks
))
185 set_bit(HCI_RAW
, &hdev
->flags
);
187 clear_bit(HCI_RAW
, &hdev
->flags
);
192 return hci_get_conn_info(hdev
, (void __user
*) arg
);
195 return hci_get_auth_info(hdev
, (void __user
*) arg
);
199 return hdev
->ioctl(hdev
, cmd
, arg
);
204 static int hci_sock_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
206 struct sock
*sk
= sock
->sk
;
207 void __user
*argp
= (void __user
*) arg
;
210 BT_DBG("cmd %x arg %lx", cmd
, arg
);
214 return hci_get_dev_list(argp
);
217 return hci_get_dev_info(argp
);
220 return hci_get_conn_list(argp
);
223 if (!capable(CAP_NET_ADMIN
))
225 return hci_dev_open(arg
);
228 if (!capable(CAP_NET_ADMIN
))
230 return hci_dev_close(arg
);
233 if (!capable(CAP_NET_ADMIN
))
235 return hci_dev_reset(arg
);
238 if (!capable(CAP_NET_ADMIN
))
240 return hci_dev_reset_stat(arg
);
250 if (!capable(CAP_NET_ADMIN
))
252 return hci_dev_cmd(cmd
, argp
);
255 return hci_inquiry(argp
);
259 err
= hci_sock_bound_ioctl(sk
, cmd
, arg
);
265 static int hci_sock_bind(struct socket
*sock
, struct sockaddr
*addr
, int addr_len
)
267 struct sockaddr_hci
*haddr
= (struct sockaddr_hci
*) addr
;
268 struct sock
*sk
= sock
->sk
;
269 struct hci_dev
*hdev
= NULL
;
272 BT_DBG("sock %p sk %p", sock
, sk
);
274 if (!haddr
|| haddr
->hci_family
!= AF_BLUETOOTH
)
279 if (hci_pi(sk
)->hdev
) {
284 if (haddr
->hci_dev
!= HCI_DEV_NONE
) {
285 if (!(hdev
= hci_dev_get(haddr
->hci_dev
))) {
290 atomic_inc(&hdev
->promisc
);
293 hci_pi(sk
)->hdev
= hdev
;
294 sk
->sk_state
= BT_BOUND
;
301 static int hci_sock_getname(struct socket
*sock
, struct sockaddr
*addr
, int *addr_len
, int peer
)
303 struct sockaddr_hci
*haddr
= (struct sockaddr_hci
*) addr
;
304 struct sock
*sk
= sock
->sk
;
305 struct hci_dev
*hdev
= hci_pi(sk
)->hdev
;
307 BT_DBG("sock %p sk %p", sock
, sk
);
314 *addr_len
= sizeof(*haddr
);
315 haddr
->hci_family
= AF_BLUETOOTH
;
316 haddr
->hci_dev
= hdev
->id
;
322 static inline void hci_sock_cmsg(struct sock
*sk
, struct msghdr
*msg
, struct sk_buff
*skb
)
324 __u32 mask
= hci_pi(sk
)->cmsg_mask
;
326 if (mask
& HCI_CMSG_DIR
) {
327 int incoming
= bt_cb(skb
)->incoming
;
328 put_cmsg(msg
, SOL_HCI
, HCI_CMSG_DIR
, sizeof(incoming
), &incoming
);
331 if (mask
& HCI_CMSG_TSTAMP
) {
336 skb_get_timestamp(skb
, &tv
);
341 if (msg
->msg_flags
& MSG_CMSG_COMPAT
) {
342 struct compat_timeval ctv
;
343 ctv
.tv_sec
= tv
.tv_sec
;
344 ctv
.tv_usec
= tv
.tv_usec
;
350 put_cmsg(msg
, SOL_HCI
, HCI_CMSG_TSTAMP
, len
, data
);
354 static int hci_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
355 struct msghdr
*msg
, size_t len
, int flags
)
357 int noblock
= flags
& MSG_DONTWAIT
;
358 struct sock
*sk
= sock
->sk
;
362 BT_DBG("sock %p, sk %p", sock
, sk
);
364 if (flags
& (MSG_OOB
))
367 if (sk
->sk_state
== BT_CLOSED
)
370 if (!(skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
)))
373 msg
->msg_namelen
= 0;
377 msg
->msg_flags
|= MSG_TRUNC
;
381 skb_reset_transport_header(skb
);
382 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
384 hci_sock_cmsg(sk
, msg
, skb
);
386 skb_free_datagram(sk
, skb
);
388 return err
? : copied
;
391 static int hci_sock_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
392 struct msghdr
*msg
, size_t len
)
394 struct sock
*sk
= sock
->sk
;
395 struct hci_dev
*hdev
;
399 BT_DBG("sock %p sk %p", sock
, sk
);
401 if (msg
->msg_flags
& MSG_OOB
)
404 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_NOSIGNAL
|MSG_ERRQUEUE
))
407 if (len
< 4 || len
> HCI_MAX_FRAME_SIZE
)
412 if (!(hdev
= hci_pi(sk
)->hdev
)) {
417 if (!(skb
= bt_skb_send_alloc(sk
, len
, msg
->msg_flags
& MSG_DONTWAIT
, &err
)))
420 if (memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
)) {
425 bt_cb(skb
)->pkt_type
= *((unsigned char *) skb
->data
);
427 skb
->dev
= (void *) hdev
;
429 if (bt_cb(skb
)->pkt_type
== HCI_COMMAND_PKT
) {
430 u16 opcode
= get_unaligned_le16(skb
->data
);
431 u16 ogf
= hci_opcode_ogf(opcode
);
432 u16 ocf
= hci_opcode_ocf(opcode
);
434 if (((ogf
> HCI_SFLT_MAX_OGF
) ||
435 !hci_test_bit(ocf
& HCI_FLT_OCF_BITS
, &hci_sec_filter
.ocf_mask
[ogf
])) &&
436 !capable(CAP_NET_RAW
)) {
441 if (test_bit(HCI_RAW
, &hdev
->flags
) || (ogf
== 0x3f)) {
442 skb_queue_tail(&hdev
->raw_q
, skb
);
445 skb_queue_tail(&hdev
->cmd_q
, skb
);
449 if (!capable(CAP_NET_RAW
)) {
454 skb_queue_tail(&hdev
->raw_q
, skb
);
469 static int hci_sock_setsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, unsigned int len
)
471 struct hci_ufilter uf
= { .opcode
= 0 };
472 struct sock
*sk
= sock
->sk
;
473 int err
= 0, opt
= 0;
475 BT_DBG("sk %p, opt %d", sk
, optname
);
481 if (get_user(opt
, (int __user
*)optval
)) {
487 hci_pi(sk
)->cmsg_mask
|= HCI_CMSG_DIR
;
489 hci_pi(sk
)->cmsg_mask
&= ~HCI_CMSG_DIR
;
493 if (get_user(opt
, (int __user
*)optval
)) {
499 hci_pi(sk
)->cmsg_mask
|= HCI_CMSG_TSTAMP
;
501 hci_pi(sk
)->cmsg_mask
&= ~HCI_CMSG_TSTAMP
;
506 struct hci_filter
*f
= &hci_pi(sk
)->filter
;
508 uf
.type_mask
= f
->type_mask
;
509 uf
.opcode
= f
->opcode
;
510 uf
.event_mask
[0] = *((u32
*) f
->event_mask
+ 0);
511 uf
.event_mask
[1] = *((u32
*) f
->event_mask
+ 1);
514 len
= min_t(unsigned int, len
, sizeof(uf
));
515 if (copy_from_user(&uf
, optval
, len
)) {
520 if (!capable(CAP_NET_RAW
)) {
521 uf
.type_mask
&= hci_sec_filter
.type_mask
;
522 uf
.event_mask
[0] &= *((u32
*) hci_sec_filter
.event_mask
+ 0);
523 uf
.event_mask
[1] &= *((u32
*) hci_sec_filter
.event_mask
+ 1);
527 struct hci_filter
*f
= &hci_pi(sk
)->filter
;
529 f
->type_mask
= uf
.type_mask
;
530 f
->opcode
= uf
.opcode
;
531 *((u32
*) f
->event_mask
+ 0) = uf
.event_mask
[0];
532 *((u32
*) f
->event_mask
+ 1) = uf
.event_mask
[1];
545 static int hci_sock_getsockopt(struct socket
*sock
, int level
, int optname
, char __user
*optval
, int __user
*optlen
)
547 struct hci_ufilter uf
;
548 struct sock
*sk
= sock
->sk
;
551 if (get_user(len
, optlen
))
556 if (hci_pi(sk
)->cmsg_mask
& HCI_CMSG_DIR
)
561 if (put_user(opt
, optval
))
566 if (hci_pi(sk
)->cmsg_mask
& HCI_CMSG_TSTAMP
)
571 if (put_user(opt
, optval
))
577 struct hci_filter
*f
= &hci_pi(sk
)->filter
;
579 uf
.type_mask
= f
->type_mask
;
580 uf
.opcode
= f
->opcode
;
581 uf
.event_mask
[0] = *((u32
*) f
->event_mask
+ 0);
582 uf
.event_mask
[1] = *((u32
*) f
->event_mask
+ 1);
585 len
= min_t(unsigned int, len
, sizeof(uf
));
586 if (copy_to_user(optval
, &uf
, len
))
598 static const struct proto_ops hci_sock_ops
= {
599 .family
= PF_BLUETOOTH
,
600 .owner
= THIS_MODULE
,
601 .release
= hci_sock_release
,
602 .bind
= hci_sock_bind
,
603 .getname
= hci_sock_getname
,
604 .sendmsg
= hci_sock_sendmsg
,
605 .recvmsg
= hci_sock_recvmsg
,
606 .ioctl
= hci_sock_ioctl
,
607 .poll
= datagram_poll
,
608 .listen
= sock_no_listen
,
609 .shutdown
= sock_no_shutdown
,
610 .setsockopt
= hci_sock_setsockopt
,
611 .getsockopt
= hci_sock_getsockopt
,
612 .connect
= sock_no_connect
,
613 .socketpair
= sock_no_socketpair
,
614 .accept
= sock_no_accept
,
618 static struct proto hci_sk_proto
= {
620 .owner
= THIS_MODULE
,
621 .obj_size
= sizeof(struct hci_pinfo
)
624 static int hci_sock_create(struct net
*net
, struct socket
*sock
, int protocol
,
629 BT_DBG("sock %p", sock
);
631 if (sock
->type
!= SOCK_RAW
)
632 return -ESOCKTNOSUPPORT
;
634 sock
->ops
= &hci_sock_ops
;
636 sk
= sk_alloc(net
, PF_BLUETOOTH
, GFP_ATOMIC
, &hci_sk_proto
);
640 sock_init_data(sock
, sk
);
642 sock_reset_flag(sk
, SOCK_ZAPPED
);
644 sk
->sk_protocol
= protocol
;
646 sock
->state
= SS_UNCONNECTED
;
647 sk
->sk_state
= BT_OPEN
;
649 bt_sock_link(&hci_sk_list
, sk
);
653 static int hci_sock_dev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
655 struct hci_dev
*hdev
= (struct hci_dev
*) ptr
;
656 struct hci_ev_si_device ev
;
658 BT_DBG("hdev %s event %ld", hdev
->name
, event
);
660 /* Send event to sockets */
662 ev
.dev_id
= hdev
->id
;
663 hci_si_event(NULL
, HCI_EV_SI_DEVICE
, sizeof(ev
), &ev
);
665 if (event
== HCI_DEV_UNREG
) {
667 struct hlist_node
*node
;
669 /* Detach sockets from device */
670 read_lock(&hci_sk_list
.lock
);
671 sk_for_each(sk
, node
, &hci_sk_list
.head
) {
673 bh_lock_sock_nested(sk
);
674 if (hci_pi(sk
)->hdev
== hdev
) {
675 hci_pi(sk
)->hdev
= NULL
;
677 sk
->sk_state
= BT_OPEN
;
678 sk
->sk_state_change(sk
);
685 read_unlock(&hci_sk_list
.lock
);
691 static const struct net_proto_family hci_sock_family_ops
= {
692 .family
= PF_BLUETOOTH
,
693 .owner
= THIS_MODULE
,
694 .create
= hci_sock_create
,
697 static struct notifier_block hci_sock_nblock
= {
698 .notifier_call
= hci_sock_dev_event
701 int __init
hci_sock_init(void)
705 err
= proto_register(&hci_sk_proto
, 0);
709 err
= bt_sock_register(BTPROTO_HCI
, &hci_sock_family_ops
);
713 hci_register_notifier(&hci_sock_nblock
);
715 BT_INFO("HCI socket layer initialized");
720 BT_ERR("HCI socket registration failed");
721 proto_unregister(&hci_sk_proto
);
725 void __exit
hci_sock_cleanup(void)
727 if (bt_sock_unregister(BTPROTO_HCI
) < 0)
728 BT_ERR("HCI socket unregistration failed");
730 hci_unregister_notifier(&hci_sock_nblock
);
732 proto_unregister(&hci_sk_proto
);