1 /* $NetBSD: l2cap_upper.c,v 1.10 2009/09/25 19:44:57 plunky 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_upper.c,v 1.10 2009/09/25 19:44:57 plunky 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/socket.h> 42 #include <sys/socketvar.h> 43 #include <sys/systm.h> 44 45 #include <netbt/bluetooth.h> 46 #include <netbt/hci.h> 47 #include <netbt/l2cap.h> 48 49 /******************************************************************************* 50 * 51 * L2CAP Channel - Upper Protocol API 52 */ 53 54 /* 55 * l2cap_attach(handle, btproto, upper) 56 * 57 * attach new l2cap_channel to handle, populate 58 * with reasonable defaults 59 */ 60 int 61 l2cap_attach(struct l2cap_channel **handle, 62 const struct btproto *proto, void *upper) 63 { 64 struct l2cap_channel *chan; 65 66 KASSERT(handle != NULL); 67 KASSERT(proto != NULL); 68 KASSERT(upper != NULL); 69 70 chan = malloc(sizeof(struct l2cap_channel), M_BLUETOOTH, 71 M_NOWAIT | M_ZERO); 72 if (chan == NULL) 73 return ENOMEM; 74 75 chan->lc_proto = proto; 76 chan->lc_upper = upper; 77 78 chan->lc_state = L2CAP_CLOSED; 79 80 chan->lc_lcid = L2CAP_NULL_CID; 81 chan->lc_rcid = L2CAP_NULL_CID; 82 83 chan->lc_laddr.bt_len = sizeof(struct sockaddr_bt); 84 chan->lc_laddr.bt_family = AF_BLUETOOTH; 85 chan->lc_laddr.bt_psm = L2CAP_PSM_ANY; 86 87 chan->lc_raddr.bt_len = sizeof(struct sockaddr_bt); 88 chan->lc_raddr.bt_family = AF_BLUETOOTH; 89 chan->lc_raddr.bt_psm = L2CAP_PSM_ANY; 90 91 chan->lc_imtu = L2CAP_MTU_DEFAULT; 92 chan->lc_omtu = L2CAP_MTU_DEFAULT; 93 chan->lc_flush = L2CAP_FLUSH_TIMO_DEFAULT; 94 95 memcpy(&chan->lc_iqos, &l2cap_default_qos, sizeof(l2cap_qos_t)); 96 memcpy(&chan->lc_oqos, &l2cap_default_qos, sizeof(l2cap_qos_t)); 97 98 MBUFQ_INIT(&chan->lc_txq); 99 100 *handle = chan; 101 return 0; 102 } 103 104 /* 105 * l2cap_bind(l2cap_channel, sockaddr) 106 * 107 * set local address of channel 108 */ 109 int 110 l2cap_bind(struct l2cap_channel *chan, struct sockaddr_bt *addr) 111 { 112 113 memcpy(&chan->lc_laddr, addr, sizeof(struct sockaddr_bt)); 114 return 0; 115 } 116 117 /* 118 * l2cap_sockaddr(l2cap_channel, sockaddr) 119 * 120 * get local address of channel 121 */ 122 int 123 l2cap_sockaddr(struct l2cap_channel *chan, struct sockaddr_bt *addr) 124 { 125 126 memcpy(addr, &chan->lc_laddr, sizeof(struct sockaddr_bt)); 127 return 0; 128 } 129 130 /* 131 * l2cap_connect(l2cap_channel, sockaddr) 132 * 133 * Initiate a connection to destination. This corresponds to 134 * "Open Channel Request" in the L2CAP specification and will 135 * result in one of the following: 136 * 137 * proto->connected(upper) 138 * proto->disconnected(upper, error) 139 * 140 * and, optionally 141 * proto->connecting(upper) 142 */ 143 int 144 l2cap_connect(struct l2cap_channel *chan, struct sockaddr_bt *dest) 145 { 146 struct hci_unit *unit; 147 int err; 148 149 memcpy(&chan->lc_raddr, dest, sizeof(struct sockaddr_bt)); 150 151 if (L2CAP_PSM_INVALID(chan->lc_raddr.bt_psm)) 152 return EINVAL; 153 154 if (bdaddr_any(&chan->lc_raddr.bt_bdaddr)) 155 return EDESTADDRREQ; 156 157 /* set local address if it needs setting */ 158 if (bdaddr_any(&chan->lc_laddr.bt_bdaddr)) { 159 err = hci_route_lookup(&chan->lc_laddr.bt_bdaddr, 160 &chan->lc_raddr.bt_bdaddr); 161 if (err) 162 return err; 163 } 164 165 unit = hci_unit_lookup(&chan->lc_laddr.bt_bdaddr); 166 if (unit == NULL) 167 return EHOSTUNREACH; 168 169 /* attach to active list */ 170 err = l2cap_cid_alloc(chan); 171 if (err) 172 return err; 173 174 /* open link to remote device */ 175 chan->lc_link = hci_acl_open(unit, &chan->lc_raddr.bt_bdaddr); 176 if (chan->lc_link == NULL) 177 return EHOSTUNREACH; 178 179 /* set the link mode */ 180 err = l2cap_setmode(chan); 181 if (err == EINPROGRESS) { 182 chan->lc_state = L2CAP_WAIT_SEND_CONNECT_REQ; 183 (*chan->lc_proto->connecting)(chan->lc_upper); 184 return 0; 185 } 186 if (err) 187 goto fail; 188 189 /* 190 * We can queue a connect request now even though the link may 191 * not yet be open; Our mode setting is assured, and the queue 192 * will be started automatically at the right time. 193 */ 194 chan->lc_state = L2CAP_WAIT_RECV_CONNECT_RSP; 195 err = l2cap_send_connect_req(chan); 196 if (err) 197 goto fail; 198 199 return 0; 200 201 fail: 202 chan->lc_state = L2CAP_CLOSED; 203 hci_acl_close(chan->lc_link, err); 204 chan->lc_link = NULL; 205 return err; 206 } 207 208 /* 209 * l2cap_peeraddr(l2cap_channel, sockaddr) 210 * 211 * get remote address of channel 212 */ 213 int 214 l2cap_peeraddr(struct l2cap_channel *chan, struct sockaddr_bt *addr) 215 { 216 217 memcpy(addr, &chan->lc_raddr, sizeof(struct sockaddr_bt)); 218 return 0; 219 } 220 221 /* 222 * l2cap_disconnect(l2cap_channel, linger) 223 * 224 * Initiate L2CAP disconnection. This corresponds to 225 * "Close Channel Request" in the L2CAP specification 226 * and will result in a call to 227 * 228 * proto->disconnected(upper, error) 229 * 230 * when the disconnection is complete. If linger is set, 231 * the call will not be made until data has flushed from 232 * the queue. 233 */ 234 int 235 l2cap_disconnect(struct l2cap_channel *chan, int linger) 236 { 237 int err = 0; 238 239 if (chan->lc_state == L2CAP_CLOSED 240 || chan->lc_state == L2CAP_WAIT_DISCONNECT) 241 return EINVAL; 242 243 chan->lc_flags |= L2CAP_SHUTDOWN; 244 245 /* 246 * no need to do anything unless the queue is empty or 247 * we are not lingering.. 248 */ 249 if ((MBUFQ_FIRST(&chan->lc_txq) == NULL && chan->lc_pending == 0) 250 || linger == 0) { 251 chan->lc_state = L2CAP_WAIT_DISCONNECT; 252 err = l2cap_send_disconnect_req(chan); 253 if (err) 254 l2cap_close(chan, err); 255 } 256 return err; 257 } 258 259 /* 260 * l2cap_detach(handle) 261 * 262 * Detach l2cap channel from handle & close it down 263 */ 264 int 265 l2cap_detach(struct l2cap_channel **handle) 266 { 267 struct l2cap_channel *chan; 268 269 chan = *handle; 270 *handle = NULL; 271 272 if (chan->lc_state != L2CAP_CLOSED) 273 l2cap_close(chan, 0); 274 275 if (chan->lc_lcid != L2CAP_NULL_CID) { 276 LIST_REMOVE(chan, lc_ncid); 277 chan->lc_lcid = L2CAP_NULL_CID; 278 } 279 280 MBUFQ_DRAIN(&chan->lc_txq); 281 282 /* 283 * Could implement some kind of delayed expunge to make sure that the 284 * CID is really dead before it becomes available for reuse? 285 */ 286 287 free(chan, M_BLUETOOTH); 288 return 0; 289 } 290 291 /* 292 * l2cap_listen(l2cap_channel) 293 * 294 * Use this channel as a listening post (until detached). This will 295 * result in calls to: 296 * 297 * proto->newconn(upper, laddr, raddr) 298 * 299 * for incoming connections matching the psm and local address of 300 * the channel. NULL address is permitted and matches any device. 301 * If L2CAP_PSM_ANY is bound the next higher unused value from the 302 * dynamic range (above 0x1001) will be selected. 303 * 304 * The upper layer should create and return a new channel. 305 * 306 * You cannot use this channel for anything else subsequent to this call 307 */ 308 int 309 l2cap_listen(struct l2cap_channel *chan) 310 { 311 struct l2cap_channel *used, *prev = NULL; 312 uint32_t psm; 313 314 if (chan->lc_lcid != L2CAP_NULL_CID) 315 return EINVAL; 316 317 /* 318 * This is simplistic but its not really worth spending a 319 * lot of time looking for an unused PSM.. 320 */ 321 if (chan->lc_laddr.bt_psm == L2CAP_PSM_ANY) { 322 psm = 0x1001; 323 used = LIST_FIRST(&l2cap_listen_list); 324 325 if (used != NULL && used->lc_laddr.bt_psm >= psm) { 326 psm = used->lc_laddr.bt_psm + 0x0002; 327 if ((psm & 0x0100) != 0) 328 psm += 0x0100; 329 330 if (psm > UINT16_MAX) 331 return EADDRNOTAVAIL; 332 } 333 334 chan->lc_laddr.bt_psm = psm; 335 } else if (L2CAP_PSM_INVALID(chan->lc_laddr.bt_psm)) 336 return EINVAL; 337 338 /* 339 * This CID is irrelevant, as the channel is not stored on the active 340 * list and the socket code does not allow operations on listening 341 * sockets, but we set it so the detach code knows to LIST_REMOVE the 342 * channel. 343 */ 344 chan->lc_lcid = L2CAP_SIGNAL_CID; 345 346 /* 347 * The list of listening channels is stored in an order such that new 348 * listeners dont usurp current listeners, but that specific listening 349 * takes precedence over promiscuous, and the connect request code can 350 * easily use the first matching entry. 351 */ 352 LIST_FOREACH(used, &l2cap_listen_list, lc_ncid) { 353 if (used->lc_laddr.bt_psm < chan->lc_laddr.bt_psm) 354 break; 355 356 if (used->lc_laddr.bt_psm == chan->lc_laddr.bt_psm 357 && bdaddr_any(&used->lc_laddr.bt_bdaddr) 358 && !bdaddr_any(&chan->lc_laddr.bt_bdaddr)) 359 break; 360 361 prev = used; 362 } 363 364 if (prev == NULL) 365 LIST_INSERT_HEAD(&l2cap_listen_list, chan, lc_ncid); 366 else 367 LIST_INSERT_AFTER(prev, chan, lc_ncid); 368 369 return 0; 370 } 371 372 /* 373 * l2cap_send(l2cap_channel, mbuf) 374 * 375 * Output SDU on channel described by channel. This corresponds 376 * to "Send Data Request" in the L2CAP specification. The upper 377 * layer will be notified when SDU's have completed sending by a 378 * call to: 379 * 380 * proto->complete(upper, n) 381 * 382 * (currently n == 1) 383 * 384 * Note: I'm not sure how this will work out, but I think that 385 * if outgoing Retransmission Mode or Flow Control Mode is 386 * negotiated then this call will not be made until the SDU has 387 * been acknowleged by the peer L2CAP entity. For 'Best Effort' 388 * it will be made when the packet has cleared the controller 389 * buffers. 390 * 391 * We only support Basic mode so far, so encapsulate with a 392 * B-Frame header and start sending if we are not already 393 */ 394 int 395 l2cap_send(struct l2cap_channel *chan, struct mbuf *m) 396 { 397 l2cap_hdr_t *hdr; 398 int plen; 399 400 if (chan->lc_state == L2CAP_CLOSED) { 401 m_freem(m); 402 return ENOTCONN; 403 } 404 405 plen = m->m_pkthdr.len; 406 407 DPRINTFN(5, "send %d bytes on CID #%d (pending = %d)\n", 408 plen, chan->lc_lcid, chan->lc_pending); 409 410 /* Encapsulate with B-Frame */ 411 M_PREPEND(m, sizeof(l2cap_hdr_t), M_DONTWAIT); 412 if (m == NULL) 413 return ENOMEM; 414 415 hdr = mtod(m, l2cap_hdr_t *); 416 hdr->length = htole16(plen); 417 hdr->dcid = htole16(chan->lc_rcid); 418 419 /* Queue it on our list */ 420 MBUFQ_ENQUEUE(&chan->lc_txq, m); 421 422 /* If we are not sending, then start doing so */ 423 if (chan->lc_pending == 0) 424 return l2cap_start(chan); 425 426 return 0; 427 } 428 429 /* 430 * l2cap_setopt(l2cap_channel, sopt) 431 * 432 * Apply configuration options to channel. This corresponds to 433 * "Configure Channel Request" in the L2CAP specification. 434 * 435 * for SO_L2CAP_LM, the settings will take effect when the 436 * channel is established. If the channel is already open, 437 * a call to 438 * proto->linkmode(upper, new) 439 * 440 * will be made when the change is complete. 441 */ 442 int 443 l2cap_setopt(struct l2cap_channel *chan, const struct sockopt *sopt) 444 { 445 int mode, err = 0; 446 uint16_t mtu; 447 448 switch (sopt->sopt_name) { 449 case SO_L2CAP_IMTU: /* set Incoming MTU */ 450 err = sockopt_get(sopt, &mtu, sizeof(mtu)); 451 if (err) 452 break; 453 454 if (mtu < L2CAP_MTU_MINIMUM) 455 err = EINVAL; 456 else if (chan->lc_state == L2CAP_CLOSED) 457 chan->lc_imtu = mtu; 458 else 459 err = EBUSY; 460 461 break; 462 463 case SO_L2CAP_LM: /* set link mode */ 464 err = sockopt_getint(sopt, &mode); 465 if (err) 466 break; 467 468 mode &= (L2CAP_LM_SECURE | L2CAP_LM_ENCRYPT | L2CAP_LM_AUTH); 469 470 if (mode & L2CAP_LM_SECURE) 471 mode |= L2CAP_LM_ENCRYPT; 472 473 if (mode & L2CAP_LM_ENCRYPT) 474 mode |= L2CAP_LM_AUTH; 475 476 chan->lc_mode = mode; 477 478 if (chan->lc_state == L2CAP_OPEN) 479 err = l2cap_setmode(chan); 480 481 break; 482 483 case SO_L2CAP_OQOS: /* set Outgoing QoS flow spec */ 484 case SO_L2CAP_FLUSH: /* set Outgoing Flush Timeout */ 485 default: 486 err = ENOPROTOOPT; 487 break; 488 } 489 490 return err; 491 } 492 493 /* 494 * l2cap_getopt(l2cap_channel, sopt) 495 * 496 * Return configuration parameters. 497 */ 498 int 499 l2cap_getopt(struct l2cap_channel *chan, struct sockopt *sopt) 500 { 501 502 switch (sopt->sopt_name) { 503 case SO_L2CAP_IMTU: /* get Incoming MTU */ 504 return sockopt_set(sopt, &chan->lc_imtu, sizeof(uint16_t)); 505 506 case SO_L2CAP_OMTU: /* get Outgoing MTU */ 507 return sockopt_set(sopt, &chan->lc_omtu, sizeof(uint16_t)); 508 509 case SO_L2CAP_IQOS: /* get Incoming QoS flow spec */ 510 return sockopt_set(sopt, &chan->lc_iqos, sizeof(l2cap_qos_t)); 511 512 case SO_L2CAP_OQOS: /* get Outgoing QoS flow spec */ 513 return sockopt_set(sopt, &chan->lc_oqos, sizeof(l2cap_qos_t)); 514 515 case SO_L2CAP_FLUSH: /* get Flush Timeout */ 516 return sockopt_set(sopt, &chan->lc_flush, sizeof(uint16_t)); 517 518 case SO_L2CAP_LM: /* get link mode */ 519 return sockopt_setint(sopt, chan->lc_mode); 520 521 default: 522 break; 523 } 524 525 return ENOPROTOOPT; 526 } 527