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