Annotation of sys/netbt/l2cap_misc.c, Revision 1.1
1.1 ! nbrk 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 $ */
! 3:
! 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: */
! 33:
! 34: #include <sys/cdefs.h>
! 35:
! 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>
! 42:
! 43: #include <netbt/bluetooth.h>
! 44: #include <netbt/hci.h>
! 45: #include <netbt/l2cap.h>
! 46:
! 47: struct l2cap_channel_list
! 48: l2cap_active_list = LIST_HEAD_INITIALIZER(l2cap_active_list);
! 49: struct l2cap_channel_list
! 50: l2cap_listen_list = LIST_HEAD_INITIALIZER(l2cap_listen_list);
! 51:
! 52: struct pool l2cap_req_pool;
! 53: struct pool l2cap_pdu_pool;
! 54:
! 55: const l2cap_qos_t l2cap_default_qos = {
! 56: 0, /* flags */
! 57: 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: };
! 64:
! 65: /*
! 66: * L2CAP request timeouts
! 67: */
! 68: int l2cap_response_timeout = 30; /* seconds */
! 69: int l2cap_response_extended_timeout = 180; /* seconds */
! 70:
! 71: void
! 72: l2cap_init(void)
! 73: {
! 74: pool_init(&l2cap_req_pool, sizeof(struct l2cap_req), 0, 0, 0,
! 75: "l2cap_req", NULL);
! 76: pool_init(&l2cap_pdu_pool, sizeof(struct l2cap_pdu), 0, 0, 0,
! 77: "l2cap_pdu", NULL);
! 78: }
! 79:
! 80: /*
! 81: * Set Link Mode on channel
! 82: */
! 83: int
! 84: l2cap_setmode(struct l2cap_channel *chan)
! 85: {
! 86:
! 87: KASSERT(chan != NULL);
! 88: KASSERT(chan->lc_link != NULL);
! 89:
! 90: 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"));
! 94:
! 95: if (chan->lc_mode & L2CAP_LM_AUTH)
! 96: chan->lc_link->hl_flags |= HCI_LINK_AUTH_REQ;
! 97:
! 98: if (chan->lc_mode & L2CAP_LM_ENCRYPT)
! 99: chan->lc_link->hl_flags |= HCI_LINK_ENCRYPT_REQ;
! 100:
! 101: if (chan->lc_mode & L2CAP_LM_SECURE)
! 102: chan->lc_link->hl_flags |= HCI_LINK_SECURE_REQ;
! 103:
! 104: return hci_acl_setmode(chan->lc_link);
! 105: }
! 106:
! 107: /*
! 108: * Allocate a new Request structure & ID and set the timer going
! 109: */
! 110: int
! 111: 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;
! 116:
! 117: if (link == NULL)
! 118: return ENETDOWN;
! 119:
! 120: /* find next ID (0 is not allowed) */
! 121: next_id = link->hl_lastid + 1;
! 122: if (next_id > 0xff)
! 123: next_id = 1;
! 124:
! 125: /* Ouroboros check */
! 126: req = TAILQ_FIRST(&link->hl_reqs);
! 127: if (req && req->lr_id == next_id)
! 128: return ENFILE;
! 129:
! 130: req = pool_get(&l2cap_req_pool, PR_NOWAIT);
! 131: if (req == NULL)
! 132: return ENOMEM;
! 133:
! 134: req->lr_id = link->hl_lastid = next_id;
! 135:
! 136: req->lr_code = code;
! 137: req->lr_chan = chan;
! 138: req->lr_link = link;
! 139:
! 140: timeout_set(&req->lr_rtx, l2cap_rtx, req);
! 141: timeout_add(&req->lr_rtx, l2cap_response_timeout*hz);
! 142:
! 143: TAILQ_INSERT_TAIL(&link->hl_reqs, req, lr_next);
! 144:
! 145: return 0;
! 146: }
! 147:
! 148: /*
! 149: * Find a running request for this link
! 150: */
! 151: struct l2cap_req *
! 152: l2cap_request_lookup(struct hci_link *link, uint8_t id)
! 153: {
! 154: struct l2cap_req *req;
! 155:
! 156: TAILQ_FOREACH(req, &link->hl_reqs, lr_next) {
! 157: if (req->lr_id == id)
! 158: return req;
! 159: }
! 160:
! 161: return NULL;
! 162: }
! 163:
! 164: /*
! 165: * Halt and free a request
! 166: */
! 167: void
! 168: l2cap_request_free(struct l2cap_req *req)
! 169: {
! 170: struct hci_link *link = req->lr_link;
! 171:
! 172: timeout_del(&req->lr_rtx);
! 173: if (timeout_triggered(&req->lr_rtx))
! 174: return;
! 175:
! 176: TAILQ_REMOVE(&link->hl_reqs, req, lr_next);
! 177: pool_put(&l2cap_req_pool, req);
! 178: }
! 179:
! 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
! 188: l2cap_rtx(void *arg)
! 189: {
! 190: struct l2cap_req *req = arg;
! 191: struct l2cap_channel *chan;
! 192: int s;
! 193:
! 194: s = splsoftnet();
! 195:
! 196: chan = req->lr_chan;
! 197: l2cap_request_free(req);
! 198:
! 199: DPRINTF("cid %d, ident %d\n", (chan ? chan->lc_lcid : 0), req->lr_id);
! 200:
! 201: if (chan && chan->lc_state != L2CAP_CLOSED)
! 202: l2cap_close(chan, ETIMEDOUT);
! 203:
! 204: splx(s);
! 205: }
! 206:
! 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
! 215: l2cap_cid_alloc(struct l2cap_channel *chan)
! 216: {
! 217: struct l2cap_channel *used, *prev = NULL;
! 218: uint16_t cid = L2CAP_FIRST_CID;
! 219:
! 220: if (chan->lc_lcid != L2CAP_NULL_CID || chan->lc_state != L2CAP_CLOSED)
! 221: return EISCONN;
! 222:
! 223: LIST_FOREACH(used, &l2cap_active_list, lc_ncid) {
! 224: if (used->lc_lcid > cid)
! 225: break; /* found our gap */
! 226:
! 227: KASSERT(used->lc_lcid == cid);
! 228: cid++;
! 229:
! 230: if (cid == L2CAP_LAST_CID)
! 231: return ENFILE;
! 232:
! 233: prev = used; /* for insert after */
! 234: }
! 235:
! 236: chan->lc_lcid = cid;
! 237:
! 238: if (prev)
! 239: LIST_INSERT_AFTER(prev, chan, lc_ncid);
! 240: else
! 241: LIST_INSERT_HEAD(&l2cap_active_list, chan, lc_ncid);
! 242:
! 243: return 0;
! 244: }
! 245:
! 246: /*
! 247: * Find channel with CID
! 248: */
! 249: struct l2cap_channel *
! 250: l2cap_cid_lookup(uint16_t cid)
! 251: {
! 252: struct l2cap_channel *chan;
! 253:
! 254: LIST_FOREACH(chan, &l2cap_active_list, lc_ncid) {
! 255: if (chan->lc_lcid == cid)
! 256: return chan;
! 257:
! 258: if (chan->lc_lcid > cid)
! 259: return NULL;
! 260: }
! 261:
! 262: return NULL;
! 263: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to l2cap_misc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netbt