sys/netgraph7/bluetooth/socket/ng_btsocket_l2cap_raw.c

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