/*

     BlueZ - Bluetooth protocol stack for Linux
     Copyright (C) 2000-2001 Qualcomm Incorporated

     Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>

     Copyright (C) 2010 Google Inc.

     Copyright (C) 2011 ProFUSION Embedded Systems

  
     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

     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.
  */

  /* Bluetooth L2CAP core. */

  #include <linux/module.h>
  
  #include <linux/types.h>

  #include <linux/capability.h>

  #include <linux/errno.h>
  #include <linux/kernel.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/device.h>

  #include <linux/debugfs.h>
  #include <linux/seq_file.h>

  #include <linux/uaccess.h>

  #include <linux/crc16.h>

  #include <net/sock.h>
  
  #include <asm/system.h>

  #include <asm/unaligned.h>
  
  #include <net/bluetooth/bluetooth.h>
  #include <net/bluetooth/hci_core.h>
  #include <net/bluetooth/l2cap.h>

  #include <net/bluetooth/smp.h>

  bool disable_ertm;

  static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN;

  static u8 l2cap_fixed_chan[8] = { L2CAP_FC_L2CAP, };

  static LIST_HEAD(chan_list);
  static DEFINE_RWLOCK(chan_list_lock);

  static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
  				u8 code, u8 ident, u16 dlen, void *data);

  static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len,
  								void *data);

  static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data);

  static void l2cap_send_disconn_req(struct l2cap_conn *conn,
  				struct l2cap_chan *chan, int err);

  static int l2cap_ertm_data_rcv(struct sock *sk, struct sk_buff *skb);

  /* ---- L2CAP channels ---- */

  static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, u16 cid)

  {

  	struct l2cap_chan *c, *r = NULL;

  	rcu_read_lock();
  
  	list_for_each_entry_rcu(c, &conn->chan_l, list) {
  		if (c->dcid == cid) {
  			r = c;
  			break;
  		}

  	}

  
  	rcu_read_unlock();
  	return r;

  }

  static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)

  {

  	struct l2cap_chan *c, *r = NULL;

  	rcu_read_lock();
  
  	list_for_each_entry_rcu(c, &conn->chan_l, list) {
  		if (c->scid == cid) {
  			r = c;
  			break;
  		}

  	}

  
  	rcu_read_unlock();
  	return r;

  }
  
  /* Find channel with given SCID.
   * Returns locked socket */

  static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)

  {

  	struct l2cap_chan *c;

  	c = __l2cap_get_chan_by_scid(conn, cid);

  	if (c)

  		lock_sock(c->sk);

  	return c;

  }

  static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident)

  {

  	struct l2cap_chan *c, *r = NULL;

  	rcu_read_lock();
  
  	list_for_each_entry_rcu(c, &conn->chan_l, list) {
  		if (c->ident == ident) {
  			r = c;
  			break;
  		}

  	}

  
  	rcu_read_unlock();
  	return r;

  }

  static inline struct l2cap_chan *l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident)

  {

  	struct l2cap_chan *c;

  	c = __l2cap_get_chan_by_ident(conn, ident);

  	if (c)

  		lock_sock(c->sk);

  	return c;

  }

  static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src)

  {

  	struct l2cap_chan *c;

  	list_for_each_entry(c, &chan_list, global_l) {
  		if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src))

  			return c;

  	}

  	return NULL;

  }
  
  int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm)
  {

  	int err;

  	write_lock(&chan_list_lock);

  	if (psm && __l2cap_global_chan_by_addr(psm, src)) {

  		err = -EADDRINUSE;
  		goto done;

  	}

  	if (psm) {
  		chan->psm = psm;
  		chan->sport = psm;
  		err = 0;
  	} else {
  		u16 p;
  
  		err = -EINVAL;
  		for (p = 0x1001; p < 0x1100; p += 2)

  			if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) {

  				chan->psm   = cpu_to_le16(p);
  				chan->sport = cpu_to_le16(p);
  				err = 0;
  				break;
  			}
  	}

  done:

  	write_unlock(&chan_list_lock);

  	return err;

  }
  
  int l2cap_add_scid(struct l2cap_chan *chan,  __u16 scid)
  {

  	write_lock(&chan_list_lock);

  
  	chan->scid = scid;

  	write_unlock(&chan_list_lock);

  
  	return 0;
  }

  static u16 l2cap_alloc_cid(struct l2cap_conn *conn)

  {

  	u16 cid = L2CAP_CID_DYN_START;

  	for (; cid < L2CAP_CID_DYN_END; cid++) {

  		if (!__l2cap_get_chan_by_scid(conn, cid))

  			return cid;
  	}
  
  	return 0;
  }

  static char *state_to_string(int state)
  {
  	switch(state) {
  	case BT_CONNECTED:
  		return "BT_CONNECTED";
  	case BT_OPEN:
  		return "BT_OPEN";
  	case BT_BOUND:
  		return "BT_BOUND";
  	case BT_LISTEN:
  		return "BT_LISTEN";
  	case BT_CONNECT:
  		return "BT_CONNECT";
  	case BT_CONNECT2:
  		return "BT_CONNECT2";
  	case BT_CONFIG:
  		return "BT_CONFIG";
  	case BT_DISCONN:
  		return "BT_DISCONN";
  	case BT_CLOSED:
  		return "BT_CLOSED";
  	}
  
  	return "invalid state";
  }

  static void l2cap_state_change(struct l2cap_chan *chan, int state)
  {

  	BT_DBG("%p %s -> %s", chan, state_to_string(chan->state),
  						state_to_string(state));

  	chan->state = state;
  	chan->ops->state_change(chan->data, state);
  }

  static void l2cap_chan_timeout(struct work_struct *work)

  {

  	struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
  							chan_timer.work);

  	struct sock *sk = chan->sk;
  	int reason;

  	BT_DBG("chan %p state %d", chan, chan->state);

  	lock_sock(sk);

  	if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG)

  		reason = ECONNREFUSED;

  	else if (chan->state == BT_CONNECT &&

  					chan->sec_level != BT_SECURITY_SDP)
  		reason = ECONNREFUSED;
  	else
  		reason = ETIMEDOUT;

  	l2cap_chan_close(chan, reason);

  	release_sock(sk);

  	chan->ops->close(chan->data);

  	l2cap_chan_put(chan);

  }

  struct l2cap_chan *l2cap_chan_create(struct sock *sk)

  {
  	struct l2cap_chan *chan;
  
  	chan = kzalloc(sizeof(*chan), GFP_ATOMIC);
  	if (!chan)
  		return NULL;
  
  	chan->sk = sk;

  	write_lock(&chan_list_lock);

  	list_add(&chan->global_l, &chan_list);

  	write_unlock(&chan_list_lock);

  	INIT_DELAYED_WORK(&chan->chan_timer, l2cap_chan_timeout);

  	chan->state = BT_OPEN;

  	atomic_set(&chan->refcnt, 1);

  	BT_DBG("sk %p chan %p", sk, chan);

  	return chan;
  }

  void l2cap_chan_destroy(struct l2cap_chan *chan)

  {

  	write_lock(&chan_list_lock);

  	list_del(&chan->global_l);

  	write_unlock(&chan_list_lock);

  	l2cap_chan_put(chan);

  }

  static void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)

  {

  	BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn,

  			chan->psm, chan->dcid);

  	conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;

  	chan->conn = conn;

  	if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED) {

  		if (conn->hcon->type == LE_LINK) {
  			/* LE connection */

  			chan->omtu = L2CAP_LE_DEFAULT_MTU;

  			chan->scid = L2CAP_CID_LE_DATA;
  			chan->dcid = L2CAP_CID_LE_DATA;

  		} else {
  			/* Alloc CID for connection-oriented socket */

  			chan->scid = l2cap_alloc_cid(conn);

  			chan->omtu = L2CAP_DEFAULT_MTU;

  		}

  	} else if (chan->chan_type == L2CAP_CHAN_CONN_LESS) {

  		/* Connectionless socket */

  		chan->scid = L2CAP_CID_CONN_LESS;
  		chan->dcid = L2CAP_CID_CONN_LESS;

  		chan->omtu = L2CAP_DEFAULT_MTU;

  	} else {
  		/* Raw socket can send/recv signalling messages only */

  		chan->scid = L2CAP_CID_SIGNALING;
  		chan->dcid = L2CAP_CID_SIGNALING;

  		chan->omtu = L2CAP_DEFAULT_MTU;

  	}

  	chan->local_id		= L2CAP_BESTEFFORT_ID;
  	chan->local_stype	= L2CAP_SERV_BESTEFFORT;
  	chan->local_msdu	= L2CAP_DEFAULT_MAX_SDU_SIZE;
  	chan->local_sdu_itime	= L2CAP_DEFAULT_SDU_ITIME;
  	chan->local_acc_lat	= L2CAP_DEFAULT_ACC_LAT;
  	chan->local_flush_to	= L2CAP_DEFAULT_FLUSH_TO;

  	l2cap_chan_hold(chan);

  	list_add_rcu(&chan->list, &conn->chan_l);

  }

  /* Delete channel.

   * Must be called on the locked socket. */

  static void l2cap_chan_del(struct l2cap_chan *chan, int err)

  {

  	struct sock *sk = chan->sk;

  	struct l2cap_conn *conn = chan->conn;

  	struct sock *parent = bt_sk(sk)->parent;

  	__clear_chan_timer(chan);

  	BT_DBG("chan %p, conn %p, err %d", chan, conn, err);

  	if (conn) {

  		/* Delete from channel list */

  		list_del_rcu(&chan->list);
  		synchronize_rcu();

  		l2cap_chan_put(chan);

  		chan->conn = NULL;

  		hci_conn_put(conn->hcon);
  	}

  	l2cap_state_change(chan, BT_CLOSED);

  	sock_set_flag(sk, SOCK_ZAPPED);
  
  	if (err)
  		sk->sk_err = err;
  
  	if (parent) {
  		bt_accept_unlink(sk);
  		parent->sk_data_ready(parent, 0);
  	} else
  		sk->sk_state_change(sk);

  	if (!(test_bit(CONF_OUTPUT_DONE, &chan->conf_state) &&
  			test_bit(CONF_INPUT_DONE, &chan->conf_state)))

  		return;

  	skb_queue_purge(&chan->tx_q);

  	if (chan->mode == L2CAP_MODE_ERTM) {

  		struct srej_list *l, *tmp;

  		__clear_retrans_timer(chan);
  		__clear_monitor_timer(chan);
  		__clear_ack_timer(chan);

  		skb_queue_purge(&chan->srej_q);

  		list_for_each_entry_safe(l, tmp, &chan->srej_l, list) {

  			list_del(&l->list);
  			kfree(l);
  		}
  	}

  }

  static void l2cap_chan_cleanup_listen(struct sock *parent)
  {
  	struct sock *sk;
  
  	BT_DBG("parent %p", parent);
  
  	/* Close not yet accepted channels */

  	while ((sk = bt_accept_dequeue(parent, NULL))) {

  		struct l2cap_chan *chan = l2cap_pi(sk)->chan;

  		__clear_chan_timer(chan);

  		lock_sock(sk);

  		l2cap_chan_close(chan, ECONNRESET);

  		release_sock(sk);

  		chan->ops->close(chan->data);

  	}

  }

  void l2cap_chan_close(struct l2cap_chan *chan, int reason)

  {
  	struct l2cap_conn *conn = chan->conn;
  	struct sock *sk = chan->sk;

  	BT_DBG("chan %p state %d socket %p", chan, chan->state, sk->sk_socket);

  	switch (chan->state) {

  	case BT_LISTEN:
  		l2cap_chan_cleanup_listen(sk);

  
  		l2cap_state_change(chan, BT_CLOSED);
  		sock_set_flag(sk, SOCK_ZAPPED);

  		break;
  
  	case BT_CONNECTED:
  	case BT_CONFIG:

  		if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED &&

  					conn->hcon->type == ACL_LINK) {

  			__clear_chan_timer(chan);
  			__set_chan_timer(chan, sk->sk_sndtimeo);

  			l2cap_send_disconn_req(conn, chan, reason);
  		} else
  			l2cap_chan_del(chan, reason);
  		break;
  
  	case BT_CONNECT2:

  		if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED &&

  					conn->hcon->type == ACL_LINK) {
  			struct l2cap_conn_rsp rsp;
  			__u16 result;
  
  			if (bt_sk(sk)->defer_setup)
  				result = L2CAP_CR_SEC_BLOCK;
  			else
  				result = L2CAP_CR_BAD_PSM;

  			l2cap_state_change(chan, BT_DISCONN);

  
  			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,
  							sizeof(rsp), &rsp);
  		}
  
  		l2cap_chan_del(chan, reason);
  		break;
  
  	case BT_CONNECT:
  	case BT_DISCONN:
  		l2cap_chan_del(chan, reason);
  		break;
  
  	default:
  		sock_set_flag(sk, SOCK_ZAPPED);
  		break;
  	}
  }

  static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan)

  {

  	if (chan->chan_type == L2CAP_CHAN_RAW) {

  		switch (chan->sec_level) {

  		case BT_SECURITY_HIGH:
  			return HCI_AT_DEDICATED_BONDING_MITM;
  		case BT_SECURITY_MEDIUM:
  			return HCI_AT_DEDICATED_BONDING;
  		default:
  			return HCI_AT_NO_BONDING;
  		}

  	} else if (chan->psm == cpu_to_le16(0x0001)) {

  		if (chan->sec_level == BT_SECURITY_LOW)
  			chan->sec_level = BT_SECURITY_SDP;

  		if (chan->sec_level == BT_SECURITY_HIGH)

  			return HCI_AT_NO_BONDING_MITM;

  		else

  			return HCI_AT_NO_BONDING;

  	} else {

  		switch (chan->sec_level) {

  		case BT_SECURITY_HIGH:

  			return HCI_AT_GENERAL_BONDING_MITM;

  		case BT_SECURITY_MEDIUM:

  			return HCI_AT_GENERAL_BONDING;

  		default:

  			return HCI_AT_NO_BONDING;

  		}

  	}

  }
  
  /* Service level security */

  int l2cap_chan_check_security(struct l2cap_chan *chan)

  {

  	struct l2cap_conn *conn = chan->conn;

  	__u8 auth_type;

  	auth_type = l2cap_get_auth_type(chan);

  	return hci_conn_security(conn->hcon, chan->sec_level, auth_type);

  }

  static 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 void 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);

  	u8 flags;

  
  	BT_DBG("code 0x%2.2x", code);
  
  	if (!skb)

  		return;

  	if (lmp_no_flush_capable(conn->hcon->hdev))
  		flags = ACL_START_NO_FLUSH;
  	else
  		flags = ACL_START;

  	bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON;

  	skb->priority = HCI_PRIO_MAX;

  	hci_send_acl(conn->hchan, skb, flags);
  }
  
  static void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb)
  {
  	struct hci_conn *hcon = chan->conn->hcon;
  	u16 flags;
  
  	BT_DBG("chan %p, skb %p len %d priority %u", chan, skb, skb->len,
  							skb->priority);
  
  	if (!test_bit(FLAG_FLUSHABLE, &chan->flags) &&
  					lmp_no_flush_capable(hcon->hdev))
  		flags = ACL_START_NO_FLUSH;
  	else
  		flags = ACL_START;

  	bt_cb(skb)->force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
  	hci_send_acl(chan->conn->hchan, skb, flags);

  }

  static inline void l2cap_send_sframe(struct l2cap_chan *chan, u32 control)

  {
  	struct sk_buff *skb;
  	struct l2cap_hdr *lh;

  	struct l2cap_conn *conn = chan->conn;

  	int count, hlen;

  	if (chan->state != BT_CONNECTED)

  		return;

  	if (test_bit(FLAG_EXT_CTRL, &chan->flags))
  		hlen = L2CAP_EXT_HDR_SIZE;
  	else
  		hlen = L2CAP_ENH_HDR_SIZE;

  	if (chan->fcs == L2CAP_FCS_CRC16)

  		hlen += L2CAP_FCS_SIZE;

  	BT_DBG("chan %p, control 0x%8.8x", chan, control);

  	count = min_t(unsigned int, conn->mtu, hlen);

  
  	control |= __set_sframe(chan);

  	if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))

  		control |= __set_ctrl_final(chan);

  	if (test_and_clear_bit(CONN_SEND_PBIT, &chan->conn_state))

  		control |= __set_ctrl_poll(chan);

  	skb = bt_skb_alloc(count, GFP_ATOMIC);
  	if (!skb)

  		return;

  
  	lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);

  	lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE);

  	lh->cid = cpu_to_le16(chan->dcid);

  
  	__put_control(chan, control, skb_put(skb, __ctrl_size(chan)));

  	if (chan->fcs == L2CAP_FCS_CRC16) {

  		u16 fcs = crc16(0, (u8 *)lh, count - L2CAP_FCS_SIZE);
  		put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE));

  	}

  	skb->priority = HCI_PRIO_MAX;
  	l2cap_do_send(chan, skb);

  }

  static inline void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, u32 control)

  {

  	if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {

  		control |= __set_ctrl_super(chan, L2CAP_SUPER_RNR);

  		set_bit(CONN_RNR_SENT, &chan->conn_state);

  	} else

  		control |= __set_ctrl_super(chan, L2CAP_SUPER_RR);

  	control |= __set_reqseq(chan, chan->buffer_seq);

  	l2cap_send_sframe(chan, control);

  }

  static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan)

  {

  	return !test_bit(CONF_CONNECT_PEND, &chan->conf_state);

  }

  static void l2cap_do_start(struct l2cap_chan *chan)

  {

  	struct l2cap_conn *conn = chan->conn;

  
  	if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) {

  		if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
  			return;

  		if (l2cap_chan_check_security(chan) &&

  				__l2cap_no_conn_pending(chan)) {

  			struct l2cap_conn_req req;

  			req.scid = cpu_to_le16(chan->scid);
  			req.psm  = chan->psm;

  			chan->ident = l2cap_get_ident(conn);

  			set_bit(CONF_CONNECT_PEND, &chan->conf_state);

  			l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ,
  							sizeof(req), &req);

  		}

  	} else {
  		struct l2cap_info_req req;
  		req.type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
  
  		conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
  		conn->info_ident = l2cap_get_ident(conn);

  		schedule_delayed_work(&conn->info_timer,

  					msecs_to_jiffies(L2CAP_INFO_TIMEOUT));
  
  		l2cap_send_cmd(conn, conn->info_ident,
  					L2CAP_INFO_REQ, sizeof(req), &req);
  	}
  }

  static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask)
  {
  	u32 local_feat_mask = l2cap_feat_mask;

  	if (!disable_ertm)

  		local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING;
  
  	switch (mode) {
  	case L2CAP_MODE_ERTM:
  		return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask;
  	case L2CAP_MODE_STREAMING:
  		return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask;
  	default:
  		return 0x00;
  	}
  }

  static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err)

  {

  	struct sock *sk;

  	struct l2cap_disconn_req req;

  	if (!conn)
  		return;

  	sk = chan->sk;

  	if (chan->mode == L2CAP_MODE_ERTM) {

  		__clear_retrans_timer(chan);
  		__clear_monitor_timer(chan);
  		__clear_ack_timer(chan);

  	}

  	req.dcid = cpu_to_le16(chan->dcid);
  	req.scid = cpu_to_le16(chan->scid);

  	l2cap_send_cmd(conn, l2cap_get_ident(conn),
  			L2CAP_DISCONN_REQ, sizeof(req), &req);

  	l2cap_state_change(chan, BT_DISCONN);

  	sk->sk_err = err;

  }

  /* ---- L2CAP connections ---- */

  static void l2cap_conn_start(struct l2cap_conn *conn)
  {

  	struct l2cap_chan *chan;

  
  	BT_DBG("conn %p", conn);

  	rcu_read_lock();

  	list_for_each_entry_rcu(chan, &conn->chan_l, list) {

  		struct sock *sk = chan->sk;

  		bh_lock_sock(sk);

  		if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {

  			bh_unlock_sock(sk);
  			continue;
  		}

  		if (chan->state == BT_CONNECT) {

  			struct l2cap_conn_req req;

  			if (!l2cap_chan_check_security(chan) ||

  					!__l2cap_no_conn_pending(chan)) {

  				bh_unlock_sock(sk);
  				continue;
  			}

  			if (!l2cap_mode_supported(chan->mode, conn->feat_mask)
  					&& test_bit(CONF_STATE2_DEVICE,
  					&chan->conf_state)) {

  				/* l2cap_chan_close() calls list_del(chan)

  				 * so release the lock */

  				l2cap_chan_close(chan, ECONNRESET);

  				bh_unlock_sock(sk);
  				continue;

  			}

  			req.scid = cpu_to_le16(chan->scid);
  			req.psm  = chan->psm;

  			chan->ident = l2cap_get_ident(conn);

  			set_bit(CONF_CONNECT_PEND, &chan->conf_state);

  			l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ,
  							sizeof(req), &req);

  		} else if (chan->state == BT_CONNECT2) {

  			struct l2cap_conn_rsp rsp;

  			char buf[128];

  			rsp.scid = cpu_to_le16(chan->dcid);
  			rsp.dcid = cpu_to_le16(chan->scid);

  			if (l2cap_chan_check_security(chan)) {

  				if (bt_sk(sk)->defer_setup) {
  					struct sock *parent = bt_sk(sk)->parent;
  					rsp.result = cpu_to_le16(L2CAP_CR_PEND);
  					rsp.status = cpu_to_le16(L2CAP_CS_AUTHOR_PEND);

  					if (parent)
  						parent->sk_data_ready(parent, 0);

  
  				} else {

  					l2cap_state_change(chan, BT_CONFIG);

  					rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
  					rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
  				}

  			} else {
  				rsp.result = cpu_to_le16(L2CAP_CR_PEND);
  				rsp.status = cpu_to_le16(L2CAP_CS_AUTHEN_PEND);
  			}

  			l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
  							sizeof(rsp), &rsp);

  			if (test_bit(CONF_REQ_SENT, &chan->conf_state) ||

  					rsp.result != L2CAP_CR_SUCCESS) {
  				bh_unlock_sock(sk);
  				continue;
  			}

  			set_bit(CONF_REQ_SENT, &chan->conf_state);

  			l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,

  						l2cap_build_conf_req(chan, buf), buf);
  			chan->num_conf_req++;

  		}
  
  		bh_unlock_sock(sk);
  	}

  	rcu_read_unlock();

  }

  /* Find socket with cid and source bdaddr.
   * Returns closest match, locked.
   */

  static struct l2cap_chan *l2cap_global_chan_by_scid(int state, __le16 cid, bdaddr_t *src)

  {

  	struct l2cap_chan *c, *c1 = NULL;

  	read_lock(&chan_list_lock);

  	list_for_each_entry(c, &chan_list, global_l) {
  		struct sock *sk = c->sk;

  		if (state && c->state != state)

  			continue;

  		if (c->scid == cid) {

  			/* Exact match. */

  			if (!bacmp(&bt_sk(sk)->src, src)) {
  				read_unlock(&chan_list_lock);
  				return c;
  			}

  
  			/* Closest match */
  			if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))

  				c1 = c;

  		}
  	}

  	read_unlock(&chan_list_lock);

  	return c1;

  }
  
  static void l2cap_le_conn_ready(struct l2cap_conn *conn)
  {

  	struct sock *parent, *sk;

  	struct l2cap_chan *chan, *pchan;

  
  	BT_DBG("");
  
  	/* Check if we have socket listening on cid */

  	pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA,

  							conn->src);

  	if (!pchan)

  		return;

  	parent = pchan->sk;

  	lock_sock(parent);

  	/* Check for backlog size */
  	if (sk_acceptq_is_full(parent)) {
  		BT_DBG("backlog full %d", parent->sk_ack_backlog);
  		goto clean;
  	}

  	chan = pchan->ops->new_connection(pchan->data);
  	if (!chan)

  		goto clean;

  	sk = chan->sk;

  	hci_conn_hold(conn->hcon);

  	bacpy(&bt_sk(sk)->src, conn->src);
  	bacpy(&bt_sk(sk)->dst, conn->dst);

  	bt_accept_enqueue(parent, sk);

  	l2cap_chan_add(conn, chan);

  	__set_chan_timer(chan, sk->sk_sndtimeo);

  	l2cap_state_change(chan, BT_CONNECTED);

  	parent->sk_data_ready(parent, 0);

  clean:

  	release_sock(parent);

  }

  static void l2cap_chan_ready(struct sock *sk)
  {
  	struct l2cap_chan *chan = l2cap_pi(sk)->chan;
  	struct sock *parent = bt_sk(sk)->parent;
  
  	BT_DBG("sk %p, parent %p", sk, parent);
  
  	chan->conf_state = 0;
  	__clear_chan_timer(chan);

  	l2cap_state_change(chan, BT_CONNECTED);

  	sk->sk_state_change(sk);
  
  	if (parent)
  		parent->sk_data_ready(parent, 0);
  }

  static void l2cap_conn_ready(struct l2cap_conn *conn)
  {

  	struct l2cap_chan *chan;

  	BT_DBG("conn %p", conn);

  	if (!conn->hcon->out && conn->hcon->type == LE_LINK)
  		l2cap_le_conn_ready(conn);

  	if (conn->hcon->out && conn->hcon->type == LE_LINK)
  		smp_conn_security(conn, conn->hcon->pending_sec_level);

  	rcu_read_lock();

  	list_for_each_entry_rcu(chan, &conn->chan_l, list) {

  		struct sock *sk = chan->sk;

  		bh_lock_sock(sk);

  		if (conn->hcon->type == LE_LINK) {

  			if (smp_conn_security(conn, chan->sec_level))

  				l2cap_chan_ready(sk);

  		} else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {

  			__clear_chan_timer(chan);

  			l2cap_state_change(chan, BT_CONNECTED);

  			sk->sk_state_change(sk);

  		} else if (chan->state == BT_CONNECT)

  			l2cap_do_start(chan);

  		bh_unlock_sock(sk);

  	}

  	rcu_read_unlock();

  }
  
  /* Notify sockets that we cannot guaranty reliability anymore */
  static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err)
  {

  	struct l2cap_chan *chan;

  
  	BT_DBG("conn %p", conn);

  	rcu_read_lock();

  	list_for_each_entry_rcu(chan, &conn->chan_l, list) {

  		struct sock *sk = chan->sk;

  		if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))

  			sk->sk_err = err;
  	}

  	rcu_read_unlock();

  }

  static void l2cap_info_timeout(struct work_struct *work)

  {

  	struct l2cap_conn *conn = container_of(work, struct l2cap_conn,

  							info_timer.work);

  	conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;

  	conn->info_ident = 0;

  	l2cap_conn_start(conn);
  }

  static void l2cap_conn_del(struct hci_conn *hcon, int err)
  {
  	struct l2cap_conn *conn = hcon->l2cap_data;
  	struct l2cap_chan *chan, *l;
  	struct sock *sk;
  
  	if (!conn)
  		return;
  
  	BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
  
  	kfree_skb(conn->rx_skb);
  
  	/* Kill channels */
  	list_for_each_entry_safe(chan, l, &conn->chan_l, list) {
  		sk = chan->sk;

  		lock_sock(sk);

  		l2cap_chan_del(chan, err);

  		release_sock(sk);

  		chan->ops->close(chan->data);
  	}

  	hci_chan_del(conn->hchan);

  	if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)

  		__cancel_delayed_work(&conn->info_timer);

  	if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->pend)) {

  		__cancel_delayed_work(&conn->security_timer);

  		smp_chan_destroy(conn);

  	}

  
  	hcon->l2cap_data = NULL;
  	kfree(conn);
  }

  static void security_timeout(struct work_struct *work)

  {

  	struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
  						security_timer.work);

  
  	l2cap_conn_del(conn->hcon, ETIMEDOUT);
  }

  static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status)
  {

  	struct l2cap_conn *conn = hcon->l2cap_data;

  	struct hci_chan *hchan;

  	if (conn || status)

  		return conn;

  	hchan = hci_chan_create(hcon);
  	if (!hchan)
  		return NULL;

  	conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC);

  	if (!conn) {
  		hci_chan_del(hchan);

  		return NULL;

  	}

  
  	hcon->l2cap_data = conn;
  	conn->hcon = hcon;

  	conn->hchan = hchan;

  	BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan);

  	if (hcon->hdev->le_mtu && hcon->type == LE_LINK)
  		conn->mtu = hcon->hdev->le_mtu;
  	else
  		conn->mtu = hcon->hdev->acl_mtu;

  	conn->src = &hcon->hdev->bdaddr;
  	conn->dst = &hcon->dst;

  	conn->feat_mask = 0;

  	spin_lock_init(&conn->lock);

  
  	INIT_LIST_HEAD(&conn->chan_l);

  	if (hcon->type == LE_LINK)

  		INIT_DELAYED_WORK(&conn->security_timer, security_timeout);

  	else

  		INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout);

  	conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;

  	return conn;
  }

  /* ---- Socket interface ---- */

  
  /* Find socket with psm and source bdaddr.
   * Returns closest match.
   */

  static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, bdaddr_t *src)

  {

  	struct l2cap_chan *c, *c1 = NULL;

  	read_lock(&chan_list_lock);

  	list_for_each_entry(c, &chan_list, global_l) {
  		struct sock *sk = c->sk;

  		if (state && c->state != state)

  			continue;

  		if (c->psm == psm) {

  			/* Exact match. */

  			if (!bacmp(&bt_sk(sk)->src, src)) {

  				read_unlock(&chan_list_lock);

  				return c;
  			}

  
  			/* Closest match */
  			if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))

  				c1 = c;

  		}
  	}

  	read_unlock(&chan_list_lock);

  	return c1;

  }

  inline int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid, bdaddr_t *dst)

  {

  	struct sock *sk = chan->sk;

  	bdaddr_t *src = &bt_sk(sk)->src;

  	struct l2cap_conn *conn;
  	struct hci_conn *hcon;
  	struct hci_dev *hdev;

  	__u8 auth_type;

  	int err;

  	BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst),

  							chan->psm);

  	hdev = hci_get_route(dst, src);
  	if (!hdev)

  		return -EHOSTUNREACH;

  	hci_dev_lock(hdev);

  	lock_sock(sk);
  
  	/* PSM must be odd and lsb of upper byte must be 0 */
  	if ((__le16_to_cpu(psm) & 0x0101) != 0x0001 && !cid &&
  					chan->chan_type != L2CAP_CHAN_RAW) {
  		err = -EINVAL;
  		goto done;
  	}
  
  	if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !(psm || cid)) {
  		err = -EINVAL;
  		goto done;
  	}
  
  	switch (chan->mode) {
  	case L2CAP_MODE_BASIC:
  		break;
  	case L2CAP_MODE_ERTM:
  	case L2CAP_MODE_STREAMING:
  		if (!disable_ertm)
  			break;
  		/* fall through */
  	default:
  		err = -ENOTSUPP;
  		goto done;
  	}
  
  	switch (sk->sk_state) {
  	case BT_CONNECT:
  	case BT_CONNECT2:
  	case BT_CONFIG:
  		/* Already connecting */
  		err = 0;
  		goto done;
  
  	case BT_CONNECTED:
  		/* Already connected */
  		err = -EISCONN;
  		goto done;
  
  	case BT_OPEN:
  	case BT_BOUND:
  		/* Can connect */
  		break;
  
  	default:
  		err = -EBADFD;
  		goto done;
  	}
  
  	/* Set destination address and psm */

  	bacpy(&bt_sk(sk)->dst, dst);

  	chan->psm = psm;
  	chan->dcid = cid;

  	auth_type = l2cap_get_auth_type(chan);

  	if (chan->dcid == L2CAP_CID_LE_DATA)

  		hcon = hci_connect(hdev, LE_LINK, dst,

  					chan->sec_level, auth_type);

  	else
  		hcon = hci_connect(hdev, ACL_LINK, dst,

  					chan->sec_level, auth_type);

  	if (IS_ERR(hcon)) {
  		err = PTR_ERR(hcon);

  		goto done;

  	}

  
  	conn = l2cap_conn_add(hcon, 0);
  	if (!conn) {
  		hci_conn_put(hcon);

  		err = -ENOMEM;

  		goto done;
  	}

  	/* Update source addr of the socket */
  	bacpy(src, conn->src);

  	l2cap_chan_add(conn, chan);

  	l2cap_state_change(chan, BT_CONNECT);

  	__set_chan_timer(chan, sk->sk_sndtimeo);

  
  	if (hcon->state == BT_CONNECTED) {

  		if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {

  			__clear_chan_timer(chan);

  			if (l2cap_chan_check_security(chan))

  				l2cap_state_change(chan, BT_CONNECTED);

  		} else

  			l2cap_do_start(chan);

  	}