vserver 2.0 rc7
[linux-2.6.git] / net / bluetooth / l2cap.c
index 1da6a95..32fccfb 100644 (file)
@@ -30,7 +30,6 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
-#include <linux/major.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #define BT_DBG(D...)
 #endif
 
-#define VERSION "2.4"
+#define VERSION "2.7"
 
 static struct proto_ops l2cap_sock_ops;
 
-struct bt_sock_list l2cap_sk_list = {
+static struct bt_sock_list l2cap_sk_list = {
        .lock = RW_LOCK_UNLOCKED
 };
 
@@ -74,8 +73,8 @@ static void __l2cap_sock_close(struct sock *sk, int reason);
 static void l2cap_sock_close(struct sock *sk);
 static void l2cap_sock_kill(struct sock *sk);
 
-static int l2cap_send_req(struct l2cap_conn *conn, u8 code, u16 len, void *data);
-static int l2cap_send_rsp(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data);
+static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
+                               u8 code, u8 ident, u16 dlen, void *data);
 
 /* ---- L2CAP timers ---- */
 static void l2cap_sock_timeout(unsigned long arg)
@@ -134,7 +133,7 @@ static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status)
        conn->dst = &hcon->dst;
 
        spin_lock_init(&conn->lock);
-       conn->chan_list.lock = RW_LOCK_UNLOCKED;
+       rwlock_init(&conn->chan_list.lock);
 
        BT_DBG("hcon %p conn %p", hcon, conn);
        return conn;
@@ -174,6 +173,40 @@ static inline void l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, stru
        write_unlock(&l->lock);
 }
 
+static inline u8 l2cap_get_ident(struct l2cap_conn *conn)
+{
+       u8 id;
+
+       /* Get next available identificator.
+        *    1 - 128 are used by kernel.
+        *  129 - 199 are reserved.
+        *  200 - 254 are used by utilities like l2ping, etc.
+        */
+
+       spin_lock(&conn->lock);
+
+       if (++conn->tx_ident > 128)
+               conn->tx_ident = 1;
+
+       id = conn->tx_ident;
+
+       spin_unlock(&conn->lock);
+
+       return id;
+}
+
+static inline int l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data)
+{
+       struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
+
+       BT_DBG("code 0x%2.2x", code);
+
+       if (!skb)
+               return -ENOMEM;
+
+       return hci_send_acl(conn->hcon, skb, 0);
+}
+
 /* ---- Socket interface ---- */
 static struct sock *__l2cap_get_sock_by_addr(u16 psm, bdaddr_t *src)
 {
@@ -230,9 +263,6 @@ static void l2cap_sock_destruct(struct sock *sk)
 
        skb_queue_purge(&sk->sk_receive_queue);
        skb_queue_purge(&sk->sk_write_queue);
-
-       if (sk->sk_protinfo)
-               kfree(sk->sk_protinfo);
 }
 
 static void l2cap_sock_cleanup_listen(struct sock *parent)
@@ -246,7 +276,7 @@ static void l2cap_sock_cleanup_listen(struct sock *parent)
                l2cap_sock_close(sk);
 
        parent->sk_state  = BT_CLOSED;
-       parent->sk_zapped = 1;
+       sock_set_flag(parent, SOCK_ZAPPED);
 }
 
 /* Kill socket (only if zapped and orphan)
@@ -254,7 +284,7 @@ static void l2cap_sock_cleanup_listen(struct sock *parent)
  */
 static void l2cap_sock_kill(struct sock *sk)
 {
-       if (!sk->sk_zapped || sk->sk_socket)
+       if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
                return;
 
        BT_DBG("sk %p state %d", sk, sk->sk_state);
@@ -286,7 +316,8 @@ static void __l2cap_sock_close(struct sock *sk, int reason)
 
                        req.dcid = __cpu_to_le16(l2cap_pi(sk)->dcid);
                        req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
-                       l2cap_send_req(conn, L2CAP_DISCONN_REQ, sizeof(req), &req);
+                       l2cap_send_cmd(conn, l2cap_get_ident(conn),
+                                       L2CAP_DISCONN_REQ, sizeof(req), &req);
                } else {
                        l2cap_chan_del(sk, reason);
                }
@@ -298,7 +329,7 @@ static void __l2cap_sock_close(struct sock *sk, int reason)
                break;
 
        default:
-               sk->sk_zapped = 1;
+               sock_set_flag(sk, SOCK_ZAPPED);
                break;
        }
 }
@@ -335,19 +366,28 @@ static void l2cap_sock_init(struct sock *sk, struct sock *parent)
        pi->flush_to = L2CAP_DEFAULT_FLUSH_TO;
 }
 
+static struct proto l2cap_proto = {
+       .name           = "L2CAP",
+       .owner          = THIS_MODULE,
+       .obj_size       = sizeof(struct l2cap_pinfo)
+};
+
 static struct sock *l2cap_sock_alloc(struct socket *sock, int proto, int prio)
 {
        struct sock *sk;
 
-       sk = bt_sock_alloc(sock, proto, sizeof(struct l2cap_pinfo), prio);
+       sk = sk_alloc(PF_BLUETOOTH, prio, &l2cap_proto, 1);
        if (!sk)
                return NULL;
 
-       sk_set_owner(sk, THIS_MODULE);
+       sock_init_data(sock, sk);
+       INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 
        sk->sk_destruct = l2cap_sock_destruct;
        sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
 
+       sock_reset_flag(sk, SOCK_ZAPPED);
+
        sk->sk_protocol = proto;
        sk->sk_state    = BT_OPEN;
 
@@ -365,7 +405,8 @@ static int l2cap_sock_create(struct socket *sock, int protocol)
 
        sock->state = SS_UNCONNECTED;
 
-       if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
+       if (sock->type != SOCK_SEQPACKET &&
+                       sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
                return -ESOCKTNOSUPPORT;
 
        if (sock->type == SOCK_RAW && !capable(CAP_NET_RAW))
@@ -459,9 +500,11 @@ static int l2cap_do_connect(struct sock *sk)
        if (hcon->state == BT_CONNECTED) {
                if (sk->sk_type == SOCK_SEQPACKET) {
                        struct l2cap_conn_req req;
+                       l2cap_pi(sk)->ident = l2cap_get_ident(conn);
                        req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
                        req.psm  = l2cap_pi(sk)->psm;
-                       l2cap_send_req(conn, L2CAP_CONN_REQ, sizeof(req), &req);
+                       l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
+                                       L2CAP_CONN_REQ, sizeof(req), &req);
                } else {
                        l2cap_sock_clear_timer(sk);
                        sk->sk_state = BT_CONNECTED;
@@ -732,7 +775,7 @@ static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct ms
                return -EOPNOTSUPP;
 
        /* Check outgoing MTU */
-       if (len > l2cap_pi(sk)->omtu)
+       if (sk->sk_type != SOCK_RAW && len > l2cap_pi(sk)->omtu)
                return -EINVAL;
 
        lock_sock(sk);
@@ -760,7 +803,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, ch
        switch (optname) {
        case L2CAP_OPTIONS:
                len = min_t(unsigned int, sizeof(opts), optlen);
-               if (copy_from_user((char *)&opts, optval, len)) {
+               if (copy_from_user((char *) &opts, optval, len)) {
                        err = -EFAULT;
                        break;
                }
@@ -769,7 +812,7 @@ static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, ch
                break;
 
        case L2CAP_LM:
-               if (get_user(opt, (u32 __user *)optval)) {
+               if (get_user(opt, (u32 __user *) optval)) {
                        err = -EFAULT;
                        break;
                }
@@ -791,7 +834,9 @@ static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, ch
        struct sock *sk = sock->sk;
        struct l2cap_options opts;
        struct l2cap_conninfo cinfo;
-       int len, err = 0; 
+       int len, err = 0;
+
+       BT_DBG("sk %p", sk);
 
        if (get_user(len, optlen))
                return -EFAULT;
@@ -803,15 +848,16 @@ static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, ch
                opts.imtu     = l2cap_pi(sk)->imtu;
                opts.omtu     = l2cap_pi(sk)->omtu;
                opts.flush_to = l2cap_pi(sk)->flush_to;
+               opts.mode     = 0x00;
 
                len = min_t(unsigned int, len, sizeof(opts));
-               if (copy_to_user(optval, (char *)&opts, len))
+               if (copy_to_user(optval, (char *) &opts, len))
                        err = -EFAULT;
 
                break;
 
        case L2CAP_LM:
-               if (put_user(l2cap_pi(sk)->link_mode, (u32 __user *)optval))
+               if (put_user(l2cap_pi(sk)->link_mode, (u32 __user *) optval))
                        err = -EFAULT;
                break;
 
@@ -822,9 +868,10 @@ static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, ch
                }
 
                cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;
+               memcpy(cinfo.dev_class, l2cap_pi(sk)->conn->hcon->dev_class, 3);
 
                len = min_t(unsigned int, len, sizeof(cinfo));
-               if (copy_to_user(optval, (char *)&cinfo, len))
+               if (copy_to_user(optval, (char *) &cinfo, len))
                        err = -EFAULT;
 
                break;
@@ -911,6 +958,26 @@ static inline struct sock *l2cap_get_chan_by_scid(struct l2cap_chan_list *l, u16
        return s;
 }
 
+static struct sock *__l2cap_get_chan_by_ident(struct l2cap_chan_list *l, u8 ident)
+{
+       struct sock *s;
+       for (s = l->head; s; s = l2cap_pi(s)->next_c) {
+               if (l2cap_pi(s)->ident == ident)
+                       break;
+       }
+       return s;
+}
+
+static inline struct sock *l2cap_get_chan_by_ident(struct l2cap_chan_list *l, u8 ident)
+{
+       struct sock *s;
+       read_lock(&l->lock);
+       s = __l2cap_get_chan_by_ident(l, ident);
+       if (s) bh_lock_sock(s);
+       read_unlock(&l->lock);
+       return s;
+}
+
 static u16 l2cap_alloc_cid(struct l2cap_chan_list *l)
 {
        u16 cid = 0x0040;
@@ -1000,14 +1067,15 @@ static void l2cap_chan_del(struct sock *sk, int err)
        }
 
        sk->sk_state  = BT_CLOSED;
-       sk->sk_zapped = 1;
+       sock_set_flag(sk, SOCK_ZAPPED);
 
        if (err)
                sk->sk_err = err;
 
-       if (parent)
+       if (parent) {
+               bt_accept_unlink(sk);
                parent->sk_data_ready(parent, 0);
-       else
+       else
                sk->sk_state_change(sk);
 }
 
@@ -1029,9 +1097,10 @@ static void l2cap_conn_ready(struct l2cap_conn *conn)
                        sk->sk_state_change(sk);
                } else if (sk->sk_state == BT_CONNECT) {
                        struct l2cap_conn_req req;
+                       l2cap_pi(sk)->ident = l2cap_get_ident(conn);
                        req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
                        req.psm  = l2cap_pi(sk)->psm;
-                       l2cap_send_req(conn, L2CAP_CONN_REQ, sizeof(req), &req);
+                       l2cap_send_cmd(conn, l2cap_pi(sk)->ident, L2CAP_CONN_REQ, sizeof(req), &req);
                }
 
                bh_unlock_sock(sk);
@@ -1040,6 +1109,22 @@ static void l2cap_conn_ready(struct l2cap_conn *conn)
        read_unlock(&l->lock);
 }
 
+/* Notify sockets that we cannot guaranty reliability anymore */
+static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err)
+{
+       struct l2cap_chan_list *l = &conn->chan_list;
+       struct sock *sk;
+
+       BT_DBG("conn %p", conn);
+
+       read_lock(&l->lock);
+       for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
+               if (l2cap_pi(sk)->link_mode & L2CAP_LM_RELIABLE)
+                       sk->sk_err = err;
+       }
+       read_unlock(&l->lock);
+}
+
 static void l2cap_chan_ready(struct sock *sk)
 {
        struct sock *parent = bt_sk(sk)->parent;
@@ -1091,27 +1176,6 @@ static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
 }
 
 /* ---- L2CAP signalling commands ---- */
-static inline u8 l2cap_get_ident(struct l2cap_conn *conn)
-{
-       u8 id;
-
-       /* Get next available identificator.
-        *    1 - 199 are used by kernel.
-        *  200 - 254 are used by utilities like l2ping, etc 
-        */
-
-       spin_lock(&conn->lock);
-
-       if (++conn->tx_ident > 199)
-               conn->tx_ident = 1;
-
-       id = conn->tx_ident;
-
-       spin_unlock(&conn->lock);
-
-       return id;
-}
-
 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
                                u8 code, u8 ident, u16 dlen, void *data)
 {
@@ -1170,29 +1234,6 @@ fail:
        return NULL;
 }
 
-static int l2cap_send_req(struct l2cap_conn *conn, u8 code, u16 len, void *data)
-{
-       u8 ident = l2cap_get_ident(conn);
-       struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
-
-       BT_DBG("code 0x%2.2x", code);
-
-       if (!skb)
-               return -ENOMEM;
-       return hci_send_acl(conn->hcon, skb, 0);
-}
-
-static int l2cap_send_rsp(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data)
-{
-       struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
-
-       BT_DBG("code 0x%2.2x", code);
-
-       if (!skb)
-               return -ENOMEM;
-       return hci_send_acl(conn->hcon, skb, 0);
-}
-
 static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val)
 {
        struct l2cap_conf_opt *opt = *ptr;
@@ -1303,7 +1344,7 @@ static int l2cap_build_conf_req(struct sock *sk, void *data)
        if (pi->imtu != L2CAP_DEFAULT_MTU)
                l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, pi->imtu);
 
-       /* FIXME. Need actual value of the flush timeout */
+       /* FIXME: Need actual value of the flush timeout */
        //if (flush_to != L2CAP_DEFAULT_FLUSH_TO)
        //   l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 2, pi->flush_to);
 
@@ -1374,7 +1415,7 @@ static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hd
        result = L2CAP_CR_NO_MEM;
 
        /* Check for backlog size */
-       if (parent->sk_ack_backlog > parent->sk_max_ack_backlog) {
+       if (sk_acceptq_is_full(parent)) {
                BT_DBG("backlog full %d", parent->sk_ack_backlog); 
                goto response;
        }
@@ -1388,7 +1429,7 @@ static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hd
        /* Check if we already have channel with that dcid */
        if (__l2cap_get_chan_by_dcid(list, scid)) {
                write_unlock(&list->lock);
-               sk->sk_zapped = 1;
+               sock_set_flag(sk, SOCK_ZAPPED);
                l2cap_sock_kill(sk);
                goto response;
        }
@@ -1411,8 +1452,9 @@ static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hd
        status = L2CAP_CS_AUTHEN_PEND;
        sk->sk_state = BT_CONNECT2;
        l2cap_pi(sk)->ident = cmd->ident;
-       
-       if (l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT) {
+
+       if ((l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT) ||
+                       (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE)) {
                if (!hci_conn_encrypt(conn->hcon))
                        goto done;
        } else if (l2cap_pi(sk)->link_mode & L2CAP_LM_AUTH) {
@@ -1434,7 +1476,7 @@ sendresp:
        rsp.dcid   = __cpu_to_le16(dcid);
        rsp.result = __cpu_to_le16(result);
        rsp.status = __cpu_to_le16(status);
-       l2cap_send_rsp(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp);
+       l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp);
        return 0;
 }
 
@@ -1452,16 +1494,23 @@ static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hd
 
        BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", dcid, scid, result, status);
 
-       if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
-               return 0;
+       if (scid) {
+               if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
+                       return 0;
+       } else {
+               if (!(sk = l2cap_get_chan_by_ident(&conn->chan_list, cmd->ident)))
+                       return 0;
+       }
 
        switch (result) {
        case L2CAP_CR_SUCCESS:
                sk->sk_state = BT_CONFIG;
+               l2cap_pi(sk)->ident = 0;
                l2cap_pi(sk)->dcid = dcid;
                l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
 
-               l2cap_send_req(conn, L2CAP_CONF_REQ, l2cap_build_conf_req(sk, req), req);
+               l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
+                                       l2cap_build_conf_req(sk, req), req);
                break;
 
        case L2CAP_CR_PEND:
@@ -1496,12 +1545,14 @@ static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr
 
        if (flags & 0x0001) {
                /* Incomplete config. Send empty response. */
-               l2cap_send_rsp(conn, cmd->ident, L2CAP_CONF_RSP, l2cap_build_conf_rsp(sk, rsp, NULL), rsp);
+               l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
+                               l2cap_build_conf_rsp(sk, rsp, NULL), rsp);
                goto unlock;
        }
 
        /* Complete config. */
-       l2cap_send_rsp(conn, cmd->ident, L2CAP_CONF_RSP, l2cap_build_conf_rsp(sk, rsp, &result), rsp);
+       l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
+                       l2cap_build_conf_rsp(sk, rsp, &result), rsp);
 
        if (result)
                goto unlock;
@@ -1514,7 +1565,8 @@ static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr
                l2cap_chan_ready(sk);
        } else if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT)) {
                u8 req[64];
-               l2cap_send_req(conn, L2CAP_CONF_REQ, l2cap_build_conf_req(sk, req), req);
+               l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
+                                       l2cap_build_conf_req(sk, req), req);
        }
 
 unlock:
@@ -1549,8 +1601,8 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
                         * resend config request that we sent earlier. It is
                         * stupid, but it helps qualification testing which
                         * expects at least some response from us. */
-                       l2cap_send_req(conn, L2CAP_CONF_REQ,
-                               l2cap_build_conf_req(sk, req), req);
+                       l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
+                                               l2cap_build_conf_req(sk, req), req);
                        goto done;
                }
 
@@ -1562,7 +1614,8 @@ static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr
                        struct l2cap_disconn_req req;
                        req.dcid = __cpu_to_le16(l2cap_pi(sk)->dcid);
                        req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
-                       l2cap_send_req(conn, L2CAP_DISCONN_REQ, sizeof(req), &req);
+                       l2cap_send_cmd(conn, l2cap_get_ident(conn),
+                                       L2CAP_DISCONN_REQ, sizeof(req), &req);
                }
                goto done;
        }
@@ -1600,7 +1653,7 @@ static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd
 
        rsp.dcid = __cpu_to_le16(l2cap_pi(sk)->scid);
        rsp.scid = __cpu_to_le16(l2cap_pi(sk)->dcid);
-       l2cap_send_rsp(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
+       l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
 
        sk->sk_shutdown = SHUTDOWN_MASK;
 
@@ -1644,7 +1697,7 @@ static inline int l2cap_information_req(struct l2cap_conn *conn, struct l2cap_cm
 
        rsp.type   = __cpu_to_le16(type);
        rsp.result = __cpu_to_le16(L2CAP_IR_NOTSUPP);
-       l2cap_send_rsp(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), &rsp);
+       l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp), &rsp);
 
        return 0;
 }
@@ -1715,7 +1768,7 @@ static inline void l2cap_sig_channel(struct l2cap_conn *conn, struct sk_buff *sk
                        break;
 
                case L2CAP_ECHO_REQ:
-                       l2cap_send_rsp(conn, cmd.ident, L2CAP_ECHO_RSP, cmd.len, data);
+                       l2cap_send_cmd(conn, cmd.ident, L2CAP_ECHO_RSP, cmd.len, data);
                        break;
 
                case L2CAP_ECHO_RSP:
@@ -1741,7 +1794,7 @@ static inline void l2cap_sig_channel(struct l2cap_conn *conn, struct sk_buff *sk
 
                        /* FIXME: Map err to a valid reason */
                        rej.reason = __cpu_to_le16(0);
-                       l2cap_send_rsp(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej);
+                       l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej);
                }
 
                data += cmd.len;
@@ -1920,7 +1973,8 @@ static int l2cap_auth_cfm(struct hci_conn *hcon, u8 status)
                bh_lock_sock(sk);
 
                if (sk->sk_state != BT_CONNECT2 ||
-                               (l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT)) {
+                               (l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT) ||
+                               (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE)) {
                        bh_unlock_sock(sk);
                        continue;
                }
@@ -1938,7 +1992,8 @@ static int l2cap_auth_cfm(struct hci_conn *hcon, u8 status)
                rsp.dcid   = __cpu_to_le16(l2cap_pi(sk)->scid);
                rsp.result = __cpu_to_le16(result);
                rsp.status = __cpu_to_le16(0);
-               l2cap_send_rsp(conn, l2cap_pi(sk)->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp);
+               l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
+                               L2CAP_CONN_RSP, sizeof(rsp), &rsp);
 
                bh_unlock_sock(sk);
        }
@@ -1984,7 +2039,11 @@ static int l2cap_encrypt_cfm(struct hci_conn *hcon, u8 status)
                rsp.dcid   = __cpu_to_le16(l2cap_pi(sk)->scid);
                rsp.result = __cpu_to_le16(result);
                rsp.status = __cpu_to_le16(0);
-               l2cap_send_rsp(conn, l2cap_pi(sk)->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp);
+               l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
+                               L2CAP_CONN_RSP, sizeof(rsp), &rsp);
+
+               if (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE)
+                       hci_conn_change_link_key(hcon);
 
                bh_unlock_sock(sk);
        }
@@ -2011,10 +2070,12 @@ static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 fl
                        kfree_skb(conn->rx_skb);
                        conn->rx_skb = NULL;
                        conn->rx_len = 0;
+                       l2cap_conn_unreliable(conn, ECOMM);
                }
 
                if (skb->len < 2) {
                        BT_ERR("Frame is too short (len %d)", skb->len);
+                       l2cap_conn_unreliable(conn, ECOMM);
                        goto drop;
                }
 
@@ -2032,6 +2093,7 @@ static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 fl
                if (skb->len > len) {
                        BT_ERR("Frame is too long (len %d, expected len %d)",
                                skb->len, len);
+                       l2cap_conn_unreliable(conn, ECOMM);
                        goto drop;
                }
 
@@ -2046,6 +2108,7 @@ static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 fl
 
                if (!conn->rx_len) {
                        BT_ERR("Unexpected continuation frame (len %d)", skb->len);
+                       l2cap_conn_unreliable(conn, ECOMM);
                        goto drop;
                }
 
@@ -2055,6 +2118,7 @@ static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 fl
                        kfree_skb(conn->rx_skb);
                        conn->rx_skb = NULL;
                        conn->rx_len = 0;
+                       l2cap_conn_unreliable(conn, ECOMM);
                        goto drop;
                }
 
@@ -2202,15 +2266,22 @@ static struct hci_proto l2cap_hci_proto = {
 static int __init l2cap_init(void)
 {
        int err;
+       
+       err = proto_register(&l2cap_proto, 0);
+       if (err < 0)
+               return err;
 
-       if ((err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops))) {
+       err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
+       if (err < 0) {
                BT_ERR("L2CAP socket registration failed");
-               return err;
+               goto error;
        }
 
-       if ((err = hci_register_proto(&l2cap_hci_proto))) {
+       err = hci_register_proto(&l2cap_hci_proto);
+       if (err < 0) {
                BT_ERR("L2CAP protocol registration failed");
-               return err;
+               bt_sock_unregister(BTPROTO_L2CAP);
+               goto error;
        }
 
        l2cap_proc_init();
@@ -2219,24 +2290,29 @@ static int __init l2cap_init(void)
        BT_INFO("L2CAP socket layer initialized");
 
        return 0;
+
+error:
+       proto_unregister(&l2cap_proto);
+       return err;
 }
 
 static void __exit l2cap_exit(void)
 {
        l2cap_proc_cleanup();
 
-       /* Unregister socket and protocol */
-       if (bt_sock_unregister(BTPROTO_L2CAP))
+       if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
                BT_ERR("L2CAP socket unregistration failed");
 
-       if (hci_unregister_proto(&l2cap_hci_proto))
+       if (hci_unregister_proto(&l2cap_hci_proto) < 0)
                BT_ERR("L2CAP protocol unregistration failed");
+
+       proto_unregister(&l2cap_proto);
 }
 
 void l2cap_load(void)
 {
        /* Dummy function to trigger automatic L2CAP module loading by
-        * other modules that use L2CAP sockets but don not use any othe
+        * other modules that use L2CAP sockets but don't use any other
         * symbols from it. */
        return;
 }