1 /******************************************************************************
2 *
3 * Copyright (C) 1999-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This file contains state machine and action routines for multiplexer
22 * channel of the RFCOMM unit
23 *
24 ******************************************************************************/
25 #include <string.h>
26 #include "stack/bt_types.h"
27 #include "stack/rfcdefs.h"
28 #include "stack/l2cdefs.h"
29 #include "stack/port_api.h"
30 #include "port_int.h"
31 #include "stack/l2c_api.h"
32 #include "rfc_int.h"
33 #include "common/bt_defs.h"
34 #include "osi/allocator.h"
35 #include "osi/mutex.h"
36 #include "common/bt_target.h"
37 #if (defined RFCOMM_INCLUDED && RFCOMM_INCLUDED == 1)
38
39 #define L2CAP_SUCCESS 0
40 #define L2CAP_ERROR 1
41
42
43 /********************************************************************************/
44 /* L O C A L F U N C T I O N P R O T O T Y P E S */
45 /********************************************************************************/
46 static void rfc_mx_sm_state_idle (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
47 static void rfc_mx_sm_state_wait_conn_cnf (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
48 static void rfc_mx_sm_state_configure (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
49 static void rfc_mx_sm_sabme_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
50 static void rfc_mx_sm_state_wait_sabme (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
51 static void rfc_mx_sm_state_connected (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
52 static void rfc_mx_sm_state_disc_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
53
54 static void rfc_mx_send_config_req (tRFC_MCB *p_mcb);
55 static void rfc_mx_conf_ind (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg);
56 static void rfc_mx_conf_cnf (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg);
57
58
59
60 /*******************************************************************************
61 **
62 ** Function rfc_mx_sm_execute
63 **
64 ** Description This function sends multiplexor events through the state
65 ** machine.
66 **
67 ** Returns void
68 **
69 *******************************************************************************/
rfc_mx_sm_execute(tRFC_MCB * p_mcb,UINT16 event,void * p_data)70 void rfc_mx_sm_execute (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
71 {
72 switch (p_mcb->state) {
73 case RFC_MX_STATE_IDLE:
74 rfc_mx_sm_state_idle (p_mcb, event, p_data);
75 break;
76
77 case RFC_MX_STATE_WAIT_CONN_CNF:
78 rfc_mx_sm_state_wait_conn_cnf (p_mcb, event, p_data);
79 break;
80
81 case RFC_MX_STATE_CONFIGURE:
82 rfc_mx_sm_state_configure (p_mcb, event, p_data);
83 break;
84
85 case RFC_MX_STATE_SABME_WAIT_UA:
86 rfc_mx_sm_sabme_wait_ua (p_mcb, event, p_data);
87 break;
88
89 case RFC_MX_STATE_WAIT_SABME:
90 rfc_mx_sm_state_wait_sabme (p_mcb, event, p_data);
91 break;
92
93 case RFC_MX_STATE_CONNECTED:
94 rfc_mx_sm_state_connected (p_mcb, event, p_data);
95 break;
96
97 case RFC_MX_STATE_DISC_WAIT_UA:
98 rfc_mx_sm_state_disc_wait_ua (p_mcb, event, p_data);
99 break;
100
101 }
102 }
103
104
105 /*******************************************************************************
106 **
107 ** Function rfc_mx_sm_state_idle
108 **
109 ** Description This function handles events when the multiplexer is in
110 ** IDLE state. This state exists when connection is being
111 ** initially established.
112 **
113 ** Returns void
114 **
115 *******************************************************************************/
rfc_mx_sm_state_idle(tRFC_MCB * p_mcb,UINT16 event,void * p_data)116 void rfc_mx_sm_state_idle (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
117 {
118 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_idle - evt:%d", event);
119 switch (event) {
120 case RFC_MX_EVENT_START_REQ:
121
122 /* Initialize L2CAP MTU */
123 p_mcb->peer_l2cap_mtu = L2CAP_DEFAULT_MTU - RFCOMM_MIN_OFFSET - 1;
124
125 if ((p_mcb->lcid = L2CA_ConnectReq (BT_PSM_RFCOMM, p_mcb->bd_addr)) == 0) {
126 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
127 return;
128 }
129 /* Save entry for quicker access to mcb based on the LCID */
130 rfc_save_lcid_mcb (p_mcb, p_mcb->lcid);
131
132 p_mcb->state = RFC_MX_STATE_WAIT_CONN_CNF;
133 return;
134
135 case RFC_MX_EVENT_START_RSP:
136 case RFC_MX_EVENT_CONN_CNF:
137 case RFC_MX_EVENT_CONF_IND:
138 case RFC_MX_EVENT_CONF_CNF:
139 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
140 return;
141
142 case RFC_MX_EVENT_CONN_IND:
143
144 rfc_timer_start (p_mcb, RFCOMM_CONN_TIMEOUT);
145 L2CA_ConnectRsp (p_mcb->bd_addr, *((UINT8 *)p_data), p_mcb->lcid, L2CAP_CONN_OK, 0);
146
147 rfc_mx_send_config_req (p_mcb);
148
149 p_mcb->state = RFC_MX_STATE_CONFIGURE;
150 return;
151
152 case RFC_EVENT_SABME:
153 break;
154
155 case RFC_EVENT_UA:
156 case RFC_EVENT_DM:
157 return;
158
159 case RFC_EVENT_DISC:
160 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, 1);
161 return;
162
163 case RFC_EVENT_UIH:
164 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, 0);
165 return;
166 }
167 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
168 }
169
170
171 /*******************************************************************************
172 **
173 ** Function rfc_mx_sm_state_wait_conn_cnf
174 **
175 ** Description This function handles events when the multiplexer is
176 ** waiting for Connection Confirm from L2CAP.
177 **
178 ** Returns void
179 **
180 *******************************************************************************/
rfc_mx_sm_state_wait_conn_cnf(tRFC_MCB * p_mcb,UINT16 event,void * p_data)181 void rfc_mx_sm_state_wait_conn_cnf (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
182 {
183 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_wait_conn_cnf - evt:%d", event);
184 switch (event) {
185 case RFC_MX_EVENT_START_REQ:
186 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
187 return;
188
189 /* There is some new timing so that Config Ind comes before security is completed
190 so we are still waiting fo the confirmation. */
191 case RFC_MX_EVENT_CONF_IND:
192 rfc_mx_conf_ind (p_mcb, (tL2CAP_CFG_INFO *)p_data);
193 return;
194
195 case RFC_MX_EVENT_CONN_CNF:
196 if (*((UINT16 *)p_data) != L2CAP_SUCCESS) {
197 p_mcb->state = RFC_MX_STATE_IDLE;
198
199 PORT_StartCnf (p_mcb, *((UINT16 *)p_data));
200 return;
201 }
202 p_mcb->state = RFC_MX_STATE_CONFIGURE;
203 rfc_mx_send_config_req (p_mcb);
204 return;
205
206 case RFC_MX_EVENT_DISC_IND:
207 p_mcb->state = RFC_MX_STATE_IDLE;
208 PORT_CloseInd (p_mcb);
209 return;
210
211 case RFC_EVENT_TIMEOUT:
212 p_mcb->state = RFC_MX_STATE_IDLE;
213 L2CA_DisconnectReq (p_mcb->lcid);
214
215 /* we gave up outgoing connection request then try peer's request */
216 if (p_mcb->pending_lcid) {
217 UINT16 i;
218 UINT8 idx;
219
220 RFCOMM_TRACE_DEBUG ("RFCOMM MX retry as acceptor in collision case - evt:%d in state:%d", event, p_mcb->state);
221
222 rfc_save_lcid_mcb (NULL, p_mcb->lcid);
223 p_mcb->lcid = p_mcb->pending_lcid;
224 rfc_save_lcid_mcb (p_mcb, p_mcb->lcid);
225
226 p_mcb->is_initiator = 0;
227
228 /* update direction bit */
229 for (i = 0; i < RFCOMM_MAX_DLCI; i += 2) {
230 if ((idx = p_mcb->port_inx[i]) != 0) {
231 p_mcb->port_inx[i] = 0;
232 p_mcb->port_inx[i + 1] = idx;
233 rfc_cb.port.port[idx - 1].dlci += 1;
234 RFCOMM_TRACE_DEBUG ("RFCOMM MX - DLCI:%d -> %d", i, rfc_cb.port.port[idx - 1].dlci);
235 }
236 }
237
238 rfc_mx_sm_execute (p_mcb, RFC_MX_EVENT_CONN_IND, &(p_mcb->pending_id));
239 } else {
240 PORT_CloseInd (p_mcb);
241 }
242 return;
243 }
244 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
245 }
246
247
248 /*******************************************************************************
249 **
250 ** Function rfc_mx_sm_state_configure
251 **
252 ** Description This function handles events when the multiplexer in the
253 ** configuration state.
254 **
255 ** Returns void
256 **
257 *******************************************************************************/
rfc_mx_sm_state_configure(tRFC_MCB * p_mcb,UINT16 event,void * p_data)258 void rfc_mx_sm_state_configure (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
259 {
260 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_configure - evt:%d", event);
261 switch (event) {
262 case RFC_MX_EVENT_START_REQ:
263 case RFC_MX_EVENT_CONN_CNF:
264
265 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
266 return;
267
268 case RFC_MX_EVENT_CONF_IND:
269 rfc_mx_conf_ind (p_mcb, (tL2CAP_CFG_INFO *)p_data);
270 return;
271
272 case RFC_MX_EVENT_CONF_CNF:
273 rfc_mx_conf_cnf (p_mcb, (tL2CAP_CFG_INFO *)p_data);
274 return;
275
276 case RFC_MX_EVENT_DISC_IND:
277 p_mcb->state = RFC_MX_STATE_IDLE;
278 PORT_CloseInd (p_mcb);
279 return;
280
281 case RFC_EVENT_TIMEOUT:
282 p_mcb->state = RFC_MX_STATE_IDLE;
283 L2CA_DisconnectReq (p_mcb->lcid);
284
285 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
286 return;
287 }
288 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
289 }
290
291
292 /*******************************************************************************
293 **
294 ** Function rfc_mx_sm_sabme_wait_ua
295 **
296 ** Description This function handles events when the multiplexer sent
297 ** SABME and is waiting for UA reply.
298 **
299 ** Returns void
300 **
301 *******************************************************************************/
rfc_mx_sm_sabme_wait_ua(tRFC_MCB * p_mcb,UINT16 event,void * p_data)302 void rfc_mx_sm_sabme_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
303 {
304 UNUSED(p_data);
305
306 RFCOMM_TRACE_EVENT ("rfc_mx_sm_sabme_wait_ua - evt:%d", event);
307 switch (event) {
308 case RFC_MX_EVENT_START_REQ:
309 case RFC_MX_EVENT_CONN_CNF:
310 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
311 return;
312
313 /* workaround: we don't support reconfig */
314 /* commented out until we support reconfig
315 case RFC_MX_EVENT_CONF_IND:
316 rfc_mx_conf_ind (p_mcb, (tL2CAP_CFG_INFO *)p_data);
317 return;
318
319 case RFC_MX_EVENT_CONF_CNF:
320 rfc_mx_conf_cnf (p_mcb, (tL2CAP_CFG_INFO *)p_data);
321 return;
322 */
323
324 case RFC_MX_EVENT_DISC_IND:
325 p_mcb->state = RFC_MX_STATE_IDLE;
326 PORT_CloseInd (p_mcb);
327 return;
328
329 case RFC_EVENT_UA:
330 rfc_timer_stop (p_mcb);
331
332 p_mcb->state = RFC_MX_STATE_CONNECTED;
333 p_mcb->peer_ready = 1;
334
335 PORT_StartCnf (p_mcb, RFCOMM_SUCCESS);
336 return;
337
338 case RFC_EVENT_DM:
339 rfc_timer_stop (p_mcb);
340 /* Case falls through */
341
342 case RFC_MX_EVENT_CONF_IND: /* workaround: we don't support reconfig */
343 case RFC_MX_EVENT_CONF_CNF: /* workaround: we don't support reconfig */
344 case RFC_EVENT_TIMEOUT:
345 p_mcb->state = RFC_MX_STATE_IDLE;
346 L2CA_DisconnectReq (p_mcb->lcid);
347
348 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
349 return;
350 }
351 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
352 }
353
354 /*******************************************************************************
355 **
356 ** Function rfc_mx_sm_state_wait_sabme
357 **
358 ** Description This function handles events when the multiplexer is
359 ** waiting for SABME on the acceptor side after configuration
360 **
361 ** Returns void
362 **
363 *******************************************************************************/
rfc_mx_sm_state_wait_sabme(tRFC_MCB * p_mcb,UINT16 event,void * p_data)364 void rfc_mx_sm_state_wait_sabme (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
365 {
366 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_wait_sabme - evt:%d", event);
367 switch (event) {
368 case RFC_MX_EVENT_DISC_IND:
369 p_mcb->state = RFC_MX_STATE_IDLE;
370 PORT_CloseInd (p_mcb);
371 return;
372
373 case RFC_EVENT_SABME:
374 /* if we gave up outgoing connection request */
375 if (p_mcb->pending_lcid) {
376 p_mcb->pending_lcid = 0;
377
378 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
379
380 rfc_timer_stop (p_mcb);
381 p_mcb->state = RFC_MX_STATE_CONNECTED;
382 p_mcb->peer_ready = 1;
383
384 /* MX channel collision has been resolved, continue to open ports */
385 PORT_StartCnf (p_mcb, RFCOMM_SUCCESS);
386 } else {
387 rfc_timer_stop (p_mcb);
388 PORT_StartInd (p_mcb);
389 }
390 return;
391
392 case RFC_MX_EVENT_START_RSP:
393 if (*((UINT16 *)p_data) != RFCOMM_SUCCESS) {
394 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, 1);
395 } else {
396 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
397
398 p_mcb->state = RFC_MX_STATE_CONNECTED;
399 p_mcb->peer_ready = 1;
400 }
401 return;
402
403 case RFC_MX_EVENT_CONF_IND: /* workaround: we don't support reconfig */
404 case RFC_MX_EVENT_CONF_CNF: /* workaround: we don't support reconfig */
405 case RFC_EVENT_TIMEOUT:
406 p_mcb->state = RFC_MX_STATE_IDLE;
407 L2CA_DisconnectReq (p_mcb->lcid);
408
409 PORT_CloseInd (p_mcb);
410 return;
411 }
412 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
413 }
414
415
416 /*******************************************************************************
417 **
418 ** Function rfc_mx_sm_state_connected
419 **
420 ** Description This function handles events when the multiplexer is
421 ** in the CONNECTED state
422 **
423 ** Returns void
424 **
425 *******************************************************************************/
rfc_mx_sm_state_connected(tRFC_MCB * p_mcb,UINT16 event,void * p_data)426 void rfc_mx_sm_state_connected (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
427 {
428 UNUSED(p_data);
429
430 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_connected - evt:%d", event);
431
432 switch (event) {
433 case RFC_EVENT_TIMEOUT:
434 case RFC_MX_EVENT_CLOSE_REQ:
435 rfc_timer_start (p_mcb, RFC_DISC_TIMEOUT);
436 p_mcb->state = RFC_MX_STATE_DISC_WAIT_UA;
437 rfc_send_disc (p_mcb, RFCOMM_MX_DLCI);
438 return;
439
440 case RFC_MX_EVENT_DISC_IND:
441 p_mcb->state = RFC_MX_STATE_IDLE;
442 PORT_CloseInd (p_mcb);
443 return;
444
445 case RFC_EVENT_DISC:
446 /* Reply with UA. If initiator bring down L2CAP connection */
447 /* If server wait for some time if client decide to reinitiate channel */
448 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
449 if (p_mcb->is_initiator) {
450 L2CA_DisconnectReq (p_mcb->lcid);
451 }
452 /* notify all ports that connection is gone */
453 PORT_CloseInd (p_mcb);
454 return;
455 }
456 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
457 }
458
459
460 /*******************************************************************************
461 **
462 ** Function rfc_mx_sm_state_disc_wait_ua
463 **
464 ** Description This function handles events when the multiplexer sent
465 ** DISC and is waiting for UA reply.
466 **
467 ** Returns void
468 **
469 *******************************************************************************/
rfc_mx_sm_state_disc_wait_ua(tRFC_MCB * p_mcb,UINT16 event,void * p_data)470 void rfc_mx_sm_state_disc_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
471 {
472 BT_HDR *p_buf;
473
474 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_disc_wait_ua - evt:%d", event);
475 switch (event) {
476 case RFC_EVENT_UA:
477 case RFC_EVENT_DM:
478 case RFC_EVENT_TIMEOUT:
479 L2CA_DisconnectReq (p_mcb->lcid);
480
481 if (p_mcb->restart_required) {
482 /* Start Request was received while disconnecting. Execute it again */
483 if ((p_mcb->lcid = L2CA_ConnectReq (BT_PSM_RFCOMM, p_mcb->bd_addr)) == 0) {
484 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
485 return;
486 }
487 /* Save entry for quicker access to mcb based on the LCID */
488 rfc_save_lcid_mcb (p_mcb, p_mcb->lcid);
489
490 /* clean up before reuse it */
491 while ((p_buf = (BT_HDR *)fixed_queue_dequeue(p_mcb->cmd_q, 0)) != NULL) {
492 osi_free(p_buf);
493 }
494
495 rfc_timer_start (p_mcb, RFC_MCB_INIT_INACT_TIMER);
496
497 p_mcb->is_initiator = 1;
498 p_mcb->restart_required = 0;
499 p_mcb->local_cfg_sent = 0;
500 p_mcb->peer_cfg_rcvd = 0;
501
502 p_mcb->state = RFC_MX_STATE_WAIT_CONN_CNF;
503 return;
504 }
505 rfc_release_multiplexer_channel (p_mcb);
506 return;
507
508 case RFC_EVENT_DISC:
509 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
510 return;
511
512 case RFC_EVENT_UIH:
513 osi_free (p_data);
514 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, 0);
515 return;
516
517 case RFC_MX_EVENT_START_REQ:
518 p_mcb->restart_required = 1;
519 return;
520
521 case RFC_MX_EVENT_DISC_IND:
522 p_mcb->state = RFC_MX_STATE_IDLE;
523 PORT_CloseInd (p_mcb);
524 return;
525
526 case RFC_MX_EVENT_CLOSE_REQ:
527 return;
528
529 case RFC_MX_EVENT_QOS_VIOLATION_IND:
530 break;
531 }
532 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
533 }
534
535
536 /*******************************************************************************
537 **
538 ** Function rfc_mx_send_config_req
539 **
540 ** Description This function handles L2CA_ConnectInd message from the
541 ** L2CAP. Accept connection.
542 **
543 *******************************************************************************/
rfc_mx_send_config_req(tRFC_MCB * p_mcb)544 static void rfc_mx_send_config_req (tRFC_MCB *p_mcb)
545 {
546 tL2CAP_CFG_INFO cfg;
547
548 RFCOMM_TRACE_EVENT ("rfc_mx_send_config_req");
549
550 memset (&cfg, 0, sizeof (tL2CAP_CFG_INFO));
551
552 cfg.mtu_present = 1;
553 cfg.mtu = L2CAP_MTU_SIZE;
554
555 /* Defaults set by memset
556 cfg.flush_to_present = 0;
557 cfg.qos_present = 0;
558 cfg.fcr_present = 0;
559 cfg.fcr.mode = L2CAP_FCR_BASIC_MODE;
560 cfg.fcs_present = 0;
561 cfg.fcs = N/A when fcs_present is 0;
562 */
563 L2CA_ConfigReq (p_mcb->lcid, &cfg);
564 }
565
566
567 /*******************************************************************************
568 **
569 ** Function rfc_mx_conf_cnf
570 **
571 ** Description This function handles L2CA_ConfigCnf message from the
572 ** L2CAP. If result is not success tell upper layer that
573 ** start has not been accepted. If initiator send SABME
574 ** on DLCI 0. T1 is still running.
575 **
576 *******************************************************************************/
rfc_mx_conf_cnf(tRFC_MCB * p_mcb,tL2CAP_CFG_INFO * p_cfg)577 static void rfc_mx_conf_cnf (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg)
578 {
579 // RFCOMM_TRACE_EVENT ("rfc_mx_conf_cnf p_cfg:%08x res:%d ", p_cfg, (p_cfg) ? p_cfg->result : 0);
580
581 if (p_cfg->result != L2CAP_CFG_OK) {
582 if (p_mcb->is_initiator) {
583 PORT_StartCnf (p_mcb, p_cfg->result);
584 L2CA_DisconnectReq (p_mcb->lcid);
585 }
586 rfc_release_multiplexer_channel (p_mcb);
587 return;
588 }
589
590 p_mcb->local_cfg_sent = 1;
591 if ((p_mcb->state == RFC_MX_STATE_CONFIGURE) && p_mcb->peer_cfg_rcvd) {
592 if (p_mcb->is_initiator) {
593 p_mcb->state = RFC_MX_STATE_SABME_WAIT_UA;
594 rfc_send_sabme (p_mcb, RFCOMM_MX_DLCI);
595 rfc_timer_start (p_mcb, RFC_T1_TIMEOUT);
596 } else {
597 p_mcb->state = RFC_MX_STATE_WAIT_SABME;
598 rfc_timer_start (p_mcb, RFCOMM_CONN_TIMEOUT); /* - increased from T2=20 to CONN=120
599 to allow the user more than 10 sec to type in the
600 pin which can be e.g. 16 digits */
601 }
602 }
603 }
604
605
606 /*******************************************************************************
607 **
608 ** Function rfc_mx_conf_ind
609 **
610 ** Description This function handles L2CA_ConfigInd message from the
611 ** L2CAP. Send the L2CA_ConfigRsp message.
612 **
613 *******************************************************************************/
rfc_mx_conf_ind(tRFC_MCB * p_mcb,tL2CAP_CFG_INFO * p_cfg)614 static void rfc_mx_conf_ind (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg)
615 {
616 /* Save peer L2CAP MTU if present */
617 /* RFCOMM adds 3-4 bytes in the beginning and 1 bytes FCS */
618 if (p_cfg->mtu_present) {
619 p_mcb->peer_l2cap_mtu = p_cfg->mtu - RFCOMM_MIN_OFFSET - 1;
620 } else {
621 p_mcb->peer_l2cap_mtu = L2CAP_DEFAULT_MTU - RFCOMM_MIN_OFFSET - 1;
622 }
623
624 p_cfg->mtu_present = 0;
625 p_cfg->flush_to_present = 0;
626 p_cfg->qos_present = 0;
627
628 p_cfg->result = L2CAP_CFG_OK;
629
630 L2CA_ConfigRsp (p_mcb->lcid, p_cfg);
631
632 p_mcb->peer_cfg_rcvd = 1;
633 if ((p_mcb->state == RFC_MX_STATE_CONFIGURE) && p_mcb->local_cfg_sent) {
634 if (p_mcb->is_initiator) {
635 p_mcb->state = RFC_MX_STATE_SABME_WAIT_UA;
636 rfc_send_sabme (p_mcb, RFCOMM_MX_DLCI);
637 rfc_timer_start (p_mcb, RFC_T1_TIMEOUT);
638 } else {
639 p_mcb->state = RFC_MX_STATE_WAIT_SABME;
640 rfc_timer_start (p_mcb, RFCOMM_CONN_TIMEOUT); /* - increased from T2=20 to CONN=120
641 to allow the user more than 10 sec to type in the
642 pin which can be e.g. 16 digits */
643 }
644 }
645 }
646
647 #endif ///(defined RFCOMM_INCLUDED && RFCOMM_INCLUDED == 1)
648