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