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