Annotation of sys/netbt/rfcomm_dlc.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rfcomm_dlc.c,v 1.1 2007/06/01 02:46:12 uwe Exp $ */
2: /* $NetBSD: rfcomm_dlc.c,v 1.3 2007/04/21 06:15:23 plunky Exp $ */
3:
4: /*-
5: * Copyright (c) 2006 Itronix Inc.
6: * All rights reserved.
7: *
8: * Written by Iain Hibbert for Itronix Inc.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. The name of Itronix Inc. may not be used to endorse
19: * or promote products derived from this software without specific
20: * prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
26: * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
29: * ON ANY THEORY OF LIABILITY, WHETHER IN
30: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32: * POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: #include <sys/cdefs.h>
36:
37: #include <sys/param.h>
38: #include <sys/kernel.h>
39: #include <sys/mbuf.h>
40: #include <sys/proc.h>
41: #include <sys/systm.h>
42:
43: #include <netbt/bluetooth.h>
44: #include <netbt/hci.h>
45: #include <netbt/l2cap.h>
46: #include <netbt/rfcomm.h>
47:
48: /*
49: * rfcomm_dlc_lookup(rfcomm_session, dlci)
50: *
51: * Find DLC on session with matching dlci
52: */
53: struct rfcomm_dlc *
54: rfcomm_dlc_lookup(struct rfcomm_session *rs, int dlci)
55: {
56: struct rfcomm_dlc *dlc;
57:
58: LIST_FOREACH(dlc, &rs->rs_dlcs, rd_next) {
59: if (dlc->rd_dlci == dlci)
60: break;
61: }
62:
63: return dlc;
64: }
65:
66: /*
67: * rfcomm_dlc_newconn(rfcomm_session, dlci)
68: *
69: * handle a new dlc request (since its called from a couple of places)
70: */
71: struct rfcomm_dlc *
72: rfcomm_dlc_newconn(struct rfcomm_session *rs, int dlci)
73: {
74: struct rfcomm_session *ls;
75: struct rfcomm_dlc *new, *dlc, *any, *best;
76: struct sockaddr_bt laddr, raddr, addr;
77: int chan;
78:
79: /*
80: * Search amongst the listening DLC community for the best match for
81: * address & channel. We keep listening DLC's hanging on listening
82: * sessions in a last first order, so scan the entire bunch and keep
83: * a note of the best address and BDADDR_ANY matches in order to find
84: * the oldest and most specific match.
85: */
86: l2cap_sockaddr(rs->rs_l2cap, &laddr);
87: l2cap_peeraddr(rs->rs_l2cap, &raddr);
88: chan = RFCOMM_CHANNEL(dlci);
89: new = NULL;
90:
91: any = best = NULL;
92: LIST_FOREACH(ls, &rfcomm_session_listen, rs_next) {
93: l2cap_sockaddr(ls->rs_l2cap, &addr);
94:
95: if (addr.bt_psm != laddr.bt_psm)
96: continue;
97:
98: if (bdaddr_same(&laddr.bt_bdaddr, &addr.bt_bdaddr)) {
99: LIST_FOREACH(dlc, &ls->rs_dlcs, rd_next) {
100: if (dlc->rd_laddr.bt_channel == chan)
101: best = dlc;
102: }
103: }
104:
105: if (bdaddr_any(&addr.bt_bdaddr)) {
106: LIST_FOREACH(dlc, &ls->rs_dlcs, rd_next) {
107: if (dlc->rd_laddr.bt_channel == chan)
108: any = dlc;
109: }
110: }
111: }
112:
113: dlc = best ? best : any;
114:
115: /* XXX
116: * Note that if this fails, we could have missed a chance to open
117: * a connection - really need to rewrite the strategy for storing
118: * listening DLC's so all can be checked in turn..
119: */
120: if (dlc != NULL)
121: new = (*dlc->rd_proto->newconn)(dlc->rd_upper, &laddr, &raddr);
122:
123: if (new == NULL) {
124: rfcomm_session_send_frame(rs, RFCOMM_FRAME_DM, dlci);
125: return NULL;
126: }
127:
128: new->rd_dlci = dlci;
129: new->rd_mtu = rfcomm_mtu_default;
130: new->rd_mode = dlc->rd_mode;
131:
132: memcpy(&new->rd_laddr, &laddr, sizeof(struct sockaddr_bt));
133: new->rd_laddr.bt_channel = chan;
134:
135: memcpy(&new->rd_raddr, &raddr, sizeof(struct sockaddr_bt));
136: new->rd_raddr.bt_channel = chan;
137:
138: new->rd_session = rs;
139: new->rd_state = RFCOMM_DLC_WAIT_CONNECT;
140: LIST_INSERT_HEAD(&rs->rs_dlcs, new, rd_next);
141:
142: return new;
143: }
144:
145: /*
146: * rfcomm_dlc_close(dlc, error)
147: *
148: * detach DLC from session and clean up
149: */
150: void
151: rfcomm_dlc_close(struct rfcomm_dlc *dlc, int err)
152: {
153: struct rfcomm_session *rs;
154: struct rfcomm_credit *credit;
155:
156: KASSERT(dlc->rd_state != RFCOMM_DLC_CLOSED);
157:
158: /* Clear credit history */
159: rs = dlc->rd_session;
160: SIMPLEQ_FOREACH(credit, &rs->rs_credits, rc_next)
161: if (credit->rc_dlc == dlc)
162: credit->rc_dlc = NULL;
163:
164: timeout_del(&dlc->rd_timeout);
165:
166: LIST_REMOVE(dlc, rd_next);
167: dlc->rd_session = NULL;
168: dlc->rd_state = RFCOMM_DLC_CLOSED;
169:
170: (*dlc->rd_proto->disconnected)(dlc->rd_upper, err);
171:
172: /*
173: * It is the responsibility of the party who sends the last
174: * DISC(dlci) to disconnect the session, but we will schedule
175: * an expiry just in case that doesnt happen..
176: */
177: if (LIST_EMPTY(&rs->rs_dlcs)) {
178: if (rs->rs_state == RFCOMM_SESSION_LISTEN)
179: rfcomm_session_free(rs);
180: else
181: timeout_add(&rs->rs_timeout,
182: rfcomm_ack_timeout * hz);
183: }
184: }
185:
186: /*
187: * rfcomm_dlc_timeout(dlc)
188: *
189: * DLC timeout function is schedUled when we sent any of SABM,
190: * DISC, MCC_MSC, or MCC_PN and should be cancelled when we get
191: * the relevant response. There is nothing to do but shut this
192: * DLC down.
193: */
194: void
195: rfcomm_dlc_timeout(void *arg)
196: {
197: struct rfcomm_dlc *dlc = arg;
198: int s;
199:
200: s = splsoftnet();
201:
202: if (dlc->rd_state != RFCOMM_DLC_CLOSED)
203: rfcomm_dlc_close(dlc, ETIMEDOUT);
204: else if (dlc->rd_flags & RFCOMM_DLC_DETACH)
205: free(dlc, M_BLUETOOTH);
206:
207: splx(s);
208: }
209:
210: /*
211: * rfcomm_dlc_setmode(rfcomm_dlc)
212: *
213: * Set link mode for DLC. This is only called when the session is
214: * already open, so we don't need to worry about any previous mode
215: * settings.
216: */
217: int
218: rfcomm_dlc_setmode(struct rfcomm_dlc *dlc)
219: {
220: int mode = 0;
221:
222: KASSERT(dlc->rd_session != NULL);
223: KASSERT(dlc->rd_session->rs_state == RFCOMM_SESSION_OPEN);
224:
225: DPRINTF("dlci %d, auth %s, encrypt %s, secure %s\n", dlc->rd_dlci,
226: (dlc->rd_mode & RFCOMM_LM_AUTH ? "yes" : "no"),
227: (dlc->rd_mode & RFCOMM_LM_ENCRYPT ? "yes" : "no"),
228: (dlc->rd_mode & RFCOMM_LM_SECURE ? "yes" : "no"));
229:
230: if (dlc->rd_mode & RFCOMM_LM_AUTH)
231: mode |= L2CAP_LM_AUTH;
232:
233: if (dlc->rd_mode & RFCOMM_LM_ENCRYPT)
234: mode |= L2CAP_LM_ENCRYPT;
235:
236: if (dlc->rd_mode & RFCOMM_LM_SECURE)
237: mode |= L2CAP_LM_SECURE;
238:
239: return l2cap_setopt(dlc->rd_session->rs_l2cap, SO_L2CAP_LM, &mode);
240: }
241:
242: /*
243: * rfcomm_dlc_connect(rfcomm_dlc)
244: *
245: * initiate DLC connection (session is already connected)
246: */
247: int
248: rfcomm_dlc_connect(struct rfcomm_dlc *dlc)
249: {
250: struct rfcomm_mcc_pn pn;
251: int err = 0;
252:
253: KASSERT(dlc->rd_session != NULL);
254: KASSERT(dlc->rd_session->rs_state == RFCOMM_SESSION_OPEN);
255: KASSERT(dlc->rd_state == RFCOMM_DLC_WAIT_SESSION);
256:
257: /*
258: * If we have not already sent a PN on the session, we must send
259: * a PN to negotiate Credit Flow Control, and this setting will
260: * apply to all future connections for this session. We ask for
261: * this every time, in order to establish initial credits.
262: */
263: memset(&pn, 0, sizeof(pn));
264: pn.dlci = dlc->rd_dlci;
265: pn.priority = dlc->rd_dlci | 0x07;
266: pn.mtu = htole16(dlc->rd_mtu);
267:
268: pn.flow_control = 0xf0;
269: dlc->rd_rxcred = (dlc->rd_rxsize / dlc->rd_mtu);
270: dlc->rd_rxcred = min(dlc->rd_rxcred, RFCOMM_CREDITS_DEFAULT);
271: pn.credits = dlc->rd_rxcred;
272:
273: err = rfcomm_session_send_mcc(dlc->rd_session, 1,
274: RFCOMM_MCC_PN, &pn, sizeof(pn));
275: if (err)
276: return err;
277:
278: dlc->rd_state = RFCOMM_DLC_WAIT_CONNECT;
279: timeout_add(&dlc->rd_timeout, rfcomm_mcc_timeout * hz);
280:
281: return 0;
282: }
283:
284: /*
285: * rfcomm_dlc_open(rfcomm_dlc)
286: *
287: * send "Modem Status Command" and mark DLC as open.
288: */
289: int
290: rfcomm_dlc_open(struct rfcomm_dlc *dlc)
291: {
292: struct rfcomm_mcc_msc msc;
293: int err;
294:
295: KASSERT(dlc->rd_session != NULL);
296: KASSERT(dlc->rd_session->rs_state == RFCOMM_SESSION_OPEN);
297:
298: memset(&msc, 0, sizeof(msc));
299: msc.address = RFCOMM_MKADDRESS(1, dlc->rd_dlci);
300: msc.modem = dlc->rd_lmodem & 0xfe; /* EA = 0 */
301: msc.brk = 0x00 | 0x01; /* EA = 1 */
302:
303: err = rfcomm_session_send_mcc(dlc->rd_session, 1,
304: RFCOMM_MCC_MSC, &msc, sizeof(msc));
305: if (err)
306: return err;
307:
308: timeout_add(&dlc->rd_timeout, rfcomm_mcc_timeout * hz);
309:
310: dlc->rd_state = RFCOMM_DLC_OPEN;
311: (*dlc->rd_proto->connected)(dlc->rd_upper);
312:
313: return 0;
314: }
315:
316: /*
317: * rfcomm_dlc_start(rfcomm_dlc)
318: *
319: * Start sending data (and/or credits) for DLC. Our strategy is to
320: * send anything we can down to the l2cap layer. When credits run
321: * out, data will naturally bunch up. When not using credit flow
322: * control, we limit the number of packets we have pending to reduce
323: * flow control lag.
324: * We should deal with channel priority somehow.
325: */
326: void
327: rfcomm_dlc_start(struct rfcomm_dlc *dlc)
328: {
329: struct rfcomm_session *rs = dlc->rd_session;
330: struct mbuf *m;
331: int len, credits;
332:
333: KASSERT(rs != NULL);
334: KASSERT(rs->rs_state == RFCOMM_SESSION_OPEN);
335: KASSERT(dlc->rd_state == RFCOMM_DLC_OPEN);
336:
337: for (;;) {
338: credits = 0;
339: len = dlc->rd_mtu;
340: if (rs->rs_flags & RFCOMM_SESSION_CFC) {
341: credits = (dlc->rd_rxsize / dlc->rd_mtu);
342: credits -= dlc->rd_rxcred;
343: credits = min(credits, RFCOMM_CREDITS_MAX);
344:
345: if (credits > 0)
346: len--;
347:
348: if (dlc->rd_txcred == 0)
349: len = 0;
350: } else {
351: if (rs->rs_flags & RFCOMM_SESSION_RFC)
352: break;
353:
354: if (dlc->rd_rmodem & RFCOMM_MSC_FC)
355: break;
356:
357: if (dlc->rd_pending > RFCOMM_CREDITS_DEFAULT)
358: break;
359: }
360:
361: if (dlc->rd_txbuf == NULL)
362: len = 0;
363:
364: if (len == 0) {
365: if (credits == 0)
366: break;
367:
368: /*
369: * No need to send small numbers of credits on their
370: * own unless the other end hasn't many left.
371: */
372: if (credits < RFCOMM_CREDITS_DEFAULT
373: && dlc->rd_rxcred > RFCOMM_CREDITS_DEFAULT)
374: break;
375:
376: m = NULL;
377: } else {
378: /*
379: * take what data we can from (front of) txbuf
380: */
381: m = dlc->rd_txbuf;
382: if (len < m->m_pkthdr.len) {
383: dlc->rd_txbuf = m_split(m, len, M_DONTWAIT);
384: if (dlc->rd_txbuf == NULL) {
385: dlc->rd_txbuf = m;
386: break;
387: }
388: } else {
389: dlc->rd_txbuf = NULL;
390: len = m->m_pkthdr.len;
391: }
392: }
393:
394: DPRINTFN(10, "dlci %d send %d bytes, %d credits, rxcred = %d\n",
395: dlc->rd_dlci, len, credits, dlc->rd_rxcred);
396:
397: if (rfcomm_session_send_uih(rs, dlc, credits, m)) {
398: printf("%s: lost %d bytes on DLCI %d\n",
399: __func__, len, dlc->rd_dlci);
400:
401: break;
402: }
403:
404: dlc->rd_pending++;
405:
406: if (rs->rs_flags & RFCOMM_SESSION_CFC) {
407: if (len > 0)
408: dlc->rd_txcred--;
409:
410: if (credits > 0)
411: dlc->rd_rxcred += credits;
412: }
413: }
414: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rfcomm_dlc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netbt