1 /* $NetBSD: l2cap_upper.c,v 1.9 2008/08/06 15:01:24 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.9 2008/08/06 15:01:24 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 the 300 * channel (NULL psm/address are permitted and match any protocol/device). 301 * 302 * The upper layer should create and return a new channel. 303 * 304 * You cannot use this channel for anything else subsequent to this call 305 */ 306 int 307 l2cap_listen(struct l2cap_channel *chan) 308 { 309 struct l2cap_channel *used, *prev = NULL; 310 311 if (chan->lc_lcid != L2CAP_NULL_CID) 312 return EINVAL; 313 314 if (chan->lc_laddr.bt_psm != L2CAP_PSM_ANY 315 && L2CAP_PSM_INVALID(chan->lc_laddr.bt_psm)) 316 return EADDRNOTAVAIL; 317 318 /* 319 * This CID is irrelevant, as the channel is not stored on the active 320 * list and the socket code does not allow operations on listening 321 * sockets, but we set it so the detach code knows to LIST_REMOVE the 322 * channel. 323 */ 324 chan->lc_lcid = L2CAP_SIGNAL_CID; 325 326 /* 327 * The list of listening channels is stored in an order such that new 328 * listeners dont usurp current listeners, but that specific listening 329 * takes precedence over promiscuous, and the connect request code can 330 * easily use the first matching entry. 331 */ 332 LIST_FOREACH(used, &l2cap_listen_list, lc_ncid) { 333 if (used->lc_laddr.bt_psm < chan->lc_laddr.bt_psm) 334 break; 335 336 if (used->lc_laddr.bt_psm == chan->lc_laddr.bt_psm 337 && bdaddr_any(&used->lc_laddr.bt_bdaddr) 338 && !bdaddr_any(&chan->lc_laddr.bt_bdaddr)) 339 break; 340 341 prev = used; 342 } 343 344 if (prev == NULL) 345 LIST_INSERT_HEAD(&l2cap_listen_list, chan, lc_ncid); 346 else 347 LIST_INSERT_AFTER(prev, chan, lc_ncid); 348 349 return 0; 350 } 351 352 /* 353 * l2cap_send(l2cap_channel, mbuf) 354 * 355 * Output SDU on channel described by channel. This corresponds 356 * to "Send Data Request" in the L2CAP specification. The upper 357 * layer will be notified when SDU's have completed sending by a 358 * call to: 359 * 360 * proto->complete(upper, n) 361 * 362 * (currently n == 1) 363 * 364 * Note: I'm not sure how this will work out, but I think that 365 * if outgoing Retransmission Mode or Flow Control Mode is 366 * negotiated then this call will not be made until the SDU has 367 * been acknowleged by the peer L2CAP entity. For 'Best Effort' 368 * it will be made when the packet has cleared the controller 369 * buffers. 370 * 371 * We only support Basic mode so far, so encapsulate with a 372 * B-Frame header and start sending if we are not already 373 */ 374 int 375 l2cap_send(struct l2cap_channel *chan, struct mbuf *m) 376 { 377 l2cap_hdr_t *hdr; 378 int plen; 379 380 if (chan->lc_state == L2CAP_CLOSED) { 381 m_freem(m); 382 return ENOTCONN; 383 } 384 385 plen = m->m_pkthdr.len; 386 387 DPRINTFN(5, "send %d bytes on CID #%d (pending = %d)\n", 388 plen, chan->lc_lcid, chan->lc_pending); 389 390 /* Encapsulate with B-Frame */ 391 M_PREPEND(m, sizeof(l2cap_hdr_t), M_DONTWAIT); 392 if (m == NULL) 393 return ENOMEM; 394 395 hdr = mtod(m, l2cap_hdr_t *); 396 hdr->length = htole16(plen); 397 hdr->dcid = htole16(chan->lc_rcid); 398 399 /* Queue it on our list */ 400 MBUFQ_ENQUEUE(&chan->lc_txq, m); 401 402 /* If we are not sending, then start doing so */ 403 if (chan->lc_pending == 0) 404 return l2cap_start(chan); 405 406 return 0; 407 } 408 409 /* 410 * l2cap_setopt(l2cap_channel, sopt) 411 * 412 * Apply configuration options to channel. This corresponds to 413 * "Configure Channel Request" in the L2CAP specification. 414 * 415 * for SO_L2CAP_LM, the settings will take effect when the 416 * channel is established. If the channel is already open, 417 * a call to 418 * proto->linkmode(upper, new) 419 * 420 * will be made when the change is complete. 421 */ 422 int 423 l2cap_setopt(struct l2cap_channel *chan, const struct sockopt *sopt) 424 { 425 int mode, err = 0; 426 uint16_t mtu; 427 428 switch (sopt->sopt_name) { 429 case SO_L2CAP_IMTU: /* set Incoming MTU */ 430 err = sockopt_get(sopt, &mtu, sizeof(mtu)); 431 if (err) 432 break; 433 434 if (mtu < L2CAP_MTU_MINIMUM) 435 err = EINVAL; 436 else if (chan->lc_state == L2CAP_CLOSED) 437 chan->lc_imtu = mtu; 438 else 439 err = EBUSY; 440 441 break; 442 443 case SO_L2CAP_LM: /* set link mode */ 444 err = sockopt_getint(sopt, &mode); 445 if (err) 446 break; 447 448 mode &= (L2CAP_LM_SECURE | L2CAP_LM_ENCRYPT | L2CAP_LM_AUTH); 449 450 if (mode & L2CAP_LM_SECURE) 451 mode |= L2CAP_LM_ENCRYPT; 452 453 if (mode & L2CAP_LM_ENCRYPT) 454 mode |= L2CAP_LM_AUTH; 455 456 chan->lc_mode = mode; 457 458 if (chan->lc_state == L2CAP_OPEN) 459 err = l2cap_setmode(chan); 460 461 break; 462 463 case SO_L2CAP_OQOS: /* set Outgoing QoS flow spec */ 464 case SO_L2CAP_FLUSH: /* set Outgoing Flush Timeout */ 465 default: 466 err = ENOPROTOOPT; 467 break; 468 } 469 470 return err; 471 } 472 473 /* 474 * l2cap_getopt(l2cap_channel, sopt) 475 * 476 * Return configuration parameters. 477 */ 478 int 479 l2cap_getopt(struct l2cap_channel *chan, struct sockopt *sopt) 480 { 481 482 switch (sopt->sopt_name) { 483 case SO_L2CAP_IMTU: /* get Incoming MTU */ 484 return sockopt_set(sopt, &chan->lc_imtu, sizeof(uint16_t)); 485 486 case SO_L2CAP_OMTU: /* get Outgoing MTU */ 487 return sockopt_set(sopt, &chan->lc_omtu, sizeof(uint16_t)); 488 489 case SO_L2CAP_IQOS: /* get Incoming QoS flow spec */ 490 return sockopt_set(sopt, &chan->lc_iqos, sizeof(l2cap_qos_t)); 491 492 case SO_L2CAP_OQOS: /* get Outgoing QoS flow spec */ 493 return sockopt_set(sopt, &chan->lc_oqos, sizeof(l2cap_qos_t)); 494 495 case SO_L2CAP_FLUSH: /* get Flush Timeout */ 496 return sockopt_set(sopt, &chan->lc_flush, sizeof(uint16_t)); 497 498 case SO_L2CAP_LM: /* get link mode */ 499 return sockopt_setint(sopt, chan->lc_mode); 500 501 default: 502 break; 503 } 504 505 return ENOPROTOOPT; 506 } 507