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