Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 1010 insertions, 0 deletions

diff --git a/net/bluetooth/rfcomm/sock.c b/net/bluetooth/rfcomm/sock.c
new file mode 100644
index 000000000000..640028a2183c
--- /dev/null
+++ b/net/bluetooth/rfcomm/sock.c
@@ -0,0 +1,1010 @@
+/* 
+   RFCOMM implementation for Linux Bluetooth stack (BlueZ).
+   Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
+   Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>
+
+   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
+   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 
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 
+   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 
+   SOFTWARE IS DISCLAIMED.
+*/
+
+/*
+ * RFCOMM sockets.
+ *
+ * $Id: sock.c,v 1.24 2002/10/03 01:00:34 maxk Exp $
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+
+#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>
+#include <linux/fcntl.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/socket.h>
+#include <linux/skbuff.h>
+#include <linux/list.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <net/sock.h>
+
+#include <asm/system.h>
+#include <asm/uaccess.h>
+
+#include <net/bluetooth/bluetooth.h>
+#include <net/bluetooth/hci_core.h>
+#include <net/bluetooth/l2cap.h>
+#include <net/bluetooth/rfcomm.h>
+
+#ifndef CONFIG_BT_RFCOMM_DEBUG
+#undef  BT_DBG
+#define BT_DBG(D...)
+#endif
+
+static struct proto_ops rfcomm_sock_ops;
+
+static struct bt_sock_list rfcomm_sk_list = {
+        .lock = RW_LOCK_UNLOCKED
+};
+
+static void rfcomm_sock_close(struct sock *sk);
+static void rfcomm_sock_kill(struct sock *sk);
+
+/* ---- DLC callbacks ----
+ *
+ * called under rfcomm_dlc_lock()
+ */
+static void rfcomm_sk_data_ready(struct rfcomm_dlc *d, struct sk_buff *skb)
+{
+        struct sock *sk = d->owner;
+        if (!sk)
+                return;
+
+        atomic_add(skb->len, &sk->sk_rmem_alloc);
+        skb_queue_tail(&sk->sk_receive_queue, skb);
+        sk->sk_data_ready(sk, skb->len);
+
+        if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
+                rfcomm_dlc_throttle(d);
+}
+
+static void rfcomm_sk_state_change(struct rfcomm_dlc *d, int err)
+{
+        struct sock *sk = d->owner, *parent;
+        if (!sk)
+                return;
+
+        BT_DBG("dlc %p state %ld err %d", d, d->state, err);
+
+        bh_lock_sock(sk);
+
+        if (err)
+                sk->sk_err = err;
+
+        sk->sk_state = d->state;
+
+        parent = bt_sk(sk)->parent;
+        if (parent) {
+                if (d->state == BT_CLOSED) {
+                        sock_set_flag(sk, SOCK_ZAPPED);
+                        bt_accept_unlink(sk);
+                }
+                parent->sk_data_ready(parent, 0);
+        } else {
+                if (d->state == BT_CONNECTED)
+                        rfcomm_session_getaddr(d->session, &bt_sk(sk)->src, NULL);
+                sk->sk_state_change(sk);
+        }
+
+        bh_unlock_sock(sk);
+
+        if (parent && sock_flag(sk, SOCK_ZAPPED)) {
+                /* We have to drop DLC lock here, otherwise
+                 * rfcomm_sock_destruct() will dead lock. */
+                rfcomm_dlc_unlock(d);
+                rfcomm_sock_kill(sk);
+                rfcomm_dlc_lock(d);
+        }
+}
+
+/* ---- Socket functions ---- */
+static struct sock *__rfcomm_get_sock_by_addr(u8 channel, bdaddr_t *src)
+{
+        struct sock *sk = NULL;
+        struct hlist_node *node;
+
+        sk_for_each(sk, node, &rfcomm_sk_list.head) {
+                if (rfcomm_pi(sk)->channel == channel && 
+                                !bacmp(&bt_sk(sk)->src, src))
+                        break;
+        }
+
+        return node ? sk : NULL;
+}
+
+/* Find socket with channel and source bdaddr.
+ * Returns closest match.
+ */
+static struct sock *__rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
+{
+        struct sock *sk = NULL, *sk1 = NULL;
+        struct hlist_node *node;
+
+        sk_for_each(sk, node, &rfcomm_sk_list.head) {
+                if (state && sk->sk_state != state)
+                        continue;
+
+                if (rfcomm_pi(sk)->channel == channel) {
+                        /* Exact match. */
+                        if (!bacmp(&bt_sk(sk)->src, src))
+                                break;
+
+                        /* Closest match */
+                        if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
+                                sk1 = sk;
+                }
+        }
+        return node ? sk : sk1;
+}
+
+/* Find socket with given address (channel, src).
+ * Returns locked socket */
+static inline struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
+{
+        struct sock *s;
+        read_lock(&rfcomm_sk_list.lock);
+        s = __rfcomm_get_sock_by_channel(state, channel, src);
+        if (s) bh_lock_sock(s);
+        read_unlock(&rfcomm_sk_list.lock);
+        return s;
+}
+
+static void rfcomm_sock_destruct(struct sock *sk)
+{
+        struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
+
+        BT_DBG("sk %p dlc %p", sk, d);
+
+        skb_queue_purge(&sk->sk_receive_queue);
+        skb_queue_purge(&sk->sk_write_queue);
+
+        rfcomm_dlc_lock(d);
+        rfcomm_pi(sk)->dlc = NULL;
+
+        /* Detach DLC if it's owned by this socket */
+        if (d->owner == sk)
+                d->owner = NULL;
+        rfcomm_dlc_unlock(d);
+
+        rfcomm_dlc_put(d);
+}
+
+static void rfcomm_sock_cleanup_listen(struct sock *parent)
+{
+        struct sock *sk;
+
+        BT_DBG("parent %p", parent);
+
+        /* Close not yet accepted dlcs */
+        while ((sk = bt_accept_dequeue(parent, NULL))) {
+                rfcomm_sock_close(sk);
+                rfcomm_sock_kill(sk);
+        }
+
+        parent->sk_state  = BT_CLOSED;
+        sock_set_flag(parent, SOCK_ZAPPED);
+}
+
+/* Kill socket (only if zapped and orphan)
+ * Must be called on unlocked socket.
+ */
+static void rfcomm_sock_kill(struct sock *sk)
+{
+        if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
+                return;
+
+        BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
+
+        /* Kill poor orphan */
+        bt_sock_unlink(&rfcomm_sk_list, sk);
+        sock_set_flag(sk, SOCK_DEAD);
+        sock_put(sk);
+}
+
+static void __rfcomm_sock_close(struct sock *sk)
+{
+        struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
+
+        BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
+
+        switch (sk->sk_state) {
+        case BT_LISTEN:
+                rfcomm_sock_cleanup_listen(sk);
+                break;
+
+        case BT_CONNECT:
+        case BT_CONNECT2:
+        case BT_CONFIG:
+        case BT_CONNECTED:
+                rfcomm_dlc_close(d, 0);
+
+        default:
+                sock_set_flag(sk, SOCK_ZAPPED);
+                break;
+        }
+}
+
+/* Close socket.
+ * Must be called on unlocked socket.
+ */
+static void rfcomm_sock_close(struct sock *sk)
+{
+        lock_sock(sk);
+        __rfcomm_sock_close(sk);
+        release_sock(sk);
+}
+
+static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
+{
+        struct rfcomm_pinfo *pi = rfcomm_pi(sk);
+
+        BT_DBG("sk %p", sk);
+
+        if (parent) {
+                sk->sk_type = parent->sk_type;
+                pi->link_mode = rfcomm_pi(parent)->link_mode;
+        } else {
+                pi->link_mode = 0;
+        }
+
+        pi->dlc->link_mode = pi->link_mode;
+}
+
+static struct proto rfcomm_proto = {
+        .name           = "RFCOMM",
+        .owner          = THIS_MODULE,
+        .obj_size       = sizeof(struct rfcomm_pinfo)
+};
+
+static struct sock *rfcomm_sock_alloc(struct socket *sock, int proto, int prio)
+{
+        struct rfcomm_dlc *d;
+        struct sock *sk;
+
+        sk = sk_alloc(PF_BLUETOOTH, prio, &rfcomm_proto, 1);
+        if (!sk)
+                return NULL;
+
+        sock_init_data(sock, sk);
+        INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
+
+        d = rfcomm_dlc_alloc(prio);
+        if (!d) {
+                sk_free(sk);
+                return NULL;
+        }
+
+        d->data_ready   = rfcomm_sk_data_ready;
+        d->state_change = rfcomm_sk_state_change;
+
+        rfcomm_pi(sk)->dlc = d;
+        d->owner = sk;
+
+        sk->sk_destruct = rfcomm_sock_destruct;
+        sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
+
+        sk->sk_sndbuf   = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
+        sk->sk_rcvbuf   = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
+
+        sock_reset_flag(sk, SOCK_ZAPPED);
+
+        sk->sk_protocol = proto;
+        sk->sk_state    = BT_OPEN;
+
+        bt_sock_link(&rfcomm_sk_list, sk);
+
+        BT_DBG("sk %p", sk);
+        return sk;
+}
+
+static int rfcomm_sock_create(struct socket *sock, int protocol)
+{
+        struct sock *sk;
+
+        BT_DBG("sock %p", sock);
+
+        sock->state = SS_UNCONNECTED;
+
+        if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
+                return -ESOCKTNOSUPPORT;
+
+        sock->ops = &rfcomm_sock_ops;
+
+        if (!(sk = rfcomm_sock_alloc(sock, protocol, GFP_KERNEL)))
+                return -ENOMEM;
+
+        rfcomm_sock_init(sk, NULL);
+        return 0;
+}
+
+static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
+{
+        struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
+        struct sock *sk = sock->sk;
+        int err = 0;
+
+        BT_DBG("sk %p %s", sk, batostr(&sa->rc_bdaddr));
+
+        if (!addr || addr->sa_family != AF_BLUETOOTH)
+                return -EINVAL;
+
+        lock_sock(sk);
+
+        if (sk->sk_state != BT_OPEN) {
+                err = -EBADFD;
+                goto done;
+        }
+
+        write_lock_bh(&rfcomm_sk_list.lock);
+
+        if (sa->rc_channel && __rfcomm_get_sock_by_addr(sa->rc_channel, &sa->rc_bdaddr)) {
+                err = -EADDRINUSE;
+        } else {
+                /* Save source address */
+                bacpy(&bt_sk(sk)->src, &sa->rc_bdaddr);
+                rfcomm_pi(sk)->channel = sa->rc_channel;
+                sk->sk_state = BT_BOUND;
+        }
+
+        write_unlock_bh(&rfcomm_sk_list.lock);
+
+done:
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
+{
+        struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
+        struct sock *sk = sock->sk;
+        struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
+        int err = 0;
+
+        BT_DBG("sk %p", sk);
+
+        if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_rc))
+                return -EINVAL;
+
+        if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
+                return -EBADFD;
+
+        if (sk->sk_type != SOCK_STREAM)
+                return -EINVAL;
+
+        lock_sock(sk);
+
+        sk->sk_state = BT_CONNECT;
+        bacpy(&bt_sk(sk)->dst, &sa->rc_bdaddr);
+        rfcomm_pi(sk)->channel = sa->rc_channel;
+
+        err = rfcomm_dlc_open(d, &bt_sk(sk)->src, &sa->rc_bdaddr, sa->rc_channel);
+        if (!err)
+                err = bt_sock_wait_state(sk, BT_CONNECTED,
+                                sock_sndtimeo(sk, flags & O_NONBLOCK));
+
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_listen(struct socket *sock, int backlog)
+{
+        struct sock *sk = sock->sk;
+        int err = 0;
+
+        BT_DBG("sk %p backlog %d", sk, backlog);
+
+        lock_sock(sk);
+
+        if (sk->sk_state != BT_BOUND) {
+                err = -EBADFD;
+                goto done;
+        }
+
+        if (!rfcomm_pi(sk)->channel) {
+                bdaddr_t *src = &bt_sk(sk)->src;
+                u8 channel;
+
+                err = -EINVAL;
+
+                write_lock_bh(&rfcomm_sk_list.lock);
+
+                for (channel = 1; channel < 31; channel++)
+                        if (!__rfcomm_get_sock_by_addr(channel, src)) {
+                                rfcomm_pi(sk)->channel = channel;
+                                err = 0;
+                                break;
+                        }
+
+                write_unlock_bh(&rfcomm_sk_list.lock);
+
+                if (err < 0)
+                        goto done;
+        }
+
+        sk->sk_max_ack_backlog = backlog;
+        sk->sk_ack_backlog = 0;
+        sk->sk_state = BT_LISTEN;
+
+done:
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
+{
+        DECLARE_WAITQUEUE(wait, current);
+        struct sock *sk = sock->sk, *nsk;
+        long timeo;
+        int err = 0;
+
+        lock_sock(sk);
+
+        if (sk->sk_state != BT_LISTEN) {
+                err = -EBADFD;
+                goto done;
+        }
+
+        timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
+
+        BT_DBG("sk %p timeo %ld", sk, timeo);
+
+        /* Wait for an incoming connection. (wake-one). */
+        add_wait_queue_exclusive(sk->sk_sleep, &wait);
+        while (!(nsk = bt_accept_dequeue(sk, newsock))) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                if (!timeo) {
+                        err = -EAGAIN;
+                        break;
+                }
+
+                release_sock(sk);
+                timeo = schedule_timeout(timeo);
+                lock_sock(sk);
+
+                if (sk->sk_state != BT_LISTEN) {
+                        err = -EBADFD;
+                        break;
+                }
+
+                if (signal_pending(current)) {
+                        err = sock_intr_errno(timeo);
+                        break;
+                }
+        }
+        set_current_state(TASK_RUNNING);
+        remove_wait_queue(sk->sk_sleep, &wait);
+
+        if (err)
+                goto done;
+
+        newsock->state = SS_CONNECTED;
+
+        BT_DBG("new socket %p", nsk);
+
+done:
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
+{
+        struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
+        struct sock *sk = sock->sk;
+
+        BT_DBG("sock %p, sk %p", sock, sk);
+
+        sa->rc_family  = AF_BLUETOOTH;
+        sa->rc_channel = rfcomm_pi(sk)->channel;
+        if (peer)
+                bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
+        else
+                bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
+
+        *len = sizeof(struct sockaddr_rc);
+        return 0;
+}
+
+static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
+                               struct msghdr *msg, size_t len)
+{
+        struct sock *sk = sock->sk;
+        struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
+        struct sk_buff *skb;
+        int err;
+        int sent = 0;
+
+        if (msg->msg_flags & MSG_OOB)
+                return -EOPNOTSUPP;
+
+        if (sk->sk_shutdown & SEND_SHUTDOWN)
+                return -EPIPE;
+
+        BT_DBG("sock %p, sk %p", sock, sk);
+
+        lock_sock(sk);
+
+        while (len) {
+                size_t size = min_t(size_t, len, d->mtu);
+                
+                skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
+                                msg->msg_flags & MSG_DONTWAIT, &err);
+                if (!skb)
+                        break;
+                skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
+
+                err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
+                if (err) {
+                        kfree_skb(skb);
+                        sent = err;
+                        break;
+                }
+
+                err = rfcomm_dlc_send(d, skb);
+                if (err < 0) {
+                        kfree_skb(skb);
+                        break;
+                }
+
+                sent += size;
+                len  -= size;
+        }
+
+        release_sock(sk);
+
+        return sent ? sent : err;
+}
+
+static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
+{
+        DECLARE_WAITQUEUE(wait, current);
+
+        add_wait_queue(sk->sk_sleep, &wait);
+        for (;;) {
+                set_current_state(TASK_INTERRUPTIBLE);
+
+                if (skb_queue_len(&sk->sk_receive_queue) || sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN) ||
+                                signal_pending(current) || !timeo)
+                        break;
+
+                set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
+                release_sock(sk);
+                timeo = schedule_timeout(timeo);
+                lock_sock(sk);
+                clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
+        }
+
+        __set_current_state(TASK_RUNNING);
+        remove_wait_queue(sk->sk_sleep, &wait);
+        return timeo;
+}
+
+static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
+                               struct msghdr *msg, size_t size, int flags)
+{
+        struct sock *sk = sock->sk;
+        int err = 0;
+        size_t target, copied = 0;
+        long timeo;
+
+        if (flags & MSG_OOB)
+                return -EOPNOTSUPP;
+
+        msg->msg_namelen = 0;
+
+        BT_DBG("sk %p size %d", sk, size);
+
+        lock_sock(sk);
+
+        target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
+        timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
+
+        do {
+                struct sk_buff *skb;
+                int chunk;
+
+                skb = skb_dequeue(&sk->sk_receive_queue);
+                if (!skb) {
+                        if (copied >= target)
+                                break;
+
+                        if ((err = sock_error(sk)) != 0)
+                                break;
+                        if (sk->sk_shutdown & RCV_SHUTDOWN)
+                                break;
+
+                        err = -EAGAIN;
+                        if (!timeo)
+                                break;
+
+                        timeo = rfcomm_sock_data_wait(sk, timeo);
+
+                        if (signal_pending(current)) {
+                                err = sock_intr_errno(timeo);
+                                goto out;
+                        }
+                        continue;
+                }
+
+                chunk = min_t(unsigned int, skb->len, size);
+                if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                        if (!copied)
+                                copied = -EFAULT;
+                        break;
+                }
+                copied += chunk;
+                size   -= chunk;
+
+                if (!(flags & MSG_PEEK)) {
+                        atomic_sub(chunk, &sk->sk_rmem_alloc);
+
+                        skb_pull(skb, chunk);
+                        if (skb->len) {
+                                skb_queue_head(&sk->sk_receive_queue, skb);
+                                break;
+                        }
+                        kfree_skb(skb);
+
+                } else {
+                        /* put message back and return */
+                        skb_queue_head(&sk->sk_receive_queue, skb);
+                        break;
+                }
+        } while (size);
+
+out:
+        if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
+                rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
+
+        release_sock(sk);
+        return copied ? : err;
+}
+
+static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
+{
+        struct sock *sk = sock->sk;
+        int err = 0;
+        u32 opt;
+
+        BT_DBG("sk %p", sk);
+
+        lock_sock(sk);
+
+        switch (optname) {
+        case RFCOMM_LM:
+                if (get_user(opt, (u32 __user *) optval)) {
+                        err = -EFAULT;
+                        break;
+                }
+
+                rfcomm_pi(sk)->link_mode = opt;
+                break;
+
+        default:
+                err = -ENOPROTOOPT;
+                break;
+        }
+
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
+{
+        struct sock *sk = sock->sk;
+        struct sock *l2cap_sk;
+        struct rfcomm_conninfo cinfo;
+        int len, err = 0;
+
+        BT_DBG("sk %p", sk);
+
+        if (get_user(len, optlen))
+                return -EFAULT;
+
+        lock_sock(sk);
+
+        switch (optname) {
+        case RFCOMM_LM:
+                if (put_user(rfcomm_pi(sk)->link_mode, (u32 __user *) optval))
+                        err = -EFAULT;
+                break;
+
+        case RFCOMM_CONNINFO:
+                if (sk->sk_state != BT_CONNECTED) {
+                        err = -ENOTCONN;
+                        break;
+                }
+
+                l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
+
+                cinfo.hci_handle = l2cap_pi(l2cap_sk)->conn->hcon->handle;
+                memcpy(cinfo.dev_class, l2cap_pi(l2cap_sk)->conn->hcon->dev_class, 3);
+
+                len = min_t(unsigned int, len, sizeof(cinfo));
+                if (copy_to_user(optval, (char *) &cinfo, len))
+                        err = -EFAULT;
+
+                break;
+
+        default:
+                err = -ENOPROTOOPT;
+                break;
+        }
+
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
+{
+        struct sock *sk = sock->sk;
+        int err;
+
+        lock_sock(sk);
+
+#ifdef CONFIG_BT_RFCOMM_TTY
+        err = rfcomm_dev_ioctl(sk, cmd, (void __user *)arg);
+#else
+        err = -EOPNOTSUPP;
+#endif
+
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_shutdown(struct socket *sock, int how)
+{
+        struct sock *sk = sock->sk;
+        int err = 0;
+
+        BT_DBG("sock %p, sk %p", sock, sk);
+
+        if (!sk) return 0;
+
+        lock_sock(sk);
+        if (!sk->sk_shutdown) {
+                sk->sk_shutdown = SHUTDOWN_MASK;
+                __rfcomm_sock_close(sk);
+
+                if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
+                        err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
+        }
+        release_sock(sk);
+        return err;
+}
+
+static int rfcomm_sock_release(struct socket *sock)
+{
+        struct sock *sk = sock->sk;
+        int err;
+
+        BT_DBG("sock %p, sk %p", sock, sk);
+
+        if (!sk)
+                return 0;
+
+        err = rfcomm_sock_shutdown(sock, 2);
+
+        sock_orphan(sk);
+        rfcomm_sock_kill(sk);
+        return err;
+}
+
+/* ---- RFCOMM core layer callbacks ---- 
+ *
+ * called under rfcomm_lock()
+ */
+int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
+{
+        struct sock *sk, *parent;
+        bdaddr_t src, dst;
+        int result = 0;
+
+        BT_DBG("session %p channel %d", s, channel);
+
+        rfcomm_session_getaddr(s, &src, &dst);
+
+        /* Check if we have socket listening on channel */
+        parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
+        if (!parent)
+                return 0;
+
+        /* Check for backlog size */
+        if (sk_acceptq_is_full(parent)) {
+                BT_DBG("backlog full %d", parent->sk_ack_backlog); 
+                goto done;
+        }
+
+        sk = rfcomm_sock_alloc(NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
+        if (!sk)
+                goto done;
+
+        rfcomm_sock_init(sk, parent);
+        bacpy(&bt_sk(sk)->src, &src);
+        bacpy(&bt_sk(sk)->dst, &dst);
+        rfcomm_pi(sk)->channel = channel;
+
+        sk->sk_state = BT_CONFIG;
+        bt_accept_enqueue(parent, sk);
+
+        /* Accept connection and return socket DLC */
+        *d = rfcomm_pi(sk)->dlc;
+        result = 1;
+
+done:
+        bh_unlock_sock(parent);
+        return result;
+}
+
+/* ---- Proc fs support ---- */
+#ifdef CONFIG_PROC_FS
+static void *rfcomm_seq_start(struct seq_file *seq, loff_t *pos)
+{
+        struct sock *sk;
+        struct hlist_node *node;
+        loff_t l = *pos;
+
+        read_lock_bh(&rfcomm_sk_list.lock);
+
+        sk_for_each(sk, node, &rfcomm_sk_list.head)
+                if (!l--)
+                        return sk;
+        return NULL;
+}
+
+static void *rfcomm_seq_next(struct seq_file *seq, void *e, loff_t *pos)
+{
+        struct sock *sk = e;
+        (*pos)++;
+        return sk_next(sk);
+}
+
+static void rfcomm_seq_stop(struct seq_file *seq, void *e)
+{
+        read_unlock_bh(&rfcomm_sk_list.lock);
+}
+
+static int  rfcomm_seq_show(struct seq_file *seq, void *e)
+{
+        struct sock *sk = e;
+        seq_printf(seq, "%s %s %d %d\n",
+                        batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
+                        sk->sk_state, rfcomm_pi(sk)->channel);
+        return 0;
+}
+
+static struct seq_operations rfcomm_seq_ops = {
+        .start  = rfcomm_seq_start,
+        .next   = rfcomm_seq_next,
+        .stop   = rfcomm_seq_stop,
+        .show   = rfcomm_seq_show 
+};
+
+static int rfcomm_seq_open(struct inode *inode, struct file *file)
+{
+        return seq_open(file, &rfcomm_seq_ops);
+}
+
+static struct file_operations rfcomm_seq_fops = {
+        .owner   = THIS_MODULE,
+        .open    = rfcomm_seq_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = seq_release,
+};
+
+static int  __init rfcomm_sock_proc_init(void)
+{
+        struct proc_dir_entry *p = create_proc_entry("sock", S_IRUGO, proc_bt_rfcomm);
+        if (!p)
+                return -ENOMEM;
+        p->proc_fops = &rfcomm_seq_fops;
+        return 0;
+}
+
+static void __exit rfcomm_sock_proc_cleanup(void)
+{
+        remove_proc_entry("sock", proc_bt_rfcomm);
+}
+
+#else /* CONFIG_PROC_FS */
+
+static int  __init rfcomm_sock_proc_init(void)
+{
+        return 0;
+}
+
+static void __exit rfcomm_sock_proc_cleanup(void)
+{
+        return;
+}
+#endif /* CONFIG_PROC_FS */
+
+static struct proto_ops rfcomm_sock_ops = {
+        .family         = PF_BLUETOOTH,
+        .owner          = THIS_MODULE,
+        .release        = rfcomm_sock_release,
+        .bind           = rfcomm_sock_bind,
+        .connect        = rfcomm_sock_connect,
+        .listen         = rfcomm_sock_listen,
+        .accept         = rfcomm_sock_accept,
+        .getname        = rfcomm_sock_getname,
+        .sendmsg        = rfcomm_sock_sendmsg,
+        .recvmsg        = rfcomm_sock_recvmsg,
+        .shutdown       = rfcomm_sock_shutdown,
+        .setsockopt     = rfcomm_sock_setsockopt,
+        .getsockopt     = rfcomm_sock_getsockopt,
+        .ioctl          = rfcomm_sock_ioctl,
+        .poll           = bt_sock_poll,
+        .socketpair     = sock_no_socketpair,
+        .mmap           = sock_no_mmap
+};
+
+static struct net_proto_family rfcomm_sock_family_ops = {
+        .family         = PF_BLUETOOTH,
+        .owner          = THIS_MODULE,
+        .create         = rfcomm_sock_create
+};
+
+int  __init rfcomm_init_sockets(void)
+{
+        int err;
+
+        err = proto_register(&rfcomm_proto, 0);
+        if (err < 0)
+                return err;
+
+        err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops);
+        if (err < 0)
+                goto error;
+
+        rfcomm_sock_proc_init();
+
+        BT_INFO("RFCOMM socket layer initialized");
+
+        return 0;
+
+error:
+        BT_ERR("RFCOMM socket layer registration failed");
+        proto_unregister(&rfcomm_proto);
+        return err;
+}
+
+void __exit rfcomm_cleanup_sockets(void)
+{
+        rfcomm_sock_proc_cleanup();
+
+        if (bt_sock_unregister(BTPROTO_RFCOMM) < 0)
+                BT_ERR("RFCOMM socket layer unregistration failed");
+
+        proto_unregister(&rfcomm_proto);
+}