1 /* 2 * ng_btsocket_l2cap_raw.c 3 */ 4 5 /*- 6 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 7 * 8 * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $Id: ng_btsocket_l2cap_raw.c,v 1.12 2003/09/14 23:29:06 max Exp $ 33 * $FreeBSD$ 34 */ 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/bitstring.h> 39 #include <sys/domain.h> 40 #include <sys/errno.h> 41 #include <sys/filedesc.h> 42 #include <sys/ioccom.h> 43 #include <sys/kernel.h> 44 #include <sys/lock.h> 45 #include <sys/malloc.h> 46 #include <sys/mbuf.h> 47 #include <sys/mutex.h> 48 #include <sys/priv.h> 49 #include <sys/protosw.h> 50 #include <sys/queue.h> 51 #include <sys/socket.h> 52 #include <sys/socketvar.h> 53 #include <sys/sysctl.h> 54 #include <sys/taskqueue.h> 55 56 #include <net/vnet.h> 57 58 #include <netgraph/ng_message.h> 59 #include <netgraph/netgraph.h> 60 #include <netgraph/bluetooth/include/ng_bluetooth.h> 61 #include <netgraph/bluetooth/include/ng_hci.h> 62 #include <netgraph/bluetooth/include/ng_l2cap.h> 63 #include <netgraph/bluetooth/include/ng_btsocket.h> 64 #include <netgraph/bluetooth/include/ng_btsocket_l2cap.h> 65 66 /* MALLOC define */ 67 #ifdef NG_SEPARATE_MALLOC 68 static MALLOC_DEFINE(M_NETGRAPH_BTSOCKET_L2CAP_RAW, 69 "netgraph_btsocks_l2cap_raw", "Netgraph Bluetooth raw L2CAP sockets"); 70 #else 71 #define M_NETGRAPH_BTSOCKET_L2CAP_RAW M_NETGRAPH 72 #endif /* NG_SEPARATE_MALLOC */ 73 74 /* Netgraph node methods */ 75 static ng_constructor_t ng_btsocket_l2cap_raw_node_constructor; 76 static ng_rcvmsg_t ng_btsocket_l2cap_raw_node_rcvmsg; 77 static ng_shutdown_t ng_btsocket_l2cap_raw_node_shutdown; 78 static ng_newhook_t ng_btsocket_l2cap_raw_node_newhook; 79 static ng_connect_t ng_btsocket_l2cap_raw_node_connect; 80 static ng_rcvdata_t ng_btsocket_l2cap_raw_node_rcvdata; 81 static ng_disconnect_t ng_btsocket_l2cap_raw_node_disconnect; 82 83 static void ng_btsocket_l2cap_raw_input (void *, int); 84 static void ng_btsocket_l2cap_raw_rtclean (void *, int); 85 static void ng_btsocket_l2cap_raw_get_token (u_int32_t *); 86 87 static int ng_btsocket_l2cap_raw_send_ngmsg 88 (hook_p, int, void *, int); 89 static int ng_btsocket_l2cap_raw_send_sync_ngmsg 90 (ng_btsocket_l2cap_raw_pcb_p, int, void *, int); 91 92 #define ng_btsocket_l2cap_raw_wakeup_input_task() \ 93 taskqueue_enqueue(taskqueue_swi, &ng_btsocket_l2cap_raw_queue_task) 94 95 #define ng_btsocket_l2cap_raw_wakeup_route_task() \ 96 taskqueue_enqueue(taskqueue_swi, &ng_btsocket_l2cap_raw_rt_task) 97 98 /* Netgraph type descriptor */ 99 static struct ng_type typestruct = { 100 .version = NG_ABI_VERSION, 101 .name = NG_BTSOCKET_L2CAP_RAW_NODE_TYPE, 102 .constructor = ng_btsocket_l2cap_raw_node_constructor, 103 .rcvmsg = ng_btsocket_l2cap_raw_node_rcvmsg, 104 .shutdown = ng_btsocket_l2cap_raw_node_shutdown, 105 .newhook = ng_btsocket_l2cap_raw_node_newhook, 106 .connect = ng_btsocket_l2cap_raw_node_connect, 107 .rcvdata = ng_btsocket_l2cap_raw_node_rcvdata, 108 .disconnect = ng_btsocket_l2cap_raw_node_disconnect, 109 }; 110 111 /* Globals */ 112 extern int ifqmaxlen; 113 static u_int32_t ng_btsocket_l2cap_raw_debug_level; 114 static u_int32_t ng_btsocket_l2cap_raw_ioctl_timeout; 115 static node_p ng_btsocket_l2cap_raw_node; 116 static struct ng_bt_itemq ng_btsocket_l2cap_raw_queue; 117 static struct mtx ng_btsocket_l2cap_raw_queue_mtx; 118 static struct task ng_btsocket_l2cap_raw_queue_task; 119 static LIST_HEAD(, ng_btsocket_l2cap_raw_pcb) ng_btsocket_l2cap_raw_sockets; 120 static struct mtx ng_btsocket_l2cap_raw_sockets_mtx; 121 static u_int32_t ng_btsocket_l2cap_raw_token; 122 static struct mtx ng_btsocket_l2cap_raw_token_mtx; 123 static LIST_HEAD(, ng_btsocket_l2cap_rtentry) ng_btsocket_l2cap_raw_rt; 124 static struct mtx ng_btsocket_l2cap_raw_rt_mtx; 125 static struct task ng_btsocket_l2cap_raw_rt_task; 126 static struct timeval ng_btsocket_l2cap_raw_lasttime; 127 static int ng_btsocket_l2cap_raw_curpps; 128 129 /* Sysctl tree */ 130 SYSCTL_DECL(_net_bluetooth_l2cap_sockets); 131 static SYSCTL_NODE(_net_bluetooth_l2cap_sockets, OID_AUTO, raw, CTLFLAG_RW, 132 0, "Bluetooth raw L2CAP sockets family"); 133 SYSCTL_UINT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, debug_level, 134 CTLFLAG_RW, 135 &ng_btsocket_l2cap_raw_debug_level, NG_BTSOCKET_WARN_LEVEL, 136 "Bluetooth raw L2CAP sockets debug level"); 137 SYSCTL_UINT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, ioctl_timeout, 138 CTLFLAG_RW, 139 &ng_btsocket_l2cap_raw_ioctl_timeout, 5, 140 "Bluetooth raw L2CAP sockets ioctl timeout"); 141 SYSCTL_UINT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, queue_len, 142 CTLFLAG_RD, 143 &ng_btsocket_l2cap_raw_queue.len, 0, 144 "Bluetooth raw L2CAP sockets input queue length"); 145 SYSCTL_UINT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, queue_maxlen, 146 CTLFLAG_RD, 147 &ng_btsocket_l2cap_raw_queue.maxlen, 0, 148 "Bluetooth raw L2CAP sockets input queue max. length"); 149 SYSCTL_UINT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, queue_drops, 150 CTLFLAG_RD, 151 &ng_btsocket_l2cap_raw_queue.drops, 0, 152 "Bluetooth raw L2CAP sockets input queue drops"); 153 154 /* Debug */ 155 #define NG_BTSOCKET_L2CAP_RAW_INFO \ 156 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_INFO_LEVEL && \ 157 ppsratecheck(&ng_btsocket_l2cap_raw_lasttime, &ng_btsocket_l2cap_raw_curpps, 1)) \ 158 printf 159 160 #define NG_BTSOCKET_L2CAP_RAW_WARN \ 161 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_WARN_LEVEL && \ 162 ppsratecheck(&ng_btsocket_l2cap_raw_lasttime, &ng_btsocket_l2cap_raw_curpps, 1)) \ 163 printf 164 165 #define NG_BTSOCKET_L2CAP_RAW_ERR \ 166 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_ERR_LEVEL && \ 167 ppsratecheck(&ng_btsocket_l2cap_raw_lasttime, &ng_btsocket_l2cap_raw_curpps, 1)) \ 168 printf 169 170 #define NG_BTSOCKET_L2CAP_RAW_ALERT \ 171 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_ALERT_LEVEL && \ 172 ppsratecheck(&ng_btsocket_l2cap_raw_lasttime, &ng_btsocket_l2cap_raw_curpps, 1)) \ 173 printf 174 175 /***************************************************************************** 176 ***************************************************************************** 177 ** Netgraph node interface 178 ***************************************************************************** 179 *****************************************************************************/ 180 181 /* 182 * Netgraph node constructor. Do not allow to create node of this type. 183 */ 184 185 static int 186 ng_btsocket_l2cap_raw_node_constructor(node_p node) 187 { 188 return (EINVAL); 189 } /* ng_btsocket_l2cap_raw_node_constructor */ 190 191 /* 192 * Do local shutdown processing. Let old node go and create new fresh one. 193 */ 194 195 static int 196 ng_btsocket_l2cap_raw_node_shutdown(node_p node) 197 { 198 int error = 0; 199 200 NG_NODE_UNREF(node); 201 202 /* Create new node */ 203 error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_raw_node); 204 if (error != 0) { 205 NG_BTSOCKET_L2CAP_RAW_ALERT( 206 "%s: Could not create Netgraph node, error=%d\n", __func__, error); 207 208 ng_btsocket_l2cap_raw_node = NULL; 209 210 return (error); 211 } 212 213 error = ng_name_node(ng_btsocket_l2cap_raw_node, 214 NG_BTSOCKET_L2CAP_RAW_NODE_TYPE); 215 if (error != 0) { 216 NG_BTSOCKET_L2CAP_RAW_ALERT( 217 "%s: Could not name Netgraph node, error=%d\n", __func__, error); 218 219 NG_NODE_UNREF(ng_btsocket_l2cap_raw_node); 220 ng_btsocket_l2cap_raw_node = NULL; 221 222 return (error); 223 } 224 225 return (0); 226 } /* ng_btsocket_l2cap_raw_node_shutdown */ 227 228 /* 229 * We allow any hook to be connected to the node. 230 */ 231 232 static int 233 ng_btsocket_l2cap_raw_node_newhook(node_p node, hook_p hook, char const *name) 234 { 235 return (0); 236 } /* ng_btsocket_l2cap_raw_node_newhook */ 237 238 /* 239 * Just say "YEP, that's OK by me!" 240 */ 241 242 static int 243 ng_btsocket_l2cap_raw_node_connect(hook_p hook) 244 { 245 NG_HOOK_SET_PRIVATE(hook, NULL); 246 NG_HOOK_REF(hook); /* Keep extra reference to the hook */ 247 248 return (0); 249 } /* ng_btsocket_l2cap_raw_node_connect */ 250 251 /* 252 * Hook disconnection. Schedule route cleanup task 253 */ 254 255 static int 256 ng_btsocket_l2cap_raw_node_disconnect(hook_p hook) 257 { 258 /* 259 * If hook has private information than we must have this hook in 260 * the routing table and must schedule cleaning for the routing table. 261 * Otherwise hook was connected but we never got "hook_info" message, 262 * so we have never added this hook to the routing table and it save 263 * to just delete it. 264 */ 265 266 if (NG_HOOK_PRIVATE(hook) != NULL) 267 return (ng_btsocket_l2cap_raw_wakeup_route_task()); 268 269 NG_HOOK_UNREF(hook); /* Remove extra reference */ 270 271 return (0); 272 } /* ng_btsocket_l2cap_raw_node_disconnect */ 273 274 /* 275 * Process incoming messages 276 */ 277 278 static int 279 ng_btsocket_l2cap_raw_node_rcvmsg(node_p node, item_p item, hook_p hook) 280 { 281 struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ 282 int error = 0; 283 284 if (msg != NULL && msg->header.typecookie == NGM_L2CAP_COOKIE) { 285 286 /* 287 * NGM_L2CAP_NODE_HOOK_INFO is special message initiated by 288 * L2CAP layer. Ignore all other messages if they are not 289 * replies or token is zero 290 */ 291 292 if (msg->header.cmd != NGM_L2CAP_NODE_HOOK_INFO) { 293 if (msg->header.token == 0 || 294 !(msg->header.flags & NGF_RESP)) { 295 NG_FREE_ITEM(item); 296 return (0); 297 } 298 } 299 300 mtx_lock(&ng_btsocket_l2cap_raw_queue_mtx); 301 if (NG_BT_ITEMQ_FULL(&ng_btsocket_l2cap_raw_queue)) { 302 NG_BTSOCKET_L2CAP_RAW_ERR( 303 "%s: Input queue is full\n", __func__); 304 305 NG_BT_ITEMQ_DROP(&ng_btsocket_l2cap_raw_queue); 306 NG_FREE_ITEM(item); 307 error = ENOBUFS; 308 } else { 309 if (hook != NULL) { 310 NG_HOOK_REF(hook); 311 NGI_SET_HOOK(item, hook); 312 } 313 314 NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_l2cap_raw_queue, item); 315 error = ng_btsocket_l2cap_raw_wakeup_input_task(); 316 } 317 mtx_unlock(&ng_btsocket_l2cap_raw_queue_mtx); 318 } else { 319 NG_FREE_ITEM(item); 320 error = EINVAL; 321 } 322 323 return (error); 324 } /* ng_btsocket_l2cap_raw_node_rcvmsg */ 325 326 /* 327 * Receive data on a hook 328 */ 329 330 static int 331 ng_btsocket_l2cap_raw_node_rcvdata(hook_p hook, item_p item) 332 { 333 NG_FREE_ITEM(item); 334 335 return (EINVAL); 336 } /* ng_btsocket_l2cap_raw_node_rcvdata */ 337 338 /***************************************************************************** 339 ***************************************************************************** 340 ** Socket interface 341 ***************************************************************************** 342 *****************************************************************************/ 343 344 /* 345 * L2CAP sockets input routine 346 */ 347 348 static void 349 ng_btsocket_l2cap_raw_input(void *context, int pending) 350 { 351 item_p item = NULL; 352 hook_p hook = NULL; 353 struct ng_mesg *msg = NULL; 354 355 for (;;) { 356 mtx_lock(&ng_btsocket_l2cap_raw_queue_mtx); 357 NG_BT_ITEMQ_DEQUEUE(&ng_btsocket_l2cap_raw_queue, item); 358 mtx_unlock(&ng_btsocket_l2cap_raw_queue_mtx); 359 360 if (item == NULL) 361 break; 362 363 KASSERT((item->el_flags & NGQF_TYPE) == NGQF_MESG, 364 ("%s: invalid item type=%ld\n", __func__, (item->el_flags & NGQF_TYPE))); 365 366 NGI_GET_MSG(item, msg); 367 NGI_GET_HOOK(item, hook); 368 NG_FREE_ITEM(item); 369 370 switch (msg->header.cmd) { 371 case NGM_L2CAP_NODE_HOOK_INFO: { 372 ng_btsocket_l2cap_rtentry_t *rt = NULL; 373 374 if (hook == NULL || NG_HOOK_NOT_VALID(hook) || 375 msg->header.arglen != sizeof(bdaddr_t)) 376 break; 377 378 if (bcmp(msg->data, NG_HCI_BDADDR_ANY, 379 sizeof(bdaddr_t)) == 0) 380 break; 381 382 rt = (ng_btsocket_l2cap_rtentry_t *) 383 NG_HOOK_PRIVATE(hook); 384 if (rt == NULL) { 385 rt = malloc(sizeof(*rt), 386 M_NETGRAPH_BTSOCKET_L2CAP_RAW, 387 M_NOWAIT|M_ZERO); 388 if (rt == NULL) 389 break; 390 391 NG_HOOK_SET_PRIVATE(hook, rt); 392 393 mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); 394 395 LIST_INSERT_HEAD(&ng_btsocket_l2cap_raw_rt, 396 rt, next); 397 } else 398 mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); 399 400 bcopy(msg->data, &rt->src, sizeof(rt->src)); 401 rt->hook = hook; 402 403 NG_BTSOCKET_L2CAP_RAW_INFO( 404 "%s: Updating hook \"%s\", src bdaddr=%x:%x:%x:%x:%x:%x\n", 405 __func__, NG_HOOK_NAME(hook), 406 rt->src.b[5], rt->src.b[4], rt->src.b[3], 407 rt->src.b[2], rt->src.b[1], rt->src.b[0]); 408 409 mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); 410 } break; 411 412 case NGM_L2CAP_NODE_GET_FLAGS: 413 case NGM_L2CAP_NODE_GET_DEBUG: 414 case NGM_L2CAP_NODE_GET_CON_LIST: 415 case NGM_L2CAP_NODE_GET_CHAN_LIST: 416 case NGM_L2CAP_NODE_GET_AUTO_DISCON_TIMO: 417 case NGM_L2CAP_L2CA_PING: 418 case NGM_L2CAP_L2CA_GET_INFO: { 419 ng_btsocket_l2cap_raw_pcb_p pcb = NULL; 420 421 mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); 422 423 LIST_FOREACH(pcb,&ng_btsocket_l2cap_raw_sockets,next) { 424 mtx_lock(&pcb->pcb_mtx); 425 426 if (pcb->token == msg->header.token) { 427 pcb->msg = msg; 428 msg = NULL; 429 wakeup(&pcb->msg); 430 mtx_unlock(&pcb->pcb_mtx); 431 break; 432 } 433 434 mtx_unlock(&pcb->pcb_mtx); 435 } 436 437 mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); 438 } break; 439 440 default: 441 NG_BTSOCKET_L2CAP_RAW_WARN( 442 "%s: Unknown message, cmd=%d\n", __func__, msg->header.cmd); 443 break; 444 } 445 446 if (hook != NULL) 447 NG_HOOK_UNREF(hook); /* remove extra reference */ 448 449 NG_FREE_MSG(msg); /* Checks for msg != NULL */ 450 } 451 } /* ng_btsocket_l2cap_raw_input */ 452 453 /* 454 * Route cleanup task. Gets scheduled when hook is disconnected. Here we 455 * will find all sockets that use "invalid" hook and disconnect them. 456 */ 457 458 static void 459 ng_btsocket_l2cap_raw_rtclean(void *context, int pending) 460 { 461 ng_btsocket_l2cap_raw_pcb_p pcb = NULL; 462 ng_btsocket_l2cap_rtentry_p rt = NULL; 463 464 /* 465 * First disconnect all sockets that use "invalid" hook 466 */ 467 468 mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); 469 470 LIST_FOREACH(pcb, &ng_btsocket_l2cap_raw_sockets, next) { 471 mtx_lock(&pcb->pcb_mtx); 472 473 if (pcb->rt != NULL && 474 pcb->rt->hook != NULL && NG_HOOK_NOT_VALID(pcb->rt->hook)) { 475 if (pcb->so != NULL && 476 pcb->so->so_state & SS_ISCONNECTED) 477 soisdisconnected(pcb->so); 478 479 pcb->rt = NULL; 480 } 481 482 mtx_unlock(&pcb->pcb_mtx); 483 } 484 485 mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); 486 487 /* 488 * Now cleanup routing table 489 */ 490 491 mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); 492 493 for (rt = LIST_FIRST(&ng_btsocket_l2cap_raw_rt); rt != NULL; ) { 494 ng_btsocket_l2cap_rtentry_p rt_next = LIST_NEXT(rt, next); 495 496 if (rt->hook != NULL && NG_HOOK_NOT_VALID(rt->hook)) { 497 LIST_REMOVE(rt, next); 498 499 NG_HOOK_SET_PRIVATE(rt->hook, NULL); 500 NG_HOOK_UNREF(rt->hook); /* Remove extra reference */ 501 502 bzero(rt, sizeof(*rt)); 503 free(rt, M_NETGRAPH_BTSOCKET_L2CAP_RAW); 504 } 505 506 rt = rt_next; 507 } 508 509 mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); 510 } /* ng_btsocket_l2cap_raw_rtclean */ 511 512 /* 513 * Initialize everything 514 */ 515 516 void 517 ng_btsocket_l2cap_raw_init(void) 518 { 519 int error = 0; 520 521 /* Skip initialization of globals for non-default instances. */ 522 if (!IS_DEFAULT_VNET(curvnet)) 523 return; 524 525 ng_btsocket_l2cap_raw_node = NULL; 526 ng_btsocket_l2cap_raw_debug_level = NG_BTSOCKET_WARN_LEVEL; 527 ng_btsocket_l2cap_raw_ioctl_timeout = 5; 528 529 /* Register Netgraph node type */ 530 error = ng_newtype(&typestruct); 531 if (error != 0) { 532 NG_BTSOCKET_L2CAP_RAW_ALERT( 533 "%s: Could not register Netgraph node type, error=%d\n", __func__, error); 534 535 return; 536 } 537 538 /* Create Netgrapg node */ 539 error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_raw_node); 540 if (error != 0) { 541 NG_BTSOCKET_L2CAP_RAW_ALERT( 542 "%s: Could not create Netgraph node, error=%d\n", __func__, error); 543 544 ng_btsocket_l2cap_raw_node = NULL; 545 546 return; 547 } 548 549 error = ng_name_node(ng_btsocket_l2cap_raw_node, 550 NG_BTSOCKET_L2CAP_RAW_NODE_TYPE); 551 if (error != 0) { 552 NG_BTSOCKET_L2CAP_RAW_ALERT( 553 "%s: Could not name Netgraph node, error=%d\n", __func__, error); 554 555 NG_NODE_UNREF(ng_btsocket_l2cap_raw_node); 556 ng_btsocket_l2cap_raw_node = NULL; 557 558 return; 559 } 560 561 /* Create input queue */ 562 NG_BT_ITEMQ_INIT(&ng_btsocket_l2cap_raw_queue, ifqmaxlen); 563 mtx_init(&ng_btsocket_l2cap_raw_queue_mtx, 564 "btsocks_l2cap_raw_queue_mtx", NULL, MTX_DEF); 565 TASK_INIT(&ng_btsocket_l2cap_raw_queue_task, 0, 566 ng_btsocket_l2cap_raw_input, NULL); 567 568 /* Create list of sockets */ 569 LIST_INIT(&ng_btsocket_l2cap_raw_sockets); 570 mtx_init(&ng_btsocket_l2cap_raw_sockets_mtx, 571 "btsocks_l2cap_raw_sockets_mtx", NULL, MTX_DEF); 572 573 /* Tokens */ 574 ng_btsocket_l2cap_raw_token = 0; 575 mtx_init(&ng_btsocket_l2cap_raw_token_mtx, 576 "btsocks_l2cap_raw_token_mtx", NULL, MTX_DEF); 577 578 /* Routing table */ 579 LIST_INIT(&ng_btsocket_l2cap_raw_rt); 580 mtx_init(&ng_btsocket_l2cap_raw_rt_mtx, 581 "btsocks_l2cap_raw_rt_mtx", NULL, MTX_DEF); 582 TASK_INIT(&ng_btsocket_l2cap_raw_rt_task, 0, 583 ng_btsocket_l2cap_raw_rtclean, NULL); 584 } /* ng_btsocket_l2cap_raw_init */ 585 586 /* 587 * Abort connection on socket 588 */ 589 590 void 591 ng_btsocket_l2cap_raw_abort(struct socket *so) 592 { 593 594 (void)ng_btsocket_l2cap_raw_disconnect(so); 595 } /* ng_btsocket_l2cap_raw_abort */ 596 597 void 598 ng_btsocket_l2cap_raw_close(struct socket *so) 599 { 600 601 (void)ng_btsocket_l2cap_raw_disconnect(so); 602 } /* ng_btsocket_l2cap_raw_close */ 603 604 /* 605 * Create and attach new socket 606 */ 607 608 int 609 ng_btsocket_l2cap_raw_attach(struct socket *so, int proto, struct thread *td) 610 { 611 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); 612 int error; 613 614 if (pcb != NULL) 615 return (EISCONN); 616 617 if (ng_btsocket_l2cap_raw_node == NULL) 618 return (EPROTONOSUPPORT); 619 if (so->so_type != SOCK_RAW) 620 return (ESOCKTNOSUPPORT); 621 622 /* Reserve send and receive space if it is not reserved yet */ 623 error = soreserve(so, NG_BTSOCKET_L2CAP_RAW_SENDSPACE, 624 NG_BTSOCKET_L2CAP_RAW_RECVSPACE); 625 if (error != 0) 626 return (error); 627 628 /* Allocate the PCB */ 629 pcb = malloc(sizeof(*pcb), 630 M_NETGRAPH_BTSOCKET_L2CAP_RAW, M_NOWAIT|M_ZERO); 631 if (pcb == NULL) 632 return (ENOMEM); 633 634 /* Link the PCB and the socket */ 635 so->so_pcb = (caddr_t) pcb; 636 pcb->so = so; 637 638 if (priv_check(td, PRIV_NETBLUETOOTH_RAW) == 0) 639 pcb->flags |= NG_BTSOCKET_L2CAP_RAW_PRIVILEGED; 640 641 mtx_init(&pcb->pcb_mtx, "btsocks_l2cap_raw_pcb_mtx", NULL, MTX_DEF); 642 643 /* Add the PCB to the list */ 644 mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); 645 LIST_INSERT_HEAD(&ng_btsocket_l2cap_raw_sockets, pcb, next); 646 mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); 647 648 return (0); 649 } /* ng_btsocket_l2cap_raw_attach */ 650 651 /* 652 * Bind socket 653 */ 654 655 int 656 ng_btsocket_l2cap_raw_bind(struct socket *so, struct sockaddr *nam, 657 struct thread *td) 658 { 659 ng_btsocket_l2cap_raw_pcb_t *pcb = so2l2cap_raw_pcb(so); 660 struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam; 661 ng_btsocket_l2cap_rtentry_t *rt = NULL; 662 663 if (pcb == NULL) 664 return (EINVAL); 665 if (ng_btsocket_l2cap_raw_node == NULL) 666 return (EINVAL); 667 668 if (sa == NULL) 669 return (EINVAL); 670 if (sa->l2cap_family != AF_BLUETOOTH) 671 return (EAFNOSUPPORT); 672 if((sa->l2cap_len != sizeof(*sa))&& 673 (sa->l2cap_len != sizeof(struct sockaddr_l2cap_compat))) 674 return (EINVAL); 675 676 if (bcmp(&sa->l2cap_bdaddr, NG_HCI_BDADDR_ANY, 677 sizeof(sa->l2cap_bdaddr)) != 0) { 678 mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); 679 680 LIST_FOREACH(rt, &ng_btsocket_l2cap_raw_rt, next) { 681 if (rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook)) 682 continue; 683 684 if (bcmp(&sa->l2cap_bdaddr, &rt->src, 685 sizeof(rt->src)) == 0) 686 break; 687 } 688 689 mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); 690 691 if (rt == NULL) 692 return (ENETDOWN); 693 } else 694 rt = NULL; 695 696 mtx_lock(&pcb->pcb_mtx); 697 bcopy(&sa->l2cap_bdaddr, &pcb->src, sizeof(pcb->src)); 698 pcb->rt = rt; 699 mtx_unlock(&pcb->pcb_mtx); 700 701 return (0); 702 } /* ng_btsocket_l2cap_raw_bind */ 703 704 /* 705 * Connect socket 706 */ 707 708 int 709 ng_btsocket_l2cap_raw_connect(struct socket *so, struct sockaddr *nam, 710 struct thread *td) 711 { 712 ng_btsocket_l2cap_raw_pcb_t *pcb = so2l2cap_raw_pcb(so); 713 struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam; 714 ng_btsocket_l2cap_rtentry_t *rt = NULL; 715 int error; 716 717 if (pcb == NULL) 718 return (EINVAL); 719 if (ng_btsocket_l2cap_raw_node == NULL) 720 return (EINVAL); 721 722 if (sa == NULL) 723 return (EINVAL); 724 if (sa->l2cap_family != AF_BLUETOOTH) 725 return (EAFNOSUPPORT); 726 if((sa->l2cap_len != sizeof(*sa))&& 727 (sa->l2cap_len != sizeof(struct sockaddr_l2cap_compat))) 728 return (EINVAL); 729 730 if (bcmp(&sa->l2cap_bdaddr, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) == 0) 731 return (EINVAL); 732 733 mtx_lock(&pcb->pcb_mtx); 734 735 bcopy(&sa->l2cap_bdaddr, &pcb->dst, sizeof(pcb->dst)); 736 737 if (bcmp(&pcb->src, &pcb->dst, sizeof(pcb->src)) == 0) { 738 mtx_unlock(&pcb->pcb_mtx); 739 740 return (EADDRNOTAVAIL); 741 } 742 743 /* 744 * If there is route already - use it 745 */ 746 747 if (pcb->rt != NULL) { 748 soisconnected(so); 749 mtx_unlock(&pcb->pcb_mtx); 750 751 return (0); 752 } 753 754 /* 755 * Find the first hook that does not match specified destination address 756 */ 757 758 mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); 759 760 LIST_FOREACH(rt, &ng_btsocket_l2cap_raw_rt, next) { 761 if (rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook)) 762 continue; 763 764 if (bcmp(&pcb->dst, &rt->src, sizeof(rt->src)) != 0) 765 break; 766 } 767 768 if (rt != NULL) { 769 soisconnected(so); 770 771 pcb->rt = rt; 772 bcopy(&rt->src, &pcb->src, sizeof(pcb->src)); 773 774 error = 0; 775 } else 776 error = ENETDOWN; 777 778 mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); 779 mtx_unlock(&pcb->pcb_mtx); 780 781 return (error); 782 } /* ng_btsocket_l2cap_raw_connect */ 783 784 /* 785 * Process ioctl's calls on socket 786 */ 787 788 int 789 ng_btsocket_l2cap_raw_control(struct socket *so, u_long cmd, caddr_t data, 790 struct ifnet *ifp, struct thread *td) 791 { 792 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); 793 struct ng_mesg *msg = NULL; 794 int error = 0; 795 796 if (pcb == NULL) 797 return (EINVAL); 798 if (ng_btsocket_l2cap_raw_node == NULL) 799 return (EINVAL); 800 801 mtx_lock(&pcb->pcb_mtx); 802 803 /* Check if we route info */ 804 if (pcb->rt == NULL) { 805 mtx_unlock(&pcb->pcb_mtx); 806 return (EHOSTUNREACH); 807 } 808 809 /* Check if we have pending ioctl() */ 810 if (pcb->token != 0) { 811 mtx_unlock(&pcb->pcb_mtx); 812 return (EBUSY); 813 } 814 815 switch (cmd) { 816 case SIOC_L2CAP_NODE_GET_FLAGS: { 817 struct ng_btsocket_l2cap_raw_node_flags *p = 818 (struct ng_btsocket_l2cap_raw_node_flags *) data; 819 820 error = ng_btsocket_l2cap_raw_send_sync_ngmsg(pcb, 821 NGM_L2CAP_NODE_GET_FLAGS, 822 &p->flags, sizeof(p->flags)); 823 } break; 824 825 case SIOC_L2CAP_NODE_GET_DEBUG: { 826 struct ng_btsocket_l2cap_raw_node_debug *p = 827 (struct ng_btsocket_l2cap_raw_node_debug *) data; 828 829 error = ng_btsocket_l2cap_raw_send_sync_ngmsg(pcb, 830 NGM_L2CAP_NODE_GET_DEBUG, 831 &p->debug, sizeof(p->debug)); 832 } break; 833 834 case SIOC_L2CAP_NODE_SET_DEBUG: { 835 struct ng_btsocket_l2cap_raw_node_debug *p = 836 (struct ng_btsocket_l2cap_raw_node_debug *) data; 837 838 if (pcb->flags & NG_BTSOCKET_L2CAP_RAW_PRIVILEGED) 839 error = ng_btsocket_l2cap_raw_send_ngmsg(pcb->rt->hook, 840 NGM_L2CAP_NODE_SET_DEBUG, 841 &p->debug, sizeof(p->debug)); 842 else 843 error = EPERM; 844 } break; 845 846 case SIOC_L2CAP_NODE_GET_CON_LIST: { 847 struct ng_btsocket_l2cap_raw_con_list *p = 848 (struct ng_btsocket_l2cap_raw_con_list *) data; 849 ng_l2cap_node_con_list_ep *p1 = NULL; 850 ng_l2cap_node_con_ep *p2 = NULL; 851 852 if (p->num_connections == 0 || 853 p->num_connections > NG_L2CAP_MAX_CON_NUM || 854 p->connections == NULL) { 855 mtx_unlock(&pcb->pcb_mtx); 856 return (EINVAL); 857 } 858 859 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_GET_CON_LIST, 860 0, M_NOWAIT); 861 if (msg == NULL) { 862 mtx_unlock(&pcb->pcb_mtx); 863 return (ENOMEM); 864 } 865 ng_btsocket_l2cap_raw_get_token(&msg->header.token); 866 pcb->token = msg->header.token; 867 pcb->msg = NULL; 868 869 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, 870 pcb->rt->hook, 0); 871 if (error != 0) { 872 pcb->token = 0; 873 mtx_unlock(&pcb->pcb_mtx); 874 return (error); 875 } 876 877 error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl", 878 ng_btsocket_l2cap_raw_ioctl_timeout * hz); 879 pcb->token = 0; 880 881 if (error != 0) { 882 mtx_unlock(&pcb->pcb_mtx); 883 return (error); 884 } 885 886 msg = pcb->msg; 887 pcb->msg = NULL; 888 889 mtx_unlock(&pcb->pcb_mtx); 890 891 if (msg != NULL && 892 msg->header.cmd == NGM_L2CAP_NODE_GET_CON_LIST) { 893 /* Return data back to user space */ 894 p1 = (ng_l2cap_node_con_list_ep *)(msg->data); 895 p2 = (ng_l2cap_node_con_ep *)(p1 + 1); 896 897 p->num_connections = min(p->num_connections, 898 p1->num_connections); 899 if (p->num_connections > 0) 900 error = copyout((caddr_t) p2, 901 (caddr_t) p->connections, 902 p->num_connections * sizeof(*p2)); 903 } else 904 error = EINVAL; 905 906 NG_FREE_MSG(msg); /* checks for != NULL */ 907 return (error); 908 } /* NOTREACHED */ 909 910 case SIOC_L2CAP_NODE_GET_CHAN_LIST: { 911 struct ng_btsocket_l2cap_raw_chan_list *p = 912 (struct ng_btsocket_l2cap_raw_chan_list *) data; 913 ng_l2cap_node_chan_list_ep *p1 = NULL; 914 ng_l2cap_node_chan_ep *p2 = NULL; 915 916 if (p->num_channels == 0 || 917 p->num_channels > NG_L2CAP_MAX_CHAN_NUM || 918 p->channels == NULL) { 919 mtx_unlock(&pcb->pcb_mtx); 920 return (EINVAL); 921 } 922 923 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, 924 NGM_L2CAP_NODE_GET_CHAN_LIST, 0, M_NOWAIT); 925 if (msg == NULL) { 926 mtx_unlock(&pcb->pcb_mtx); 927 return (ENOMEM); 928 } 929 ng_btsocket_l2cap_raw_get_token(&msg->header.token); 930 pcb->token = msg->header.token; 931 pcb->msg = NULL; 932 933 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, 934 pcb->rt->hook, 0); 935 if (error != 0) { 936 pcb->token = 0; 937 mtx_unlock(&pcb->pcb_mtx); 938 return (error); 939 } 940 941 error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl", 942 ng_btsocket_l2cap_raw_ioctl_timeout * hz); 943 pcb->token = 0; 944 945 if (error != 0) { 946 mtx_unlock(&pcb->pcb_mtx); 947 return (error); 948 } 949 950 msg = pcb->msg; 951 pcb->msg = NULL; 952 953 mtx_unlock(&pcb->pcb_mtx); 954 955 if (msg != NULL && 956 msg->header.cmd == NGM_L2CAP_NODE_GET_CHAN_LIST) { 957 /* Return data back to user space */ 958 p1 = (ng_l2cap_node_chan_list_ep *)(msg->data); 959 p2 = (ng_l2cap_node_chan_ep *)(p1 + 1); 960 961 p->num_channels = min(p->num_channels, 962 p1->num_channels); 963 if (p->num_channels > 0) 964 error = copyout((caddr_t) p2, 965 (caddr_t) p->channels, 966 p->num_channels * sizeof(*p2)); 967 } else 968 error = EINVAL; 969 970 NG_FREE_MSG(msg); /* checks for != NULL */ 971 return (error); 972 } /* NOTREACHED */ 973 974 case SIOC_L2CAP_L2CA_PING: { 975 struct ng_btsocket_l2cap_raw_ping *p = 976 (struct ng_btsocket_l2cap_raw_ping *) data; 977 ng_l2cap_l2ca_ping_ip *ip = NULL; 978 ng_l2cap_l2ca_ping_op *op = NULL; 979 980 if ((p->echo_size != 0 && p->echo_data == NULL) || 981 p->echo_size > NG_L2CAP_MAX_ECHO_SIZE) { 982 mtx_unlock(&pcb->pcb_mtx); 983 return (EINVAL); 984 } 985 986 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, 987 NGM_L2CAP_L2CA_PING, sizeof(*ip) + p->echo_size, 988 M_NOWAIT); 989 if (msg == NULL) { 990 mtx_unlock(&pcb->pcb_mtx); 991 return (ENOMEM); 992 } 993 ng_btsocket_l2cap_raw_get_token(&msg->header.token); 994 pcb->token = msg->header.token; 995 pcb->msg = NULL; 996 997 ip = (ng_l2cap_l2ca_ping_ip *)(msg->data); 998 bcopy(&pcb->dst, &ip->bdaddr, sizeof(ip->bdaddr)); 999 ip->echo_size = p->echo_size; 1000 1001 if (ip->echo_size > 0) { 1002 mtx_unlock(&pcb->pcb_mtx); 1003 error = copyin(p->echo_data, ip + 1, p->echo_size); 1004 mtx_lock(&pcb->pcb_mtx); 1005 1006 if (error != 0) { 1007 NG_FREE_MSG(msg); 1008 pcb->token = 0; 1009 mtx_unlock(&pcb->pcb_mtx); 1010 return (error); 1011 } 1012 } 1013 1014 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, 1015 pcb->rt->hook, 0); 1016 if (error != 0) { 1017 pcb->token = 0; 1018 mtx_unlock(&pcb->pcb_mtx); 1019 return (error); 1020 } 1021 1022 error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl", 1023 bluetooth_l2cap_rtx_timeout()); 1024 pcb->token = 0; 1025 1026 if (error != 0) { 1027 mtx_unlock(&pcb->pcb_mtx); 1028 return (error); 1029 } 1030 1031 msg = pcb->msg; 1032 pcb->msg = NULL; 1033 1034 mtx_unlock(&pcb->pcb_mtx); 1035 1036 if (msg != NULL && 1037 msg->header.cmd == NGM_L2CAP_L2CA_PING) { 1038 /* Return data back to the user space */ 1039 op = (ng_l2cap_l2ca_ping_op *)(msg->data); 1040 p->result = op->result; 1041 p->echo_size = min(p->echo_size, op->echo_size); 1042 1043 if (p->echo_size > 0) 1044 error = copyout(op + 1, p->echo_data, 1045 p->echo_size); 1046 } else 1047 error = EINVAL; 1048 1049 NG_FREE_MSG(msg); /* checks for != NULL */ 1050 return (error); 1051 } /* NOTREACHED */ 1052 1053 case SIOC_L2CAP_L2CA_GET_INFO: { 1054 struct ng_btsocket_l2cap_raw_get_info *p = 1055 (struct ng_btsocket_l2cap_raw_get_info *) data; 1056 ng_l2cap_l2ca_get_info_ip *ip = NULL; 1057 ng_l2cap_l2ca_get_info_op *op = NULL; 1058 1059 if (!(pcb->flags & NG_BTSOCKET_L2CAP_RAW_PRIVILEGED)) { 1060 mtx_unlock(&pcb->pcb_mtx); 1061 return (EPERM); 1062 } 1063 1064 if (p->info_size != 0 && p->info_data == NULL) { 1065 mtx_unlock(&pcb->pcb_mtx); 1066 return (EINVAL); 1067 } 1068 1069 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, 1070 NGM_L2CAP_L2CA_GET_INFO, sizeof(*ip) + p->info_size, 1071 M_NOWAIT); 1072 if (msg == NULL) { 1073 mtx_unlock(&pcb->pcb_mtx); 1074 return (ENOMEM); 1075 } 1076 ng_btsocket_l2cap_raw_get_token(&msg->header.token); 1077 pcb->token = msg->header.token; 1078 pcb->msg = NULL; 1079 1080 ip = (ng_l2cap_l2ca_get_info_ip *)(msg->data); 1081 bcopy(&pcb->dst, &ip->bdaddr, sizeof(ip->bdaddr)); 1082 ip->info_type = p->info_type; 1083 1084 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, 1085 pcb->rt->hook, 0); 1086 if (error != 0) { 1087 pcb->token = 0; 1088 mtx_unlock(&pcb->pcb_mtx); 1089 return (error); 1090 } 1091 1092 error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl", 1093 bluetooth_l2cap_rtx_timeout()); 1094 pcb->token = 0; 1095 1096 if (error != 0) { 1097 mtx_unlock(&pcb->pcb_mtx); 1098 return (error); 1099 } 1100 1101 msg = pcb->msg; 1102 pcb->msg = NULL; 1103 1104 mtx_unlock(&pcb->pcb_mtx); 1105 1106 if (msg != NULL && 1107 msg->header.cmd == NGM_L2CAP_L2CA_GET_INFO) { 1108 /* Return data back to the user space */ 1109 op = (ng_l2cap_l2ca_get_info_op *)(msg->data); 1110 p->result = op->result; 1111 p->info_size = min(p->info_size, op->info_size); 1112 1113 if (p->info_size > 0) 1114 error = copyout(op + 1, p->info_data, 1115 p->info_size); 1116 } else 1117 error = EINVAL; 1118 1119 NG_FREE_MSG(msg); /* checks for != NULL */ 1120 return (error); 1121 } /* NOTREACHED */ 1122 1123 case SIOC_L2CAP_NODE_GET_AUTO_DISCON_TIMO: { 1124 struct ng_btsocket_l2cap_raw_auto_discon_timo *p = 1125 (struct ng_btsocket_l2cap_raw_auto_discon_timo *) data; 1126 1127 error = ng_btsocket_l2cap_raw_send_sync_ngmsg(pcb, 1128 NGM_L2CAP_NODE_GET_AUTO_DISCON_TIMO, 1129 &p->timeout, sizeof(p->timeout)); 1130 } break; 1131 1132 case SIOC_L2CAP_NODE_SET_AUTO_DISCON_TIMO: { 1133 struct ng_btsocket_l2cap_raw_auto_discon_timo *p = 1134 (struct ng_btsocket_l2cap_raw_auto_discon_timo *) data; 1135 1136 if (pcb->flags & NG_BTSOCKET_L2CAP_RAW_PRIVILEGED) 1137 error = ng_btsocket_l2cap_raw_send_ngmsg(pcb->rt->hook, 1138 NGM_L2CAP_NODE_SET_AUTO_DISCON_TIMO, 1139 &p->timeout, sizeof(p->timeout)); 1140 else 1141 error = EPERM; 1142 } break; 1143 1144 default: 1145 error = EINVAL; 1146 break; 1147 } 1148 1149 mtx_unlock(&pcb->pcb_mtx); 1150 1151 return (error); 1152 } /* ng_btsocket_l2cap_raw_control */ 1153 1154 /* 1155 * Detach and destroy socket 1156 */ 1157 1158 void 1159 ng_btsocket_l2cap_raw_detach(struct socket *so) 1160 { 1161 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); 1162 1163 KASSERT(pcb != NULL, ("nt_btsocket_l2cap_raw_detach: pcb == NULL")); 1164 if (ng_btsocket_l2cap_raw_node == NULL) 1165 return; 1166 1167 mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); 1168 mtx_lock(&pcb->pcb_mtx); 1169 1170 LIST_REMOVE(pcb, next); 1171 1172 mtx_unlock(&pcb->pcb_mtx); 1173 mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); 1174 1175 mtx_destroy(&pcb->pcb_mtx); 1176 1177 bzero(pcb, sizeof(*pcb)); 1178 free(pcb, M_NETGRAPH_BTSOCKET_L2CAP_RAW); 1179 1180 so->so_pcb = NULL; 1181 } /* ng_btsocket_l2cap_raw_detach */ 1182 1183 /* 1184 * Disconnect socket 1185 */ 1186 1187 int 1188 ng_btsocket_l2cap_raw_disconnect(struct socket *so) 1189 { 1190 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); 1191 1192 if (pcb == NULL) 1193 return (EINVAL); 1194 if (ng_btsocket_l2cap_raw_node == NULL) 1195 return (EINVAL); 1196 1197 mtx_lock(&pcb->pcb_mtx); 1198 pcb->rt = NULL; 1199 soisdisconnected(so); 1200 mtx_unlock(&pcb->pcb_mtx); 1201 1202 return (0); 1203 } /* ng_btsocket_l2cap_raw_disconnect */ 1204 1205 /* 1206 * Get peer address 1207 */ 1208 1209 int 1210 ng_btsocket_l2cap_raw_peeraddr(struct socket *so, struct sockaddr **nam) 1211 { 1212 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); 1213 struct sockaddr_l2cap sa; 1214 1215 if (pcb == NULL) 1216 return (EINVAL); 1217 if (ng_btsocket_l2cap_raw_node == NULL) 1218 return (EINVAL); 1219 1220 mtx_lock(&pcb->pcb_mtx); 1221 bcopy(&pcb->dst, &sa.l2cap_bdaddr, sizeof(sa.l2cap_bdaddr)); 1222 mtx_unlock(&pcb->pcb_mtx); 1223 1224 sa.l2cap_psm = 0; 1225 sa.l2cap_len = sizeof(sa); 1226 sa.l2cap_family = AF_BLUETOOTH; 1227 sa.l2cap_cid = 0; 1228 sa.l2cap_bdaddr_type = BDADDR_BREDR; 1229 1230 *nam = sodupsockaddr((struct sockaddr *) &sa, M_NOWAIT); 1231 1232 return ((*nam == NULL)? ENOMEM : 0); 1233 } /* ng_btsocket_l2cap_raw_peeraddr */ 1234 1235 /* 1236 * Send data to socket 1237 */ 1238 1239 int 1240 ng_btsocket_l2cap_raw_send(struct socket *so, int flags, struct mbuf *m, 1241 struct sockaddr *nam, struct mbuf *control, struct thread *td) 1242 { 1243 NG_FREE_M(m); /* Checks for m != NULL */ 1244 NG_FREE_M(control); 1245 1246 return (EOPNOTSUPP); 1247 } /* ng_btsocket_l2cap_raw_send */ 1248 1249 /* 1250 * Get socket address 1251 */ 1252 1253 int 1254 ng_btsocket_l2cap_raw_sockaddr(struct socket *so, struct sockaddr **nam) 1255 { 1256 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); 1257 struct sockaddr_l2cap sa; 1258 1259 if (pcb == NULL) 1260 return (EINVAL); 1261 if (ng_btsocket_l2cap_raw_node == NULL) 1262 return (EINVAL); 1263 1264 mtx_lock(&pcb->pcb_mtx); 1265 bcopy(&pcb->src, &sa.l2cap_bdaddr, sizeof(sa.l2cap_bdaddr)); 1266 mtx_unlock(&pcb->pcb_mtx); 1267 1268 sa.l2cap_psm = 0; 1269 sa.l2cap_len = sizeof(sa); 1270 sa.l2cap_family = AF_BLUETOOTH; 1271 sa.l2cap_cid = 0; 1272 sa.l2cap_bdaddr_type = BDADDR_BREDR; 1273 *nam = sodupsockaddr((struct sockaddr *) &sa, M_NOWAIT); 1274 1275 return ((*nam == NULL)? ENOMEM : 0); 1276 } /* ng_btsocket_l2cap_raw_sockaddr */ 1277 1278 /* 1279 * Get next token 1280 */ 1281 1282 static void 1283 ng_btsocket_l2cap_raw_get_token(u_int32_t *token) 1284 { 1285 mtx_lock(&ng_btsocket_l2cap_raw_token_mtx); 1286 1287 if (++ ng_btsocket_l2cap_raw_token == 0) 1288 ng_btsocket_l2cap_raw_token = 1; 1289 1290 *token = ng_btsocket_l2cap_raw_token; 1291 1292 mtx_unlock(&ng_btsocket_l2cap_raw_token_mtx); 1293 } /* ng_btsocket_l2cap_raw_get_token */ 1294 1295 /* 1296 * Send Netgraph message to the node - do not expect reply 1297 */ 1298 1299 static int 1300 ng_btsocket_l2cap_raw_send_ngmsg(hook_p hook, int cmd, void *arg, int arglen) 1301 { 1302 struct ng_mesg *msg = NULL; 1303 int error = 0; 1304 1305 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, cmd, arglen, M_NOWAIT); 1306 if (msg == NULL) 1307 return (ENOMEM); 1308 1309 if (arg != NULL && arglen > 0) 1310 bcopy(arg, msg->data, arglen); 1311 1312 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, hook, 0); 1313 1314 return (error); 1315 } /* ng_btsocket_l2cap_raw_send_ngmsg */ 1316 1317 /* 1318 * Send Netgraph message to the node (no data) and wait for reply 1319 */ 1320 1321 static int 1322 ng_btsocket_l2cap_raw_send_sync_ngmsg(ng_btsocket_l2cap_raw_pcb_p pcb, 1323 int cmd, void *rsp, int rsplen) 1324 { 1325 struct ng_mesg *msg = NULL; 1326 int error = 0; 1327 1328 mtx_assert(&pcb->pcb_mtx, MA_OWNED); 1329 1330 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, cmd, 0, M_NOWAIT); 1331 if (msg == NULL) 1332 return (ENOMEM); 1333 1334 ng_btsocket_l2cap_raw_get_token(&msg->header.token); 1335 pcb->token = msg->header.token; 1336 pcb->msg = NULL; 1337 1338 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, 1339 pcb->rt->hook, 0); 1340 if (error != 0) { 1341 pcb->token = 0; 1342 return (error); 1343 } 1344 1345 error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "l2ctl", 1346 ng_btsocket_l2cap_raw_ioctl_timeout * hz); 1347 pcb->token = 0; 1348 1349 if (error != 0) 1350 return (error); 1351 1352 if (pcb->msg != NULL && pcb->msg->header.cmd == cmd) 1353 bcopy(pcb->msg->data, rsp, rsplen); 1354 else 1355 error = EINVAL; 1356 1357 NG_FREE_MSG(pcb->msg); /* checks for != NULL */ 1358 1359 return (0); 1360 } /* ng_btsocket_l2cap_raw_send_sync_ngmsg */ 1361 1362