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