| 1 | /* $NetBSD: l2cap_misc.c,v 1.7 2009/09/13 18:45:11 pooka Exp $ */ |
| 2 | |
| 3 | /*- |
| 4 | * Copyright (c) 2005 Iain Hibbert. |
| 5 | * Copyright (c) 2006 Itronix Inc. |
| 6 | * All rights reserved. |
| 7 | * |
| 8 | * Redistribution and use in source and binary forms, with or without |
| 9 | * modification, are permitted provided that the following conditions |
| 10 | * are met: |
| 11 | * 1. Redistributions of source code must retain the above copyright |
| 12 | * notice, this list of conditions and the following disclaimer. |
| 13 | * 2. Redistributions in binary form must reproduce the above copyright |
| 14 | * notice, this list of conditions and the following disclaimer in the |
| 15 | * documentation and/or other materials provided with the distribution. |
| 16 | * 3. The name of Itronix Inc. may not be used to endorse |
| 17 | * or promote products derived from this software without specific |
| 18 | * prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND |
| 21 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
| 22 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| 23 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY |
| 24 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| 25 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| 26 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| 27 | * ON ANY THEORY OF LIABILITY, WHETHER IN |
| 28 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 29 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 30 | * POSSIBILITY OF SUCH DAMAGE. |
| 31 | */ |
| 32 | |
| 33 | #include <sys/cdefs.h> |
| 34 | __KERNEL_RCSID(0, "$NetBSD: l2cap_misc.c,v 1.7 2009/09/13 18:45:11 pooka Exp $" ); |
| 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, l2cap_pdu_pool; |
| 53 | |
| 54 | const l2cap_qos_t l2cap_default_qos = { |
| 55 | 0, /* flags */ |
| 56 | L2CAP_QOS_BEST_EFFORT, /* service type */ |
| 57 | 0x00000000, /* token rate */ |
| 58 | 0x00000000, /* token bucket size */ |
| 59 | 0x00000000, /* peak bandwidth */ |
| 60 | 0xffffffff, /* latency */ |
| 61 | 0xffffffff /* delay variation */ |
| 62 | }; |
| 63 | |
| 64 | /* |
| 65 | * L2CAP request timeouts |
| 66 | */ |
| 67 | int l2cap_response_timeout = 30; /* seconds */ |
| 68 | int l2cap_response_extended_timeout = 180; /* seconds */ |
| 69 | |
| 70 | void |
| 71 | l2cap_init(void) |
| 72 | { |
| 73 | |
| 74 | pool_init(&l2cap_req_pool, sizeof(struct l2cap_req), 0, 0, 0, |
| 75 | "l2cap_req" , NULL, IPL_SOFTNET); |
| 76 | pool_init(&l2cap_pdu_pool, sizeof(struct l2cap_pdu), 0, 0, 0, |
| 77 | "l2cap_pdu" , NULL, IPL_SOFTNET); |
| 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 | callout_init(&req->lr_rtx, 0); |
| 141 | callout_setfunc(&req->lr_rtx, l2cap_rtx, req); |
| 142 | callout_schedule(&req->lr_rtx, l2cap_response_timeout * hz); |
| 143 | |
| 144 | TAILQ_INSERT_TAIL(&link->hl_reqs, req, lr_next); |
| 145 | |
| 146 | return 0; |
| 147 | } |
| 148 | |
| 149 | /* |
| 150 | * Find a running request for this link |
| 151 | */ |
| 152 | struct l2cap_req * |
| 153 | l2cap_request_lookup(struct hci_link *link, uint8_t id) |
| 154 | { |
| 155 | struct l2cap_req *req; |
| 156 | |
| 157 | TAILQ_FOREACH(req, &link->hl_reqs, lr_next) { |
| 158 | if (req->lr_id == id) |
| 159 | return req; |
| 160 | } |
| 161 | |
| 162 | return NULL; |
| 163 | } |
| 164 | |
| 165 | /* |
| 166 | * Halt and free a request |
| 167 | */ |
| 168 | void |
| 169 | l2cap_request_free(struct l2cap_req *req) |
| 170 | { |
| 171 | struct hci_link *link = req->lr_link; |
| 172 | |
| 173 | callout_stop(&req->lr_rtx); |
| 174 | if (callout_invoking(&req->lr_rtx)) |
| 175 | return; |
| 176 | |
| 177 | callout_destroy(&req->lr_rtx); |
| 178 | |
| 179 | TAILQ_REMOVE(&link->hl_reqs, req, lr_next); |
| 180 | pool_put(&l2cap_req_pool, req); |
| 181 | } |
| 182 | |
| 183 | /* |
| 184 | * Response Timeout eXpired |
| 185 | * |
| 186 | * No response to our request, so deal with it as best we can. |
| 187 | * |
| 188 | * XXX should try again at least with ertx? |
| 189 | */ |
| 190 | void |
| 191 | l2cap_rtx(void *arg) |
| 192 | { |
| 193 | struct l2cap_req *req = arg; |
| 194 | struct l2cap_channel *chan; |
| 195 | |
| 196 | mutex_enter(bt_lock); |
| 197 | callout_ack(&req->lr_rtx); |
| 198 | |
| 199 | chan = req->lr_chan; |
| 200 | l2cap_request_free(req); |
| 201 | |
| 202 | DPRINTF("cid %d, ident %d\n" , (chan ? chan->lc_lcid : 0), req->lr_id); |
| 203 | |
| 204 | if (chan && chan->lc_state != L2CAP_CLOSED) |
| 205 | l2cap_close(chan, ETIMEDOUT); |
| 206 | |
| 207 | mutex_exit(bt_lock); |
| 208 | } |
| 209 | |
| 210 | /* |
| 211 | * Allocate next available CID to channel. We keep a single |
| 212 | * ordered list of channels, so find the first gap. |
| 213 | * |
| 214 | * If this turns out to be not enough (!), could use a |
| 215 | * list per HCI unit.. |
| 216 | */ |
| 217 | int |
| 218 | l2cap_cid_alloc(struct l2cap_channel *chan) |
| 219 | { |
| 220 | struct l2cap_channel *used, *prev = NULL; |
| 221 | uint16_t cid = L2CAP_FIRST_CID; |
| 222 | |
| 223 | if (chan->lc_lcid != L2CAP_NULL_CID || chan->lc_state != L2CAP_CLOSED) |
| 224 | return EISCONN; |
| 225 | |
| 226 | LIST_FOREACH(used, &l2cap_active_list, lc_ncid) { |
| 227 | if (used->lc_lcid > cid) |
| 228 | break; /* found our gap */ |
| 229 | |
| 230 | KASSERT(used->lc_lcid == cid); |
| 231 | cid++; |
| 232 | |
| 233 | if (cid == L2CAP_LAST_CID) |
| 234 | return ENFILE; |
| 235 | |
| 236 | prev = used; /* for insert after */ |
| 237 | } |
| 238 | |
| 239 | chan->lc_lcid = cid; |
| 240 | |
| 241 | if (prev) |
| 242 | LIST_INSERT_AFTER(prev, chan, lc_ncid); |
| 243 | else |
| 244 | LIST_INSERT_HEAD(&l2cap_active_list, chan, lc_ncid); |
| 245 | |
| 246 | return 0; |
| 247 | } |
| 248 | |
| 249 | /* |
| 250 | * Find channel with CID |
| 251 | */ |
| 252 | struct l2cap_channel * |
| 253 | l2cap_cid_lookup(uint16_t cid) |
| 254 | { |
| 255 | struct l2cap_channel *chan; |
| 256 | |
| 257 | LIST_FOREACH(chan, &l2cap_active_list, lc_ncid) { |
| 258 | if (chan->lc_lcid == cid) |
| 259 | return chan; |
| 260 | |
| 261 | if (chan->lc_lcid > cid) |
| 262 | return NULL; |
| 263 | } |
| 264 | |
| 265 | return NULL; |
| 266 | } |
| 267 | |