1 /* 2 * ng_l2cap_main.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_main.c,v 1.2 2003/04/28 21:44:59 max Exp $ 31 * $FreeBSD: src/sys/netgraph/bluetooth/l2cap/ng_l2cap_main.c,v 1.5 2005/01/07 01:45:43 imp Exp $ 32 * $DragonFly: src/sys/netgraph7/bluetooth/l2cap/ng_l2cap_main.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 "ng_parse.h" 44 #include "bluetooth/include/ng_bluetooth.h" 45 #include "bluetooth/include/ng_hci.h" 46 #include "bluetooth/include/ng_l2cap.h" 47 #include "bluetooth/l2cap/ng_l2cap_var.h" 48 #include "bluetooth/l2cap/ng_l2cap_cmds.h" 49 #include "bluetooth/l2cap/ng_l2cap_evnt.h" 50 #include "bluetooth/l2cap/ng_l2cap_llpi.h" 51 #include "bluetooth/l2cap/ng_l2cap_ulpi.h" 52 #include "bluetooth/l2cap/ng_l2cap_misc.h" 53 #include "bluetooth/l2cap/ng_l2cap_prse.h" 54 55 /****************************************************************************** 56 ****************************************************************************** 57 ** This node implements Link Layer Control and Adaptation Protocol (L2CAP) 58 ****************************************************************************** 59 ******************************************************************************/ 60 61 /* MALLOC define */ 62 #ifdef NG_SEPARATE_MALLOC 63 MALLOC_DEFINE(M_NETGRAPH_L2CAP, "netgraph_l2cap", 64 "Netgraph Bluetooth L2CAP node"); 65 #else 66 #define M_NETGRAPH_L2CAP M_NETGRAPH 67 #endif /* NG_SEPARATE_MALLOC */ 68 69 /* Netgraph node methods */ 70 static ng_constructor_t ng_l2cap_constructor; 71 static ng_shutdown_t ng_l2cap_shutdown; 72 static ng_newhook_t ng_l2cap_newhook; 73 static ng_connect_t ng_l2cap_connect; 74 static ng_disconnect_t ng_l2cap_disconnect; 75 static ng_rcvmsg_t ng_l2cap_lower_rcvmsg; 76 static ng_rcvmsg_t ng_l2cap_upper_rcvmsg; 77 static ng_rcvmsg_t ng_l2cap_default_rcvmsg; 78 static ng_rcvdata_t ng_l2cap_rcvdata; 79 80 /* Netgraph node type descriptor */ 81 static struct ng_type typestruct = { 82 .version = NG_ABI_VERSION, 83 .name = NG_L2CAP_NODE_TYPE, 84 .constructor = ng_l2cap_constructor, 85 .rcvmsg = ng_l2cap_default_rcvmsg, 86 .shutdown = ng_l2cap_shutdown, 87 .newhook = ng_l2cap_newhook, 88 .connect = ng_l2cap_connect, 89 .rcvdata = ng_l2cap_rcvdata, 90 .disconnect = ng_l2cap_disconnect, 91 .cmdlist = ng_l2cap_cmdlist, 92 }; 93 NETGRAPH_INIT(l2cap, &typestruct); 94 MODULE_VERSION(ng_l2cap, NG_BLUETOOTH_VERSION); 95 MODULE_DEPEND(ng_l2cap, ng_bluetooth, NG_BLUETOOTH_VERSION, 96 NG_BLUETOOTH_VERSION, NG_BLUETOOTH_VERSION); 97 98 /***************************************************************************** 99 ***************************************************************************** 100 ** Netgraph methods implementation 101 ***************************************************************************** 102 *****************************************************************************/ 103 104 static void ng_l2cap_cleanup (ng_l2cap_p); 105 static void ng_l2cap_destroy_channels (ng_l2cap_p); 106 107 /* 108 * Create new instance of L2CAP node 109 */ 110 111 static int 112 ng_l2cap_constructor(node_p node) 113 { 114 ng_l2cap_p l2cap = NULL; 115 116 /* Create new L2CAP node */ 117 MALLOC(l2cap, ng_l2cap_p, sizeof(*l2cap), 118 M_NETGRAPH_L2CAP, M_WAITOK | M_NULLOK | M_ZERO); 119 if (l2cap == NULL) 120 return (ENOMEM); 121 122 l2cap->node = node; 123 l2cap->debug = NG_L2CAP_WARN_LEVEL; 124 l2cap->discon_timo = 5; /* sec */ 125 126 LIST_INIT(&l2cap->con_list); 127 LIST_INIT(&l2cap->chan_list); 128 129 NG_NODE_SET_PRIVATE(node, l2cap); 130 NG_NODE_FORCE_WRITER(node); 131 132 return (0); 133 } /* ng_l2cap_constructor */ 134 135 /* 136 * Shutdown L2CAP node 137 */ 138 139 static int 140 ng_l2cap_shutdown(node_p node) 141 { 142 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); 143 144 NG_NODE_SET_PRIVATE(node, NULL); 145 NG_NODE_UNREF(node); 146 147 /* Clean up L2CAP node. Delete all connection, channels and commands */ 148 l2cap->node = NULL; 149 ng_l2cap_cleanup(l2cap); 150 151 bzero(l2cap, sizeof(*l2cap)); 152 FREE(l2cap, M_NETGRAPH_L2CAP); 153 154 return (0); 155 } /* ng_l2cap_shutdown */ 156 157 /* 158 * Give our OK for a hook to be added. HCI layer is connected to the HCI 159 * (NG_L2CAP_HOOK_HCI) hook. As per specification L2CAP layer MUST provide 160 * Procol/Service Multiplexing, so the L2CAP node provides separate hooks 161 * for SDP (NG_L2CAP_HOOK_SDP), RFCOMM (NG_L2CAP_HOOK_RFCOMM) and TCP 162 * (NG_L2CAP_HOOK_TCP) protcols. Unknown PSM will be forwarded to 163 * NG_L2CAP_HOOK_ORPHAN hook. Control node/application is connected to 164 * control (NG_L2CAP_HOOK_CTL) hook. 165 */ 166 167 static int 168 ng_l2cap_newhook(node_p node, hook_p hook, char const *name) 169 { 170 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); 171 hook_p *h = NULL; 172 173 if (strcmp(name, NG_L2CAP_HOOK_HCI) == 0) 174 h = &l2cap->hci; 175 else if (strcmp(name, NG_L2CAP_HOOK_L2C) == 0) 176 h = &l2cap->l2c; 177 else if (strcmp(name, NG_L2CAP_HOOK_CTL) == 0) 178 h = &l2cap->ctl; 179 else 180 return (EINVAL); 181 182 if (*h != NULL) 183 return (EISCONN); 184 185 *h = hook; 186 187 return (0); 188 } /* ng_l2cap_newhook */ 189 190 /* 191 * Give our final OK to connect hook. Nothing to do here. 192 */ 193 194 static int 195 ng_l2cap_connect(hook_p hook) 196 { 197 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 198 int error = 0; 199 200 if (hook == l2cap->hci) 201 NG_HOOK_SET_RCVMSG(hook, ng_l2cap_lower_rcvmsg); 202 else 203 if (hook == l2cap->l2c || hook == l2cap->ctl) { 204 NG_HOOK_SET_RCVMSG(hook, ng_l2cap_upper_rcvmsg); 205 206 /* Send delayed notification to the upper layer */ 207 error = ng_send_fn(l2cap->node, hook, ng_l2cap_send_hook_info, 208 NULL, 0); 209 } else 210 error = EINVAL; 211 212 return (error); 213 } /* ng_l2cap_connect */ 214 215 /* 216 * Disconnect the hook. For downstream hook we must notify upper layers. 217 * 218 * XXX For upstream hooks this is really ugly :( Hook was disconnected and it 219 * XXX is now too late to do anything. For now we just clean up our own mess 220 * XXX and remove all channels that use disconnected upstream hook. If we don't 221 * XXX do that then L2CAP node can get out of sync with upper layers. 222 * XXX No notification will be sent to remote peer. 223 */ 224 225 static int 226 ng_l2cap_disconnect(hook_p hook) 227 { 228 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 229 hook_p *h = NULL; 230 231 if (hook == l2cap->hci) { 232 ng_l2cap_cleanup(l2cap); 233 h = &l2cap->hci; 234 } else 235 if (hook == l2cap->l2c) { 236 ng_l2cap_destroy_channels(l2cap); 237 h = &l2cap->l2c; 238 } else 239 if (hook == l2cap->ctl) 240 h = &l2cap->ctl; 241 else 242 return (EINVAL); 243 244 *h = NULL; 245 246 /* Shutdown when all hooks are disconnected */ 247 if (NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0 && 248 NG_NODE_IS_VALID(NG_HOOK_NODE(hook))) 249 ng_rmnode_self(NG_HOOK_NODE(hook)); 250 251 return (0); 252 } /* ng_l2cap_disconnect */ 253 254 /* 255 * Process control message from lower layer 256 */ 257 258 static int 259 ng_l2cap_lower_rcvmsg(node_p node, item_p item, hook_p lasthook) 260 { 261 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); 262 struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ 263 int error = 0; 264 265 switch (msg->header.typecookie) { 266 case NGM_HCI_COOKIE: 267 switch (msg->header.cmd) { 268 /* HCI node is ready */ 269 case NGM_HCI_NODE_UP: { 270 ng_hci_node_up_ep *ep = NULL; 271 272 if (msg->header.arglen != sizeof(*ep)) 273 error = EMSGSIZE; 274 else { 275 ep = (ng_hci_node_up_ep *)(msg->data); 276 277 NG_L2CAP_INFO( 278 "%s: %s - HCI node is up, bdaddr: %x:%x:%x:%x:%x:%x, " \ 279 "pkt_size=%d bytes, num_pkts=%d\n", __func__, NG_NODE_NAME(l2cap->node), 280 ep->bdaddr.b[5], ep->bdaddr.b[4], 281 ep->bdaddr.b[3], ep->bdaddr.b[2], 282 ep->bdaddr.b[1], ep->bdaddr.b[0], 283 ep->pkt_size, ep->num_pkts); 284 285 bcopy(&ep->bdaddr, &l2cap->bdaddr, 286 sizeof(l2cap->bdaddr)); 287 l2cap->pkt_size = ep->pkt_size; 288 l2cap->num_pkts = ep->num_pkts; 289 290 /* Notify upper layers */ 291 ng_l2cap_send_hook_info(l2cap->node, 292 l2cap->l2c, NULL, 0); 293 ng_l2cap_send_hook_info(l2cap->node, 294 l2cap->ctl, NULL, 0); 295 } 296 } break; 297 298 case NGM_HCI_SYNC_CON_QUEUE: { 299 ng_hci_sync_con_queue_ep *ep = NULL; 300 ng_l2cap_con_p con = NULL; 301 302 if (msg->header.arglen != sizeof(*ep)) 303 error = EMSGSIZE; 304 else { 305 ep = (ng_hci_sync_con_queue_ep *)(msg->data); 306 con = ng_l2cap_con_by_handle(l2cap, 307 ep->con_handle); 308 if (con == NULL) 309 break; 310 311 NG_L2CAP_INFO( 312 "%s: %s - sync HCI connection queue, con_handle=%d, pending=%d, completed=%d\n", 313 __func__, NG_NODE_NAME(l2cap->node), 314 ep->con_handle, con->pending, 315 ep->completed); 316 317 con->pending -= ep->completed; 318 if (con->pending < 0) { 319 NG_L2CAP_WARN( 320 "%s: %s - pending packet counter is out of sync! " \ 321 "con_handle=%d, pending=%d, completed=%d\n", __func__, 322 NG_NODE_NAME(l2cap->node), 323 con->con_handle, con->pending, 324 ep->completed); 325 326 con->pending = 0; 327 } 328 329 ng_l2cap_lp_deliver(con); 330 } 331 } break; 332 333 /* LP_ConnectCfm[Neg] */ 334 case NGM_HCI_LP_CON_CFM: 335 error = ng_l2cap_lp_con_cfm(l2cap, msg); 336 break; 337 338 /* LP_ConnectInd */ 339 case NGM_HCI_LP_CON_IND: 340 error = ng_l2cap_lp_con_ind(l2cap, msg); 341 break; 342 343 /* LP_DisconnectInd */ 344 case NGM_HCI_LP_DISCON_IND: 345 error = ng_l2cap_lp_discon_ind(l2cap, msg); 346 break; 347 348 /* LP_QoSSetupCfm[Neg] */ 349 case NGM_HCI_LP_QOS_CFM: 350 error = ng_l2cap_lp_qos_cfm(l2cap, msg); 351 break; 352 353 /* LP_OoSViolationInd */ 354 case NGM_HCI_LP_QOS_IND: 355 error = ng_l2cap_lp_qos_ind(l2cap, msg); 356 break; 357 358 default: 359 error = EINVAL; 360 break; 361 } 362 break; 363 364 default: 365 return (ng_l2cap_default_rcvmsg(node, item, lasthook)); 366 /* NOT REACHED */ 367 } 368 369 NG_FREE_ITEM(item); 370 371 return (error); 372 } /* ng_l2cap_lower_rcvmsg */ 373 374 /* 375 * Process control message from upper layer 376 */ 377 378 static int 379 ng_l2cap_upper_rcvmsg(node_p node, item_p item, hook_p lasthook) 380 { 381 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); 382 struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ 383 int error = 0; 384 385 switch (msg->header.typecookie) { 386 case NGM_L2CAP_COOKIE: 387 switch (msg->header.cmd) { 388 /* L2CA_Connect */ 389 case NGM_L2CAP_L2CA_CON: 390 error = ng_l2cap_l2ca_con_req(l2cap, msg); 391 break; 392 393 /* L2CA_ConnectRsp */ 394 case NGM_L2CAP_L2CA_CON_RSP: 395 error = ng_l2cap_l2ca_con_rsp_req(l2cap, msg); 396 break; 397 398 /* L2CA_Config */ 399 case NGM_L2CAP_L2CA_CFG: 400 error = ng_l2cap_l2ca_cfg_req(l2cap, msg); 401 break; 402 403 /* L2CA_ConfigRsp */ 404 case NGM_L2CAP_L2CA_CFG_RSP: 405 error = ng_l2cap_l2ca_cfg_rsp_req(l2cap, msg); 406 break; 407 408 /* L2CA_Disconnect */ 409 case NGM_L2CAP_L2CA_DISCON: 410 error = ng_l2cap_l2ca_discon_req(l2cap, msg); 411 break; 412 413 /* L2CA_GroupCreate */ 414 case NGM_L2CAP_L2CA_GRP_CREATE: 415 error = ng_l2cap_l2ca_grp_create(l2cap, msg); 416 break; 417 418 /* L2CA_GroupClose */ 419 case NGM_L2CAP_L2CA_GRP_CLOSE: 420 error = ng_l2cap_l2ca_grp_close(l2cap, msg); 421 break; 422 423 /* L2CA_GroupAddMember */ 424 case NGM_L2CAP_L2CA_GRP_ADD_MEMBER: 425 error = ng_l2cap_l2ca_grp_add_member_req(l2cap, msg); 426 break; 427 428 /* L2CA_GroupDeleteMember */ 429 case NGM_L2CAP_L2CA_GRP_REM_MEMBER: 430 error = ng_l2cap_l2ca_grp_rem_member(l2cap, msg); 431 break; 432 433 /* L2CA_GroupMembership */ 434 case NGM_L2CAP_L2CA_GRP_MEMBERSHIP: 435 error = ng_l2cap_l2ca_grp_get_members(l2cap, msg); 436 break; 437 438 /* L2CA_Ping */ 439 case NGM_L2CAP_L2CA_PING: 440 error = ng_l2cap_l2ca_ping_req(l2cap, msg); 441 break; 442 443 /* L2CA_GetInfo */ 444 case NGM_L2CAP_L2CA_GET_INFO: 445 error = ng_l2cap_l2ca_get_info_req(l2cap, msg); 446 break; 447 448 /* L2CA_EnableCLT */ 449 case NGM_L2CAP_L2CA_ENABLE_CLT: 450 error = ng_l2cap_l2ca_enable_clt(l2cap, msg); 451 break; 452 453 default: 454 return (ng_l2cap_default_rcvmsg(node, item, lasthook)); 455 /* NOT REACHED */ 456 } 457 break; 458 459 default: 460 return (ng_l2cap_default_rcvmsg(node, item, lasthook)); 461 /* NOT REACHED */ 462 } 463 464 NG_FREE_ITEM(item); 465 466 return (error); 467 } /* ng_l2cap_upper_rcvmsg */ 468 469 /* 470 * Default control message processing routine 471 */ 472 473 static int 474 ng_l2cap_default_rcvmsg(node_p node, item_p item, hook_p lasthook) 475 { 476 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); 477 struct ng_mesg *msg = NULL, *rsp = NULL; 478 int error = 0; 479 480 /* Detach and process message */ 481 NGI_GET_MSG(item, msg); 482 483 switch (msg->header.typecookie) { 484 case NGM_GENERIC_COOKIE: 485 switch (msg->header.cmd) { 486 case NGM_TEXT_STATUS: 487 NG_MKRESPONSE(rsp, msg, NG_TEXTRESPONSE, M_WAITOK | M_NULLOK); 488 if (rsp == NULL) 489 error = ENOMEM; 490 else 491 snprintf(rsp->data, NG_TEXTRESPONSE, 492 "bdaddr %x:%x:%x:%x:%x:%x, " \ 493 "pkt_size %d\n" \ 494 "Hooks %s %s %s\n" \ 495 "Flags %#x\n", 496 l2cap->bdaddr.b[5], l2cap->bdaddr.b[4], 497 l2cap->bdaddr.b[3], l2cap->bdaddr.b[2], 498 l2cap->bdaddr.b[1], l2cap->bdaddr.b[0], 499 l2cap->pkt_size, 500 (l2cap->hci != NULL)? 501 NG_L2CAP_HOOK_HCI : "", 502 (l2cap->l2c != NULL)? 503 NG_L2CAP_HOOK_L2C : "", 504 (l2cap->ctl != NULL)? 505 NG_L2CAP_HOOK_CTL : "", 506 l2cap->flags); 507 break; 508 509 default: 510 error = EINVAL; 511 break; 512 } 513 break; 514 515 /* Messages from the upper layer or directed to the local node */ 516 case NGM_L2CAP_COOKIE: 517 switch (msg->header.cmd) { 518 /* Get node flags */ 519 case NGM_L2CAP_NODE_GET_FLAGS: 520 NG_MKRESPONSE(rsp, msg, sizeof(ng_l2cap_node_flags_ep), 521 M_WAITOK | M_NULLOK); 522 if (rsp == NULL) 523 error = ENOMEM; 524 else 525 *((ng_l2cap_node_flags_ep *)(rsp->data)) = 526 l2cap->flags; 527 break; 528 529 /* Get node debug */ 530 case NGM_L2CAP_NODE_GET_DEBUG: 531 NG_MKRESPONSE(rsp, msg, sizeof(ng_l2cap_node_debug_ep), 532 M_WAITOK | M_NULLOK); 533 if (rsp == NULL) 534 error = ENOMEM; 535 else 536 *((ng_l2cap_node_debug_ep *)(rsp->data)) = 537 l2cap->debug; 538 break; 539 540 /* Set node debug */ 541 case NGM_L2CAP_NODE_SET_DEBUG: 542 if (msg->header.arglen != 543 sizeof(ng_l2cap_node_debug_ep)) 544 error = EMSGSIZE; 545 else 546 l2cap->debug = 547 *((ng_l2cap_node_debug_ep *)(msg->data)); 548 break; 549 550 /* Get connection list */ 551 case NGM_L2CAP_NODE_GET_CON_LIST: { 552 ng_l2cap_con_p con = NULL; 553 ng_l2cap_node_con_list_ep *e1 = NULL; 554 ng_l2cap_node_con_ep *e2 = NULL; 555 int n = 0; 556 557 /* Count number of connections */ 558 LIST_FOREACH(con, &l2cap->con_list, next) 559 n++; 560 if (n > NG_L2CAP_MAX_CON_NUM) 561 n = NG_L2CAP_MAX_CON_NUM; 562 563 /* Prepare response */ 564 NG_MKRESPONSE(rsp, msg, 565 sizeof(*e1) + n * sizeof(*e2), M_WAITOK | M_NULLOK); 566 if (rsp == NULL) { 567 error = ENOMEM; 568 break; 569 } 570 571 e1 = (ng_l2cap_node_con_list_ep *)(rsp->data); 572 e2 = (ng_l2cap_node_con_ep *)(e1 + 1); 573 574 e1->num_connections = n; 575 576 LIST_FOREACH(con, &l2cap->con_list, next) { 577 e2->state = con->state; 578 579 e2->flags = con->flags; 580 if (con->tx_pkt != NULL) 581 e2->flags |= NG_L2CAP_CON_TX; 582 if (con->rx_pkt != NULL) 583 e2->flags |= NG_L2CAP_CON_RX; 584 585 e2->pending = con->pending; 586 587 e2->con_handle = con->con_handle; 588 bcopy(&con->remote, &e2->remote, 589 sizeof(e2->remote)); 590 591 e2 ++; 592 if (--n <= 0) 593 break; 594 } 595 } break; 596 597 /* Get channel list */ 598 case NGM_L2CAP_NODE_GET_CHAN_LIST: { 599 ng_l2cap_chan_p ch = NULL; 600 ng_l2cap_node_chan_list_ep *e1 = NULL; 601 ng_l2cap_node_chan_ep *e2 = NULL; 602 int n = 0; 603 604 /* Count number of channels */ 605 LIST_FOREACH(ch, &l2cap->chan_list, next) 606 n ++; 607 if (n > NG_L2CAP_MAX_CHAN_NUM) 608 n = NG_L2CAP_MAX_CHAN_NUM; 609 610 /* Prepare response */ 611 NG_MKRESPONSE(rsp, msg, 612 sizeof(ng_l2cap_node_chan_list_ep) + 613 n * sizeof(ng_l2cap_node_chan_ep), M_WAITOK | M_NULLOK); 614 if (rsp == NULL) { 615 error = ENOMEM; 616 break; 617 } 618 619 e1 = (ng_l2cap_node_chan_list_ep *)(rsp->data); 620 e2 = (ng_l2cap_node_chan_ep *)(e1 + 1); 621 622 e1->num_channels = n; 623 624 LIST_FOREACH(ch, &l2cap->chan_list, next) { 625 e2->state = ch->state; 626 627 e2->scid = ch->scid; 628 e2->dcid = ch->dcid; 629 630 e2->imtu = ch->imtu; 631 e2->omtu = ch->omtu; 632 633 e2->psm = ch->psm; 634 bcopy(&ch->con->remote, &e2->remote, 635 sizeof(e2->remote)); 636 637 e2 ++; 638 if (--n <= 0) 639 break; 640 } 641 } break; 642 643 case NGM_L2CAP_NODE_GET_AUTO_DISCON_TIMO: 644 NG_MKRESPONSE(rsp, msg, 645 sizeof(ng_l2cap_node_auto_discon_ep), M_WAITOK | M_NULLOK); 646 if (rsp == NULL) 647 error = ENOMEM; 648 else 649 *((ng_l2cap_node_auto_discon_ep *)(rsp->data)) = 650 l2cap->discon_timo; 651 break; 652 653 case NGM_L2CAP_NODE_SET_AUTO_DISCON_TIMO: 654 if (msg->header.arglen != 655 sizeof(ng_l2cap_node_auto_discon_ep)) 656 error = EMSGSIZE; 657 else 658 l2cap->discon_timo = 659 *((ng_l2cap_node_auto_discon_ep *) 660 (msg->data)); 661 break; 662 663 default: 664 error = EINVAL; 665 break; 666 } 667 break; 668 669 default: 670 error = EINVAL; 671 break; 672 } 673 674 NG_RESPOND_MSG(error, node, item, rsp); 675 NG_FREE_MSG(msg); 676 677 return (error); 678 } /* ng_l2cap_rcvmsg */ 679 680 /* 681 * Process data packet from one of our hooks. 682 * 683 * From the HCI hook we expect to receive ACL data packets. ACL data packets 684 * gets re-assembled into one L2CAP packet (according to length) and then gets 685 * processed. 686 * 687 * NOTE: We expect to receive L2CAP packet header in the first fragment. 688 * Otherwise we WILL NOT be able to get length of the L2CAP packet. 689 * 690 * Signaling L2CAP packets (destination channel ID == 0x1) are processed within 691 * the node. Connectionless data packets (destination channel ID == 0x2) will 692 * be forwarded to appropriate upstream hook unless it is not connected or 693 * connectionless traffic for the specified PSM was disabled. 694 * 695 * From the upstream hooks we expect to receive data packets. These data 696 * packets will be converted into L2CAP data packets. The length of each 697 * L2CAP packet must not exceed channel's omtu (our peer's imtu). Then 698 * these L2CAP packets will be converted to ACL data packets (according to 699 * HCI layer MTU) and sent to lower layer. 700 * 701 * No data is expected from the control hook. 702 */ 703 704 static int 705 ng_l2cap_rcvdata(hook_p hook, item_p item) 706 { 707 ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); 708 struct mbuf *m = NULL; 709 int error = 0; 710 711 /* Detach mbuf, discard item and process data */ 712 NGI_GET_M(item, m); 713 NG_FREE_ITEM(item); 714 715 if (hook == l2cap->hci) 716 error = ng_l2cap_lp_receive(l2cap, m); 717 else if (hook == l2cap->l2c) 718 error = ng_l2cap_l2ca_write_req(l2cap, m); 719 else { 720 NG_FREE_M(m); 721 error = EINVAL; 722 } 723 724 return (error); 725 } /* ng_l2cap_rcvdata */ 726 727 /* 728 * Clean all connections, channels and commands for the L2CAP node 729 */ 730 731 static void 732 ng_l2cap_cleanup(ng_l2cap_p l2cap) 733 { 734 ng_l2cap_con_p con = NULL; 735 736 /* Clean up connection and channels */ 737 while (!LIST_EMPTY(&l2cap->con_list)) { 738 con = LIST_FIRST(&l2cap->con_list); 739 740 if (con->flags & NG_L2CAP_CON_LP_TIMO) 741 ng_l2cap_lp_untimeout(con); 742 else if (con->flags & NG_L2CAP_CON_AUTO_DISCON_TIMO) 743 ng_l2cap_discon_untimeout(con); 744 745 /* Connection terminated by local host */ 746 ng_l2cap_con_fail(con, 0x16); 747 } 748 } /* ng_l2cap_cleanup */ 749 750 /* 751 * Destroy all channels that use specified upstream hook 752 */ 753 754 static void 755 ng_l2cap_destroy_channels(ng_l2cap_p l2cap) 756 { 757 while (!LIST_EMPTY(&l2cap->chan_list)) 758 ng_l2cap_free_chan(LIST_FIRST(&l2cap->chan_list)); 759 } /* ng_l2cap_destroy_channels_by_hook */ 760 761