Annotation of sys/netbt/l2cap_upper.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: l2cap_upper.c,v 1.1 2007/06/01 02:46:11 uwe 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/cdefs.h>
! 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);
! 72: if (chan == NULL)
! 73: return ENOMEM;
! 74: bzero(chan, sizeof *chan);
! 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:
! 125: memcpy(addr, &chan->lc_laddr, sizeof(struct sockaddr_bt));
! 126: return 0;
! 127: }
! 128:
! 129: /*
! 130: * l2cap_connect(l2cap_channel, sockaddr)
! 131: *
! 132: * Initiate a connection to destination. This corresponds to
! 133: * "Open Channel Request" in the L2CAP specification and will
! 134: * result in one of the following:
! 135: *
! 136: * proto->connected(upper)
! 137: * proto->disconnected(upper, error)
! 138: *
! 139: * and, optionally
! 140: * proto->connecting(upper)
! 141: */
! 142: int
! 143: l2cap_connect(struct l2cap_channel *chan, struct sockaddr_bt *dest)
! 144: {
! 145: struct hci_unit *unit;
! 146: int err;
! 147:
! 148: memcpy(&chan->lc_raddr, dest, sizeof(struct sockaddr_bt));
! 149:
! 150: if (L2CAP_PSM_INVALID(chan->lc_raddr.bt_psm))
! 151: return EINVAL;
! 152:
! 153: if (bdaddr_any(&chan->lc_raddr.bt_bdaddr))
! 154: return EDESTADDRREQ;
! 155:
! 156: /* set local address if it needs setting */
! 157: if (bdaddr_any(&chan->lc_laddr.bt_bdaddr)) {
! 158: err = hci_route_lookup(&chan->lc_laddr.bt_bdaddr,
! 159: &chan->lc_raddr.bt_bdaddr);
! 160: if (err)
! 161: return err;
! 162: }
! 163:
! 164: unit = hci_unit_lookup(&chan->lc_laddr.bt_bdaddr);
! 165: if (unit == NULL)
! 166: return EHOSTUNREACH;
! 167:
! 168: /* attach to active list */
! 169: err = l2cap_cid_alloc(chan);
! 170: if (err)
! 171: return err;
! 172:
! 173: /* open link to remote device */
! 174: chan->lc_link = hci_acl_open(unit, &chan->lc_raddr.bt_bdaddr);
! 175: if (chan->lc_link == NULL)
! 176: return EHOSTUNREACH;
! 177:
! 178: /* set the link mode */
! 179: err = l2cap_setmode(chan);
! 180: if (err == EINPROGRESS) {
! 181: chan->lc_state = L2CAP_WAIT_SEND_CONNECT_REQ;
! 182: (*chan->lc_proto->connecting)(chan->lc_upper);
! 183: return 0;
! 184: }
! 185: if (err)
! 186: goto fail;
! 187:
! 188: /*
! 189: * We can queue a connect request now even though the link may
! 190: * not yet be open; Our mode setting is assured, and the queue
! 191: * will be started automatically at the right time.
! 192: */
! 193: chan->lc_state = L2CAP_WAIT_RECV_CONNECT_RSP;
! 194: err = l2cap_send_connect_req(chan);
! 195: if (err)
! 196: goto fail;
! 197:
! 198: return 0;
! 199:
! 200: fail:
! 201: chan->lc_state = L2CAP_CLOSED;
! 202: hci_acl_close(chan->lc_link, err);
! 203: chan->lc_link = NULL;
! 204: return err;
! 205: }
! 206:
! 207: /*
! 208: * l2cap_peeraddr(l2cap_channel, sockaddr)
! 209: *
! 210: * get remote address of channel
! 211: */
! 212: int
! 213: l2cap_peeraddr(struct l2cap_channel *chan, struct sockaddr_bt *addr)
! 214: {
! 215:
! 216: memcpy(addr, &chan->lc_raddr, sizeof(struct sockaddr_bt));
! 217: return 0;
! 218: }
! 219:
! 220: /*
! 221: * l2cap_disconnect(l2cap_channel, linger)
! 222: *
! 223: * Initiate L2CAP disconnection. This corresponds to
! 224: * "Close Channel Request" in the L2CAP specification
! 225: * and will result in a call to
! 226: *
! 227: * proto->disconnected(upper, error)
! 228: *
! 229: * when the disconnection is complete. If linger is set,
! 230: * the call will not be made until data has flushed from
! 231: * the queue.
! 232: */
! 233: int
! 234: l2cap_disconnect(struct l2cap_channel *chan, int linger)
! 235: {
! 236: int err = 0;
! 237:
! 238: if (chan->lc_state == L2CAP_CLOSED
! 239: || chan->lc_state == L2CAP_WAIT_DISCONNECT)
! 240: return EINVAL;
! 241:
! 242: chan->lc_flags |= L2CAP_SHUTDOWN;
! 243:
! 244: /*
! 245: * no need to do anything unless the queue is empty or
! 246: * we are not lingering..
! 247: */
! 248: if ((IF_IS_EMPTY(&chan->lc_txq) && chan->lc_pending == 0)
! 249: || linger == 0) {
! 250: chan->lc_state = L2CAP_WAIT_DISCONNECT;
! 251: err = l2cap_send_disconnect_req(chan);
! 252: if (err)
! 253: l2cap_close(chan, err);
! 254: }
! 255: return err;
! 256: }
! 257:
! 258: /*
! 259: * l2cap_detach(handle)
! 260: *
! 261: * Detach l2cap channel from handle & close it down
! 262: */
! 263: int
! 264: l2cap_detach(struct l2cap_channel **handle)
! 265: {
! 266: struct l2cap_channel *chan;
! 267:
! 268: chan = *handle;
! 269: *handle = NULL;
! 270:
! 271: if (chan->lc_state != L2CAP_CLOSED)
! 272: l2cap_close(chan, 0);
! 273:
! 274: if (chan->lc_lcid != L2CAP_NULL_CID) {
! 275: LIST_REMOVE(chan, lc_ncid);
! 276: chan->lc_lcid = L2CAP_NULL_CID;
! 277: }
! 278:
! 279: IF_PURGE(&chan->lc_txq);
! 280:
! 281: /*
! 282: * Could implement some kind of delayed expunge to make sure that the
! 283: * CID is really dead before it becomes available for reuse?
! 284: */
! 285:
! 286: free(chan, M_BLUETOOTH);
! 287: return 0;
! 288: }
! 289:
! 290: /*
! 291: * l2cap_listen(l2cap_channel)
! 292: *
! 293: * Use this channel as a listening post (until detached). This will
! 294: * result in calls to:
! 295: *
! 296: * proto->newconn(upper, laddr, raddr)
! 297: *
! 298: * for incoming connections matching the psm and local address of the
! 299: * channel (NULL psm/address are permitted and match any protocol/device).
! 300: *
! 301: * The upper layer should create and return a new channel.
! 302: *
! 303: * You cannot use this channel for anything else subsequent to this call
! 304: */
! 305: int
! 306: l2cap_listen(struct l2cap_channel *chan)
! 307: {
! 308: struct l2cap_channel *used, *prev = NULL;
! 309:
! 310: if (chan->lc_lcid != L2CAP_NULL_CID)
! 311: return EINVAL;
! 312:
! 313: if (chan->lc_laddr.bt_psm != L2CAP_PSM_ANY
! 314: && L2CAP_PSM_INVALID(chan->lc_laddr.bt_psm))
! 315: return EADDRNOTAVAIL;
! 316:
! 317: /*
! 318: * This CID is irrelevant, as the channel is not stored on the active
! 319: * list and the socket code does not allow operations on listening
! 320: * sockets, but we set it so the detach code knows to LIST_REMOVE the
! 321: * channel.
! 322: */
! 323: chan->lc_lcid = L2CAP_SIGNAL_CID;
! 324:
! 325: /*
! 326: * The list of listening channels is stored in an order such that new
! 327: * listeners dont usurp current listeners, but that specific listening
! 328: * takes precedence over promiscuous, and the connect request code can
! 329: * easily use the first matching entry.
! 330: */
! 331: LIST_FOREACH(used, &l2cap_listen_list, lc_ncid) {
! 332: if (used->lc_laddr.bt_psm < chan->lc_laddr.bt_psm)
! 333: break;
! 334:
! 335: if (used->lc_laddr.bt_psm == chan->lc_laddr.bt_psm
! 336: && bdaddr_any(&used->lc_laddr.bt_bdaddr)
! 337: && !bdaddr_any(&chan->lc_laddr.bt_bdaddr))
! 338: break;
! 339:
! 340: prev = used;
! 341: }
! 342:
! 343: if (prev == NULL)
! 344: LIST_INSERT_HEAD(&l2cap_listen_list, chan, lc_ncid);
! 345: else
! 346: LIST_INSERT_AFTER(prev, chan, lc_ncid);
! 347:
! 348: return 0;
! 349: }
! 350:
! 351: /*
! 352: * l2cap_send(l2cap_channel, mbuf)
! 353: *
! 354: * Output SDU on channel described by channel. This corresponds
! 355: * to "Send Data Request" in the L2CAP specification. The upper
! 356: * layer will be notified when SDU's have completed sending by a
! 357: * call to:
! 358: *
! 359: * proto->complete(upper, n)
! 360: *
! 361: * (currently n == 1)
! 362: *
! 363: * Note: I'm not sure how this will work out, but I think that
! 364: * if outgoing Retransmission Mode or Flow Control Mode is
! 365: * negotiated then this call will not be made until the SDU has
! 366: * been acknowleged by the peer L2CAP entity. For 'Best Effort'
! 367: * it will be made when the packet has cleared the controller
! 368: * buffers.
! 369: *
! 370: * We only support Basic mode so far, so encapsulate with a
! 371: * B-Frame header and start sending if we are not already
! 372: */
! 373: int
! 374: l2cap_send(struct l2cap_channel *chan, struct mbuf *m)
! 375: {
! 376: l2cap_hdr_t *hdr;
! 377: int plen;
! 378:
! 379: if (chan->lc_state == L2CAP_CLOSED) {
! 380: m_freem(m);
! 381: return ENOTCONN;
! 382: }
! 383:
! 384: plen = m->m_pkthdr.len;
! 385:
! 386: DPRINTFN(5, "send %d bytes on CID #%d (pending = %d)\n",
! 387: plen, chan->lc_lcid, chan->lc_pending);
! 388:
! 389: /* Encapsulate with B-Frame */
! 390: M_PREPEND(m, sizeof(l2cap_hdr_t), M_DONTWAIT);
! 391: if (m == NULL)
! 392: return ENOMEM;
! 393:
! 394: hdr = mtod(m, l2cap_hdr_t *);
! 395: hdr->length = htole16(plen);
! 396: hdr->dcid = htole16(chan->lc_rcid);
! 397:
! 398: /* Queue it on our list */
! 399: IF_ENQUEUE(&chan->lc_txq, m);
! 400:
! 401: /* If we are not sending, then start doing so */
! 402: if (chan->lc_pending == 0)
! 403: return l2cap_start(chan);
! 404:
! 405: return 0;
! 406: }
! 407:
! 408: /*
! 409: * l2cap_setopt(l2cap_channel, opt, addr)
! 410: *
! 411: * Apply configuration options to channel. This corresponds to
! 412: * "Configure Channel Request" in the L2CAP specification.
! 413: *
! 414: * for SO_L2CAP_LM, the settings will take effect when the
! 415: * channel is established. If the channel is already open,
! 416: * a call to
! 417: * proto->linkmode(upper, new)
! 418: *
! 419: * will be made when the change is complete.
! 420: */
! 421: int
! 422: l2cap_setopt(struct l2cap_channel *chan, int opt, void *addr)
! 423: {
! 424: int mode, err = 0;
! 425: uint16_t mtu;
! 426:
! 427: switch (opt) {
! 428: case SO_L2CAP_IMTU: /* set Incoming MTU */
! 429: mtu = *(uint16_t *)addr;
! 430: if (mtu < L2CAP_MTU_MINIMUM)
! 431: err = EINVAL;
! 432: else if (chan->lc_state == L2CAP_CLOSED)
! 433: chan->lc_imtu = mtu;
! 434: else
! 435: err = EBUSY;
! 436:
! 437: break;
! 438:
! 439: case SO_L2CAP_LM: /* set link mode */
! 440: mode = *(int *)addr;
! 441: mode &= (L2CAP_LM_SECURE | L2CAP_LM_ENCRYPT | L2CAP_LM_AUTH);
! 442:
! 443: if (mode & L2CAP_LM_SECURE)
! 444: mode |= L2CAP_LM_ENCRYPT;
! 445:
! 446: if (mode & L2CAP_LM_ENCRYPT)
! 447: mode |= L2CAP_LM_AUTH;
! 448:
! 449: chan->lc_mode = mode;
! 450:
! 451: if (chan->lc_state == L2CAP_OPEN)
! 452: err = l2cap_setmode(chan);
! 453:
! 454: break;
! 455:
! 456: case SO_L2CAP_OQOS: /* set Outgoing QoS flow spec */
! 457: case SO_L2CAP_FLUSH: /* set Outgoing Flush Timeout */
! 458: default:
! 459: err = ENOPROTOOPT;
! 460: break;
! 461: }
! 462:
! 463: return err;
! 464: }
! 465:
! 466: /*
! 467: * l2cap_getopt(l2cap_channel, opt, addr)
! 468: *
! 469: * Return configuration parameters.
! 470: */
! 471: int
! 472: l2cap_getopt(struct l2cap_channel *chan, int opt, void *addr)
! 473: {
! 474:
! 475: switch (opt) {
! 476: case SO_L2CAP_IMTU: /* get Incoming MTU */
! 477: *(uint16_t *)addr = chan->lc_imtu;
! 478: return sizeof(uint16_t);
! 479:
! 480: case SO_L2CAP_OMTU: /* get Outgoing MTU */
! 481: *(uint16_t *)addr = chan->lc_omtu;
! 482: return sizeof(uint16_t);
! 483:
! 484: case SO_L2CAP_IQOS: /* get Incoming QoS flow spec */
! 485: memcpy(addr, &chan->lc_iqos, sizeof(l2cap_qos_t));
! 486: return sizeof(l2cap_qos_t);
! 487:
! 488: case SO_L2CAP_OQOS: /* get Outgoing QoS flow spec */
! 489: memcpy(addr, &chan->lc_oqos, sizeof(l2cap_qos_t));
! 490: return sizeof(l2cap_qos_t);
! 491:
! 492: case SO_L2CAP_FLUSH: /* get Flush Timeout */
! 493: *(uint16_t *)addr = chan->lc_flush;
! 494: return sizeof(uint16_t);
! 495:
! 496: case SO_L2CAP_LM: /* get link mode */
! 497: *(int *)addr = chan->lc_mode;
! 498: return sizeof(int);
! 499:
! 500: default:
! 501: break;
! 502: }
! 503:
! 504: return 0;
! 505: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to l2cap_upper.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netbt