267 lines
6.3 KiB
C
267 lines
6.3 KiB
C
/* $NetBSD: l2cap_misc.c,v 1.7 2009/09/13 18:45:11 pooka Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2005 Iain Hibbert.
|
|
* Copyright (c) 2006 Itronix Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of Itronix Inc. may not be used to endorse
|
|
* or promote products derived from this software without specific
|
|
* prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: l2cap_misc.c,v 1.7 2009/09/13 18:45:11 pooka Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/systm.h>
|
|
|
|
#include <netbt/bluetooth.h>
|
|
#include <netbt/hci.h>
|
|
#include <netbt/l2cap.h>
|
|
|
|
struct l2cap_channel_list
|
|
l2cap_active_list = LIST_HEAD_INITIALIZER(l2cap_active_list);
|
|
struct l2cap_channel_list
|
|
l2cap_listen_list = LIST_HEAD_INITIALIZER(l2cap_listen_list);
|
|
|
|
struct pool l2cap_req_pool, l2cap_pdu_pool;
|
|
|
|
const l2cap_qos_t l2cap_default_qos = {
|
|
0, /* flags */
|
|
L2CAP_QOS_BEST_EFFORT, /* service type */
|
|
0x00000000, /* token rate */
|
|
0x00000000, /* token bucket size */
|
|
0x00000000, /* peak bandwidth */
|
|
0xffffffff, /* latency */
|
|
0xffffffff /* delay variation */
|
|
};
|
|
|
|
/*
|
|
* L2CAP request timeouts
|
|
*/
|
|
int l2cap_response_timeout = 30; /* seconds */
|
|
int l2cap_response_extended_timeout = 180; /* seconds */
|
|
|
|
void
|
|
l2cap_init(void)
|
|
{
|
|
|
|
pool_init(&l2cap_req_pool, sizeof(struct l2cap_req), 0, 0, 0,
|
|
"l2cap_req", NULL, IPL_SOFTNET);
|
|
pool_init(&l2cap_pdu_pool, sizeof(struct l2cap_pdu), 0, 0, 0,
|
|
"l2cap_pdu", NULL, IPL_SOFTNET);
|
|
}
|
|
|
|
/*
|
|
* Set Link Mode on channel
|
|
*/
|
|
int
|
|
l2cap_setmode(struct l2cap_channel *chan)
|
|
{
|
|
|
|
KASSERT(chan != NULL);
|
|
KASSERT(chan->lc_link != NULL);
|
|
|
|
DPRINTF("CID #%d, auth %s, encrypt %s, secure %s\n", chan->lc_lcid,
|
|
(chan->lc_mode & L2CAP_LM_AUTH ? "yes" : "no"),
|
|
(chan->lc_mode & L2CAP_LM_ENCRYPT ? "yes" : "no"),
|
|
(chan->lc_mode & L2CAP_LM_SECURE ? "yes" : "no"));
|
|
|
|
if (chan->lc_mode & L2CAP_LM_AUTH)
|
|
chan->lc_link->hl_flags |= HCI_LINK_AUTH_REQ;
|
|
|
|
if (chan->lc_mode & L2CAP_LM_ENCRYPT)
|
|
chan->lc_link->hl_flags |= HCI_LINK_ENCRYPT_REQ;
|
|
|
|
if (chan->lc_mode & L2CAP_LM_SECURE)
|
|
chan->lc_link->hl_flags |= HCI_LINK_SECURE_REQ;
|
|
|
|
return hci_acl_setmode(chan->lc_link);
|
|
}
|
|
|
|
/*
|
|
* Allocate a new Request structure & ID and set the timer going
|
|
*/
|
|
int
|
|
l2cap_request_alloc(struct l2cap_channel *chan, uint8_t code)
|
|
{
|
|
struct hci_link *link = chan->lc_link;
|
|
struct l2cap_req *req;
|
|
int next_id;
|
|
|
|
if (link == NULL)
|
|
return ENETDOWN;
|
|
|
|
/* find next ID (0 is not allowed) */
|
|
next_id = link->hl_lastid + 1;
|
|
if (next_id > 0xff)
|
|
next_id = 1;
|
|
|
|
/* Ouroboros check */
|
|
req = TAILQ_FIRST(&link->hl_reqs);
|
|
if (req && req->lr_id == next_id)
|
|
return ENFILE;
|
|
|
|
req = pool_get(&l2cap_req_pool, PR_NOWAIT);
|
|
if (req == NULL)
|
|
return ENOMEM;
|
|
|
|
req->lr_id = link->hl_lastid = next_id;
|
|
|
|
req->lr_code = code;
|
|
req->lr_chan = chan;
|
|
req->lr_link = link;
|
|
|
|
callout_init(&req->lr_rtx, 0);
|
|
callout_setfunc(&req->lr_rtx, l2cap_rtx, req);
|
|
callout_schedule(&req->lr_rtx, l2cap_response_timeout * hz);
|
|
|
|
TAILQ_INSERT_TAIL(&link->hl_reqs, req, lr_next);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Find a running request for this link
|
|
*/
|
|
struct l2cap_req *
|
|
l2cap_request_lookup(struct hci_link *link, uint8_t id)
|
|
{
|
|
struct l2cap_req *req;
|
|
|
|
TAILQ_FOREACH(req, &link->hl_reqs, lr_next) {
|
|
if (req->lr_id == id)
|
|
return req;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Halt and free a request
|
|
*/
|
|
void
|
|
l2cap_request_free(struct l2cap_req *req)
|
|
{
|
|
struct hci_link *link = req->lr_link;
|
|
|
|
callout_stop(&req->lr_rtx);
|
|
if (callout_invoking(&req->lr_rtx))
|
|
return;
|
|
|
|
callout_destroy(&req->lr_rtx);
|
|
|
|
TAILQ_REMOVE(&link->hl_reqs, req, lr_next);
|
|
pool_put(&l2cap_req_pool, req);
|
|
}
|
|
|
|
/*
|
|
* Response Timeout eXpired
|
|
*
|
|
* No response to our request, so deal with it as best we can.
|
|
*
|
|
* XXX should try again at least with ertx?
|
|
*/
|
|
void
|
|
l2cap_rtx(void *arg)
|
|
{
|
|
struct l2cap_req *req = arg;
|
|
struct l2cap_channel *chan;
|
|
|
|
mutex_enter(bt_lock);
|
|
callout_ack(&req->lr_rtx);
|
|
|
|
chan = req->lr_chan;
|
|
l2cap_request_free(req);
|
|
|
|
DPRINTF("cid %d, ident %d\n", (chan ? chan->lc_lcid : 0), req->lr_id);
|
|
|
|
if (chan && chan->lc_state != L2CAP_CLOSED)
|
|
l2cap_close(chan, ETIMEDOUT);
|
|
|
|
mutex_exit(bt_lock);
|
|
}
|
|
|
|
/*
|
|
* Allocate next available CID to channel. We keep a single
|
|
* ordered list of channels, so find the first gap.
|
|
*
|
|
* If this turns out to be not enough (!), could use a
|
|
* list per HCI unit..
|
|
*/
|
|
int
|
|
l2cap_cid_alloc(struct l2cap_channel *chan)
|
|
{
|
|
struct l2cap_channel *used, *prev = NULL;
|
|
uint16_t cid = L2CAP_FIRST_CID;
|
|
|
|
if (chan->lc_lcid != L2CAP_NULL_CID || chan->lc_state != L2CAP_CLOSED)
|
|
return EISCONN;
|
|
|
|
LIST_FOREACH(used, &l2cap_active_list, lc_ncid) {
|
|
if (used->lc_lcid > cid)
|
|
break; /* found our gap */
|
|
|
|
KASSERT(used->lc_lcid == cid);
|
|
cid++;
|
|
|
|
if (cid == L2CAP_LAST_CID)
|
|
return ENFILE;
|
|
|
|
prev = used; /* for insert after */
|
|
}
|
|
|
|
chan->lc_lcid = cid;
|
|
|
|
if (prev)
|
|
LIST_INSERT_AFTER(prev, chan, lc_ncid);
|
|
else
|
|
LIST_INSERT_HEAD(&l2cap_active_list, chan, lc_ncid);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Find channel with CID
|
|
*/
|
|
struct l2cap_channel *
|
|
l2cap_cid_lookup(uint16_t cid)
|
|
{
|
|
struct l2cap_channel *chan;
|
|
|
|
LIST_FOREACH(chan, &l2cap_active_list, lc_ncid) {
|
|
if (chan->lc_lcid == cid)
|
|
return chan;
|
|
|
|
if (chan->lc_lcid > cid)
|
|
return NULL;
|
|
}
|
|
|
|
return NULL;
|
|
}
|