a5c89047c0
NetBSD Foundation Membership still pending.) This stack was written by Iain under sponsorship from Itronix Inc. The stack includes support for rfcomm networking (networking via your bluetooth enabled cell phone), hid devices (keyboards/mice), and headsets. Drivers for both PCMCIA and USB bluetooth controllers are included.
476 lines
12 KiB
C
476 lines
12 KiB
C
/* $NetBSD: l2cap_upper.c,v 1.1 2006/06/19 15:44:45 gdamore 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_upper.c,v 1.1 2006/06/19 15:44:45 gdamore Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/socketvar.h>
|
|
#include <sys/systm.h>
|
|
|
|
#include <netbt/bluetooth.h>
|
|
#include <netbt/hci.h>
|
|
#include <netbt/l2cap.h>
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* L2CAP Channel - Upper Protocol API
|
|
*/
|
|
|
|
/*
|
|
* l2cap_attach(handle, btproto, upper)
|
|
*
|
|
* attach new l2cap_channel to handle, populate
|
|
* with with reasonable defaults
|
|
*/
|
|
int
|
|
l2cap_attach(struct l2cap_channel **handle,
|
|
const struct btproto *proto, void *upper)
|
|
{
|
|
struct l2cap_channel *chan;
|
|
|
|
KASSERT(handle);
|
|
KASSERT(proto);
|
|
KASSERT(upper);
|
|
|
|
chan = malloc(sizeof(struct l2cap_channel), M_BLUETOOTH,
|
|
M_NOWAIT | M_ZERO);
|
|
if (chan == NULL)
|
|
return ENOMEM;
|
|
|
|
chan->lc_proto = proto;
|
|
chan->lc_upper = upper;
|
|
|
|
chan->lc_state = L2CAP_CLOSED;
|
|
|
|
chan->lc_lcid = L2CAP_NULL_CID;
|
|
chan->lc_rcid = L2CAP_NULL_CID;
|
|
|
|
chan->lc_laddr.bt_len = sizeof(struct sockaddr_bt);
|
|
chan->lc_laddr.bt_family = AF_BLUETOOTH;
|
|
chan->lc_laddr.bt_psm = L2CAP_PSM_ANY;
|
|
|
|
chan->lc_raddr.bt_len = sizeof(struct sockaddr_bt);
|
|
chan->lc_raddr.bt_family = AF_BLUETOOTH;
|
|
chan->lc_raddr.bt_psm = L2CAP_PSM_ANY;
|
|
|
|
chan->lc_imtu = L2CAP_MTU_DEFAULT;
|
|
chan->lc_omtu = L2CAP_MTU_DEFAULT;
|
|
chan->lc_flush = L2CAP_FLUSH_TIMO_DEFAULT;
|
|
|
|
memcpy(&chan->lc_iqos, &l2cap_default_qos, sizeof(l2cap_qos_t));
|
|
memcpy(&chan->lc_oqos, &l2cap_default_qos, sizeof(l2cap_qos_t));
|
|
|
|
MBUFQ_INIT(&chan->lc_txq);
|
|
|
|
*handle = chan;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_bind(l2cap_channel, sockaddr)
|
|
*
|
|
* set local address of channel
|
|
*/
|
|
int
|
|
l2cap_bind(struct l2cap_channel *chan, struct sockaddr_bt *addr)
|
|
{
|
|
|
|
memcpy(&chan->lc_laddr, addr, sizeof(struct sockaddr_bt));
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_sockaddr(l2cap_channel, sockaddr)
|
|
*
|
|
* get local address of channel
|
|
*/
|
|
int
|
|
l2cap_sockaddr(struct l2cap_channel *chan, struct sockaddr_bt *addr)
|
|
{
|
|
|
|
memcpy(addr, &chan->lc_laddr, sizeof(struct sockaddr_bt));
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_connect(l2cap_channel, sockaddr)
|
|
*
|
|
* Initiate a connection to destination. This corresponds to
|
|
* "Open Channel Request" in the L2CAP specification and will
|
|
* result in one of the following:
|
|
*
|
|
* proto->connected(upper)
|
|
* proto->disconnected(upper, error)
|
|
*
|
|
* and, optionally
|
|
* proto->connecting(upper)
|
|
*/
|
|
int
|
|
l2cap_connect(struct l2cap_channel *chan, struct sockaddr_bt *dest)
|
|
{
|
|
struct hci_unit *unit;
|
|
int err;
|
|
|
|
memcpy(&chan->lc_raddr, dest, sizeof(struct sockaddr_bt));
|
|
|
|
if (L2CAP_PSM_INVALID(chan->lc_raddr.bt_psm))
|
|
return EINVAL;
|
|
|
|
if (bdaddr_any(&chan->lc_raddr.bt_bdaddr))
|
|
return EDESTADDRREQ;
|
|
|
|
/* set local address if it needs setting */
|
|
if (bdaddr_any(&chan->lc_laddr.bt_bdaddr)) {
|
|
err = hci_route_lookup(&chan->lc_laddr.bt_bdaddr,
|
|
&chan->lc_raddr.bt_bdaddr);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
unit = hci_unit_lookup(&chan->lc_laddr.bt_bdaddr);
|
|
if (unit == NULL)
|
|
return EHOSTUNREACH;
|
|
|
|
/* attach to active list */
|
|
err = l2cap_cid_alloc(chan);
|
|
if (err)
|
|
return err;
|
|
|
|
/* open link to remote device */
|
|
chan->lc_link = hci_acl_open(unit, &chan->lc_raddr.bt_bdaddr);
|
|
if (chan->lc_link == NULL)
|
|
return EHOSTUNREACH;
|
|
|
|
/*
|
|
* We queue a connect request right away even though the link
|
|
* may not yet be open; the queue will be started automatically
|
|
* at the right time.
|
|
*/
|
|
chan->lc_state = L2CAP_WAIT_CONNECT_RSP;
|
|
err = l2cap_send_connect_req(chan);
|
|
if (err) {
|
|
chan->lc_state = L2CAP_CLOSED;
|
|
hci_acl_close(chan->lc_link, err);
|
|
chan->lc_link = NULL;
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_peeraddr(l2cap_channel, sockaddr)
|
|
*
|
|
* get remote address of channel
|
|
*/
|
|
int
|
|
l2cap_peeraddr(struct l2cap_channel *chan, struct sockaddr_bt *addr)
|
|
{
|
|
|
|
memcpy(addr, &chan->lc_raddr, sizeof(struct sockaddr_bt));
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_disconnect(l2cap_channel, linger)
|
|
*
|
|
* Initiate L2CAP disconnection. This corresponds to
|
|
* "Close Channel Request" in the L2CAP specification
|
|
* and will result in a call to
|
|
*
|
|
* proto->disconnected(upper, error)
|
|
*
|
|
* when the disconnection is complete. If linger is set,
|
|
* the call will not be made until data has flushed from
|
|
* the queue.
|
|
*/
|
|
int
|
|
l2cap_disconnect(struct l2cap_channel *chan, int linger)
|
|
{
|
|
int err = 0;
|
|
|
|
if (chan->lc_state & (L2CAP_CLOSED | L2CAP_WAIT_DISCONNECT))
|
|
return EINVAL;
|
|
|
|
chan->lc_flags |= L2CAP_SHUTDOWN;
|
|
|
|
/*
|
|
* no need to do anything unless the queue is empty or
|
|
* we are not lingering..
|
|
*/
|
|
if ((MBUFQ_FIRST(&chan->lc_txq) == NULL && chan->lc_pending == 0)
|
|
|| linger == 0) {
|
|
chan->lc_state = L2CAP_WAIT_DISCONNECT;
|
|
err = l2cap_send_disconnect_req(chan);
|
|
if (err)
|
|
l2cap_close(chan, err);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* l2cap_detach(handle)
|
|
*
|
|
* Detach l2cap channel from handle & close it down
|
|
*/
|
|
int
|
|
l2cap_detach(struct l2cap_channel **handle)
|
|
{
|
|
struct l2cap_channel *chan;
|
|
|
|
chan = *handle;
|
|
*handle = NULL;
|
|
|
|
if (chan->lc_state != L2CAP_CLOSED)
|
|
l2cap_close(chan, 0);
|
|
|
|
if (chan->lc_lcid != L2CAP_NULL_CID) {
|
|
LIST_REMOVE(chan, lc_ncid);
|
|
chan->lc_lcid = L2CAP_NULL_CID;
|
|
}
|
|
|
|
MBUFQ_DRAIN(&chan->lc_txq);
|
|
|
|
/*
|
|
* Could implement some kind of delayed expunge to make sure that the
|
|
* CID is really dead before it becomes available for reuse?
|
|
*/
|
|
|
|
free(chan, M_BLUETOOTH);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_listen(l2cap_channel)
|
|
*
|
|
* Use this channel as a listening post (until detached). This will
|
|
* result in calls to:
|
|
*
|
|
* proto->newconn(upper, laddr, raddr)
|
|
*
|
|
* for incoming connections matching the psm and local address of the
|
|
* channel (NULL psm/address are permitted and match any protocol/device).
|
|
*
|
|
* The upper layer should create and return a new channel.
|
|
*
|
|
* You cannot use this channel for anything else subsequent to this call
|
|
*/
|
|
int
|
|
l2cap_listen(struct l2cap_channel *chan)
|
|
{
|
|
struct l2cap_channel *used, *prev = NULL;
|
|
|
|
if (chan->lc_lcid != L2CAP_NULL_CID)
|
|
return EINVAL;
|
|
|
|
if (chan->lc_laddr.bt_psm != L2CAP_PSM_ANY
|
|
&& L2CAP_PSM_INVALID(chan->lc_laddr.bt_psm))
|
|
return EADDRNOTAVAIL;
|
|
|
|
/*
|
|
* This CID is irrelevant, as the channel is not stored on the active
|
|
* list and the socket code does not allow operations on listening
|
|
* sockets, but we set it so the detach code knows to LIST_REMOVE the
|
|
* channel.
|
|
*/
|
|
chan->lc_lcid = L2CAP_SIGNAL_CID;
|
|
|
|
/*
|
|
* The list of listening channels is stored in an order such that new
|
|
* listeners dont usurp current listeners, but that specific listening
|
|
* takes precedence over promiscuous, and the connect request code can
|
|
* easily use the first matching entry.
|
|
*/
|
|
LIST_FOREACH(used, &l2cap_listen_list, lc_ncid) {
|
|
if (used->lc_laddr.bt_psm < chan->lc_laddr.bt_psm)
|
|
break;
|
|
|
|
if (used->lc_laddr.bt_psm == chan->lc_laddr.bt_psm
|
|
&& bdaddr_any(&used->lc_laddr.bt_bdaddr)
|
|
&& !bdaddr_any(&chan->lc_laddr.bt_bdaddr))
|
|
break;
|
|
|
|
prev = used;
|
|
}
|
|
|
|
if (prev == NULL)
|
|
LIST_INSERT_HEAD(&l2cap_listen_list, chan, lc_ncid);
|
|
else
|
|
LIST_INSERT_AFTER(prev, chan, lc_ncid);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_send(l2cap_channel, mbuf)
|
|
*
|
|
* Output SDU on channel described by channel. This corresponds
|
|
* to "Send Data Request" in the L2CAP specification. The upper
|
|
* layer will be notified when SDU's have completed sending by a
|
|
* call to:
|
|
*
|
|
* proto->complete(upper, n)
|
|
*
|
|
* (currently n == 1)
|
|
*
|
|
* Note: I'm not sure how this will work out, but I think that
|
|
* if outgoing Retransmission Mode or Flow Control Mode is
|
|
* negotiated then this call will not be made until the SDU has
|
|
* been acknowleged by the peer L2CAP entity. For 'Best Effort'
|
|
* it will be made when the packet has cleared the controller
|
|
* buffers.
|
|
*
|
|
* We only support Basic mode so far, so encapsulate with a
|
|
* B-Frame header and start sending if we are not already
|
|
*/
|
|
int
|
|
l2cap_send(struct l2cap_channel *chan, struct mbuf *m)
|
|
{
|
|
l2cap_hdr_t *hdr;
|
|
int plen;
|
|
|
|
if (chan->lc_state == L2CAP_CLOSED) {
|
|
m_freem(m);
|
|
return ENOTCONN;
|
|
}
|
|
|
|
plen = m->m_pkthdr.len;
|
|
|
|
DPRINTFN(5, "send %d bytes on CID #%d (pending = %d)\n",
|
|
plen, chan->lc_lcid, chan->lc_pending);
|
|
|
|
/* Encapsulate with B-Frame */
|
|
M_PREPEND(m, sizeof(l2cap_hdr_t), M_DONTWAIT);
|
|
if (m == NULL)
|
|
return ENOMEM;
|
|
|
|
hdr = mtod(m, l2cap_hdr_t *);
|
|
hdr->length = htole16(plen);
|
|
hdr->dcid = htole16(chan->lc_rcid);
|
|
|
|
/* Queue it on our list */
|
|
MBUFQ_ENQUEUE(&chan->lc_txq, m);
|
|
|
|
/* If we are not sending, then start doing so */
|
|
if (chan->lc_pending == 0)
|
|
return l2cap_start(chan);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* l2cap_setopt(channel, opt, addr)
|
|
*
|
|
* Apply configuration options to channel. This corresponds to
|
|
* "Configure Channel Request" in the L2CAP specification.
|
|
*/
|
|
int
|
|
l2cap_setopt(struct l2cap_channel *chan, int opt, void *addr)
|
|
{
|
|
int err = 0;
|
|
uint16_t tmp;
|
|
|
|
/*
|
|
* currently we dont allow changing any options when channel
|
|
* is other than closed. We could allow this (not sure why?)
|
|
* but would have to instigate a configure request.
|
|
*/
|
|
if (chan->lc_state != L2CAP_CLOSED)
|
|
return EBUSY;
|
|
|
|
switch (opt) {
|
|
case SO_L2CAP_IMTU: /* set Incoming MTU */
|
|
tmp = *(uint16_t *)addr;
|
|
if (tmp < L2CAP_MTU_MINIMUM) {
|
|
err = EINVAL;
|
|
break;
|
|
}
|
|
|
|
chan->lc_imtu = tmp;
|
|
break;
|
|
|
|
case SO_L2CAP_OQOS: /* set Outgoing QoS flow spec */
|
|
// XXX
|
|
// memcpy(&chan->lc_oqos, addr, sizeof(l2cap_qos_t));
|
|
//break;
|
|
|
|
case SO_L2CAP_FLUSH: /* set Outgoing Flush Timeout */
|
|
// XXX
|
|
// chan->lc_flush = *(uint16_t *)addr;
|
|
//break;
|
|
|
|
default:
|
|
err = EINVAL;
|
|
break;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
int
|
|
l2cap_getopt(struct l2cap_channel *chan, int opt, void *addr)
|
|
{
|
|
|
|
switch (opt) {
|
|
case SO_L2CAP_IMTU: /* get Incoming MTU */
|
|
*(uint16_t *)addr = chan->lc_imtu;
|
|
return sizeof(uint16_t);
|
|
|
|
case SO_L2CAP_OMTU: /* get Outgoing MTU */
|
|
*(uint16_t *)addr = chan->lc_omtu;
|
|
return sizeof(uint16_t);
|
|
|
|
case SO_L2CAP_IQOS: /* get Incoming QoS flow spec */
|
|
memcpy(addr, &chan->lc_iqos, sizeof(l2cap_qos_t));
|
|
return sizeof(l2cap_qos_t);
|
|
|
|
case SO_L2CAP_OQOS: /* get Outgoing QoS flow spec */
|
|
memcpy(addr, &chan->lc_oqos, sizeof(l2cap_qos_t));
|
|
return sizeof(l2cap_qos_t);
|
|
|
|
case SO_L2CAP_FLUSH: /* get Flush Timeout */
|
|
*(uint16_t *)addr = chan->lc_flush;
|
|
return sizeof(uint16_t);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|