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 the L2CAP UCD code 22 * 23 ******************************************************************************/ 24 25 #include <stdlib.h> 26 #include <string.h> 27 #include <stdio.h> 28 29 #include "gki.h" 30 #include "bt_types.h" 31 #include "hcidefs.h" 32 #include "hcimsgs.h" 33 #include "l2cdefs.h" 34 #include "l2c_int.h" 35 #include "btu.h" 36 #include "btm_api.h" 37 #include "btm_int.h" 38 39 #if (L2CAP_UCD_INCLUDED == TRUE) 40 static BOOLEAN l2c_ucd_connect ( BD_ADDR rem_bda ); 41 42 /******************************************************************************* 43 ** 44 ** Function l2c_ucd_discover_cback 45 ** 46 ** Description UCD Discover callback 47 ** 48 ** Returns void 49 ** 50 *******************************************************************************/ 51 static void l2c_ucd_discover_cback (BD_ADDR rem_bda, UINT8 info_type, UINT32 data) 52 { 53 tL2C_RCB *p_rcb = &l2cb.rcb_pool[0]; 54 UINT16 xx; 55 56 L2CAP_TRACE_DEBUG0 ("L2CAP - l2c_ucd_discover_cback"); 57 58 for (xx = 0; xx < MAX_L2CAP_CLIENTS; xx++, p_rcb++) 59 { 60 if (p_rcb->in_use) 61 { 62 /* if this application is waiting UCD reception info */ 63 if (( info_type == L2CAP_UCD_INFO_TYPE_RECEPTION ) 64 && ( p_rcb->ucd.state & L2C_UCD_STATE_W4_RECEPTION )) 65 { 66 p_rcb->ucd.cb_info.pL2CA_UCD_Discover_Cb (rem_bda, info_type, data); 67 p_rcb->ucd.state &= ~(L2C_UCD_STATE_W4_RECEPTION); 68 } 69 70 /* if this application is waiting UCD MTU info */ 71 if (( info_type == L2CAP_UCD_INFO_TYPE_MTU ) 72 && ( p_rcb->ucd.state & L2C_UCD_STATE_W4_MTU )) 73 { 74 p_rcb->ucd.cb_info.pL2CA_UCD_Discover_Cb (rem_bda, info_type, data); 75 p_rcb->ucd.state &= ~(L2C_UCD_STATE_W4_MTU); 76 } 77 } 78 } 79 } 80 81 /******************************************************************************* 82 ** 83 ** Function l2c_ucd_data_ind_cback 84 ** 85 ** Description UCD Data callback 86 ** 87 ** Returns void 88 ** 89 *******************************************************************************/ 90 static void l2c_ucd_data_ind_cback (BD_ADDR rem_bda, BT_HDR *p_buf) 91 { 92 UINT8 *p; 93 UINT16 psm; 94 tL2C_RCB *p_rcb; 95 96 L2CAP_TRACE_DEBUG0 ("L2CAP - l2c_ucd_data_ind_cback"); 97 98 p = (UINT8 *)(p_buf + 1) + p_buf->offset; 99 STREAM_TO_UINT16(psm, p) 100 101 p_buf->offset += L2CAP_UCD_OVERHEAD; 102 p_buf->len -= L2CAP_UCD_OVERHEAD; 103 104 if ((p_rcb = l2cu_find_rcb_by_psm (psm)) == NULL) 105 { 106 L2CAP_TRACE_ERROR1 ("L2CAP - no RCB for l2c_ucd_data_ind_cback, PSM: 0x%04x", psm); 107 GKI_freebuf (p_buf); 108 } 109 else 110 { 111 p_rcb->ucd.cb_info.pL2CA_UCD_Data_Cb(rem_bda, p_buf); 112 } 113 } 114 115 /******************************************************************************* 116 ** 117 ** Function l2c_ucd_congestion_status_cback 118 ** 119 ** Description UCD Congestion Status callback 120 ** 121 ** Returns void 122 ** 123 *******************************************************************************/ 124 static void l2c_ucd_congestion_status_cback (BD_ADDR rem_bda, BOOLEAN is_congested) 125 { 126 tL2C_RCB *p_rcb = &l2cb.rcb_pool[0]; 127 UINT16 xx; 128 129 L2CAP_TRACE_DEBUG0 ("L2CAP - l2c_ucd_congestion_status_cback"); 130 131 for (xx = 0; xx < MAX_L2CAP_CLIENTS; xx++, p_rcb++) 132 { 133 if (( p_rcb->in_use ) 134 &&( p_rcb->ucd.state != L2C_UCD_STATE_UNUSED )) 135 { 136 if ( p_rcb->ucd.cb_info.pL2CA_UCD_Congestion_Status_Cb ) 137 { 138 L2CAP_TRACE_DEBUG4 ("L2CAP - Calling UCDCongestionStatus_Cb (%d), PSM=0x%04x, BDA: %08x%04x,", 139 is_congested, p_rcb->psm, 140 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], 141 (rem_bda[4]<<8)+rem_bda[5]); 142 143 p_rcb->ucd.cb_info.pL2CA_UCD_Congestion_Status_Cb ( rem_bda, is_congested ); 144 } 145 } 146 } 147 } 148 149 /******************************************************************************* 150 ** 151 ** Function l2c_ucd_disconnect_ind_cback 152 ** 153 ** Description UCD disconnect callback (This prevent to access null pointer) 154 ** 155 ** Returns void 156 ** 157 *******************************************************************************/ 158 static void l2c_ucd_disconnect_ind_cback (UINT16 cid, BOOLEAN result) 159 { 160 /* do nothing */ 161 } 162 163 /******************************************************************************* 164 ** 165 ** Function l2c_ucd_config_ind_cback 166 ** 167 ** Description UCD config callback (This prevent to access null pointer) 168 ** 169 ** Returns void 170 ** 171 *******************************************************************************/ 172 static void l2c_ucd_config_ind_cback (UINT16 cid, tL2CAP_CFG_INFO *p_cfg) 173 { 174 /* do nothing */ 175 } 176 177 /******************************************************************************* 178 ** 179 ** Function l2c_ucd_config_cfm_cback 180 ** 181 ** Description UCD config callback (This prevent to access null pointer) 182 ** 183 ** Returns void 184 ** 185 *******************************************************************************/ 186 static void l2c_ucd_config_cfm_cback (UINT16 cid, tL2CAP_CFG_INFO *p_cfg) 187 { 188 /* do nothing */ 189 } 190 191 /******************************************************************************* 192 ** 193 ** Function L2CA_UcdRegister 194 ** 195 ** Description Register PSM on UCD. 196 ** 197 ** Parameters: tL2CAP_UCD_CB_INFO 198 ** 199 ** Return value: TRUE if successs 200 ** 201 *******************************************************************************/ 202 BOOLEAN L2CA_UcdRegister ( UINT16 psm, tL2CAP_UCD_CB_INFO *p_cb_info ) 203 { 204 tL2C_RCB *p_rcb; 205 206 L2CAP_TRACE_API1 ("L2CA_UcdRegister() PSM: 0x%04x", psm); 207 208 if ((!p_cb_info->pL2CA_UCD_Discover_Cb) 209 || (!p_cb_info->pL2CA_UCD_Data_Cb)) 210 { 211 L2CAP_TRACE_ERROR1 ("L2CAP - no callback registering PSM(0x%04x) on UCD", psm); 212 return (FALSE); 213 } 214 215 if ((p_rcb = l2cu_find_rcb_by_psm (psm)) == NULL) 216 { 217 L2CAP_TRACE_ERROR1 ("L2CAP - no RCB for L2CA_UcdRegister, PSM: 0x%04x", psm); 218 return (FALSE); 219 } 220 221 p_rcb->ucd.state = L2C_UCD_STATE_W4_DATA; 222 p_rcb->ucd.cb_info = *p_cb_info; 223 224 /* check if master rcb is created for UCD */ 225 if ((p_rcb = l2cu_find_rcb_by_psm (L2C_UCD_RCB_ID)) == NULL) 226 { 227 if ((p_rcb = l2cu_allocate_rcb (L2C_UCD_RCB_ID)) == NULL) 228 { 229 L2CAP_TRACE_ERROR0 ("L2CAP - no RCB available for L2CA_UcdRegister"); 230 return (FALSE); 231 } 232 else 233 { 234 /* these callback functions will forward data to each UCD application */ 235 p_rcb->ucd.cb_info.pL2CA_UCD_Discover_Cb = l2c_ucd_discover_cback; 236 p_rcb->ucd.cb_info.pL2CA_UCD_Data_Cb = l2c_ucd_data_ind_cback; 237 p_rcb->ucd.cb_info.pL2CA_UCD_Congestion_Status_Cb = l2c_ucd_congestion_status_cback; 238 239 memset (&p_rcb->api, 0, sizeof(tL2CAP_APPL_INFO)); 240 p_rcb->api.pL2CA_DisconnectInd_Cb = l2c_ucd_disconnect_ind_cback; 241 242 /* This will make L2CAP check UCD congestion callback */ 243 p_rcb->api.pL2CA_CongestionStatus_Cb = NULL; 244 245 /* do nothing but prevent crash */ 246 p_rcb->api.pL2CA_ConfigInd_Cb = l2c_ucd_config_ind_cback; 247 p_rcb->api.pL2CA_ConfigCfm_Cb = l2c_ucd_config_cfm_cback; 248 } 249 } 250 251 return (TRUE); 252 } 253 254 /******************************************************************************* 255 ** 256 ** Function L2CA_UcdDeregister 257 ** 258 ** Description Deregister PSM on UCD. 259 ** 260 ** Parameters: PSM 261 ** 262 ** Return value: TRUE if successs 263 ** 264 *******************************************************************************/ 265 BOOLEAN L2CA_UcdDeregister ( UINT16 psm ) 266 { 267 tL2C_CCB *p_ccb; 268 tL2C_RCB *p_rcb; 269 UINT16 xx; 270 271 L2CAP_TRACE_API1 ("L2CA_UcdDeregister() PSM: 0x%04x", psm); 272 273 if ((p_rcb = l2cu_find_rcb_by_psm (psm)) == NULL) 274 { 275 L2CAP_TRACE_ERROR1 ("L2CAP - no RCB for L2CA_UcdDeregister, PSM: 0x%04x", psm); 276 return (FALSE); 277 } 278 279 p_rcb->ucd.state = L2C_UCD_STATE_UNUSED; 280 281 /* check this was the last UCD registration */ 282 p_rcb = &l2cb.rcb_pool[0]; 283 284 for (xx = 0; xx < MAX_L2CAP_CLIENTS; xx++, p_rcb++) 285 { 286 if ((p_rcb->in_use) && (p_rcb->ucd.state != L2C_UCD_STATE_UNUSED)) 287 return (TRUE); 288 } 289 290 /* delete master rcb for UCD */ 291 if ((p_rcb = l2cu_find_rcb_by_psm (L2C_UCD_RCB_ID)) != NULL) 292 { 293 l2cu_release_rcb (p_rcb); 294 } 295 296 /* delete CCB for UCD */ 297 p_ccb = l2cb.ccb_pool; 298 for ( xx = 0; xx < MAX_L2CAP_CHANNELS; xx++ ) 299 { 300 if (( p_ccb->in_use ) 301 &&( p_ccb->local_cid == L2CAP_CONNECTIONLESS_CID )) 302 { 303 l2cu_release_ccb (p_ccb); 304 } 305 p_ccb++; 306 } 307 308 return (TRUE); 309 } 310 311 /******************************************************************************* 312 ** 313 ** Function L2CA_UcdDiscover 314 ** 315 ** Description Discover UCD of remote device. 316 ** 317 ** Parameters: PSM 318 ** BD_ADDR of remote device 319 ** info_type : L2CAP_UCD_INFO_TYPE_RECEPTION 320 ** L2CAP_UCD_INFO_TYPE_MTU 321 ** 322 ** 323 ** Return value: TRUE if successs 324 ** 325 *******************************************************************************/ 326 BOOLEAN L2CA_UcdDiscover ( UINT16 psm, BD_ADDR rem_bda, UINT8 info_type ) 327 { 328 tL2C_LCB *p_lcb; 329 tL2C_CCB *p_ccb; 330 tL2C_RCB *p_rcb; 331 332 L2CAP_TRACE_API4 ("L2CA_UcdDiscover() PSM: 0x%04x BDA: %08x%04x, InfoType=0x%02x", psm, 333 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], 334 (rem_bda[4]<<8)+rem_bda[5], info_type); 335 336 /* Fail if the PSM is not registered */ 337 if (((p_rcb = l2cu_find_rcb_by_psm (psm)) == NULL) 338 ||( p_rcb->ucd.state == L2C_UCD_STATE_UNUSED )) 339 { 340 L2CAP_TRACE_WARNING1 ("L2CAP - no RCB for L2CA_UcdDiscover, PSM: 0x%04x", psm); 341 return (FALSE); 342 } 343 344 /* First, see if we already have a link to the remote */ 345 /* then find the channel control block for UCD. */ 346 if (((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda)) == NULL) 347 ||((p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID)) == NULL)) 348 { 349 if ( l2c_ucd_connect (rem_bda) == FALSE ) 350 { 351 return (FALSE); 352 } 353 } 354 355 /* set waiting flags in rcb */ 356 357 if ( info_type & L2CAP_UCD_INFO_TYPE_RECEPTION ) 358 p_rcb->ucd.state |= L2C_UCD_STATE_W4_RECEPTION; 359 360 if ( info_type & L2CAP_UCD_INFO_TYPE_MTU ) 361 p_rcb->ucd.state |= L2C_UCD_STATE_W4_MTU; 362 363 /* if link is already established */ 364 if ((p_lcb)&&(p_lcb->link_state == LST_CONNECTED)) 365 { 366 if (!p_ccb) 367 { 368 p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID); 369 } 370 l2c_ucd_check_pending_info_req(p_ccb); 371 } 372 return (TRUE); 373 } 374 375 /******************************************************************************* 376 ** 377 ** Function L2CA_UcdDataWrite 378 ** 379 ** Description Send UCD to remote device 380 ** 381 ** Parameters: PSM 382 ** BD Address of remote 383 ** Pointer to buffer of type BT_HDR 384 ** flags : L2CAP_FLUSHABLE_CH_BASED 385 ** L2CAP_FLUSHABLE_PKT 386 ** L2CAP_NON_FLUSHABLE_PKT 387 ** 388 ** Return value L2CAP_DW_SUCCESS, if data accepted 389 ** L2CAP_DW_FAILED, if error 390 ** 391 *******************************************************************************/ 392 UINT16 L2CA_UcdDataWrite (UINT16 psm, BD_ADDR rem_bda, BT_HDR *p_buf, UINT16 flags) 393 { 394 tL2C_LCB *p_lcb; 395 tL2C_CCB *p_ccb; 396 tL2C_RCB *p_rcb; 397 UINT8 *p; 398 399 L2CAP_TRACE_API3 ("L2CA_UcdDataWrite() PSM: 0x%04x BDA: %08x%04x", psm, 400 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], 401 (rem_bda[4]<<8)+rem_bda[5]); 402 403 /* Fail if the PSM is not registered */ 404 if (((p_rcb = l2cu_find_rcb_by_psm (psm)) == NULL) 405 ||( p_rcb->ucd.state == L2C_UCD_STATE_UNUSED )) 406 { 407 L2CAP_TRACE_WARNING1 ("L2CAP - no RCB for L2CA_UcdDataWrite, PSM: 0x%04x", psm); 408 GKI_freebuf (p_buf); 409 return (L2CAP_DW_FAILED); 410 } 411 412 /* First, see if we already have a link to the remote */ 413 /* then find the channel control block for UCD */ 414 if (((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda)) == NULL) 415 ||((p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID)) == NULL)) 416 { 417 if ( l2c_ucd_connect (rem_bda) == FALSE ) 418 { 419 GKI_freebuf (p_buf); 420 return (L2CAP_DW_FAILED); 421 } 422 423 /* If we still don't have lcb and ccb after connect attempt, then can't proceed */ 424 if (((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda)) == NULL) 425 || ((p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID)) == NULL)) 426 { 427 GKI_freebuf (p_buf); 428 return (L2CAP_DW_FAILED); 429 } 430 } 431 432 /* write PSM */ 433 p_buf->offset -= L2CAP_UCD_OVERHEAD; 434 p_buf->len += L2CAP_UCD_OVERHEAD; 435 p = (UINT8 *)(p_buf + 1) + p_buf->offset; 436 437 UINT16_TO_STREAM (p, psm); 438 439 /* UCD MTU check */ 440 if ((p_lcb->ucd_mtu) && (p_buf->len > p_lcb->ucd_mtu)) 441 { 442 L2CAP_TRACE_WARNING1 ("L2CAP - Handle: 0x%04x UCD bigger than peer's UCD mtu size cannot be sent", p_lcb->handle); 443 GKI_freebuf (p_buf); 444 return (L2CAP_DW_FAILED); 445 } 446 447 /* If already congested, do not accept any more packets */ 448 if (p_ccb->cong_sent) 449 { 450 L2CAP_TRACE_ERROR3 ("L2CAP - Handle: 0x%04x UCD cannot be sent, already congested count: %u buff_quota: %u", 451 p_lcb->handle, 452 (p_ccb->xmit_hold_q.count + p_lcb->ucd_out_sec_pending_q.count), 453 p_ccb->buff_quota); 454 455 GKI_freebuf (p_buf); 456 return (L2CAP_DW_FAILED); 457 } 458 459 /* channel based, packet based flushable or non-flushable */ 460 p_buf->layer_specific = flags; 461 462 l2c_csm_execute (p_ccb, L2CEVT_L2CA_DATA_WRITE, p_buf); 463 464 if (p_ccb->cong_sent) 465 return (L2CAP_DW_CONGESTED); 466 else 467 return (L2CAP_DW_SUCCESS); 468 } 469 470 /******************************************************************************* 471 ** 472 ** Function L2CA_UcdSetIdleTimeout 473 ** 474 ** Description Set UCD Idle timeout. 475 ** 476 ** Parameters: BD Addr 477 ** Timeout in second 478 ** 479 ** Return value: TRUE if successs 480 ** 481 *******************************************************************************/ 482 BOOLEAN L2CA_UcdSetIdleTimeout ( BD_ADDR rem_bda, UINT16 timeout ) 483 { 484 tL2C_LCB *p_lcb; 485 tL2C_CCB *p_ccb; 486 487 L2CAP_TRACE_API3 ("L2CA_UcdSetIdleTimeout() Timeout: 0x%04x BDA: %08x%04x", timeout, 488 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], 489 (rem_bda[4]<<8)+rem_bda[5]); 490 491 /* First, see if we already have a link to the remote */ 492 /* then find the channel control block. */ 493 if (((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda)) == NULL) 494 ||((p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID)) == NULL)) 495 { 496 L2CAP_TRACE_WARNING0 ("L2CAP - no UCD channel"); 497 return (FALSE); 498 } 499 else 500 { 501 p_ccb->fixed_chnl_idle_tout = timeout; 502 return (TRUE); 503 } 504 } 505 506 /******************************************************************************* 507 ** 508 ** Function L2CA_UCDSetTxPriority 509 ** 510 ** Description Sets the transmission priority for a connectionless channel. 511 ** 512 ** Returns TRUE if a valid channel, else FALSE 513 ** 514 *******************************************************************************/ 515 BOOLEAN L2CA_UCDSetTxPriority ( BD_ADDR rem_bda, tL2CAP_CHNL_PRIORITY priority ) 516 { 517 tL2C_LCB *p_lcb; 518 tL2C_CCB *p_ccb; 519 520 L2CAP_TRACE_API3 ("L2CA_UCDSetTxPriority() priority: 0x%02x BDA: %08x%04x", priority, 521 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], 522 (rem_bda[4]<<8)+rem_bda[5]); 523 524 if ((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda)) == NULL) 525 { 526 L2CAP_TRACE_WARNING0 ("L2CAP - no LCB for L2CA_UCDSetTxPriority"); 527 return (FALSE); 528 } 529 530 /* Find the channel control block */ 531 if ((p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID)) == NULL) 532 { 533 L2CAP_TRACE_WARNING0 ("L2CAP - no CCB for L2CA_UCDSetTxPriority"); 534 return (FALSE); 535 } 536 537 /* it will update the order of CCB in LCB by priority and update round robin service variables */ 538 l2cu_change_pri_ccb (p_ccb, priority); 539 540 return (TRUE); 541 } 542 543 /******************************************************************************* 544 ** 545 ** Function l2c_ucd_connect 546 ** 547 ** Description Connect UCD to remote device. 548 ** 549 ** Parameters: BD_ADDR of remote device 550 ** 551 ** Return value: TRUE if successs 552 ** 553 *******************************************************************************/ 554 static BOOLEAN l2c_ucd_connect ( BD_ADDR rem_bda ) 555 { 556 tL2C_LCB *p_lcb; 557 tL2C_CCB *p_ccb; 558 tL2C_RCB *p_rcb; 559 560 L2CAP_TRACE_DEBUG2 ("l2c_ucd_connect() BDA: %08x%04x", 561 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], 562 (rem_bda[4]<<8)+rem_bda[5]); 563 564 /* Fail if we have not established communications with the controller */ 565 if (!BTM_IsDeviceUp()) 566 { 567 L2CAP_TRACE_WARNING0 ("l2c_ucd_connect - BTU not ready"); 568 return (FALSE); 569 } 570 571 /* First, see if we already have a link to the remote */ 572 if ((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda)) == NULL) 573 { 574 /* No link. Get an LCB and start link establishment */ 575 if ( ((p_lcb = l2cu_allocate_lcb (rem_bda, FALSE)) == NULL) 576 || (l2cu_create_conn(p_lcb) == FALSE) ) 577 { 578 L2CAP_TRACE_WARNING0 ("L2CAP - conn not started l2c_ucd_connect"); 579 return (FALSE); 580 } 581 } 582 else if ( p_lcb->info_rx_bits & (1 << L2CAP_EXTENDED_FEATURES_INFO_TYPE) ) 583 { 584 if (!(p_lcb->peer_ext_fea & L2CAP_EXTFEA_UCD_RECEPTION)) 585 { 586 L2CAP_TRACE_WARNING0 ("L2CAP - UCD is not supported by peer, l2c_ucd_connect"); 587 return (FALSE); 588 } 589 } 590 591 /* Find the channel control block. */ 592 if ((p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID)) == NULL) 593 { 594 /* Allocate a channel control block */ 595 if ((p_ccb = l2cu_allocate_ccb (p_lcb, 0)) == NULL) 596 { 597 L2CAP_TRACE_WARNING0 ("L2CAP - no CCB for l2c_ucd_connect"); 598 return (FALSE); 599 } 600 else 601 { 602 /* Set CID for the connection */ 603 p_ccb->local_cid = L2CAP_CONNECTIONLESS_CID; 604 p_ccb->remote_cid = L2CAP_CONNECTIONLESS_CID; 605 606 /* Set the default idle timeout value to use */ 607 p_ccb->fixed_chnl_idle_tout = L2CAP_UCD_IDLE_TIMEOUT; 608 609 /* Set the default channel priority value to use */ 610 l2cu_change_pri_ccb (p_ccb, L2CAP_UCD_CH_PRIORITY); 611 612 if ((p_rcb = l2cu_find_rcb_by_psm (L2C_UCD_RCB_ID)) == NULL) 613 { 614 L2CAP_TRACE_WARNING0 ("L2CAP - no UCD registered, l2c_ucd_connect"); 615 return (FALSE); 616 } 617 /* Save UCD registration info */ 618 p_ccb->p_rcb = p_rcb; 619 620 /* There is no configuration, so if the link is up, the channel is up */ 621 if (p_lcb->link_state == LST_CONNECTED) 622 { 623 p_ccb->chnl_state = CST_OPEN; 624 } 625 } 626 } 627 628 return (TRUE); 629 } 630 631 /******************************************************************************* 632 ** 633 ** Function l2c_ucd_delete_sec_pending_q 634 ** 635 ** Description discard all of UCD packets in security pending queue 636 ** 637 ** Returns None 638 ** 639 *******************************************************************************/ 640 void l2c_ucd_delete_sec_pending_q(tL2C_LCB *p_lcb) 641 { 642 /* clean up any security pending UCD */ 643 while (p_lcb->ucd_out_sec_pending_q.p_first) 644 GKI_freebuf (GKI_dequeue (&p_lcb->ucd_out_sec_pending_q)); 645 646 while (p_lcb->ucd_in_sec_pending_q.p_first) 647 GKI_freebuf (GKI_dequeue (&p_lcb->ucd_in_sec_pending_q)); 648 } 649 650 /******************************************************************************* 651 ** 652 ** Function l2c_ucd_check_pending_info_req 653 ** 654 ** Description check if any application is waiting for UCD information 655 ** 656 ** Return TRUE if any pending UCD info request 657 ** 658 *******************************************************************************/ 659 BOOLEAN l2c_ucd_check_pending_info_req(tL2C_CCB *p_ccb) 660 { 661 tL2C_RCB *p_rcb = &l2cb.rcb_pool[0]; 662 UINT16 xx; 663 BOOLEAN pending = FALSE; 664 665 if (p_ccb == NULL) 666 { 667 L2CAP_TRACE_ERROR0 ("L2CAP - NULL p_ccb in l2c_ucd_check_pending_info_req"); 668 return (FALSE); 669 } 670 671 for (xx = 0; xx < MAX_L2CAP_CLIENTS; xx++, p_rcb++) 672 { 673 if (p_rcb->in_use) 674 { 675 /* if application is waiting UCD reception info */ 676 if (p_rcb->ucd.state & L2C_UCD_STATE_W4_RECEPTION) 677 { 678 /* if this information is available */ 679 if ( p_ccb->p_lcb->info_rx_bits & (1 << L2CAP_EXTENDED_FEATURES_INFO_TYPE) ) 680 { 681 if (!(p_ccb->p_lcb->peer_ext_fea & L2CAP_EXTFEA_UCD_RECEPTION)) 682 { 683 L2CAP_TRACE_WARNING0 ("L2CAP - UCD is not supported by peer, l2c_ucd_check_pending_info_req"); 684 685 l2c_ucd_delete_sec_pending_q(p_ccb->p_lcb); 686 l2cu_release_ccb (p_ccb); 687 } 688 689 p_ccb->p_rcb->ucd.cb_info.pL2CA_UCD_Discover_Cb (p_ccb->p_lcb->remote_bd_addr, 690 L2CAP_UCD_INFO_TYPE_RECEPTION, 691 p_ccb->p_lcb->peer_ext_fea & L2CAP_EXTFEA_UCD_RECEPTION); 692 } 693 else 694 { 695 pending = TRUE; 696 if (p_ccb->p_lcb->w4_info_rsp == FALSE) 697 { 698 l2cu_send_peer_info_req (p_ccb->p_lcb, L2CAP_EXTENDED_FEATURES_INFO_TYPE); 699 } 700 } 701 } 702 703 /* if application is waiting for UCD MTU */ 704 if (p_rcb->ucd.state & L2C_UCD_STATE_W4_MTU) 705 { 706 /* if this information is available */ 707 if ( p_ccb->p_lcb->info_rx_bits & (1 << L2CAP_CONNLESS_MTU_INFO_TYPE)) 708 { 709 p_ccb->p_rcb->ucd.cb_info.pL2CA_UCD_Discover_Cb (p_ccb->p_lcb->remote_bd_addr, 710 L2CAP_UCD_INFO_TYPE_MTU, 711 p_ccb->p_lcb->ucd_mtu); 712 } 713 else 714 { 715 pending = TRUE; 716 if (p_ccb->p_lcb->w4_info_rsp == FALSE) 717 { 718 l2cu_send_peer_info_req (p_ccb->p_lcb, L2CAP_CONNLESS_MTU_INFO_TYPE); 719 } 720 } 721 } 722 } 723 } 724 return (pending); 725 } 726 727 /******************************************************************************* 728 ** 729 ** Function l2c_ucd_enqueue_pending_out_sec_q 730 ** 731 ** Description enqueue outgoing UCD packet into security pending queue 732 ** and check congestion 733 ** 734 ** Return None 735 ** 736 *******************************************************************************/ 737 void l2c_ucd_enqueue_pending_out_sec_q(tL2C_CCB *p_ccb, void *p_data) 738 { 739 GKI_enqueue (&p_ccb->p_lcb->ucd_out_sec_pending_q, p_data); 740 l2cu_check_channel_congestion (p_ccb); 741 } 742 743 /******************************************************************************* 744 ** 745 ** Function l2c_ucd_check_pending_out_sec_q 746 ** 747 ** Description check outgoing security 748 ** 749 ** Return TRUE if any UCD packet for security 750 ** 751 *******************************************************************************/ 752 BOOLEAN l2c_ucd_check_pending_out_sec_q(tL2C_CCB *p_ccb) 753 { 754 UINT8 *p; 755 UINT16 psm; 756 BT_HDR *p_buf; 757 758 if ( p_ccb->p_lcb->ucd_out_sec_pending_q.count ) 759 { 760 p_buf = (BT_HDR*)(p_ccb->p_lcb->ucd_out_sec_pending_q.p_first); 761 p = (UINT8 *)(p_buf + 1) + p_buf->offset; 762 STREAM_TO_UINT16(psm, p) 763 764 p_ccb->chnl_state = CST_ORIG_W4_SEC_COMP; 765 btm_sec_l2cap_access_req (p_ccb->p_lcb->remote_bd_addr, psm, 766 p_ccb->p_lcb->handle, CONNLESS_ORIG, &l2c_link_sec_comp, p_ccb); 767 768 return (TRUE); 769 } 770 return (FALSE); 771 } 772 773 /******************************************************************************* 774 ** 775 ** Function l2c_ucd_send_pending_out_sec_q 776 ** 777 ** Description dequeue UCD packet from security pending queue and 778 ** enqueue it into CCB 779 ** 780 ** Return None 781 ** 782 *******************************************************************************/ 783 void l2c_ucd_send_pending_out_sec_q(tL2C_CCB *p_ccb) 784 { 785 BT_HDR *p_buf; 786 787 if ( p_ccb->p_lcb->ucd_out_sec_pending_q.count ) 788 { 789 p_buf = (BT_HDR*)GKI_dequeue (&p_ccb->p_lcb->ucd_out_sec_pending_q); 790 791 l2c_enqueue_peer_data (p_ccb, (BT_HDR *)p_buf); 792 l2c_link_check_send_pkts (p_ccb->p_lcb, NULL, NULL); 793 } 794 } 795 796 /******************************************************************************* 797 ** 798 ** Function l2c_ucd_discard_pending_out_sec_q 799 ** 800 ** Description dequeue UCD packet from security pending queue and 801 ** discard it. 802 ** 803 ** Return None 804 ** 805 *******************************************************************************/ 806 void l2c_ucd_discard_pending_out_sec_q(tL2C_CCB *p_ccb) 807 { 808 BT_HDR *p_buf; 809 810 p_buf = (BT_HDR*)GKI_dequeue (&p_ccb->p_lcb->ucd_out_sec_pending_q); 811 812 /* we may need to report to application */ 813 814 if (p_buf) 815 { 816 GKI_freebuf (p_buf); 817 } 818 } 819 820 /******************************************************************************* 821 ** 822 ** Function l2c_ucd_check_pending_in_sec_q 823 ** 824 ** Description check incoming security 825 ** 826 ** Return TRUE if any UCD packet for security 827 ** 828 *******************************************************************************/ 829 BOOLEAN l2c_ucd_check_pending_in_sec_q(tL2C_CCB *p_ccb) 830 { 831 UINT8 *p; 832 UINT16 psm; 833 BT_HDR *p_buf; 834 835 if ( p_ccb->p_lcb->ucd_in_sec_pending_q.count ) 836 { 837 p_buf = (BT_HDR*)(p_ccb->p_lcb->ucd_in_sec_pending_q.p_first); 838 p = (UINT8 *)(p_buf + 1) + p_buf->offset; 839 STREAM_TO_UINT16(psm, p) 840 841 p_ccb->chnl_state = CST_TERM_W4_SEC_COMP; 842 btm_sec_l2cap_access_req (p_ccb->p_lcb->remote_bd_addr, psm, 843 p_ccb->p_lcb->handle, CONNLESS_TERM, &l2c_link_sec_comp, p_ccb); 844 845 return (TRUE); 846 } 847 return (FALSE); 848 } 849 850 /******************************************************************************* 851 ** 852 ** Function l2c_ucd_send_pending_in_sec_q 853 ** 854 ** Description dequeue UCD packet from security pending queue and 855 ** send it to application 856 ** 857 ** Return None 858 ** 859 *******************************************************************************/ 860 void l2c_ucd_send_pending_in_sec_q(tL2C_CCB *p_ccb) 861 { 862 BT_HDR *p_buf; 863 864 if ( p_ccb->p_lcb->ucd_in_sec_pending_q.count ) 865 { 866 p_buf = (BT_HDR*)GKI_dequeue (&p_ccb->p_lcb->ucd_in_sec_pending_q); 867 868 p_ccb->p_rcb->ucd.cb_info.pL2CA_UCD_Data_Cb(p_ccb->p_lcb->remote_bd_addr, (BT_HDR *)p_buf); 869 } 870 } 871 872 /******************************************************************************* 873 ** 874 ** Function l2c_ucd_discard_pending_in_sec_q 875 ** 876 ** Description dequeue UCD packet from security pending queue and 877 ** discard it. 878 ** 879 ** Return None 880 ** 881 *******************************************************************************/ 882 void l2c_ucd_discard_pending_in_sec_q(tL2C_CCB *p_ccb) 883 { 884 BT_HDR *p_buf; 885 886 p_buf = (BT_HDR*)GKI_dequeue (&p_ccb->p_lcb->ucd_in_sec_pending_q); 887 888 if (p_buf) 889 { 890 GKI_freebuf (p_buf); 891 } 892 } 893 894 /******************************************************************************* 895 ** 896 ** Function l2c_ucd_check_rx_pkts 897 ** 898 ** Description Check if UCD reception is registered. 899 ** Process received UCD packet if application is expecting. 900 ** 901 ** Return TRUE if UCD reception is registered 902 ** 903 *******************************************************************************/ 904 BOOLEAN l2c_ucd_check_rx_pkts(tL2C_LCB *p_lcb, BT_HDR *p_msg) 905 { 906 tL2C_CCB *p_ccb; 907 tL2C_RCB *p_rcb; 908 909 if (((p_ccb = l2cu_find_ccb_by_cid (p_lcb, L2CAP_CONNECTIONLESS_CID)) != NULL) 910 ||((p_rcb = l2cu_find_rcb_by_psm (L2C_UCD_RCB_ID)) != NULL)) 911 { 912 if (p_ccb == NULL) 913 { 914 /* Allocate a channel control block */ 915 if ((p_ccb = l2cu_allocate_ccb (p_lcb, 0)) == NULL) 916 { 917 L2CAP_TRACE_WARNING0 ("L2CAP - no CCB for UCD reception"); 918 GKI_freebuf (p_msg); 919 return TRUE; 920 } 921 else 922 { 923 /* Set CID for the connection */ 924 p_ccb->local_cid = L2CAP_CONNECTIONLESS_CID; 925 p_ccb->remote_cid = L2CAP_CONNECTIONLESS_CID; 926 927 /* Set the default idle timeout value to use */ 928 p_ccb->fixed_chnl_idle_tout = L2CAP_UCD_IDLE_TIMEOUT; 929 930 /* Set the default channel priority value to use */ 931 l2cu_change_pri_ccb (p_ccb, L2CAP_UCD_CH_PRIORITY); 932 933 /* Save registration info */ 934 p_ccb->p_rcb = p_rcb; 935 936 p_ccb->chnl_state = CST_OPEN; 937 } 938 } 939 l2c_csm_execute(p_ccb, L2CEVT_L2CAP_DATA, p_msg); 940 return TRUE; 941 } 942 else 943 return FALSE; 944 } 945 946 /******************************************************************************* 947 ** 948 ** Function l2c_ucd_process_event 949 ** 950 ** Description This is called from main state machine when LCID is connectionless 951 ** Process the event if it is for UCD. 952 ** 953 ** Return TRUE if the event is consumed by UCD 954 ** FALSE if the event needs to be processed by main state machine 955 ** 956 *******************************************************************************/ 957 BOOLEAN l2c_ucd_process_event(tL2C_CCB *p_ccb, UINT16 event, void *p_data) 958 { 959 /* if the event is not processed by this function, this variable will be set to FALSE */ 960 BOOLEAN done = TRUE; 961 962 switch (p_ccb->chnl_state) 963 { 964 case CST_CLOSED: 965 switch (event) 966 { 967 case L2CEVT_LP_CONNECT_CFM: /* Link came up */ 968 /* check if waiting for UCD info */ 969 if (!l2c_ucd_check_pending_info_req (p_ccb)) 970 { 971 /* check if any outgoing UCD packet is waiting security check */ 972 if (!l2c_ucd_check_pending_out_sec_q(p_ccb)) 973 { 974 p_ccb->chnl_state = CST_OPEN; 975 } 976 } 977 break; 978 979 case L2CEVT_L2CAP_DATA: /* Peer data packet rcvd */ 980 GKI_enqueue (&p_ccb->p_lcb->ucd_in_sec_pending_q, p_data); 981 break; 982 983 case L2CEVT_L2CA_DATA_WRITE: /* Upper layer data to send */ 984 l2c_ucd_enqueue_pending_out_sec_q(p_ccb, p_data); 985 break; 986 987 case L2CEVT_L2CAP_INFO_RSP: 988 /* check if waiting for UCD info */ 989 if (!l2c_ucd_check_pending_info_req (p_ccb)) 990 { 991 /* check if any outgoing UCD packet is waiting security check */ 992 if (!l2c_ucd_check_pending_out_sec_q(p_ccb)) 993 { 994 p_ccb->chnl_state = CST_OPEN; 995 } 996 } 997 break; 998 999 default: 1000 done = FALSE; /* main state machine continues to process event */ 1001 break; 1002 } 1003 break; 1004 1005 case CST_ORIG_W4_SEC_COMP: 1006 switch (event) 1007 { 1008 case L2CEVT_SEC_RE_SEND_CMD: /* BTM has enough info to proceed */ 1009 /* check if any outgoing UCD packet is waiting security check */ 1010 if (!l2c_ucd_check_pending_out_sec_q(p_ccb)) 1011 { 1012 p_ccb->chnl_state = CST_OPEN; 1013 } 1014 break; 1015 1016 case L2CEVT_SEC_COMP: /* Security completed success */ 1017 p_ccb->chnl_state = CST_OPEN; 1018 l2c_ucd_send_pending_out_sec_q(p_ccb); 1019 1020 if ( p_ccb->p_lcb->ucd_out_sec_pending_q.count ) 1021 { 1022 /* start a timer to send next UCD packet in OPEN state */ 1023 /* it will prevent stack overflow */ 1024 btu_start_timer (&p_ccb->timer_entry, BTU_TTYPE_L2CAP_CHNL, 0); 1025 } 1026 else 1027 { 1028 /* start a timer for idle timeout of UCD */ 1029 btu_start_timer (&p_ccb->timer_entry, BTU_TTYPE_L2CAP_CHNL, p_ccb->fixed_chnl_idle_tout); 1030 } 1031 break; 1032 1033 case L2CEVT_SEC_COMP_NEG: 1034 p_ccb->chnl_state = CST_OPEN; 1035 l2c_ucd_discard_pending_out_sec_q(p_ccb); 1036 1037 /* start a timer for idle timeout of UCD */ 1038 btu_start_timer (&p_ccb->timer_entry, BTU_TTYPE_L2CAP_CHNL, p_ccb->fixed_chnl_idle_tout); 1039 break; 1040 1041 case L2CEVT_L2CA_DATA_WRITE: /* Upper layer data to send */ 1042 l2c_ucd_enqueue_pending_out_sec_q(p_ccb, p_data); 1043 break; 1044 1045 case L2CEVT_L2CAP_DATA: /* Peer data packet rcvd */ 1046 GKI_enqueue (&p_ccb->p_lcb->ucd_in_sec_pending_q, p_data); 1047 break; 1048 1049 case L2CEVT_L2CAP_INFO_RSP: 1050 /* check if waiting for UCD info */ 1051 l2c_ucd_check_pending_info_req (p_ccb); 1052 break; 1053 1054 default: 1055 done = FALSE; /* main state machine continues to process event */ 1056 break; 1057 } 1058 break; 1059 1060 1061 case CST_TERM_W4_SEC_COMP: 1062 switch (event) 1063 { 1064 case L2CEVT_SEC_COMP: 1065 p_ccb->chnl_state = CST_OPEN; 1066 l2c_ucd_send_pending_in_sec_q (p_ccb); 1067 1068 if ( p_ccb->p_lcb->ucd_in_sec_pending_q.count ) 1069 { 1070 /* start a timer to check next UCD packet in OPEN state */ 1071 /* it will prevent stack overflow */ 1072 btu_start_timer (&p_ccb->timer_entry, BTU_TTYPE_L2CAP_CHNL, 0); 1073 } 1074 else 1075 { 1076 /* start a timer for idle timeout of UCD */ 1077 btu_start_timer (&p_ccb->timer_entry, BTU_TTYPE_L2CAP_CHNL, p_ccb->fixed_chnl_idle_tout); 1078 } 1079 break; 1080 1081 case L2CEVT_SEC_COMP_NEG: 1082 if (((tL2C_CONN_INFO *)p_data)->status == BTM_DELAY_CHECK) 1083 { 1084 done = FALSE; 1085 break; 1086 } 1087 p_ccb->chnl_state = CST_OPEN; 1088 l2c_ucd_discard_pending_in_sec_q (p_ccb); 1089 1090 /* start a timer for idle timeout of UCD */ 1091 btu_start_timer (&p_ccb->timer_entry, BTU_TTYPE_L2CAP_CHNL, p_ccb->fixed_chnl_idle_tout); 1092 break; 1093 1094 case L2CEVT_L2CA_DATA_WRITE: /* Upper layer data to send */ 1095 l2c_ucd_enqueue_pending_out_sec_q(p_ccb, p_data); 1096 break; 1097 1098 case L2CEVT_L2CAP_DATA: /* Peer data packet rcvd */ 1099 GKI_enqueue (&p_ccb->p_lcb->ucd_in_sec_pending_q, p_data); 1100 break; 1101 1102 case L2CEVT_SEC_RE_SEND_CMD: /* BTM has enough info to proceed */ 1103 /* check if any incoming UCD packet is waiting security check */ 1104 if (!l2c_ucd_check_pending_in_sec_q(p_ccb)) 1105 { 1106 p_ccb->chnl_state = CST_OPEN; 1107 } 1108 break; 1109 1110 case L2CEVT_L2CAP_INFO_RSP: 1111 /* check if waiting for UCD info */ 1112 l2c_ucd_check_pending_info_req (p_ccb); 1113 break; 1114 1115 default: 1116 done = FALSE; /* main state machine continues to process event */ 1117 break; 1118 } 1119 break; 1120 1121 case CST_OPEN: 1122 switch (event) 1123 { 1124 case L2CEVT_L2CAP_DATA: /* Peer data packet rcvd */ 1125 /* stop idle timer of UCD */ 1126 btu_stop_timer (&p_ccb->timer_entry); 1127 1128 GKI_enqueue (&p_ccb->p_lcb->ucd_in_sec_pending_q, p_data); 1129 l2c_ucd_check_pending_in_sec_q (p_ccb); 1130 break; 1131 1132 case L2CEVT_L2CA_DATA_WRITE: /* Upper layer data to send */ 1133 /* stop idle timer of UCD */ 1134 btu_stop_timer (&p_ccb->timer_entry); 1135 1136 l2c_ucd_enqueue_pending_out_sec_q(p_ccb, p_data); 1137 1138 /* coverity[check_return] */ /* coverity[unchecked_value] */ 1139 /* success changes state, failure stays in current state */ 1140 l2c_ucd_check_pending_out_sec_q (p_ccb); 1141 break; 1142 1143 case L2CEVT_TIMEOUT: 1144 /* check if any UCD packet is waiting security check */ 1145 if ((!l2c_ucd_check_pending_in_sec_q(p_ccb)) 1146 &&(!l2c_ucd_check_pending_out_sec_q(p_ccb))) 1147 { 1148 l2cu_release_ccb (p_ccb); 1149 } 1150 break; 1151 1152 case L2CEVT_L2CAP_INFO_RSP: 1153 /* check if waiting for UCD info */ 1154 l2c_ucd_check_pending_info_req (p_ccb); 1155 break; 1156 1157 default: 1158 done = FALSE; /* main state machine continues to process event */ 1159 break; 1160 } 1161 break; 1162 1163 default: 1164 done = FALSE; /* main state machine continues to process event */ 1165 break; 1166 } 1167 1168 return done; 1169 } 1170 #endif /* (L2CAP_UCD_INCLUDED == TRUE) */ 1171
