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