2 * ng_btsocket_l2cap_raw.c
6 * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com>
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
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.
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
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 $
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>
42 #include <sys/malloc.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>
63 #ifdef NG_SEPARATE_MALLOC
64 MALLOC_DEFINE(M_NETGRAPH_BTSOCKET_L2CAP_RAW, "netgraph_btsocks_l2cap_raw",
65 "Netgraph Bluetooth raw L2CAP sockets");
67 #define M_NETGRAPH_BTSOCKET_L2CAP_RAW M_NETGRAPH
68 #endif /* NG_SEPARATE_MALLOC */
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;
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 *);
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);
88 #define ng_btsocket_l2cap_raw_wakeup_input_task() \
89 taskqueue_enqueue(taskqueue_swi, &ng_btsocket_l2cap_raw_queue_task)
91 #define ng_btsocket_l2cap_raw_wakeup_route_task() \
92 taskqueue_enqueue(taskqueue_swi, &ng_btsocket_l2cap_raw_rt_task)
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,
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;
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,
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,
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,
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,
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,
145 &ng_btsocket_l2cap_raw_queue.drops, 0,
146 "Bluetooth raw L2CAP sockets input queue drops");
149 #define NG_BTSOCKET_L2CAP_RAW_INFO \
150 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_INFO_LEVEL) \
153 #define NG_BTSOCKET_L2CAP_RAW_WARN \
154 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_WARN_LEVEL) \
157 #define NG_BTSOCKET_L2CAP_RAW_ERR \
158 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_ERR_LEVEL) \
161 #define NG_BTSOCKET_L2CAP_RAW_ALERT \
162 if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_ALERT_LEVEL) \
165 /*****************************************************************************
166 *****************************************************************************
167 ** Netgraph node interface
168 *****************************************************************************
169 *****************************************************************************/
172 * Netgraph node constructor. Do not allow to create node of this type.
176 ng_btsocket_l2cap_raw_node_constructor(node_p node)
179 } /* ng_btsocket_l2cap_raw_node_constructor */
182 * Do local shutdown processing. Let old node go and create new fresh one.
186 ng_btsocket_l2cap_raw_node_shutdown(node_p node)
192 /* Create new node */
193 error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_raw_node);
195 NG_BTSOCKET_L2CAP_RAW_ALERT(
196 "%s: Could not create Netgraph node, error=%d\n", __func__, error);
198 ng_btsocket_l2cap_raw_node = NULL;
203 error = ng_name_node(ng_btsocket_l2cap_raw_node,
204 NG_BTSOCKET_L2CAP_RAW_NODE_TYPE);
206 NG_BTSOCKET_L2CAP_RAW_ALERT(
207 "%s: Could not name Netgraph node, error=%d\n", __func__, error);
209 NG_NODE_UNREF(ng_btsocket_l2cap_raw_node);
210 ng_btsocket_l2cap_raw_node = NULL;
216 } /* ng_btsocket_l2cap_raw_node_shutdown */
219 * We allow any hook to be connected to the node.
223 ng_btsocket_l2cap_raw_node_newhook(node_p node, hook_p hook, char const *name)
226 } /* ng_btsocket_l2cap_raw_node_newhook */
229 * Just say "YEP, that's OK by me!"
233 ng_btsocket_l2cap_raw_node_connect(hook_p hook)
235 NG_HOOK_SET_PRIVATE(hook, NULL);
236 NG_HOOK_REF(hook); /* Keep extra reference to the hook */
239 } /* ng_btsocket_l2cap_raw_node_connect */
242 * Hook disconnection. Schedule route cleanup task
246 ng_btsocket_l2cap_raw_node_disconnect(hook_p hook)
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
256 if (NG_HOOK_PRIVATE(hook) != NULL)
257 return (ng_btsocket_l2cap_raw_wakeup_route_task());
259 NG_HOOK_UNREF(hook); /* Remove extra reference */
262 } /* ng_btsocket_l2cap_raw_node_disconnect */
265 * Process incoming messages
269 ng_btsocket_l2cap_raw_node_rcvmsg(node_p node, item_p item, hook_p hook)
271 struct ng_mesg *msg = NGI_MSG(item); /* item still has message */
274 if (msg != NULL && msg->header.typecookie == NGM_L2CAP_COOKIE) {
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
282 if (msg->header.cmd != NGM_L2CAP_NODE_HOOK_INFO) {
283 if (msg->header.token == 0 ||
284 !(msg->header.flags & NGF_RESP)) {
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__);
295 NG_BT_ITEMQ_DROP(&ng_btsocket_l2cap_raw_queue);
301 NGI_SET_HOOK(item, hook);
305 NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_l2cap_raw_queue, item);
306 error = ng_btsocket_l2cap_raw_wakeup_input_task();
308 lockmgr(&ng_btsocket_l2cap_raw_queue_lock, LK_RELEASE);
315 } /* ng_btsocket_l2cap_raw_node_rcvmsg */
318 * Receive data on a hook
322 ng_btsocket_l2cap_raw_node_rcvdata(hook_p hook, item_p item)
327 } /* ng_btsocket_l2cap_raw_node_rcvdata */
329 /*****************************************************************************
330 *****************************************************************************
332 *****************************************************************************
333 *****************************************************************************/
336 * L2CAP sockets input routine
340 ng_btsocket_l2cap_raw_input(void *context, int pending)
344 struct ng_mesg *msg = NULL;
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);
354 KASSERT((item->el_flags & NGQF_TYPE) == NGQF_MESG,
355 ("%s: invalid item type=%ld\n", __func__, (item->el_flags & NGQF_TYPE)));
357 NGI_GET_MSG(item, msg);
358 NGI_GET_HOOK(item, hook);
360 ng_unref_item(item, 0);
362 switch (msg->header.cmd) {
363 case NGM_L2CAP_NODE_HOOK_INFO: {
364 ng_btsocket_l2cap_rtentry_t *rt = NULL;
366 if (hook == NULL || NG_HOOK_NOT_VALID(hook) ||
367 msg->header.arglen != sizeof(bdaddr_t))
370 if (bcmp(msg->data, NG_HCI_BDADDR_ANY,
371 sizeof(bdaddr_t)) == 0)
374 rt = (ng_btsocket_l2cap_rtentry_t *)
375 NG_HOOK_PRIVATE(hook);
377 rt = kmalloc(sizeof(*rt),
378 M_NETGRAPH_BTSOCKET_L2CAP_RAW,
379 M_WAITOK | M_NULLOK | M_ZERO);
383 NG_HOOK_SET_PRIVATE(hook, rt);
385 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_EXCLUSIVE);
387 LIST_INSERT_HEAD(&ng_btsocket_l2cap_raw_rt,
390 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_EXCLUSIVE);
392 bcopy(msg->data, &rt->src, sizeof(rt->src));
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]);
401 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_RELEASE);
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;
413 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_EXCLUSIVE);
415 LIST_FOREACH(pcb,&ng_btsocket_l2cap_raw_sockets,next) {
416 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
418 if (pcb->token == msg->header.token) {
422 lockmgr(&pcb->pcb_lock, LK_RELEASE);
426 lockmgr(&pcb->pcb_lock, LK_RELEASE);
429 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_RELEASE);
433 NG_BTSOCKET_L2CAP_RAW_WARN(
434 "%s: Unknown message, cmd=%d\n", __func__, msg->header.cmd);
439 NG_HOOK_UNREF(hook); /* remove extra reference */
441 NG_FREE_MSG(msg); /* Checks for msg != NULL */
443 } /* ng_btsocket_l2cap_raw_input */
446 * Route cleanup task. Gets scheduled when hook is disconnected. Here we
447 * will find all sockets that use "invalid" hook and disconnect them.
451 ng_btsocket_l2cap_raw_rtclean(void *context, int pending)
453 ng_btsocket_l2cap_raw_pcb_p pcb = NULL;
454 ng_btsocket_l2cap_rtentry_p rt = NULL;
457 * First disconnect all sockets that use "invalid" hook
460 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_EXCLUSIVE);
462 LIST_FOREACH(pcb, &ng_btsocket_l2cap_raw_sockets, next) {
463 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
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);
474 lockmgr(&pcb->pcb_lock, LK_RELEASE);
477 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_RELEASE);
480 * Now cleanup routing table
483 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_EXCLUSIVE);
485 for (rt = LIST_FIRST(&ng_btsocket_l2cap_raw_rt); rt != NULL; ) {
486 ng_btsocket_l2cap_rtentry_p rt_next = LIST_NEXT(rt, next);
488 if (rt->hook != NULL && NG_HOOK_NOT_VALID(rt->hook)) {
489 LIST_REMOVE(rt, next);
491 NG_HOOK_SET_PRIVATE(rt->hook, NULL);
492 NG_HOOK_UNREF(rt->hook); /* Remove extra reference */
494 bzero(rt, sizeof(*rt));
495 kfree(rt, M_NETGRAPH_BTSOCKET_L2CAP_RAW);
501 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_RELEASE);
502 } /* ng_btsocket_l2cap_raw_rtclean */
505 * Initialize everything
509 ng_btsocket_l2cap_raw_init(void)
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;
517 /* Register Netgraph node type */
518 error = ng_newtype(&typestruct);
520 NG_BTSOCKET_L2CAP_RAW_ALERT(
521 "%s: Could not register Netgraph node type, error=%d\n", __func__, error);
526 /* Create Netgrapg node */
527 error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_raw_node);
529 NG_BTSOCKET_L2CAP_RAW_ALERT(
530 "%s: Could not create Netgraph node, error=%d\n", __func__, error);
532 ng_btsocket_l2cap_raw_node = NULL;
537 error = ng_name_node(ng_btsocket_l2cap_raw_node,
538 NG_BTSOCKET_L2CAP_RAW_NODE_TYPE);
540 NG_BTSOCKET_L2CAP_RAW_ALERT(
541 "%s: Could not name Netgraph node, error=%d\n", __func__, error);
543 NG_NODE_UNREF(ng_btsocket_l2cap_raw_node);
544 ng_btsocket_l2cap_raw_node = NULL;
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);
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);
562 ng_btsocket_l2cap_raw_token = 0;
563 lockinit(&ng_btsocket_l2cap_raw_token_lock,
564 "btsocks_l2cap_raw_token_lock", 0, 0);
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 */
575 * Abort connection on socket
579 ng_btsocket_l2cap_raw_abort(netmsg_t msg)
582 (void)ng_btsocket_l2cap_raw_disconnect(msg);
583 } /* ng_btsocket_l2cap_raw_abort */
587 ng_btsocket_l2cap_raw_close(struct socket *so)
590 (void)ng_btsocket_l2cap_raw_disconnect(so);
591 } /* ng_btsocket_l2cap_raw_close */
595 * Create and attach new socket
599 ng_btsocket_l2cap_raw_attach(netmsg_t msg)
601 struct socket *so = msg->attach.base.nm_so;
602 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so);
610 if (ng_btsocket_l2cap_raw_node == NULL) {
611 error = EPROTONOSUPPORT;
614 if (so->so_type != SOCK_RAW) {
615 error = ESOCKTNOSUPPORT;
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);
625 /* Allocate the PCB */
626 pcb = kmalloc(sizeof(*pcb), M_NETGRAPH_BTSOCKET_L2CAP_RAW,
627 M_WAITOK | M_NULLOK | M_ZERO);
633 /* Link the PCB and the socket */
634 so->so_pcb = (caddr_t) pcb;
637 if (curproc == NULL ||
638 priv_check(curthread, PRIV_NETBLUETOOTH_RAW) == 0)
639 pcb->flags |= NG_BTSOCKET_L2CAP_RAW_PRIVILEGED;
641 lockinit(&pcb->pcb_lock, "btsocks_l2cap_raw_pcb_lock", 0, 0);
643 /* Add the PCB to the list */
644 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_EXCLUSIVE);
645 LIST_INSERT_HEAD(&ng_btsocket_l2cap_raw_sockets, pcb, next);
646 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_RELEASE);
649 lwkt_replymsg(&msg->attach.base.lmsg, error);
650 } /* ng_btsocket_l2cap_raw_attach */
657 ng_btsocket_l2cap_raw_bind(netmsg_t msg)
659 struct socket *so = msg->bind.base.nm_so;
660 struct sockaddr *nam = msg->bind.nm_nam;
661 ng_btsocket_l2cap_raw_pcb_t *pcb = so2l2cap_raw_pcb(so);
662 struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam;
663 ng_btsocket_l2cap_rtentry_t *rt = NULL;
670 if (ng_btsocket_l2cap_raw_node == NULL) {
679 if (sa->l2cap_family != AF_BLUETOOTH) {
680 error = EAFNOSUPPORT;
683 if (sa->l2cap_len != sizeof(*sa)) {
688 if (bcmp(&sa->l2cap_bdaddr, NG_HCI_BDADDR_ANY,
689 sizeof(sa->l2cap_bdaddr)) != 0) {
690 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_EXCLUSIVE);
692 LIST_FOREACH(rt, &ng_btsocket_l2cap_raw_rt, next) {
693 if (rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook))
696 if (bcmp(&sa->l2cap_bdaddr, &rt->src,
697 sizeof(rt->src)) == 0)
701 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_RELEASE);
710 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
711 bcopy(&sa->l2cap_bdaddr, &pcb->src, sizeof(pcb->src));
713 lockmgr(&pcb->pcb_lock, LK_RELEASE);
716 lwkt_replymsg(&msg->bind.base.lmsg, error);
717 } /* ng_btsocket_l2cap_raw_bind */
724 ng_btsocket_l2cap_raw_connect(netmsg_t msg)
726 struct socket *so = msg->connect.base.nm_so;
727 struct sockaddr *nam = msg->connect.nm_nam;
728 ng_btsocket_l2cap_raw_pcb_t *pcb = so2l2cap_raw_pcb(so);
729 struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam;
730 ng_btsocket_l2cap_rtentry_t *rt = NULL;
737 if (ng_btsocket_l2cap_raw_node == NULL) {
746 if (sa->l2cap_family != AF_BLUETOOTH) {
747 error = EAFNOSUPPORT;
750 if (sa->l2cap_len != sizeof(*sa)) {
754 if (bcmp(&sa->l2cap_bdaddr, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) == 0) {
759 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
761 bcopy(&sa->l2cap_bdaddr, &pcb->dst, sizeof(pcb->dst));
763 if (bcmp(&pcb->src, &pcb->dst, sizeof(pcb->src)) == 0) {
764 lockmgr(&pcb->pcb_lock, LK_RELEASE);
765 error = EADDRNOTAVAIL;
770 * If there is route already - use it
773 if (pcb->rt != NULL) {
775 lockmgr(&pcb->pcb_lock, LK_RELEASE);
780 * Find the first hook that does not match specified destination address
783 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_EXCLUSIVE);
785 LIST_FOREACH(rt, &ng_btsocket_l2cap_raw_rt, next) {
786 if (rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook))
789 if (bcmp(&pcb->dst, &rt->src, sizeof(rt->src)) != 0)
797 bcopy(&rt->src, &pcb->src, sizeof(pcb->src));
801 lockmgr(&ng_btsocket_l2cap_raw_rt_lock, LK_RELEASE);
802 lockmgr(&pcb->pcb_lock, LK_RELEASE);
805 lwkt_replymsg(&msg->connect.base.lmsg, error);
806 } /* ng_btsocket_l2cap_raw_connect */
809 * Process ioctl's calls on socket
813 ng_btsocket_l2cap_raw_control(netmsg_t msg)
815 struct socket *so = msg->control.base.nm_so;
816 u_long cmd = msg->control.nm_cmd;
817 caddr_t data = msg->control.nm_data;
818 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so);
819 struct ng_mesg *ngmsg = NULL;
826 if (ng_btsocket_l2cap_raw_node == NULL) {
831 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
833 /* Check if we route info */
834 if (pcb->rt == NULL) {
835 lockmgr(&pcb->pcb_lock, LK_RELEASE);
836 error = EHOSTUNREACH;
840 /* Check if we have pending ioctl() */
841 if (pcb->token != 0) {
842 lockmgr(&pcb->pcb_lock, LK_RELEASE);
848 case SIOC_L2CAP_NODE_GET_FLAGS: {
849 struct ng_btsocket_l2cap_raw_node_flags *p =
850 (struct ng_btsocket_l2cap_raw_node_flags *) data;
852 error = ng_btsocket_l2cap_raw_send_sync_ngmsg(pcb,
853 NGM_L2CAP_NODE_GET_FLAGS,
854 &p->flags, sizeof(p->flags));
857 case SIOC_L2CAP_NODE_GET_DEBUG: {
858 struct ng_btsocket_l2cap_raw_node_debug *p =
859 (struct ng_btsocket_l2cap_raw_node_debug *) data;
861 error = ng_btsocket_l2cap_raw_send_sync_ngmsg(pcb,
862 NGM_L2CAP_NODE_GET_DEBUG,
863 &p->debug, sizeof(p->debug));
866 case SIOC_L2CAP_NODE_SET_DEBUG: {
867 struct ng_btsocket_l2cap_raw_node_debug *p =
868 (struct ng_btsocket_l2cap_raw_node_debug *) data;
870 if (pcb->flags & NG_BTSOCKET_L2CAP_RAW_PRIVILEGED)
871 error = ng_btsocket_l2cap_raw_send_ngmsg(pcb->rt->hook,
872 NGM_L2CAP_NODE_SET_DEBUG,
873 &p->debug, sizeof(p->debug));
878 case SIOC_L2CAP_NODE_GET_CON_LIST: {
879 struct ng_btsocket_l2cap_raw_con_list *p =
880 (struct ng_btsocket_l2cap_raw_con_list *) data;
881 ng_l2cap_node_con_list_ep *p1 = NULL;
882 ng_l2cap_node_con_ep *p2 = NULL;
884 if (p->num_connections == 0 ||
885 p->num_connections > NG_L2CAP_MAX_CON_NUM ||
886 p->connections == NULL) {
891 NG_MKMESSAGE(ngmsg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_GET_CON_LIST,
892 0, M_WAITOK | M_NULLOK);
897 ng_btsocket_l2cap_raw_get_token(&ngmsg->header.token);
898 pcb->token = ngmsg->header.token;
901 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, ngmsg,
908 error = lksleep(&pcb->msg, &pcb->pcb_lock, PCATCH, "l2ctl",
909 ng_btsocket_l2cap_raw_ioctl_timeout * hz);
915 if (pcb->msg != NULL &&
916 pcb->msg->header.cmd == NGM_L2CAP_NODE_GET_CON_LIST) {
917 /* Return data back to user space */
918 p1 = (ng_l2cap_node_con_list_ep *)(pcb->msg->data);
919 p2 = (ng_l2cap_node_con_ep *)(p1 + 1);
921 p->num_connections = min(p->num_connections,
922 p1->num_connections);
923 if (p->num_connections > 0)
924 error = copyout((caddr_t) p2,
925 (caddr_t) p->connections,
926 p->num_connections * sizeof(*p2));
930 NG_FREE_MSG(pcb->msg); /* checks for != NULL */
933 case SIOC_L2CAP_NODE_GET_CHAN_LIST: {
934 struct ng_btsocket_l2cap_raw_chan_list *p =
935 (struct ng_btsocket_l2cap_raw_chan_list *) data;
936 ng_l2cap_node_chan_list_ep *p1 = NULL;
937 ng_l2cap_node_chan_ep *p2 = NULL;
939 if (p->num_channels == 0 ||
940 p->num_channels > NG_L2CAP_MAX_CHAN_NUM ||
941 p->channels == NULL) {
946 NG_MKMESSAGE(ngmsg, NGM_L2CAP_COOKIE,
947 NGM_L2CAP_NODE_GET_CHAN_LIST, 0, M_WAITOK | M_NULLOK);
952 ng_btsocket_l2cap_raw_get_token(&ngmsg->header.token);
953 pcb->token = ngmsg->header.token;
956 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, ngmsg,
963 error = lksleep(&pcb->msg, &pcb->pcb_lock, PCATCH, "l2ctl",
964 ng_btsocket_l2cap_raw_ioctl_timeout * hz);
970 if (pcb->msg != NULL &&
971 pcb->msg->header.cmd == NGM_L2CAP_NODE_GET_CHAN_LIST) {
972 /* Return data back to user space */
973 p1 = (ng_l2cap_node_chan_list_ep *)(pcb->msg->data);
974 p2 = (ng_l2cap_node_chan_ep *)(p1 + 1);
976 p->num_channels = min(p->num_channels,
978 if (p->num_channels > 0)
979 error = copyout((caddr_t) p2,
980 (caddr_t) p->channels,
981 p->num_channels * sizeof(*p2));
985 NG_FREE_MSG(pcb->msg); /* checks for != NULL */
988 case SIOC_L2CAP_L2CA_PING: {
989 struct ng_btsocket_l2cap_raw_ping *p =
990 (struct ng_btsocket_l2cap_raw_ping *) data;
991 ng_l2cap_l2ca_ping_ip *ip = NULL;
992 ng_l2cap_l2ca_ping_op *op = NULL;
994 if (!(pcb->flags & NG_BTSOCKET_L2CAP_RAW_PRIVILEGED)) {
999 if ((p->echo_size != 0 && p->echo_data == NULL) ||
1000 p->echo_size > NG_L2CAP_MAX_ECHO_SIZE) {
1005 NG_MKMESSAGE(ngmsg, NGM_L2CAP_COOKIE,
1006 NGM_L2CAP_L2CA_PING, sizeof(*ip) + p->echo_size,
1007 M_WAITOK | M_NULLOK);
1008 if (ngmsg == NULL) {
1012 ng_btsocket_l2cap_raw_get_token(&ngmsg->header.token);
1013 pcb->token = ngmsg->header.token;
1016 ip = (ng_l2cap_l2ca_ping_ip *)(ngmsg->data);
1017 bcopy(&pcb->dst, &ip->bdaddr, sizeof(ip->bdaddr));
1018 ip->echo_size = p->echo_size;
1020 if (ip->echo_size > 0) {
1021 error = copyin(p->echo_data, ip + 1, p->echo_size);
1029 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, ngmsg,
1036 error = lksleep(&pcb->msg, &pcb->pcb_lock, PCATCH, "l2ctl",
1037 bluetooth_l2cap_rtx_timeout());
1043 if (pcb->msg != NULL &&
1044 pcb->msg->header.cmd == NGM_L2CAP_L2CA_PING) {
1045 /* Return data back to the user space */
1046 op = (ng_l2cap_l2ca_ping_op *)(pcb->msg->data);
1047 p->result = op->result;
1048 p->echo_size = min(p->echo_size, op->echo_size);
1050 if (p->echo_size > 0)
1051 error = copyout(op + 1, p->echo_data,
1056 NG_FREE_MSG(pcb->msg); /* checks for != NULL */
1059 case SIOC_L2CAP_L2CA_GET_INFO: {
1060 struct ng_btsocket_l2cap_raw_get_info *p =
1061 (struct ng_btsocket_l2cap_raw_get_info *) data;
1062 ng_l2cap_l2ca_get_info_ip *ip = NULL;
1063 ng_l2cap_l2ca_get_info_op *op = NULL;
1065 if (!(pcb->flags & NG_BTSOCKET_L2CAP_RAW_PRIVILEGED)) {
1070 if (p->info_size != 0 && p->info_data == NULL) {
1075 NG_MKMESSAGE(ngmsg, NGM_L2CAP_COOKIE,
1076 NGM_L2CAP_L2CA_GET_INFO, sizeof(*ip) + p->info_size,
1077 M_WAITOK | M_NULLOK);
1078 if (ngmsg == NULL) {
1082 ng_btsocket_l2cap_raw_get_token(&ngmsg->header.token);
1083 pcb->token = ngmsg->header.token;
1086 ip = (ng_l2cap_l2ca_get_info_ip *)(ngmsg->data);
1087 bcopy(&pcb->dst, &ip->bdaddr, sizeof(ip->bdaddr));
1088 ip->info_type = p->info_type;
1090 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, ngmsg,
1097 error = lksleep(&pcb->msg, &pcb->pcb_lock, PCATCH, "l2ctl",
1098 bluetooth_l2cap_rtx_timeout());
1104 if (pcb->msg != NULL &&
1105 pcb->msg->header.cmd == NGM_L2CAP_L2CA_GET_INFO) {
1106 /* Return data back to the user space */
1107 op = (ng_l2cap_l2ca_get_info_op *)(pcb->msg->data);
1108 p->result = op->result;
1109 p->info_size = min(p->info_size, op->info_size);
1111 if (p->info_size > 0)
1112 error = copyout(op + 1, p->info_data,
1117 NG_FREE_MSG(pcb->msg); /* checks for != NULL */
1120 case SIOC_L2CAP_NODE_GET_AUTO_DISCON_TIMO: {
1121 struct ng_btsocket_l2cap_raw_auto_discon_timo *p =
1122 (struct ng_btsocket_l2cap_raw_auto_discon_timo *) data;
1124 error = ng_btsocket_l2cap_raw_send_sync_ngmsg(pcb,
1125 NGM_L2CAP_NODE_GET_AUTO_DISCON_TIMO,
1126 &p->timeout, sizeof(p->timeout));
1129 case SIOC_L2CAP_NODE_SET_AUTO_DISCON_TIMO: {
1130 struct ng_btsocket_l2cap_raw_auto_discon_timo *p =
1131 (struct ng_btsocket_l2cap_raw_auto_discon_timo *) data;
1133 if (pcb->flags & NG_BTSOCKET_L2CAP_RAW_PRIVILEGED)
1134 error = ng_btsocket_l2cap_raw_send_ngmsg(pcb->rt->hook,
1135 NGM_L2CAP_NODE_SET_AUTO_DISCON_TIMO,
1136 &p->timeout, sizeof(p->timeout));
1146 lockmgr(&pcb->pcb_lock, LK_RELEASE);
1149 lwkt_replymsg(&msg->control.base.lmsg, error);
1150 } /* ng_btsocket_l2cap_raw_control */
1153 * Detach and destroy socket
1157 ng_btsocket_l2cap_raw_detach(netmsg_t msg)
1159 struct socket *so = msg->detach.base.nm_so;
1160 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so);
1163 KASSERT(pcb != NULL, ("nt_btsocket_l2cap_raw_detach: pcb == NULL"));
1164 if (ng_btsocket_l2cap_raw_node == NULL)
1167 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_EXCLUSIVE);
1168 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
1170 LIST_REMOVE(pcb, next);
1172 lockmgr(&pcb->pcb_lock, LK_RELEASE);
1173 lockmgr(&ng_btsocket_l2cap_raw_sockets_lock, LK_RELEASE);
1175 lockuninit(&pcb->pcb_lock);
1177 bzero(pcb, sizeof(*pcb));
1178 kfree(pcb, M_NETGRAPH_BTSOCKET_L2CAP_RAW);
1183 lwkt_replymsg(&msg->detach.base.lmsg, error);
1184 } /* ng_btsocket_l2cap_raw_detach */
1191 ng_btsocket_l2cap_raw_disconnect(netmsg_t msg)
1193 struct socket *so = msg->disconnect.base.nm_so;
1194 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so);
1201 if (ng_btsocket_l2cap_raw_node == NULL) {
1206 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
1208 soisdisconnected(so);
1209 lockmgr(&pcb->pcb_lock, LK_RELEASE);
1212 lwkt_replymsg(&msg->disconnect.base.lmsg, error);
1213 } /* ng_btsocket_l2cap_raw_disconnect */
1220 ng_btsocket_l2cap_raw_peeraddr(netmsg_t msg)
1222 struct socket *so = msg->peeraddr.base.nm_so;
1223 struct sockaddr **nam = msg->peeraddr.nm_nam;
1224 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so);
1225 struct sockaddr_l2cap sa;
1232 if (ng_btsocket_l2cap_raw_node == NULL) {
1237 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
1238 bcopy(&pcb->dst, &sa.l2cap_bdaddr, sizeof(sa.l2cap_bdaddr));
1239 lockmgr(&pcb->pcb_lock, LK_RELEASE);
1242 sa.l2cap_len = sizeof(sa);
1243 sa.l2cap_family = AF_BLUETOOTH;
1245 *nam = dup_sockaddr((struct sockaddr *) &sa);
1251 lwkt_replymsg(&msg->peeraddr.base.lmsg, error);
1252 } /* ng_btsocket_l2cap_raw_peeraddr */
1255 * Send data to socket
1259 ng_btsocket_l2cap_raw_send(netmsg_t msg)
1261 struct mbuf *control = msg->send.nm_control;
1262 struct mbuf *m = msg->send.nm_m;
1264 NG_FREE_M(m); /* Checks for m != NULL */
1267 lwkt_replymsg(&msg->send.base.lmsg, EOPNOTSUPP);
1268 } /* ng_btsocket_l2cap_raw_send */
1271 * Get socket address
1275 ng_btsocket_l2cap_raw_sockaddr(netmsg_t msg)
1277 struct socket *so = msg->sockaddr.base.nm_so;
1278 struct sockaddr **nam = msg->sockaddr.nm_nam;
1279 ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so);
1280 struct sockaddr_l2cap sa;
1287 if (ng_btsocket_l2cap_raw_node == NULL) {
1292 lockmgr(&pcb->pcb_lock, LK_EXCLUSIVE);
1293 bcopy(&pcb->src, &sa.l2cap_bdaddr, sizeof(sa.l2cap_bdaddr));
1294 lockmgr(&pcb->pcb_lock, LK_RELEASE);
1297 sa.l2cap_len = sizeof(sa);
1298 sa.l2cap_family = AF_BLUETOOTH;
1300 *nam = dup_sockaddr((struct sockaddr *) &sa);
1306 lwkt_replymsg(&msg->sockaddr.base.lmsg, error);
1307 } /* ng_btsocket_l2cap_raw_sockaddr */
1314 ng_btsocket_l2cap_raw_get_token(u_int32_t *token)
1316 lockmgr(&ng_btsocket_l2cap_raw_token_lock, LK_EXCLUSIVE);
1318 if (++ ng_btsocket_l2cap_raw_token == 0)
1319 ng_btsocket_l2cap_raw_token = 1;
1321 *token = ng_btsocket_l2cap_raw_token;
1323 lockmgr(&ng_btsocket_l2cap_raw_token_lock, LK_RELEASE);
1324 } /* ng_btsocket_l2cap_raw_get_token */
1327 * Send Netgraph message to the node - do not expect reply
1331 ng_btsocket_l2cap_raw_send_ngmsg(hook_p hook, int cmd, void *arg, int arglen)
1333 struct ng_mesg *msg = NULL;
1336 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, cmd, arglen, M_WAITOK | M_NULLOK);
1340 if (arg != NULL && arglen > 0)
1341 bcopy(arg, msg->data, arglen);
1343 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, hook, 0);
1346 } /* ng_btsocket_l2cap_raw_send_ngmsg */
1349 * Send Netgraph message to the node (no data) and wait for reply
1353 ng_btsocket_l2cap_raw_send_sync_ngmsg(ng_btsocket_l2cap_raw_pcb_p pcb,
1354 int cmd, void *rsp, int rsplen)
1356 struct ng_mesg *msg = NULL;
1359 KKASSERT(lockowned(&pcb->pcb_lock) != 0);
1361 NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, cmd, 0, M_WAITOK | M_NULLOK);
1365 ng_btsocket_l2cap_raw_get_token(&msg->header.token);
1366 pcb->token = msg->header.token;
1369 NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg,
1376 error = lksleep(&pcb->msg, &pcb->pcb_lock, PCATCH, "l2ctl",
1377 ng_btsocket_l2cap_raw_ioctl_timeout * hz);
1383 if (pcb->msg != NULL && pcb->msg->header.cmd == cmd)
1384 bcopy(pcb->msg->data, rsp, rsplen);
1388 NG_FREE_MSG(pcb->msg); /* checks for != NULL */
1391 } /* ng_btsocket_l2cap_raw_send_sync_ngmsg */