Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next into for-davem

Conflicts:
	drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h

1 files changed, 67 insertions, 19 deletions

diff --git a/net/bluetooth/l2cap_sock.c b/net/bluetooth/l2cap_sock.c
index 9119898ef040..5ffd75e20bde 100644
--- a/net/bluetooth/l2cap_sock.c
+++ b/net/bluetooth/l2cap_sock.c
@@ -32,7 +32,8 @@
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>
 #include <net/bluetooth/l2cap.h>
-#include <net/bluetooth/smp.h>
+
+#include "smp.h"
 
 static struct bt_sock_list l2cap_sk_list = {
         .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
@@ -68,6 +69,9 @@ static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
         if (la.l2_cid && la.l2_psm)
                 return -EINVAL;
 
+        if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
+                return -EINVAL;
+
         lock_sock(sk);
 
         if (sk->sk_state != BT_OPEN) {
@@ -99,11 +103,20 @@ static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
         if (err < 0)
                 goto done;
 
-        if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
-            __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
-                chan->sec_level = BT_SECURITY_SDP;
+        switch (chan->chan_type) {
+        case L2CAP_CHAN_CONN_LESS:
+                if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_3DSP)
+                        chan->sec_level = BT_SECURITY_SDP;
+                break;
+        case L2CAP_CHAN_CONN_ORIENTED:
+                if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
+                    __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
+                        chan->sec_level = BT_SECURITY_SDP;
+                break;
+        }
 
-        bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
+        bacpy(&chan->src, &la.l2_bdaddr);
+        chan->src_type = la.l2_bdaddr_type;
 
         chan->state = BT_BOUND;
         sk->sk_state = BT_BOUND;
@@ -134,6 +147,15 @@ static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
         if (la.l2_cid && la.l2_psm)
                 return -EINVAL;
 
+        if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
+                return -EINVAL;
+
+        if (chan->src_type == BDADDR_BREDR && la.l2_bdaddr_type != BDADDR_BREDR)
+                return -EINVAL;
+
+        if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)
+                return -EINVAL;
+
         err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
                                  &la.l2_bdaddr, la.l2_bdaddr_type);
         if (err)
@@ -265,12 +287,14 @@ static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
 
         if (peer) {
                 la->l2_psm = chan->psm;
-                bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
+                bacpy(&la->l2_bdaddr, &chan->dst);
                 la->l2_cid = cpu_to_le16(chan->dcid);
+                la->l2_bdaddr_type = chan->dst_type;
         } else {
                 la->l2_psm = chan->sport;
-                bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
+                bacpy(&la->l2_bdaddr, &chan->src);
                 la->l2_cid = cpu_to_le16(chan->scid);
+                la->l2_bdaddr_type = chan->src_type;
         }
 
         return 0;
@@ -660,10 +684,13 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
                         break;
                 }
 
-                if (opt)
+                if (opt) {
                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
-                else
+                        set_bit(FLAG_DEFER_SETUP, &chan->flags);
+                } else {
                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
+                        clear_bit(FLAG_DEFER_SETUP, &chan->flags);
+                }
                 break;
 
         case BT_FLUSHABLE:
@@ -678,7 +705,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
                 }
 
                 if (opt == BT_FLUSHABLE_OFF) {
-                        struct l2cap_conn *conn = chan->conn;
+                        conn = chan->conn;
                         /* proceed further only when we have l2cap_conn and
                            No Flush support in the LM */
                         if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
@@ -964,13 +991,12 @@ static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
 
 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
 {
-        int err;
         struct sock *sk = chan->data;
-        struct l2cap_pinfo *pi = l2cap_pi(sk);
+        int err;
 
         lock_sock(sk);
 
-        if (pi->rx_busy_skb) {
+        if (l2cap_pi(sk)->rx_busy_skb) {
                 err = -ENOMEM;
                 goto done;
         }
@@ -986,9 +1012,9 @@ static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
          * acked and reassembled until there is buffer space
          * available.
          */
-        if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
-                pi->rx_busy_skb = skb;
-                l2cap_chan_busy(pi->chan, 1);
+        if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
+                l2cap_pi(sk)->rx_busy_skb = skb;
+                l2cap_chan_busy(chan, 1);
                 err = 0;
         }
 
@@ -1098,6 +1124,14 @@ static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
                 parent->sk_data_ready(parent, 0);
 }
 
+static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
+{
+        struct sock *sk = chan->data;
+
+        clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
+        sk->sk_state_change(sk);
+}
+
 static struct l2cap_ops l2cap_chan_ops = {
         .name           = "L2CAP Socket Interface",
         .new_connection = l2cap_sock_new_connection_cb,
@@ -1107,6 +1141,7 @@ static struct l2cap_ops l2cap_chan_ops = {
         .state_change   = l2cap_sock_state_change_cb,
         .ready          = l2cap_sock_ready_cb,
         .defer          = l2cap_sock_defer_cb,
+        .resume         = l2cap_sock_resume_cb,
         .alloc_skb      = l2cap_sock_alloc_skb_cb,
 };
 
@@ -1116,6 +1151,7 @@ static void l2cap_sock_destruct(struct sock *sk)
 
         if (l2cap_pi(sk)->chan)
                 l2cap_chan_put(l2cap_pi(sk)->chan);
+
         if (l2cap_pi(sk)->rx_busy_skb) {
                 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
                 l2cap_pi(sk)->rx_busy_skb = NULL;
@@ -1125,10 +1161,22 @@ static void l2cap_sock_destruct(struct sock *sk)
         skb_queue_purge(&sk->sk_write_queue);
 }
 
+static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
+                               int *msg_namelen)
+{
+        struct sockaddr_l2 *la = (struct sockaddr_l2 *) msg_name;
+
+        memset(la, 0, sizeof(struct sockaddr_l2));
+        la->l2_family = AF_BLUETOOTH;
+        la->l2_psm = bt_cb(skb)->psm;
+        bacpy(&la->l2_bdaddr, &bt_cb(skb)->bdaddr);
+
+        *msg_namelen = sizeof(struct sockaddr_l2);
+}
+
 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
 {
-        struct l2cap_pinfo *pi = l2cap_pi(sk);
-        struct l2cap_chan *chan = pi->chan;
+        struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 
         BT_DBG("sk %p", sk);
 
@@ -1152,13 +1200,13 @@ static void l2cap_sock_init(struct sock *sk, struct sock *parent)
 
                 security_sk_clone(parent, sk);
         } else {
-
                 switch (sk->sk_type) {
                 case SOCK_RAW:
                         chan->chan_type = L2CAP_CHAN_RAW;
                         break;
                 case SOCK_DGRAM:
                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
+                        bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
                         break;
                 case SOCK_SEQPACKET:
                 case SOCK_STREAM: