2007-02-09 15:24:33 +01:00
|
|
|
/*
|
2005-04-17 00:20:36 +02:00
|
|
|
BlueZ - Bluetooth protocol stack for Linux
|
|
|
|
Copyright (C) 2000-2001 Qualcomm Incorporated
|
|
|
|
|
|
|
|
Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License version 2 as
|
|
|
|
published by the Free Software Foundation;
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
|
|
|
|
IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
|
2007-02-09 15:24:33 +01:00
|
|
|
CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
|
|
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
2005-04-17 00:20:36 +02:00
|
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
|
2007-02-09 15:24:33 +01:00
|
|
|
ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
|
|
|
|
COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
|
2005-04-17 00:20:36 +02:00
|
|
|
SOFTWARE IS DISCLAIMED.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Bluetooth HCI sockets. */
|
|
|
|
|
2012-05-23 09:04:22 +02:00
|
|
|
#include <linux/export.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
|
|
|
#include <net/bluetooth/bluetooth.h>
|
|
|
|
#include <net/bluetooth/hci_core.h>
|
2012-02-20 20:34:38 +01:00
|
|
|
#include <net/bluetooth/hci_mon.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2015-03-06 20:08:50 +01:00
|
|
|
static LIST_HEAD(mgmt_chan_list);
|
|
|
|
static DEFINE_MUTEX(mgmt_chan_list_lock);
|
|
|
|
|
2012-02-20 20:34:38 +01:00
|
|
|
static atomic_t monitor_promisc = ATOMIC_INIT(0);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* ----- HCI socket interface ----- */
|
|
|
|
|
2014-07-11 05:41:00 +02:00
|
|
|
/* Socket info */
|
|
|
|
#define hci_pi(sk) ((struct hci_pinfo *) sk)
|
|
|
|
|
|
|
|
struct hci_pinfo {
|
|
|
|
struct bt_sock bt;
|
|
|
|
struct hci_dev *hdev;
|
|
|
|
struct hci_filter filter;
|
|
|
|
__u32 cmsg_mask;
|
|
|
|
unsigned short channel;
|
2015-03-15 03:27:53 +01:00
|
|
|
unsigned long flags;
|
2014-07-11 05:41:00 +02:00
|
|
|
};
|
|
|
|
|
2015-03-15 03:27:53 +01:00
|
|
|
void hci_sock_set_flag(struct sock *sk, int nr)
|
|
|
|
{
|
|
|
|
set_bit(nr, &hci_pi(sk)->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void hci_sock_clear_flag(struct sock *sk, int nr)
|
|
|
|
{
|
|
|
|
clear_bit(nr, &hci_pi(sk)->flags);
|
|
|
|
}
|
|
|
|
|
2015-03-15 03:28:00 +01:00
|
|
|
int hci_sock_test_flag(struct sock *sk, int nr)
|
|
|
|
{
|
|
|
|
return test_bit(nr, &hci_pi(sk)->flags);
|
|
|
|
}
|
|
|
|
|
2015-02-19 15:20:43 +01:00
|
|
|
static inline int hci_test_bit(int nr, const void *addr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2015-02-19 15:20:43 +01:00
|
|
|
return *((const __u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Security filter */
|
2014-07-11 05:36:39 +02:00
|
|
|
#define HCI_SFLT_MAX_OGF 5
|
|
|
|
|
|
|
|
struct hci_sec_filter {
|
|
|
|
__u32 type_mask;
|
|
|
|
__u32 event_mask[2];
|
|
|
|
__u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
|
|
|
|
};
|
|
|
|
|
2014-07-11 05:36:40 +02:00
|
|
|
static const struct hci_sec_filter hci_sec_filter = {
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Packet types */
|
|
|
|
0x10,
|
|
|
|
/* Events */
|
2005-10-28 19:20:53 +02:00
|
|
|
{ 0x1000d9fe, 0x0000b00c },
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Commands */
|
|
|
|
{
|
|
|
|
{ 0x0 },
|
|
|
|
/* OGF_LINK_CTL */
|
2007-09-09 08:39:43 +02:00
|
|
|
{ 0xbe000006, 0x00000001, 0x00000000, 0x00 },
|
2005-04-17 00:20:36 +02:00
|
|
|
/* OGF_LINK_POLICY */
|
2007-09-09 08:39:43 +02:00
|
|
|
{ 0x00005200, 0x00000000, 0x00000000, 0x00 },
|
2005-04-17 00:20:36 +02:00
|
|
|
/* OGF_HOST_CTL */
|
2007-09-09 08:39:43 +02:00
|
|
|
{ 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
|
2005-04-17 00:20:36 +02:00
|
|
|
/* OGF_INFO_PARAM */
|
2007-09-09 08:39:43 +02:00
|
|
|
{ 0x000002be, 0x00000000, 0x00000000, 0x00 },
|
2005-04-17 00:20:36 +02:00
|
|
|
/* OGF_STATUS_PARAM */
|
2007-09-09 08:39:43 +02:00
|
|
|
{ 0x000000ea, 0x00000000, 0x00000000, 0x00 }
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bt_sock_list hci_sk_list = {
|
2008-03-29 00:17:38 +01:00
|
|
|
.lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2013-08-26 08:25:15 +02:00
|
|
|
static bool is_filtered_packet(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct hci_filter *flt;
|
|
|
|
int flt_type, flt_event;
|
|
|
|
|
|
|
|
/* Apply filter */
|
|
|
|
flt = &hci_pi(sk)->filter;
|
|
|
|
|
|
|
|
if (bt_cb(skb)->pkt_type == HCI_VENDOR_PKT)
|
|
|
|
flt_type = 0;
|
|
|
|
else
|
|
|
|
flt_type = bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS;
|
|
|
|
|
|
|
|
if (!test_bit(flt_type, &flt->type_mask))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Extra filter for event packets only */
|
|
|
|
if (bt_cb(skb)->pkt_type != HCI_EVENT_PKT)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
flt_event = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
|
|
|
|
|
|
|
|
if (!hci_test_bit(flt_event, &flt->event_mask))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Check filter only when opcode is set */
|
|
|
|
if (!flt->opcode)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (flt_event == HCI_EV_CMD_COMPLETE &&
|
|
|
|
flt->opcode != get_unaligned((__le16 *)(skb->data + 3)))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (flt_event == HCI_EV_CMD_STATUS &&
|
|
|
|
flt->opcode != get_unaligned((__le16 *)(skb->data + 4)))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Send frame to RAW socket */
|
2012-02-20 14:50:30 +01:00
|
|
|
void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct sock *sk;
|
2012-02-20 14:50:36 +01:00
|
|
|
struct sk_buff *skb_copy = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
BT_DBG("hdev %p len %d", hdev, skb->len);
|
|
|
|
|
|
|
|
read_lock(&hci_sk_list.lock);
|
2012-02-20 14:50:30 +01:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 02:06:00 +01:00
|
|
|
sk_for_each(sk, &hci_sk_list.head) {
|
2005-04-17 00:20:36 +02:00
|
|
|
struct sk_buff *nskb;
|
|
|
|
|
|
|
|
if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Don't send frame to the socket it came from */
|
|
|
|
if (skb->sk == sk)
|
|
|
|
continue;
|
|
|
|
|
2013-08-27 06:40:52 +02:00
|
|
|
if (hci_pi(sk)->channel == HCI_CHANNEL_RAW) {
|
|
|
|
if (is_filtered_packet(sk, skb))
|
|
|
|
continue;
|
|
|
|
} else if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
|
|
|
|
if (!bt_cb(skb)->incoming)
|
|
|
|
continue;
|
|
|
|
if (bt_cb(skb)->pkt_type != HCI_EVENT_PKT &&
|
|
|
|
bt_cb(skb)->pkt_type != HCI_ACLDATA_PKT &&
|
|
|
|
bt_cb(skb)->pkt_type != HCI_SCODATA_PKT)
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
/* Don't send frame to other channel types */
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
2013-08-27 06:40:52 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-02-20 14:50:36 +01:00
|
|
|
if (!skb_copy) {
|
|
|
|
/* Create a private copy with headroom */
|
2014-06-12 00:36:26 +02:00
|
|
|
skb_copy = __pskb_copy_fclone(skb, 1, GFP_ATOMIC, true);
|
2012-02-20 14:50:36 +01:00
|
|
|
if (!skb_copy)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Put type byte before the data */
|
|
|
|
memcpy(skb_push(skb_copy, 1), &bt_cb(skb)->pkt_type, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
nskb = skb_clone(skb_copy, GFP_ATOMIC);
|
2010-12-01 15:58:25 +01:00
|
|
|
if (!nskb)
|
2005-04-17 00:20:36 +02:00
|
|
|
continue;
|
|
|
|
|
2012-02-20 14:50:30 +01:00
|
|
|
if (sock_queue_rcv_skb(sk, nskb))
|
|
|
|
kfree_skb(nskb);
|
|
|
|
}
|
|
|
|
|
|
|
|
read_unlock(&hci_sk_list.lock);
|
2012-02-20 14:50:36 +01:00
|
|
|
|
|
|
|
kfree_skb(skb_copy);
|
2012-02-20 14:50:30 +01:00
|
|
|
}
|
|
|
|
|
2015-02-20 12:26:23 +01:00
|
|
|
/* Send frame to sockets with specific channel */
|
|
|
|
void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
|
2015-03-15 03:27:59 +01:00
|
|
|
int flag, struct sock *skip_sk)
|
2012-02-20 14:50:30 +01:00
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
|
2015-02-20 12:26:23 +01:00
|
|
|
BT_DBG("channel %u len %d", channel, skb->len);
|
2012-02-20 14:50:30 +01:00
|
|
|
|
|
|
|
read_lock(&hci_sk_list.lock);
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 02:06:00 +01:00
|
|
|
sk_for_each(sk, &hci_sk_list.head) {
|
2012-02-20 14:50:30 +01:00
|
|
|
struct sk_buff *nskb;
|
|
|
|
|
2015-03-15 03:27:59 +01:00
|
|
|
/* Ignore socket without the flag set */
|
2015-03-15 03:28:00 +01:00
|
|
|
if (!hci_sock_test_flag(sk, flag))
|
2015-01-12 04:33:32 +01:00
|
|
|
continue;
|
|
|
|
|
2015-03-15 03:27:59 +01:00
|
|
|
/* Skip the original socket */
|
|
|
|
if (sk == skip_sk)
|
2015-03-15 03:27:54 +01:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sk->sk_state != BT_BOUND)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (hci_pi(sk)->channel != channel)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
nskb = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (!nskb)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sock_queue_rcv_skb(sk, nskb))
|
|
|
|
kfree_skb(nskb);
|
|
|
|
}
|
|
|
|
|
|
|
|
read_unlock(&hci_sk_list.lock);
|
|
|
|
}
|
|
|
|
|
2012-02-20 20:34:38 +01:00
|
|
|
/* Send frame to monitor socket */
|
|
|
|
void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb_copy = NULL;
|
2015-01-12 04:33:31 +01:00
|
|
|
struct hci_mon_hdr *hdr;
|
2012-02-20 20:34:38 +01:00
|
|
|
__le16 opcode;
|
|
|
|
|
|
|
|
if (!atomic_read(&monitor_promisc))
|
|
|
|
return;
|
|
|
|
|
|
|
|
BT_DBG("hdev %p len %d", hdev, skb->len);
|
|
|
|
|
|
|
|
switch (bt_cb(skb)->pkt_type) {
|
|
|
|
case HCI_COMMAND_PKT:
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_COMMAND_PKT);
|
2012-02-20 20:34:38 +01:00
|
|
|
break;
|
|
|
|
case HCI_EVENT_PKT:
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_EVENT_PKT);
|
2012-02-20 20:34:38 +01:00
|
|
|
break;
|
|
|
|
case HCI_ACLDATA_PKT:
|
|
|
|
if (bt_cb(skb)->incoming)
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_ACL_RX_PKT);
|
2012-02-20 20:34:38 +01:00
|
|
|
else
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_ACL_TX_PKT);
|
2012-02-20 20:34:38 +01:00
|
|
|
break;
|
|
|
|
case HCI_SCODATA_PKT:
|
|
|
|
if (bt_cb(skb)->incoming)
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_SCO_RX_PKT);
|
2012-02-20 20:34:38 +01:00
|
|
|
else
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_SCO_TX_PKT);
|
2012-02-20 20:34:38 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-12 04:33:31 +01:00
|
|
|
/* Create a private copy with headroom */
|
|
|
|
skb_copy = __pskb_copy_fclone(skb, HCI_MON_HDR_SIZE, GFP_ATOMIC, true);
|
|
|
|
if (!skb_copy)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Put header before the data */
|
|
|
|
hdr = (void *) skb_push(skb_copy, HCI_MON_HDR_SIZE);
|
|
|
|
hdr->opcode = opcode;
|
|
|
|
hdr->index = cpu_to_le16(hdev->id);
|
|
|
|
hdr->len = cpu_to_le16(skb->len);
|
|
|
|
|
2015-03-15 03:27:59 +01:00
|
|
|
hci_send_to_channel(HCI_CHANNEL_MONITOR, skb_copy,
|
|
|
|
HCI_SOCK_TRUSTED, NULL);
|
2012-02-20 20:34:38 +01:00
|
|
|
kfree_skb(skb_copy);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct sk_buff *create_monitor_event(struct hci_dev *hdev, int event)
|
|
|
|
{
|
|
|
|
struct hci_mon_hdr *hdr;
|
|
|
|
struct hci_mon_new_index *ni;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
__le16 opcode;
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case HCI_DEV_REG:
|
|
|
|
skb = bt_skb_alloc(HCI_MON_NEW_INDEX_SIZE, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ni = (void *) skb_put(skb, HCI_MON_NEW_INDEX_SIZE);
|
|
|
|
ni->type = hdev->dev_type;
|
|
|
|
ni->bus = hdev->bus;
|
|
|
|
bacpy(&ni->bdaddr, &hdev->bdaddr);
|
|
|
|
memcpy(ni->name, hdev->name, 8);
|
|
|
|
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_NEW_INDEX);
|
2012-02-20 20:34:38 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HCI_DEV_UNREG:
|
|
|
|
skb = bt_skb_alloc(0, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
|
|
return NULL;
|
|
|
|
|
2014-03-12 18:52:35 +01:00
|
|
|
opcode = cpu_to_le16(HCI_MON_DEL_INDEX);
|
2012-02-20 20:34:38 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
__net_timestamp(skb);
|
|
|
|
|
|
|
|
hdr = (void *) skb_push(skb, HCI_MON_HDR_SIZE);
|
|
|
|
hdr->opcode = opcode;
|
|
|
|
hdr->index = cpu_to_le16(hdev->id);
|
|
|
|
hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
|
|
|
|
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void send_monitor_replay(struct sock *sk)
|
|
|
|
{
|
|
|
|
struct hci_dev *hdev;
|
|
|
|
|
|
|
|
read_lock(&hci_dev_list_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(hdev, &hci_dev_list, list) {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
skb = create_monitor_event(hdev, HCI_DEV_REG);
|
|
|
|
if (!skb)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sock_queue_rcv_skb(sk, skb))
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
read_unlock(&hci_dev_list_lock);
|
|
|
|
}
|
|
|
|
|
2012-02-20 14:50:37 +01:00
|
|
|
/* Generate internal stack event */
|
|
|
|
static void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
|
|
|
|
{
|
|
|
|
struct hci_event_hdr *hdr;
|
|
|
|
struct hci_ev_stack_internal *ev;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
|
|
|
|
hdr->evt = HCI_EV_STACK_INTERNAL;
|
|
|
|
hdr->plen = sizeof(*ev) + dlen;
|
|
|
|
|
|
|
|
ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
|
|
|
|
ev->type = type;
|
|
|
|
memcpy(ev->data, data, dlen);
|
|
|
|
|
|
|
|
bt_cb(skb)->incoming = 1;
|
|
|
|
__net_timestamp(skb);
|
|
|
|
|
|
|
|
bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
|
|
|
|
hci_send_to_sock(hdev, skb);
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
void hci_sock_dev_event(struct hci_dev *hdev, int event)
|
|
|
|
{
|
|
|
|
struct hci_ev_si_device ev;
|
|
|
|
|
|
|
|
BT_DBG("hdev %s event %d", hdev->name, event);
|
|
|
|
|
2012-02-20 20:34:38 +01:00
|
|
|
/* Send event to monitor */
|
|
|
|
if (atomic_read(&monitor_promisc)) {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
skb = create_monitor_event(hdev, event);
|
|
|
|
if (skb) {
|
2015-03-15 03:27:59 +01:00
|
|
|
hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
|
|
|
|
HCI_SOCK_TRUSTED, NULL);
|
2012-02-20 20:34:38 +01:00
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-20 14:50:37 +01:00
|
|
|
/* Send event to sockets */
|
|
|
|
ev.event = event;
|
|
|
|
ev.dev_id = hdev->id;
|
|
|
|
hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
|
|
|
|
|
|
|
|
if (event == HCI_DEV_UNREG) {
|
|
|
|
struct sock *sk;
|
|
|
|
|
|
|
|
/* Detach sockets from device */
|
|
|
|
read_lock(&hci_sk_list.lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 02:06:00 +01:00
|
|
|
sk_for_each(sk, &hci_sk_list.head) {
|
2012-02-20 14:50:37 +01:00
|
|
|
bh_lock_sock_nested(sk);
|
|
|
|
if (hci_pi(sk)->hdev == hdev) {
|
|
|
|
hci_pi(sk)->hdev = NULL;
|
|
|
|
sk->sk_err = EPIPE;
|
|
|
|
sk->sk_state = BT_OPEN;
|
|
|
|
sk->sk_state_change(sk);
|
|
|
|
|
|
|
|
hci_dev_put(hdev);
|
|
|
|
}
|
|
|
|
bh_unlock_sock(sk);
|
|
|
|
}
|
|
|
|
read_unlock(&hci_sk_list.lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-06 20:08:50 +01:00
|
|
|
static struct hci_mgmt_chan *__hci_mgmt_chan_find(unsigned short channel)
|
|
|
|
{
|
|
|
|
struct hci_mgmt_chan *c;
|
|
|
|
|
|
|
|
list_for_each_entry(c, &mgmt_chan_list, list) {
|
|
|
|
if (c->channel == channel)
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct hci_mgmt_chan *hci_mgmt_chan_find(unsigned short channel)
|
|
|
|
{
|
|
|
|
struct hci_mgmt_chan *c;
|
|
|
|
|
|
|
|
mutex_lock(&mgmt_chan_list_lock);
|
|
|
|
c = __hci_mgmt_chan_find(channel);
|
|
|
|
mutex_unlock(&mgmt_chan_list_lock);
|
|
|
|
|
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
int hci_mgmt_chan_register(struct hci_mgmt_chan *c)
|
|
|
|
{
|
|
|
|
if (c->channel < HCI_CHANNEL_CONTROL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&mgmt_chan_list_lock);
|
|
|
|
if (__hci_mgmt_chan_find(c->channel)) {
|
|
|
|
mutex_unlock(&mgmt_chan_list_lock);
|
|
|
|
return -EALREADY;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&c->list, &mgmt_chan_list);
|
|
|
|
|
|
|
|
mutex_unlock(&mgmt_chan_list_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(hci_mgmt_chan_register);
|
|
|
|
|
|
|
|
void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c)
|
|
|
|
{
|
|
|
|
mutex_lock(&mgmt_chan_list_lock);
|
|
|
|
list_del(&c->list);
|
|
|
|
mutex_unlock(&mgmt_chan_list_lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(hci_mgmt_chan_unregister);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int hci_sock_release(struct socket *sock)
|
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
2006-02-13 11:40:03 +01:00
|
|
|
struct hci_dev *hdev;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
BT_DBG("sock %p sk %p", sock, sk);
|
|
|
|
|
|
|
|
if (!sk)
|
|
|
|
return 0;
|
|
|
|
|
2006-02-13 11:40:03 +01:00
|
|
|
hdev = hci_pi(sk)->hdev;
|
|
|
|
|
2012-02-20 20:34:38 +01:00
|
|
|
if (hci_pi(sk)->channel == HCI_CHANNEL_MONITOR)
|
|
|
|
atomic_dec(&monitor_promisc);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
bt_sock_unlink(&hci_sk_list, sk);
|
|
|
|
|
|
|
|
if (hdev) {
|
2013-08-27 06:40:52 +02:00
|
|
|
if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
|
2014-07-02 21:30:54 +02:00
|
|
|
mgmt_index_added(hdev);
|
2015-03-13 10:11:02 +01:00
|
|
|
hci_dev_clear_flag(hdev, HCI_USER_CHANNEL);
|
2013-08-27 06:40:52 +02:00
|
|
|
hci_dev_close(hdev->id);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
atomic_dec(&hdev->promisc);
|
|
|
|
hci_dev_put(hdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
sock_orphan(sk);
|
|
|
|
|
|
|
|
skb_queue_purge(&sk->sk_receive_queue);
|
|
|
|
skb_queue_purge(&sk->sk_write_queue);
|
|
|
|
|
|
|
|
sock_put(sk);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-15 11:01:14 +02:00
|
|
|
static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
|
2010-05-18 13:20:32 +02:00
|
|
|
{
|
|
|
|
bdaddr_t bdaddr;
|
2011-08-25 15:48:02 +02:00
|
|
|
int err;
|
2010-05-18 13:20:32 +02:00
|
|
|
|
|
|
|
if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2011-06-17 18:03:21 +02:00
|
|
|
hci_dev_lock(hdev);
|
2011-08-25 15:48:02 +02:00
|
|
|
|
2014-07-09 11:59:13 +02:00
|
|
|
err = hci_bdaddr_list_add(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
|
2011-08-25 15:48:02 +02:00
|
|
|
|
2011-06-17 18:03:21 +02:00
|
|
|
hci_dev_unlock(hdev);
|
2011-08-25 15:48:02 +02:00
|
|
|
|
|
|
|
return err;
|
2010-05-18 13:20:32 +02:00
|
|
|
}
|
|
|
|
|
2011-06-15 11:01:14 +02:00
|
|
|
static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg)
|
2010-05-18 13:20:32 +02:00
|
|
|
{
|
|
|
|
bdaddr_t bdaddr;
|
2011-08-25 15:48:02 +02:00
|
|
|
int err;
|
2010-05-18 13:20:32 +02:00
|
|
|
|
|
|
|
if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2011-06-17 18:03:21 +02:00
|
|
|
hci_dev_lock(hdev);
|
2011-08-25 15:48:02 +02:00
|
|
|
|
2014-07-09 11:59:13 +02:00
|
|
|
err = hci_bdaddr_list_del(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
|
2011-08-25 15:48:02 +02:00
|
|
|
|
2011-06-17 18:03:21 +02:00
|
|
|
hci_dev_unlock(hdev);
|
2011-08-25 15:48:02 +02:00
|
|
|
|
|
|
|
return err;
|
2010-05-18 13:20:32 +02:00
|
|
|
}
|
|
|
|
|
2007-02-09 15:24:33 +01:00
|
|
|
/* Ioctls that require bound socket */
|
2012-05-23 09:04:18 +02:00
|
|
|
static int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct hci_dev *hdev = hci_pi(sk)->hdev;
|
|
|
|
|
|
|
|
if (!hdev)
|
|
|
|
return -EBADFD;
|
|
|
|
|
2015-03-13 10:11:00 +01:00
|
|
|
if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL))
|
2013-08-27 06:40:51 +02:00
|
|
|
return -EBUSY;
|
|
|
|
|
2015-03-13 10:11:00 +01:00
|
|
|
if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED))
|
2014-06-29 12:13:05 +02:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2013-10-10 19:02:08 +02:00
|
|
|
if (hdev->dev_type != HCI_BREDR)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (cmd) {
|
|
|
|
case HCISETRAW:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2014-04-17 05:04:38 +02:00
|
|
|
return -EOPNOTSUPP;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
case HCIGETCONNINFO:
|
2008-07-14 20:13:50 +02:00
|
|
|
return hci_get_conn_info(hdev, (void __user *) arg);
|
|
|
|
|
|
|
|
case HCIGETAUTHINFO:
|
|
|
|
return hci_get_auth_info(hdev, (void __user *) arg);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-05-18 13:20:32 +02:00
|
|
|
case HCIBLOCKADDR:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2011-06-15 11:01:14 +02:00
|
|
|
return hci_sock_blacklist_add(hdev, (void __user *) arg);
|
2010-05-18 13:20:32 +02:00
|
|
|
|
|
|
|
case HCIUNBLOCKADDR:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2011-06-15 11:01:14 +02:00
|
|
|
return hci_sock_blacklist_del(hdev, (void __user *) arg);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2013-08-27 06:40:51 +02:00
|
|
|
|
2013-10-10 19:50:06 +02:00
|
|
|
return -ENOIOCTLCMD;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2012-05-23 09:04:21 +02:00
|
|
|
static int hci_sock_ioctl(struct socket *sock, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-07-14 20:13:50 +02:00
|
|
|
void __user *argp = (void __user *) arg;
|
2013-08-27 06:40:51 +02:00
|
|
|
struct sock *sk = sock->sk;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err;
|
|
|
|
|
|
|
|
BT_DBG("cmd %x arg %lx", cmd, arg);
|
|
|
|
|
2013-08-26 18:39:55 +02:00
|
|
|
lock_sock(sk);
|
|
|
|
|
|
|
|
if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
|
|
|
|
err = -EBADFD;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
release_sock(sk);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (cmd) {
|
|
|
|
case HCIGETDEVLIST:
|
|
|
|
return hci_get_dev_list(argp);
|
|
|
|
|
|
|
|
case HCIGETDEVINFO:
|
|
|
|
return hci_get_dev_info(argp);
|
|
|
|
|
|
|
|
case HCIGETCONNLIST:
|
|
|
|
return hci_get_conn_list(argp);
|
|
|
|
|
|
|
|
case HCIDEVUP:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2005-04-17 00:20:36 +02:00
|
|
|
return hci_dev_open(arg);
|
|
|
|
|
|
|
|
case HCIDEVDOWN:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2005-04-17 00:20:36 +02:00
|
|
|
return hci_dev_close(arg);
|
|
|
|
|
|
|
|
case HCIDEVRESET:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2005-04-17 00:20:36 +02:00
|
|
|
return hci_dev_reset(arg);
|
|
|
|
|
|
|
|
case HCIDEVRESTAT:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2005-04-17 00:20:36 +02:00
|
|
|
return hci_dev_reset_stat(arg);
|
|
|
|
|
|
|
|
case HCISETSCAN:
|
|
|
|
case HCISETAUTH:
|
|
|
|
case HCISETENCRYPT:
|
|
|
|
case HCISETPTYPE:
|
|
|
|
case HCISETLINKPOL:
|
|
|
|
case HCISETLINKMODE:
|
|
|
|
case HCISETACLMTU:
|
|
|
|
case HCISETSCOMTU:
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
2012-09-21 00:37:25 +02:00
|
|
|
return -EPERM;
|
2005-04-17 00:20:36 +02:00
|
|
|
return hci_dev_cmd(cmd, argp);
|
|
|
|
|
|
|
|
case HCIINQUIRY:
|
|
|
|
return hci_inquiry(argp);
|
|
|
|
}
|
2013-08-26 18:39:55 +02:00
|
|
|
|
|
|
|
lock_sock(sk);
|
|
|
|
|
|
|
|
err = hci_sock_bound_ioctl(sk, cmd, arg);
|
|
|
|
|
|
|
|
done:
|
|
|
|
release_sock(sk);
|
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2012-05-23 09:04:21 +02:00
|
|
|
static int hci_sock_bind(struct socket *sock, struct sockaddr *addr,
|
|
|
|
int addr_len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-12-07 23:21:06 +01:00
|
|
|
struct sockaddr_hci haddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct hci_dev *hdev = NULL;
|
2010-12-07 23:21:06 +01:00
|
|
|
int len, err = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
BT_DBG("sock %p sk %p", sock, sk);
|
|
|
|
|
2010-12-07 23:21:06 +01:00
|
|
|
if (!addr)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
memset(&haddr, 0, sizeof(haddr));
|
|
|
|
len = min_t(unsigned int, sizeof(haddr), addr_len);
|
|
|
|
memcpy(&haddr, addr, len);
|
|
|
|
|
|
|
|
if (haddr.hci_family != AF_BLUETOOTH)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
lock_sock(sk);
|
|
|
|
|
2012-02-20 14:50:35 +01:00
|
|
|
if (sk->sk_state == BT_BOUND) {
|
2005-04-17 00:20:36 +02:00
|
|
|
err = -EALREADY;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2012-02-20 14:50:35 +01:00
|
|
|
switch (haddr.hci_channel) {
|
|
|
|
case HCI_CHANNEL_RAW:
|
|
|
|
if (hci_pi(sk)->hdev) {
|
|
|
|
err = -EALREADY;
|
2005-04-17 00:20:36 +02:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2012-02-20 14:50:35 +01:00
|
|
|
if (haddr.hci_dev != HCI_DEV_NONE) {
|
|
|
|
hdev = hci_dev_get(haddr.hci_dev);
|
|
|
|
if (!hdev) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_inc(&hdev->promisc);
|
|
|
|
}
|
|
|
|
|
|
|
|
hci_pi(sk)->hdev = hdev;
|
|
|
|
break;
|
|
|
|
|
2013-08-27 06:40:52 +02:00
|
|
|
case HCI_CHANNEL_USER:
|
|
|
|
if (hci_pi(sk)->hdev) {
|
|
|
|
err = -EALREADY;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (haddr.hci_dev == HCI_DEV_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2013-10-02 07:59:24 +02:00
|
|
|
if (!capable(CAP_NET_ADMIN)) {
|
2013-08-27 06:40:52 +02:00
|
|
|
err = -EPERM;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
hdev = hci_dev_get(haddr.hci_dev);
|
|
|
|
if (!hdev) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_bit(HCI_UP, &hdev->flags) ||
|
|
|
|
test_bit(HCI_INIT, &hdev->flags) ||
|
2015-03-13 10:11:00 +01:00
|
|
|
hci_dev_test_flag(hdev, HCI_SETUP) ||
|
|
|
|
hci_dev_test_flag(hdev, HCI_CONFIG)) {
|
2013-08-27 06:40:52 +02:00
|
|
|
err = -EBUSY;
|
|
|
|
hci_dev_put(hdev);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2015-03-13 10:11:06 +01:00
|
|
|
if (hci_dev_test_and_set_flag(hdev, HCI_USER_CHANNEL)) {
|
2013-08-27 06:40:52 +02:00
|
|
|
err = -EUSERS;
|
|
|
|
hci_dev_put(hdev);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2014-07-02 21:30:54 +02:00
|
|
|
mgmt_index_removed(hdev);
|
2013-08-27 06:40:52 +02:00
|
|
|
|
|
|
|
err = hci_dev_open(hdev->id);
|
|
|
|
if (err) {
|
2015-03-13 10:11:02 +01:00
|
|
|
hci_dev_clear_flag(hdev, HCI_USER_CHANNEL);
|
2014-07-02 21:30:54 +02:00
|
|
|
mgmt_index_added(hdev);
|
2013-08-27 06:40:52 +02:00
|
|
|
hci_dev_put(hdev);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
atomic_inc(&hdev->promisc);
|
|
|
|
|
|
|
|
hci_pi(sk)->hdev = hdev;
|
|
|
|
break;
|
|
|
|
|
2012-02-20 20:34:38 +01:00
|
|
|
case HCI_CHANNEL_MONITOR:
|
|
|
|
if (haddr.hci_dev != HCI_DEV_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!capable(CAP_NET_RAW)) {
|
|
|
|
err = -EPERM;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2015-03-15 03:27:58 +01:00
|
|
|
/* The monitor interface is restricted to CAP_NET_RAW
|
|
|
|
* capabilities and with that implicitly trusted.
|
|
|
|
*/
|
|
|
|
hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
|
|
|
|
|
2012-02-20 20:34:38 +01:00
|
|
|
send_monitor_replay(sk);
|
|
|
|
|
|
|
|
atomic_inc(&monitor_promisc);
|
|
|
|
break;
|
|
|
|
|
2012-02-20 14:50:35 +01:00
|
|
|
default:
|
2015-03-06 20:08:50 +01:00
|
|
|
if (!hci_mgmt_chan_find(haddr.hci_channel)) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (haddr.hci_dev != HCI_DEV_NONE) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2015-03-15 03:28:04 +01:00
|
|
|
/* Users with CAP_NET_ADMIN capabilities are allowed
|
|
|
|
* access to all management commands and events. For
|
|
|
|
* untrusted users the interface is restricted and
|
|
|
|
* also only untrusted events are sent.
|
2015-03-15 03:27:58 +01:00
|
|
|
*/
|
2015-03-15 03:28:04 +01:00
|
|
|
if (capable(CAP_NET_ADMIN))
|
|
|
|
hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
|
2015-03-15 03:27:58 +01:00
|
|
|
|
2015-03-15 03:27:55 +01:00
|
|
|
/* At the moment the index and unconfigured index events
|
|
|
|
* are enabled unconditionally. Setting them on each
|
|
|
|
* socket when binding keeps this functionality. They
|
|
|
|
* however might be cleared later and then sending of these
|
|
|
|
* events will be disabled, but that is then intentional.
|
|
|
|
*/
|
|
|
|
if (haddr.hci_channel == HCI_CHANNEL_CONTROL) {
|
|
|
|
hci_sock_set_flag(sk, HCI_MGMT_INDEX_EVENTS);
|
|
|
|
hci_sock_set_flag(sk, HCI_MGMT_UNCONF_INDEX_EVENTS);
|
|
|
|
}
|
2015-03-06 20:08:50 +01:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2012-02-20 14:50:35 +01:00
|
|
|
|
2010-12-07 23:21:06 +01:00
|
|
|
hci_pi(sk)->channel = haddr.hci_channel;
|
2005-04-17 00:20:36 +02:00
|
|
|
sk->sk_state = BT_BOUND;
|
|
|
|
|
|
|
|
done:
|
|
|
|
release_sock(sk);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-05-23 09:04:21 +02:00
|
|
|
static int hci_sock_getname(struct socket *sock, struct sockaddr *addr,
|
|
|
|
int *addr_len, int peer)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
|
|
|
|
struct sock *sk = sock->sk;
|
2013-08-26 09:20:37 +02:00
|
|
|
struct hci_dev *hdev;
|
|
|
|
int err = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
BT_DBG("sock %p sk %p", sock, sk);
|
|
|
|
|
2013-08-26 09:06:30 +02:00
|
|
|
if (peer)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
lock_sock(sk);
|
|
|
|
|
2013-08-26 09:20:37 +02:00
|
|
|
hdev = hci_pi(sk)->hdev;
|
|
|
|
if (!hdev) {
|
|
|
|
err = -EBADFD;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
*addr_len = sizeof(*haddr);
|
|
|
|
haddr->hci_family = AF_BLUETOOTH;
|
2006-02-13 11:40:03 +01:00
|
|
|
haddr->hci_dev = hdev->id;
|
2013-08-26 09:20:37 +02:00
|
|
|
haddr->hci_channel= hci_pi(sk)->channel;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2013-08-26 09:20:37 +02:00
|
|
|
done:
|
2005-04-17 00:20:36 +02:00
|
|
|
release_sock(sk);
|
2013-08-26 09:20:37 +02:00
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2012-05-23 09:04:18 +02:00
|
|
|
static void hci_sock_cmsg(struct sock *sk, struct msghdr *msg,
|
|
|
|
struct sk_buff *skb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
__u32 mask = hci_pi(sk)->cmsg_mask;
|
|
|
|
|
2005-08-10 05:30:28 +02:00
|
|
|
if (mask & HCI_CMSG_DIR) {
|
|
|
|
int incoming = bt_cb(skb)->incoming;
|
2012-05-23 09:04:21 +02:00
|
|
|
put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming),
|
|
|
|
&incoming);
|
2005-08-10 05:30:28 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-08-15 02:24:31 +02:00
|
|
|
if (mask & HCI_CMSG_TSTAMP) {
|
2010-02-15 22:23:48 +01:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
struct compat_timeval ctv;
|
|
|
|
#endif
|
2005-08-15 02:24:31 +02:00
|
|
|
struct timeval tv;
|
2007-09-09 08:39:34 +02:00
|
|
|
void *data;
|
|
|
|
int len;
|
2005-08-15 02:24:31 +02:00
|
|
|
|
|
|
|
skb_get_timestamp(skb, &tv);
|
2007-09-09 08:39:34 +02:00
|
|
|
|
2007-09-12 14:10:58 +02:00
|
|
|
data = &tv;
|
|
|
|
len = sizeof(tv);
|
|
|
|
#ifdef CONFIG_COMPAT
|
2012-02-10 23:12:15 +01:00
|
|
|
if (!COMPAT_USE_64BIT_TIME &&
|
|
|
|
(msg->msg_flags & MSG_CMSG_COMPAT)) {
|
2007-09-09 08:39:34 +02:00
|
|
|
ctv.tv_sec = tv.tv_sec;
|
|
|
|
ctv.tv_usec = tv.tv_usec;
|
|
|
|
data = &ctv;
|
|
|
|
len = sizeof(ctv);
|
|
|
|
}
|
2007-09-12 14:10:58 +02:00
|
|
|
#endif
|
2007-09-09 08:39:34 +02:00
|
|
|
|
|
|
|
put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
|
2005-08-15 02:24:31 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-02-09 15:24:33 +01:00
|
|
|
|
2015-03-02 08:37:48 +01:00
|
|
|
static int hci_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
|
|
|
|
int flags)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int noblock = flags & MSG_DONTWAIT;
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int copied, err;
|
|
|
|
|
|
|
|
BT_DBG("sock %p, sk %p", sock, sk);
|
|
|
|
|
|
|
|
if (flags & (MSG_OOB))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (sk->sk_state == BT_CLOSED)
|
|
|
|
return 0;
|
|
|
|
|
2010-12-01 15:58:25 +01:00
|
|
|
skb = skb_recv_datagram(sk, flags, noblock, &err);
|
|
|
|
if (!skb)
|
2005-04-17 00:20:36 +02:00
|
|
|
return err;
|
|
|
|
|
|
|
|
copied = skb->len;
|
|
|
|
if (len < copied) {
|
|
|
|
msg->msg_flags |= MSG_TRUNC;
|
|
|
|
copied = len;
|
|
|
|
}
|
|
|
|
|
2007-03-13 17:06:52 +01:00
|
|
|
skb_reset_transport_header(skb);
|
2014-11-05 22:46:40 +01:00
|
|
|
err = skb_copy_datagram_msg(skb, 0, msg, copied);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-02-20 14:50:34 +01:00
|
|
|
switch (hci_pi(sk)->channel) {
|
|
|
|
case HCI_CHANNEL_RAW:
|
|
|
|
hci_sock_cmsg(sk, msg, skb);
|
|
|
|
break;
|
2013-08-27 06:40:52 +02:00
|
|
|
case HCI_CHANNEL_USER:
|
2012-02-20 20:34:38 +01:00
|
|
|
case HCI_CHANNEL_MONITOR:
|
|
|
|
sock_recv_timestamp(msg, sk, skb);
|
|
|
|
break;
|
2015-03-06 20:08:50 +01:00
|
|
|
default:
|
|
|
|
if (hci_mgmt_chan_find(hci_pi(sk)->channel))
|
|
|
|
sock_recv_timestamp(msg, sk, skb);
|
|
|
|
break;
|
2012-02-20 14:50:34 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
skb_free_datagram(sk, skb);
|
|
|
|
|
|
|
|
return err ? : copied;
|
|
|
|
}
|
|
|
|
|
2015-03-02 08:37:48 +01:00
|
|
|
static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg,
|
|
|
|
size_t len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct sock *sk = sock->sk;
|
2015-03-06 20:08:50 +01:00
|
|
|
struct hci_mgmt_chan *chan;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct hci_dev *hdev;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
BT_DBG("sock %p sk %p", sock, sk);
|
|
|
|
|
|
|
|
if (msg->msg_flags & MSG_OOB)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (len < 4 || len > HCI_MAX_FRAME_SIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
lock_sock(sk);
|
|
|
|
|
2010-12-07 23:21:06 +01:00
|
|
|
switch (hci_pi(sk)->channel) {
|
|
|
|
case HCI_CHANNEL_RAW:
|
2013-08-27 06:40:52 +02:00
|
|
|
case HCI_CHANNEL_USER:
|
2010-12-07 23:21:06 +01:00
|
|
|
break;
|
2012-02-20 20:34:38 +01:00
|
|
|
case HCI_CHANNEL_MONITOR:
|
|
|
|
err = -EOPNOTSUPP;
|
|
|
|
goto done;
|
2010-12-07 23:21:06 +01:00
|
|
|
default:
|
2015-03-06 20:08:50 +01:00
|
|
|
mutex_lock(&mgmt_chan_list_lock);
|
|
|
|
chan = __hci_mgmt_chan_find(hci_pi(sk)->channel);
|
|
|
|
if (chan)
|
2015-03-06 20:08:51 +01:00
|
|
|
err = mgmt_control(chan, sk, msg, len);
|
2015-03-06 20:08:50 +01:00
|
|
|
else
|
|
|
|
err = -EINVAL;
|
|
|
|
|
|
|
|
mutex_unlock(&mgmt_chan_list_lock);
|
2010-12-07 23:21:06 +01:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2010-12-01 15:58:25 +01:00
|
|
|
hdev = hci_pi(sk)->hdev;
|
|
|
|
if (!hdev) {
|
2005-04-17 00:20:36 +02:00
|
|
|
err = -EBADFD;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2009-11-18 01:05:00 +01:00
|
|
|
if (!test_bit(HCI_UP, &hdev->flags)) {
|
|
|
|
err = -ENETDOWN;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2010-12-01 15:58:25 +01:00
|
|
|
skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
|
|
|
|
if (!skb)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto done;
|
|
|
|
|
2014-04-07 03:25:44 +02:00
|
|
|
if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
err = -EFAULT;
|
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
|
2005-08-10 05:30:28 +02:00
|
|
|
bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
|
2005-04-17 00:20:36 +02:00
|
|
|
skb_pull(skb, 1);
|
|
|
|
|
2013-12-17 12:21:25 +01:00
|
|
|
if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
|
|
|
|
/* No permission check is needed for user channel
|
|
|
|
* since that gets enforced when binding the socket.
|
|
|
|
*
|
|
|
|
* However check that the packet type is valid.
|
|
|
|
*/
|
|
|
|
if (bt_cb(skb)->pkt_type != HCI_COMMAND_PKT &&
|
|
|
|
bt_cb(skb)->pkt_type != HCI_ACLDATA_PKT &&
|
|
|
|
bt_cb(skb)->pkt_type != HCI_SCODATA_PKT) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb_queue_tail(&hdev->raw_q, skb);
|
|
|
|
queue_work(hdev->workqueue, &hdev->tx_work);
|
|
|
|
} else if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
|
2008-05-03 01:25:46 +02:00
|
|
|
u16 opcode = get_unaligned_le16(skb->data);
|
2005-04-17 00:20:36 +02:00
|
|
|
u16 ogf = hci_opcode_ogf(opcode);
|
|
|
|
u16 ocf = hci_opcode_ocf(opcode);
|
|
|
|
|
|
|
|
if (((ogf > HCI_SFLT_MAX_OGF) ||
|
2012-05-17 05:36:22 +02:00
|
|
|
!hci_test_bit(ocf & HCI_FLT_OCF_BITS,
|
|
|
|
&hci_sec_filter.ocf_mask[ogf])) &&
|
|
|
|
!capable(CAP_NET_RAW)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
err = -EPERM;
|
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
|
2014-06-29 12:13:05 +02:00
|
|
|
if (ogf == 0x3f) {
|
2005-04-17 00:20:36 +02:00
|
|
|
skb_queue_tail(&hdev->raw_q, skb);
|
2011-12-15 03:50:02 +01:00
|
|
|
queue_work(hdev->workqueue, &hdev->tx_work);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
2014-10-28 05:12:20 +01:00
|
|
|
/* Stand-alone HCI commands must be flagged as
|
2013-03-05 19:37:47 +01:00
|
|
|
* single-command requests.
|
|
|
|
*/
|
2015-03-01 13:58:26 +01:00
|
|
|
bt_cb(skb)->req_start = 1;
|
2013-03-05 19:37:47 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
skb_queue_tail(&hdev->cmd_q, skb);
|
2011-12-15 02:53:47 +01:00
|
|
|
queue_work(hdev->workqueue, &hdev->cmd_work);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!capable(CAP_NET_RAW)) {
|
|
|
|
err = -EPERM;
|
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb_queue_tail(&hdev->raw_q, skb);
|
2011-12-15 03:50:02 +01:00
|
|
|
queue_work(hdev->workqueue, &hdev->tx_work);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
err = len;
|
|
|
|
|
|
|
|
done:
|
|
|
|
release_sock(sk);
|
|
|
|
return err;
|
|
|
|
|
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2012-05-23 09:04:21 +02:00
|
|
|
static int hci_sock_setsockopt(struct socket *sock, int level, int optname,
|
|
|
|
char __user *optval, unsigned int len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct hci_ufilter uf = { .opcode = 0 };
|
|
|
|
struct sock *sk = sock->sk;
|
|
|
|
int err = 0, opt = 0;
|
|
|
|
|
|
|
|
BT_DBG("sk %p, opt %d", sk, optname);
|
|
|
|
|
|
|
|
lock_sock(sk);
|
|
|
|
|
2012-02-20 14:50:32 +01:00
|
|
|
if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
|
2013-08-26 18:29:39 +02:00
|
|
|
err = -EBADFD;
|
2012-02-20 14:50:32 +01:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (optname) {
|
|
|
|
case HCI_DATA_DIR:
|
|
|
|
if (get_user(opt, (int __user *)optval)) {
|
|
|
|
err = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opt)
|
|
|
|
hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
|
|
|
|
else
|
|
|
|
hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HCI_TIME_STAMP:
|
|
|
|
if (get_user(opt, (int __user *)optval)) {
|
|
|
|
err = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (opt)
|
|
|
|
hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
|
|
|
|
else
|
|
|
|
hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case HCI_FILTER:
|
2007-05-05 00:35:59 +02:00
|
|
|
{
|
|
|
|
struct hci_filter *f = &hci_pi(sk)->filter;
|
|
|
|
|
|
|
|
uf.type_mask = f->type_mask;
|
|
|
|
uf.opcode = f->opcode;
|
|
|
|
uf.event_mask[0] = *((u32 *) f->event_mask + 0);
|
|
|
|
uf.event_mask[1] = *((u32 *) f->event_mask + 1);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
len = min_t(unsigned int, len, sizeof(uf));
|
|
|
|
if (copy_from_user(&uf, optval, len)) {
|
|
|
|
err = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!capable(CAP_NET_RAW)) {
|
|
|
|
uf.type_mask &= hci_sec_filter.type_mask;
|
|
|
|
uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
|
|
|
|
uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
struct hci_filter *f = &hci_pi(sk)->filter;
|
|
|
|
|
|
|
|
f->type_mask = uf.type_mask;
|
|
|
|
f->opcode = uf.opcode;
|
|
|
|
*((u32 *) f->event_mask + 0) = uf.event_mask[0];
|
|
|
|
*((u32 *) f->event_mask + 1) = uf.event_mask[1];
|
|
|
|
}
|
2007-02-09 15:24:33 +01:00
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
default:
|
|
|
|
err = -ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-02-20 14:50:32 +01:00
|
|
|
done:
|
2005-04-17 00:20:36 +02:00
|
|
|
release_sock(sk);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-05-23 09:04:21 +02:00
|
|
|
static int hci_sock_getsockopt(struct socket *sock, int level, int optname,
|
|
|
|
char __user *optval, int __user *optlen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct hci_ufilter uf;
|
|
|
|
struct sock *sk = sock->sk;
|
2012-02-20 14:50:33 +01:00
|
|
|
int len, opt, err = 0;
|
|
|
|
|
|
|
|
BT_DBG("sk %p, opt %d", sk, optname);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (get_user(len, optlen))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2012-02-20 14:50:33 +01:00
|
|
|
lock_sock(sk);
|
|
|
|
|
|
|
|
if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
|
2013-08-26 18:29:39 +02:00
|
|
|
err = -EBADFD;
|
2012-02-20 14:50:33 +01:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (optname) {
|
|
|
|
case HCI_DATA_DIR:
|
|
|
|
if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
|
|
|
|
opt = 1;
|
2007-02-09 15:24:33 +01:00
|
|
|
else
|
2005-04-17 00:20:36 +02:00
|
|
|
opt = 0;
|
|
|
|
|
|
|
|
if (put_user(opt, optval))
|
2012-02-20 14:50:33 +01:00
|
|
|
err = -EFAULT;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HCI_TIME_STAMP:
|
|
|
|
if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
|
|
|
|
opt = 1;
|
2007-02-09 15:24:33 +01:00
|
|
|
else
|
2005-04-17 00:20:36 +02:00
|
|
|
opt = 0;
|
|
|
|
|
|
|
|
if (put_user(opt, optval))
|
2012-02-20 14:50:33 +01:00
|
|
|
err = -EFAULT;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case HCI_FILTER:
|
|
|
|
{
|
|
|
|
struct hci_filter *f = &hci_pi(sk)->filter;
|
|
|
|
|
2012-08-15 13:31:46 +02:00
|
|
|
memset(&uf, 0, sizeof(uf));
|
2005-04-17 00:20:36 +02:00
|
|
|
uf.type_mask = f->type_mask;
|
|
|
|
uf.opcode = f->opcode;
|
|
|
|
uf.event_mask[0] = *((u32 *) f->event_mask + 0);
|
|
|
|
uf.event_mask[1] = *((u32 *) f->event_mask + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
len = min_t(unsigned int, len, sizeof(uf));
|
|
|
|
if (copy_to_user(optval, &uf, len))
|
2012-02-20 14:50:33 +01:00
|
|
|
err = -EFAULT;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2012-02-20 14:50:33 +01:00
|
|
|
err = -ENOPROTOOPT;
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-02-20 14:50:33 +01:00
|
|
|
done:
|
|
|
|
release_sock(sk);
|
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-12-22 21:49:22 +01:00
|
|
|
static const struct proto_ops hci_sock_ops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.family = PF_BLUETOOTH,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.release = hci_sock_release,
|
|
|
|
.bind = hci_sock_bind,
|
|
|
|
.getname = hci_sock_getname,
|
|
|
|
.sendmsg = hci_sock_sendmsg,
|
|
|
|
.recvmsg = hci_sock_recvmsg,
|
|
|
|
.ioctl = hci_sock_ioctl,
|
|
|
|
.poll = datagram_poll,
|
|
|
|
.listen = sock_no_listen,
|
|
|
|
.shutdown = sock_no_shutdown,
|
|
|
|
.setsockopt = hci_sock_setsockopt,
|
|
|
|
.getsockopt = hci_sock_getsockopt,
|
|
|
|
.connect = sock_no_connect,
|
|
|
|
.socketpair = sock_no_socketpair,
|
|
|
|
.accept = sock_no_accept,
|
|
|
|
.mmap = sock_no_mmap
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct proto hci_sk_proto = {
|
|
|
|
.name = "HCI",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.obj_size = sizeof(struct hci_pinfo)
|
|
|
|
};
|
|
|
|
|
2009-11-06 07:18:14 +01:00
|
|
|
static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
|
|
|
|
int kern)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
|
|
|
|
BT_DBG("sock %p", sock);
|
|
|
|
|
|
|
|
if (sock->type != SOCK_RAW)
|
|
|
|
return -ESOCKTNOSUPPORT;
|
|
|
|
|
|
|
|
sock->ops = &hci_sock_ops;
|
|
|
|
|
2007-11-01 08:39:31 +01:00
|
|
|
sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!sk)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
sock_init_data(sock, sk);
|
|
|
|
|
|
|
|
sock_reset_flag(sk, SOCK_ZAPPED);
|
|
|
|
|
|
|
|
sk->sk_protocol = protocol;
|
|
|
|
|
|
|
|
sock->state = SS_UNCONNECTED;
|
|
|
|
sk->sk_state = BT_OPEN;
|
|
|
|
|
|
|
|
bt_sock_link(&hci_sk_list, sk);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-05 07:58:39 +02:00
|
|
|
static const struct net_proto_family hci_sock_family_ops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.family = PF_BLUETOOTH,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.create = hci_sock_create,
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init hci_sock_init(void)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2015-01-12 00:18:17 +01:00
|
|
|
BUILD_BUG_ON(sizeof(struct sockaddr_hci) > sizeof(struct sockaddr));
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
err = proto_register(&hci_sk_proto, 0);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
|
2012-07-25 18:28:36 +02:00
|
|
|
if (err < 0) {
|
|
|
|
BT_ERR("HCI socket registration failed");
|
2005-04-17 00:20:36 +02:00
|
|
|
goto error;
|
2012-07-25 18:28:36 +02:00
|
|
|
}
|
|
|
|
|
2013-04-05 01:14:33 +02:00
|
|
|
err = bt_procfs_init(&init_net, "hci", &hci_sk_list, NULL);
|
2012-07-25 18:28:36 +02:00
|
|
|
if (err < 0) {
|
|
|
|
BT_ERR("Failed to create HCI proc file");
|
|
|
|
bt_sock_unregister(BTPROTO_HCI);
|
|
|
|
goto error;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
BT_INFO("HCI socket layer initialized");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
proto_unregister(&hci_sk_proto);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-02-22 08:13:09 +01:00
|
|
|
void hci_sock_cleanup(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2012-07-25 18:28:36 +02:00
|
|
|
bt_procfs_cleanup(&init_net, "hci");
|
2013-02-24 19:36:51 +01:00
|
|
|
bt_sock_unregister(BTPROTO_HCI);
|
2005-04-17 00:20:36 +02:00
|
|
|
proto_unregister(&hci_sk_proto);
|
|
|
|
}
|