sys/netbt/l2cap_upper.c

   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 }