root/netbt/l2cap_misc.c

DEFINITIONS

1. l2cap_init
2. l2cap_setmode
3. l2cap_request_alloc
4. l2cap_request_lookup
5. l2cap_request_free
6. l2cap_rtx
7. l2cap_cid_alloc
8. l2cap_cid_lookup

    1 /*      $OpenBSD: l2cap_misc.c,v 1.2 2007/06/01 02:46:11 uwe Exp $      */
    2 /*      $NetBSD: l2cap_misc.c,v 1.3 2007/04/21 06:15:23 plunky Exp $    */
    4 /*-
    5  * Copyright (c) 2005 Iain Hibbert.
    6  * Copyright (c) 2006 Itronix Inc.
    7  * All rights reserved.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions and the following disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  * 3. The name of Itronix Inc. may not be used to endorse
   18  *    or promote products derived from this software without specific
   19  *    prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   23  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
   25  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   28  * ON ANY THEORY OF LIABILITY, WHETHER IN
   29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   31  * POSSIBILITY OF SUCH DAMAGE.
   32  */
   34 #include <sys/cdefs.h>
   36 #include <sys/param.h>
   37 #include <sys/kernel.h>
   38 #include <sys/mbuf.h>
   39 #include <sys/proc.h>
   40 #include <sys/queue.h>
   41 #include <sys/systm.h>
   43 #include <netbt/bluetooth.h>
   44 #include <netbt/hci.h>
   45 #include <netbt/l2cap.h>
   47 struct l2cap_channel_list
l2cap_active_list = LIST_HEAD_INITIALIZER(l2cap_active_list);
   49 struct l2cap_channel_list
l2cap_listen_list = LIST_HEAD_INITIALIZER(l2cap_listen_list);
   52 struct pool l2cap_req_pool;
   53 struct pool l2cap_pdu_pool;
   55 const l2cap_qos_t l2cap_default_qos = {
   56         0,                      /* flags */
L2CAP_QOS_BEST_EFFORT,  /* service type */
   58         0x00000000,             /* token rate */
   59         0x00000000,             /* token bucket size */
   60         0x00000000,             /* peak bandwidth */
   61         0xffffffff,             /* latency */
   62         0xffffffff              /* delay variation */
   63 };
   65 /*
   66  * L2CAP request timeouts
   67  */
   68 int l2cap_response_timeout = 30;                /* seconds */
   69 int l2cap_response_extended_timeout = 180;      /* seconds */
   71 void
l2cap_init(void)
   73 {
pool_init(&l2cap_req_pool, sizeof(struct l2cap_req), 0, 0, 0,
   75             "l2cap_req", NULL);
pool_init(&l2cap_pdu_pool, sizeof(struct l2cap_pdu), 0, 0, 0,
   77             "l2cap_pdu", NULL);
   78 }
   80 /*
   81  * Set Link Mode on channel
   82  */
   83 int
l2cap_setmode(struct l2cap_channel *chan)
   85 {
KASSERT(chan != NULL);
KASSERT(chan->lc_link != NULL);
DPRINTF("CID #%d, auth %s, encrypt %s, secure %s\n", chan->lc_lcid,
   91                 (chan->lc_mode & L2CAP_LM_AUTH ? "yes" : "no"),
   92                 (chan->lc_mode & L2CAP_LM_ENCRYPT ? "yes" : "no"),
   93                 (chan->lc_mode & L2CAP_LM_SECURE ? "yes" : "no"));
   95         if (chan->lc_mode & L2CAP_LM_AUTH)
chan->lc_link->hl_flags |= HCI_LINK_AUTH_REQ;
   98         if (chan->lc_mode & L2CAP_LM_ENCRYPT)
chan->lc_link->hl_flags |= HCI_LINK_ENCRYPT_REQ;
  101         if (chan->lc_mode & L2CAP_LM_SECURE)
chan->lc_link->hl_flags |= HCI_LINK_SECURE_REQ;
  104         return hci_acl_setmode(chan->lc_link);
  105 }
  107 /*
  108  * Allocate a new Request structure & ID and set the timer going
  109  */
  110 int
l2cap_request_alloc(struct l2cap_channel *chan, uint8_t code)
  112 {
  113         struct hci_link *link = chan->lc_link;
  114         struct l2cap_req *req;
  115         int next_id;
  117         if (link == NULL)
  118                 return ENETDOWN;
  120         /* find next ID (0 is not allowed) */
next_id = link->hl_lastid + 1;
  122         if (next_id > 0xff)
next_id = 1;
  125         /* Ouroboros check */
req = TAILQ_FIRST(&link->hl_reqs);
  127         if (req && req->lr_id == next_id)
  128                 return ENFILE;
req = pool_get(&l2cap_req_pool, PR_NOWAIT);
  131         if (req == NULL)
  132                 return ENOMEM;
req->lr_id = link->hl_lastid = next_id;
req->lr_code = code;
req->lr_chan = chan;
req->lr_link = link;
timeout_set(&req->lr_rtx, l2cap_rtx, req);
timeout_add(&req->lr_rtx, l2cap_response_timeout*hz);
TAILQ_INSERT_TAIL(&link->hl_reqs, req, lr_next);
  145         return 0;
  146 }
  148 /*
  149  * Find a running request for this link
  150  */
  151 struct l2cap_req *
l2cap_request_lookup(struct hci_link *link, uint8_t id)
  153 {
  154         struct l2cap_req *req;
TAILQ_FOREACH(req, &link->hl_reqs, lr_next) {
  157                 if (req->lr_id == id)
  158                         return req;
  159         }
  161         return NULL;
  162 }
  164 /*
  165  * Halt and free a request
  166  */
  167 void
l2cap_request_free(struct l2cap_req *req)
  169 {
  170         struct hci_link *link = req->lr_link;
timeout_del(&req->lr_rtx);
  173         if (timeout_triggered(&req->lr_rtx))
  174                 return;
TAILQ_REMOVE(&link->hl_reqs, req, lr_next);
pool_put(&l2cap_req_pool, req);
  178 }
  180 /*
  181  * Response Timeout eXpired
  182  *
  183  * No response to our request, so deal with it as best we can.
  184  *
  185  * XXX should try again at least with ertx?
  186  */
  187 void
l2cap_rtx(void *arg)
  189 {
  190         struct l2cap_req *req = arg;
  191         struct l2cap_channel *chan;
  192         int s;
s = splsoftnet();
chan = req->lr_chan;
l2cap_request_free(req);
DPRINTF("cid %d, ident %d\n", (chan ? chan->lc_lcid : 0), req->lr_id);
  201         if (chan && chan->lc_state != L2CAP_CLOSED)
l2cap_close(chan, ETIMEDOUT);
splx(s);
  205 }
  207 /*
  208  * Allocate next available CID to channel. We keep a single
  209  * ordered list of channels, so find the first gap.
  210  *
  211  * If this turns out to be not enough (!), could use a
  212  * list per HCI unit..
  213  */
  214 int
l2cap_cid_alloc(struct l2cap_channel *chan)
  216 {
  217         struct l2cap_channel *used, *prev = NULL;
uint16_t cid = L2CAP_FIRST_CID;
  220         if (chan->lc_lcid != L2CAP_NULL_CID || chan->lc_state != L2CAP_CLOSED)
  221                 return EISCONN;
LIST_FOREACH(used, &l2cap_active_list, lc_ncid) {
  224                 if (used->lc_lcid > cid)
  225                         break;  /* found our gap */
KASSERT(used->lc_lcid == cid);
cid++;
  230                 if (cid == L2CAP_LAST_CID)
  231                         return ENFILE;
prev = used;    /* for insert after */
  234         }
chan->lc_lcid = cid;
  238         if (prev)
LIST_INSERT_AFTER(prev, chan, lc_ncid);
  240         else
LIST_INSERT_HEAD(&l2cap_active_list, chan, lc_ncid);
  243         return 0;
  244 }
  246 /*
  247  * Find channel with CID
  248  */
  249 struct l2cap_channel *
l2cap_cid_lookup(uint16_t cid)
  251 {
  252         struct l2cap_channel *chan;
LIST_FOREACH(chan, &l2cap_active_list, lc_ncid) {
  255                 if (chan->lc_lcid == cid)
  256                         return chan;
  258                 if (chan->lc_lcid > cid)
  259                         return NULL;
  260         }
  262         return NULL;
  263 }