1/*
2 * ng_l2cap_misc.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_misc.c,v 1.5 2003/09/08 19:11:45 max Exp $
31 * $FreeBSD$
32 */
33
34#include <sys/param.h>
35#include <sys/systm.h>
36#include <sys/kernel.h>
37#include <sys/malloc.h>
38#include <sys/mbuf.h>
39#include <sys/queue.h>
40#include <netgraph/ng_message.h>
41#include <netgraph/netgraph.h>
42#include <netgraph/bluetooth/include/ng_bluetooth.h>
43#include <netgraph/bluetooth/include/ng_hci.h>
44#include <netgraph/bluetooth/include/ng_l2cap.h>
45#include <netgraph/bluetooth/l2cap/ng_l2cap_var.h>
46#include <netgraph/bluetooth/l2cap/ng_l2cap_cmds.h>
47#include <netgraph/bluetooth/l2cap/ng_l2cap_evnt.h>
48#include <netgraph/bluetooth/l2cap/ng_l2cap_llpi.h>
49#include <netgraph/bluetooth/l2cap/ng_l2cap_ulpi.h>
50#include <netgraph/bluetooth/l2cap/ng_l2cap_misc.h>
51
52static u_int16_t	ng_l2cap_get_cid	(ng_l2cap_p, int);
53
54/******************************************************************************
55 ******************************************************************************
56 **                              Utility routines
57 ******************************************************************************
58 ******************************************************************************/
59
60/*
61 * Send hook information to the upper layer
62 */
63
64void
65ng_l2cap_send_hook_info(node_p node, hook_p hook, void *arg1, int arg2)
66{
67	ng_l2cap_p	 l2cap = NULL;
68	struct ng_mesg	*msg = NULL;
69	int		 error = 0;
70	ng_l2cap_node_hook_info_ep *ep ;
71
72	if (node == NULL || NG_NODE_NOT_VALID(node) ||
73	    hook == NULL || NG_HOOK_NOT_VALID(hook))
74		return;
75
76	l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node);
77	if (l2cap->hci == NULL || NG_HOOK_NOT_VALID(l2cap->hci) ||
78	    bcmp(&l2cap->bdaddr, NG_HCI_BDADDR_ANY, sizeof(l2cap->bdaddr)) == 0)
79		return;
80
81	NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_HOOK_INFO,
82		     sizeof(*ep), M_NOWAIT);
83
84	if (msg != NULL) {
85		ep = (ng_l2cap_node_hook_info_ep *) &msg->data;
86		bcopy(&l2cap->bdaddr, &ep->addr, sizeof(bdaddr_t));
87		NG_SEND_MSG_HOOK(error, node, msg, hook, 0);
88	} else
89		error = ENOMEM;
90
91	if (error != 0)
92		NG_L2CAP_INFO(
93"%s: %s - failed to send HOOK_INFO message to hook \"%s\", error=%d\n",
94			__func__, NG_NODE_NAME(l2cap->node), NG_HOOK_NAME(hook),
95			error);
96} /* ng_l2cap_send_hook_info */
97
98/*
99 * Create new connection descriptor for the "remote" unit.
100 * Will link connection descriptor to the l2cap node.
101 */
102
103ng_l2cap_con_p
104ng_l2cap_new_con(ng_l2cap_p l2cap, bdaddr_p bdaddr, int type)
105{
106	static int	fake_con_handle = 0x0f00;
107	ng_l2cap_con_p	con = NULL;
108
109	/* Create new connection descriptor */
110	con = malloc(sizeof(*con), M_NETGRAPH_L2CAP,
111		M_NOWAIT|M_ZERO);
112	if (con == NULL)
113		return (NULL);
114
115	con->l2cap = l2cap;
116	con->state = NG_L2CAP_CON_CLOSED;
117	con->encryption = 0;
118	/*
119	 * XXX
120	 *
121	 * Assign fake connection handle to the connection descriptor.
122	 * Bluetooth specification marks 0x0f00 - 0x0fff connection
123	 * handles as reserved. We need this fake connection handles
124	 * for timeouts. Connection handle will be passed as argument
125	 * to timeout so when timeout happens we can find the right
126	 * connection descriptor. We can not pass pointers, because
127	 * timeouts are external (to Netgraph) events and there might
128	 * be a race when node/hook goes down and timeout event already
129	 * went into node's queue
130	 */
131
132	con->con_handle = fake_con_handle ++;
133	if (fake_con_handle > 0x0fff)
134		fake_con_handle = 0x0f00;
135
136	bcopy(bdaddr, &con->remote, sizeof(con->remote));
137	con->linktype = type;
138	ng_callout_init(&con->con_timo);
139
140	con->ident = NG_L2CAP_FIRST_IDENT - 1;
141	TAILQ_INIT(&con->cmd_list);
142
143	/* Link connection */
144	LIST_INSERT_HEAD(&l2cap->con_list, con, next);
145
146	return (con);
147} /* ng_l2cap_new_con */
148
149/*
150 * Add reference to the connection descriptor
151 */
152
153void
154ng_l2cap_con_ref(ng_l2cap_con_p con)
155{
156	con->refcnt ++;
157
158	if (con->flags & NG_L2CAP_CON_AUTO_DISCON_TIMO) {
159		if ((con->state != NG_L2CAP_CON_OPEN) ||
160		    (con->flags & NG_L2CAP_CON_OUTGOING) == 0)
161			panic(
162"%s: %s - bad auto disconnect timeout, state=%d, flags=%#x\n",
163				__func__, NG_NODE_NAME(con->l2cap->node),
164				con->state, con->flags);
165
166		ng_l2cap_discon_untimeout(con);
167	}
168} /* ng_l2cap_con_ref */
169
170/*
171 * Remove reference from the connection descriptor
172 */
173
174void
175ng_l2cap_con_unref(ng_l2cap_con_p con)
176{
177	con->refcnt --;
178
179	if (con->refcnt < 0)
180		panic(
181"%s: %s - con->refcnt < 0\n", __func__, NG_NODE_NAME(con->l2cap->node));
182
183	/*
184	 * Set auto disconnect timer only if the following conditions are met:
185	 * 1) we have no reference on the connection
186	 * 2) connection is in OPEN state
187	 * 3) it is an outgoing connection
188	 * 4) disconnect timeout > 0
189	 * 5) connection is not dying
190	 */
191
192	if ((con->refcnt == 0) &&
193	    (con->state == NG_L2CAP_CON_OPEN) &&
194	    (con->flags & NG_L2CAP_CON_OUTGOING) &&
195	    (con->l2cap->discon_timo > 0) &&
196	    ((con->flags & NG_L2CAP_CON_DYING) == 0))
197		ng_l2cap_discon_timeout(con);
198} /* ng_l2cap_con_unref */
199
200/*
201 * Set auto disconnect timeout
202 * XXX FIXME: check return code from ng_callout
203 */
204
205int
206ng_l2cap_discon_timeout(ng_l2cap_con_p con)
207{
208	if (con->flags & (NG_L2CAP_CON_LP_TIMO|NG_L2CAP_CON_AUTO_DISCON_TIMO))
209		panic(
210"%s: %s - invalid timeout, state=%d, flags=%#x\n",
211			__func__, NG_NODE_NAME(con->l2cap->node),
212			con->state, con->flags);
213
214	con->flags |= NG_L2CAP_CON_AUTO_DISCON_TIMO;
215	ng_callout(&con->con_timo, con->l2cap->node, NULL,
216				con->l2cap->discon_timo * hz,
217				ng_l2cap_process_discon_timeout, NULL,
218				con->con_handle);
219
220	return (0);
221} /* ng_l2cap_discon_timeout */
222
223/*
224 * Unset auto disconnect timeout
225 */
226
227int
228ng_l2cap_discon_untimeout(ng_l2cap_con_p con)
229{
230	if (!(con->flags & NG_L2CAP_CON_AUTO_DISCON_TIMO))
231		panic(
232"%s: %s - no disconnect timeout, state=%d, flags=%#x\n",
233			__func__,  NG_NODE_NAME(con->l2cap->node),
234			con->state, con->flags);
235
236	if (ng_uncallout(&con->con_timo, con->l2cap->node) == 0)
237		return (ETIMEDOUT);
238
239	con->flags &= ~NG_L2CAP_CON_AUTO_DISCON_TIMO;
240
241	return (0);
242} /* ng_l2cap_discon_untimeout */
243
244/*
245 * Free connection descriptor. Will unlink connection and free everything.
246 */
247
248void
249ng_l2cap_free_con(ng_l2cap_con_p con)
250{
251	ng_l2cap_chan_p f = NULL, n = NULL;
252
253	con->state = NG_L2CAP_CON_CLOSED;
254
255	while (con->tx_pkt != NULL) {
256		struct mbuf	*m = con->tx_pkt->m_nextpkt;
257
258		m_freem(con->tx_pkt);
259		con->tx_pkt = m;
260	}
261
262	NG_FREE_M(con->rx_pkt);
263
264	for (f = LIST_FIRST(&con->l2cap->chan_list); f != NULL; ) {
265		n = LIST_NEXT(f, next);
266
267		if (f->con == con)
268			ng_l2cap_free_chan(f);
269
270		f = n;
271	}
272
273	while (!TAILQ_EMPTY(&con->cmd_list)) {
274		ng_l2cap_cmd_p	cmd = TAILQ_FIRST(&con->cmd_list);
275
276		ng_l2cap_unlink_cmd(cmd);
277		if (cmd->flags & NG_L2CAP_CMD_PENDING)
278			ng_l2cap_command_untimeout(cmd);
279		ng_l2cap_free_cmd(cmd);
280	}
281
282	if (con->flags & (NG_L2CAP_CON_AUTO_DISCON_TIMO|NG_L2CAP_CON_LP_TIMO))
283		panic(
284"%s: %s - timeout pending! state=%d, flags=%#x\n",
285			__func__,  NG_NODE_NAME(con->l2cap->node),
286			con->state, con->flags);
287
288	LIST_REMOVE(con, next);
289
290	bzero(con, sizeof(*con));
291	free(con, M_NETGRAPH_L2CAP);
292} /* ng_l2cap_free_con */
293
294/*
295 * Get connection by "remote" address
296 */
297
298ng_l2cap_con_p
299ng_l2cap_con_by_addr(ng_l2cap_p l2cap, bdaddr_p bdaddr, unsigned int type)
300{
301	ng_l2cap_con_p	con = NULL;
302
303	LIST_FOREACH(con, &l2cap->con_list, next)
304		if ((bcmp(bdaddr, &con->remote, sizeof(con->remote)) == 0)&&
305		    (con->linktype == type))
306			break;
307
308	return (con);
309} /* ng_l2cap_con_by_addr */
310
311/*
312 * Get connection by "handle"
313 */
314
315ng_l2cap_con_p
316ng_l2cap_con_by_handle(ng_l2cap_p l2cap, u_int16_t con_handle)
317{
318	ng_l2cap_con_p	con = NULL;
319
320	LIST_FOREACH(con, &l2cap->con_list, next)
321		if (con->con_handle == con_handle)
322			break;
323
324	return (con);
325} /* ng_l2cap_con_by_handle */
326
327/*
328 * Allocate new L2CAP channel descriptor on "con" connection with "psm".
329 * Will link the channel to the l2cap node
330 */
331
332ng_l2cap_chan_p
333ng_l2cap_new_chan(ng_l2cap_p l2cap, ng_l2cap_con_p con, u_int16_t psm, int idtype)
334{
335	ng_l2cap_chan_p	ch = NULL;
336
337	ch = malloc(sizeof(*ch), M_NETGRAPH_L2CAP,
338		M_NOWAIT|M_ZERO);
339	if (ch == NULL)
340		return (NULL);
341	if(idtype == NG_L2CAP_L2CA_IDTYPE_ATT){
342		ch->scid = ch->dcid = NG_L2CAP_ATT_CID;
343	}else if(idtype == NG_L2CAP_L2CA_IDTYPE_SMP){
344		ch->scid = ch->dcid = NG_L2CAP_SMP_CID;
345	}else{
346		ch->scid = ng_l2cap_get_cid(l2cap,
347					    (con->linktype!= NG_HCI_LINK_ACL));
348	}
349
350	ch->idtype = idtype;
351	if (ch->scid != NG_L2CAP_NULL_CID) {
352		/* Initialize channel */
353		ch->psm = psm;
354		ch->con = con;
355		ch->state = NG_L2CAP_CLOSED;
356
357		/* Set MTU and flow control settings to defaults */
358		ch->imtu = NG_L2CAP_MTU_DEFAULT;
359		bcopy(ng_l2cap_default_flow(), &ch->iflow, sizeof(ch->iflow));
360
361		ch->omtu = NG_L2CAP_MTU_DEFAULT;
362		bcopy(ng_l2cap_default_flow(), &ch->oflow, sizeof(ch->oflow));
363
364		ch->flush_timo = NG_L2CAP_FLUSH_TIMO_DEFAULT;
365		ch->link_timo = NG_L2CAP_LINK_TIMO_DEFAULT;
366
367		LIST_INSERT_HEAD(&l2cap->chan_list, ch, next);
368
369		ng_l2cap_con_ref(con);
370	} else {
371		bzero(ch, sizeof(*ch));
372		free(ch, M_NETGRAPH_L2CAP);
373		ch = NULL;
374	}
375
376	return (ch);
377} /* ng_l2cap_new_chan */
378
379
380ng_l2cap_chan_p
381ng_l2cap_chan_by_scid(ng_l2cap_p l2cap, u_int16_t scid, int idtype)
382{
383	ng_l2cap_chan_p	ch = NULL;
384
385	if((idtype == NG_L2CAP_L2CA_IDTYPE_ATT)||
386	   (idtype == NG_L2CAP_L2CA_IDTYPE_SMP)){
387		return NULL;
388	}
389
390	LIST_FOREACH(ch, &l2cap->chan_list, next){
391		if((idtype != NG_L2CAP_L2CA_IDTYPE_BREDR)&&
392		   (ch->con->linktype == NG_HCI_LINK_ACL ))
393			continue;
394		if((idtype != NG_L2CAP_L2CA_IDTYPE_LE)&&
395		   (ch->con->linktype != NG_HCI_LINK_ACL ))
396			continue;
397		if (ch->scid == scid)
398			break;
399	}
400	return (ch);
401} /* ng_l2cap_chan_by_scid */
402
403ng_l2cap_chan_p
404ng_l2cap_chan_by_conhandle(ng_l2cap_p l2cap, uint16_t scid,
405			   u_int16_t con_handle)
406{
407	ng_l2cap_chan_p	ch = NULL;
408
409
410	LIST_FOREACH(ch, &l2cap->chan_list, next){
411		if ((ch->scid == scid) &&
412		    (ch->con->con_handle == con_handle))
413			break;
414	}
415	return (ch);
416} /* ng_l2cap_chan_by_scid */
417
418/*
419 * Free channel descriptor.
420 */
421
422void
423ng_l2cap_free_chan(ng_l2cap_chan_p ch)
424{
425	ng_l2cap_cmd_p	f = NULL, n = NULL;
426
427	f = TAILQ_FIRST(&ch->con->cmd_list);
428
429	while (f != NULL) {
430		n = TAILQ_NEXT(f, next);
431
432		if (f->ch == ch) {
433			ng_l2cap_unlink_cmd(f);
434			if (f->flags & NG_L2CAP_CMD_PENDING)
435				ng_l2cap_command_untimeout(f);
436			ng_l2cap_free_cmd(f);
437		}
438
439		f = n;
440	}
441
442	LIST_REMOVE(ch, next);
443
444	ng_l2cap_con_unref(ch->con);
445
446	bzero(ch, sizeof(*ch));
447	free(ch, M_NETGRAPH_L2CAP);
448} /* ng_l2cap_free_chan */
449
450/*
451 * Create new L2CAP command descriptor. WILL NOT add command to the queue.
452 */
453
454ng_l2cap_cmd_p
455ng_l2cap_new_cmd(ng_l2cap_con_p con, ng_l2cap_chan_p ch, u_int8_t ident,
456		u_int8_t code, u_int32_t token)
457{
458	ng_l2cap_cmd_p	cmd = NULL;
459
460	KASSERT((ch == NULL || ch->con == con),
461("%s: %s - invalid channel pointer!\n",
462		__func__, NG_NODE_NAME(con->l2cap->node)));
463
464	cmd = malloc(sizeof(*cmd), M_NETGRAPH_L2CAP,
465		M_NOWAIT|M_ZERO);
466	if (cmd == NULL)
467		return (NULL);
468
469	cmd->con = con;
470	cmd->ch = ch;
471	cmd->ident = ident;
472	cmd->code = code;
473	cmd->token = token;
474	ng_callout_init(&cmd->timo);
475
476	return (cmd);
477} /* ng_l2cap_new_cmd */
478
479/*
480 * Get pending (i.e. initiated by local side) L2CAP command descriptor by ident
481 */
482
483ng_l2cap_cmd_p
484ng_l2cap_cmd_by_ident(ng_l2cap_con_p con, u_int8_t ident)
485{
486	ng_l2cap_cmd_p	cmd = NULL;
487
488	TAILQ_FOREACH(cmd, &con->cmd_list, next) {
489		if ((cmd->flags & NG_L2CAP_CMD_PENDING) && cmd->ident == ident) {
490			KASSERT((cmd->con == con),
491("%s: %s - invalid connection pointer!\n",
492				__func__, NG_NODE_NAME(con->l2cap->node)));
493
494			break;
495		}
496	}
497
498	return (cmd);
499} /* ng_l2cap_cmd_by_ident */
500
501/*
502 * Set LP timeout
503 * XXX FIXME: check return code from ng_callout
504 */
505
506int
507ng_l2cap_lp_timeout(ng_l2cap_con_p con)
508{
509	if (con->flags & (NG_L2CAP_CON_LP_TIMO|NG_L2CAP_CON_AUTO_DISCON_TIMO))
510		panic(
511"%s: %s - invalid timeout, state=%d, flags=%#x\n",
512			__func__, NG_NODE_NAME(con->l2cap->node),
513			con->state, con->flags);
514
515	con->flags |= NG_L2CAP_CON_LP_TIMO;
516	ng_callout(&con->con_timo, con->l2cap->node, NULL,
517				bluetooth_hci_connect_timeout(),
518				ng_l2cap_process_lp_timeout, NULL,
519				con->con_handle);
520
521	return (0);
522} /* ng_l2cap_lp_timeout */
523
524/*
525 * Unset LP timeout
526 */
527
528int
529ng_l2cap_lp_untimeout(ng_l2cap_con_p con)
530{
531	if (!(con->flags & NG_L2CAP_CON_LP_TIMO))
532		panic(
533"%s: %s - no LP connection timeout, state=%d, flags=%#x\n",
534			__func__,  NG_NODE_NAME(con->l2cap->node),
535			con->state, con->flags);
536
537	if (ng_uncallout(&con->con_timo, con->l2cap->node) == 0)
538		return (ETIMEDOUT);
539
540	con->flags &= ~NG_L2CAP_CON_LP_TIMO;
541
542	return (0);
543} /* ng_l2cap_lp_untimeout */
544
545/*
546 * Set L2CAP command timeout
547 * XXX FIXME: check return code from ng_callout
548 */
549
550int
551ng_l2cap_command_timeout(ng_l2cap_cmd_p cmd, int timo)
552{
553	int	arg;
554
555	if (cmd->flags & NG_L2CAP_CMD_PENDING)
556		panic(
557"%s: %s - duplicated command timeout, code=%#x, flags=%#x\n",
558			__func__, NG_NODE_NAME(cmd->con->l2cap->node),
559			cmd->code, cmd->flags);
560
561	arg = ((cmd->ident << 16) | cmd->con->con_handle);
562	cmd->flags |= NG_L2CAP_CMD_PENDING;
563	ng_callout(&cmd->timo, cmd->con->l2cap->node, NULL, timo,
564				ng_l2cap_process_command_timeout, NULL, arg);
565
566	return (0);
567} /* ng_l2cap_command_timeout */
568
569/*
570 * Unset L2CAP command timeout
571 */
572
573int
574ng_l2cap_command_untimeout(ng_l2cap_cmd_p cmd)
575{
576	if (!(cmd->flags & NG_L2CAP_CMD_PENDING))
577		panic(
578"%s: %s - no command timeout, code=%#x, flags=%#x\n",
579			__func__, NG_NODE_NAME(cmd->con->l2cap->node),
580			cmd->code, cmd->flags);
581
582	if (ng_uncallout(&cmd->timo, cmd->con->l2cap->node) == 0)
583		return (ETIMEDOUT);
584
585	cmd->flags &= ~NG_L2CAP_CMD_PENDING;
586
587	return (0);
588} /* ng_l2cap_command_untimeout */
589
590/*
591 * Prepend "m"buf with "size" bytes
592 */
593
594struct mbuf *
595ng_l2cap_prepend(struct mbuf *m, int size)
596{
597	M_PREPEND(m, size, M_NOWAIT);
598	if (m == NULL || (m->m_len < size && (m = m_pullup(m, size)) == NULL))
599		return (NULL);
600
601	return (m);
602} /* ng_l2cap_prepend */
603
604/*
605 * Default flow settings
606 */
607
608ng_l2cap_flow_p
609ng_l2cap_default_flow(void)
610{
611	static ng_l2cap_flow_t	default_flow = {
612		/* flags */		0x0,
613		/* service_type */	NG_HCI_SERVICE_TYPE_BEST_EFFORT,
614		/* token_rate */	0xffffffff, /* maximum */
615		/* token_bucket_size */	0xffffffff, /* maximum */
616		/* peak_bandwidth */	0x00000000, /* maximum */
617		/* latency */		0xffffffff, /* don't care */
618		/* delay_variation */	0xffffffff  /* don't care */
619	};
620
621	return (&default_flow);
622} /* ng_l2cap_default_flow */
623
624/*
625 * Get next available channel ID
626 * XXX FIXME this is *UGLY* but will do for now
627 */
628
629static u_int16_t
630ng_l2cap_get_cid(ng_l2cap_p l2cap,int isle)
631{
632	u_int16_t	cid ;
633	u_int16_t 	endcid;
634	uint16_t	 mask;
635	int idtype;
636	if(isle){
637		endcid = l2cap->lecid;
638		/*Assume Last CID is 2^n-1 */
639		mask = NG_L2CAP_LELAST_CID;
640		idtype = NG_L2CAP_L2CA_IDTYPE_LE;
641	}else{
642		endcid = l2cap->cid;
643		/*Assume Last CID is 2^n-1 */
644		mask = NG_L2CAP_LAST_CID;
645		idtype = NG_L2CAP_L2CA_IDTYPE_BREDR;
646	}
647	cid = (endcid+1) & mask;
648
649	if (cid < NG_L2CAP_FIRST_CID)
650		cid = NG_L2CAP_FIRST_CID;
651
652	while (cid != endcid) {
653		if (ng_l2cap_chan_by_scid(l2cap, cid, idtype) == NULL) {
654			if(!isle){
655				l2cap->cid = cid;
656			}else{
657				l2cap->lecid = cid;
658			}
659			return (cid);
660		}
661
662		cid ++;
663		cid &= mask;
664		if (cid < NG_L2CAP_FIRST_CID)
665			cid = NG_L2CAP_FIRST_CID;
666	}
667
668	return (NG_L2CAP_NULL_CID);
669} /* ng_l2cap_get_cid */
670
671/*
672 * Get next available command ident
673 * XXX FIXME this is *UGLY* but will do for now
674 */
675
676u_int8_t
677ng_l2cap_get_ident(ng_l2cap_con_p con)
678{
679	u_int8_t	ident = con->ident + 1;
680
681	if (ident < NG_L2CAP_FIRST_IDENT)
682		ident = NG_L2CAP_FIRST_IDENT;
683
684	while (ident != con->ident) {
685		if (ng_l2cap_cmd_by_ident(con, ident) == NULL) {
686			con->ident = ident;
687
688			return (ident);
689		}
690
691		ident ++;
692		if (ident < NG_L2CAP_FIRST_IDENT)
693			ident = NG_L2CAP_FIRST_IDENT;
694	}
695
696	return (NG_L2CAP_NULL_IDENT);
697} /* ng_l2cap_get_ident */
698
699