Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / net / bluetooth / l2cap_sock.c
index 47394a1..7c4a9ae 100644 (file)
@@ -30,6 +30,8 @@
 #include <net/bluetooth/hci_core.h>
 #include <net/bluetooth/l2cap.h>
 
+static const struct proto_ops l2cap_sock_ops;
+
 /* ---- L2CAP timers ---- */
 static void l2cap_sock_timeout(unsigned long arg)
 {
@@ -51,7 +53,7 @@ static void l2cap_sock_timeout(unsigned long arg)
        if (sk->sk_state == BT_CONNECTED || sk->sk_state == BT_CONFIG)
                reason = ECONNREFUSED;
        else if (sk->sk_state == BT_CONNECT &&
-                               l2cap_pi(sk)->sec_level != BT_SECURITY_SDP)
+                       l2cap_pi(sk)->chan->sec_level != BT_SECURITY_SDP)
                reason = ECONNREFUSED;
        else
                reason = ETIMEDOUT;
@@ -80,9 +82,13 @@ static struct sock *__l2cap_get_sock_by_addr(__le16 psm, bdaddr_t *src)
 {
        struct sock *sk;
        struct hlist_node *node;
-       sk_for_each(sk, node, &l2cap_sk_list.head)
-               if (l2cap_pi(sk)->sport == psm && !bacmp(&bt_sk(sk)->src, src))
+       sk_for_each(sk, node, &l2cap_sk_list.head) {
+               struct l2cap_chan *chan = l2cap_pi(sk)->chan;
+
+               if (chan->sport == psm && !bacmp(&bt_sk(sk)->src, src))
                        goto found;
+       }
+
        sk = NULL;
 found:
        return sk;
@@ -91,6 +97,7 @@ found:
 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        struct sockaddr_l2 la;
        int len, err = 0;
 
@@ -136,17 +143,17 @@ static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
        } else {
                /* Save source address */
                bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
-               l2cap_pi(sk)->psm   = la.l2_psm;
-               l2cap_pi(sk)->sport = la.l2_psm;
+               chan->psm   = la.l2_psm;
+               chan->sport = la.l2_psm;
                sk->sk_state = BT_BOUND;
 
                if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
                                        __le16_to_cpu(la.l2_psm) == 0x0003)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
+                       chan->sec_level = BT_SECURITY_SDP;
        }
 
        if (la.l2_cid)
-               l2cap_pi(sk)->scid = la.l2_cid;
+               chan->scid = la.l2_cid;
 
        write_unlock_bh(&l2cap_sk_list.lock);
 
@@ -158,6 +165,7 @@ done:
 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        struct sockaddr_l2 la;
        int len, err = 0;
 
@@ -182,7 +190,7 @@ static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int al
                goto done;
        }
 
-       switch (l2cap_pi(sk)->mode) {
+       switch (chan->mode) {
        case L2CAP_MODE_BASIC:
                break;
        case L2CAP_MODE_ERTM:
@@ -226,10 +234,10 @@ static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int al
 
        /* Set destination address and psm */
        bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
-       l2cap_pi(sk)->psm = la.l2_psm;
-       l2cap_pi(sk)->dcid = la.l2_cid;
+       chan->psm = la.l2_psm;
+       chan->dcid = la.l2_cid;
 
-       err = l2cap_do_connect(sk);
+       err = l2cap_chan_connect(l2cap_pi(sk)->chan);
        if (err)
                goto done;
 
@@ -244,6 +252,7 @@ done:
 static int l2cap_sock_listen(struct socket *sock, int backlog)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        int err = 0;
 
        BT_DBG("sk %p backlog %d", sk, backlog);
@@ -256,7 +265,7 @@ static int l2cap_sock_listen(struct socket *sock, int backlog)
                goto done;
        }
 
-       switch (l2cap_pi(sk)->mode) {
+       switch (chan->mode) {
        case L2CAP_MODE_BASIC:
                break;
        case L2CAP_MODE_ERTM:
@@ -269,7 +278,7 @@ static int l2cap_sock_listen(struct socket *sock, int backlog)
                goto done;
        }
 
-       if (!l2cap_pi(sk)->psm && !l2cap_pi(sk)->scid) {
+       if (!chan->psm && !chan->scid) {
                bdaddr_t *src = &bt_sk(sk)->src;
                u16 psm;
 
@@ -279,8 +288,8 @@ static int l2cap_sock_listen(struct socket *sock, int backlog)
 
                for (psm = 0x1001; psm < 0x1100; psm += 2)
                        if (!__l2cap_get_sock_by_addr(cpu_to_le16(psm), src)) {
-                               l2cap_pi(sk)->psm   = cpu_to_le16(psm);
-                               l2cap_pi(sk)->sport = cpu_to_le16(psm);
+                               chan->psm   = cpu_to_le16(psm);
+                               chan->sport = cpu_to_le16(psm);
                                err = 0;
                                break;
                        }
@@ -360,6 +369,7 @@ static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *l
 {
        struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 
        BT_DBG("sock %p, sk %p", sock, sk);
 
@@ -367,13 +377,13 @@ static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *l
        *len = sizeof(struct sockaddr_l2);
 
        if (peer) {
-               la->l2_psm = l2cap_pi(sk)->psm;
+               la->l2_psm = chan->psm;
                bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
-               la->l2_cid = cpu_to_le16(l2cap_pi(sk)->dcid);
+               la->l2_cid = cpu_to_le16(chan->dcid);
        } else {
-               la->l2_psm = l2cap_pi(sk)->sport;
+               la->l2_psm = chan->sport;
                bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
-               la->l2_cid = cpu_to_le16(l2cap_pi(sk)->scid);
+               la->l2_cid = cpu_to_le16(chan->scid);
        }
 
        return 0;
@@ -382,6 +392,7 @@ static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *l
 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        struct l2cap_options opts;
        struct l2cap_conninfo cinfo;
        int len, err = 0;
@@ -397,13 +408,13 @@ static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __us
        switch (optname) {
        case L2CAP_OPTIONS:
                memset(&opts, 0, sizeof(opts));
-               opts.imtu     = l2cap_pi(sk)->imtu;
-               opts.omtu     = l2cap_pi(sk)->omtu;
-               opts.flush_to = l2cap_pi(sk)->flush_to;
-               opts.mode     = l2cap_pi(sk)->mode;
-               opts.fcs      = l2cap_pi(sk)->fcs;
-               opts.max_tx   = l2cap_pi(sk)->max_tx;
-               opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
+               opts.imtu     = chan->imtu;
+               opts.omtu     = chan->omtu;
+               opts.flush_to = chan->flush_to;
+               opts.mode     = chan->mode;
+               opts.fcs      = chan->fcs;
+               opts.max_tx   = chan->max_tx;
+               opts.txwin_size = (__u16)chan->tx_win;
 
                len = min_t(unsigned int, len, sizeof(opts));
                if (copy_to_user(optval, (char *) &opts, len))
@@ -412,7 +423,7 @@ static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __us
                break;
 
        case L2CAP_LM:
-               switch (l2cap_pi(sk)->sec_level) {
+               switch (chan->sec_level) {
                case BT_SECURITY_LOW:
                        opt = L2CAP_LM_AUTH;
                        break;
@@ -428,10 +439,10 @@ static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __us
                        break;
                }
 
-               if (l2cap_pi(sk)->role_switch)
+               if (chan->role_switch)
                        opt |= L2CAP_LM_MASTER;
 
-               if (l2cap_pi(sk)->force_reliable)
+               if (chan->force_reliable)
                        opt |= L2CAP_LM_RELIABLE;
 
                if (put_user(opt, (u32 __user *) optval))
@@ -446,8 +457,8 @@ static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __us
                        break;
                }
 
-               cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;
-               memcpy(cinfo.dev_class, l2cap_pi(sk)->conn->hcon->dev_class, 3);
+               cinfo.hci_handle = chan->conn->hcon->handle;
+               memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
 
                len = min_t(unsigned int, len, sizeof(cinfo));
                if (copy_to_user(optval, (char *) &cinfo, len))
@@ -467,6 +478,7 @@ static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __us
 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        struct bt_security sec;
        int len, err = 0;
 
@@ -491,7 +503,7 @@ static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, ch
                        break;
                }
 
-               sec.level = l2cap_pi(sk)->sec_level;
+               sec.level = chan->sec_level;
 
                len = min_t(unsigned int, len, sizeof(sec));
                if (copy_to_user(optval, (char *) &sec, len))
@@ -511,7 +523,7 @@ static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, ch
                break;
 
        case BT_FLUSHABLE:
-               if (put_user(l2cap_pi(sk)->flushable, (u32 __user *) optval))
+               if (put_user(chan->flushable, (u32 __user *) optval))
                        err = -EFAULT;
 
                break;
@@ -528,6 +540,7 @@ static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, ch
 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        struct l2cap_options opts;
        int len, err = 0;
        u32 opt;
@@ -543,13 +556,13 @@ static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __us
                        break;
                }
 
-               opts.imtu     = l2cap_pi(sk)->imtu;
-               opts.omtu     = l2cap_pi(sk)->omtu;
-               opts.flush_to = l2cap_pi(sk)->flush_to;
-               opts.mode     = l2cap_pi(sk)->mode;
-               opts.fcs      = l2cap_pi(sk)->fcs;
-               opts.max_tx   = l2cap_pi(sk)->max_tx;
-               opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
+               opts.imtu     = chan->imtu;
+               opts.omtu     = chan->omtu;
+               opts.flush_to = chan->flush_to;
+               opts.mode     = chan->mode;
+               opts.fcs      = chan->fcs;
+               opts.max_tx   = chan->max_tx;
+               opts.txwin_size = (__u16)chan->tx_win;
 
                len = min_t(unsigned int, sizeof(opts), optlen);
                if (copy_from_user((char *) &opts, optval, len)) {
@@ -562,10 +575,10 @@ static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __us
                        break;
                }
 
-               l2cap_pi(sk)->mode = opts.mode;
-               switch (l2cap_pi(sk)->mode) {
+               chan->mode = opts.mode;
+               switch (chan->mode) {
                case L2CAP_MODE_BASIC:
-                       l2cap_pi(sk)->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
+                       chan->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
                        break;
                case L2CAP_MODE_ERTM:
                case L2CAP_MODE_STREAMING:
@@ -577,11 +590,11 @@ static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __us
                        break;
                }
 
-               l2cap_pi(sk)->imtu = opts.imtu;
-               l2cap_pi(sk)->omtu = opts.omtu;
-               l2cap_pi(sk)->fcs  = opts.fcs;
-               l2cap_pi(sk)->max_tx = opts.max_tx;
-               l2cap_pi(sk)->tx_win = (__u8)opts.txwin_size;
+               chan->imtu = opts.imtu;
+               chan->omtu = opts.omtu;
+               chan->fcs  = opts.fcs;
+               chan->max_tx = opts.max_tx;
+               chan->tx_win = (__u8)opts.txwin_size;
                break;
 
        case L2CAP_LM:
@@ -591,14 +604,14 @@ static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __us
                }
 
                if (opt & L2CAP_LM_AUTH)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_LOW;
+                       chan->sec_level = BT_SECURITY_LOW;
                if (opt & L2CAP_LM_ENCRYPT)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
+                       chan->sec_level = BT_SECURITY_MEDIUM;
                if (opt & L2CAP_LM_SECURE)
-                       l2cap_pi(sk)->sec_level = BT_SECURITY_HIGH;
+                       chan->sec_level = BT_SECURITY_HIGH;
 
-               l2cap_pi(sk)->role_switch    = (opt & L2CAP_LM_MASTER);
-               l2cap_pi(sk)->force_reliable = (opt & L2CAP_LM_RELIABLE);
+               chan->role_switch    = (opt & L2CAP_LM_MASTER);
+               chan->force_reliable = (opt & L2CAP_LM_RELIABLE);
                break;
 
        default:
@@ -613,6 +626,7 @@ static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __us
 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        struct bt_security sec;
        int len, err = 0;
        u32 opt;
@@ -649,7 +663,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, ch
                        break;
                }
 
-               l2cap_pi(sk)->sec_level = sec.level;
+               chan->sec_level = sec.level;
                break;
 
        case BT_DEFER_SETUP:
@@ -678,7 +692,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, ch
                }
 
                if (opt == BT_FLUSHABLE_OFF) {
-                       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
+                       struct l2cap_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)) {
@@ -687,7 +701,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, ch
                        }
                }
 
-               l2cap_pi(sk)->flushable = opt;
+               chan->flushable = opt;
                break;
 
        default:
@@ -702,7 +716,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, ch
 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
 {
        struct sock *sk = sock->sk;
-       struct l2cap_pinfo *pi = l2cap_pi(sk);
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        struct sk_buff *skb;
        u16 control;
        int err;
@@ -725,76 +739,77 @@ static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct ms
 
        /* Connectionless channel */
        if (sk->sk_type == SOCK_DGRAM) {
-               skb = l2cap_create_connless_pdu(sk, msg, len);
+               skb = l2cap_create_connless_pdu(chan, msg, len);
                if (IS_ERR(skb)) {
                        err = PTR_ERR(skb);
                } else {
-                       l2cap_do_send(sk, skb);
+                       l2cap_do_send(chan, skb);
                        err = len;
                }
                goto done;
        }
 
-       switch (pi->mode) {
+       switch (chan->mode) {
        case L2CAP_MODE_BASIC:
                /* Check outgoing MTU */
-               if (len > pi->omtu) {
+               if (len > chan->omtu) {
                        err = -EMSGSIZE;
                        goto done;
                }
 
                /* Create a basic PDU */
-               skb = l2cap_create_basic_pdu(sk, msg, len);
+               skb = l2cap_create_basic_pdu(chan, msg, len);
                if (IS_ERR(skb)) {
                        err = PTR_ERR(skb);
                        goto done;
                }
 
-               l2cap_do_send(sk, skb);
+               l2cap_do_send(chan, skb);
                err = len;
                break;
 
        case L2CAP_MODE_ERTM:
        case L2CAP_MODE_STREAMING:
                /* Entire SDU fits into one PDU */
-               if (len <= pi->chan->remote_mps) {
+               if (len <= chan->remote_mps) {
                        control = L2CAP_SDU_UNSEGMENTED;
-                       skb = l2cap_create_iframe_pdu(sk, msg, len, control, 0);
+                       skb = l2cap_create_iframe_pdu(chan, msg, len, control,
+                                                                       0);
                        if (IS_ERR(skb)) {
                                err = PTR_ERR(skb);
                                goto done;
                        }
-                       __skb_queue_tail(&pi->chan->tx_q, skb);
+                       __skb_queue_tail(&chan->tx_q, skb);
 
-                       if (pi->chan->tx_send_head == NULL)
-                               pi->chan->tx_send_head = skb;
+                       if (chan->tx_send_head == NULL)
+                               chan->tx_send_head = skb;
 
                } else {
                /* Segment SDU into multiples PDUs */
-                       err = l2cap_sar_segment_sdu(pi->chan, msg, len);
+                       err = l2cap_sar_segment_sdu(chan, msg, len);
                        if (err < 0)
                                goto done;
                }
 
-               if (pi->mode == L2CAP_MODE_STREAMING) {
-                       l2cap_streaming_send(pi->chan);
+               if (chan->mode == L2CAP_MODE_STREAMING) {
+                       l2cap_streaming_send(chan);
                        err = len;
                        break;
                }
 
-               if ((pi->chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
-                               (pi->chan->conn_state & L2CAP_CONN_WAIT_F)) {
+               if ((chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
+                               (chan->conn_state & L2CAP_CONN_WAIT_F)) {
                        err = len;
                        break;
                }
-               err = l2cap_ertm_send(pi->chan);
+               err = l2cap_ertm_send(chan);
 
                if (err >= 0)
                        err = len;
                break;
 
        default:
-               BT_DBG("bad state %1.1x", pi->mode);
+               BT_DBG("bad state %1.1x", chan->mode);
                err = -EBADFD;
        }
 
@@ -810,7 +825,9 @@ static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct ms
        lock_sock(sk);
 
        if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
-               __l2cap_connect_rsp_defer(sk);
+               sk->sk_state = BT_CONFIG;
+
+               __l2cap_connect_rsp_defer(l2cap_pi(sk)->chan);
                release_sock(sk);
                return 0;
        }
@@ -834,6 +851,8 @@ void l2cap_sock_kill(struct sock *sk)
        BT_DBG("sk %p state %d", sk, sk->sk_state);
 
        /* Kill poor orphan */
+
+       l2cap_chan_free(l2cap_pi(sk)->chan);
        bt_sock_unlink(&l2cap_sk_list, sk);
        sock_set_flag(sk, SOCK_DEAD);
        sock_put(sk);
@@ -865,8 +884,8 @@ static void l2cap_sock_cleanup_listen(struct sock *parent)
 
 void __l2cap_sock_close(struct sock *sk, int reason)
 {
-       struct l2cap_conn *conn = l2cap_pi(sk)->conn;
        struct l2cap_chan *chan = l2cap_pi(sk)->chan;
+       struct l2cap_conn *conn = chan->conn;
 
        BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 
@@ -898,8 +917,8 @@ void __l2cap_sock_close(struct sock *sk, int reason)
                        else
                                result = L2CAP_CR_BAD_PSM;
 
-                       rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
-                       rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
+                       rsp.scid   = cpu_to_le16(chan->dcid);
+                       rsp.dcid   = cpu_to_le16(chan->scid);
                        rsp.result = cpu_to_le16(result);
                        rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
                        l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
@@ -923,6 +942,7 @@ void __l2cap_sock_close(struct sock *sk, int reason)
 static int l2cap_sock_shutdown(struct socket *sock, int how)
 {
        struct sock *sk = sock->sk;
+       struct l2cap_chan *chan = l2cap_pi(sk)->chan;
        int err = 0;
 
        BT_DBG("sock %p, sk %p", sock, sk);
@@ -932,7 +952,7 @@ static int l2cap_sock_shutdown(struct socket *sock, int how)
 
        lock_sock(sk);
        if (!sk->sk_shutdown) {
-               if (l2cap_pi(sk)->mode == L2CAP_MODE_ERTM)
+               if (chan->mode == L2CAP_MODE_ERTM)
                        err = __l2cap_wait_ack(sk);
 
                sk->sk_shutdown = SHUTDOWN_MASK;
@@ -979,44 +999,47 @@ static void l2cap_sock_destruct(struct sock *sk)
 void l2cap_sock_init(struct sock *sk, struct sock *parent)
 {
        struct l2cap_pinfo *pi = l2cap_pi(sk);
+       struct l2cap_chan *chan = pi->chan;
 
        BT_DBG("sk %p", sk);
 
        if (parent) {
+               struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
+
                sk->sk_type = parent->sk_type;
                bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 
-               pi->imtu = l2cap_pi(parent)->imtu;
-               pi->omtu = l2cap_pi(parent)->omtu;
-               pi->conf_state = l2cap_pi(parent)->conf_state;
-               pi->mode = l2cap_pi(parent)->mode;
-               pi->fcs  = l2cap_pi(parent)->fcs;
-               pi->max_tx = l2cap_pi(parent)->max_tx;
-               pi->tx_win = l2cap_pi(parent)->tx_win;
-               pi->sec_level = l2cap_pi(parent)->sec_level;
-               pi->role_switch = l2cap_pi(parent)->role_switch;
-               pi->force_reliable = l2cap_pi(parent)->force_reliable;
-               pi->flushable = l2cap_pi(parent)->flushable;
+               chan->imtu = pchan->imtu;
+               chan->omtu = pchan->omtu;
+               chan->conf_state = pchan->conf_state;
+               chan->mode = pchan->mode;
+               chan->fcs  = pchan->fcs;
+               chan->max_tx = pchan->max_tx;
+               chan->tx_win = pchan->tx_win;
+               chan->sec_level = pchan->sec_level;
+               chan->role_switch = pchan->role_switch;
+               chan->force_reliable = pchan->force_reliable;
+               chan->flushable = pchan->flushable;
        } else {
-               pi->imtu = L2CAP_DEFAULT_MTU;
-               pi->omtu = 0;
+               chan->imtu = L2CAP_DEFAULT_MTU;
+               chan->omtu = 0;
                if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
-                       pi->mode = L2CAP_MODE_ERTM;
-                       pi->conf_state |= L2CAP_CONF_STATE2_DEVICE;
+                       chan->mode = L2CAP_MODE_ERTM;
+                       chan->conf_state |= L2CAP_CONF_STATE2_DEVICE;
                } else {
-                       pi->mode = L2CAP_MODE_BASIC;
+                       chan->mode = L2CAP_MODE_BASIC;
                }
-               pi->max_tx = L2CAP_DEFAULT_MAX_TX;
-               pi->fcs  = L2CAP_FCS_CRC16;
-               pi->tx_win = L2CAP_DEFAULT_TX_WINDOW;
-               pi->sec_level = BT_SECURITY_LOW;
-               pi->role_switch = 0;
-               pi->force_reliable = 0;
-               pi->flushable = BT_FLUSHABLE_OFF;
+               chan->max_tx = L2CAP_DEFAULT_MAX_TX;
+               chan->fcs  = L2CAP_FCS_CRC16;
+               chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
+               chan->sec_level = BT_SECURITY_LOW;
+               chan->role_switch = 0;
+               chan->force_reliable = 0;
+               chan->flushable = BT_FLUSHABLE_OFF;
        }
 
        /* Default config options */
-       pi->flush_to = L2CAP_DEFAULT_FLUSH_TO;
+       chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
 }
 
 static struct proto l2cap_proto = {
@@ -1054,6 +1077,7 @@ static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
                             int kern)
 {
        struct sock *sk;
+       struct l2cap_chan *chan;
 
        BT_DBG("sock %p", sock);
 
@@ -1072,11 +1096,19 @@ static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
        if (!sk)
                return -ENOMEM;
 
+       chan = l2cap_chan_alloc(sk);
+       if (!chan) {
+               l2cap_sock_kill(sk);
+               return -ENOMEM;
+       }
+
+       l2cap_pi(sk)->chan = chan;
+
        l2cap_sock_init(sk, NULL);
        return 0;
 }
 
-const struct proto_ops l2cap_sock_ops = {
+static const struct proto_ops l2cap_sock_ops = {
        .family         = PF_BLUETOOTH,
        .owner          = THIS_MODULE,
        .release        = l2cap_sock_release,