sys/netgraph7/bluetooth/l2cap/ng_l2cap_misc.c

   1 /*
   2  * ng_l2cap_misc.c
   3  */
   4
   5 /*-
   6  * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com>
   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  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $Id: ng_l2cap_misc.c,v 1.5 2003/09/08 19:11:45 max Exp $
  31  * $FreeBSD: src/sys/netgraph/bluetooth/l2cap/ng_l2cap_misc.c,v 1.12 2005/08/31 18:13:23 emax Exp $
  32  * $DragonFly: src/sys/netgraph7/bluetooth/l2cap/ng_l2cap_misc.c,v 1.2 2008/06/26 23:05:40 dillon Exp $
  33  */
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/malloc.h>
  39 #include <sys/mbuf.h>
  40 #include <sys/queue.h>
  41 #include "ng_message.h"
  42 #include "netgraph.h"
  43 #include "bluetooth/include/ng_bluetooth.h"
  44 #include "bluetooth/include/ng_hci.h"
  45 #include "bluetooth/include/ng_l2cap.h"
  46 #include "bluetooth/l2cap/ng_l2cap_var.h"
  47 #include "bluetooth/l2cap/ng_l2cap_cmds.h"
  48 #include "bluetooth/l2cap/ng_l2cap_evnt.h"
  49 #include "bluetooth/l2cap/ng_l2cap_llpi.h"
  50 #include "bluetooth/l2cap/ng_l2cap_ulpi.h"
  51 #include "bluetooth/l2cap/ng_l2cap_misc.h"
  52
  53 static u_int16_t        ng_l2cap_get_cid        (ng_l2cap_p);
  54
  55 /******************************************************************************
  56  ******************************************************************************
  57  **                              Utility routines
  58  ******************************************************************************
  59  ******************************************************************************/
  60
  61 /*
  62  * Send hook information to the upper layer
  63  */
  64
  65 void
  66 ng_l2cap_send_hook_info(node_p node, hook_p hook, void *arg1, int arg2)
  67 {
  68         ng_l2cap_p       l2cap = NULL;
  69         struct ng_mesg  *msg = NULL;
  70         int              error = 0;
  71
  72         if (node == NULL || NG_NODE_NOT_VALID(node) ||
  73             hook == NULL || NG_HOOK_NOT_VALID(hook))
  74                 return;
  75
  76         l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node);
  77         if (l2cap->hci == NULL || NG_HOOK_NOT_VALID(l2cap->hci) ||
  78             bcmp(&l2cap->bdaddr, NG_HCI_BDADDR_ANY, sizeof(l2cap->bdaddr)) == 0)
  79                 return;
  80
  81         NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_HOOK_INFO,
  82                 sizeof(bdaddr_t), M_WAITOK | M_NULLOK);
  83         if (msg != NULL) {
  84                 bcopy(&l2cap->bdaddr, msg->data, sizeof(bdaddr_t));
  85                 NG_SEND_MSG_HOOK(error, node, msg, hook, 0);
  86         } else
  87                 error = ENOMEM;
  88
  89         if (error != 0)
  90                 NG_L2CAP_INFO(
  91 "%s: %s - failed to send HOOK_INFO message to hook \"%s\", error=%d\n",
  92                         __func__, NG_NODE_NAME(l2cap->node), NG_HOOK_NAME(hook),
  93                         error);
  94 } /* ng_l2cap_send_hook_info */
  95
  96 /*
  97  * Create new connection descriptor for the "remote" unit.
  98  * Will link connection descriptor to the l2cap node.
  99  */
 100
 101 ng_l2cap_con_p
 102 ng_l2cap_new_con(ng_l2cap_p l2cap, bdaddr_p bdaddr)
 103 {
 104         static int      fake_con_handle = 0x0f00;
 105         ng_l2cap_con_p  con = NULL;
 106
 107         /* Create new connection descriptor */
 108         MALLOC(con, ng_l2cap_con_p, sizeof(*con), M_NETGRAPH_L2CAP,
 109                 M_WAITOK | M_NULLOK | M_ZERO);
 110         if (con == NULL)
 111                 return (NULL);
 112
 113         con->l2cap = l2cap;
 114         con->state = NG_L2CAP_CON_CLOSED;
 115
 116         /*
 117          * XXX
 118          *
 119          * Assign fake connection handle to the connection descriptor.
 120          * Bluetooth specification marks 0x0f00 - 0x0fff connection
 121          * handles as reserved. We need this fake connection handles
 122          * for timeouts. Connection handle will be passed as argument
 123          * to timeout so when timeout happens we can find the right
 124          * connection descriptor. We can not pass pointers, because
 125          * timeouts are external (to Netgraph) events and there might
 126          * be a race when node/hook goes down and timeout event already
 127          * went into node's queue
 128          */
 129
 130         con->con_handle = fake_con_handle ++;
 131         if (fake_con_handle > 0x0fff)
 132                 fake_con_handle = 0x0f00;
 133
 134         bcopy(bdaddr, &con->remote, sizeof(con->remote));
 135         ng_callout_init(&con->con_timo);
 136
 137         con->ident = NG_L2CAP_FIRST_IDENT - 1;
 138         TAILQ_INIT(&con->cmd_list);
 139
 140         /* Link connection */
 141         LIST_INSERT_HEAD(&l2cap->con_list, con, next);
 142
 143         return (con);
 144 } /* ng_l2cap_new_con */
 145
 146 /*
 147  * Add reference to the connection descriptor
 148  */
 149
 150 void
 151 ng_l2cap_con_ref(ng_l2cap_con_p con)
 152 {
 153         con->refcnt ++;
 154
 155         if (con->flags & NG_L2CAP_CON_AUTO_DISCON_TIMO) {
 156                 if ((con->state != NG_L2CAP_CON_OPEN) ||
 157                     (con->flags & NG_L2CAP_CON_OUTGOING) == 0)
 158                         panic(
 159 "%s: %s - bad auto disconnect timeout, state=%d, flags=%#x\n",
 160                                 __func__, NG_NODE_NAME(con->l2cap->node),
 161                                 con->state, con->flags);
 162
 163                 ng_l2cap_discon_untimeout(con);
 164         }
 165 } /* ng_l2cap_con_ref */
 166
 167 /*
 168  * Remove reference from the connection descriptor
 169  */
 170
 171 void
 172 ng_l2cap_con_unref(ng_l2cap_con_p con)
 173 {
 174         con->refcnt --;
 175
 176         if (con->refcnt < 0)
 177                 panic(
 178 "%s: %s - con->refcnt < 0\n", __func__, NG_NODE_NAME(con->l2cap->node));
 179
 180         /*
 181          * Set auto disconnect timer only if the following conditions are met:
 182          * 1) we have no reference on the connection
 183          * 2) connection is in OPEN state
 184          * 3) it is an outgoing connection
 185          * 4) disconnect timeout > 0
 186          * 5) connection is not dying
 187          */
 188
 189         if ((con->refcnt == 0) &&
 190             (con->state == NG_L2CAP_CON_OPEN) &&
 191             (con->flags & NG_L2CAP_CON_OUTGOING) &&
 192             (con->l2cap->discon_timo > 0) &&
 193             ((con->flags & NG_L2CAP_CON_DYING) == 0))
 194                 ng_l2cap_discon_timeout(con);
 195 } /* ng_l2cap_con_unref */
 196
 197 /*
 198  * Set auto disconnect timeout
 199  * XXX FIXME: check return code from ng_callout
 200  */
 201
 202 int
 203 ng_l2cap_discon_timeout(ng_l2cap_con_p con)
 204 {
 205         if (con->flags & (NG_L2CAP_CON_LP_TIMO|NG_L2CAP_CON_AUTO_DISCON_TIMO))
 206                 panic(
 207 "%s: %s - invalid timeout, state=%d, flags=%#x\n",
 208                         __func__, NG_NODE_NAME(con->l2cap->node),
 209                         con->state, con->flags);
 210
 211         con->flags |= NG_L2CAP_CON_AUTO_DISCON_TIMO;
 212         ng_callout(&con->con_timo, con->l2cap->node, NULL,
 213                                 con->l2cap->discon_timo * hz,
 214                                 ng_l2cap_process_discon_timeout, NULL,
 215                                 con->con_handle);
 216
 217         return (0);
 218 } /* ng_l2cap_discon_timeout */
 219
 220 /*
 221  * Unset auto disconnect timeout
 222  */
 223
 224 int
 225 ng_l2cap_discon_untimeout(ng_l2cap_con_p con)
 226 {
 227         if (!(con->flags & NG_L2CAP_CON_AUTO_DISCON_TIMO))
 228                 panic(
 229 "%s: %s - no disconnect timeout, state=%d, flags=%#x\n",
 230                         __func__,  NG_NODE_NAME(con->l2cap->node),
 231                         con->state, con->flags);
 232
 233         if (ng_uncallout(&con->con_timo, con->l2cap->node) == 0)
 234                 return (ETIMEDOUT);
 235
 236         con->flags &= ~NG_L2CAP_CON_AUTO_DISCON_TIMO;
 237
 238         return (0);
 239 } /* ng_l2cap_discon_untimeout */
 240
 241 /*
 242  * Free connection descriptor. Will unlink connection and free everything.
 243  */
 244
 245 void
 246 ng_l2cap_free_con(ng_l2cap_con_p con)
 247 {
 248         ng_l2cap_chan_p f = NULL, n = NULL;
 249
 250         con->state = NG_L2CAP_CON_CLOSED;
 251
 252         while (con->tx_pkt != NULL) {
 253                 struct mbuf     *m = con->tx_pkt->m_nextpkt;
 254
 255                 m_freem(con->tx_pkt);
 256                 con->tx_pkt = m;
 257         }
 258
 259         NG_FREE_M(con->rx_pkt);
 260
 261         for (f = LIST_FIRST(&con->l2cap->chan_list); f != NULL; ) {
 262                 n = LIST_NEXT(f, next);
 263
 264                 if (f->con == con)
 265                         ng_l2cap_free_chan(f);
 266
 267                 f = n;
 268         }
 269
 270         while (!TAILQ_EMPTY(&con->cmd_list)) {
 271                 ng_l2cap_cmd_p  cmd = TAILQ_FIRST(&con->cmd_list);
 272
 273                 ng_l2cap_unlink_cmd(cmd);
 274                 if (cmd->flags & NG_L2CAP_CMD_PENDING)
 275                         ng_l2cap_command_untimeout(cmd);
 276                 ng_l2cap_free_cmd(cmd);
 277         }
 278
 279         if (con->flags & (NG_L2CAP_CON_AUTO_DISCON_TIMO|NG_L2CAP_CON_LP_TIMO))
 280                 panic(
 281 "%s: %s - timeout pending! state=%d, flags=%#x\n",
 282                         __func__,  NG_NODE_NAME(con->l2cap->node),
 283                         con->state, con->flags);
 284
 285         LIST_REMOVE(con, next);
 286
 287         bzero(con, sizeof(*con));
 288         FREE(con, M_NETGRAPH_L2CAP);
 289 } /* ng_l2cap_free_con */
 290
 291 /*
 292  * Get connection by "remote" address
 293  */
 294
 295 ng_l2cap_con_p
 296 ng_l2cap_con_by_addr(ng_l2cap_p l2cap, bdaddr_p bdaddr)
 297 {
 298         ng_l2cap_con_p  con = NULL;
 299
 300         LIST_FOREACH(con, &l2cap->con_list, next)
 301                 if (bcmp(bdaddr, &con->remote, sizeof(con->remote)) == 0)
 302                         break;
 303
 304         return (con);
 305 } /* ng_l2cap_con_by_addr */
 306
 307 /*
 308  * Get connection by "handle"
 309  */
 310
 311 ng_l2cap_con_p
 312 ng_l2cap_con_by_handle(ng_l2cap_p l2cap, u_int16_t con_handle)
 313 {
 314         ng_l2cap_con_p  con = NULL;
 315
 316         LIST_FOREACH(con, &l2cap->con_list, next)
 317                 if (con->con_handle == con_handle)
 318                         break;
 319
 320         return (con);
 321 } /* ng_l2cap_con_by_handle */
 322
 323 /*
 324  * Allocate new L2CAP channel descriptor on "con" conection with "psm".
 325  * Will link the channel to the l2cap node
 326  */
 327
 328 ng_l2cap_chan_p
 329 ng_l2cap_new_chan(ng_l2cap_p l2cap, ng_l2cap_con_p con, u_int16_t psm)
 330 {
 331         ng_l2cap_chan_p ch = NULL;
 332
 333         MALLOC(ch, ng_l2cap_chan_p, sizeof(*ch), M_NETGRAPH_L2CAP,
 334                 M_WAITOK | M_NULLOK | M_ZERO);
 335         if (ch == NULL)
 336                 return (NULL);
 337
 338         ch->scid = ng_l2cap_get_cid(l2cap);
 339
 340         if (ch->scid != NG_L2CAP_NULL_CID) {
 341                 /* Initialize channel */
 342                 ch->psm = psm;
 343                 ch->con = con;
 344                 ch->state = NG_L2CAP_CLOSED;
 345
 346                 /* Set MTU and flow control settings to defaults */
 347                 ch->imtu = NG_L2CAP_MTU_DEFAULT;
 348                 bcopy(ng_l2cap_default_flow(), &ch->iflow, sizeof(ch->iflow));
 349
 350                 ch->omtu = NG_L2CAP_MTU_DEFAULT;
 351                 bcopy(ng_l2cap_default_flow(), &ch->oflow, sizeof(ch->oflow));
 352
 353                 ch->flush_timo = NG_L2CAP_FLUSH_TIMO_DEFAULT;
 354                 ch->link_timo = NG_L2CAP_LINK_TIMO_DEFAULT;
 355
 356                 LIST_INSERT_HEAD(&l2cap->chan_list, ch, next);
 357
 358                 ng_l2cap_con_ref(con);
 359         } else {
 360                 bzero(ch, sizeof(*ch));
 361                 FREE(ch, M_NETGRAPH_L2CAP);
 362                 ch = NULL;
 363         }
 364
 365         return (ch);
 366 } /* ng_l2cap_new_chan */
 367
 368 /*
 369  * Get channel by source (local) channel ID
 370  */
 371
 372 ng_l2cap_chan_p
 373 ng_l2cap_chan_by_scid(ng_l2cap_p l2cap, u_int16_t scid)
 374 {
 375         ng_l2cap_chan_p ch = NULL;
 376
 377         LIST_FOREACH(ch, &l2cap->chan_list, next)
 378                 if (ch->scid == scid)
 379                         break;
 380
 381         return (ch);
 382 } /* ng_l2cap_chan_by_scid */
 383
 384 /*
 385  * Free channel descriptor.
 386  */
 387
 388 void
 389 ng_l2cap_free_chan(ng_l2cap_chan_p ch)
 390 {
 391         ng_l2cap_cmd_p  f = NULL, n = NULL;
 392
 393         f = TAILQ_FIRST(&ch->con->cmd_list);
 394         while (f != NULL) {
 395                 n = TAILQ_NEXT(f, next);
 396
 397                 if (f->ch == ch) {
 398                         ng_l2cap_unlink_cmd(f);
 399                         if (f->flags & NG_L2CAP_CMD_PENDING)
 400                                 ng_l2cap_command_untimeout(f);
 401                         ng_l2cap_free_cmd(f);
 402                 }
 403
 404                 f = n;
 405         }
 406
 407         LIST_REMOVE(ch, next);
 408
 409         ng_l2cap_con_unref(ch->con);
 410
 411         bzero(ch, sizeof(*ch));
 412         FREE(ch, M_NETGRAPH_L2CAP);
 413 } /* ng_l2cap_free_chan */
 414
 415 /*
 416  * Create new L2CAP command descriptor. WILL NOT add command to the queue.
 417  */
 418
 419 ng_l2cap_cmd_p
 420 ng_l2cap_new_cmd(ng_l2cap_con_p con, ng_l2cap_chan_p ch, u_int8_t ident,
 421                 u_int8_t code, u_int32_t token)
 422 {
 423         ng_l2cap_cmd_p  cmd = NULL;
 424
 425         KASSERT((ch == NULL || ch->con == con),
 426 ("%s: %s - invalid channel pointer!\n",
 427                 __func__, NG_NODE_NAME(con->l2cap->node)));
 428
 429         MALLOC(cmd, ng_l2cap_cmd_p, sizeof(*cmd), M_NETGRAPH_L2CAP,
 430                 M_WAITOK | M_NULLOK | M_ZERO);
 431         if (cmd == NULL)
 432                 return (NULL);
 433
 434         cmd->con = con;
 435         cmd->ch = ch;
 436         cmd->ident = ident;
 437         cmd->code = code;
 438         cmd->token = token;
 439         ng_callout_init(&cmd->timo);
 440
 441         return (cmd);
 442 } /* ng_l2cap_new_cmd */
 443
 444 /*
 445  * Get pending (i.e. initiated by local side) L2CAP command descriptor by ident
 446  */
 447
 448 ng_l2cap_cmd_p
 449 ng_l2cap_cmd_by_ident(ng_l2cap_con_p con, u_int8_t ident)
 450 {
 451         ng_l2cap_cmd_p  cmd = NULL;
 452
 453         TAILQ_FOREACH(cmd, &con->cmd_list, next) {
 454                 if ((cmd->flags & NG_L2CAP_CMD_PENDING) && cmd->ident == ident) {
 455                         KASSERT((cmd->con == con),
 456 ("%s: %s - invalid connection pointer!\n",
 457                                 __func__, NG_NODE_NAME(con->l2cap->node)));
 458
 459                         break;
 460                 }
 461         }
 462
 463         return (cmd);
 464 } /* ng_l2cap_cmd_by_ident */
 465
 466 /*
 467  * Set LP timeout
 468  * XXX FIXME: check return code from ng_callout
 469  */
 470
 471 int
 472 ng_l2cap_lp_timeout(ng_l2cap_con_p con)
 473 {
 474         if (con->flags & (NG_L2CAP_CON_LP_TIMO|NG_L2CAP_CON_AUTO_DISCON_TIMO))
 475                 panic(
 476 "%s: %s - invalid timeout, state=%d, flags=%#x\n",
 477                         __func__, NG_NODE_NAME(con->l2cap->node),
 478                         con->state, con->flags);
 479
 480         con->flags |= NG_L2CAP_CON_LP_TIMO;
 481         ng_callout(&con->con_timo, con->l2cap->node, NULL,
 482                                 bluetooth_hci_connect_timeout(),
 483                                 ng_l2cap_process_lp_timeout, NULL,
 484                                 con->con_handle);
 485
 486         return (0);
 487 } /* ng_l2cap_lp_timeout */
 488
 489 /*
 490  * Unset LP timeout
 491  */
 492
 493 int
 494 ng_l2cap_lp_untimeout(ng_l2cap_con_p con)
 495 {
 496         if (!(con->flags & NG_L2CAP_CON_LP_TIMO))
 497                 panic(
 498 "%s: %s - no LP connection timeout, state=%d, flags=%#x\n",
 499                         __func__,  NG_NODE_NAME(con->l2cap->node),
 500                         con->state, con->flags);
 501
 502         if (ng_uncallout(&con->con_timo, con->l2cap->node) == 0)
 503                 return (ETIMEDOUT);
 504
 505         con->flags &= ~NG_L2CAP_CON_LP_TIMO;
 506
 507         return (0);
 508 } /* ng_l2cap_lp_untimeout */
 509
 510 /*
 511  * Set L2CAP command timeout
 512  * XXX FIXME: check return code from ng_callout
 513  */
 514
 515 int
 516 ng_l2cap_command_timeout(ng_l2cap_cmd_p cmd, int timo)
 517 {
 518         int     arg;
 519
 520         if (cmd->flags & NG_L2CAP_CMD_PENDING)
 521                 panic(
 522 "%s: %s - duplicated command timeout, code=%#x, flags=%#x\n",
 523                         __func__, NG_NODE_NAME(cmd->con->l2cap->node),
 524                         cmd->code, cmd->flags);
 525
 526         arg = ((cmd->ident << 16) | cmd->con->con_handle);
 527         cmd->flags |= NG_L2CAP_CMD_PENDING;
 528         ng_callout(&cmd->timo, cmd->con->l2cap->node, NULL, timo,
 529                                 ng_l2cap_process_command_timeout, NULL, arg);
 530
 531         return (0);
 532 } /* ng_l2cap_command_timeout */
 533
 534 /*
 535  * Unset L2CAP command timeout
 536  */
 537
 538 int
 539 ng_l2cap_command_untimeout(ng_l2cap_cmd_p cmd)
 540 {
 541         if (!(cmd->flags & NG_L2CAP_CMD_PENDING))
 542                 panic(
 543 "%s: %s - no command timeout, code=%#x, flags=%#x\n",
 544                         __func__, NG_NODE_NAME(cmd->con->l2cap->node),
 545                         cmd->code, cmd->flags);
 546
 547         if (ng_uncallout(&cmd->timo, cmd->con->l2cap->node) == 0)
 548                 return (ETIMEDOUT);
 549
 550         cmd->flags &= ~NG_L2CAP_CMD_PENDING;
 551
 552         return (0);
 553 } /* ng_l2cap_command_untimeout */
 554
 555 /*
 556  * Prepend "m"buf with "size" bytes
 557  */
 558
 559 struct mbuf *
 560 ng_l2cap_prepend(struct mbuf *m, int size)
 561 {
 562         M_PREPEND(m, size, MB_DONTWAIT);
 563         if (m == NULL || (m->m_len < size && (m = m_pullup(m, size)) == NULL))
 564                 return (NULL);
 565
 566         return (m);
 567 } /* ng_l2cap_prepend */
 568
 569 /*
 570  * Default flow settings
 571  */
 572
 573 ng_l2cap_flow_p
 574 ng_l2cap_default_flow(void)
 575 {
 576         static ng_l2cap_flow_t  default_flow = {
 577                 /* flags */             0x0,
 578                 /* service_type */      NG_HCI_SERVICE_TYPE_BEST_EFFORT,
 579                 /* token_rate */        0xffffffff, /* maximum */
 580                 /* token_bucket_size */ 0xffffffff, /* maximum */
 581                 /* peak_bandwidth */    0x00000000, /* maximum */
 582                 /* latency */           0xffffffff, /* don't care */
 583                 /* delay_variation */   0xffffffff  /* don't care */
 584         };
 585
 586         return (&default_flow);
 587 } /* ng_l2cap_default_flow */
 588
 589 /*
 590  * Get next available channel ID
 591  * XXX FIXME this is *UGLY* but will do for now
 592  */
 593
 594 static u_int16_t
 595 ng_l2cap_get_cid(ng_l2cap_p l2cap)
 596 {
 597         u_int16_t       cid = l2cap->cid + 1;
 598
 599         if (cid < NG_L2CAP_FIRST_CID)
 600                 cid = NG_L2CAP_FIRST_CID;
 601
 602         while (cid != l2cap->cid) {
 603                 if (ng_l2cap_chan_by_scid(l2cap, cid) == NULL) {
 604                         l2cap->cid = cid;
 605
 606                         return (cid);
 607                 }
 608
 609                 cid ++;
 610                 if (cid < NG_L2CAP_FIRST_CID)
 611                         cid = NG_L2CAP_FIRST_CID;
 612         }
 613
 614         return (NG_L2CAP_NULL_CID);
 615 } /* ng_l2cap_get_cid */
 616
 617 /*
 618  * Get next available command ident
 619  * XXX FIXME this is *UGLY* but will do for now
 620  */
 621
 622 u_int8_t
 623 ng_l2cap_get_ident(ng_l2cap_con_p con)
 624 {
 625         u_int8_t        ident = con->ident + 1;
 626
 627         if (ident < NG_L2CAP_FIRST_IDENT)
 628                 ident = NG_L2CAP_FIRST_IDENT;
 629
 630         while (ident != con->ident) {
 631                 if (ng_l2cap_cmd_by_ident(con, ident) == NULL) {
 632                         con->ident = ident;
 633
 634                         return (ident);
 635                 }
 636
 637                 ident ++;
 638                 if (ident < NG_L2CAP_FIRST_IDENT)
 639                         ident = NG_L2CAP_FIRST_IDENT;
 640         }
 641
 642         return (NG_L2CAP_NULL_IDENT);
 643 } /* ng_l2cap_get_ident */
 644