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