Release 4.7 net/bluetooth/l2cap_core.c
/*
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
Copyright (c) 2012 Code Aurora Forum. All rights reserved.
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/debugfs.h>
#include <linux/crc16.h>
#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/l2cap.h>
#include "smp.h"
#include "a2mp.h"
#include "amp.h"
#define LE_FLOWCTL_MAX_CREDITS 65535
bool disable_ertm;
static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN | L2CAP_FEAT_UCD;
static LIST_HEAD(chan_list);
static DEFINE_RWLOCK(chan_list_lock);
static u16 le_max_credits = L2CAP_LE_MAX_CREDITS;
static u16 le_default_mps = L2CAP_LE_DEFAULT_MPS;
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_chan *chan, int err);
static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control,
struct sk_buff_head *skbs, u8 event);
static inline u8 bdaddr_type(u8 link_type, u8 bdaddr_type)
{
if (link_type == LE_LINK) {
if (bdaddr_type == ADDR_LE_DEV_PUBLIC)
return BDADDR_LE_PUBLIC;
else
return BDADDR_LE_RANDOM;
}
return BDADDR_BREDR;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 30 | 81.08% | 1 | 50.00% |
johan hedberg | johan hedberg | 7 | 18.92% | 1 | 50.00% |
| Total | 37 | 100.00% | 2 | 100.00% |
static inline u8 bdaddr_src_type(struct hci_conn *hcon)
{
return bdaddr_type(hcon->type, hcon->src_type);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 24 | 100.00% | 1 | 100.00% |
| Total | 24 | 100.00% | 1 | 100.00% |
static inline u8 bdaddr_dst_type(struct hci_conn *hcon)
{
return bdaddr_type(hcon->type, hcon->dst_type);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 24 | 100.00% | 1 | 100.00% |
| Total | 24 | 100.00% | 1 | 100.00% |
/* ---- L2CAP channels ---- */
static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn,
u16 cid)
{
struct l2cap_chan *c;
list_for_each_entry(c, &conn->chan_l, list) {
if (c->dcid == cid)
return c;
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 19 | 42.22% | 4 | 50.00% |
linus torvalds | linus torvalds | 11 | 24.44% | 1 | 12.50% |
marcel holtmann | marcel holtmann | 9 | 20.00% | 1 | 12.50% |
andrei emeltchenko | andrei emeltchenko | 4 | 8.89% | 1 | 12.50% |
maksim krasnyanskiy | maksim krasnyanskiy | 2 | 4.44% | 1 | 12.50% |
| Total | 45 | 100.00% | 8 | 100.00% |
static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn,
u16 cid)
{
struct l2cap_chan *c;
list_for_each_entry(c, &conn->chan_l, list) {
if (c->scid == cid)
return c;
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 18 | 40.00% | 3 | 42.86% |
linus torvalds | linus torvalds | 9 | 20.00% | 1 | 14.29% |
marcel holtmann | marcel holtmann | 8 | 17.78% | 1 | 14.29% |
maksim krasnyanskiy | maksim krasnyanskiy | 6 | 13.33% | 1 | 14.29% |
andrei emeltchenko | andrei emeltchenko | 4 | 8.89% | 1 | 14.29% |
| Total | 45 | 100.00% | 7 | 100.00% |
/* Find channel with given SCID.
* Returns locked channel. */
static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn,
u16 cid)
{
struct l2cap_chan *c;
mutex_lock(&conn->chan_lock);
c = __l2cap_get_chan_by_scid(conn, cid);
if (c)
l2cap_chan_lock(c);
mutex_unlock(&conn->chan_lock);
return c;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 21 | 36.21% | 2 | 28.57% |
maxim krasnyansky | maxim krasnyansky | 14 | 24.14% | 1 | 14.29% |
marcel holtmann | marcel holtmann | 8 | 13.79% | 1 | 14.29% |
andrei emeltchenko | andrei emeltchenko | 8 | 13.79% | 1 | 14.29% |
gustavo f. padovan | gustavo f. padovan | 7 | 12.07% | 2 | 28.57% |
| Total | 58 | 100.00% | 7 | 100.00% |
/* Find channel with given DCID.
* Returns locked channel.
*/
static struct l2cap_chan *l2cap_get_chan_by_dcid(struct l2cap_conn *conn,
u16 cid)
{
struct l2cap_chan *c;
mutex_lock(&conn->chan_lock);
c = __l2cap_get_chan_by_dcid(conn, cid);
if (c)
l2cap_chan_lock(c);
mutex_unlock(&conn->chan_lock);
return c;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 46 | 79.31% | 1 | 20.00% |
marcel holtmann | marcel holtmann | 5 | 8.62% | 1 | 20.00% |
andrei emeltchenko | andrei emeltchenko | 4 | 6.90% | 1 | 20.00% |
gustavo f. padovan | gustavo f. padovan | 2 | 3.45% | 1 | 20.00% |
maxim krasnyansky | maxim krasnyansky | 1 | 1.72% | 1 | 20.00% |
| Total | 58 | 100.00% | 5 | 100.00% |
static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn,
u8 ident)
{
struct l2cap_chan *c;
list_for_each_entry(c, &conn->chan_l, list) {
if (c->ident == ident)
return c;
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 23 | 51.11% | 2 | 33.33% |
gustavo f. padovan | gustavo f. padovan | 18 | 40.00% | 3 | 50.00% |
andrei emeltchenko | andrei emeltchenko | 4 | 8.89% | 1 | 16.67% |
| Total | 45 | 100.00% | 6 | 100.00% |
static struct l2cap_chan *l2cap_get_chan_by_ident(struct l2cap_conn *conn,
u8 ident)
{
struct l2cap_chan *c;
mutex_lock(&conn->chan_lock);
c = __l2cap_get_chan_by_ident(conn, ident);
if (c)
l2cap_chan_lock(c);
mutex_unlock(&conn->chan_lock);
return c;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 58 | 100.00% | 1 | 100.00% |
| Total | 58 | 100.00% | 1 | 100.00% |
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(&c->src, src))
return c;
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 51 | 92.73% | 3 | 75.00% |
szymon janc | szymon janc | 4 | 7.27% | 1 | 25.00% |
| Total | 55 | 100.00% | 4 | 100.00% |
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, start, end, incr;
if (chan->src_type == BDADDR_BREDR) {
start = L2CAP_PSM_DYN_START;
end = L2CAP_PSM_AUTO_END;
incr = 2;
} else {
start = L2CAP_PSM_LE_DYN_START;
end = L2CAP_PSM_LE_DYN_END;
incr = 1;
}
err = -EINVAL;
for (p = start; p <= end; p += incr)
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;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 139 | 74.73% | 4 | 80.00% |
johan hedberg | johan hedberg | 47 | 25.27% | 1 | 20.00% |
| Total | 186 | 100.00% | 5 | 100.00% |
EXPORT_SYMBOL_GPL(l2cap_add_psm);
int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid)
{
write_lock(&chan_list_lock);
/* Override the defaults (which are for conn-oriented) */
chan->omtu = L2CAP_DEFAULT_MTU;
chan->chan_type = L2CAP_CHAN_FIXED;
chan->scid = scid;
write_unlock(&chan_list_lock);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 34 | 72.34% | 3 | 75.00% |
johan hedberg | johan hedberg | 13 | 27.66% | 1 | 25.00% |
| Total | 47 | 100.00% | 4 | 100.00% |
static u16 l2cap_alloc_cid(struct l2cap_conn *conn)
{
u16 cid, dyn_end;
if (conn->hcon->type == LE_LINK)
dyn_end = L2CAP_CID_LE_DYN_END;
else
dyn_end = L2CAP_CID_DYN_END;
for (cid = L2CAP_CID_DYN_START; cid <= dyn_end; cid++) {
if (!__l2cap_get_chan_by_scid(conn, cid))
return cid;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 37 | 56.06% | 2 | 40.00% |
johan hedberg | johan hedberg | 26 | 39.39% | 2 | 40.00% |
gustavo f. padovan | gustavo f. padovan | 3 | 4.55% | 1 | 20.00% |
| Total | 66 | 100.00% | 5 | 100.00% |
static void l2cap_state_change(struct l2cap_chan *chan, int state)
{
BT_DBG("chan %p %s -> %s", chan, state_to_string(chan->state),
state_to_string(state));
chan->state = state;
chan->ops->state_change(chan, state, 0);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 48 | 92.31% | 2 | 40.00% |
gustavo padovan | gustavo padovan | 3 | 5.77% | 2 | 40.00% |
andrei emeltchenko | andrei emeltchenko | 1 | 1.92% | 1 | 20.00% |
| Total | 52 | 100.00% | 5 | 100.00% |
static inline void l2cap_state_change_and_error(struct l2cap_chan *chan,
int state, int err)
{
chan->state = state;
chan->ops->state_change(chan, chan->state, err);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 20 | 51.28% | 2 | 66.67% |
andrei emeltchenko | andrei emeltchenko | 19 | 48.72% | 1 | 33.33% |
| Total | 39 | 100.00% | 3 | 100.00% |
static inline void l2cap_chan_set_err(struct l2cap_chan *chan, int err)
{
chan->ops->state_change(chan, chan->state, err);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 21 | 70.00% | 1 | 50.00% |
gustavo padovan | gustavo padovan | 9 | 30.00% | 1 | 50.00% |
| Total | 30 | 100.00% | 2 | 100.00% |
static void __set_retrans_timer(struct l2cap_chan *chan)
{
if (!delayed_work_pending(&chan->monitor_timer) &&
chan->retrans_timeout) {
l2cap_set_timer(chan, &chan->retrans_timer,
msecs_to_jiffies(chan->retrans_timeout));
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 45 | 100.00% | 1 | 100.00% |
| Total | 45 | 100.00% | 1 | 100.00% |
static void __set_monitor_timer(struct l2cap_chan *chan)
{
__clear_retrans_timer(chan);
if (chan->monitor_timeout) {
l2cap_set_timer(chan, &chan->monitor_timer,
msecs_to_jiffies(chan->monitor_timeout));
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 41 | 100.00% | 1 | 100.00% |
| Total | 41 | 100.00% | 1 | 100.00% |
static struct sk_buff *l2cap_ertm_seq_in_queue(struct sk_buff_head *head,
u16 seq)
{
struct sk_buff *skb;
skb_queue_walk(head, skb) {
if (bt_cb(skb)->l2cap.txseq == seq)
return skb;
}
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 47 | 97.92% | 1 | 50.00% |
johan hedberg | johan hedberg | 1 | 2.08% | 1 | 50.00% |
| Total | 48 | 100.00% | 2 | 100.00% |
/* ---- L2CAP sequence number lists ---- */
/* For ERTM, ordered lists of sequence numbers must be tracked for
* SREJ requests that are received and for frames that are to be
* retransmitted. These seq_list functions implement a singly-linked
* list in an array, where membership in the list can also be checked
* in constant time. Items can also be added to the tail of the list
* and removed from the head in constant time, without further memory
* allocs or frees.
*/
static int l2cap_seq_list_init(struct l2cap_seq_list *seq_list, u16 size)
{
size_t alloc_size, i;
/* Allocated size is a power of 2 to map sequence numbers
* (which may be up to 14 bits) in to a smaller array that is
* sized for the negotiated ERTM transmit windows.
*/
alloc_size = roundup_pow_of_two(size);
seq_list->list = kmalloc(sizeof(u16) * alloc_size, GFP_KERNEL);
if (!seq_list->list)
return -ENOMEM;
seq_list->mask = alloc_size - 1;
seq_list->head = L2CAP_SEQ_LIST_CLEAR;
seq_list->tail = L2CAP_SEQ_LIST_CLEAR;
for (i = 0; i < alloc_size; i++)
seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 99 | 100.00% | 1 | 100.00% |
| Total | 99 | 100.00% | 1 | 100.00% |
static inline void l2cap_seq_list_free(struct l2cap_seq_list *seq_list)
{
kfree(seq_list->list);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 19 | 100.00% | 1 | 100.00% |
| Total | 19 | 100.00% | 1 | 100.00% |
static inline bool l2cap_seq_list_contains(struct l2cap_seq_list *seq_list,
u16 seq)
{
/* Constant-time check for list membership */
return seq_list->list[seq & seq_list->mask] != L2CAP_SEQ_LIST_CLEAR;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 30 | 100.00% | 1 | 100.00% |
| Total | 30 | 100.00% | 1 | 100.00% |
static inline u16 l2cap_seq_list_pop(struct l2cap_seq_list *seq_list)
{
u16 seq = seq_list->head;
u16 mask = seq_list->mask;
seq_list->head = seq_list->list[seq & mask];
seq_list->list[seq & mask] = L2CAP_SEQ_LIST_CLEAR;
if (seq_list->head == L2CAP_SEQ_LIST_TAIL) {
seq_list->head = L2CAP_SEQ_LIST_CLEAR;
seq_list->tail = L2CAP_SEQ_LIST_CLEAR;
}
return seq;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 66 | 88.00% | 1 | 50.00% |
johan hedberg | johan hedberg | 9 | 12.00% | 1 | 50.00% |
| Total | 75 | 100.00% | 2 | 100.00% |
static void l2cap_seq_list_clear(struct l2cap_seq_list *seq_list)
{
u16 i;
if (seq_list->head == L2CAP_SEQ_LIST_CLEAR)
return;
for (i = 0; i <= seq_list->mask; i++)
seq_list->list[i] = L2CAP_SEQ_LIST_CLEAR;
seq_list->head = L2CAP_SEQ_LIST_CLEAR;
seq_list->tail = L2CAP_SEQ_LIST_CLEAR;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 54 | 91.53% | 1 | 50.00% |
gustavo padovan | gustavo padovan | 5 | 8.47% | 1 | 50.00% |
| Total | 59 | 100.00% | 2 | 100.00% |
static void l2cap_seq_list_append(struct l2cap_seq_list *seq_list, u16 seq)
{
u16 mask = seq_list->mask;
/* All appends happen in constant time */
if (seq_list->list[seq & mask] != L2CAP_SEQ_LIST_CLEAR)
return;
if (seq_list->tail == L2CAP_SEQ_LIST_CLEAR)
seq_list->head = seq;
else
seq_list->list[seq_list->tail & mask] = seq;
seq_list->tail = seq;
seq_list->list[seq & mask] = L2CAP_SEQ_LIST_TAIL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 79 | 97.53% | 1 | 50.00% |
gustavo padovan | gustavo padovan | 2 | 2.47% | 1 | 50.00% |
| Total | 81 | 100.00% | 2 | 100.00% |
static void l2cap_chan_timeout(struct work_struct *work)
{
struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
chan_timer.work);
struct l2cap_conn *conn = chan->conn;
int reason;
BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
mutex_lock(&conn->chan_lock);
l2cap_chan_lock(chan);
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);
l2cap_chan_unlock(chan);
chan->ops->close(chan);
mutex_unlock(&conn->chan_lock);
l2cap_chan_put(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 110 | 76.92% | 6 | 60.00% |
andrei emeltchenko | andrei emeltchenko | 32 | 22.38% | 3 | 30.00% |
ulisses furquim | ulisses furquim | 1 | 0.70% | 1 | 10.00% |
| Total | 143 | 100.00% | 10 | 100.00% |
struct l2cap_chan *l2cap_chan_create(void)
{
struct l2cap_chan *chan;
chan = kzalloc(sizeof(*chan), GFP_ATOMIC);
if (!chan)
return NULL;
mutex_init(&chan->lock);
/* Set default lock nesting level */
atomic_set(&chan->nesting, L2CAP_NESTING_NORMAL);
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;
kref_init(&chan->kref);
/* This flag is cleared in l2cap_chan_ready() */
set_bit(CONF_NOT_COMPLETE, &chan->conf_state);
BT_DBG("chan %p", chan);
return chan;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 82 | 67.21% | 7 | 53.85% |
mat martineau | mat martineau | 11 | 9.02% | 1 | 7.69% |
johan hedberg | johan hedberg | 11 | 9.02% | 1 | 7.69% |
andrei emeltchenko | andrei emeltchenko | 8 | 6.56% | 1 | 7.69% |
szymon janc | szymon janc | 6 | 4.92% | 1 | 7.69% |
syam sidhardhan | syam sidhardhan | 2 | 1.64% | 1 | 7.69% |
gustavo padovan | gustavo padovan | 2 | 1.64% | 1 | 7.69% |
| Total | 122 | 100.00% | 13 | 100.00% |
EXPORT_SYMBOL_GPL(l2cap_chan_create);
static void l2cap_chan_destroy(struct kref *kref)
{
struct l2cap_chan *chan = container_of(kref, struct l2cap_chan, kref);
BT_DBG("chan %p", chan);
write_lock(&chan_list_lock);
list_del(&chan->global_l);
write_unlock(&chan_list_lock);
kfree(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 32 | 55.17% | 3 | 60.00% |
syam sidhardhan | syam sidhardhan | 17 | 29.31% | 1 | 20.00% |
jaganath kanakkassery | jaganath kanakkassery | 9 | 15.52% | 1 | 20.00% |
| Total | 58 | 100.00% | 5 | 100.00% |
void l2cap_chan_hold(struct l2cap_chan *c)
{
BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount));
kref_get(&c->kref);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
jaganath kanakkassery | jaganath kanakkassery | 30 | 85.71% | 1 | 50.00% |
syam sidhardhan | syam sidhardhan | 5 | 14.29% | 1 | 50.00% |
| Total | 35 | 100.00% | 2 | 100.00% |
void l2cap_chan_put(struct l2cap_chan *c)
{
BT_DBG("chan %p orig refcnt %d", c, atomic_read(&c->kref.refcount));
kref_put(&c->kref, l2cap_chan_destroy);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
jaganath kanakkassery | jaganath kanakkassery | 31 | 83.78% | 2 | 66.67% |
syam sidhardhan | syam sidhardhan | 6 | 16.22% | 1 | 33.33% |
| Total | 37 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL_GPL(l2cap_chan_put);
void l2cap_chan_set_defaults(struct l2cap_chan *chan)
{
chan->fcs = L2CAP_FCS_CRC16;
chan->max_tx = L2CAP_DEFAULT_MAX_TX;
chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
chan->remote_max_tx = chan->max_tx;
chan->remote_tx_win = chan->tx_win;
chan->ack_win = L2CAP_DEFAULT_TX_WINDOW;
chan->sec_level = BT_SECURITY_LOW;
chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
chan->retrans_timeout = L2CAP_DEFAULT_RETRANS_TO;
chan->monitor_timeout = L2CAP_DEFAULT_MONITOR_TO;
chan->conf_state = 0;
set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 50 | 52.08% | 1 | 33.33% |
jukka rissanen | jukka rissanen | 40 | 41.67% | 1 | 33.33% |
mat martineau | mat martineau | 6 | 6.25% | 1 | 33.33% |
| Total | 96 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL_GPL(l2cap_chan_set_defaults);
static void l2cap_le_flowctl_init(struct l2cap_chan *chan)
{
chan->sdu = NULL;
chan->sdu_last_frag = NULL;
chan->sdu_len = 0;
chan->tx_credits = 0;
chan->rx_credits = le_max_credits;
chan->mps = min_t(u16, chan->imtu, le_default_mps);
skb_queue_head_init(&chan->tx_q);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 64 | 100.00% | 7 | 100.00% |
| Total | 64 | 100.00% | 7 | 100.00% |
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,
__le16_to_cpu(chan->psm), chan->dcid);
conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;
chan->conn = conn;
switch (chan->chan_type) {
case L2CAP_CHAN_CONN_ORIENTED:
/* Alloc CID for connection-oriented socket */
chan->scid = l2cap_alloc_cid(conn);
if (conn->hcon->type == ACL_LINK)
chan->omtu = L2CAP_DEFAULT_MTU;
break;
case L2CAP_CHAN_CONN_LESS:
/* Connectionless socket */
chan->scid = L2CAP_CID_CONN_LESS;
chan->dcid = L2CAP_CID_CONN_LESS;
chan->omtu = L2CAP_DEFAULT_MTU;
break;
case L2CAP_CHAN_FIXED:
/* Caller will set CID and CID specific MTU values */
break;
default:
/* 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_EFS_DEFAULT_FLUSH_TO;
l2cap_chan_hold(chan);
/* Only keep a reference for fixed channels if they requested it */
if (chan->chan_type != L2CAP_CHAN_FIXED ||
test_bit(FLAG_HOLD_HCI_CONN, &chan->flags))
hci_conn_hold(conn->hcon);
list_add(&chan->list, &conn->chan_l);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 55 | 26.07% | 8 | 27.59% |
marcel holtmann | marcel holtmann | 51 | 24.17% | 2 | 6.90% |
johan hedberg | johan hedberg | 38 | 18.01% | 4 | 13.79% |
gustavo f. padovan | gustavo f. padovan | 31 | 14.69% | 8 | 27.59% |
maxim krasnyansky | maxim krasnyansky | 12 | 5.69% | 1 | 3.45% |
linus torvalds | linus torvalds | 9 | 4.27% | 2 | 6.90% |
maksim krasnyanskiy | maksim krasnyanskiy | 5 | 2.37% | 1 | 3.45% |
ville tervo | ville tervo | 5 | 2.37% | 1 | 3.45% |
gustavo padovan | gustavo padovan | 4 | 1.90% | 1 | 3.45% |
ulisses furquim | ulisses furquim | 1 | 0.47% | 1 | 3.45% |
| Total | 211 | 100.00% | 29 | 100.00% |
void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
{
mutex_lock(&conn->chan_lock);
__l2cap_chan_add(conn, chan);
mutex_unlock(&conn->chan_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 37 | 97.37% | 2 | 66.67% |
maksim krasnyanskiy | maksim krasnyanskiy | 1 | 2.63% | 1 | 33.33% |
| Total | 38 | 100.00% | 3 | 100.00% |
void l2cap_chan_del(struct l2cap_chan *chan, int err)
{
struct l2cap_conn *conn = chan->conn;
__clear_chan_timer(chan);
BT_DBG("chan %p, conn %p, err %d, state %s", chan, conn, err,
state_to_string(chan->state));
chan->ops->teardown(chan, err);
if (conn) {
struct amp_mgr *mgr = conn->hcon->amp_mgr;
/* Delete from channel list */
list_del(&chan->list);
l2cap_chan_put(chan);
chan->conn = NULL;
/* Reference was only held for non-fixed channels or
* fixed channels that explicitly requested it using the
* FLAG_HOLD_HCI_CONN flag.
*/
if (chan->chan_type != L2CAP_CHAN_FIXED ||
test_bit(FLAG_HOLD_HCI_CONN, &chan->flags))
hci_conn_drop(conn->hcon);
if (mgr && mgr->bredr_chan == chan)
mgr->bredr_chan = NULL;
}
if (chan->hs_hchan) {
struct hci_chan *hs_hchan = chan->hs_hchan;
BT_DBG("chan %p disconnect hs_hchan %p", chan, hs_hchan);
amp_disconnect_logical_link(hs_hchan);
}
if (test_bit(CONF_NOT_COMPLETE, &chan->conf_state))
return;
switch(chan->mode) {
case L2CAP_MODE_BASIC:
break;
case L2CAP_MODE_LE_FLOWCTL:
skb_queue_purge(&chan->tx_q);
break;
case L2CAP_MODE_ERTM:
__clear_retrans_timer(chan);
__clear_monitor_timer(chan);
__clear_ack_timer(chan);
skb_queue_purge(&chan->srej_q);
l2cap_seq_list_free(&chan->srej_list);
l2cap_seq_list_free(&chan->retrans_list);
/* fall through */
case L2CAP_MODE_STREAMING:
skb_queue_purge(&chan->tx_q);
break;
}
return;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 62 | 23.94% | 5 | 14.71% |
gustavo f. padovan | gustavo f. padovan | 59 | 22.78% | 16 | 47.06% |
johan hedberg | johan hedberg | 44 | 16.99% | 5 | 14.71% |
marcel holtmann | marcel holtmann | 32 | 12.36% | 1 | 2.94% |
gustavo padovan | gustavo padovan | 22 | 8.49% | 1 | 2.94% |
mat martineau | mat martineau | 17 | 6.56% | 2 | 5.88% |
maksim krasnyanskiy | maksim krasnyanskiy | 14 | 5.41% | 1 | 2.94% |
linus torvalds | linus torvalds | 7 | 2.70% | 1 | 2.94% |
david herrmann | david herrmann | 1 | 0.39% | 1 | 2.94% |
ulisses furquim | ulisses furquim | 1 | 0.39% | 1 | 2.94% |
| Total | 259 | 100.00% | 34 | 100.00% |
EXPORT_SYMBOL_GPL(l2cap_chan_del);
static void l2cap_conn_update_id_addr(struct work_struct *work)
{
struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
id_addr_update_work);
struct hci_conn *hcon = conn->hcon;
struct l2cap_chan *chan;
mutex_lock(&conn->chan_lock);
list_for_each_entry(chan, &conn->chan_l, list) {
l2cap_chan_lock(chan);
bacpy(&chan->dst, &hcon->dst);
chan->dst_type = bdaddr_dst_type(hcon);
l2cap_chan_unlock(chan);
}
mutex_unlock(&conn->chan_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 98 | 100.00% | 3 | 100.00% |
| Total | 98 | 100.00% | 3 | 100.00% |
static void l2cap_chan_le_connect_reject(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
struct l2cap_le_conn_rsp rsp;
u16 result;
if (test_bit(FLAG_DEFER_SETUP, &chan->flags))
result = L2CAP_CR_AUTHORIZATION;
else
result = L2CAP_CR_BAD_PSM;
l2cap_state_change(chan, BT_DISCONN);
rsp.dcid = cpu_to_le16(chan->scid);
rsp.mtu = cpu_to_le16(chan->imtu);
rsp.mps = cpu_to_le16(chan->mps);
rsp.credits = cpu_to_le16(chan->rx_credits);
rsp.result = cpu_to_le16(result);
l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CONN_RSP, sizeof(rsp),
&rsp);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 127 | 100.00% | 3 | 100.00% |
| Total | 127 | 100.00% | 3 | 100.00% |
static void l2cap_chan_connect_reject(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
struct l2cap_conn_rsp rsp;
u16 result;
if (test_bit(FLAG_DEFER_SETUP, &chan->flags))
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);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 113 | 99.12% | 1 | 50.00% |
joe perches | joe perches | 1 | 0.88% | 1 | 50.00% |
| Total | 114 | 100.00% | 2 | 100.00% |
void l2cap_chan_close(struct l2cap_chan *chan, int reason)
{
struct l2cap_conn *conn = chan->conn;
BT_DBG("chan %p state %s", chan, state_to_string(chan->state));
switch (chan->state) {
case BT_LISTEN:
chan->ops->teardown(chan, 0);
break;
case BT_CONNECTED:
case BT_CONFIG:
if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED) {
__set_chan_timer(chan, chan->ops->get_sndtimeo(chan));
l2cap_send_disconn_req(chan, reason);
} else
l2cap_chan_del(chan, reason);
break;
case BT_CONNECT2:
if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED) {
if (conn->hcon->type == ACL_LINK)
l2cap_chan_connect_reject(chan);
else if (conn->hcon->type == LE_LINK)
l2cap_chan_le_connect_reject(chan);
}
l2cap_chan_del(chan, reason);
break;
case BT_CONNECT:
case BT_DISCONN:
l2cap_chan_del(chan, reason);
break;
default:
chan->ops->teardown(chan, 0);
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 134 | 72.83% | 6 | 46.15% |
andrei emeltchenko | andrei emeltchenko | 21 | 11.41% | 3 | 23.08% |
johan hedberg | johan hedberg | 21 | 11.41% | 2 | 15.38% |
gustavo padovan | gustavo padovan | 7 | 3.80% | 1 | 7.69% |
marcel holtmann | marcel holtmann | 1 | 0.54% | 1 | 7.69% |
| Total | 184 | 100.00% | 13 | 100.00% |
EXPORT_SYMBOL(l2cap_chan_close);
static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan)
{
switch (chan->chan_type) {
case L2CAP_CHAN_RAW:
switch (chan->sec_level) {
case BT_SECURITY_HIGH:
case BT_SECURITY_FIPS:
return HCI_AT_DEDICATED_BONDING_MITM;
case BT_SECURITY_MEDIUM:
return HCI_AT_DEDICATED_BONDING;
default:
return HCI_AT_NO_BONDING;
}
break;
case L2CAP_CHAN_CONN_LESS:
if (chan->psm == cpu_to_le16(L2CAP_PSM_3DSP)) {
if (chan->sec_level == BT_SECURITY_LOW)
chan->sec_level = BT_SECURITY_SDP;
}
if (chan->sec_level == BT_SECURITY_HIGH ||
chan->sec_level == BT_SECURITY_FIPS)
return HCI_AT_NO_BONDING_MITM;
else
return HCI_AT_NO_BONDING;
break;
case L2CAP_CHAN_CONN_ORIENTED:
if (chan->psm == cpu_to_le16(L2CAP_PSM_SDP)) {
if (chan->sec_level == BT_SECURITY_LOW)
chan->sec_level = BT_SECURITY_SDP;
if (chan->sec_level == BT_SECURITY_HIGH ||
chan->sec_level == BT_SECURITY_FIPS)
return HCI_AT_NO_BONDING_MITM;
else
return HCI_AT_NO_BONDING;
}
/* fall through */
default:
switch (chan->sec_level) {
case BT_SECURITY_HIGH:
case BT_SECURITY_FIPS:
return HCI_AT_GENERAL_BONDING_MITM;
case BT_SECURITY_MEDIUM:
return HCI_AT_GENERAL_BONDING;
default:
return HCI_AT_NO_BONDING;
}
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 120 | 65.22% | 6 | 50.00% |
johan hedberg | johan hedberg | 51 | 27.72% | 1 | 8.33% |
gustavo f. padovan | gustavo f. padovan | 10 | 5.43% | 3 | 25.00% |
joe perches | joe perches | 2 | 1.09% | 1 | 8.33% |
andrei emeltchenko | andrei emeltchenko | 1 | 0.54% | 1 | 8.33% |
| Total | 184 | 100.00% | 12 | 100.00% |
/* Service level security */
int l2cap_chan_check_security(struct l2cap_chan *chan, bool initiator)
{
struct l2cap_conn *conn = chan->conn;
__u8 auth_type;
if (conn->hcon->type == LE_LINK)
return smp_conn_security(conn->hcon, chan->sec_level);
auth_type = l2cap_get_auth_type(chan);
return hci_conn_security(conn->hcon, chan->sec_level, auth_type,
initiator);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 50 | 71.43% | 3 | 33.33% |
marcel holtmann | marcel holtmann | 14 | 20.00% | 4 | 44.44% |
gustavo f. padovan | gustavo f. padovan | 6 | 8.57% | 2 | 22.22% |
| Total | 70 | 100.00% | 9 | 100.00% |
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.
*/
mutex_lock(&conn->ident_lock);
if (++conn->tx_ident > 128)
conn->tx_ident = 1;
id = conn->tx_ident;
mutex_unlock(&conn->ident_lock);
return id;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 54 | 98.18% | 2 | 66.67% |
johannes berg | johannes berg | 1 | 1.82% | 1 | 33.33% |
| Total | 55 | 100.00% | 3 | 100.00% |
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;
/* Use NO_FLUSH if supported or we have an LE link (which does
* not support auto-flushing packets) */
if (lmp_no_flush_capable(conn->hcon->hdev) ||
conn->hcon->type == LE_LINK)
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);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 55 | 48.67% | 1 | 12.50% |
andrei emeltchenko | andrei emeltchenko | 23 | 20.35% | 1 | 12.50% |
luiz augusto von dentz | luiz augusto von dentz | 14 | 12.39% | 2 | 25.00% |
steven walter | steven walter | 9 | 7.96% | 1 | 12.50% |
jaikumar ganesh | jaikumar ganesh | 9 | 7.96% | 1 | 12.50% |
gustavo f. padovan | gustavo f. padovan | 3 | 2.65% | 2 | 25.00% |
| Total | 113 | 100.00% | 8 | 100.00% |
static bool __chan_is_moving(struct l2cap_chan *chan)
{
return chan->move_state != L2CAP_MOVE_STABLE &&
chan->move_state != L2CAP_MOVE_WAIT_PREPARE;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 24 | 100.00% | 1 | 100.00% |
| Total | 24 | 100.00% | 1 | 100.00% |
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 (chan->hs_hcon && !__chan_is_moving(chan)) {
if (chan->hs_hchan)
hci_send_acl(chan->hs_hchan, skb, ACL_COMPLETE);
else
kfree_skb(skb);
return;
}
/* Use NO_FLUSH for LE links (where this is the only option) or
* if the BR/EDR link supports it and flushing has not been
* explicitly requested (through FLAG_FLUSHABLE).
*/
if (hcon->type == LE_LINK ||
(!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);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
luiz augusto von dentz | luiz augusto von dentz | 98 | 64.05% | 1 | 14.29% |
mat martineau | mat martineau | 38 | 24.84% | 1 | 14.29% |
steven walter | steven walter | 9 | 5.88% | 1 | 14.29% |
marcel holtmann | marcel holtmann | 6 | 3.92% | 2 | 28.57% |
gustavo f. padovan | gustavo f. padovan | 1 | 0.65% | 1 | 14.29% |
andrei emeltchenko | andrei emeltchenko | 1 | 0.65% | 1 | 14.29% |
| Total | 153 | 100.00% | 7 | 100.00% |
static void __unpack_enhanced_control(u16 enh, struct l2cap_ctrl *control)
{
control->reqseq = (enh & L2CAP_CTRL_REQSEQ) >> L2CAP_CTRL_REQSEQ_SHIFT;
control->final = (enh & L2CAP_CTRL_FINAL) >> L2CAP_CTRL_FINAL_SHIFT;
if (enh & L2CAP_CTRL_FRAME_TYPE) {
/* S-Frame */
control->sframe = 1;
control->poll = (enh & L2CAP_CTRL_POLL) >> L2CAP_CTRL_POLL_SHIFT;
control->super = (enh & L2CAP_CTRL_SUPERVISE) >> L2CAP_CTRL_SUPER_SHIFT;
control->sar = 0;
control->txseq = 0;
} else {
/* I-Frame */
control->sframe = 0;
control->sar = (enh & L2CAP_CTRL_SAR) >> L2CAP_CTRL_SAR_SHIFT;
control->txseq = (enh & L2CAP_CTRL_TXSEQ) >> L2CAP_CTRL_TXSEQ_SHIFT;
control->poll = 0;
control->super = 0;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 109 | 80.74% | 2 | 18.18% |
gustavo padovan | gustavo padovan | 20 | 14.81% | 4 | 36.36% |
gustavo f. padovan | gustavo f. padovan | 6 | 4.44% | 5 | 45.45% |
| Total | 135 | 100.00% | 11 | 100.00% |
static void __unpack_extended_control(u32 ext, struct l2cap_ctrl *control)
{
control->reqseq = (ext & L2CAP_EXT_CTRL_REQSEQ) >> L2CAP_EXT_CTRL_REQSEQ_SHIFT;
control->final = (ext & L2CAP_EXT_CTRL_FINAL) >> L2CAP_EXT_CTRL_FINAL_SHIFT;
if (ext & L2CAP_EXT_CTRL_FRAME_TYPE) {
/* S-Frame */
control->sframe = 1;
control->poll = (ext & L2CAP_EXT_CTRL_POLL) >> L2CAP_EXT_CTRL_POLL_SHIFT;
control->super = (ext & L2CAP_EXT_CTRL_SUPERVISE) >> L2CAP_EXT_CTRL_SUPER_SHIFT;
control->sar = 0;
control->txseq = 0;
} else {
/* I-Frame */
control->sframe = 0;
control->sar = (ext & L2CAP_EXT_CTRL_SAR) >> L2CAP_EXT_CTRL_SAR_SHIFT;
control->txseq = (ext & L2CAP_EXT_CTRL_TXSEQ) >> L2CAP_EXT_CTRL_TXSEQ_SHIFT;
control->poll = 0;
control->super = 0;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 135 | 100.00% | 2 | 100.00% |
| Total | 135 | 100.00% | 2 | 100.00% |
static inline void __unpack_control(struct l2cap_chan *chan,
struct sk_buff *skb)
{
if (test_bit(FLAG_EXT_CTRL, &chan->flags)) {
__unpack_extended_control(get_unaligned_le32(skb->data),
&bt_cb(skb)->l2cap);
skb_pull(skb, L2CAP_EXT_CTRL_SIZE);
} else {
__unpack_enhanced_control(get_unaligned_le16(skb->data),
&bt_cb(skb)->l2cap);
skb_pull(skb, L2CAP_ENH_CTRL_SIZE);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 82 | 97.62% | 2 | 66.67% |
johan hedberg | johan hedberg | 2 | 2.38% | 1 | 33.33% |
| Total | 84 | 100.00% | 3 | 100.00% |
static u32 __pack_extended_control(struct l2cap_ctrl *control)
{
u32 packed;
packed = control->reqseq << L2CAP_EXT_CTRL_REQSEQ_SHIFT;
packed |= control->final << L2CAP_EXT_CTRL_FINAL_SHIFT;
if (control->sframe) {
packed |= control->poll << L2CAP_EXT_CTRL_POLL_SHIFT;
packed |= control->super << L2CAP_EXT_CTRL_SUPER_SHIFT;
packed |= L2CAP_EXT_CTRL_FRAME_TYPE;
} else {
packed |= control->sar << L2CAP_EXT_CTRL_SAR_SHIFT;
packed |= control->txseq << L2CAP_EXT_CTRL_TXSEQ_SHIFT;
}
return packed;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 80 | 100.00% | 2 | 100.00% |
| Total | 80 | 100.00% | 2 | 100.00% |
static u16 __pack_enhanced_control(struct l2cap_ctrl *control)
{
u16 packed;
packed = control->reqseq << L2CAP_CTRL_REQSEQ_SHIFT;
packed |= control->final << L2CAP_CTRL_FINAL_SHIFT;
if (control->sframe) {
packed |= control->poll << L2CAP_CTRL_POLL_SHIFT;
packed |= control->super << L2CAP_CTRL_SUPER_SHIFT;
packed |= L2CAP_CTRL_FRAME_TYPE;
} else {
packed |= control->sar << L2CAP_CTRL_SAR_SHIFT;
packed |= control->txseq << L2CAP_CTRL_TXSEQ_SHIFT;
}
return packed;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 80 | 100.00% | 2 | 100.00% |
| Total | 80 | 100.00% | 2 | 100.00% |
static inline void __pack_control(struct l2cap_chan *chan,
struct l2cap_ctrl *control,
struct sk_buff *skb)
{
if (test_bit(FLAG_EXT_CTRL, &chan->flags)) {
put_unaligned_le32(__pack_extended_control(control),
skb->data + L2CAP_HDR_SIZE);
} else {
put_unaligned_le16(__pack_enhanced_control(control),
skb->data + L2CAP_HDR_SIZE);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 67 | 100.00% | 2 | 100.00% |
| Total | 67 | 100.00% | 2 | 100.00% |
static inline unsigned int __ertm_hdr_size(struct l2cap_chan *chan)
{
if (test_bit(FLAG_EXT_CTRL, &chan->flags))
return L2CAP_EXT_HDR_SIZE;
else
return L2CAP_ENH_HDR_SIZE;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 32 | 100.00% | 1 | 100.00% |
| Total | 32 | 100.00% | 1 | 100.00% |
static struct sk_buff *l2cap_create_sframe_pdu(struct l2cap_chan *chan,
u32 control)
{
struct sk_buff *skb;
struct l2cap_hdr *lh;
int hlen = __ertm_hdr_size(chan);
if (chan->fcs == L2CAP_FCS_CRC16)
hlen += L2CAP_FCS_SIZE;
skb = bt_skb_alloc(hlen, GFP_KERNEL);
if (!skb)
return ERR_PTR(-ENOMEM);
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);
if (test_bit(FLAG_EXT_CTRL, &chan->flags))
put_unaligned_le32(control, skb_put(skb, L2CAP_EXT_CTRL_SIZE));
else
put_unaligned_le16(control, skb_put(skb, L2CAP_ENH_CTRL_SIZE));
if (chan->fcs == L2CAP_FCS_CRC16) {
u16 fcs = crc16(0, (u8 *)skb->data, skb->len);
put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE));
}
skb->priority = HCI_PRIO_MAX;
return skb;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 188 | 98.43% | 3 | 75.00% |
gustavo padovan | gustavo padovan | 3 | 1.57% | 1 | 25.00% |
| Total | 191 | 100.00% | 4 | 100.00% |
static void l2cap_send_sframe(struct l2cap_chan *chan,
struct l2cap_ctrl *control)
{
struct sk_buff *skb;
u32 control_field;
BT_DBG("chan %p, control %p", chan, control);
if (!control->sframe)
return;
if (__chan_is_moving(chan))
return;
if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state) &&
!control->poll)
control->final = 1;
if (control->super == L2CAP_SUPER_RR)
clear_bit(CONN_RNR_SENT, &chan->conn_state);
else if (control->super == L2CAP_SUPER_RNR)
set_bit(CONN_RNR_SENT, &chan->conn_state);
if (control->super != L2CAP_SUPER_SREJ) {
chan->last_acked_seq = control->reqseq;
__clear_ack_timer(chan);
}
BT_DBG("reqseq %d, final %d, poll %d, super %d", control->reqseq,
control->final, control->poll, control->super);
if (test_bit(FLAG_EXT_CTRL, &chan->flags))
control_field = __pack_extended_control(control);
else
control_field = __pack_enhanced_control(control);
skb = l2cap_create_sframe_pdu(chan, control_field);
if (!IS_ERR(skb))
l2cap_do_send(chan, skb);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 204 | 100.00% | 4 | 100.00% |
| Total | 204 | 100.00% | 4 | 100.00% |
static void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, bool poll)
{
struct l2cap_ctrl control;
BT_DBG("chan %p, poll %d", chan, poll);
memset(&control, 0, sizeof(control));
control.sframe = 1;
control.poll = poll;
if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state))
control.super = L2CAP_SUPER_RNR;
else
control.super = L2CAP_SUPER_RR;
control.reqseq = chan->buffer_seq;
l2cap_send_sframe(chan, &control);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 93 | 100.00% | 3 | 100.00% |
| Total | 93 | 100.00% | 3 | 100.00% |
static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan)
{
if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED)
return true;
return !test_bit(CONF_CONNECT_PEND, &chan->conf_state);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 15 | 42.86% | 1 | 25.00% |
johan hedberg | johan hedberg | 11 | 31.43% | 1 | 25.00% |
gustavo f. padovan | gustavo f. padovan | 9 | 25.71% | 2 | 50.00% |
| Total | 35 | 100.00% | 4 | 100.00% |
static bool __amp_capable(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
struct hci_dev *hdev;
bool amp_available = false;
if (!(conn->local_fixed_chan & L2CAP_FC_A2MP))
return false;
if (!(conn->remote_fixed_chan & L2CAP_FC_A2MP))
return false;
read_lock(&hci_dev_list_lock);
list_for_each_entry(hdev, &hci_dev_list, list) {
if (hdev->amp_type != AMP_TYPE_BREDR &&
test_bit(HCI_UP, &hdev->flags)) {
amp_available = true;
break;
}
}
read_unlock(&hci_dev_list_lock);
if (chan->chan_policy == BT_CHANNEL_POLICY_AMP_PREFERRED)
return amp_available;
return false;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 99 | 83.19% | 2 | 50.00% |
andrei emeltchenko | andrei emeltchenko | 14 | 11.76% | 1 | 25.00% |
johan hedberg | johan hedberg | 6 | 5.04% | 1 | 25.00% |
| Total | 119 | 100.00% | 4 | 100.00% |
static bool l2cap_check_efs(struct l2cap_chan *chan)
{
/* Check EFS parameters */
return true;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 15 | 100.00% | 1 | 100.00% |
| Total | 15 | 100.00% | 1 | 100.00% |
void l2cap_send_conn_req(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
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);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 62 | 77.50% | 1 | 12.50% |
gustavo f. padovan | gustavo f. padovan | 14 | 17.50% | 5 | 62.50% |
andrei emeltchenko | andrei emeltchenko | 4 | 5.00% | 2 | 25.00% |
| Total | 80 | 100.00% | 8 | 100.00% |
static void l2cap_send_create_chan_req(struct l2cap_chan *chan, u8 amp_id)
{
struct l2cap_create_chan_req req;
req.scid = cpu_to_le16(chan->scid);
req.psm = chan->psm;
req.amp_id = amp_id;
chan->ident = l2cap_get_ident(chan->conn);
l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_REQ,
sizeof(req), &req);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 75 | 100.00% | 1 | 100.00% |
| Total | 75 | 100.00% | 1 | 100.00% |
static void l2cap_move_setup(struct l2cap_chan *chan)
{
struct sk_buff *skb;
BT_DBG("chan %p", chan);
if (chan->mode != L2CAP_MODE_ERTM)
return;
__clear_retrans_timer(chan);
__clear_monitor_timer(chan);
__clear_ack_timer(chan);
chan->retry_count = 0;
skb_queue_walk(&chan->tx_q, skb) {
if (bt_cb(skb)->l2cap.retries)
bt_cb(skb)->l2cap.retries = 1;
else
break;
}
chan->expected_tx_seq = chan->buffer_seq;
clear_bit(CONN_REJ_ACT, &chan->conn_state);
clear_bit(CONN_SREJ_ACT, &chan->conn_state);
l2cap_seq_list_clear(&chan->retrans_list);
l2cap_seq_list_clear(&chan->srej_list);
skb_queue_purge(&chan->srej_q);
chan->tx_state = L2CAP_TX_STATE_XMIT;
chan->rx_state = L2CAP_RX_STATE_MOVE;
set_bit(CONN_REMOTE_BUSY, &chan->conn_state);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 157 | 98.74% | 1 | 50.00% |
johan hedberg | johan hedberg | 2 | 1.26% | 1 | 50.00% |
| Total | 159 | 100.00% | 2 | 100.00% |
static void l2cap_move_done(struct l2cap_chan *chan)
{
u8 move_role = chan->move_role;
BT_DBG("chan %p", chan);
chan->move_state = L2CAP_MOVE_STABLE;
chan->move_role = L2CAP_MOVE_ROLE_NONE;
if (chan->mode != L2CAP_MODE_ERTM)
return;
switch (move_role) {
case L2CAP_MOVE_ROLE_INITIATOR:
l2cap_tx(chan, NULL, NULL, L2CAP_EV_EXPLICIT_POLL);
chan->rx_state = L2CAP_RX_STATE_WAIT_F;
break;
case L2CAP_MOVE_ROLE_RESPONDER:
chan->rx_state = L2CAP_RX_STATE_WAIT_P;
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 83 | 100.00% | 1 | 100.00% |
| Total | 83 | 100.00% | 1 | 100.00% |
static void l2cap_chan_ready(struct l2cap_chan *chan)
{
/* The channel may have already been flagged as connected in
* case of receiving data before the L2CAP info req/rsp
* procedure is complete.
*/
if (chan->state == BT_CONNECTED)
return;
/* This clears all conf flags, including CONF_NOT_COMPLETE */
chan->conf_state = 0;
__clear_chan_timer(chan);
if (chan->mode == L2CAP_MODE_LE_FLOWCTL && !chan->tx_credits)
chan->ops->suspend(chan);
chan->state = BT_CONNECTED;
chan->ops->ready(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 32 | 45.71% | 3 | 50.00% |
vinicius costa gomes | vinicius costa gomes | 29 | 41.43% | 1 | 16.67% |
andrei emeltchenko | andrei emeltchenko | 8 | 11.43% | 1 | 16.67% |
mat martineau | mat martineau | 1 | 1.43% | 1 | 16.67% |
| Total | 70 | 100.00% | 6 | 100.00% |
static void l2cap_le_connect(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
struct l2cap_le_conn_req req;
if (test_and_set_bit(FLAG_LE_CONN_REQ_SENT, &chan->flags))
return;
req.psm = chan->psm;
req.scid = cpu_to_le16(chan->scid);
req.mtu = cpu_to_le16(chan->imtu);
req.mps = cpu_to_le16(chan->mps);
req.credits = cpu_to_le16(chan->rx_credits);
chan->ident = l2cap_get_ident(conn);
l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CONN_REQ,
sizeof(req), &req);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 92 | 78.63% | 4 | 80.00% |
andrei emeltchenko | andrei emeltchenko | 25 | 21.37% | 1 | 20.00% |
| Total | 117 | 100.00% | 5 | 100.00% |
static void l2cap_le_start(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
if (!smp_conn_security(conn->hcon, chan->sec_level))
return;
if (!chan->psm) {
l2cap_chan_ready(chan);
return;
}
if (chan->state == BT_CONNECT)
l2cap_le_connect(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 63 | 100.00% | 2 | 100.00% |
| Total | 63 | 100.00% | 2 | 100.00% |
static void l2cap_start_connection(struct l2cap_chan *chan)
{
if (__amp_capable(chan)) {
BT_DBG("chan %p AMP capable: discover AMPs", chan);
a2mp_discover_amp(chan);
} else if (chan->conn->hcon->type == LE_LINK) {
l2cap_le_start(chan);
} else {
l2cap_send_conn_req(chan);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 60 | 100.00% | 2 | 100.00% |
| Total | 60 | 100.00% | 2 | 100.00% |
static void l2cap_request_info(struct l2cap_conn *conn)
{
struct l2cap_info_req req;
if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)
return;
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, L2CAP_INFO_TIMEOUT);
l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ,
sizeof(req), &req);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 77 | 100.00% | 1 | 100.00% |
| Total | 77 | 100.00% | 1 | 100.00% |
static void l2cap_do_start(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
if (conn->hcon->type == LE_LINK) {
l2cap_le_start(chan);
return;
}
if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)) {
l2cap_request_info(conn);
return;
}
if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
return;
if (l2cap_chan_check_security(chan, true) &&
__l2cap_no_conn_pending(chan))
l2cap_start_connection(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 57 | 64.77% | 2 | 28.57% |
vinicius costa gomes | vinicius costa gomes | 17 | 19.32% | 1 | 14.29% |
johan hedberg | johan hedberg | 13 | 14.77% | 3 | 42.86% |
marcel holtmann | marcel holtmann | 1 | 1.14% | 1 | 14.29% |
| Total | 88 | 100.00% | 7 | 100.00% |
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;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 59 | 100.00% | 2 | 100.00% |
| Total | 59 | 100.00% | 2 | 100.00% |
static void l2cap_send_disconn_req(struct l2cap_chan *chan, int err)
{
struct l2cap_conn *conn = chan->conn;
struct l2cap_disconn_req req;
if (!conn)
return;
if (chan->mode == L2CAP_MODE_ERTM && chan->state == BT_CONNECTED) {
__clear_retrans_timer(chan);
__clear_monitor_timer(chan);
__clear_ack_timer(chan);
}
if (chan->scid == L2CAP_CID_A2MP) {
l2cap_state_change(chan, BT_DISCONN);
return;
}
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_and_error(chan, BT_DISCONN, err);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 54 | 40.60% | 3 | 18.75% |
gustavo f. padovan | gustavo f. padovan | 45 | 33.83% | 8 | 50.00% |
andrei emeltchenko | andrei emeltchenko | 32 | 24.06% | 4 | 25.00% |
johan hedberg | johan hedberg | 2 | 1.50% | 1 | 6.25% |
| Total | 133 | 100.00% | 16 | 100.00% |
/* ---- L2CAP connections ---- */
static void l2cap_conn_start(struct l2cap_conn *conn)
{
struct l2cap_chan *chan, *tmp;
BT_DBG("conn %p", conn);
mutex_lock(&conn->chan_lock);
list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) {
l2cap_chan_lock(chan);
if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
l2cap_chan_ready(chan);
l2cap_chan_unlock(chan);
continue;
}
if (chan->state == BT_CONNECT) {
if (!l2cap_chan_check_security(chan, true) ||
!__l2cap_no_conn_pending(chan)) {
l2cap_chan_unlock(chan);
continue;
}
if (!l2cap_mode_supported(chan->mode, conn->feat_mask)
&& test_bit(CONF_STATE2_DEVICE,
&chan->conf_state)) {
l2cap_chan_close(chan, ECONNRESET);
l2cap_chan_unlock(chan);
continue;
}
l2cap_start_connection(chan);
} 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, false)) {
if (test_bit(FLAG_DEFER_SETUP, &chan->flags)) {
rsp.result = cpu_to_le16(L2CAP_CR_PEND);
rsp.status = cpu_to_le16(L2CAP_CS_AUTHOR_PEND);
chan->ops->defer(chan);
} 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) {
l2cap_chan_unlock(chan);
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++;
}
l2cap_chan_unlock(chan);
}
mutex_unlock(&conn->chan_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 184 | 47.42% | 5 | 14.71% |
gustavo f. padovan | gustavo f. padovan | 142 | 36.60% | 19 | 55.88% |
andrei emeltchenko | andrei emeltchenko | 36 | 9.28% | 4 | 11.76% |
gustavo padovan | gustavo padovan | 11 | 2.84% | 3 | 8.82% |
johan hedberg | johan hedberg | 9 | 2.32% | 2 | 5.88% |
joe perches | joe perches | 6 | 1.55% | 1 | 2.94% |
| Total | 388 | 100.00% | 34 | 100.00% |
static void l2cap_le_conn_ready(struct l2cap_conn *conn)
{
struct hci_conn *hcon = conn->hcon;
struct hci_dev *hdev = hcon->hdev;
BT_DBG("%s conn %p", hdev->name, conn);
/* For outgoing pairing which doesn't necessarily have an
* associated socket (e.g. mgmt_pair_device).
*/
if (hcon->out)
smp_conn_security(hcon, hcon->pending_sec_level);
/* For LE slave connections, make sure the connection interval
* is in the range of the minium and maximum interval that has
* been configured for this connection. If not, then trigger
* the connection update procedure.
*/
if (hcon->role == HCI_ROLE_SLAVE &&
(hcon->le_conn_interval < hcon->le_conn_min_interval ||
hcon->le_conn_interval > hcon->le_conn_max_interval)) {
struct l2cap_conn_param_update_req req;
req.min = cpu_to_le16(hcon->le_conn_min_interval);
req.max = cpu_to_le16(hcon->le_conn_max_interval);
req.latency = cpu_to_le16(hcon->le_conn_latency);
req.to_multiplier = cpu_to_le16(hcon->le_supv_timeout);
l2cap_send_cmd(conn, l2cap_get_ident(conn),
L2CAP_CONN_PARAM_UPDATE_REQ, sizeof(req), &req);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 111 | 72.55% | 3 | 33.33% |
johan hedberg | johan hedberg | 22 | 14.38% | 4 | 44.44% |
ville tervo | ville tervo | 19 | 12.42% | 1 | 11.11% |
ido yariv | ido yariv | 1 | 0.65% | 1 | 11.11% |
| Total | 153 | 100.00% | 9 | 100.00% |
static void l2cap_conn_ready(struct l2cap_conn *conn)
{
struct l2cap_chan *chan;
struct hci_conn *hcon = conn->hcon;
BT_DBG("conn %p", conn);
if (hcon->type == ACL_LINK)
l2cap_request_info(conn);
mutex_lock(&conn->chan_lock);
list_for_each_entry(chan, &conn->chan_l, list) {
l2cap_chan_lock(chan);
if (chan->scid == L2CAP_CID_A2MP) {
l2cap_chan_unlock(chan);
continue;
}
if (hcon->type == LE_LINK) {
l2cap_le_start(chan);
} else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)
l2cap_chan_ready(chan);
} else if (chan->state == BT_CONNECT) {
l2cap_do_start(chan);
}
l2cap_chan_unlock(chan);
}
mutex_unlock(&conn->chan_lock);
if (hcon->type == LE_LINK)
l2cap_le_conn_ready(conn);
queue_work(hcon->hdev->workqueue, &conn->pending_rx_work);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 51 | 28.49% | 5 | 21.74% |
marcel holtmann | marcel holtmann | 47 | 26.26% | 2 | 8.70% |
andrei emeltchenko | andrei emeltchenko | 36 | 20.11% | 4 | 17.39% |
gustavo f. padovan | gustavo f. padovan | 19 | 10.61% | 6 | 26.09% |
vinicius costa gomes | vinicius costa gomes | 12 | 6.70% | 2 | 8.70% |
ville tervo | ville tervo | 8 | 4.47% | 1 | 4.35% |
anderson briglia | anderson briglia | 3 | 1.68% | 1 | 4.35% |
gustavo padovan | gustavo padovan | 3 | 1.68% | 2 | 8.70% |
| Total | 179 | 100.00% | 23 | 100.00% |
/* 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);
mutex_lock(&conn->chan_lock);
list_for_each_entry(chan, &conn->chan_l, list) {
if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
l2cap_chan_set_err(chan, err);
}
mutex_unlock(&conn->chan_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 34 | 47.89% | 1 | 12.50% |
andrei emeltchenko | andrei emeltchenko | 26 | 36.62% | 3 | 37.50% |
gustavo f. padovan | gustavo f. padovan | 10 | 14.08% | 3 | 37.50% |
gustavo padovan | gustavo padovan | 1 | 1.41% | 1 | 12.50% |
| Total | 71 | 100.00% | 8 | 100.00% |
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);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 30 | 66.67% | 3 | 60.00% |
gustavo f. padovan | gustavo f. padovan | 15 | 33.33% | 2 | 40.00% |
| Total | 45 | 100.00% | 5 | 100.00% |
/*
* l2cap_user
* External modules can register l2cap_user objects on l2cap_conn. The ->probe
* callback is called during registration. The ->remove callback is called
* during unregistration.
* An l2cap_user object can either be explicitly unregistered or when the
* underlying l2cap_conn object is deleted. This guarantees that l2cap->hcon,
* l2cap->hchan, .. are valid as long as the remove callback hasn't been called.
* External modules must own a reference to the l2cap_conn object if they intend
* to call l2cap_unregister_user(). The l2cap_conn object might get destroyed at
* any time if they don't.
*/
int l2cap_register_user(struct l2cap_conn *conn, struct l2cap_user *user)
{
struct hci_dev *hdev = conn->hcon->hdev;
int ret;
/* We need to check whether l2cap_conn is registered. If it is not, we
* must not register the l2cap_user. l2cap_conn_del() is unregisters
* l2cap_conn objects, but doesn't provide its own locking. Instead, it
* relies on the parent hci_conn object to be locked. This itself relies
* on the hci_dev object to be locked. So we must lock the hci device
* here, too. */
hci_dev_lock(hdev);
if (!list_empty(&user->list)) {
ret = -EINVAL;
goto out_unlock;
}
/* conn->hchan is NULL after l2cap_conn_del() was called */
if (!conn->hchan) {
ret = -ENODEV;
goto out_unlock;
}
ret = user->probe(conn, user);
if (ret)
goto out_unlock;
list_add(&user->list, &conn->users);
ret = 0;
out_unlock:
hci_dev_unlock(hdev);
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
david herrmann | david herrmann | 114 | 95.80% | 1 | 50.00% |
alexey dobriyan | alexey dobriyan | 5 | 4.20% | 1 | 50.00% |
| Total | 119 | 100.00% | 2 | 100.00% |
EXPORT_SYMBOL(l2cap_register_user);
void l2cap_unregister_user(struct l2cap_conn *conn, struct l2cap_user *user)
{
struct hci_dev *hdev = conn->hcon->hdev;
hci_dev_lock(hdev);
if (list_empty(&user->list))
goto out_unlock;
list_del_init(&user->list);
user->remove(conn, user);
out_unlock:
hci_dev_unlock(hdev);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
david herrmann | david herrmann | 63 | 92.65% | 1 | 33.33% |
alexey dobriyan | alexey dobriyan | 4 | 5.88% | 1 | 33.33% |
tedd ho-jeong an | tedd ho-jeong an | 1 | 1.47% | 1 | 33.33% |
| Total | 68 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL(l2cap_unregister_user);
static void l2cap_unregister_all_users(struct l2cap_conn *conn)
{
struct l2cap_user *user;
while (!list_empty(&conn->users)) {
user = list_first_entry(&conn->users, struct l2cap_user, list);
list_del_init(&user->list);
user->remove(conn, user);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
david herrmann | david herrmann | 60 | 98.36% | 1 | 50.00% |
tedd ho-jeong an | tedd ho-jeong an | 1 | 1.64% | 1 | 50.00% |
| Total | 61 | 100.00% | 2 | 100.00% |
static void l2cap_conn_del(struct hci_conn *hcon, int err)
{
struct l2cap_conn *conn = hcon->l2cap_data;
struct l2cap_chan *chan, *l;
if (!conn)
return;
BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
kfree_skb(conn->rx_skb);
skb_queue_purge(&conn->pending_rx);
/* We can not call flush_work(&conn->pending_rx_work) here since we
* might block if we are running on a worker from the same workqueue
* pending_rx_work is waiting on.
*/
if (work_pending(&conn->pending_rx_work))
cancel_work_sync(&conn->pending_rx_work);
if (work_pending(&conn->id_addr_update_work))
cancel_work_sync(&conn->id_addr_update_work);
l2cap_unregister_all_users(conn);
/* Force the connection to be immediately dropped */
hcon->disc_timeout = 0;
mutex_lock(&conn->chan_lock);
/* Kill channels */
list_for_each_entry_safe(chan, l, &conn->chan_l, list) {
l2cap_chan_hold(chan);
l2cap_chan_lock(chan);
l2cap_chan_del(chan, err);
l2cap_chan_unlock(chan);
chan->ops->close(chan);
l2cap_chan_put(chan);
}
mutex_unlock(&conn->chan_lock);
hci_chan_del(conn->hchan);
if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)
cancel_delayed_work_sync(&conn->info_timer);
hcon->l2cap_data = NULL;
conn->hchan = NULL;
l2cap_conn_put(conn);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
vinicius costa gomes | vinicius costa gomes | 115 | 53.00% | 1 | 8.33% |
johan hedberg | johan hedberg | 40 | 18.43% | 3 | 25.00% |
andrei emeltchenko | andrei emeltchenko | 20 | 9.22% | 2 | 16.67% |
david herrmann | david herrmann | 12 | 5.53% | 2 | 16.67% |
jukka taimisto | jukka taimisto | 12 | 5.53% | 1 | 8.33% |
mat martineau | mat martineau | 10 | 4.61% | 1 | 8.33% |
luiz augusto von dentz | luiz augusto von dentz | 7 | 3.23% | 1 | 8.33% |
ulisses furquim | ulisses furquim | 1 | 0.46% | 1 | 8.33% |
| Total | 217 | 100.00% | 12 | 100.00% |
static void l2cap_conn_free(struct kref *ref)
{
struct l2cap_conn *conn = container_of(ref, struct l2cap_conn, ref);
hci_conn_put(conn->hcon);
kfree(conn);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 17 | 44.74% | 1 | 20.00% |
marcel holtmann | marcel holtmann | 9 | 23.68% | 1 | 20.00% |
linus torvalds | linus torvalds | 7 | 18.42% | 1 | 20.00% |
luiz augusto von dentz | luiz augusto von dentz | 4 | 10.53% | 1 | 20.00% |
maksim krasnyanskiy | maksim krasnyanskiy | 1 | 2.63% | 1 | 20.00% |
| Total | 38 | 100.00% | 5 | 100.00% |
struct l2cap_conn *l2cap_conn_get(struct l2cap_conn *conn)
{
kref_get(&conn->ref);
return conn;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 16 | 69.57% | 2 | 66.67% |
david herrmann | david herrmann | 7 | 30.43% | 1 | 33.33% |
| Total | 23 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL(l2cap_conn_get);
void l2cap_conn_put(struct l2cap_conn *conn)
{
kref_put(&conn->ref, l2cap_conn_free);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 14 | 70.00% | 1 | 33.33% |
david herrmann | david herrmann | 5 | 25.00% | 1 | 33.33% |
marcel holtmann | marcel holtmann | 1 | 5.00% | 1 | 33.33% |
| Total | 20 | 100.00% | 3 | 100.00% |
EXPORT_SYMBOL(l2cap_conn_put);
/* ---- Socket interface ---- */
/* Find socket with psm and source / destination bdaddr.
* Returns closest match.
*/
static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm,
bdaddr_t *src,
bdaddr_t *dst,
u8 link_type)
{
struct l2cap_chan *c, *c1 = NULL;
read_lock(&chan_list_lock);
list_for_each_entry(c, &chan_list, global_l) {
if (state && c->state != state)
continue;
if (link_type == ACL_LINK && c->src_type != BDADDR_BREDR)
continue;
if (link_type == LE_LINK && c->src_type == BDADDR_BREDR)
continue;
if (c->psm == psm) {
int src_match, dst_match;
int src_any, dst_any;
/* Exact match. */
src_match = !bacmp(&c->src, src);
dst_match = !bacmp(&c->dst, dst);
if (src_match && dst_match) {
l2cap_chan_hold(c);
read_unlock(&chan_list_lock);
return c;
}
/* Closest match */
src_any = !bacmp(&c->src, BDADDR_ANY);
dst_any = !bacmp(&c->dst, BDADDR_ANY);
if ((src_match && dst_any) || (src_any && dst_match) ||
(src_any && dst_any))
c1 = c;
}
}
if (c1)
l2cap_chan_hold(c1);
read_unlock(&chan_list_lock);
return c1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 176 | 77.88% | 2 | 12.50% |
marcel holtmann | marcel holtmann | 17 | 7.52% | 3 | 18.75% |
andrei emeltchenko | andrei emeltchenko | 8 | 3.54% | 2 | 12.50% |
linus torvalds | linus torvalds | 6 | 2.65% | 1 | 6.25% |
david herrmann | david herrmann | 5 | 2.21% | 1 | 6.25% |
ville tervo | ville tervo | 4 | 1.77% | 2 | 12.50% |
gustavo f. padovan | gustavo f. padovan | 3 | 1.33% | 1 | 6.25% |
vinicius costa gomes | vinicius costa gomes | 3 | 1.33% | 1 | 6.25% |
thomas gleixner | thomas gleixner | 2 | 0.88% | 1 | 6.25% |
luiz augusto von dentz | luiz augusto von dentz | 1 | 0.44% | 1 | 6.25% |
pavel emelianov | pavel emelianov | 1 | 0.44% | 1 | 6.25% |
| Total | 226 | 100.00% | 16 | 100.00% |
static void l2cap_monitor_timeout(struct work_struct *work)
{
struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
monitor_timer.work);
BT_DBG("chan %p", chan);
l2cap_chan_lock(chan);
if (!chan->conn) {
l2cap_chan_unlock(chan);
l2cap_chan_put(chan);
return;
}
l2cap_tx(chan, NULL, NULL, L2CAP_EV_MONITOR_TO);
l2cap_chan_unlock(chan);
l2cap_chan_put(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 49 | 60.49% | 1 | 50.00% |
david herrmann | david herrmann | 32 | 39.51% | 1 | 50.00% |
| Total | 81 | 100.00% | 2 | 100.00% |
static void l2cap_retrans_timeout(struct work_struct *work)
{
struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
retrans_timer.work);
BT_DBG("chan %p", chan);
l2cap_chan_lock(chan);
if (!chan->conn) {
l2cap_chan_unlock(chan);
l2cap_chan_put(chan);
return;
}
l2cap_tx(chan, NULL, NULL, L2CAP_EV_RETRANS_TO);
l2cap_chan_unlock(chan);
l2cap_chan_put(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 67 | 82.72% | 1 | 50.00% |
david herrmann | david herrmann | 14 | 17.28% | 1 | 50.00% |
| Total | 81 | 100.00% | 2 | 100.00% |
static void l2cap_streaming_send(struct l2cap_chan *chan,
struct sk_buff_head *skbs)
{
struct sk_buff *skb;
struct l2cap_ctrl *control;
BT_DBG("chan %p, skbs %p", chan, skbs);
if (__chan_is_moving(chan))
return;
skb_queue_splice_tail_init(skbs, &chan->tx_q);
while (!skb_queue_empty(&chan->tx_q)) {
skb = skb_dequeue(&chan->tx_q);
bt_cb(skb)->l2cap.retries = 1;
control = &bt_cb(skb)->l2cap;
control->reqseq = 0;
control->txseq = chan->next_tx_seq;
__pack_control(chan, control, skb);
if (chan->fcs == L2CAP_FCS_CRC16) {
u16 fcs = crc16(0, (u8 *) skb->data, skb->len);
put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE));
}
l2cap_do_send(chan, skb);
BT_DBG("Sent txseq %u", control->txseq);
chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq);
chan->frames_sent++;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 147 | 75.00% | 4 | 44.44% |
maksim krasnyanskiy | maksim krasnyanskiy | 22 | 11.22% | 1 | 11.11% |
ido yariv | ido yariv | 19 | 9.69% | 1 | 11.11% |
marcel holtmann | marcel holtmann | 4 | 2.04% | 1 | 11.11% |
gustavo f. padovan | gustavo f. padovan | 2 | 1.02% | 1 | 11.11% |
linus torvalds | linus torvalds | 2 | 1.02% | 1 | 11.11% |
| Total | 196 | 100.00% | 9 | 100.00% |
static int l2cap_ertm_send(struct l2cap_chan *chan)
{
struct sk_buff *skb, *tx_skb;
struct l2cap_ctrl *control;
int sent = 0;
BT_DBG("chan %p", chan);
if (chan->state != BT_CONNECTED)
return -ENOTCONN;
if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
return 0;
if (__chan_is_moving(chan))
return 0;
while (chan->tx_send_head &&
chan->unacked_frames < chan->remote_tx_win &&
chan->tx_state == L2CAP_TX_STATE_XMIT) {
skb = chan->tx_send_head;
bt_cb(skb)->l2cap.retries = 1;
control = &bt_cb(skb)->l2cap;
if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
control->final = 1;
control->reqseq = chan->buffer_seq;
chan->last_acked_seq = chan->buffer_seq;
control->txseq = chan->next_tx_seq;
__pack_control(chan, control, skb);
if (chan->fcs == L2CAP_FCS_CRC16) {
u16 fcs = crc16(0, (u8 *) skb->data, skb->len);
put_unaligned_le16(fcs, skb_put(skb, L2CAP_FCS_SIZE));
}
/* Clone after data has been modified. Data is assumed to be
read-only (for locking purposes) on cloned sk_buffs.
*/
tx_skb = skb_clone(skb, GFP_KERNEL);
if (!tx_skb)
break;
__set_retrans_timer(chan);
chan->next_tx_seq = __next_seq(chan, chan->next_tx_seq);
chan->unacked_frames++;
chan->frames_sent++;
sent++;
if (skb_queue_is_last(&chan->tx_q, skb))
chan->tx_send_head = NULL;
else
chan->tx_send_head = skb_queue_next(&chan->tx_q, skb);
l2cap_do_send(chan, tx_skb);
BT_DBG("Sent txseq %u", control->txseq);
}
BT_DBG("Sent %d, %u unacked, %u in ERTM queue", sent,
chan->unacked_frames, skb_queue_len(&chan->tx_q));
return sent;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 200 | 60.06% | 5 | 17.86% |
gustavo f. padovan | gustavo f. padovan | 52 | 15.62% | 7 | 25.00% |
marcel holtmann | marcel holtmann | 30 | 9.01% | 6 | 21.43% |
ville tervo | ville tervo | 14 | 4.20% | 2 | 7.14% |
linus torvalds | linus torvalds | 12 | 3.60% | 1 | 3.57% |
maksim krasnyanskiy | maksim krasnyanskiy | 11 | 3.30% | 3 | 10.71% |
andrei emeltchenko | andrei emeltchenko | 6 | 1.80% | 1 | 3.57% |
gustavo padovan | gustavo padovan | 5 | 1.50% | 2 | 7.14% |
vinicius costa gomes | vinicius costa gomes | 3 | 0.90% | 1 | 3.57% |
| Total | 333 | 100.00% | 28 | 100.00% |
static void l2cap_ertm_resend(struct l2cap_chan *chan)
{
struct l2cap_ctrl control;
struct sk_buff *skb;
struct sk_buff *tx_skb;
u16 seq;
BT_DBG("chan %p", chan);
if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
return;
if (__chan_is_moving(chan))
return;
while (chan->retrans_list.head != L2CAP_SEQ_LIST_CLEAR) {
seq = l2cap_seq_list_pop(&chan->retrans_list);
skb = l2cap_ertm_seq_in_queue(&chan->tx_q, seq);
if (!skb) {
BT_DBG("Error: Can't retransmit seq %d, frame missing",
seq);
continue;
}
bt_cb(skb)->l2cap.retries++;
control = bt_cb(skb)->l2cap;
if (chan->max_tx != 0 &&
bt_cb(skb)->l2cap.retries > chan->max_tx) {
BT_DBG("Retry limit exceeded (%d)", chan->max_tx);
l2cap_send_disconn_req(chan, ECONNRESET);
l2cap_seq_list_clear(&chan->retrans_list);
break;
}
control.reqseq = chan->buffer_seq;
if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
control.final = 1;
else
control.final = 0;
if (skb_cloned(skb)) {
/* Cloned sk_buffs are read-only, so we need a
* writeable copy
*/
tx_skb = skb_copy(skb, GFP_KERNEL);
} else {
tx_skb = skb_clone(skb, GFP_KERNEL);
}
if (!tx_skb) {
l2cap_seq_list_clear(&chan->retrans_list);
break;
}
/* Update skb contents */
if (test_bit(FLAG_EXT_CTRL, &chan->flags)) {
put_unaligned_le32(__pack_extended_control(&control),
tx_skb->data + L2CAP_HDR_SIZE);
} else {
put_unaligned_le16(__pack_enhanced_control(&control),
tx_skb->data + L2CAP_HDR_SIZE);
}
/* Update FCS */
if (chan->fcs == L2CAP_FCS_CRC16) {
u16 fcs = crc16(0, (u8 *) tx_skb->data,
tx_skb->len - L2CAP_FCS_SIZE);
put_unaligned_le16(fcs, skb_tail_pointer(tx_skb) -
L2CAP_FCS_SIZE);
}
l2cap_do_send(chan, tx_skb);
BT_DBG("Resent txseq %d", control.txseq);
chan->last_acked_seq = chan->buffer_seq;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 221 | 59.89% | 3 | 9.38% |
gustavo padovan | gustavo padovan | 61 | 16.53% | 4 | 12.50% |
gustavo f. padovan | gustavo f. padovan | 27 | 7.32% | 12 | 37.50% |
mat martineau | mat martineau | 25 | 6.78% | 3 | 9.38% |
andrei emeltchenko | andrei emeltchenko | 21 | 5.69% | 4 | 12.50% |
lukasz rymanowski | lukasz rymanowski | 6 | 1.63% | 1 | 3.12% |
linus torvalds | linus torvalds | 3 | 0.81% | 1 | 3.12% |
maksim krasnyanskiy | maksim krasnyanskiy | 2 | 0.54% | 2 | 6.25% |
marcel holtmann | marcel holtmann | 2 | 0.54% | 1 | 3.12% |
ville tervo | ville tervo | 1 | 0.27% | 1 | 3.12% |
| Total | 369 | 100.00% | 32 | 100.00% |
static void l2cap_retransmit(struct l2cap_chan *chan,
struct l2cap_ctrl *control)
{
BT_DBG("chan %p, control %p", chan, control);
l2cap_seq_list_append(&chan->retrans_list, control->reqseq);
l2cap_ertm_resend(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 32 | 76.19% | 1 | 20.00% |
andrei emeltchenko | andrei emeltchenko | 4 | 9.52% | 1 | 20.00% |
gustavo padovan | gustavo padovan | 3 | 7.14% | 1 | 20.00% |
mat martineau | mat martineau | 2 | 4.76% | 1 | 20.00% |
gustavo f. padovan | gustavo f. padovan | 1 | 2.38% | 1 | 20.00% |
| Total | 42 | 100.00% | 5 | 100.00% |
static void l2cap_retransmit_all(struct l2cap_chan *chan,
struct l2cap_ctrl *control)
{
struct sk_buff *skb;
BT_DBG("chan %p, control %p", chan, control);
if (control->poll)
set_bit(CONN_SEND_FBIT, &chan->conn_state);
l2cap_seq_list_clear(&chan->retrans_list);
if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
return;
if (chan->unacked_frames) {
skb_queue_walk(&chan->tx_q, skb) {
if (bt_cb(skb)->l2cap.txseq == control->reqseq ||
skb == chan->tx_send_head)
break;
}
skb_queue_walk_from(&chan->tx_q, skb) {
if (skb == chan->tx_send_head)
break;
l2cap_seq_list_append(&chan->retrans_list,
bt_cb(skb)->l2cap.txseq);
}
l2cap_ertm_resend(chan);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 79 | 54.86% | 2 | 11.76% |
gustavo padovan | gustavo padovan | 30 | 20.83% | 3 | 17.65% |
mat martineau | mat martineau | 19 | 13.19% | 5 | 29.41% |
gustavo f. padovan | gustavo f. padovan | 14 | 9.72% | 5 | 29.41% |
andrei emeltchenko | andrei emeltchenko | 2 | 1.39% | 2 | 11.76% |
| Total | 144 | 100.00% | 17 | 100.00% |
static void l2cap_send_ack(struct l2cap_chan *chan)
{
struct l2cap_ctrl control;
u16 frames_to_ack = __seq_offset(chan, chan->buffer_seq,
chan->last_acked_seq);
int threshold;
BT_DBG("chan %p last_acked_seq %d buffer_seq %d",
chan, chan->last_acked_seq, chan->buffer_seq);
memset(&control, 0, sizeof(control));
control.sframe = 1;
if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state) &&
chan->rx_state == L2CAP_RX_STATE_RECV) {
__clear_ack_timer(chan);
control.super = L2CAP_SUPER_RNR;
control.reqseq = chan->buffer_seq;
l2cap_send_sframe(chan, &control);
} else {
if (!test_bit(CONN_REMOTE_BUSY, &chan->conn_state)) {
l2cap_ertm_send(chan);
/* If any i-frames were sent, they included an ack */
if (chan->buffer_seq == chan->last_acked_seq)
frames_to_ack = 0;
}
/* Ack now if the window is 3/4ths full.
* Calculate without mul or div
*/
threshold = chan->ack_win;
threshold += threshold << 1;
threshold >>= 2;
BT_DBG("frames_to_ack %u, threshold %d", frames_to_ack,
threshold);
if (frames_to_ack >= threshold) {
__clear_ack_timer(chan);
control.super = L2CAP_SUPER_RR;
control.reqseq = chan->buffer_seq;
l2cap_send_sframe(chan, &control);
frames_to_ack = 0;
}
if (frames_to_ack)
__set_ack_timer(chan);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 161 | 70.93% | 1 | 8.33% |
gustavo padovan | gustavo padovan | 26 | 11.45% | 2 | 16.67% |
mat martineau | mat martineau | 22 | 9.69% | 1 | 8.33% |
gustavo f. padovan | gustavo f. padovan | 14 | 6.17% | 6 | 50.00% |
andrei emeltchenko | andrei emeltchenko | 3 | 1.32% | 1 | 8.33% |
maksim krasnyanskiy | maksim krasnyanskiy | 1 | 0.44% | 1 | 8.33% |
| Total | 227 | 100.00% | 12 | 100.00% |
static inline int l2cap_skbuff_fromiovec(struct l2cap_chan *chan,
struct msghdr *msg, int len,
int count, struct sk_buff *skb)
{
struct l2cap_conn *conn = chan->conn;
struct sk_buff **frag;
int sent = 0;
if (copy_from_iter(skb_put(skb, count), count, &msg->msg_iter) != count)
return -EFAULT;
sent += count;
len -= count;
/* Continuation fragments (no L2CAP header) */
frag = &skb_shinfo(skb)->frag_list;
while (len) {
struct sk_buff *tmp;
count = min_t(unsigned int, conn->mtu, len);
tmp = chan->ops->alloc_skb(chan, 0, count,
msg->msg_flags & MSG_DONTWAIT);
if (IS_ERR(tmp))
return PTR_ERR(tmp);
*frag = tmp;
if (copy_from_iter(skb_put(*frag, count), count,
&msg->msg_iter) != count)
return -EFAULT;
sent += count;
len -= count;
skb->len += (*frag)->len;
skb->data_len += (*frag)->len;
frag = &(*frag)->next;
}
return sent;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 155 | 69.82% | 1 | 20.00% |
mat martineau | mat martineau | 53 | 23.87% | 2 | 40.00% |
al viro | al viro | 12 | 5.41% | 1 | 20.00% |
marcel holtmann | marcel holtmann | 2 | 0.90% | 1 | 20.00% |
| Total | 222 | 100.00% | 5 | 100.00% |
static struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan,
struct msghdr *msg, size_t len)
{
struct l2cap_conn *conn = chan->conn;
struct sk_buff *skb;
int err, count, hlen = L2CAP_HDR_SIZE + L2CAP_PSMLEN_SIZE;
struct l2cap_hdr *lh;
BT_DBG("chan %p psm 0x%2.2x len %zu", chan,
__le16_to_cpu(chan->psm), len);
count = min_t(unsigned int, (conn->mtu - hlen), len);
skb = chan->ops->alloc_skb(chan, hlen, count,
msg->msg_flags & MSG_DONTWAIT);
if (IS_ERR(skb))
return skb;
/* Create L2CAP header */
lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
lh->cid = cpu_to_le16(chan->dcid);
lh->len = cpu_to_le16(len + L2CAP_PSMLEN_SIZE);
put_unaligned(chan->psm, (__le16 *) skb_put(skb, L2CAP_PSMLEN_SIZE));
err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb);
if (unlikely(err < 0)) {
kfree_skb(skb);
return ERR_PTR(err);
}
return skb;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 134 | 65.69% | 1 | 25.00% |
mat martineau | mat martineau | 67 | 32.84% | 1 | 25.00% |
marcel holtmann | marcel holtmann | 3 | 1.47% | 2 | 50.00% |
| Total | 204 | 100.00% | 4 | 100.00% |
static struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan,
struct msghdr *msg, size_t len)
{
struct l2cap_conn *conn = chan->conn;
struct sk_buff *skb;
int err, count;
struct l2cap_hdr *lh;
BT_DBG("chan %p len %zu", chan, len);
count = min_t(unsigned int, (conn->mtu - L2CAP_HDR_SIZE), len);
skb = chan->ops->alloc_skb(chan, L2CAP_HDR_SIZE, count,
msg->msg_flags & MSG_DONTWAIT);
if (IS_ERR(skb))
return skb;
/* Create L2CAP header */
lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
lh->cid = cpu_to_le16(chan->dcid);
lh->len = cpu_to_le16(len);
err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb);
if (unlikely(err < 0)) {
kfree_skb(skb);
return ERR_PTR(err);
}
return skb;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 110 | 64.33% | 1 | 20.00% |
mat martineau | mat martineau | 59 | 34.50% | 3 | 60.00% |
marcel holtmann | marcel holtmann | 2 | 1.17% | 1 | 20.00% |
| Total | 171 | 100.00% | 5 | 100.00% |
static struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan,
struct msghdr *msg, size_t len,
u16 sdulen)
{
struct l2cap_conn *conn = chan->conn;
struct sk_buff *skb;
int err, count, hlen;
struct l2cap_hdr *lh;
BT_DBG("chan %p len %zu", chan, len);
if (!conn)
return ERR_PTR(-ENOTCONN);
hlen = __ertm_hdr_size(chan);
if (sdulen)
hlen += L2CAP_SDULEN_SIZE;
if (chan->fcs == L2CAP_FCS_CRC16)
hlen += L2CAP_FCS_SIZE;
count = min_t(unsigned int, (conn->mtu - hlen), len);
skb = chan->ops->alloc_skb(chan, hlen, count,
msg->msg_flags & MSG_DONTWAIT);
if (IS_ERR(skb))
return skb;
/* Create L2CAP header */
lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
lh->cid = cpu_to_le16(chan->dcid);
lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
/* Control header is populated later */
if (test_bit(FLAG_EXT_CTRL, &chan->flags))
put_unaligned_le32(0, skb_put(skb, L2CAP_EXT_CTRL_SIZE));
else
put_unaligned_le16(0, skb_put(skb, L2CAP_ENH_CTRL_SIZE));
if (sdulen)
put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE));
err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb);
if (unlikely(err < 0)) {
kfree_skb(skb);
return ERR_PTR(err);
}
bt_cb(skb)->l2cap.fcs = chan->fcs;
bt_cb(skb)->l2cap.retries = 0;
return skb;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 211 | 70.57% | 2 | 15.38% |
mat martineau | mat martineau | 48 | 16.05% | 1 | 7.69% |
gustavo f. padovan | gustavo f. padovan | 27 | 9.03% | 6 | 46.15% |
szymon janc | szymon janc | 6 | 2.01% | 1 | 7.69% |
andrei emeltchenko | andrei emeltchenko | 5 | 1.67% | 2 | 15.38% |
marcel holtmann | marcel holtmann | 2 | 0.67% | 1 | 7.69% |
| Total | 299 | 100.00% | 13 | 100.00% |
static int l2cap_segment_sdu(struct l2cap_chan *chan,
struct sk_buff_head *seg_queue,
struct msghdr *msg, size_t len)
{
struct sk_buff *skb;
u16 sdu_len;
size_t pdu_len;
u8 sar;
BT_DBG("chan %p, msg %p, len %zu", chan, msg, len);
/* It is critical that ERTM PDUs fit in a single HCI fragment,
* so fragmented skbs are not used. The HCI layer's handling
* of fragmented skbs is not compatible with ERTM's queueing.
*/
/* PDU size is derived from the HCI MTU */
pdu_len = chan->conn->mtu;
/* Constrain PDU size for BR/EDR connections */
if (!chan->hs_hcon)
pdu_len = min_t(size_t, pdu_len, L2CAP_BREDR_MAX_PAYLOAD);
/* Adjust for largest possible L2CAP overhead. */
if (chan->fcs)
pdu_len -= L2CAP_FCS_SIZE;
pdu_len -= __ertm_hdr_size(chan);
/* Remote device may have requested smaller PDUs */
pdu_len = min_t(size_t, pdu_len, chan->remote_mps);
if (len <= pdu_len) {
sar = L2CAP_SAR_UNSEGMENTED;
sdu_len = 0;
pdu_len = len;
} else {
sar = L2CAP_SAR_START;
sdu_len = len;
}
while (len > 0) {
skb = l2cap_create_iframe_pdu(chan, msg, pdu_len, sdu_len);
if (IS_ERR(skb)) {
__skb_queue_purge(seg_queue);
return PTR_ERR(skb);
}
bt_cb(skb)->l2cap.sar = sar;
__skb_queue_tail(seg_queue, skb);
len -= pdu_len;
if (sdu_len)
sdu_len = 0;
if (len <= pdu_len) {
sar = L2CAP_SAR_END;
pdu_len = len;
} else {
sar = L2CAP_SAR_CONTINUE;
}
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 158 | 66.39% | 2 | 13.33% |
gustavo padovan | gustavo padovan | 32 | 13.45% | 4 | 26.67% |
marcel holtmann | marcel holtmann | 15 | 6.30% | 1 | 6.67% |
mat martineau | mat martineau | 10 | 4.20% | 1 | 6.67% |
gustavo f. padovan | gustavo f. padovan | 9 | 3.78% | 2 | 13.33% |
maxim krasnyansky | maxim krasnyansky | 6 | 2.52% | 1 | 6.67% |
andrei emeltchenko | andrei emeltchenko | 3 | 1.26% | 1 | 6.67% |
luiz augusto von dentz | luiz augusto von dentz | 3 | 1.26% | 1 | 6.67% |
maksim krasnyanskiy | maksim krasnyanskiy | 1 | 0.42% | 1 | 6.67% |
linus torvalds | linus torvalds | 1 | 0.42% | 1 | 6.67% |
| Total | 238 | 100.00% | 15 | 100.00% |
static struct sk_buff *l2cap_create_le_flowctl_pdu(struct l2cap_chan *chan,
struct msghdr *msg,
size_t len, u16 sdulen)
{
struct l2cap_conn *conn = chan->conn;
struct sk_buff *skb;
int err, count, hlen;
struct l2cap_hdr *lh;
BT_DBG("chan %p len %zu", chan, len);
if (!conn)
return ERR_PTR(-ENOTCONN);
hlen = L2CAP_HDR_SIZE;
if (sdulen)
hlen += L2CAP_SDULEN_SIZE;
count = min_t(unsigned int, (conn->mtu - hlen), len);
skb = chan->ops->alloc_skb(chan, hlen, count,
msg->msg_flags & MSG_DONTWAIT);
if (IS_ERR(skb))
return skb;
/* Create L2CAP header */
lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
lh->cid = cpu_to_le16(chan->dcid);
lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
if (sdulen)
put_unaligned_le16(sdulen, skb_put(skb, L2CAP_SDULEN_SIZE));
err = l2cap_skbuff_fromiovec(chan, msg, len, count, skb);
if (unlikely(err < 0)) {
kfree_skb(skb);
return ERR_PTR(err);
}
return skb;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 112 | 50.45% | 4 | 23.53% |
marcel holtmann | marcel holtmann | 56 | 25.23% | 5 | 29.41% |
johan hedberg | johan hedberg | 40 | 18.02% | 1 | 5.88% |
andrei emeltchenko | andrei emeltchenko | 7 | 3.15% | 2 | 11.76% |
gustavo f. padovan | gustavo f. padovan | 4 | 1.80% | 2 | 11.76% |
linus torvalds | linus torvalds | 1 | 0.45% | 1 | 5.88% |
luiz augusto von dentz | luiz augusto von dentz | 1 | 0.45% | 1 | 5.88% |
szymon janc | szymon janc | 1 | 0.45% | 1 | 5.88% |
| Total | 222 | 100.00% | 17 | 100.00% |
static int l2cap_segment_le_sdu(struct l2cap_chan *chan,
struct sk_buff_head *seg_queue,
struct msghdr *msg, size_t len)
{
struct sk_buff *skb;
size_t pdu_len;
u16 sdu_len;
BT_DBG("chan %p, msg %p, len %zu", chan, msg, len);
sdu_len = len;
pdu_len = chan->remote_mps - L2CAP_SDULEN_SIZE;
while (len > 0) {
if (len <= pdu_len)
pdu_len = len;
skb = l2cap_create_le_flowctl_pdu(chan, msg, pdu_len, sdu_len);
if (IS_ERR(skb)) {
__skb_queue_purge(seg_queue);
return PTR_ERR(skb);
}
__skb_queue_tail(seg_queue, skb);
len -= pdu_len;
if (sdu_len) {
sdu_len = 0;
pdu_len += L2CAP_SDULEN_SIZE;
}
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 73 | 53.28% | 2 | 25.00% |
gustavo padovan | gustavo padovan | 59 | 43.07% | 2 | 25.00% |
gustavo f. padovan | gustavo f. padovan | 2 | 1.46% | 1 | 12.50% |
andrei emeltchenko | andrei emeltchenko | 2 | 1.46% | 2 | 25.00% |
szymon janc | szymon janc | 1 | 0.73% | 1 | 12.50% |
| Total | 137 | 100.00% | 8 | 100.00% |
int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
{
struct sk_buff *skb;
int err;
struct sk_buff_head seg_queue;
if (!chan->conn)
return -ENOTCONN;
/* Connectionless channel */
if (chan->chan_type == L2CAP_CHAN_CONN_LESS) {
skb = l2cap_create_connless_pdu(chan, msg, len);
if (IS_ERR(skb))
return PTR_ERR(skb);
/* Channel lock is released before requesting new skb and then
* reacquired thus we need to recheck channel state.
*/
if (chan->state != BT_CONNECTED) {
kfree_skb(skb);
return -ENOTCONN;
}
l2cap_do_send(chan, skb);
return len;
}
switch (chan->mode) {
case L2CAP_MODE_LE_FLOWCTL:
/* Check outgoing MTU */
if (len > chan->omtu)
return -EMSGSIZE;
if (!chan->tx_credits)
return -EAGAIN;
__skb_queue_head_init(&seg_queue);
err = l2cap_segment_le_sdu(chan, &seg_queue, msg, len);
if (chan->state != BT_CONNECTED) {
__skb_queue_purge(&seg_queue);
err = -ENOTCONN;
}
if (err)
return err;
skb_queue_splice_tail_init(&seg_queue, &chan->tx_q);
while (chan->tx_credits && !skb_queue_empty(&chan->tx_q)) {
l2cap_do_send(chan, skb_dequeue(&chan->tx_q));
chan->tx_credits--;
}
if (!chan->tx_credits)
chan->ops->suspend(chan);
err = len;
break;
case L2CAP_MODE_BASIC:
/* Check outgoing MTU */
if (len > chan->omtu)
return -EMSGSIZE;
/* Create a basic PDU */
skb = l2cap_create_basic_pdu(chan, msg, len);
if (IS_ERR(skb))
return PTR_ERR(skb);
/* Channel lock is released before requesting new skb and then
* reacquired thus we need to recheck channel state.
*/
if (chan->state != BT_CONNECTED) {
kfree_skb(skb);
return -ENOTCONN;
}
l2cap_do_send(chan, skb);
err = len;
break;
case L2CAP_MODE_ERTM:
case L2CAP_MODE_STREAMING:
/* Check outgoing MTU */
if (len > chan->omtu) {
err = -EMSGSIZE;
break;
}
__skb_queue_head_init(&seg_queue);
/* Do segmentation before calling in to the state machine,
* since it's possible to block while waiting for memory
* allocation.
*/
err = l2cap_segment_sdu(chan, &seg_queue, msg, len);
/* The channel could have been closed while segmenting,
* check that it is still connected.
*/
if (chan->state != BT_CONNECTED) {
__skb_queue_purge(&seg_queue);
err = -ENOTCONN;
}
if (err)
break;
if (chan->mode == L2CAP_MODE_ERTM)
l2cap_tx(chan, NULL, &seg_queue, L2CAP_EV_DATA_REQUEST);
else
l2cap_streaming_send(chan, &seg_queue);
err = len;
/* If the skbs were not queued for sending, they'll still be in
* seg_queue and need to be purged.
*/
__skb_queue_purge(&seg_queue);
break;
default:
BT_DBG("bad state %1.1x", chan->mode);
err = -EBADFD;
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 244 | 53.16% | 1 | 4.55% |
gustavo padovan | gustavo padovan | 84 | 18.30% | 5 | 22.73% |
andrzej kaczmarek | andrzej kaczmarek | 40 | 8.71% | 1 | 4.55% |
marcel holtmann | marcel holtmann | 33 | 7.19% | 4 | 18.18% |
mat martineau | mat martineau | 31 | 6.75% | 3 | 13.64% |
gustavo f. padovan | gustavo f. padovan | 15 | 3.27% | 4 | 18.18% |
linus torvalds | linus torvalds | 9 | 1.96% | 1 | 4.55% |
andrei emeltchenko | andrei emeltchenko | 3 | 0.65% | 3 | 13.64% |
| Total | 459 | 100.00% | 22 | 100.00% |
EXPORT_SYMBOL_GPL(l2cap_chan_send);
static void l2cap_send_srej(struct l2cap_chan *chan, u16 txseq)
{
struct l2cap_ctrl control;
u16 seq;
BT_DBG("chan %p, txseq %u", chan, txseq);
memset(&control, 0, sizeof(control));
control.sframe = 1;
control.super = L2CAP_SUPER_SREJ;
for (seq = chan->expected_tx_seq; seq != txseq;
seq = __next_seq(chan, seq)) {
if (!l2cap_ertm_seq_in_queue(&chan->srej_q, seq)) {
control.reqseq = seq;
l2cap_send_sframe(chan, &control);
l2cap_seq_list_append(&chan->srej_list, seq);
}
}
chan->expected_tx_seq = __next_seq(chan, txseq);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 103 | 80.47% | 2 | 50.00% |
gustavo f. padovan | gustavo f. padovan | 24 | 18.75% | 1 | 25.00% |
mat martineau | mat martineau | 1 | 0.78% | 1 | 25.00% |
| Total | 128 | 100.00% | 4 | 100.00% |
static void l2cap_send_srej_tail(struct l2cap_chan *chan)
{
struct l2cap_ctrl control;
BT_DBG("chan %p", chan);
if (chan->srej_list.tail == L2CAP_SEQ_LIST_CLEAR)
return;
memset(&control, 0, sizeof(control));
control.sframe = 1;
control.super = L2CAP_SUPER_SREJ;
control.reqseq = chan->srej_list.tail;
l2cap_send_sframe(chan, &control);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 76 | 100.00% | 2 | 100.00% |
| Total | 76 | 100.00% | 2 | 100.00% |
static void l2cap_send_srej_list(struct l2cap_chan *chan, u16 txseq)
{
struct l2cap_ctrl control;
u16 initial_head;
u16 seq;
BT_DBG("chan %p, txseq %u", chan, txseq);
memset(&control, 0, sizeof(control));
control.sframe = 1;
control.super = L2CAP_SUPER_SREJ;
/* Capture initial list head to allow only one pass through the list. */
initial_head = chan->srej_list.head;
do {
seq = l2cap_seq_list_pop(&chan->srej_list);
if (seq == txseq || seq == L2CAP_SEQ_LIST_CLEAR)
break;
control.reqseq = seq;
l2cap_send_sframe(chan, &control);
l2cap_seq_list_append(&chan->srej_list, seq);
} while (chan->srej_list.head != initial_head);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 126 | 100.00% | 2 | 100.00% |
| Total | 126 | 100.00% | 2 | 100.00% |
static void l2cap_process_reqseq(struct l2cap_chan *chan, u16 reqseq)
{
struct sk_buff *acked_skb;
u16 ackseq;
BT_DBG("chan %p, reqseq %u", chan, reqseq);
if (chan->unacked_frames == 0 || reqseq == chan->expected_ack_seq)
return;
BT_DBG("expected_ack_seq %u, unacked_frames %u",
chan->expected_ack_seq, chan->unacked_frames);
for (ackseq = chan->expected_ack_seq; ackseq != reqseq;
ackseq = __next_seq(chan, ackseq)) {
acked_skb = l2cap_ertm_seq_in_queue(&chan->tx_q, ackseq);
if (acked_skb) {
skb_unlink(acked_skb, &chan->tx_q);
kfree_skb(acked_skb);
chan->unacked_frames--;
}
}
chan->expected_ack_seq = reqseq;
if (chan->unacked_frames == 0)
__clear_retrans_timer(chan);
BT_DBG("unacked_frames %u", chan->unacked_frames);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 137 | 92.57% | 2 | 66.67% |
gustavo f. padovan | gustavo f. padovan | 11 | 7.43% | 1 | 33.33% |
| Total | 148 | 100.00% | 3 | 100.00% |
static void l2cap_abort_rx_srej_sent(struct l2cap_chan *chan)
{
BT_DBG("chan %p", chan);
chan->expected_tx_seq = chan->buffer_seq;
l2cap_seq_list_clear(&chan->srej_list);
skb_queue_purge(&chan->srej_q);
chan->rx_state = L2CAP_RX_STATE_RECV;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 34 | 70.83% | 1 | 50.00% |
gustavo f. padovan | gustavo f. padovan | 14 | 29.17% | 1 | 50.00% |
| Total | 48 | 100.00% | 2 | 100.00% |
static void l2cap_tx_state_xmit(struct l2cap_chan *chan,
struct l2cap_ctrl *control,
struct sk_buff_head *skbs, u8 event)
{
BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs,
event);
switch (event) {
case L2CAP_EV_DATA_REQUEST:
if (chan->tx_send_head == NULL)
chan->tx_send_head = skb_peek(skbs);
skb_queue_splice_tail_init(skbs, &chan->tx_q);
l2cap_ertm_send(chan);
break;
case L2CAP_EV_LOCAL_BUSY_DETECTED:
BT_DBG("Enter LOCAL_BUSY");
set_bit(CONN_LOCAL_BUSY, &chan->conn_state);
if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) {
/* The SREJ_SENT state must be aborted if we are to
* enter the LOCAL_BUSY state.
*/
l2cap_abort_rx_srej_sent(chan);
}
l2cap_send_ack(chan);
break;
case L2CAP_EV_LOCAL_BUSY_CLEAR:
BT_DBG("Exit LOCAL_BUSY");
clear_bit(CONN_LOCAL_BUSY, &chan->conn_state);
if (test_bit(CONN_RNR_SENT, &chan->conn_state)) {
struct l2cap_ctrl local_control;
memset(&local_control, 0, sizeof(local_control));
local_control.sframe = 1;
local_control.super = L2CAP_SUPER_RR;
local_control.poll = 1;
local_control.reqseq = chan->buffer_seq;
l2cap_send_sframe(chan, &local_control);
chan->retry_count = 1;
__set_monitor_timer(chan);
chan->tx_state = L2CAP_TX_STATE_WAIT_F;
}
break;
case L2CAP_EV_RECV_REQSEQ_AND_FBIT:
l2cap_process_reqseq(chan, control->reqseq);
break;
case L2CAP_EV_EXPLICIT_POLL:
l2cap_send_rr_or_rnr(chan, 1);
chan->retry_count = 1;
__set_monitor_timer(chan);
__clear_ack_timer(chan);
chan->tx_state = L2CAP_TX_STATE_WAIT_F;
break;
case L2CAP_EV_RETRANS_TO:
l2cap_send_rr_or_rnr(chan, 1);
chan->retry_count = 1;
__set_monitor_timer(chan);
chan->tx_state = L2CAP_TX_STATE_WAIT_F;
break;
case L2CAP_EV_RECV_FBIT:
/* Nothing to process */
break;
default:
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 187 | 62.13% | 1 | 14.29% |
mat martineau | mat martineau | 93 | 30.90% | 5 | 71.43% |
gustavo f. padovan | gustavo f. padovan | 21 | 6.98% | 1 | 14.29% |
| Total | 301 | 100.00% | 7 | 100.00% |
static void l2cap_tx_state_wait_f(struct l2cap_chan *chan,
struct l2cap_ctrl *control,
struct sk_buff_head *skbs, u8 event)
{
BT_DBG("chan %p, control %p, skbs %p, event %d", chan, control, skbs,
event);
switch (event) {
case L2CAP_EV_DATA_REQUEST:
if (chan->tx_send_head == NULL)
chan->tx_send_head = skb_peek(skbs);
/* Queue data, but don't send. */
skb_queue_splice_tail_init(skbs, &chan->tx_q);
break;
case L2CAP_EV_LOCAL_BUSY_DETECTED:
BT_DBG("Enter LOCAL_BUSY");
set_bit(CONN_LOCAL_BUSY, &chan->conn_state);
if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) {
/* The SREJ_SENT state must be aborted if we are to
* enter the LOCAL_BUSY state.
*/
l2cap_abort_rx_srej_sent(chan);
}
l2cap_send_ack(chan);
break;
case L2CAP_EV_LOCAL_BUSY_CLEAR:
BT_DBG("Exit LOCAL_BUSY");
clear_bit(CONN_LOCAL_BUSY, &chan->conn_state);
if (test_bit(CONN_RNR_SENT, &chan->conn_state)) {
struct l2cap_ctrl local_control;
memset(&local_control, 0, sizeof(local_control));
local_control.sframe = 1;
local_control.super = L2CAP_SUPER_RR;
local_control.poll = 1;
local_control.reqseq = chan->buffer_seq;
l2cap_send_sframe(chan, &local_control);
chan->retry_count = 1;
__set_monitor_timer(chan);
chan->tx_state = L2CAP_TX_STATE_WAIT_F;
}
break;
case L2CAP_EV_RECV_REQSEQ_AND_FBIT:
l2cap_process_reqseq(chan, control->reqseq);
/* Fall through */
case L2CAP_EV_RECV_FBIT:
if (control && control->final) {
__clear_monitor_timer(chan);
if (chan->unacked_frames > 0)
__set_retrans_timer(chan);
chan->retry_count = 0;
chan->tx_state = L2CAP_TX_STATE_XMIT;
BT_DBG("recv fbit tx_state 0x2.2%x", chan->tx_state);
}
break;
case L2CAP_EV_EXPLICIT_POLL:
/* Ignore */
break;
case L2CAP_EV_MONITOR_TO:
if (chan->max_tx == 0 || chan->retry_count < chan->max_tx) {
l2cap_send_rr_or_rnr(chan, 1);
__set_monitor_timer(chan);
chan->retry_count++;
} else {
l2cap_send_disconn_req(chan, ECONNABORTED);
}
break;
default:
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 217 | 64.20% | 1 | 25.00% |
mat martineau | mat martineau | 121 | 35.80% | 3 | 75.00% |
| Total | 338 | 100.00% | 4 | 100.00% |
static void l2cap_tx(struct l2cap_chan *chan, struct l2cap_ctrl *control,
struct sk_buff_head *skbs, u8 event)
{
BT_DBG("chan %p, control %p, skbs %p, event %d, state %d",
chan, control, skbs, event, chan->tx_state);
switch (chan->tx_state) {
case L2CAP_TX_STATE_XMIT:
l2cap_tx_state_xmit(chan, control, skbs, event);
break;
case L2CAP_TX_STATE_WAIT_F:
l2cap_tx_state_wait_f(chan, control, skbs, event);
break;
default:
/* Ignore event */
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 51 | 62.20% | 1 | 33.33% |
johan hedberg | johan hedberg | 30 | 36.59% | 1 | 33.33% |
gustavo padovan | gustavo padovan | 1 | 1.22% | 1 | 33.33% |
| Total | 82 | 100.00% | 3 | 100.00% |
static void l2cap_pass_to_tx(struct l2cap_chan *chan,
struct l2cap_ctrl *control)
{
BT_DBG("chan %p, control %p", chan, control);
l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_REQSEQ_AND_FBIT);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 26 | 72.22% | 1 | 50.00% |
mat martineau | mat martineau | 10 | 27.78% | 1 | 50.00% |
| Total | 36 | 100.00% | 2 | 100.00% |
static void l2cap_pass_to_tx_fbit(struct l2cap_chan *chan,
struct l2cap_ctrl *control)
{
BT_DBG("chan %p, control %p", chan, control);
l2cap_tx(chan, control, NULL, L2CAP_EV_RECV_FBIT);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 24 | 66.67% | 1 | 50.00% |
mat martineau | mat martineau | 12 | 33.33% | 1 | 50.00% |
| Total | 36 | 100.00% | 2 | 100.00% |
/* Copy frame to all raw sockets on that connection */
static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct sk_buff *nskb;
struct l2cap_chan *chan;
BT_DBG("conn %p", conn);
mutex_lock(&conn->chan_lock);
list_for_each_entry(chan, &conn->chan_l, list) {
if (chan->chan_type != L2CAP_CHAN_RAW)
continue;
/* Don't send frame to the channel it came from */
if (bt_cb(skb)->l2cap.chan == chan)
continue;
nskb = skb_clone(skb, GFP_KERNEL);
if (!nskb)
continue;
if (chan->ops->recv(chan, nskb))
kfree_skb(nskb);
}
mutex_unlock(&conn->chan_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 84 | 72.41% | 2 | 66.67% |
mat martineau | mat martineau | 32 | 27.59% | 1 | 33.33% |
| Total | 116 | 100.00% | 3 | 100.00% |
/* ---- L2CAP signalling commands ---- */
static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn, u8 code,
u8 ident, u16 dlen, void *data)
{
struct sk_buff *skb, **frag;
struct l2cap_cmd_hdr *cmd;
struct l2cap_hdr *lh;
int len, count;
BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %u",
conn, code, ident, dlen);
if (conn->mtu < L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE)
return NULL;
len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen;
count = min_t(unsigned int, conn->mtu, len);
skb = bt_skb_alloc(count, GFP_KERNEL);
if (!skb)
return NULL;
lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen);
if (conn->hcon->type == LE_LINK)
lh->cid = cpu_to_le16(L2CAP_CID_LE_SIGNALING);
else
lh->cid = cpu_to_le16(L2CAP_CID_SIGNALING);
cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE);
cmd->code = code;
cmd->ident = ident;
cmd->len = cpu_to_le16(dlen);
if (dlen) {
count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE;
memcpy(skb_put(skb, count), data, count);
data += count;
}
len -= skb->len;
/* Continuation fragments (no L2CAP header) */
frag = &skb_shinfo(skb)->frag_list;
while (len) {
count = min_t(unsigned int, conn->mtu, len);
*frag = bt_skb_alloc(count, GFP_KERNEL);
if (!*frag)
goto fail;
memcpy(skb_put(*frag, count), data, count);
len -= count;
data += count;
frag = &(*frag)->next;
}
return skb;
fail:
kfree_skb(skb);
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 233 | 70.61% | 1 | 25.00% |
mat martineau | mat martineau | 95 | 28.79% | 2 | 50.00% |
joe perches | joe perches | 2 | 0.61% | 1 | 25.00% |
| Total | 330 | 100.00% | 4 | 100.00% |
static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen,
unsigned long *val)
{
struct l2cap_conf_opt *opt = *ptr;
int len;
len = L2CAP_CONF_OPT_SIZE + opt->len;
*ptr += len;
*type = opt->type;
*olen = opt->len;
switch (opt->len) {
case 1:
*val = *((u8 *) opt->val);
break;
case 2:
*val = get_unaligned_le16(opt->val);
break;
case 4:
*val = get_unaligned_le32(opt->val);
break;
default:
*val = (unsigned long) opt->val;
break;
}
BT_DBG("type 0x%2.2x len %u val 0x%lx", *type, opt->len, *val);
return len;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 109 | 73.65% | 1 | 33.33% |
mat martineau | mat martineau | 39 | 26.35% | 2 | 66.67% |
| Total | 148 | 100.00% | 3 | 100.00% |
static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val)
{
struct l2cap_conf_opt *opt = *ptr;
BT_DBG("type 0x%2.2x len %u val 0x%lx", type, len, val);
opt->type = type;
opt->len = len;
switch (len) {
case 1:
*((u8 *) opt->val) = val;
break;
case 2:
put_unaligned_le16(val, opt->val);
break;
case 4:
put_unaligned_le32(val, opt->val);
break;
default:
memcpy(opt->val, (void *) val, len);
break;
}
*ptr += L2CAP_CONF_OPT_SIZE + len;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 105 | 84.00% | 1 | 50.00% |
mat martineau | mat martineau | 20 | 16.00% | 1 | 50.00% |
| Total | 125 | 100.00% | 2 | 100.00% |
static void l2cap_add_opt_efs(void **ptr, struct l2cap_chan *chan)
{
struct l2cap_conf_efs efs;
switch (chan->mode) {
case L2CAP_MODE_ERTM:
efs.id = chan->local_id;
efs.stype = chan->local_stype;
efs.msdu = cpu_to_le16(chan->local_msdu);
efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime);
efs.acc_lat = cpu_to_le32(L2CAP_DEFAULT_ACC_LAT);
efs.flush_to = cpu_to_le32(L2CAP_EFS_DEFAULT_FLUSH_TO);
break;
case L2CAP_MODE_STREAMING:
efs.id = 1;
efs.stype = L2CAP_SERV_BESTEFFORT;
efs.msdu = cpu_to_le16(chan->local_msdu);
efs.sdu_itime = cpu_to_le32(chan->local_sdu_itime);
efs.acc_lat = 0;
efs.flush_to = 0;
break;
default:
return;
}
l2cap_add_conf_opt(ptr, L2CAP_CONF_EFS, sizeof(efs),
(unsigned long) &efs);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 119 | 74.84% | 1 | 10.00% |
gustavo padovan | gustavo padovan | 28 | 17.61% | 3 | 30.00% |
andrei emeltchenko | andrei emeltchenko | 6 | 3.77% | 1 | 10.00% |
gustavo f. padovan | gustavo f. padovan | 4 | 2.52% | 4 | 40.00% |
joe perches | joe perches | 2 | 1.26% | 1 | 10.00% |
| Total | 159 | 100.00% | 10 | 100.00% |
static void l2cap_ack_timeout(struct work_struct *work)
{
struct l2cap_chan *chan = container_of(work, struct l2cap_chan,
ack_timer.work);
u16 frames_to_ack;
BT_DBG("chan %p", chan);
l2cap_chan_lock(chan);
frames_to_ack = __seq_offset(chan, chan->buffer_seq,
chan->last_acked_seq);
if (frames_to_ack)
l2cap_send_rr_or_rnr(chan, 0);
l2cap_chan_unlock(chan);
l2cap_chan_put(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 43 | 54.43% | 1 | 14.29% |
linus torvalds | linus torvalds | 19 | 24.05% | 1 | 14.29% |
gustavo padovan | gustavo padovan | 12 | 15.19% | 2 | 28.57% |
claudio takahasi | claudio takahasi | 3 | 3.80% | 1 | 14.29% |
maksim krasnyanskiy | maksim krasnyanskiy | 1 | 1.27% | 1 | 14.29% |
marcel holtmann | marcel holtmann | 1 | 1.27% | 1 | 14.29% |
| Total | 79 | 100.00% | 7 | 100.00% |
int l2cap_ertm_init(struct l2cap_chan *chan)
{
int err;
chan->next_tx_seq = 0;
chan->expected_tx_seq = 0;
chan->expected_ack_seq = 0;
chan->unacked_frames = 0;
chan->buffer_seq = 0;
chan->frames_sent = 0;
chan->last_acked_seq = 0;
chan->sdu = NULL;
chan->sdu_last_frag = NULL;
chan->sdu_len = 0;
skb_queue_head_init(&chan->tx_q);
chan->local_amp_id = AMP_ID_BREDR;
chan->move_id = AMP_ID_BREDR;
chan->move_state = L2CAP_MOVE_STABLE;
chan->move_role = L2CAP_MOVE_ROLE_NONE;
if (chan->mode != L2CAP_MODE_ERTM)
return 0;
chan->rx_state = L2CAP_RX_STATE_RECV;
chan->tx_state = L2CAP_TX_STATE_XMIT;
INIT_DELAYED_WORK(&chan->retrans_timer, l2cap_retrans_timeout);
INIT_DELAYED_WORK(&chan->monitor_timer, l2cap_monitor_timeout);
INIT_DELAYED_WORK(&chan->ack_timer, l2cap_ack_timeout);
skb_queue_head_init(&chan->srej_q);
err = l2cap_seq_list_init(&chan->srej_list, chan->tx_win);
if (err < 0)
return err;
err = l2cap_seq_list_init(&chan->retrans_list, chan->remote_tx_win);
if (err < 0)
l2cap_seq_list_free(&chan->srej_list);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 78 | 35.45% | 4 | 28.57% |
johan hedberg | johan hedberg | 76 | 34.55% | 1 | 7.14% |
gustavo padovan | gustavo padovan | 36 | 16.36% | 4 | 28.57% |
gustavo f. padovan | gustavo f. padovan | 19 | 8.64% | 4 | 28.57% |
marcel holtmann | marcel holtmann | 11 | 5.00% | 1 | 7.14% |
| Total | 220 | 100.00% | 14 | 100.00% |
static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask)
{
switch (mode) {
case L2CAP_MODE_STREAMING:
case L2CAP_MODE_ERTM:
if (l2cap_mode_supported(mode, remote_feat_mask))
return mode;
/* fall through */
default:
return L2CAP_MODE_BASIC;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 42 | 100.00% | 1 | 100.00% |
| Total | 42 | 100.00% | 1 | 100.00% |
static inline bool __l2cap_ews_supported(struct l2cap_conn *conn)
{
return ((conn->local_fixed_chan & L2CAP_FC_A2MP) &&
(conn->feat_mask & L2CAP_FEAT_EXT_WINDOW));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 12 | 38.71% | 1 | 20.00% |
johan hedberg | johan hedberg | 9 | 29.03% | 1 | 20.00% |
gustavo padovan | gustavo padovan | 5 | 16.13% | 1 | 20.00% |
marcel holtmann | marcel holtmann | 4 | 12.90% | 1 | 20.00% |
gustavo f. padovan | gustavo f. padovan | 1 | 3.23% | 1 | 20.00% |
| Total | 31 | 100.00% | 5 | 100.00% |
static inline bool __l2cap_efs_supported(struct l2cap_conn *conn)
{
return ((conn->local_fixed_chan & L2CAP_FC_A2MP) &&
(conn->feat_mask & L2CAP_FEAT_EXT_FLOW));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 14 | 45.16% | 1 | 20.00% |
johan hedberg | johan hedberg | 9 | 29.03% | 1 | 20.00% |
marcel holtmann | marcel holtmann | 4 | 12.90% | 1 | 20.00% |
gustavo padovan | gustavo padovan | 3 | 9.68% | 1 | 20.00% |
gustavo f. padovan | gustavo f. padovan | 1 | 3.23% | 1 | 20.00% |
| Total | 31 | 100.00% | 5 | 100.00% |
static void __l2cap_set_ertm_timeouts(struct l2cap_chan *chan,
struct l2cap_conf_rfc *rfc)
{
if (chan->local_amp_id != AMP_ID_BREDR && chan->hs_hcon) {
u64 ertm_to = chan->hs_hcon->hdev->amp_be_flush_to;
/* Class 1 devices have must have ERTM timeouts
* exceeding the Link Supervision Timeout. The
* default Link Supervision Timeout for AMP
* controllers is 10 seconds.
*
* Class 1 devices use 0xffffffff for their
* best-effort flush timeout, so the clamping logic
* will result in a timeout that meets the above
* requirement. ERTM timeouts are 16-bit values, so
* the maximum timeout is 65.535 seconds.
*/
/* Convert timeout to milliseconds and round */
ertm_to = DIV_ROUND_UP_ULL(ertm_to, 1000);
/* This is the recommended formula for class 2 devices
* that start ERTM timers when packets are sent to the
* controller.
*/
ertm_to = 3 * ertm_to + 500;
if (ertm_to > 0xffff)
ertm_to = 0xffff;
rfc->retrans_timeout = cpu_to_le16((u16) ertm_to);
rfc->monitor_timeout = rfc->retrans_timeout;
} else {
rfc->retrans_timeout = cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO);
rfc->monitor_timeout = cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 108 | 96.43% | 1 | 33.33% |
joe perches | joe perches | 2 | 1.79% | 1 | 33.33% |
marcel holtmann | marcel holtmann | 2 | 1.79% | 1 | 33.33% |
| Total | 112 | 100.00% | 3 | 100.00% |
static inline void l2cap_txwin_setup(struct l2cap_chan *chan)
{
if (chan->tx_win > L2CAP_DEFAULT_TX_WINDOW &&
__l2cap_ews_supported(chan->conn)) {
/* use extended control field */
set_bit(FLAG_EXT_CTRL, &chan->flags);
chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW;
} else {
chan->tx_win = min_t(u16, chan->tx_win,
L2CAP_DEFAULT_TX_WINDOW);
chan->tx_win_max = L2CAP_DEFAULT_TX_WINDOW;
}
chan->ack_win = chan->tx_win;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 68 | 87.18% | 2 | 50.00% |
mat martineau | mat martineau | 8 | 10.26% | 1 | 25.00% |
marcel holtmann | marcel holtmann | 2 | 2.56% | 1 | 25.00% |
| Total | 78 | 100.00% | 4 | 100.00% |
static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data)
{
struct l2cap_conf_req *req = data;
struct l2cap_conf_rfc rfc = { .mode = chan->mode };
void *ptr = req->data;
u16 size;
BT_DBG("chan %p", chan);
if (chan->num_conf_req || chan->num_conf_rsp)
goto done;
switch (chan->mode) {
case L2CAP_MODE_STREAMING:
case L2CAP_MODE_ERTM:
if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state))
break;
if (__l2cap_efs_supported(chan->conn))
set_bit(FLAG_EFS_ENABLE, &chan->flags);
/* fall through */
default:
chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask);
break;
}
done:
if (chan->imtu != L2CAP_DEFAULT_MTU)
l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);
switch (chan->mode) {
case L2CAP_MODE_BASIC:
if (disable_ertm)
break;
if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) &&
!(chan->conn->feat_mask & L2CAP_FEAT_STREAMING))
break;
rfc.mode = L2CAP_MODE_BASIC;
rfc.txwin_size = 0;
rfc.max_transmit = 0;
rfc.retrans_timeout = 0;
rfc.monitor_timeout = 0;
rfc.max_pdu_size = 0;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
(unsigned long) &rfc);
break;
case L2CAP_MODE_ERTM:
rfc.mode = L2CAP_MODE_ERTM;
rfc.max_transmit = chan->max_tx;
__l2cap_set_ertm_timeouts(chan, &rfc);
size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu -
L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE -
L2CAP_FCS_SIZE);
rfc.max_pdu_size = cpu_to_le16(size);
l2cap_txwin_setup(chan);
rfc.txwin_size = min_t(u16, chan->tx_win,
L2CAP_DEFAULT_TX_WINDOW);
l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
(unsigned long) &rfc);
if (test_bit(FLAG_EFS_ENABLE, &chan->flags))
l2cap_add_opt_efs(&ptr, chan);
if (test_bit(FLAG_EXT_CTRL, &chan->flags))
l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2,
chan->tx_win);
if (chan->conn->feat_mask & L2CAP_FEAT_FCS)
if (chan->fcs == L2CAP_FCS_NONE ||
test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) {
chan->fcs = L2CAP_FCS_NONE;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1,
chan->fcs);
}
break;
case L2CAP_MODE_STREAMING:
l2cap_txwin_setup(chan);
rfc.mode = L2CAP_MODE_STREAMING;
rfc.txwin_size = 0;
rfc.max_transmit = 0;
rfc.retrans_timeout = 0;
rfc.monitor_timeout = 0;
size = min_t(u16, L2CAP_DEFAULT_MAX_PDU_SIZE, chan->conn->mtu -
L2CAP_EXT_HDR_SIZE - L2CAP_SDULEN_SIZE -
L2CAP_FCS_SIZE);
rfc.max_pdu_size = cpu_to_le16(size);
l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
(unsigned long) &rfc);
if (test_bit(FLAG_EFS_ENABLE, &chan->flags))
l2cap_add_opt_efs(&ptr, chan);
if (chan->conn->feat_mask & L2CAP_FEAT_FCS)
if (chan->fcs == L2CAP_FCS_NONE ||
test_bit(CONF_RECV_NO_FCS, &chan->conf_state)) {
chan->fcs = L2CAP_FCS_NONE;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1,
chan->fcs);
}
break;
}
req->dcid = cpu_to_le16(chan->dcid);
req->flags = cpu_to_le16(0);
return ptr - data;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 270 | 42.86% | 1 | 3.45% |
gustavo f. padovan | gustavo f. padovan | 214 | 33.97% | 18 | 62.07% |
andrei emeltchenko | andrei emeltchenko | 127 | 20.16% | 5 | 17.24% |
mat martineau | mat martineau | 11 | 1.75% | 2 | 6.90% |
marcel holtmann | marcel holtmann | 7 | 1.11% | 2 | 6.90% |
joe perches | joe perches | 1 | 0.16% | 1 | 3.45% |
| Total | 630 | 100.00% | 29 | 100.00% |
static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data)
{
struct l2cap_conf_rsp *rsp = data;
void *ptr = rsp->data;
void *req = chan->conf_req;
int len = chan->conf_len;
int type, hint, olen;
unsigned long val;
struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC };
struct l2cap_conf_efs efs;
u8 remote_efs = 0;
u16 mtu = L2CAP_DEFAULT_MTU;
u16 result = L2CAP_CONF_SUCCESS;
u16 size;
BT_DBG("chan %p", chan);
while (len >= L2CAP_CONF_OPT_SIZE) {
len -= l2cap_get_conf_opt(&req, &type, &olen, &val);
hint = type & L2CAP_CONF_HINT;
type &= L2CAP_CONF_MASK;
switch (type) {
case L2CAP_CONF_MTU:
mtu = val;
break;
case L2CAP_CONF_FLUSH_TO:
chan->flush_to = val;
break;
case L2CAP_CONF_QOS:
break;
case L2CAP_CONF_RFC:
if (olen == sizeof(rfc))
memcpy(&rfc, (void *) val, olen);
break;
case L2CAP_CONF_FCS:
if (val == L2CAP_FCS_NONE)
set_bit(CONF_RECV_NO_FCS, &chan->conf_state);
break;
case L2CAP_CONF_EFS:
remote_efs = 1;
if (olen == sizeof(efs))
memcpy(&efs, (void *) val, olen);
break;
case L2CAP_CONF_EWS:
if (!(chan->conn->local_fixed_chan & L2CAP_FC_A2MP))
return -ECONNREFUSED;
set_bit(FLAG_EXT_CTRL, &chan->flags);
set_bit(CONF_EWS_RECV, &chan->conf_state);
chan->tx_win_max = L2CAP_DEFAULT_EXT_WINDOW;
chan->remote_tx_win = val;
break;
default:
if (hint)
break;
result = L2CAP_CONF_UNKNOWN;
*((u8 *) ptr++) = type;
break;
}
}
if (chan->num_conf_rsp || chan->num_conf_req > 1)
goto done;
switch (chan->mode) {
case L2CAP_MODE_STREAMING:
case L2CAP_MODE_ERTM:
if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) {
chan->mode = l2cap_select_mode(rfc.mode,
chan->conn->feat_mask);
break;
}
if (remote_efs) {
if (__l2cap_efs_supported(chan->conn))
set_bit(FLAG_EFS_ENABLE, &chan->flags);
else
return -ECONNREFUSED;
}
if (chan->mode != rfc.mode)
return -ECONNREFUSED;
break;
}
done:
if (chan->mode != rfc.mode) {
result = L2CAP_CONF_UNACCEPT;
rfc.mode = chan->mode;
if (chan->num_conf_rsp == 1)
return -ECONNREFUSED;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
(unsigned long) &rfc);
}
if (result == L2CAP_CONF_SUCCESS) {
/* Configure output options and let the other side know
* which ones we don't like. */
if (mtu < L2CAP_DEFAULT_MIN_MTU)
result = L2CAP_CONF_UNACCEPT;
else {
chan->omtu = mtu;
set_bit(CONF_MTU_DONE, &chan->conf_state);
}
l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu);
if (remote_efs) {
if (chan->local_stype != L2CAP_SERV_NOTRAFIC &&
efs.stype != L2CAP_SERV_NOTRAFIC &&
efs.stype != chan->local_stype) {
result = L2CAP_CONF_UNACCEPT;
if (chan->num_conf_req >= 1)
return -ECONNREFUSED;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS,
sizeof(efs),
(unsigned long) &efs);
} else {
/* Send PENDING Conf Rsp */
result = L2CAP_CONF_PENDING;
set_bit(CONF_LOC_CONF_PEND, &chan->conf_state);
}
}
switch (rfc.mode) {
case L2CAP_MODE_BASIC:
chan->fcs = L2CAP_FCS_NONE;
set_bit(CONF_MODE_DONE, &chan->conf_state);
break;
case L2CAP_MODE_ERTM:
if (!test_bit(CONF_EWS_RECV, &chan->conf_state))
chan->remote_tx_win = rfc.txwin_size;
else
rfc.txwin_size = L2CAP_DEFAULT_TX_WINDOW;
chan->remote_max_tx = rfc.max_transmit;
size = min_t(u16, le16_to_cpu(rfc.max_pdu_size),
chan->conn->mtu - L2CAP_EXT_HDR_SIZE -
L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE);
rfc.max_pdu_size = cpu_to_le16(size);
chan->remote_mps = size;
__l2cap_set_ertm_timeouts(chan, &rfc);
set_bit(CONF_MODE_DONE, &chan->conf_state);
l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
sizeof(rfc), (unsigned long) &rfc);
if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) {
chan->remote_id = efs.id;
chan->remote_stype = efs.stype;
chan->remote_msdu = le16_to_cpu(efs.msdu);
chan->remote_flush_to =
le32_to_cpu(efs.flush_to);
chan->remote_acc_lat =
le32_to_cpu(efs.acc_lat);
chan->remote_sdu_itime =
le32_to_cpu(efs.sdu_itime);
l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS,
sizeof(efs),
(unsigned long) &efs);
}
break;
case L2CAP_MODE_STREAMING:
size = min_t(u16, le16_to_cpu(rfc.max_pdu_size),
chan->conn->mtu - L2CAP_EXT_HDR_SIZE -
L2CAP_SDULEN_SIZE - L2CAP_FCS_SIZE);
rfc.max_pdu_size = cpu_to_le16(size);
chan->remote_mps = size;
set_bit(CONF_MODE_DONE, &chan->conf_state);
l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
(unsigned long) &rfc);
break;
default:
result = L2CAP_CONF_UNACCEPT;
memset(&rfc, 0, sizeof(rfc));
rfc.mode = chan->mode;
}
if (result == L2CAP_CONF_SUCCESS)
set_bit(CONF_OUTPUT_DONE, &chan->conf_state);
}
rsp->scid = cpu_to_le16(chan->dcid);
rsp->result = cpu_to_le16(result);
rsp->flags = cpu_to_le16(0);
return ptr - data;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 506 | 50.30% | 2 | 7.14% |
andrei emeltchenko | andrei emeltchenko | 328 | 32.60% | 7 | 25.00% |
gustavo f. padovan | gustavo f. padovan | 149 | 14.81% | 14 | 50.00% |
mat martineau | mat martineau | 11 | 1.09% | 2 | 7.14% |
marcel holtmann | marcel holtmann | 6 | 0.60% | 1 | 3.57% |
johan hedberg | johan hedberg | 5 | 0.50% | 1 | 3.57% |
joe perches | joe perches | 1 | 0.10% | 1 | 3.57% |
| Total | 1006 | 100.00% | 28 | 100.00% |
static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len,
void *data, u16 *result)
{
struct l2cap_conf_req *req = data;
void *ptr = req->data;
int type, olen;
unsigned long val;
struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC };
struct l2cap_conf_efs efs;
BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data);
while (len >= L2CAP_CONF_OPT_SIZE) {
len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
switch (type) {
case L2CAP_CONF_MTU:
if (val < L2CAP_DEFAULT_MIN_MTU) {
*result = L2CAP_CONF_UNACCEPT;
chan->imtu = L2CAP_DEFAULT_MIN_MTU;
} else
chan->imtu = val;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);
break;
case L2CAP_CONF_FLUSH_TO:
chan->flush_to = val;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO,
2, chan->flush_to);
break;
case L2CAP_CONF_RFC:
if (olen == sizeof(rfc))
memcpy(&rfc, (void *)val, olen);
if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) &&
rfc.mode != chan->mode)
return -ECONNREFUSED;
chan->fcs = 0;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
sizeof(rfc), (unsigned long) &rfc);
break;
case L2CAP_CONF_EWS:
chan->ack_win = min_t(u16, val, chan->ack_win);
l2cap_add_conf_opt(&ptr, L2CAP_CONF_EWS, 2,
chan->tx_win);
break;
case L2CAP_CONF_EFS:
if (olen == sizeof(efs))
memcpy(&efs, (void *)val, olen);
if (chan->local_stype != L2CAP_SERV_NOTRAFIC &&
efs.stype != L2CAP_SERV_NOTRAFIC &&
efs.stype != chan->local_stype)
return -ECONNREFUSED;
l2cap_add_conf_opt(&ptr, L2CAP_CONF_EFS, sizeof(efs),
(unsigned long) &efs);
break;
case L2CAP_CONF_FCS:
if (*result == L2CAP_CONF_PENDING)
if (val == L2CAP_FCS_NONE)
set_bit(CONF_RECV_NO_FCS,
&chan->conf_state);
break;
}
}
if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode)
return -ECONNREFUSED;
chan->mode = rfc.mode;
if (*result == L2CAP_CONF_SUCCESS || *result == L2CAP_CONF_PENDING) {
switch (rfc.mode) {
case L2CAP_MODE_ERTM:
chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
chan->mps = le16_to_cpu(rfc.max_pdu_size);
if (!test_bit(FLAG_EXT_CTRL, &chan->flags))
chan->ack_win = min_t(u16, chan->ack_win,
rfc.txwin_size);
if (test_bit(FLAG_EFS_ENABLE, &chan->flags)) {
chan->local_msdu = le16_to_cpu(efs.msdu);
chan->local_sdu_itime =
le32_to_cpu(efs.sdu_itime);
chan->local_acc_lat = le32_to_cpu(efs.acc_lat);
chan->local_flush_to =
le32_to_cpu(efs.flush_to);
}
break;
case L2CAP_MODE_STREAMING:
chan->mps = le16_to_cpu(rfc.max_pdu_size);
}
}
req->dcid = cpu_to_le16(chan->dcid);
req->flags = cpu_to_le16(0);
return ptr - data;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 300 | 49.92% | 2 | 10.00% |
andrei emeltchenko | andrei emeltchenko | 200 | 33.28% | 7 | 35.00% |
gustavo f. padovan | gustavo f. padovan | 59 | 9.82% | 8 | 40.00% |
mat martineau | mat martineau | 41 | 6.82% | 2 | 10.00% |
joe perches | joe perches | 1 | 0.17% | 1 | 5.00% |
| Total | 601 | 100.00% | 20 | 100.00% |
static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data,
u16 result, u16 flags)
{
struct l2cap_conf_rsp *rsp = data;
void *ptr = rsp->data;
BT_DBG("chan %p", chan);
rsp->scid = cpu_to_le16(chan->dcid);
rsp->result = cpu_to_le16(result);
rsp->flags = cpu_to_le16(flags);
return ptr - data;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 72 | 93.51% | 2 | 66.67% |
gustavo f. padovan | gustavo f. padovan | 5 | 6.49% | 1 | 33.33% |
| Total | 77 | 100.00% | 3 | 100.00% |
void __l2cap_le_connect_rsp_defer(struct l2cap_chan *chan)
{
struct l2cap_le_conn_rsp rsp;
struct l2cap_conn *conn = chan->conn;
BT_DBG("chan %p", chan);
rsp.dcid = cpu_to_le16(chan->scid);
rsp.mtu = cpu_to_le16(chan->imtu);
rsp.mps = cpu_to_le16(chan->mps);
rsp.credits = cpu_to_le16(chan->rx_credits);
rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CONN_RSP, sizeof(rsp),
&rsp);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 101 | 99.02% | 3 | 75.00% |
joe perches | joe perches | 1 | 0.98% | 1 | 25.00% |
| Total | 102 | 100.00% | 4 | 100.00% |
void __l2cap_connect_rsp_defer(struct l2cap_chan *chan)
{
struct l2cap_conn_rsp rsp;
struct l2cap_conn *conn = chan->conn;
u8 buf[128];
u8 rsp_code;
rsp.scid = cpu_to_le16(chan->dcid);
rsp.dcid = cpu_to_le16(chan->scid);
rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
if (chan->hs_hcon)
rsp_code = L2CAP_CREATE_CHAN_RSP;
else
rsp_code = L2CAP_CONN_RSP;
BT_DBG("chan %p rsp_code %u", chan, rsp_code);
l2cap_send_cmd(conn, chan->ident, rsp_code, sizeof(rsp), &rsp);
if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state))
return;
l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
l2cap_build_conf_req(chan, buf), buf);
chan->num_conf_req++;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 124 | 80.52% | 5 | 71.43% |
andrei emeltchenko | andrei emeltchenko | 28 | 18.18% | 1 | 14.29% |
joe perches | joe perches | 2 | 1.30% | 1 | 14.29% |
| Total | 154 | 100.00% | 7 | 100.00% |
static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len)
{
int type, olen;
unsigned long val;
/* Use sane default values in case a misbehaving remote device
* did not send an RFC or extended window size option.
*/
u16 txwin_ext = chan->ack_win;
struct l2cap_conf_rfc rfc = {
.mode = chan->mode,
.retrans_timeout = cpu_to_le16(L2CAP_DEFAULT_RETRANS_TO),
.monitor_timeout = cpu_to_le16(L2CAP_DEFAULT_MONITOR_TO),
.max_pdu_size = cpu_to_le16(chan->imtu),
.txwin_size = min_t(u16, chan->ack_win, L2CAP_DEFAULT_TX_WINDOW),
};
BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len);
if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING))
return;
while (len >= L2CAP_CONF_OPT_SIZE) {
len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
switch (type) {
case L2CAP_CONF_RFC:
if (olen == sizeof(rfc))
memcpy(&rfc, (void *)val, olen);
break;
case L2CAP_CONF_EWS:
txwin_ext = val;
break;
}
}
switch (rfc.mode) {
case L2CAP_MODE_ERTM:
chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
chan->mps = le16_to_cpu(rfc.max_pdu_size);
if (test_bit(FLAG_EXT_CTRL, &chan->flags))
chan->ack_win = min_t(u16, chan->ack_win, txwin_ext);
else
chan->ack_win = min_t(u16, chan->ack_win,
rfc.txwin_size);
break;
case L2CAP_MODE_STREAMING:
chan->mps = le16_to_cpu(rfc.max_pdu_size);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo f. padovan | gustavo f. padovan | 168 | 58.33% | 4 | 50.00% |
mat martineau | mat martineau | 117 | 40.62% | 2 | 25.00% |
joe perches | joe perches | 2 | 0.69% | 1 | 12.50% |
szymon janc | szymon janc | 1 | 0.35% | 1 | 12.50% |
| Total | 288 | 100.00% | 8 | 100.00% |
static inline int l2cap_command_rej(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data;
if (cmd_len < sizeof(*rej))
return -EPROTO;
if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD)
return 0;
if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) &&
cmd->ident == conn->info_ident) {
cancel_delayed_work(&conn->info_timer);
conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
conn->info_ident = 0;
l2cap_conn_start(conn);
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 86 | 78.90% | 2 | 33.33% |
johan hedberg | johan hedberg | 17 | 15.60% | 1 | 16.67% |
ilia kolomisnky | ilia kolomisnky | 3 | 2.75% | 1 | 16.67% |
linus torvalds | linus torvalds | 2 | 1.83% | 1 | 16.67% |
ulisses furquim | ulisses furquim | 1 | 0.92% | 1 | 16.67% |
| Total | 109 | 100.00% | 6 | 100.00% |
static struct l2cap_chan *l2cap_connect(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd,
u8 *data, u8 rsp_code, u8 amp_id)
{
struct l2cap_conn_req *req = (struct l2cap_conn_req *) data;
struct l2cap_conn_rsp rsp;
struct l2cap_chan *chan = NULL, *pchan;
int result, status = L2CAP_CS_NO_INFO;
u16 dcid = 0, scid = __le16_to_cpu(req->scid);
__le16 psm = req->psm;
BT_DBG("psm 0x%2.2x scid 0x%4.4x", __le16_to_cpu(psm), scid);
/* Check if we have socket listening on psm */
pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, &conn->hcon->src,
&conn->hcon->dst, ACL_LINK);
if (!pchan) {
result = L2CAP_CR_BAD_PSM;
goto sendresp;
}
mutex_lock(&conn->chan_lock);
l2cap_chan_lock(pchan);
/* Check if the ACL is secure enough (if not SDP) */
if (psm != cpu_to_le16(L2CAP_PSM_SDP) &&
!hci_conn_check_link_mode(conn->hcon)) {
conn->disc_reason = HCI_ERROR_AUTH_FAILURE;
result = L2CAP_CR_SEC_BLOCK;
goto response;
}
result = L2CAP_CR_NO_MEM;
/* Check if we already have channel with that dcid */
if (__l2cap_get_chan_by_dcid(conn, scid))
goto response;
chan = pchan->ops->new_connection(pchan);
if (!chan)
goto response;
/* For certain devices (ex: HID mouse), support for authentication,
* pairing and bonding is optional. For such devices, inorder to avoid
* the ACL alive for too long after L2CAP disconnection, reset the ACL
* disc_timeout back to HCI_DISCONN_TIMEOUT during L2CAP connect.
*/
conn->hcon->disc_timeout = HCI_DISCONN_TIMEOUT;
bacpy(&chan->src, &conn->hcon->src);
bacpy(&chan->dst, &conn->hcon->dst);
chan->src_type = bdaddr_src_type(conn->hcon);
chan->dst_type = bdaddr_dst_type(conn->hcon);
chan->psm = psm;
chan->dcid = scid;
chan->local_amp_id = amp_id;
__l2cap_chan_add(conn, chan);
dcid = chan->scid;
__set_chan_timer(chan, chan->ops->get_sndtimeo(chan));
chan->ident = cmd->ident;
if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) {
if (l2cap_chan_check_security(chan, false)) {
if (test_bit(FLAG_DEFER_SETUP, &chan->flags)) {
l2cap_state_change(chan, BT_CONNECT2);
result = L2CAP_CR_PEND;
status = L2CAP_CS_AUTHOR_PEND;
chan->ops->defer(chan);
} else {
/* Force pending result for AMP controllers.
* The connection will succeed after the
* physical link is up.
*/
if (amp_id == AMP_ID_BREDR) {
l2cap_state_change(chan, BT_CONFIG);
result = L2CAP_CR_SUCCESS;
} else {
l2cap_state_change(chan, BT_CONNECT2);
result = L2CAP_CR_PEND;
}
status = L2CAP_CS_NO_INFO;
}
} else {
l2cap_state_change(chan, BT_CONNECT2);
result = L2CAP_CR_PEND;
status = L2CAP_CS_AUTHEN_PEND;
}
} else {
l2cap_state_change(chan, BT_CONNECT2);
result = L2CAP_CR_PEND;
status = L2CAP_CS_NO_INFO;
}
response:
l2cap_chan_unlock(pchan);
mutex_unlock(&conn->chan_lock);
l2cap_chan_put(pchan);
sendresp:
rsp.scid = cpu_to_le16(scid);
rsp.dcid = cpu_to_le16(dcid);
rsp.result = cpu_to_le16(result);
rsp.status = cpu_to_le16(status);
l2cap_send_cmd(conn, cmd->ident, rsp_code, sizeof(rsp), &rsp);
if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) {
struct l2cap_info_req info;
info.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, L2CAP_INFO_TIMEOUT);
l2cap_send_cmd(conn, conn->info_ident, L2CAP_INFO_REQ,
sizeof(info), &info);
}
if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) &&
result == L2CAP_CR_SUCCESS) {
u8 buf[128];
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++;
}
return chan;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 413 | 60.91% | 9 | 17.65% |
gustavo f. padovan | gustavo f. padovan | 113 | 16.67% | 16 | 31.37% |
marcel holtmann | marcel holtmann | 63 | 9.29% | 10 | 19.61% |
mat martineau | mat martineau | 37 | 5.46% | 2 | 3.92% |
andrei emeltchenko | andrei emeltchenko | 22 | 3.24% | 5 | 9.80% |
johan hedberg | johan hedberg | 11 | 1.62% | 4 | 7.84% |
syam sidhardhan | syam sidhardhan | 9 | 1.33% | 1 | 1.96% |
ido yariv | ido yariv | 4 | 0.59% | 1 | 1.96% |
linus torvalds | linus torvalds | 3 | 0.44% | 1 | 1.96% |
joe perches | joe perches | 2 | 0.29% | 1 | 1.96% |
nathan holstein | nathan holstein | 1 | 0.15% | 1 | 1.96% |
| Total | 678 | 100.00% | 51 | 100.00% |
static int l2cap_connect_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data)
{
struct hci_dev *hdev = conn->hcon->hdev;
struct hci_conn *hcon = conn->hcon;
if (cmd_len < sizeof(struct l2cap_conn_req))
return -EPROTO;
hci_dev_lock(hdev);
if (hci_dev_test_flag(hdev, HCI_MGMT) &&
!test_and_set_bit(HCI_CONN_MGMT_CONNECTED, &hcon->flags))
mgmt_device_connected(hdev, hcon, 0, NULL, 0);
hci_dev_unlock(hdev);
l2cap_connect(conn, cmd, data, L2CAP_CONN_RSP, 0);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
jaganath kanakkassery | jaganath kanakkassery | 60 | 51.72% | 1 | 12.50% |
johan hedberg | johan hedberg | 17 | 14.66% | 1 | 12.50% |
linus torvalds | linus torvalds | 13 | 11.21% | 1 | 12.50% |
mat martineau | mat martineau | 12 | 10.34% | 1 | 12.50% |
gustavo padovan | gustavo padovan | 10 | 8.62% | 2 | 25.00% |
marcel holtmann | marcel holtmann | 4 | 3.45% | 2 | 25.00% |
| Total | 116 | 100.00% | 8 | 100.00% |
static int l2cap_connect_create_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data;
u16 scid, dcid, result, status;
struct l2cap_chan *chan;
u8 req[128];
int err;
if (cmd_len < sizeof(*rsp))
return -EPROTO;
scid = __le16_to_cpu(rsp->scid);
dcid = __le16_to_cpu(rsp->dcid);
result = __le16_to_cpu(rsp->result);
status = __le16_to_cpu(rsp->status);
BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x",
dcid, scid, result, status);
mutex_lock(&conn->chan_lock);
if (scid) {
chan = __l2cap_get_chan_by_scid(conn, scid);
if (!chan) {
err = -EBADSLT;
goto unlock;
}
} else {
chan = __l2cap_get_chan_by_ident(conn, cmd->ident);
if (!chan) {
err = -EBADSLT;
goto unlock;
}
}
err = 0;
l2cap_chan_lock(chan);
switch (result) {
case L2CAP_CR_SUCCESS:
l2cap_state_change(chan, BT_CONFIG);
chan->ident = 0;
chan->dcid = dcid;
clear_bit(CONF_CONNECT_PEND, &chan->conf_state);
if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state))
break;
l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
l2cap_build_conf_req(chan, req), req);
chan->num_conf_req++;
break;
case L2CAP_CR_PEND:
set_bit(CONF_CONNECT_PEND, &chan->conf_state);
break;
default:
l2cap_chan_del(chan, ECONNREFUSED);
break;
}
l2cap_chan_unlock(chan);
unlock:
mutex_unlock(&conn->chan_lock);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 140 | 44.30% | 1 | 4.76% |
andrei emeltchenko | andrei emeltchenko | 51 | 16.14% | 2 | 9.52% |
gustavo f. padovan | gustavo f. padovan | 43 | 13.61% | 8 | 38.10% |
linus torvalds | linus torvalds | 37 | 11.71% | 1 | 4.76% |
marcel holtmann | marcel holtmann | 22 | 6.96% | 4 | 19.05% |
johan hedberg | johan hedberg | 19 | 6.01% | 2 | 9.52% |
joao paulo rechi vita | joao paulo rechi vita | 2 | 0.63% | 1 | 4.76% |
maksim krasnyanskiy | maksim krasnyanskiy | 1 | 0.32% | 1 | 4.76% |
mat martineau | mat martineau | 1 | 0.32% | 1 | 4.76% |
| Total | 316 | 100.00% | 21 | 100.00% |
static inline void set_default_fcs(struct l2cap_chan *chan)
{
/* FCS is enabled only in ERTM or streaming mode, if one or both
* sides request it.
*/
if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING)
chan->fcs = L2CAP_FCS_NONE;
else if (!test_bit(CONF_RECV_NO_FCS, &chan->conf_state))
chan->fcs = L2CAP_FCS_CRC16;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 39 | 73.58% | 1 | 16.67% |
gustavo f. padovan | gustavo f. padovan | 13 | 24.53% | 4 | 66.67% |
andrei emeltchenko | andrei emeltchenko | 1 | 1.89% | 1 | 16.67% |
| Total | 53 | 100.00% | 6 | 100.00% |
static void l2cap_send_efs_conf_rsp(struct l2cap_chan *chan, void *data,
u8 ident, u16 flags)
{
struct l2cap_conn *conn = chan->conn;
BT_DBG("conn %p chan %p ident %d flags 0x%4.4x", conn, chan, ident,
flags);
clear_bit(CONF_LOC_CONF_PEND, &chan->conf_state);
set_bit(CONF_OUTPUT_DONE, &chan->conf_state);
l2cap_send_cmd(conn, ident, L2CAP_CONF_RSP,
l2cap_build_conf_rsp(chan, data,
L2CAP_CONF_SUCCESS, flags), data);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 85 | 100.00% | 1 | 100.00% |
| Total | 85 | 100.00% | 1 | 100.00% |
static void cmd_reject_invalid_cid(struct l2cap_conn *conn, u8 ident,
u16 scid, u16 dcid)
{
struct l2cap_cmd_rej_cid rej;
rej.reason = cpu_to_le16(L2CAP_REJ_INVALID_CID);
rej.scid = __cpu_to_le16(scid);
rej.dcid = __cpu_to_le16(dcid);
l2cap_send_cmd(conn, ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 67 | 98.53% | 1 | 50.00% |
joe perches | joe perches | 1 | 1.47% | 1 | 50.00% |
| Total | 68 | 100.00% | 2 | 100.00% |
static inline int l2cap_config_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_conf_req *req = (struct l2cap_conf_req *) data;
u16 dcid, flags;
u8 rsp[64];
struct l2cap_chan *chan;
int len, err = 0;
if (cmd_len < sizeof(*req))
return -EPROTO;
dcid = __le16_to_cpu(req->dcid);
flags = __le16_to_cpu(req->flags);
BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags);
chan = l2cap_get_chan_by_scid(conn, dcid);
if (!chan) {
cmd_reject_invalid_cid(conn, cmd->ident, dcid, 0);
return 0;
}
if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) {
cmd_reject_invalid_cid(conn, cmd->ident, chan->scid,
chan->dcid);
goto unlock;
}
/* Reject if config buffer is too small. */
len = cmd_len - sizeof(*req);
if (chan->conf_len + len > sizeof(chan->conf_req)) {
l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
l2cap_build_conf_rsp(chan, rsp,
L2CAP_CONF_REJECT, flags), rsp);
goto unlock;
}
/* Store config. */
memcpy(chan->conf_req + chan->conf_len, req->data, len);
chan->conf_len += len;
if (flags & L2CAP_CONF_FLAG_CONTINUATION) {
/* Incomplete config. Send empty response. */
l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
l2cap_build_conf_rsp(chan, rsp,
L2CAP_CONF_SUCCESS, flags), rsp);
goto unlock;
}
/* Complete config. */
len = l2cap_parse_conf_req(chan, rsp);
if (len < 0) {
l2cap_send_disconn_req(chan, ECONNRESET);
goto unlock;
}
chan->ident = cmd->ident;
l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp);
chan->num_conf_rsp++;
/* Reset config buffer. */
chan->conf_len = 0;
if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state))
goto unlock;
if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) {
set_default_fcs(chan);
if (chan->mode == L2CAP_MODE_ERTM ||
chan->mode == L2CAP_MODE_STREAMING)
err = l2cap_ertm_init(chan);
if (err < 0)
l2cap_send_disconn_req(chan, -err);
else
l2cap_chan_ready(chan);
goto unlock;
}
if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) {
u8 buf[64];
l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
l2cap_build_conf_req(chan, buf), buf);
chan->num_conf_req++;
}
/* Got Conf Rsp PENDING from remote side and assume we sent
Conf Rsp PENDING in the code above */
if (test_bit(CONF_REM_CONF_PEND, &chan->conf_state) &&
test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) {
/* check compatibility */
/* Send rsp for BR/EDR channel */
if (!chan->hs_hcon)
l2cap_send_efs_conf_rsp(chan, rsp, cmd->ident, flags);
else
chan->ident = cmd->ident;
}
unlock:
l2cap_chan_unlock(chan);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 213 | 39.59% | 2 | 4.65% |
gustavo f. padovan | gustavo f. padovan | 63 | 11.71% | 13 | 30.23% |
linus torvalds | linus torvalds | 59 | 10.97% | 2 | 4.65% |
andrei emeltchenko | andrei emeltchenko | 58 | 10.78% | 8 | 18.60% |
mat martineau | mat martineau | 37 | 6.88% | 4 | 9.30% |
johan hedberg | johan hedberg | 37 | 6.88% | 2 | 4.65% |
maksim krasnyanskiy | maksim krasnyanskiy | 20 | 3.72% | 2 | 4.65% |
marcel holtmann | marcel holtmann | 20 | 3.72% | 3 | 6.98% |
maxim krasnyansky | maxim krasnyansky | 20 | 3.72% | 1 | 2.33% |
thomas graf | thomas graf | 3 | 0.56% | 1 | 2.33% |
david s. miller | david s. miller | 2 | 0.37% | 1 | 2.33% |
arnaldo carvalho de melo | arnaldo carvalho de melo | 2 | 0.37% | 1 | 2.33% |
john w. linville | john w. linville | 2 | 0.37% | 1 | 2.33% |
stephen hemminger | stephen hemminger | 1 | 0.19% | 1 | 2.33% |
hideaki yoshifuji | hideaki yoshifuji | 1 | 0.19% | 1 | 2.33% |
| Total | 538 | 100.00% | 43 | 100.00% |
static inline int l2cap_config_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data;
u16 scid, flags, result;
struct l2cap_chan *chan;
int len = cmd_len - sizeof(*rsp);
int err = 0;
if (cmd_len < sizeof(*rsp))
return -EPROTO;
scid = __le16_to_cpu(rsp->scid);
flags = __le16_to_cpu(rsp->flags);
result = __le16_to_cpu(rsp->result);
BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x len %d", scid, flags,
result, len);
chan = l2cap_get_chan_by_scid(conn, scid);
if (!chan)
return 0;
switch (result) {
case L2CAP_CONF_SUCCESS:
l2cap_conf_rfc_get(chan, rsp->data, len);
clear_bit(CONF_REM_CONF_PEND, &chan->conf_state);
break;
case L2CAP_CONF_PENDING:
set_bit(CONF_REM_CONF_PEND, &chan->conf_state);
if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) {
char buf[64];
len = l2cap_parse_conf_rsp(chan, rsp->data, len,
buf, &result);
if (len < 0) {
l2cap_send_disconn_req(chan, ECONNRESET);
goto done;
}
if (!chan->hs_hcon) {
l2cap_send_efs_conf_rsp(chan, buf, cmd->ident,
0);
} else {
if (l2cap_check_efs(chan)) {
amp_create_logical_link(chan);
chan->ident = cmd->ident;
}
}
}
goto done;
case L2CAP_CONF_UNACCEPT:
if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) {
char req[64];
if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) {
l2cap_send_disconn_req(chan, ECONNRESET);
goto done;
}
/* throw out any old stored conf requests */
result = L2CAP_CONF_SUCCESS;
len = l2cap_parse_conf_rsp(chan, rsp->data, len,
req, &result);
if (len < 0) {
l2cap_send_disconn_req(chan, ECONNRESET);
goto done;
}
l2cap_send_cmd(conn, l2cap_get_ident(conn),
L2CAP_CONF_REQ, len, req);
chan->num_conf_req++;
if (result != L2CAP_CONF_SUCCESS)
goto done;
break;
}
default:
l2cap_chan_set_err(chan, ECONNRESET);
__set_chan_timer(chan, L2CAP_DISC_REJ_TIMEOUT);
l2cap_send_disconn_req(chan, ECONNRESET);
goto done;
}
if (flags & L2CAP_CONF_FLAG_CONTINUATION)
goto done;
set_bit(CONF_INPUT_DONE, &chan->conf_state);
if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) {
set_default_fcs(chan);
if (chan->mode == L2CAP_MODE_ERTM ||
chan->mode == L2CAP_MODE_STREAMING)
err = l2cap_ertm_init(chan);
if (err < 0)
l2cap_send_disconn_req(chan, -err);
else
l2cap_chan_ready(chan);
}
done:
l2cap_chan_unlock(chan);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
andrei emeltchenko | andrei emeltchenko | 165 | 31.91% | 11 | 30.56% |
gustavo padovan | gustavo padovan | 161 | 31.14% | 3 | 8.33% |
linus torvalds | linus torvalds | 76 | 14.70% | 2 | 5.56% |
gustavo f. padovan | gustavo f. padovan | 58 | 11.22% | 12 | 33.33% |
mat martineau | mat martineau | 30 | 5.80% | 3 | 8.33% |
johan hedberg | johan hedberg | 18 | 3.48% | 1 | 2.78% |
maksim krasnyanskiy | maksim krasnyanskiy | 5 | 0.97% | 1 | 2.78% |
marcel holtmann | marcel holtmann | 3 | 0.58% | 2 | 5.56% |
andrzej kaczmarek | andrzej kaczmarek | 1 | 0.19% | 1 | 2.78% |
| Total | 517 | 100.00% | 36 | 100.00% |
static inline int l2cap_disconnect_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data;
struct l2cap_disconn_rsp rsp;
u16 dcid, scid;
struct l2cap_chan *chan;
if (cmd_len != sizeof(*req))
return -EPROTO;
scid = __le16_to_cpu(req->scid);
dcid = __le16_to_cpu(req->dcid);
BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
mutex_lock(&conn->chan_lock);
chan = __l2cap_get_chan_by_scid(conn, dcid);
if (!chan) {
mutex_unlock(&conn->chan_lock);
cmd_reject_invalid_cid(conn, cmd->ident, dcid, scid);
return 0;
}
l2cap_chan_lock(chan);
rsp.dcid = cpu_to_le16(chan->scid);
rsp.scid = cpu_to_le16(chan->dcid);
l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
chan->ops->set_shutdown(chan);
l2cap_chan_hold(chan);
l2cap_chan_del(chan, ECONNRESET);
l2cap_chan_unlock(chan);
chan->ops->close(chan);
l2cap_chan_put(chan);
mutex_unlock(&conn->chan_lock);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
linus torvalds | linus torvalds | 76 | 32.20% | 2 | 11.11% |
gustavo padovan | gustavo padovan | 51 | 21.61% | 4 | 22.22% |
andrei emeltchenko | andrei emeltchenko | 37 | 15.68% | 2 | 11.11% |
johan hedberg | johan hedberg | 31 | 13.14% | 2 | 11.11% |
gustavo f. padovan | gustavo f. padovan | 15 | 6.36% | 3 | 16.67% |
mat martineau | mat martineau | 10 | 4.24% | 1 | 5.56% |
marcel holtmann | marcel holtmann | 9 | 3.81% | 2 | 11.11% |
maksim krasnyanskiy | maksim krasnyanskiy | 7 | 2.97% | 2 | 11.11% |
| Total | 236 | 100.00% | 18 | 100.00% |
static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data;
u16 dcid, scid;
struct l2cap_chan *chan;
if (cmd_len != sizeof(*rsp))
return -EPROTO;
scid = __le16_to_cpu(rsp->scid);
dcid = __le16_to_cpu(rsp->dcid);
BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
mutex_lock(&conn->chan_lock);
chan = __l2cap_get_chan_by_scid(conn, scid);
if (!chan) {
mutex_unlock(&conn->chan_lock);
return 0;
}
l2cap_chan_lock(chan);
l2cap_chan_hold(chan);
l2cap_chan_del(chan, 0);
l2cap_chan_unlock(chan);
chan->ops->close(chan);
l2cap_chan_put(chan);
mutex_unlock(&conn->chan_lock);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 82 | 48.52% | 4 | 30.77% |
andrei emeltchenko | andrei emeltchenko | 34 | 20.12% | 2 | 15.38% |
johan hedberg | johan hedberg | 17 | 10.06% | 1 | 7.69% |
gustavo f. padovan | gustavo f. padovan | 13 | 7.69% | 2 | 15.38% |
mat martineau | mat martineau | 10 | 5.92% | 1 | 7.69% |
marcel holtmann | marcel holtmann | 9 | 5.33% | 2 | 15.38% |
linus torvalds | linus torvalds | 4 | 2.37% | 1 | 7.69% |
| Total | 169 | 100.00% | 13 | 100.00% |
static inline int l2cap_information_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_info_req *req = (struct l2cap_info_req *) data;
u16 type;
if (cmd_len != sizeof(*req))
return -EPROTO;
type = __le16_to_cpu(req->type);
BT_DBG("type 0x%4.4x", type);
if (type == L2CAP_IT_FEAT_MASK) {
u8 buf[8];
u32 feat_mask = l2cap_feat_mask;
struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf;
rsp->type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
rsp->result = cpu_to_le16(L2CAP_IR_SUCCESS);
if (!disable_ertm)
feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING
| L2CAP_FEAT_FCS;
if (conn->local_fixed_chan & L2CAP_FC_A2MP)
feat_mask |= L2CAP_FEAT_EXT_FLOW
| L2CAP_FEAT_EXT_WINDOW;
put_unaligned_le32(feat_mask, rsp->data);
l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf),
buf);
} else if (type == L2CAP_IT_FIXED_CHAN) {
u8 buf[12];
struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf;
rsp->type = cpu_to_le16(L2CAP_IT_FIXED_CHAN);
rsp->result = cpu_to_le16(L2CAP_IR_SUCCESS);
rsp->data[0] = conn->local_fixed_chan;
memset(rsp->data + 1, 0, 7);
l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(buf),
buf);
} else {
struct l2cap_info_rsp rsp;
rsp.type = cpu_to_le16(type);
rsp.result = cpu_to_le16(L2CAP_IR_NOTSUPP);
l2cap_send_cmd(conn, cmd->ident, L2CAP_INFO_RSP, sizeof(rsp),
&rsp);
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 222 | 72.55% | 5 | 29.41% |
johan hedberg | johan hedberg | 36 | 11.76% | 2 | 11.76% |
linus torvalds | linus torvalds | 23 | 7.52% | 2 | 11.76% |
andrei emeltchenko | andrei emeltchenko | 12 | 3.92% | 3 | 17.65% |
marcel holtmann | marcel holtmann | 6 | 1.96% | 3 | 17.65% |
joe perches | joe perches | 5 | 1.63% | 1 | 5.88% |
gustavo f. padovan | gustavo f. padovan | 2 | 0.65% | 1 | 5.88% |
| Total | 306 | 100.00% | 17 | 100.00% |
static inline int l2cap_information_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data;
u16 type, result;
if (cmd_len < sizeof(*rsp))
return -EPROTO;
type = __le16_to_cpu(rsp->type);
result = __le16_to_cpu(rsp->result);
BT_DBG("type 0x%4.4x result 0x%2.2x", type, result);
/* L2CAP Info req/rsp are unbound to channels, add extra checks */
if (cmd->ident != conn->info_ident ||
conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)
return 0;
cancel_delayed_work(&conn->info_timer);
if (result != L2CAP_IR_SUCCESS) {
conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
conn->info_ident = 0;
l2cap_conn_start(conn);
return 0;
}
switch (type) {
case L2CAP_IT_FEAT_MASK:
conn->feat_mask = get_unaligned_le32(rsp->data);
if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) {
struct l2cap_info_req req;
req.type = cpu_to_le16(L2CAP_IT_FIXED_CHAN);
conn->info_ident = l2cap_get_ident(conn);
l2cap_send_cmd(conn, conn->info_ident,
L2CAP_INFO_REQ, sizeof(req), &req);
} else {
conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
conn->info_ident = 0;
l2cap_conn_start(conn);
}
break;
case L2CAP_IT_FIXED_CHAN:
conn->remote_fixed_chan = rsp->data[0];
conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
conn->info_ident = 0;
l2cap_conn_start(conn);
break;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 113 | 42.64% | 2 | 14.29% |
linus torvalds | linus torvalds | 61 | 23.02% | 2 | 14.29% |
andrei emeltchenko | andrei emeltchenko | 38 | 14.34% | 2 | 14.29% |
ville tervo | ville tervo | 27 | 10.19% | 1 | 7.14% |
johan hedberg | johan hedberg | 17 | 6.42% | 2 | 14.29% |
maksim krasnyanskiy | maksim krasnyanskiy | 5 | 1.89% | 1 | 7.14% |
jaganath kanakkassery | jaganath kanakkassery | 1 | 0.38% | 1 | 7.14% |
joe perches | joe perches | 1 | 0.38% | 1 | 7.14% |
ulisses furquim | ulisses furquim | 1 | 0.38% | 1 | 7.14% |
marcel holtmann | marcel holtmann | 1 | 0.38% | 1 | 7.14% |
| Total | 265 | 100.00% | 14 | 100.00% |
static int l2cap_create_channel_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd,
u16 cmd_len, void *data)
{
struct l2cap_create_chan_req *req = data;
struct l2cap_create_chan_rsp rsp;
struct l2cap_chan *chan;
struct hci_dev *hdev;
u16 psm, scid;
if (cmd_len != sizeof(*req))
return -EPROTO;
if (!(conn->local_fixed_chan & L2CAP_FC_A2MP))
return -EINVAL;
psm = le16_to_cpu(req->psm);
scid = le16_to_cpu(req->scid);
BT_DBG("psm 0x%2.2x, scid 0x%4.4x, amp_id %d", psm, scid, req->amp_id);
/* For controller id 0 make BR/EDR connection */
if (req->amp_id == AMP_ID_BREDR) {
l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP,
req->amp_id);
return 0;
}
/* Validate AMP controller id */
hdev = hci_dev_get(req->amp_id);
if (!hdev)
goto error;
if (hdev->dev_type != HCI_AMP || !test_bit(HCI_UP, &hdev->flags)) {
hci_dev_put(hdev);
goto error;
}
chan = l2cap_connect(conn, cmd, data, L2CAP_CREATE_CHAN_RSP,
req->amp_id);
if (chan) {
struct amp_mgr *mgr = conn->hcon->amp_mgr;
struct hci_conn *hs_hcon;
hs_hcon = hci_conn_hash_lookup_ba(hdev, AMP_LINK,
&conn->hcon->dst);
if (!hs_hcon) {
hci_dev_put(hdev);
cmd_reject_invalid_cid(conn, cmd->ident, chan->scid,
chan->dcid);
return 0;
}
BT_DBG("mgr %p bredr_chan %p hs_hcon %p", mgr, chan, hs_hcon);
mgr->bredr_chan = chan;
chan->hs_hcon = hs_hcon;
chan->fcs = L2CAP_FCS_NONE;
conn->mtu = hdev->block_mtu;
}
hci_dev_put(hdev);
return 0;
error:
rsp.dcid = 0;
rsp.scid = cpu_to_le16(scid);
rsp.result = cpu_to_le16(L2CAP_CR_BAD_AMP);
rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
l2cap_send_cmd(conn, cmd->ident, L2CAP_CREATE_CHAN_RSP,
sizeof(rsp), &rsp);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 181 | 48.40% | 2 | 15.38% |
andrei emeltchenko | andrei emeltchenko | 161 | 43.05% | 4 | 30.77% |
johan hedberg | johan hedberg | 24 | 6.42% | 3 | 23.08% |
marcel holtmann | marcel holtmann | 6 | 1.60% | 3 | 23.08% |
joe perches | joe perches | 2 | 0.53% | 1 | 7.69% |
| Total | 374 | 100.00% | 13 | 100.00% |
static void l2cap_send_move_chan_req(struct l2cap_chan *chan, u8 dest_amp_id)
{
struct l2cap_move_chan_req req;
u8 ident;
BT_DBG("chan %p, dest_amp_id %d", chan, dest_amp_id);
ident = l2cap_get_ident(chan->conn);
chan->ident = ident;
req.icid = cpu_to_le16(chan->scid);
req.dest_amp_id = dest_amp_id;
l2cap_send_cmd(chan->conn, ident, L2CAP_MOVE_CHAN_REQ, sizeof(req),
&req);
__set_chan_timer(chan, L2CAP_MOVE_TIMEOUT);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 88 | 100.00% | 1 | 100.00% |
| Total | 88 | 100.00% | 1 | 100.00% |
static void l2cap_send_move_chan_rsp(struct l2cap_chan *chan, u16 result)
{
struct l2cap_move_chan_rsp rsp;
BT_DBG("chan %p, result 0x%4.4x", chan, result);
rsp.icid = cpu_to_le16(chan->dcid);
rsp.result = cpu_to_le16(result);
l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_RSP,
sizeof(rsp), &rsp);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 68 | 100.00% | 2 | 100.00% |
| Total | 68 | 100.00% | 2 | 100.00% |
static void l2cap_send_move_chan_cfm(struct l2cap_chan *chan, u16 result)
{
struct l2cap_move_chan_cfm cfm;
BT_DBG("chan %p, result 0x%4.4x", chan, result);
chan->ident = l2cap_get_ident(chan->conn);
cfm.icid = cpu_to_le16(chan->scid);
cfm.result = cpu_to_le16(result);
l2cap_send_cmd(chan->conn, chan->ident, L2CAP_MOVE_CHAN_CFM,
sizeof(cfm), &cfm);
__set_chan_timer(chan, L2CAP_MOVE_TIMEOUT);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 86 | 100.00% | 2 | 100.00% |
| Total | 86 | 100.00% | 2 | 100.00% |
static void l2cap_send_move_chan_cfm_icid(struct l2cap_conn *conn, u16 icid)
{
struct l2cap_move_chan_cfm cfm;
BT_DBG("conn %p, icid 0x%4.4x", conn, icid);
cfm.icid = cpu_to_le16(icid);
cfm.result = cpu_to_le16(L2CAP_MC_UNCONFIRMED);
l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_MOVE_CHAN_CFM,
sizeof(cfm), &cfm);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 64 | 98.46% | 2 | 66.67% |
joe perches | joe perches | 1 | 1.54% | 1 | 33.33% |
| Total | 65 | 100.00% | 3 | 100.00% |
static void l2cap_send_move_chan_cfm_rsp(struct l2cap_conn *conn, u8 ident,
u16 icid)
{
struct l2cap_move_chan_cfm_rsp rsp;
BT_DBG("icid 0x%4.4x", icid);
rsp.icid = cpu_to_le16(icid);
l2cap_send_cmd(conn, ident, L2CAP_MOVE_CHAN_CFM_RSP, sizeof(rsp), &rsp);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 53 | 98.15% | 1 | 50.00% |
andrei emeltchenko | andrei emeltchenko | 1 | 1.85% | 1 | 50.00% |
| Total | 54 | 100.00% | 2 | 100.00% |
static void __release_logical_link(struct l2cap_chan *chan)
{
chan->hs_hchan = NULL;
chan->hs_hcon = NULL;
/* Placeholder - release the logical link */
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 24 | 100.00% | 1 | 100.00% |
| Total | 24 | 100.00% | 1 | 100.00% |
static void l2cap_logical_fail(struct l2cap_chan *chan)
{
/* Logical link setup failed */
if (chan->state != BT_CONNECTED) {
/* Create channel failure, disconnect */
l2cap_send_disconn_req(chan, ECONNRESET);
return;
}
switch (chan->move_role) {
case L2CAP_MOVE_ROLE_RESPONDER:
l2cap_move_done(chan);
l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_SUPP);
break;
case L2CAP_MOVE_ROLE_INITIATOR:
if (chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_COMP ||
chan->move_state == L2CAP_MOVE_WAIT_LOGICAL_CFM) {
/* Remote has only sent pending or
* success responses, clean up
*/
l2cap_move_done(chan);
}
/* Other amp move states imply that the move
* has already aborted
*/
l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED);
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 89 | 100.00% | 1 | 100.00% |
| Total | 89 | 100.00% | 1 | 100.00% |
static void l2cap_logical_finish_create(struct l2cap_chan *chan,
struct hci_chan *hchan)
{
struct l2cap_conf_rsp rsp;
chan->hs_hchan = hchan;
chan->hs_hcon->l2cap_data = chan->conn;
l2cap_send_efs_conf_rsp(chan, &rsp, chan->ident, 0);
if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) {
int err;
set_default_fcs(chan);
err = l2cap_ertm_init(chan);
if (err < 0)
l2cap_send_disconn_req(chan, -err);
else
l2cap_chan_ready(chan);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 96 | 96.97% | 1 | 33.33% |
andrei emeltchenko | andrei emeltchenko | 3 | 3.03% | 2 | 66.67% |
| Total | 99 | 100.00% | 3 | 100.00% |
static void l2cap_logical_finish_move(struct l2cap_chan *chan,
struct hci_chan *hchan)
{
chan->hs_hcon = hchan->conn;
chan->hs_hcon->l2cap_data = chan->conn;
BT_DBG("move_state %d", chan->move_state);
switch (chan->move_state) {
case L2CAP_MOVE_WAIT_LOGICAL_COMP:
/* Move confirm will be sent after a success
* response is received
*/
chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS;
break;
case L2CAP_MOVE_WAIT_LOGICAL_CFM:
if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY;
} else if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) {
chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP;
l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED);
} else if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) {
chan->move_state = L2CAP_MOVE_WAIT_CONFIRM;
l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS);
}
break;
default:
/* Move was not in expected state, free the channel */
__release_logical_link(chan);
chan->move_state = L2CAP_MOVE_STABLE;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 147 | 100.00% | 1 | 100.00% |
| Total | 147 | 100.00% | 1 | 100.00% |
/* Call with chan locked */
void l2cap_logical_cfm(struct l2cap_chan *chan, struct hci_chan *hchan,
u8 status)
{
BT_DBG("chan %p, hchan %p, status %d", chan, hchan, status);
if (status) {
l2cap_logical_fail(chan);
__release_logical_link(chan);
return;
}
if (chan->state != BT_CONNECTED) {
/* Ignore logical link if channel is on BR/EDR */
if (chan->local_amp_id != AMP_ID_BREDR)
l2cap_logical_finish_create(chan, hchan);
} else {
l2cap_logical_finish_move(chan, hchan);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 80 | 97.56% | 2 | 66.67% |
marcel holtmann | marcel holtmann | 2 | 2.44% | 1 | 33.33% |
| Total | 82 | 100.00% | 3 | 100.00% |
void l2cap_move_start(struct l2cap_chan *chan)
{
BT_DBG("chan %p", chan);
if (chan->local_amp_id == AMP_ID_BREDR) {
if (chan->chan_policy != BT_CHANNEL_POLICY_AMP_PREFERRED)
return;
chan->move_role = L2CAP_MOVE_ROLE_INITIATOR;
chan->move_state = L2CAP_MOVE_WAIT_PREPARE;
/* Placeholder - start physical link setup */
} else {
chan->move_role = L2CAP_MOVE_ROLE_INITIATOR;
chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS;
chan->move_id = 0;
l2cap_move_setup(chan);
l2cap_send_move_chan_req(chan, 0);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 81 | 98.78% | 1 | 50.00% |
marcel holtmann | marcel holtmann | 1 | 1.22% | 1 | 50.00% |
| Total | 82 | 100.00% | 2 | 100.00% |
static void l2cap_do_create(struct l2cap_chan *chan, int result,
u8 local_amp_id, u8 remote_amp_id)
{
BT_DBG("chan %p state %s %u -> %u", chan, state_to_string(chan->state),
local_amp_id, remote_amp_id);
chan->fcs = L2CAP_FCS_NONE;
/* Outgoing channel on AMP */
if (chan->state == BT_CONNECT) {
if (result == L2CAP_CR_SUCCESS) {
chan->local_amp_id = local_amp_id;
l2cap_send_create_chan_req(chan, remote_amp_id);
} else {
/* Revert to BR/EDR connect */
l2cap_send_conn_req(chan);
}
return;
}
/* Incoming channel on AMP */
if (__l2cap_no_conn_pending(chan)) {
struct l2cap_conn_rsp rsp;
char buf[128];
rsp.scid = cpu_to_le16(chan->dcid);
rsp.dcid = cpu_to_le16(chan->scid);
if (result == L2CAP_CR_SUCCESS) {
/* Send successful response */
rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
} else {
/* Send negative response */
rsp.result = cpu_to_le16(L2CAP_CR_NO_MEM);
rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
}
l2cap_send_cmd(chan->conn, chan->ident, L2CAP_CREATE_CHAN_RSP,
sizeof(rsp), &rsp);
if (result == L2CAP_CR_SUCCESS) {
l2cap_state_change(chan, BT_CONFIG);
set_bit(CONF_REQ_SENT, &chan->conf_state);
l2cap_send_cmd(chan->conn, l2cap_get_ident(chan->conn),
L2CAP_CONF_REQ,
l2cap_build_conf_req(chan, buf), buf);
chan->num_conf_req++;
}
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 181 | 71.54% | 1 | 20.00% |
andrei emeltchenko | andrei emeltchenko | 67 | 26.48% | 2 | 40.00% |
joe perches | joe perches | 4 | 1.58% | 1 | 20.00% |
gustavo padovan | gustavo padovan | 1 | 0.40% | 1 | 20.00% |
| Total | 253 | 100.00% | 5 | 100.00% |
static void l2cap_do_move_initiate(struct l2cap_chan *chan, u8 local_amp_id,
u8 remote_amp_id)
{
l2cap_move_setup(chan);
chan->move_id = local_amp_id;
chan->move_state = L2CAP_MOVE_WAIT_RSP;
l2cap_send_move_chan_req(chan, remote_amp_id);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 41 | 100.00% | 1 | 100.00% |
| Total | 41 | 100.00% | 1 | 100.00% |
static void l2cap_do_move_respond(struct l2cap_chan *chan, int result)
{
struct hci_chan *hchan = NULL;
/* Placeholder - get hci_chan for logical link */
if (hchan) {
if (hchan->state == BT_CONNECTED) {
/* Logical link is ready to go */
chan->hs_hcon = hchan->conn;
chan->hs_hcon->l2cap_data = chan->conn;
chan->move_state = L2CAP_MOVE_WAIT_CONFIRM;
l2cap_send_move_chan_rsp(chan, L2CAP_MR_SUCCESS);
l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS);
} else {
/* Wait for logical link to be ready */
chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM;
}
} else {
/* Logical link not available */
l2cap_send_move_chan_rsp(chan, L2CAP_MR_NOT_ALLOWED);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 100 | 100.00% | 1 | 100.00% |
| Total | 100 | 100.00% | 1 | 100.00% |
static void l2cap_do_move_cancel(struct l2cap_chan *chan, int result)
{
if (chan->move_role == L2CAP_MOVE_ROLE_RESPONDER) {
u8 rsp_result;
if (result == -EINVAL)
rsp_result = L2CAP_MR_BAD_ID;
else
rsp_result = L2CAP_MR_NOT_ALLOWED;
l2cap_send_move_chan_rsp(chan, rsp_result);
}
chan->move_role = L2CAP_MOVE_ROLE_NONE;
chan->move_state = L2CAP_MOVE_STABLE;
/* Restart data transmission */
l2cap_ertm_send(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 68 | 100.00% | 1 | 100.00% |
| Total | 68 | 100.00% | 1 | 100.00% |
/* Invoke with locked chan */
void __l2cap_physical_cfm(struct l2cap_chan *chan, int result)
{
u8 local_amp_id = chan->local_amp_id;
u8 remote_amp_id = chan->remote_amp_id;
BT_DBG("chan %p, result %d, local_amp_id %d, remote_amp_id %d",
chan, result, local_amp_id, remote_amp_id);
if (chan->state == BT_DISCONN || chan->state == BT_CLOSED) {
l2cap_chan_unlock(chan);
return;
}
if (chan->state != BT_CONNECTED) {
l2cap_do_create(chan, result, local_amp_id, remote_amp_id);
} else if (result != L2CAP_MR_SUCCESS) {
l2cap_do_move_cancel(chan, result);
} else {
switch (chan->move_role) {
case L2CAP_MOVE_ROLE_INITIATOR:
l2cap_do_move_initiate(chan, local_amp_id,
remote_amp_id);
break;
case L2CAP_MOVE_ROLE_RESPONDER:
l2cap_do_move_respond(chan, result);
break;
default:
l2cap_do_move_cancel(chan, result);
break;
}
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 130 | 90.91% | 1 | 25.00% |
andrei emeltchenko | andrei emeltchenko | 13 | 9.09% | 3 | 75.00% |
| Total | 143 | 100.00% | 4 | 100.00% |
static inline int l2cap_move_channel_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd,
u16 cmd_len, void *data)
{
struct l2cap_move_chan_req *req = data;
struct l2cap_move_chan_rsp rsp;
struct l2cap_chan *chan;
u16 icid = 0;
u16 result = L2CAP_MR_NOT_ALLOWED;
if (cmd_len != sizeof(*req))
return -EPROTO;
icid = le16_to_cpu(req->icid);
BT_DBG("icid 0x%4.4x, dest_amp_id %d", icid, req->dest_amp_id);
if (!(conn->local_fixed_chan & L2CAP_FC_A2MP))
return -EINVAL;
chan = l2cap_get_chan_by_dcid(conn, icid);
if (!chan) {
rsp.icid = cpu_to_le16(icid);
rsp.result = cpu_to_le16(L2CAP_MR_NOT_ALLOWED);
l2cap_send_cmd(conn, cmd->ident, L2CAP_MOVE_CHAN_RSP,
sizeof(rsp), &rsp);
return 0;
}
chan->ident = cmd->ident;
if (chan->scid < L2CAP_CID_DYN_START ||
chan->chan_policy == BT_CHANNEL_POLICY_BREDR_ONLY ||
(chan->mode != L2CAP_MODE_ERTM &&
chan->mode != L2CAP_MODE_STREAMING)) {
result = L2CAP_MR_NOT_ALLOWED;
goto send_move_response;
}
if (chan->local_amp_id == req->dest_amp_id) {
result = L2CAP_MR_SAME_ID;
goto send_move_response;
}
if (req->dest_amp_id != AMP_ID_BREDR) {
struct hci_dev *hdev;
hdev = hci_dev_get(req->dest_amp_id);
if (!hdev || hdev->dev_type != HCI_AMP ||
!test_bit(HCI_UP, &hdev->flags)) {
if (hdev)
hci_dev_put(hdev);
result = L2CAP_MR_BAD_ID;
goto send_move_response;
}
hci_dev_put(hdev);
}
/* Detect a move collision. Only send a collision response
* if this side has "lost", otherwise proceed with the move.
* The winner has the larger bd_addr.
*/
if ((__chan_is_moving(chan) ||
chan->move_role != L2CAP_MOVE_ROLE_NONE) &&
bacmp(&conn->hcon->src, &conn->hcon->dst) > 0) {
result = L2CAP_MR_COLLISION;
goto send_move_response;
}
chan->move_role = L2CAP_MOVE_ROLE_RESPONDER;
l2cap_move_setup(chan);
chan->move_id = req->dest_amp_id;
icid = chan->dcid;
if (req->dest_amp_id == AMP_ID_BREDR) {
/* Moving to BR/EDR */
if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY;
result = L2CAP_MR_PEND;
} else {
chan->move_state = L2CAP_MOVE_WAIT_CONFIRM;
result = L2CAP_MR_SUCCESS;
}
} else {
chan->move_state = L2CAP_MOVE_WAIT_PREPARE;
/* Placeholder - uncomment when amp functions are available */
/*amp_accept_physical(chan, req->dest_amp_id);*/
result = L2CAP_MR_PEND;
}
send_move_response:
l2cap_send_move_chan_rsp(chan, result);
l2cap_chan_unlock(chan);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 417 | 95.42% | 3 | 30.00% |
marcel holtmann | marcel holtmann | 13 | 2.97% | 4 | 40.00% |
johan hedberg | johan hedberg | 5 | 1.14% | 1 | 10.00% |
andrei emeltchenko | andrei emeltchenko | 1 | 0.23% | 1 | 10.00% |
joe perches | joe perches | 1 | 0.23% | 1 | 10.00% |
| Total | 437 | 100.00% | 10 | 100.00% |
static void l2cap_move_continue(struct l2cap_conn *conn, u16 icid, u16 result)
{
struct l2cap_chan *chan;
struct hci_chan *hchan = NULL;
chan = l2cap_get_chan_by_scid(conn, icid);
if (!chan) {
l2cap_send_move_chan_cfm_icid(conn, icid);
return;
}
__clear_chan_timer(chan);
if (result == L2CAP_MR_PEND)
__set_chan_timer(chan, L2CAP_MOVE_ERTX_TIMEOUT);
switch (chan->move_state) {
case L2CAP_MOVE_WAIT_LOGICAL_COMP:
/* Move confirm will be sent when logical link
* is complete.
*/
chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM;
break;
case L2CAP_MOVE_WAIT_RSP_SUCCESS:
if (result == L2CAP_MR_PEND) {
break;
} else if (test_bit(CONN_LOCAL_BUSY,
&chan->conn_state)) {
chan->move_state = L2CAP_MOVE_WAIT_LOCAL_BUSY;
} else {
/* Logical link is up or moving to BR/EDR,
* proceed with move
*/
chan->move_state = L2CAP_MOVE_WAIT_CONFIRM_RSP;
l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED);
}
break;
case L2CAP_MOVE_WAIT_RSP:
/* Moving to AMP */
if (result == L2CAP_MR_SUCCESS) {
/* Remote is ready, send confirm immediately
* after logical link is ready
*/
chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_CFM;
} else {
/* Both logical link and move success
* are required to confirm
*/
chan->move_state = L2CAP_MOVE_WAIT_LOGICAL_COMP;
}
/* Placeholder - get hci_chan for logical link */
if (!hchan) {
/* Logical link not available */
l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED);
break;
}
/* If the logical link is not yet connected, do not
* send confirmation.
*/
if (hchan->state != BT_CONNECTED)
break;
/* Logical link is already ready to go */
chan->hs_hcon = hchan->conn;
chan->hs_hcon->l2cap_data = chan->conn;
if (result == L2CAP_MR_SUCCESS) {
/* Can confirm now */
l2cap_send_move_chan_cfm(chan, L2CAP_MC_CONFIRMED);
} else {
/* Now only need move success
* to confirm
*/
chan->move_state = L2CAP_MOVE_WAIT_RSP_SUCCESS;
}
l2cap_logical_cfm(chan, hchan, L2CAP_MR_SUCCESS);
break;
default:
/* Any other amp move state means the move failed. */
chan->move_id = chan->local_amp_id;
l2cap_move_done(chan);
l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED);
}
l2cap_chan_unlock(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 279 | 100.00% | 2 | 100.00% |
| Total | 279 | 100.00% | 2 | 100.00% |
static void l2cap_move_fail(struct l2cap_conn *conn, u8 ident, u16 icid,
u16 result)
{
struct l2cap_chan *chan;
chan = l2cap_get_chan_by_ident(conn, ident);
if (!chan) {
/* Could not locate channel, icid is best guess */
l2cap_send_move_chan_cfm_icid(conn, icid);
return;
}
__clear_chan_timer(chan);
if (chan->move_role == L2CAP_MOVE_ROLE_INITIATOR) {
if (result == L2CAP_MR_COLLISION) {
chan->move_role = L2CAP_MOVE_ROLE_RESPONDER;
} else {
/* Cleanup - cancel move */
chan->move_id = chan->local_amp_id;
l2cap_move_done(chan);
}
}
l2cap_send_move_chan_cfm(chan, L2CAP_MC_UNCONFIRMED);
l2cap_chan_unlock(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 108 | 100.00% | 2 | 100.00% |
| Total | 108 | 100.00% | 2 | 100.00% |
static int l2cap_move_channel_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd,
u16 cmd_len, void *data)
{
struct l2cap_move_chan_rsp *rsp = data;
u16 icid, result;
if (cmd_len != sizeof(*rsp))
return -EPROTO;
icid = le16_to_cpu(rsp->icid);
result = le16_to_cpu(rsp->result);
BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result);
if (result == L2CAP_MR_SUCCESS || result == L2CAP_MR_PEND)
l2cap_move_continue(conn, icid, result);
else
l2cap_move_fail(conn, cmd->ident, icid, result);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 112 | 100.00% | 2 | 100.00% |
| Total | 112 | 100.00% | 2 | 100.00% |
static int l2cap_move_channel_confirm(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd,
u16 cmd_len, void *data)
{
struct l2cap_move_chan_cfm *cfm = data;
struct l2cap_chan *chan;
u16 icid, result;
if (cmd_len != sizeof(*cfm))
return -EPROTO;
icid = le16_to_cpu(cfm->icid);
result = le16_to_cpu(cfm->result);
BT_DBG("icid 0x%4.4x, result 0x%4.4x", icid, result);
chan = l2cap_get_chan_by_dcid(conn, icid);
if (!chan) {
/* Spec requires a response even if the icid was not found */
l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid);
return 0;
}
if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM) {
if (result == L2CAP_MC_CONFIRMED) {
chan->local_amp_id = chan->move_id;
if (chan->local_amp_id == AMP_ID_BREDR)
__release_logical_link(chan);
} else {
chan->move_id = chan->local_amp_id;
}
l2cap_move_done(chan);
}
l2cap_send_move_chan_cfm_rsp(conn, cmd->ident, icid);
l2cap_chan_unlock(chan);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 159 | 85.48% | 2 | 28.57% |
gustavo padovan | gustavo padovan | 12 | 6.45% | 1 | 14.29% |
linus torvalds | linus torvalds | 9 | 4.84% | 1 | 14.29% |
ville tervo | ville tervo | 3 | 1.61% | 1 | 14.29% |
marcel holtmann | marcel holtmann | 2 | 1.08% | 1 | 14.29% |
andrei emeltchenko | andrei emeltchenko | 1 | 0.54% | 1 | 14.29% |
| Total | 186 | 100.00% | 7 | 100.00% |
static inline int l2cap_move_channel_confirm_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd,
u16 cmd_len, void *data)
{
struct l2cap_move_chan_cfm_rsp *rsp = data;
struct l2cap_chan *chan;
u16 icid;
if (cmd_len != sizeof(*rsp))
return -EPROTO;
icid = le16_to_cpu(rsp->icid);
BT_DBG("icid 0x%4.4x", icid);
chan = l2cap_get_chan_by_scid(conn, icid);
if (!chan)
return 0;
__clear_chan_timer(chan);
if (chan->move_state == L2CAP_MOVE_WAIT_CONFIRM_RSP) {
chan->local_amp_id = chan->move_id;
if (chan->local_amp_id == AMP_ID_BREDR && chan->hs_hchan)
__release_logical_link(chan);
l2cap_move_done(chan);
}
l2cap_chan_unlock(chan);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 124 | 89.21% | 2 | 25.00% |
gustavo padovan | gustavo padovan | 8 | 5.76% | 2 | 25.00% |
marcel holtmann | marcel holtmann | 3 | 2.16% | 2 | 25.00% |
linus torvalds | linus torvalds | 3 | 2.16% | 1 | 12.50% |
andrei emeltchenko | andrei emeltchenko | 1 | 0.72% | 1 | 12.50% |
| Total | 139 | 100.00% | 8 | 100.00% |
static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd,
u16 cmd_len, u8 *data)
{
struct hci_conn *hcon = conn->hcon;
struct l2cap_conn_param_update_req *req;
struct l2cap_conn_param_update_rsp rsp;
u16 min, max, latency, to_multiplier;
int err;
if (hcon->role != HCI_ROLE_MASTER)
return -EINVAL;
if (cmd_len != sizeof(struct l2cap_conn_param_update_req))
return -EPROTO;
req = (struct l2cap_conn_param_update_req *) data;
min = __le16_to_cpu(req->min);
max = __le16_to_cpu(req->max);
latency = __le16_to_cpu(req->latency);
to_multiplier = __le16_to_cpu(req->to_multiplier);
BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x",
min, max, latency, to_multiplier);
memset(&rsp, 0, sizeof(rsp));
err = hci_check_conn_params(min, max, latency, to_multiplier);
if (err)
rsp.result = cpu_to_le16(L2CAP_CONN_PARAM_REJECTED);
else
rsp.result = cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED);
l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP,
sizeof(rsp), &rsp);
if (!err) {
u8 store_hint;
store_hint = hci_le_conn_update(hcon, min, max, latency,
to_multiplier);
mgmt_new_conn_param(hcon->hdev, &hcon->dst, hcon->dst_type,
store_hint, min, max, latency,
to_multiplier);
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
claudio takahasi | claudio takahasi | 215 | 82.69% | 2 | 25.00% |
johan hedberg | johan hedberg | 25 | 9.62% | 3 | 37.50% |
andre guedes | andre guedes | 18 | 6.92% | 2 | 25.00% |
joe perches | joe perches | 2 | 0.77% | 1 | 12.50% |
| Total | 260 | 100.00% | 8 | 100.00% |
static int l2cap_le_connect_rsp(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_le_conn_rsp *rsp = (struct l2cap_le_conn_rsp *) data;
struct hci_conn *hcon = conn->hcon;
u16 dcid, mtu, mps, credits, result;
struct l2cap_chan *chan;
int err, sec_level;
if (cmd_len < sizeof(*rsp))
return -EPROTO;
dcid = __le16_to_cpu(rsp->dcid);
mtu = __le16_to_cpu(rsp->mtu);
mps = __le16_to_cpu(rsp->mps);
credits = __le16_to_cpu(rsp->credits);
result = __le16_to_cpu(rsp->result);
if (result == L2CAP_CR_SUCCESS && (mtu < 23 || mps < 23 ||
dcid < L2CAP_CID_DYN_START ||
dcid > L2CAP_CID_LE_DYN_END))
return -EPROTO;
BT_DBG("dcid 0x%4.4x mtu %u mps %u credits %u result 0x%2.2x",
dcid, mtu, mps, credits, result);
mutex_lock(&conn->chan_lock);
chan = __l2cap_get_chan_by_ident(conn, cmd->ident);
if (!chan) {
err = -EBADSLT;
goto unlock;
}
err = 0;
l2cap_chan_lock(chan);
switch (result) {
case L2CAP_CR_SUCCESS:
if (__l2cap_get_chan_by_dcid(conn, dcid)) {
err = -EBADSLT;
break;
}
chan->ident = 0;
chan->dcid = dcid;
chan->omtu = mtu;
chan->remote_mps = mps;
chan->tx_credits = credits;
l2cap_chan_ready(chan);
break;
case L2CAP_CR_AUTHENTICATION:
case L2CAP_CR_ENCRYPTION:
/* If we already have MITM protection we can't do
* anything.
*/
if (hcon->sec_level > BT_SECURITY_MEDIUM) {
l2cap_chan_del(chan, ECONNREFUSED);
break;
}
sec_level = hcon->sec_level + 1;
if (chan->sec_level < sec_level)
chan->sec_level = sec_level;
/* We'll need to send a new Connect Request */
clear_bit(FLAG_LE_CONN_REQ_SENT, &chan->flags);
smp_conn_security(hcon, chan->sec_level);
break;
default:
l2cap_chan_del(chan, ECONNREFUSED);
break;
}
l2cap_chan_unlock(chan);
unlock:
mutex_unlock(&conn->chan_lock);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 367 | 100.00% | 4 | 100.00% |
| Total | 367 | 100.00% | 4 | 100.00% |
static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
int err = 0;
switch (cmd->code) {
case L2CAP_COMMAND_REJ:
l2cap_command_rej(conn, cmd, cmd_len, data);
break;
case L2CAP_CONN_REQ:
err = l2cap_connect_req(conn, cmd, cmd_len, data);
break;
case L2CAP_CONN_RSP:
case L2CAP_CREATE_CHAN_RSP:
l2cap_connect_create_rsp(conn, cmd, cmd_len, data);
break;
case L2CAP_CONF_REQ:
err = l2cap_config_req(conn, cmd, cmd_len, data);
break;
case L2CAP_CONF_RSP:
l2cap_config_rsp(conn, cmd, cmd_len, data);
break;
case L2CAP_DISCONN_REQ:
err = l2cap_disconnect_req(conn, cmd, cmd_len, data);
break;
case L2CAP_DISCONN_RSP:
l2cap_disconnect_rsp(conn, cmd, cmd_len, data);
break;
case L2CAP_ECHO_REQ:
l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data);
break;
case L2CAP_ECHO_RSP:
break;
case L2CAP_INFO_REQ:
err = l2cap_information_req(conn, cmd, cmd_len, data);
break;
case L2CAP_INFO_RSP:
l2cap_information_rsp(conn, cmd, cmd_len, data);
break;
case L2CAP_CREATE_CHAN_REQ:
err = l2cap_create_channel_req(conn, cmd, cmd_len, data);
break;
case L2CAP_MOVE_CHAN_REQ:
err = l2cap_move_channel_req(conn, cmd, cmd_len, data);
break;
case L2CAP_MOVE_CHAN_RSP:
l2cap_move_channel_rsp(conn, cmd, cmd_len, data);
break;
case L2CAP_MOVE_CHAN_CFM:
err = l2cap_move_channel_confirm(conn, cmd, cmd_len, data);
break;
case L2CAP_MOVE_CHAN_CFM_RSP:
l2cap_move_channel_confirm_rsp(conn, cmd, cmd_len, data);
break;
default:
BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code);
err = -EINVAL;
break;
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
gustavo padovan | gustavo padovan | 176 | 57.52% | 4 | 33.33% |
mat martineau | mat martineau | 65 | 21.24% | 4 | 33.33% |
maksim krasnyanskiy | maksim krasnyanskiy | 28 | 9.15% | 1 | 8.33% |
claudio takahasi | claudio takahasi | 18 | 5.88% | 1 | 8.33% |
johan hedberg | johan hedberg | 16 | 5.23% | 1 | 8.33% |
linus torvalds | linus torvalds | 3 | 0.98% | 1 | 8.33% |
| Total | 306 | 100.00% | 12 | 100.00% |
static int l2cap_le_connect_req(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_le_conn_req *req = (struct l2cap_le_conn_req *) data;
struct l2cap_le_conn_rsp rsp;
struct l2cap_chan *chan, *pchan;
u16 dcid, scid, credits, mtu, mps;
__le16 psm;
u8 result;
if (cmd_len != sizeof(*req))
return -EPROTO;
scid = __le16_to_cpu(req->scid);
mtu = __le16_to_cpu(req->mtu);
mps = __le16_to_cpu(req->mps);
psm = req->psm;
dcid = 0;
credits = 0;
if (mtu < 23 || mps < 23)
return -EPROTO;
BT_DBG("psm 0x%2.2x scid 0x%4.4x mtu %u mps %u", __le16_to_cpu(psm),
scid, mtu, mps);
/* Check if we have socket listening on psm */
pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, &conn->hcon->src,
&conn->hcon->dst, LE_LINK);
if (!pchan) {
result = L2CAP_CR_BAD_PSM;
chan = NULL;
goto response;
}
mutex_lock(&conn->chan_lock);
l2cap_chan_lock(pchan);
if (!smp_sufficient_security(conn->hcon, pchan->sec_level,
SMP_ALLOW_STK)) {
result = L2CAP_CR_AUTHENTICATION;
chan = NULL;
goto response_unlock;
}
/* Check for valid dynamic CID range */
if (scid < L2CAP_CID_DYN_START || scid > L2CAP_CID_LE_DYN_END) {
result = L2CAP_CR_INVALID_SCID;
chan = NULL;
goto response_unlock;
}
/* Check if we already have channel with that dcid */
if (__l2cap_get_chan_by_dcid(conn, scid)) {
result = L2CAP_CR_SCID_IN_USE;
chan = NULL;
goto response_unlock;
}
chan = pchan->ops->new_connection(pchan);
if (!chan) {
result = L2CAP_CR_NO_MEM;
goto response_unlock;
}
l2cap_le_flowctl_init(chan);
bacpy(&chan->src, &conn->hcon->src);
bacpy(&chan->dst, &conn->hcon->dst);
chan->src_type = bdaddr_src_type(conn->hcon);
chan->dst_type = bdaddr_dst_type(conn->hcon);
chan->psm = psm;
chan->dcid = scid;
chan->omtu = mtu;
chan->remote_mps = mps;
chan->tx_credits = __le16_to_cpu(req->credits);
__l2cap_chan_add(conn, chan);
dcid = chan->scid;
credits = chan->rx_credits;
__set_chan_timer(chan, chan->ops->get_sndtimeo(chan));
chan->ident = cmd->ident;
if (test_bit(FLAG_DEFER_SETUP, &chan->flags)) {
l2cap_state_change(chan, BT_CONNECT2);
/* The following result value is actually not defined
* for LE CoC but we use it to let the function know
* that it should bail out after doing its cleanup
* instead of sending a response.
*/
result = L2CAP_CR_PEND;
chan->ops->defer(chan);
} else {
l2cap_chan_ready(chan);
result = L2CAP_CR_SUCCESS;
}
response_unlock:
l2cap_chan_unlock(pchan);
mutex_unlock(&conn->chan_lock);
l2cap_chan_put(pchan);
if (result == L2CAP_CR_PEND)
return 0;
response:
if (chan) {
rsp.mtu = cpu_to_le16(chan->imtu);
rsp.mps = cpu_to_le16(chan->mps);
} else {
rsp.mtu = 0;
rsp.mps = 0;
}
rsp.dcid = cpu_to_le16(dcid);
rsp.credits = cpu_to_le16(credits);
rsp.result = cpu_to_le16(result);
l2cap_send_cmd(conn, cmd->ident, L2CAP_LE_CONN_RSP, sizeof(rsp), &rsp);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 592 | 97.05% | 10 | 90.91% |
claudio takahasi | claudio takahasi | 18 | 2.95% | 1 | 9.09% |
| Total | 610 | 100.00% | 11 | 100.00% |
static inline int l2cap_le_credits(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_le_credits *pkt;
struct l2cap_chan *chan;
u16 cid, credits, max_credits;
if (cmd_len != sizeof(*pkt))
return -EPROTO;
pkt = (struct l2cap_le_credits *) data;
cid = __le16_to_cpu(pkt->cid);
credits = __le16_to_cpu(pkt->credits);
BT_DBG("cid 0x%4.4x credits 0x%4.4x", cid, credits);
chan = l2cap_get_chan_by_dcid(conn, cid);
if (!chan)
return -EBADSLT;
max_credits = LE_FLOWCTL_MAX_CREDITS - chan->tx_credits;
if (credits > max_credits) {
BT_ERR("LE credits overflow");
l2cap_send_disconn_req(chan, ECONNRESET);
l2cap_chan_unlock(chan);
/* Return 0 so that we don't trigger an unnecessary
* command reject packet.
*/
return 0;
}
chan->tx_credits += credits;
while (chan->tx_credits && !skb_queue_empty(&chan->tx_q)) {
l2cap_do_send(chan, skb_dequeue(&chan->tx_q));
chan->tx_credits--;
}
if (chan->tx_credits)
chan->ops->resume(chan);
l2cap_chan_unlock(chan);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 205 | 97.62% | 2 | 66.67% |
martin townsend | martin townsend | 5 | 2.38% | 1 | 33.33% |
| Total | 210 | 100.00% | 3 | 100.00% |
static inline int l2cap_le_command_rej(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data;
struct l2cap_chan *chan;
if (cmd_len < sizeof(*rej))
return -EPROTO;
mutex_lock(&conn->chan_lock);
chan = __l2cap_get_chan_by_ident(conn, cmd->ident);
if (!chan)
goto done;
l2cap_chan_lock(chan);
l2cap_chan_del(chan, ECONNREFUSED);
l2cap_chan_unlock(chan);
done:
mutex_unlock(&conn->chan_lock);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 112 | 100.00% | 1 | 100.00% |
| Total | 112 | 100.00% | 1 | 100.00% |
static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn,
struct l2cap_cmd_hdr *cmd, u16 cmd_len,
u8 *data)
{
int err = 0;
switch (cmd->code) {
case L2CAP_COMMAND_REJ:
l2cap_le_command_rej(conn, cmd, cmd_len, data);
break;
case L2CAP_CONN_PARAM_UPDATE_REQ:
err = l2cap_conn_param_update_req(conn, cmd, cmd_len, data);
break;
case L2CAP_CONN_PARAM_UPDATE_RSP:
break;
case L2CAP_LE_CONN_RSP:
l2cap_le_connect_rsp(conn, cmd, cmd_len, data);
break;
case L2CAP_LE_CONN_REQ:
err = l2cap_le_connect_req(conn, cmd, cmd_len, data);
break;
case L2CAP_LE_CREDITS:
err = l2cap_le_credits(conn, cmd, cmd_len, data);
break;
case L2CAP_DISCONN_REQ:
err = l2cap_disconnect_req(conn, cmd, cmd_len, data);
break;
case L2CAP_DISCONN_RSP:
l2cap_disconnect_rsp(conn, cmd, cmd_len, data);
break;
default:
BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code);
err = -EINVAL;
break;
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 162 | 93.64% | 8 | 80.00% |
claudio takahasi | claudio takahasi | 11 | 6.36% | 2 | 20.00% |
| Total | 173 | 100.00% | 10 | 100.00% |
static inline void l2cap_le_sig_channel(struct l2cap_conn *conn,
struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct l2cap_cmd_hdr *cmd;
u16 len;
int err;
if (hcon->type != LE_LINK)
goto drop;
if (skb->len < L2CAP_CMD_HDR_SIZE)
goto drop;
cmd = (void *) skb->data;
skb_pull(skb, L2CAP_CMD_HDR_SIZE);
len = le16_to_cpu(cmd->len);
BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd->code, len, cmd->ident);
if (len != skb->len || !cmd->ident) {
BT_DBG("corrupted command");
goto drop;
}
err = l2cap_le_sig_cmd(conn, cmd, len, skb->data);
if (err) {
struct l2cap_cmd_rej_unk rej;
BT_ERR("Wrong link type (%d)", err);
rej.reason = cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD);
l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ,
sizeof(rej), &rej);
}
drop:
kfree_skb(skb);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 185 | 97.37% | 2 | 50.00% |
claudio takahasi | claudio takahasi | 4 | 2.11% | 1 | 25.00% |
joe perches | joe perches | 1 | 0.53% | 1 | 25.00% |
| Total | 190 | 100.00% | 4 | 100.00% |
static inline void l2cap_sig_channel(struct l2cap_conn *conn,
struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
u8 *data = skb->data;
int len = skb->len;
struct l2cap_cmd_hdr cmd;
int err;
l2cap_raw_recv(conn, skb);
if (hcon->type != ACL_LINK)
goto drop;
while (len >= L2CAP_CMD_HDR_SIZE) {
u16 cmd_len;
memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE);
data += L2CAP_CMD_HDR_SIZE;
len -= L2CAP_CMD_HDR_SIZE;
cmd_len = le16_to_cpu(cmd.len);
BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len,
cmd.ident);
if (cmd_len > len || !cmd.ident) {
BT_DBG("corrupted command");
break;
}
err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data);
if (err) {
struct l2cap_cmd_rej_unk rej;
BT_ERR("Wrong link type (%d)", err);
rej.reason = cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD);
l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ,
sizeof(rej), &rej);
}
data += cmd_len;
len -= cmd_len;
}
drop:
kfree_skb(skb);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 136 | 64.15% | 5 | 55.56% |
claudio takahasi | claudio takahasi | 67 | 31.60% | 1 | 11.11% |
marcel holtmann | marcel holtmann | 8 | 3.77% | 2 | 22.22% |
joe perches | joe perches | 1 | 0.47% | 1 | 11.11% |
| Total | 212 | 100.00% | 9 | 100.00% |
static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb)
{
u16 our_fcs, rcv_fcs;
int hdr_size;
if (test_bit(FLAG_EXT_CTRL, &chan->flags))
hdr_size = L2CAP_EXT_HDR_SIZE;
else
hdr_size = L2CAP_ENH_HDR_SIZE;
if (chan->fcs == L2CAP_FCS_CRC16) {
skb_trim(skb, skb->len - L2CAP_FCS_SIZE);
rcv_fcs = get_unaligned_le16(skb->data + skb->len);
our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size);
if (our_fcs != rcv_fcs)
return -EBADMSG;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 109 | 98.20% | 3 | 75.00% |
claudio takahasi | claudio takahasi | 2 | 1.80% | 1 | 25.00% |
| Total | 111 | 100.00% | 4 | 100.00% |
static void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan)
{
struct l2cap_ctrl control;
BT_DBG("chan %p", chan);
memset(&control, 0, sizeof(control));
control.sframe = 1;
control.final = 1;
control.reqseq = chan->buffer_seq;
set_bit(CONN_SEND_FBIT, &chan->conn_state);
if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
control.super = L2CAP_SUPER_RNR;
l2cap_send_sframe(chan, &control);
}
if (test_and_clear_bit(CONN_REMOTE_BUSY, &chan->conn_state) &&
chan->unacked_frames > 0)
__set_retrans_timer(chan);
/* Send pending iframes */
l2cap_ertm_send(chan);
if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) &&
test_bit(CONN_SEND_FBIT, &chan->conn_state)) {
/* F-bit wasn't sent in an s-frame or i-frame yet, so
* send it now.
*/
control.super = L2CAP_SUPER_RR;
l2cap_send_sframe(chan, &control);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 149 | 91.98% | 2 | 66.67% |
claudio takahasi | claudio takahasi | 13 | 8.02% | 1 | 33.33% |
| Total | 162 | 100.00% | 3 | 100.00% |
static void append_skb_frag(struct sk_buff *skb, struct sk_buff *new_frag,
struct sk_buff **last_frag)
{
/* skb->len reflects data in skb as well as all fragments
* skb->data_len reflects only data in fragments
*/
if (!skb_has_frag_list(skb))
skb_shinfo(skb)->frag_list = new_frag;
new_frag->next = NULL;
(*last_frag)->next = new_frag;
*last_frag = new_frag;
skb->len += new_frag->len;
skb->data_len += new_frag->len;
skb->truesize += new_frag->truesize;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 68 | 80.95% | 1 | 14.29% |
gustavo padovan | gustavo padovan | 8 | 9.52% | 4 | 57.14% |
maksim krasnyanskiy | maksim krasnyanskiy | 7 | 8.33% | 1 | 14.29% |
linus torvalds | linus torvalds | 1 | 1.19% | 1 | 14.29% |
| Total | 84 | 100.00% | 7 | 100.00% |
static int l2cap_reassemble_sdu(struct l2cap_chan *chan, struct sk_buff *skb,
struct l2cap_ctrl *control)
{
int err = -EINVAL;
switch (control->sar) {
case L2CAP_SAR_UNSEGMENTED:
if (chan->sdu)
break;
err = chan->ops->recv(chan, skb);
break;
case L2CAP_SAR_START:
if (chan->sdu)
break;
chan->sdu_len = get_unaligned_le16(skb->data);
skb_pull(skb, L2CAP_SDULEN_SIZE);
if (chan->sdu_len > chan->imtu) {
err = -EMSGSIZE;
break;
}
if (skb->len >= chan->sdu_len)
break;
chan->sdu = skb;
chan->sdu_last_frag = skb;
skb = NULL;
err = 0;
break;
case L2CAP_SAR_CONTINUE:
if (!chan->sdu)
break;
append_skb_frag(chan->sdu, skb,
&chan->sdu_last_frag);
skb = NULL;
if (chan->sdu->len >= chan->sdu_len)
break;
err = 0;
break;
case L2CAP_SAR_END:
if (!chan->sdu)
break;
append_skb_frag(chan->sdu, skb,
&chan->sdu_last_frag);
skb = NULL;
if (chan->sdu->len != chan->sdu_len)
break;
err = chan->ops->recv(chan, chan->sdu);
if (!err) {
/* Reassembly complete */
chan->sdu = NULL;
chan->sdu_last_frag = NULL;
chan->sdu_len = 0;
}
break;
}
if (err) {
kfree_skb(skb);
kfree_skb(chan->sdu);
chan->sdu = NULL;
chan->sdu_last_frag = NULL;
chan->sdu_len = 0;
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 188 | 61.24% | 1 | 5.88% |
gustavo f. padovan | gustavo f. padovan | 39 | 12.70% | 7 | 41.18% |
mat martineau | mat martineau | 32 | 10.42% | 2 | 11.76% |
gustavo padovan | gustavo padovan | 29 | 9.45% | 2 | 11.76% |
andrei emeltchenko | andrei emeltchenko | 8 | 2.61% | 3 | 17.65% |
linus torvalds | linus torvalds | 7 | 2.28% | 1 | 5.88% |
maksim krasnyanskiy | maksim krasnyanskiy | 4 | 1.30% | 1 | 5.88% |
| Total | 307 | 100.00% | 17 | 100.00% |
static int l2cap_resegment(struct l2cap_chan *chan)
{
/* Placeholder */
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 15 | 100.00% | 1 | 100.00% |
| Total | 15 | 100.00% | 1 | 100.00% |
void l2cap_chan_busy(struct l2cap_chan *chan, int busy)
{
u8 event;
if (chan->mode != L2CAP_MODE_ERTM)
return;
event = busy ? L2CAP_EV_LOCAL_BUSY_DETECTED : L2CAP_EV_LOCAL_BUSY_CLEAR;
l2cap_tx(chan, NULL, NULL, event);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 40 | 90.91% | 1 | 50.00% |
mat martineau | mat martineau | 4 | 9.09% | 1 | 50.00% |
| Total | 44 | 100.00% | 2 | 100.00% |
static int l2cap_rx_queued_iframes(struct l2cap_chan *chan)
{
int err = 0;
/* Pass sequential frames to l2cap_reassemble_sdu()
* until a gap is encountered.
*/
BT_DBG("chan %p", chan);
while (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
struct sk_buff *skb;
BT_DBG("Searching for skb with txseq %d (queue len %d)",
chan->buffer_seq, skb_queue_len(&chan->srej_q));
skb = l2cap_ertm_seq_in_queue(&chan->srej_q, chan->buffer_seq);
if (!skb)
break;
skb_unlink(skb, &chan->srej_q);
chan->buffer_seq = __next_seq(chan, chan->buffer_seq);
err = l2cap_reassemble_sdu(chan, skb, &bt_cb(skb)->l2cap);
if (err)
break;
}
if (skb_queue_empty(&chan->srej_q)) {
chan->rx_state = L2CAP_RX_STATE_RECV;
l2cap_send_ack(chan);
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 93 | 61.18% | 2 | 22.22% |
gustavo f. padovan | gustavo f. padovan | 37 | 24.34% | 4 | 44.44% |
mat martineau | mat martineau | 20 | 13.16% | 2 | 22.22% |
marcel holtmann | marcel holtmann | 2 | 1.32% | 1 | 11.11% |
| Total | 152 | 100.00% | 9 | 100.00% |
static void l2cap_handle_srej(struct l2cap_chan *chan,
struct l2cap_ctrl *control)
{
struct sk_buff *skb;
BT_DBG("chan %p, control %p", chan, control);
if (control->reqseq == chan->next_tx_seq) {
BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq);
l2cap_send_disconn_req(chan, ECONNRESET);
return;
}
skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq);
if (skb == NULL) {
BT_DBG("Seq %d not available for retransmission",
control->reqseq);
return;
}
if (chan->max_tx != 0 && bt_cb(skb)->l2cap.retries >= chan->max_tx) {
BT_DBG("Retry limit exceeded (%d)", chan->max_tx);
l2cap_send_disconn_req(chan, ECONNRESET);
return;
}
clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
if (control->poll) {
l2cap_pass_to_tx(chan, control);
set_bit(CONN_SEND_FBIT, &chan->conn_state);
l2cap_retransmit(chan, control);
l2cap_ertm_send(chan);
if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) {
set_bit(CONN_SREJ_ACT, &chan->conn_state);
chan->srej_save_reqseq = control->reqseq;
}
} else {
l2cap_pass_to_tx_fbit(chan, control);
if (control->final) {
if (chan->srej_save_reqseq != control->reqseq ||
!test_and_clear_bit(CONN_SREJ_ACT,
&chan->conn_state))
l2cap_retransmit(chan, control);
} else {
l2cap_retransmit(chan, control);
if (chan->tx_state == L2CAP_TX_STATE_WAIT_F) {
set_bit(CONN_SREJ_ACT, &chan->conn_state);
chan->srej_save_reqseq = control->reqseq;
}
}
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 202 | 69.66% | 2 | 11.76% |
gustavo f. padovan | gustavo f. padovan | 59 | 20.34% | 9 | 52.94% |
mat martineau | mat martineau | 24 | 8.28% | 3 | 17.65% |
gustavo padovan | gustavo padovan | 3 | 1.03% | 1 | 5.88% |
marcel holtmann | marcel holtmann | 2 | 0.69% | 2 | 11.76% |
| Total | 290 | 100.00% | 17 | 100.00% |
static void l2cap_handle_rej(struct l2cap_chan *chan,
struct l2cap_ctrl *control)
{
struct sk_buff *skb;
BT_DBG("chan %p, control %p", chan, control);
if (control->reqseq == chan->next_tx_seq) {
BT_DBG("Invalid reqseq %d, disconnecting", control->reqseq);
l2cap_send_disconn_req(chan, ECONNRESET);
return;
}
skb = l2cap_ertm_seq_in_queue(&chan->tx_q, control->reqseq);
if (chan->max_tx && skb &&
bt_cb(skb)->l2cap.retries >= chan->max_tx) {
BT_DBG("Retry limit exceeded (%d)", chan->max_tx);
l2cap_send_disconn_req(chan, ECONNRESET);
return;
}
clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
l2cap_pass_to_tx(chan, control);
if (control->final) {
if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state))
l2cap_retransmit_all(chan, control);
} else {
l2cap_retransmit_all(chan, control);
l2cap_ertm_send(chan);
if (chan->tx_state == L2CAP_TX_STATE_WAIT_F)
set_bit(CONN_REJ_ACT, &chan->conn_state);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 102 | 53.40% | 2 | 40.00% |
mat martineau | mat martineau | 89 | 46.60% | 3 | 60.00% |
| Total | 191 | 100.00% | 5 | 100.00% |
static u8 l2cap_classify_txseq(struct l2cap_chan *chan, u16 txseq)
{
BT_DBG("chan %p, txseq %d", chan, txseq);
BT_DBG("last_acked_seq %d, expected_tx_seq %d", chan->last_acked_seq,
chan->expected_tx_seq);
if (chan->rx_state == L2CAP_RX_STATE_SREJ_SENT) {
if (__seq_offset(chan, txseq, chan->last_acked_seq) >=
chan->tx_win) {
/* See notes below regarding "double poll" and
* invalid packets.
*/
if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) {
BT_DBG("Invalid/Ignore - after SREJ");
return L2CAP_TXSEQ_INVALID_IGNORE;
} else {
BT_DBG("Invalid - in window after SREJ sent");
return L2CAP_TXSEQ_INVALID;
}
}
if (chan->srej_list.head == txseq) {
BT_DBG("Expected SREJ");
return L2CAP_TXSEQ_EXPECTED_SREJ;
}
if (l2cap_ertm_seq_in_queue(&chan->srej_q, txseq)) {
BT_DBG("Duplicate SREJ - txseq already stored");
return L2CAP_TXSEQ_DUPLICATE_SREJ;
}
if (l2cap_seq_list_contains(&chan->srej_list, txseq)) {
BT_DBG("Unexpected SREJ - not requested");
return L2CAP_TXSEQ_UNEXPECTED_SREJ;
}
}
if (chan->expected_tx_seq == txseq) {
if (__seq_offset(chan, txseq, chan->last_acked_seq) >=
chan->tx_win) {
BT_DBG("Invalid - txseq outside tx window");
return L2CAP_TXSEQ_INVALID;
} else {
BT_DBG("Expected");
return L2CAP_TXSEQ_EXPECTED;
}
}
if (__seq_offset(chan, txseq, chan->last_acked_seq) <
__seq_offset(chan, chan->expected_tx_seq, chan->last_acked_seq)) {
BT_DBG("Duplicate - expected_tx_seq later than txseq");
return L2CAP_TXSEQ_DUPLICATE;
}
if (__seq_offset(chan, txseq, chan->last_acked_seq) >= chan->tx_win) {
/* A source of invalid packets is a "double poll" condition,
* where delays cause us to send multiple poll packets. If
* the remote stack receives and processes both polls,
* sequence numbers can wrap around in such a way that a
* resent frame has a sequence number that looks like new data
* with a sequence gap. This would trigger an erroneous SREJ
* request.
*
* Fortunately, this is impossible with a tx window that's
* less than half of the maximum sequence number, which allows
* invalid frames to be safely ignored.
*
* With tx window sizes greater than half of the tx window
* maximum, the frame is invalid and cannot be ignored. This
* causes a disconnect.
*/
if (chan->tx_win <= ((chan->tx_win_max + 1) >> 1)) {
BT_DBG("Invalid/Ignore - txseq outside tx window");
return L2CAP_TXSEQ_INVALID_IGNORE;
} else {
BT_DBG("Invalid - txseq outside tx window");
return L2CAP_TXSEQ_INVALID;
}
} else {
BT_DBG("Unexpected - txseq indicates missing frames");
return L2CAP_TXSEQ_UNEXPECTED;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 208 | 64.40% | 1 | 33.33% |
mat martineau | mat martineau | 115 | 35.60% | 2 | 66.67% |
| Total | 323 | 100.00% | 3 | 100.00% |
static int l2cap_rx_state_recv(struct l2cap_chan *chan,
struct l2cap_ctrl *control,
struct sk_buff *skb, u8 event)
{
int err = 0;
bool skb_in_use = false;
BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb,
event);
switch (event) {
case L2CAP_EV_RECV_IFRAME:
switch (l2cap_classify_txseq(chan, control->txseq)) {
case L2CAP_TXSEQ_EXPECTED:
l2cap_pass_to_tx(chan, control);
if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
BT_DBG("Busy, discarding expected seq %d",
control->txseq);
break;
}
chan->expected_tx_seq = __next_seq(chan,
control->txseq);
chan->buffer_seq = chan->expected_tx_seq;
skb_in_use = true;
err = l2cap_reassemble_sdu(chan, skb, control);
if (err)
break;
if (control->final) {
if (!test_and_clear_bit(CONN_REJ_ACT,
&chan->conn_state)) {
control->final = 0;
l2cap_retransmit_all(chan, control);
l2cap_ertm_send(chan);
}
}
if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state))
l2cap_send_ack(chan);
break;
case L2CAP_TXSEQ_UNEXPECTED:
l2cap_pass_to_tx(chan, control);
/* Can't issue SREJ frames in the local busy state.
* Drop this frame, it will be seen as missing
* when local busy is exited.
*/
if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
BT_DBG("Busy, discarding unexpected seq %d",
control->txseq);
break;
}
/* There was a gap in the sequence, so an SREJ
* must be sent for each missing frame. The
* current frame is stored for later use.
*/
skb_queue_tail(&chan->srej_q, skb);
skb_in_use = true;
BT_DBG("Queued %p (queue len %d)", skb,
skb_queue_len(&chan->srej_q));
clear_bit(CONN_SREJ_ACT, &chan->conn_state);
l2cap_seq_list_clear(&chan->srej_list);
l2cap_send_srej(chan, control->txseq);
chan->rx_state = L2CAP_RX_STATE_SREJ_SENT;
break;
case L2CAP_TXSEQ_DUPLICATE:
l2cap_pass_to_tx(chan, control);
break;
case L2CAP_TXSEQ_INVALID_IGNORE:
break;
case L2CAP_TXSEQ_INVALID:
default:
l2cap_send_disconn_req(chan, ECONNRESET);
break;
}
break;
case L2CAP_EV_RECV_RR:
l2cap_pass_to_tx(chan, control);
if (control->final) {
clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state) &&
!__chan_is_moving(chan)) {
control->final = 0;
l2cap_retransmit_all(chan, control);
}
l2cap_ertm_send(chan);
} else if (control->poll) {
l2cap_send_i_or_rr_or_rnr(chan);
} else {
if (test_and_clear_bit(CONN_REMOTE_BUSY,
&chan->conn_state) &&
chan->unacked_frames)
__set_retrans_timer(chan);
l2cap_ertm_send(chan);
}
break;
case L2CAP_EV_RECV_RNR:
set_bit(CONN_REMOTE_BUSY, &chan->conn_state);
l2cap_pass_to_tx(chan, control);
if (control && control->poll) {
set_bit(CONN_SEND_FBIT, &chan->conn_state);
l2cap_send_rr_or_rnr(chan, 0);
}
__clear_retrans_timer(chan);
l2cap_seq_list_clear(&chan->retrans_list);
break;
case L2CAP_EV_RECV_REJ:
l2cap_handle_rej(chan, control);
break;
case L2CAP_EV_RECV_SREJ:
l2cap_handle_srej(chan, control);
break;
default:
break;
}
if (skb && !skb_in_use) {
BT_DBG("Freeing %p", skb);
kfree_skb(skb);
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 324 | 58.80% | 1 | 20.00% |
mat martineau | mat martineau | 227 | 41.20% | 4 | 80.00% |
| Total | 551 | 100.00% | 5 | 100.00% |
static int l2cap_rx_state_srej_sent(struct l2cap_chan *chan,
struct l2cap_ctrl *control,
struct sk_buff *skb, u8 event)
{
int err = 0;
u16 txseq = control->txseq;
bool skb_in_use = false;
BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb,
event);
switch (event) {
case L2CAP_EV_RECV_IFRAME:
switch (l2cap_classify_txseq(chan, txseq)) {
case L2CAP_TXSEQ_EXPECTED:
/* Keep frame for reassembly later */
l2cap_pass_to_tx(chan, control);
skb_queue_tail(&chan->srej_q, skb);
skb_in_use = true;
BT_DBG("Queued %p (queue len %d)", skb,
skb_queue_len(&chan->srej_q));
chan->expected_tx_seq = __next_seq(chan, txseq);
break;
case L2CAP_TXSEQ_EXPECTED_SREJ:
l2cap_seq_list_pop(&chan->srej_list);
l2cap_pass_to_tx(chan, control);
skb_queue_tail(&chan->srej_q, skb);
skb_in_use = true;
BT_DBG("Queued %p (queue len %d)", skb,
skb_queue_len(&chan->srej_q));
err = l2cap_rx_queued_iframes(chan);
if (err)
break;
break;
case L2CAP_TXSEQ_UNEXPECTED:
/* Got a frame that can't be reassembled yet.
* Save it for later, and send SREJs to cover
* the missing frames.
*/
skb_queue_tail(&chan->srej_q, skb);
skb_in_use = true;
BT_DBG("Queued %p (queue len %d)", skb,
skb_queue_len(&chan->srej_q));
l2cap_pass_to_tx(chan, control);
l2cap_send_srej(chan, control->txseq);
break;
case L2CAP_TXSEQ_UNEXPECTED_SREJ:
/* This frame was requested with an SREJ, but
* some expected retransmitted frames are
* missing. Request retransmission of missing
* SREJ'd frames.
*/
skb_queue_tail(&chan->srej_q, skb);
skb_in_use = true;
BT_DBG("Queued %p (queue len %d)", skb,
skb_queue_len(&chan->srej_q));
l2cap_pass_to_tx(chan, control);
l2cap_send_srej_list(chan, control->txseq);
break;
case L2CAP_TXSEQ_DUPLICATE_SREJ:
/* We've already queued this frame. Drop this copy. */
l2cap_pass_to_tx(chan, control);
break;
case L2CAP_TXSEQ_DUPLICATE:
/* Expecting a later sequence number, so this frame
* was already received. Ignore it completely.
*/
break;
case L2CAP_TXSEQ_INVALID_IGNORE:
break;
case L2CAP_TXSEQ_INVALID:
default:
l2cap_send_disconn_req(chan, ECONNRESET);
break;
}
break;
case L2CAP_EV_RECV_RR:
l2cap_pass_to_tx(chan, control);
if (control->final) {
clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
if (!test_and_clear_bit(CONN_REJ_ACT,
&chan->conn_state)) {
control->final = 0;
l2cap_retransmit_all(chan, control);
}
l2cap_ertm_send(chan);
} else if (control->poll) {
if (test_and_clear_bit(CONN_REMOTE_BUSY,
&chan->conn_state) &&
chan->unacked_frames) {
__set_retrans_timer(chan);
}
set_bit(CONN_SEND_FBIT, &chan->conn_state);
l2cap_send_srej_tail(chan);
} else {
if (test_and_clear_bit(CONN_REMOTE_BUSY,
&chan->conn_state) &&
chan->unacked_frames)
__set_retrans_timer(chan);
l2cap_send_ack(chan);
}
break;
case L2CAP_EV_RECV_RNR:
set_bit(CONN_REMOTE_BUSY, &chan->conn_state);
l2cap_pass_to_tx(chan, control);
if (control->poll) {
l2cap_send_srej_tail(chan);
} else {
struct l2cap_ctrl rr_control;
memset(&rr_control, 0, sizeof(rr_control));
rr_control.sframe = 1;
rr_control.super = L2CAP_SUPER_RR;
rr_control.reqseq = chan->buffer_seq;
l2cap_send_sframe(chan, &rr_control);
}
break;
case L2CAP_EV_RECV_REJ:
l2cap_handle_rej(chan, control);
break;
case L2CAP_EV_RECV_SREJ:
l2cap_handle_srej(chan, control);
break;
}
if (skb && !skb_in_use) {
BT_DBG("Freeing %p", skb);
kfree_skb(skb);
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 404 | 68.94% | 2 | 50.00% |
johan hedberg | johan hedberg | 180 | 30.72% | 1 | 25.00% |
peter senna tschudin | peter senna tschudin | 2 | 0.34% | 1 | 25.00% |
| Total | 586 | 100.00% | 4 | 100.00% |
static int l2cap_finish_move(struct l2cap_chan *chan)
{
BT_DBG("chan %p", chan);
chan->rx_state = L2CAP_RX_STATE_RECV;
if (chan->hs_hcon)
chan->conn->mtu = chan->hs_hcon->hdev->block_mtu;
else
chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu;
return l2cap_resegment(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
mat martineau | mat martineau | 36 | 53.73% | 1 | 50.00% |
johan hedberg | johan hedberg | 31 | 46.27% | 1 | 50.00% |
| Total | 67 | 100.00% | 2 | 100.00% |
static int l2cap_rx_state_wait_p(struct l2cap_chan *chan,
struct l2cap_ctrl *control,
struct sk_buff *skb, u8 event)
{
int err;
BT_DBG("chan %p, control %p, skb %p, event %d", chan, control, skb,
event);
if (!control->poll)
return -EPROTO;
l2cap_process_reqseq(chan, control->reqseq);
if (!skb_queue_empty(&chan->tx_q))
chan->tx_send_head = skb_peek(&chan->tx_q);
else
chan->tx_send_head = NULL;
/* Rewind next_tx_seq to the point expected
* by the receiver.
*/
chan->next_tx_seq = control->reqseq;
chan->unacked_frames = 0;
err = l2cap_finish_move(chan);
if (err)
return err;
set_bit(CONN_SEND_FBIT, &chan->conn_state);
l2cap_send_i_or_rr_or_rnr(chan);
if (event == L2CAP_EV_RECV_IFRAME)
return -EPROTO;
return l2cap_rx_state_recv(chan, control, NULL, event);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 108 | 69.23% | 1 | 50.00% |
mat martineau | mat martineau | 48 | 30.77% | 1 | 50.00% |
| Total | 156 | 100.00% | 2 | 100.00% |
static int l2cap_rx_state_wait_f(struct l2cap_chan *chan,
struct l2cap_ctrl *control,
struct sk_buff *skb, u8 event)
{
int err;
if (!control->final)
return -EPROTO;
clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
chan->rx_state = L2CAP_RX_STATE_RECV;
l2cap_process_reqseq(chan, control->reqseq);
if (!skb_queue_empty(&chan->tx_q))
chan->tx_send_head = skb_peek(&chan->tx_q);
else
chan->tx_send_head = NULL;
/* Rewind next_tx_seq to the point expected
* by the receiver.
*/
chan->next_tx_seq = control->reqseq;
chan->unacked_frames = 0;
if (chan->hs_hcon)
chan->conn->mtu = chan->hs_hcon->hdev->block_mtu;
else
chan->conn->mtu = chan->conn->hcon->hdev->acl_mtu;
err = l2cap_resegment(chan);
if (!err)
err = l2cap_rx_state_recv(chan, control, skb, event);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 120 | 69.36% | 1 | 50.00% |
mat martineau | mat martineau | 53 | 30.64% | 1 | 50.00% |
| Total | 173 | 100.00% | 2 | 100.00% |
static bool __valid_reqseq(struct l2cap_chan *chan, u16 reqseq)
{
/* Make sure reqseq is for a packet that has been sent but not acked */
u16 unacked;
unacked = __seq_offset(chan, chan->next_tx_seq, chan->expected_ack_seq);
return __seq_offset(chan, chan->next_tx_seq, reqseq) <= unacked;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 30 | 63.83% | 1 | 50.00% |
mat martineau | mat martineau | 17 | 36.17% | 1 | 50.00% |
| Total | 47 | 100.00% | 2 | 100.00% |
static int l2cap_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control,
struct sk_buff *skb, u8 event)
{
int err = 0;
BT_DBG("chan %p, control %p, skb %p, event %d, state %d", chan,
control, skb, event, chan->rx_state);
if (__valid_reqseq(chan, control->reqseq)) {
switch (chan->rx_state) {
case L2CAP_RX_STATE_RECV:
err = l2cap_rx_state_recv(chan, control, skb, event);
break;
case L2CAP_RX_STATE_SREJ_SENT:
err = l2cap_rx_state_srej_sent(chan, control, skb,
event);
break;
case L2CAP_RX_STATE_WAIT_P:
err = l2cap_rx_state_wait_p(chan, control, skb, event);
break;
case L2CAP_RX_STATE_WAIT_F:
err = l2cap_rx_state_wait_f(chan, control, skb, event);
break;
default:
/* shut it down */
break;
}
} else {
BT_DBG("Invalid reqseq %d (next_tx_seq %d, expected_ack_seq %d",
control->reqseq, chan->next_tx_seq,
chan->expected_ack_seq);
l2cap_send_disconn_req(chan, ECONNRESET);
}
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 111 | 66.07% | 1 | 33.33% |
mat martineau | mat martineau | 57 | 33.93% | 2 | 66.67% |
| Total | 168 | 100.00% | 3 | 100.00% |
static int l2cap_stream_rx(struct l2cap_chan *chan, struct l2cap_ctrl *control,
struct sk_buff *skb)
{
BT_DBG("chan %p, control %p, skb %p, state %d", chan, control, skb,
chan->rx_state);
if (l2cap_classify_txseq(chan, control->txseq) ==
L2CAP_TXSEQ_EXPECTED) {
l2cap_pass_to_tx(chan, control);
BT_DBG("buffer_seq %d->%d", chan->buffer_seq,
__next_seq(chan, chan->buffer_seq));
chan->buffer_seq = __next_seq(chan, chan->buffer_seq);
l2cap_reassemble_sdu(chan, skb, control);
} else {
if (chan->sdu) {
kfree_skb(chan->sdu);
chan->sdu = NULL;
}
chan->sdu_last_frag = NULL;
chan->sdu_len = 0;
if (skb) {
BT_DBG("Freeing %p", skb);
kfree_skb(skb);
}
}
chan->last_acked_seq = control->txseq;
chan->expected_tx_seq = __next_seq(chan, control->txseq);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 90 | 51.14% | 1 | 33.33% |
mat martineau | mat martineau | 85 | 48.30% | 1 | 33.33% |
prasanna karthik | prasanna karthik | 1 | 0.57% | 1 | 33.33% |
| Total | 176 | 100.00% | 3 | 100.00% |
static int l2cap_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb)
{
struct l2cap_ctrl *control = &bt_cb(skb)->l2cap;
u16 len;
u8 event;
__unpack_control(chan, skb);
len = skb->len;
/*
* We can just drop the corrupted I-frame here.
* Receiver will miss it and start proper recovery
* procedures and ask for retransmission.
*/
if (l2cap_check_fcs(chan, skb))
goto drop;
if (!control->sframe && control->sar == L2CAP_SAR_START)
len -= L2CAP_SDULEN_SIZE;
if (chan->fcs == L2CAP_FCS_CRC16)
len -= L2CAP_FCS_SIZE;
if (len > chan->mps) {
l2cap_send_disconn_req(chan, ECONNRESET);
goto drop;
}
if (!control->sframe) {
int err;
BT_DBG("iframe sar %d, reqseq %d, final %d, txseq %d",
control->sar, control->reqseq, control->final,
control->txseq);
/* Validate F-bit - F=0 always valid, F=1 only
* valid in TX WAIT_F
*/
if (control->final && chan->tx_state != L2CAP_TX_STATE_WAIT_F)
goto drop;
if (chan->mode != L2CAP_MODE_STREAMING) {
event = L2CAP_EV_RECV_IFRAME;
err = l2cap_rx(chan, control, skb, event);
} else {
err = l2cap_stream_rx(chan, control, skb);
}
if (err)
l2cap_send_disconn_req(chan, ECONNRESET);
} else {
const u8 rx_func_to_event[4] = {
L2CAP_EV_RECV_RR, L2CAP_EV_RECV_REJ,
L2CAP_EV_RECV_RNR, L2CAP_EV_RECV_SREJ
};
/* Only I-frames are expected in streaming mode */
if (chan->mode == L2CAP_MODE_STREAMING)
goto drop;
BT_DBG("sframe reqseq %d, final %d, poll %d, super %d",
control->reqseq, control->final, control->poll,
control->super);
if (len != 0) {
BT_ERR("Trailing bytes: %d in sframe", len);
l2cap_send_disconn_req(chan, ECONNRESET);
goto drop;
}
/* Validate F and P bits */
if (control->final && (control->poll ||
chan->tx_state != L2CAP_TX_STATE_WAIT_F))
goto drop;
event = rx_func_to_event[control->super];
if (l2cap_rx(chan, control, skb, event))
l2cap_send_disconn_req(chan, ECONNRESET);
}
return 0;
drop:
kfree_skb(skb);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 272 | 77.05% | 2 | 66.67% |
mat martineau | mat martineau | 81 | 22.95% | 1 | 33.33% |
| Total | 353 | 100.00% | 3 | 100.00% |
static void l2cap_chan_le_send_credits(struct l2cap_chan *chan)
{
struct l2cap_conn *conn = chan->conn;
struct l2cap_le_credits pkt;
u16 return_credits;
/* We return more credits to the sender only after the amount of
* credits falls below half of the initial amount.
*/
if (chan->rx_credits >= (le_max_credits + 1) / 2)
return;
return_credits = le_max_credits - chan->rx_credits;
BT_DBG("chan %p returning %u credits to sender", chan, return_credits);
chan->rx_credits += return_credits;
pkt.cid = cpu_to_le16(chan->scid);
pkt.credits = cpu_to_le16(return_credits);
chan->ident = l2cap_get_ident(conn);
l2cap_send_cmd(conn, chan->ident, L2CAP_LE_CREDITS, sizeof(pkt), &pkt);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 86 | 75.44% | 1 | 50.00% |
mat martineau | mat martineau | 28 | 24.56% | 1 | 50.00% |
| Total | 114 | 100.00% | 2 | 100.00% |
static int l2cap_le_data_rcv(struct l2cap_chan *chan, struct sk_buff *skb)
{
int err;
if (!chan->rx_credits) {
BT_ERR("No credits to receive LE L2CAP data");
l2cap_send_disconn_req(chan, ECONNRESET);
return -ENOBUFS;
}
if (chan->imtu < skb->len) {
BT_ERR("Too big LE L2CAP PDU");
return -ENOBUFS;
}
chan->rx_credits--;
BT_DBG("rx_credits %u -> %u", chan->rx_credits + 1, chan->rx_credits);
l2cap_chan_le_send_credits(chan);
err = 0;
if (!chan->sdu) {
u16 sdu_len;
sdu_len = get_unaligned_le16(skb->data);
skb_pull(skb, L2CAP_SDULEN_SIZE);
BT_DBG("Start of new SDU. sdu_len %u skb->len %u imtu %u",
sdu_len, skb->len, chan->imtu);
if (sdu_len > chan->imtu) {
BT_ERR("Too big LE L2CAP SDU length received");
err = -EMSGSIZE;
goto failed;
}
if (skb->len > sdu_len) {
BT_ERR("Too much LE L2CAP data received");
err = -EINVAL;
goto failed;
}
if (skb->len == sdu_len)
return chan->ops->recv(chan, skb);
chan->sdu = skb;
chan->sdu_len = sdu_len;
chan->sdu_last_frag = skb;
return 0;
}
BT_DBG("SDU fragment. chan->sdu->len %u skb->len %u chan->sdu_len %u",
chan->sdu->len, skb->len, chan->sdu_len);
if (chan->sdu->len + skb->len > chan->sdu_len) {
BT_ERR("Too much LE L2CAP data received");
err = -EINVAL;
goto failed;
}
append_skb_frag(chan->sdu, skb, &chan->sdu_last_frag);
skb = NULL;
if (chan->sdu->len == chan->sdu_len) {
err = chan->ops->recv(chan, chan->sdu);
if (!err) {
chan->sdu = NULL;
chan->sdu_last_frag = NULL;
chan->sdu_len = 0;
}
}
failed:
if (err) {
kfree_skb(skb);
kfree_skb(chan->sdu);
chan->sdu = NULL;
chan->sdu_last_frag = NULL;
chan->sdu_len = 0;
}
/* We can't return an error here since we took care of the skb
* freeing internally. An error return would cause the caller to
* do a double-free of the skb.
*/
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 229 | 59.02% | 2 | 33.33% |
mat martineau | mat martineau | 159 | 40.98% | 4 | 66.67% |
| Total | 388 | 100.00% | 6 | 100.00% |
static void l2cap_data_channel(struct l2cap_conn *conn, u16 cid,
struct sk_buff *skb)
{
struct l2cap_chan *chan;
chan = l2cap_get_chan_by_scid(conn, cid);
if (!chan) {
if (cid == L2CAP_CID_A2MP) {
chan = a2mp_channel_create(conn, skb);
if (!chan) {
kfree_skb(skb);
return;
}
l2cap_chan_lock(chan);
} else {
BT_DBG("unknown cid 0x%4.4x", cid);
/* Drop packet and return */
kfree_skb(skb);
return;
}
}
BT_DBG("chan %p, len %d", chan, skb->len);
/* If we receive data on a fixed channel before the info req/rsp
* procdure is done simply assume that the channel is supported
* and mark it as ready.
*/
if (chan->chan_type == L2CAP_CHAN_FIXED)
l2cap_chan_ready(chan);
if (chan->state != BT_CONNECTED)
goto drop;
switch (chan->mode) {
case L2CAP_MODE_LE_FLOWCTL:
if (l2cap_le_data_rcv(chan, skb) < 0)
goto drop;
goto done;
case L2CAP_MODE_BASIC:
/* If socket recv buffers overflows we drop data here
* which is *bad* because L2CAP has to be reliable.
* But we don't have any other choice. L2CAP doesn't
* provide flow control mechanism. */
if (chan->imtu < skb->len) {
BT_ERR("Dropping L2CAP data: receive buffer overflow");
goto drop;
}
if (!chan->ops->recv(chan, skb))
goto done;
break;
case L2CAP_MODE_ERTM:
case L2CAP_MODE_STREAMING:
l2cap_data_rcv(chan, skb);
goto done;
default:
BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode);
break;
}
drop:
kfree_skb(skb);
done:
l2cap_chan_unlock(chan);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 155 | 64.32% | 2 | 11.76% |
mat martineau | mat martineau | 36 | 14.94% | 2 | 11.76% |
gustavo f. padovan | gustavo f. padovan | 17 | 7.05% | 5 | 29.41% |
gustavo padovan | gustavo padovan | 15 | 6.22% | 3 | 17.65% |
szymon janc | szymon janc | 7 | 2.90% | 1 | 5.88% |
joao paulo rechi vita | joao paulo rechi vita | 6 | 2.49% | 1 | 5.88% |
andrei emeltchenko | andrei emeltchenko | 5 | 2.07% | 3 | 17.65% |
| Total | 241 | 100.00% | 17 | 100.00% |
static void l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm,
struct sk_buff *skb)
{
struct hci_conn *hcon = conn->hcon;
struct l2cap_chan *chan;
if (hcon->type != ACL_LINK)
goto free_skb;
chan = l2cap_global_chan_by_psm(0, psm, &hcon->src, &hcon->dst,
ACL_LINK);
if (!chan)
goto free_skb;
BT_DBG("chan %p, len %d", chan, skb->len);
if (chan->state != BT_BOUND && chan->state != BT_CONNECTED)
goto drop;
if (chan->imtu < skb->len)
goto drop;
/* Store remote BD_ADDR and PSM for msg_name */
bacpy(&bt_cb(skb)->l2cap.bdaddr, &hcon->dst);
bt_cb(skb)->l2cap.psm = psm;
if (!chan->ops->recv(chan, skb)) {
l2cap_chan_put(chan);
return;
}
drop:
l2cap_chan_put(chan);
free_skb:
kfree_skb(skb);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 124 | 68.89% | 3 | 27.27% |
mat martineau | mat martineau | 25 | 13.89% | 1 | 9.09% |
gustavo f. padovan | gustavo f. padovan | 23 | 12.78% | 6 | 54.55% |
gustavo padovan | gustavo padovan | 8 | 4.44% | 1 | 9.09% |
| Total | 180 | 100.00% | 11 | 100.00% |
static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
{
struct l2cap_hdr *lh = (void *) skb->data;
struct hci_conn *hcon = conn->hcon;
u16 cid, len;
__le16 psm;
if (hcon->state != BT_CONNECTED) {
BT_DBG("queueing pending rx skb");
skb_queue_tail(&conn->pending_rx, skb);
return;
}
skb_pull(skb, L2CAP_HDR_SIZE);
cid = __le16_to_cpu(lh->cid);
len = __le16_to_cpu(lh->len);
if (len != skb->len) {
kfree_skb(skb);
return;
}
/* Since we can't actively block incoming LE connections we must
* at least ensure that we ignore incoming data from them.
*/
if (hcon->type == LE_LINK &&
hci_bdaddr_list_lookup(&hcon->hdev->blacklist, &hcon->dst,
bdaddr_dst_type(hcon))) {
kfree_skb(skb);
return;
}
BT_DBG("len %d, cid 0x%4.4x", len, cid);
switch (cid) {
case L2CAP_CID_SIGNALING:
l2cap_sig_channel(conn, skb);
break;
case L2CAP_CID_CONN_LESS:
psm = get_unaligned((__le16 *) skb->data);
skb_pull(skb, L2CAP_PSMLEN_SIZE);
l2cap_conless_channel(conn, psm, skb);
break;
case L2CAP_CID_LE_SIGNALING:
l2cap_le_sig_channel(conn, skb);
break;
default:
l2cap_data_channel(conn, cid, skb);
break;
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 231 | 100.00% | 8 | 100.00% |
| Total | 231 | 100.00% | 8 | 100.00% |
static void process_pending_rx(struct work_struct *work)
{
struct l2cap_conn *conn = container_of(work, struct l2cap_conn,
pending_rx_work);
struct sk_buff *skb;
BT_DBG("");
while ((skb = skb_dequeue(&conn->pending_rx)))
l2cap_recv_frame(conn, skb);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 57 | 100.00% | 1 | 100.00% |
| Total | 57 | 100.00% | 1 | 100.00% |
static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon)
{
struct l2cap_conn *conn = hcon->l2cap_data;
struct hci_chan *hchan;
if (conn)
return conn;
hchan = hci_chan_create(hcon);
if (!hchan)
return NULL;
conn = kzalloc(sizeof(*conn), GFP_KERNEL);
if (!conn) {
hci_chan_del(hchan);
return NULL;
}
kref_init(&conn->ref);
hcon->l2cap_data = conn;
conn->hcon = hci_conn_get(hcon);
conn->hchan = hchan;
BT_DBG("hcon %p conn %p hchan %p", hcon, conn, hchan);
switch (hcon->type) {
case LE_LINK:
if (hcon->hdev->le_mtu) {
conn->mtu = hcon->hdev->le_mtu;
break;
}
/* fall through */
default:
conn->mtu = hcon->hdev->acl_mtu;
break;
}
conn->feat_mask = 0;
conn->local_fixed_chan = L2CAP_FC_SIG_BREDR | L2CAP_FC_CONNLESS;
if (hcon->type == ACL_LINK &&
hci_dev_test_flag(hcon->hdev, HCI_HS_ENABLED))
conn->local_fixed_chan |= L2CAP_FC_A2MP;
if (hci_dev_test_flag(hcon->hdev, HCI_LE_ENABLED) &&
(bredr_sc_enabled(hcon->hdev) ||
hci_dev_test_flag(hcon->hdev, HCI_FORCE_BREDR_SMP)))
conn->local_fixed_chan |= L2CAP_FC_SMP_BREDR;
mutex_init(&conn->ident_lock);
mutex_init(&conn->chan_lock);
INIT_LIST_HEAD(&conn->chan_l);
INIT_LIST_HEAD(&conn->users);
INIT_DELAYED_WORK(&conn->info_timer, l2cap_info_timeout);
skb_queue_head_init(&conn->pending_rx);
INIT_WORK(&conn->pending_rx_work, process_pending_rx);
INIT_WORK(&conn->id_addr_update_work, l2cap_conn_update_id_addr);
conn->disc_reason = HCI_ERROR_REMOTE_USER_TERM;
return conn;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 251 | 80.19% | 7 | 38.89% |
marcel holtmann | marcel holtmann | 20 | 6.39% | 4 | 22.22% |
gustavo f. padovan | gustavo f. padovan | 18 | 5.75% | 2 | 11.11% |
andrei emeltchenko | andrei emeltchenko | 17 | 5.43% | 2 | 11.11% |
gustavo padovan | gustavo padovan | 6 | 1.92% | 2 | 11.11% |
mat martineau | mat martineau | 1 | 0.32% | 1 | 5.56% |
| Total | 313 | 100.00% | 18 | 100.00% |
static bool is_valid_psm(u16 psm, u8 dst_type) {
if (!psm)
return false;
if (bdaddr_type_is_le(dst_type))
return (psm <= 0x00ff);
/* PSM must be odd and lsb of upper byte must be 0 */
return ((psm & 0x0101) == 0x0001);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 43 | 93.48% | 1 | 50.00% |
linus torvalds | linus torvalds | 3 | 6.52% | 1 | 50.00% |
| Total | 46 | 100.00% | 2 | 100.00% |
int l2cap_chan_connect(struct l2cap_chan *chan, __le16 psm, u16 cid,
bdaddr_t *dst, u8 dst_type)
{
struct l2cap_conn *conn;
struct hci_conn *hcon;
struct hci_dev *hdev;
int err;
BT_DBG("%pMR -> %pMR (type %u) psm 0x%2.2x", &chan->src, dst,
dst_type, __le16_to_cpu(psm));
hdev = hci_get_route(dst, &chan->src);
if (!hdev)
return -EHOSTUNREACH;
hci_dev_lock(hdev);
if (!is_valid_psm(__le16_to_cpu(psm), dst_type) && !cid &&
chan->chan_type != L2CAP_CHAN_RAW) {
err = -EINVAL;
goto done;
}
if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED && !psm) {
err = -EINVAL;
goto done;
}
if (chan->chan_type == L2CAP_CHAN_FIXED && !cid) {
err = -EINVAL;
goto done;
}
switch (chan->mode) {
case L2CAP_MODE_BASIC:
break;
case L2CAP_MODE_LE_FLOWCTL:
l2cap_le_flowctl_init(chan);
break;
case L2CAP_MODE_ERTM:
case L2CAP_MODE_STREAMING:
if (!disable_ertm)
break;
/* fall through */
default:
err = -EOPNOTSUPP;
goto done;
}
switch (chan->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(&chan->dst, dst);
chan->dst_type = dst_type;
chan->psm = psm;
chan->dcid = cid;
if (bdaddr_type_is_le(dst_type)) {
/* Convert from L2CAP channel address type to HCI address type
*/
if (dst_type == BDADDR_LE_PUBLIC)
dst_type = ADDR_LE_DEV_PUBLIC;
else
dst_type = ADDR_LE_DEV_RANDOM;
if (hci_dev_test_flag(hdev, HCI_ADVERTISING))
hcon = hci_connect_le(hdev, dst, dst_type,
chan->sec_level,
HCI_LE_CONN_TIMEOUT,
HCI_ROLE_SLAVE);
else
hcon = hci_connect_le_scan(hdev, dst, dst_type,
chan->sec_level,
HCI_LE_CONN_TIMEOUT);
} else {
u8 auth_type = l2cap_get_auth_type(chan);
hcon = hci_connect_acl(hdev, dst, chan->sec_level, auth_type);
}
if (IS_ERR(hcon)) {
err = PTR_ERR(hcon);
goto done;
}
conn = l2cap_conn_add(hcon);
if (!conn) {
hci_conn_drop(hcon);
err = -ENOMEM;
goto done;
}
mutex_lock(&conn->chan_lock);
l2cap_chan_lock(chan);
if (cid && __l2cap_get_chan_by_dcid(conn, cid)) {
hci_conn_drop(hcon);
err = -EBUSY;
goto chan_unlock;
}
/* Update source addr of the socket */
bacpy(&chan->src, &hcon->src);
chan->src_type = bdaddr_src_type(hcon);
__l2cap_chan_add(conn, chan);
/* l2cap_chan_add takes its own ref so we can drop this one */
hci_conn_drop(hcon);
l2cap_state_change(chan, BT_CONNECT);
__set_chan_timer(chan, chan->ops->get_sndtimeo(chan));
/* Release chan->sport so that it can be reused by other
* sockets (as it's only used for listening sockets).
*/
write_lock(&chan_list_lock);
chan->sport = 0;
write_unlock(&chan_list_lock);
if (hcon->state == BT_CONNECTED) {
if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
__clear_chan_timer(chan);
if (l2cap_chan_check_security(chan, true))
l2cap_state_change(chan, BT_CONNECTED);
} else
l2cap_do_start(chan);
}
err = 0;
chan_unlock:
l2cap_chan_unlock(chan);
mutex_unlock(&conn->chan_lock);
done:
hci_dev_unlock(hdev);
hci_dev_put(hdev);
return err;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 458 | 73.28% | 13 | 36.11% |
maxim krasnyansky | maxim krasnyansky | 44 | 7.04% | 1 | 2.78% |
marcel holtmann | marcel holtmann | 34 | 5.44% | 8 | 22.22% |
andre guedes | andre guedes | 21 | 3.36% | 2 | 5.56% |
gustavo f. padovan | gustavo f. padovan | 20 | 3.20% | 4 | 11.11% |
linus torvalds | linus torvalds | 20 | 3.20% | 1 | 2.78% |
anderson briglia | anderson briglia | 9 | 1.44% | 1 | 2.78% |
gustavo padovan | gustavo padovan | 8 | 1.28% | 1 | 2.78% |
maksim krasnyanskiy | maksim krasnyanskiy | 4 | 0.64% | 1 | 2.78% |
jukka rissanen | jukka rissanen | 3 | 0.48% | 1 | 2.78% |
ido yariv | ido yariv | 2 | 0.32% | 1 | 2.78% |
al viro | al viro | 1 | 0.16% | 1 | 2.78% |
jakub pawlowski | jakub pawlowski | 1 | 0.16% | 1 | 2.78% |
| Total | 625 | 100.00% | 36 | 100.00% |
EXPORT_SYMBOL_GPL(l2cap_chan_connect);
/* ---- L2CAP interface with lower layer (HCI) ---- */
int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr)
{
int exact = 0, lm1 = 0, lm2 = 0;
struct l2cap_chan *c;
BT_DBG("hdev %s, bdaddr %pMR", hdev->name, bdaddr);
/* Find listening sockets and check their link_mode */
read_lock(&chan_list_lock);
list_for_each_entry(c, &chan_list, global_l) {
if (c->state != BT_LISTEN)
continue;
if (!bacmp(&c->src, &hdev->bdaddr)) {
lm1 |= HCI_LM_ACCEPT;
if (test_bit(FLAG_ROLE_SWITCH, &c->flags))
lm1 |= HCI_LM_MASTER;
exact++;
} else if (!bacmp(&c->src, BDADDR_ANY)) {
lm2 |= HCI_LM_ACCEPT;
if (test_bit(FLAG_ROLE_SWITCH, &c->flags))
lm2 |= HCI_LM_MASTER;
}
}
read_unlock(&chan_list_lock);
return exact ? lm1 : lm2;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
maksim krasnyanskiy | maksim krasnyanskiy | 84 | 52.83% | 1 | 10.00% |
marcel holtmann | marcel holtmann | 21 | 13.21% | 3 | 30.00% |
linus torvalds | linus torvalds | 21 | 13.21% | 1 | 10.00% |
andrei emeltchenko | andrei emeltchenko | 15 | 9.43% | 2 | 20.00% |
gustavo f. padovan | gustavo f. padovan | 12 | 7.55% | 2 | 20.00% |
arnaldo carvalho de melo | arnaldo carvalho de melo | 6 | 3.77% | 1 | 10.00% |
| Total | 159 | 100.00% | 10 | 100.00% |
/* Find the next fixed channel in BT_LISTEN state, continue iteration
* from an existing channel in the list or from the beginning of the
* global list (by passing NULL as first parameter).
*/
static struct l2cap_chan *l2cap_global_fixed_chan(struct l2cap_chan *c,
struct hci_conn *hcon)
{
u8 src_type = bdaddr_src_type(hcon);
read_lock(&chan_list_lock);
if (c)
c = list_next_entry(c, global_l);
else
c = list_entry(chan_list.next, typeof(*c), global_l);
list_for_each_entry_from(c, &chan_list, global_l) {
if (c->chan_type != L2CAP_CHAN_FIXED)
continue;
if (c->state != BT_LISTEN)
continue;
if (bacmp(&c->src, &hcon->src) && bacmp(&c->src, BDADDR_ANY))
continue;
if (src_type != c->src_type)
continue;
l2cap_chan_hold(c);
read_unlock(&chan_list_lock);
return c;
}
read_unlock(&chan_list_lock);
return NULL;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 149 | 100.00% | 3 | 100.00% |
| Total | 149 | 100.00% | 3 | 100.00% |
static void l2cap_connect_cfm(struct hci_conn *hcon, u8 status)
{
struct hci_dev *hdev = hcon->hdev;
struct l2cap_conn *conn;
struct l2cap_chan *pchan;
u8 dst_type;
if (hcon->type != ACL_LINK && hcon->type != LE_LINK)
return;
BT_DBG("hcon %p bdaddr %pMR status %d", hcon, &hcon->dst, status);
if (status) {
l2cap_conn_del(hcon, bt_to_errno(status));
return;
}
conn = l2cap_conn_add(hcon);
if (!conn)
return;
dst_type = bdaddr_dst_type(hcon);
/* If device is blocked, do not create channels for it */
if (hci_bdaddr_list_lookup(&hdev->blacklist, &hcon->dst, dst_type))
return;
/* Find fixed channels and notify them of the new connection. We
* use multiple individual lookups, continuing each time where
* we left off, because the list lock would prevent calling the
* potentially sleeping l2cap_chan_lock() function.
*/
pchan = l2cap_global_fixed_chan(NULL, hcon);
while (pchan) {
struct l2cap_chan *chan, *next;
/* Client fixed channels should override server ones */
if (__l2cap_get_chan_by_dcid(conn, pchan->scid))
goto next;
l2cap_chan_lock(pchan);
chan = pchan->ops->new_connection(pchan);
if (chan) {
bacpy(&chan->src, &hcon->src);
bacpy(&chan->dst, &hcon->dst);
chan->src_type = bdaddr_src_type(hcon);
chan->dst_type = dst_type;
__l2cap_chan_add(conn, chan);
}
l2cap_chan_unlock(pchan);
next:
next = l2cap_global_fixed_chan(pchan, hcon);
l2cap_chan_put(pchan);
pchan = next;
}
l2cap_conn_ready(conn);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 207 | 79.62% | 5 | 45.45% |
maksim krasnyanskiy | maksim krasnyanskiy | 28 | 10.77% | 2 | 18.18% |
linus torvalds | linus torvalds | 18 | 6.92% | 1 | 9.09% |
marcel holtmann | marcel holtmann | 5 | 1.92% | 1 | 9.09% |
andrei emeltchenko | andrei emeltchenko | 2 | 0.77% | 2 | 18.18% |
| Total | 260 | 100.00% | 11 | 100.00% |
int l2cap_disconn_ind(struct hci_conn *hcon)
{
struct l2cap_conn *conn = hcon->l2cap_data;
BT_DBG("hcon %p", hcon);
if (!conn)
return HCI_ERROR_REMOTE_USER_TERM;
return conn->disc_reason;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 31 | 79.49% | 1 | 33.33% |
maksim krasnyanskiy | maksim krasnyanskiy | 7 | 17.95% | 1 | 33.33% |
andrei emeltchenko | andrei emeltchenko | 1 | 2.56% | 1 | 33.33% |
| Total | 39 | 100.00% | 3 | 100.00% |
static void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason)
{
if (hcon->type != ACL_LINK && hcon->type != LE_LINK)
return;
BT_DBG("hcon %p reason %d", hcon, reason);
l2cap_conn_del(hcon, bt_to_errno(reason));
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 16 | 33.33% | 1 | 14.29% |
maksim krasnyanskiy | maksim krasnyanskiy | 16 | 33.33% | 2 | 28.57% |
linus torvalds | linus torvalds | 8 | 16.67% | 1 | 14.29% |
marcel holtmann | marcel holtmann | 6 | 12.50% | 1 | 14.29% |
joe perches | joe perches | 1 | 2.08% | 1 | 14.29% |
andrei emeltchenko | andrei emeltchenko | 1 | 2.08% | 1 | 14.29% |
| Total | 48 | 100.00% | 7 | 100.00% |
static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt)
{
if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED)
return;
if (encrypt == 0x00) {
if (chan->sec_level == BT_SECURITY_MEDIUM) {
__set_chan_timer(chan, L2CAP_ENC_TIMEOUT);
} else if (chan->sec_level == BT_SECURITY_HIGH ||
chan->sec_level == BT_SECURITY_FIPS)
l2cap_chan_close(chan, ECONNREFUSED);
} else {
if (chan->sec_level == BT_SECURITY_MEDIUM)
__clear_chan_timer(chan);
}
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 70 | 80.46% | 3 | 27.27% |
gustavo f. padovan | gustavo f. padovan | 16 | 18.39% | 7 | 63.64% |
andrzej kaczmarek | andrzej kaczmarek | 1 | 1.15% | 1 | 9.09% |
| Total | 87 | 100.00% | 11 | 100.00% |
static void l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
{
struct l2cap_conn *conn = hcon->l2cap_data;
struct l2cap_chan *chan;
if (!conn)
return;
BT_DBG("conn %p status 0x%2.2x encrypt %u", conn, status, encrypt);
mutex_lock(&conn->chan_lock);
list_for_each_entry(chan, &conn->chan_l, list) {
l2cap_chan_lock(chan);
BT_DBG("chan %p scid 0x%4.4x state %s", chan, chan->scid,
state_to_string(chan->state));
if (chan->scid == L2CAP_CID_A2MP) {
l2cap_chan_unlock(chan);
continue;
}
if (!status && encrypt)
chan->sec_level = hcon->sec_level;
if (!__l2cap_no_conn_pending(chan)) {
l2cap_chan_unlock(chan);
continue;
}
if (!status && (chan->state == BT_CONNECTED ||
chan->state == BT_CONFIG)) {
chan->ops->resume(chan);
l2cap_check_encryption(chan, encrypt);
l2cap_chan_unlock(chan);
continue;
}
if (chan->state == BT_CONNECT) {
if (!status)
l2cap_start_connection(chan);
else
__set_chan_timer(chan, L2CAP_DISC_TIMEOUT);
} else if (chan->state == BT_CONNECT2 &&
chan->mode != L2CAP_MODE_LE_FLOWCTL) {
struct l2cap_conn_rsp rsp;
__u16 res, stat;
if (!status) {
if (test_bit(FLAG_DEFER_SETUP, &chan->flags)) {
res = L2CAP_CR_PEND;
stat = L2CAP_CS_AUTHOR_PEND;
chan->ops->defer(chan);
} else {
l2cap_state_change(chan, BT_CONFIG);
res = L2CAP_CR_SUCCESS;
stat = L2CAP_CS_NO_INFO;
}
} else {
l2cap_state_change(chan, BT_DISCONN);
__set_chan_timer(chan, L2CAP_DISC_TIMEOUT);
res = L2CAP_CR_SEC_BLOCK;
stat = L2CAP_CS_NO_INFO;
}
rsp.scid = cpu_to_le16(chan->dcid);
rsp.dcid = cpu_to_le16(chan->scid);
rsp.result = cpu_to_le16(res);
rsp.status = cpu_to_le16(stat);
l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
sizeof(rsp), &rsp);
if (!test_bit(CONF_REQ_SENT, &chan->conf_state) &&
res == L2CAP_CR_SUCCESS) {
char buf[128];
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++;
}
}
l2cap_chan_unlock(chan);
}
mutex_unlock(&conn->chan_lock);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 77 | 17.23% | 9 | 22.50% |
maksim krasnyanskiy | maksim krasnyanskiy | 73 | 16.33% | 2 | 5.00% |
mat martineau | mat martineau | 61 | 13.65% | 1 | 2.50% |
andrei emeltchenko | andrei emeltchenko | 53 | 11.86% | 6 | 15.00% |
linus torvalds | linus torvalds | 48 | 10.74% | 1 | 2.50% |
johan hedberg | johan hedberg | 47 | 10.51% | 4 | 10.00% |
gustavo f. padovan | gustavo f. padovan | 38 | 8.50% | 10 | 25.00% |
vinicius costa gomes | vinicius costa gomes | 25 | 5.59% | 1 | 2.50% |
gustavo padovan | gustavo padovan | 19 | 4.25% | 4 | 10.00% |
hideaki yoshifuji | hideaki yoshifuji | 4 | 0.89% | 1 | 2.50% |
andrzej kaczmarek | andrzej kaczmarek | 2 | 0.45% | 1 | 2.50% |
| Total | 447 | 100.00% | 40 | 100.00% |
void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags)
{
struct l2cap_conn *conn = hcon->l2cap_data;
struct l2cap_hdr *hdr;
int len;
/* For AMP controller do not create l2cap conn */
if (!conn && hcon->hdev->dev_type != HCI_BREDR)
goto drop;
if (!conn)
conn = l2cap_conn_add(hcon);
if (!conn)
goto drop;
BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags);
switch (flags) {
case ACL_START:
case ACL_START_NO_FLUSH:
case ACL_COMPLETE:
if (conn->rx_len) {
BT_ERR("Unexpected start frame (len %d)", skb->len);
kfree_skb(conn->rx_skb);
conn->rx_skb = NULL;
conn->rx_len = 0;
l2cap_conn_unreliable(conn, ECOMM);
}
/* Start fragment always begin with Basic L2CAP header */
if (skb->len < L2CAP_HDR_SIZE) {
BT_ERR("Frame is too short (len %d)", skb->len);
l2cap_conn_unreliable(conn, ECOMM);
goto drop;
}
hdr = (struct l2cap_hdr *) skb->data;
len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE;
if (len == skb->len) {
/* Complete frame received */
l2cap_recv_frame(conn, skb);
return;
}
BT_DBG("Start: total len %d, frag len %d", len, skb->len);
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;
}
/* Allocate skb for the complete frame (with header) */
conn->rx_skb = bt_skb_alloc(len, GFP_KERNEL);
if (!conn->rx_skb)
goto drop;
skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
skb->len);
conn->rx_len = len - skb->len;
break;
case ACL_CONT:
BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len);
if (!conn->rx_len) {
BT_ERR("Unexpected continuation frame (len %d)", skb->len);
l2cap_conn_unreliable(conn, ECOMM);
goto drop;
}
if (skb->len > conn->rx_len) {
BT_ERR("Fragment is too long (len %d, expected %d)",
skb->len, conn->rx_len);
kfree_skb(conn->rx_skb);
conn->rx_skb = NULL;
conn->rx_len = 0;
l2cap_conn_unreliable(conn, ECOMM);
goto drop;
}
skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
skb->len);
conn->rx_len -= skb->len;
if (!conn->rx_len) {
/* Complete frame received. l2cap_recv_frame
* takes ownership of the skb so set the global
* rx_skb pointer to NULL first.
*/
struct sk_buff *rx_skb = conn->rx_skb;
conn->rx_skb = NULL;
l2cap_recv_frame(conn, rx_skb);
}
break;
}
drop:
kfree_skb(skb);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
maksim krasnyanskiy | maksim krasnyanskiy | 241 | 50.74% | 4 | 20.00% |
linus torvalds | linus torvalds | 92 | 19.37% | 2 | 10.00% |
andrei emeltchenko | andrei emeltchenko | 48 | 10.11% | 4 | 20.00% |
marcel holtmann | marcel holtmann | 48 | 10.11% | 4 | 20.00% |
maxim krasnyansky | maxim krasnyansky | 16 | 3.37% | 1 | 5.00% |
johan hedberg | johan hedberg | 14 | 2.95% | 1 | 5.00% |
gustavo padovan | gustavo padovan | 8 | 1.68% | 2 | 10.00% |
arnaldo carvalho de melo | arnaldo carvalho de melo | 6 | 1.26% | 1 | 5.00% |
arron wang | arron wang | 2 | 0.42% | 1 | 5.00% |
| Total | 475 | 100.00% | 20 | 100.00% |
static struct hci_cb l2cap_cb = {
.name = "L2CAP",
.connect_cfm = l2cap_connect_cfm,
.disconn_cfm = l2cap_disconn_cfm,
.security_cfm = l2cap_security_cfm,
};
static int l2cap_debugfs_show(struct seq_file *f, void *p)
{
struct l2cap_chan *c;
read_lock(&chan_list_lock);
list_for_each_entry(c, &chan_list, global_l) {
seq_printf(f, "%pMR (%u) %pMR (%u) %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n",
&c->src, c->src_type, &c->dst, c->dst_type,
c->state, __le16_to_cpu(c->psm),
c->scid, c->dcid, c->imtu, c->omtu,
c->sec_level, c->mode);
}
read_unlock(&chan_list_lock);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
maksim krasnyanskiy | maksim krasnyanskiy | 39 | 37.14% | 2 | 13.33% |
marcel holtmann | marcel holtmann | 25 | 23.81% | 7 | 46.67% |
gustavo f. padovan | gustavo f. padovan | 22 | 20.95% | 4 | 26.67% |
linus torvalds | linus torvalds | 13 | 12.38% | 1 | 6.67% |
arnaldo carvalho de melo | arnaldo carvalho de melo | 6 | 5.71% | 1 | 6.67% |
| Total | 105 | 100.00% | 15 | 100.00% |
static int l2cap_debugfs_open(struct inode *inode, struct file *file)
{
return single_open(file, l2cap_debugfs_show, inode->i_private);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
marcel holtmann | marcel holtmann | 24 | 85.71% | 2 | 66.67% |
maksim krasnyanskiy | maksim krasnyanskiy | 4 | 14.29% | 1 | 33.33% |
| Total | 28 | 100.00% | 3 | 100.00% |
static const struct file_operations l2cap_debugfs_fops = {
.open = l2cap_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static struct dentry *l2cap_debugfs;
int __init l2cap_init(void)
{
int err;
err = l2cap_init_sockets();
if (err < 0)
return err;
hci_register_cb(&l2cap_cb);
if (IS_ERR_OR_NULL(bt_debugfs))
return 0;
l2cap_debugfs = debugfs_create_file("l2cap", 0444, bt_debugfs,
NULL, &l2cap_debugfs_fops);
debugfs_create_u16("l2cap_le_max_credits", 0644, bt_debugfs,
&le_max_credits);
debugfs_create_u16("l2cap_le_default_mps", 0644, bt_debugfs,
&le_default_mps);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 28 | 33.33% | 2 | 18.18% |
marcel holtmann | marcel holtmann | 26 | 30.95% | 4 | 36.36% |
linus torvalds | linus torvalds | 13 | 15.48% | 1 | 9.09% |
arnaldo carvalho de melo | arnaldo carvalho de melo | 10 | 11.90% | 1 | 9.09% |
maksim krasnyanskiy | maksim krasnyanskiy | 3 | 3.57% | 1 | 9.09% |
samuel ortiz | samuel ortiz | 2 | 2.38% | 1 | 9.09% |
gustavo f. padovan | gustavo f. padovan | 2 | 2.38% | 1 | 9.09% |
| Total | 84 | 100.00% | 11 | 100.00% |
void l2cap_exit(void)
{
debugfs_remove(l2cap_debugfs);
hci_unregister_cb(&l2cap_cb);
l2cap_cleanup_sockets();
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
linus torvalds | linus torvalds | 7 | 33.33% | 1 | 14.29% |
johan hedberg | johan hedberg | 6 | 28.57% | 1 | 14.29% |
marcel holtmann | marcel holtmann | 5 | 23.81% | 3 | 42.86% |
gustavo f. padovan | gustavo f. padovan | 2 | 9.52% | 1 | 14.29% |
arnaldo carvalho de melo | arnaldo carvalho de melo | 1 | 4.76% | 1 | 14.29% |
| Total | 21 | 100.00% | 7 | 100.00% |
module_param(disable_ertm, bool, 0644);
MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode");
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
johan hedberg | johan hedberg | 12121 | 35.69% | 93 | 17.22% |
mat martineau | mat martineau | 7896 | 23.25% | 58 | 10.74% |
gustavo padovan | gustavo padovan | 3681 | 10.84% | 44 | 8.15% |
gustavo f. padovan | gustavo f. padovan | 2798 | 8.24% | 93 | 17.22% |
andrei emeltchenko | andrei emeltchenko | 2396 | 7.06% | 87 | 16.11% |
marcel holtmann | marcel holtmann | 1873 | 5.52% | 76 | 14.07% |
linus torvalds | linus torvalds | 745 | 2.19% | 2 | 0.37% |
maksim krasnyanskiy | maksim krasnyanskiy | 647 | 1.91% | 8 | 1.48% |
claudio takahasi | claudio takahasi | 351 | 1.03% | 3 | 0.56% |
david herrmann | david herrmann | 324 | 0.95% | 3 | 0.56% |
vinicius costa gomes | vinicius costa gomes | 204 | 0.60% | 5 | 0.93% |
jaganath kanakkassery | jaganath kanakkassery | 131 | 0.39% | 4 | 0.74% |
luiz augusto von dentz | luiz augusto von dentz | 129 | 0.38% | 2 | 0.37% |
maxim krasnyansky | maxim krasnyansky | 113 | 0.33% | 1 | 0.19% |
jukka rissanen | jukka rissanen | 83 | 0.24% | 3 | 0.56% |
ville tervo | ville tervo | 81 | 0.24% | 4 | 0.74% |
joe perches | joe perches | 45 | 0.13% | 2 | 0.37% |
andrzej kaczmarek | andrzej kaczmarek | 44 | 0.13% | 2 | 0.37% |
syam sidhardhan | syam sidhardhan | 39 | 0.11% | 2 | 0.37% |
andre guedes | andre guedes | 39 | 0.11% | 4 | 0.74% |
arnaldo carvalho de melo | arnaldo carvalho de melo | 31 | 0.09% | 4 | 0.74% |
szymon janc | szymon janc | 26 | 0.08% | 6 | 1.11% |
ido yariv | ido yariv | 26 | 0.08% | 1 | 0.19% |
steven walter | steven walter | 18 | 0.05% | 1 | 0.19% |
anderson briglia | anderson briglia | 14 | 0.04% | 1 | 0.19% |
al viro | al viro | 13 | 0.04% | 2 | 0.37% |
jukka taimisto | jukka taimisto | 12 | 0.04% | 1 | 0.19% |
jaikumar ganesh | jaikumar ganesh | 9 | 0.03% | 1 | 0.19% |
alexey dobriyan | alexey dobriyan | 9 | 0.03% | 1 | 0.19% |
joao paulo rechi vita | joao paulo rechi vita | 8 | 0.02% | 2 | 0.37% |
ulisses furquim | ulisses furquim | 6 | 0.02% | 3 | 0.56% |
lukasz rymanowski | lukasz rymanowski | 6 | 0.02% | 1 | 0.19% |
martin townsend | martin townsend | 5 | 0.01% | 1 | 0.19% |
hideaki yoshifuji | hideaki yoshifuji | 5 | 0.01% | 2 | 0.37% |
ilia kolomisnky | ilia kolomisnky | 3 | 0.01% | 1 | 0.19% |
thomas graf | thomas graf | 3 | 0.01% | 1 | 0.19% |
johannes berg | johannes berg | 3 | 0.01% | 1 | 0.19% |
peter senna tschudin | peter senna tschudin | 2 | 0.01% | 1 | 0.19% |
john w. linville | john w. linville | 2 | 0.01% | 1 | 0.19% |
david s. miller | david s. miller | 2 | 0.01% | 1 | 0.19% |
samuel ortiz | samuel ortiz | 2 | 0.01% | 1 | 0.19% |
robert p. j. day | robert p. j. day | 2 | 0.01% | 1 | 0.19% |
tedd ho-jeong an | tedd ho-jeong an | 2 | 0.01% | 1 | 0.19% |
thomas gleixner | thomas gleixner | 2 | 0.01% | 1 | 0.19% |
arron wang | arron wang | 2 | 0.01% | 1 | 0.19% |
jakub pawlowski | jakub pawlowski | 1 | 0.00% | 1 | 0.19% |
nathan holstein | nathan holstein | 1 | 0.00% | 1 | 0.19% |
rusty russell | rusty russell | 1 | 0.00% | 1 | 0.19% |
stephen hemminger | stephen hemminger | 1 | 0.00% | 1 | 0.19% |
prasanna karthik | prasanna karthik | 1 | 0.00% | 1 | 0.19% |
pavel emelianov | pavel emelianov | 1 | 0.00% | 1 | 0.19% |
| Total | 33959 | 100.00% | 540 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.