/******************************************************************************* ** ** Function avct_l2c_config_cfm_cback ** ** Description This is the L2CAP config confirm callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg) { tAVCT_LCB *p_lcb; /* look up lcb for this channel */ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) { AVCT_TRACE_DEBUG("avct_l2c_config_cfm_cback: 0x%x, ch_state: %d, res: %d", lcid, p_lcb->ch_state, p_cfg->result); /* if in correct state */ if (p_lcb->ch_state == AVCT_CH_CFG) { /* if result successful */ if (p_cfg->result == L2CAP_CFG_OK) { /* update flags */ p_lcb->ch_flags |= AVCT_L2C_CFG_CFM_DONE; /* if configuration complete */ if (p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE) { p_lcb->ch_state = AVCT_CH_OPEN; avct_lcb_event(p_lcb, AVCT_LCB_LL_OPEN_EVT, NULL); } } /* else failure */ else { AVCT_TRACE_DEBUG("ERROR avct_l2c_config_cfm_cback L2CA_DisconnectReq %d ", p_lcb->ch_state); /* store result value */ p_lcb->ch_result = p_cfg->result; /* Send L2CAP disconnect req */ L2CA_DisconnectReq(lcid); } } AVCT_TRACE_DEBUG("ch_state cfc: %d ", p_lcb->ch_state); } }
/******************************************************************************* ** ** Function avct_lcb_dealloc ** ** Description Deallocate a link control block. ** ** ** Returns void. ** *******************************************************************************/ void avct_lcb_dealloc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data) { tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; BOOLEAN found = FALSE; int i; UNUSED(p_data); AVCT_TRACE_DEBUG("avct_lcb_dealloc %d", p_lcb->allocated); for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) { /* if ccb allocated and */ if (p_ccb->allocated) { if (p_ccb->p_lcb == p_lcb) { AVCT_TRACE_DEBUG("avct_lcb_dealloc used by ccb: %d", i); found = TRUE; break; } } } if (!found) { AVCT_TRACE_DEBUG("avct_lcb_dealloc now"); /* clear reassembled msg buffer if in use */ if (p_lcb->p_rx_msg != NULL) { GKI_freebuf(p_lcb->p_rx_msg); } memset(p_lcb, 0, sizeof(tAVCT_LCB)); } }
/******************************************************************************* ** ** Function avct_l2c_config_ind_cback ** ** Description This is the L2CAP config indication callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg) { tAVCT_LCB *p_lcb; /* look up lcb for this channel */ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) { AVCT_TRACE_DEBUG("avct_l2c_config_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state); /* store the mtu in tbl */ if (p_cfg->mtu_present) { p_lcb->peer_mtu = p_cfg->mtu; } else { p_lcb->peer_mtu = L2CAP_DEFAULT_MTU; } /* send L2CAP configure response */ memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO)); p_cfg->result = L2CAP_CFG_OK; L2CA_ConfigRsp(lcid, p_cfg); /* if first config ind */ if ((p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE) == 0) { /* update flags */ p_lcb->ch_flags |= AVCT_L2C_CFG_IND_DONE; /* if configuration complete */ if (p_lcb->ch_flags & AVCT_L2C_CFG_CFM_DONE) { p_lcb->ch_state = AVCT_CH_OPEN; avct_lcb_event(p_lcb, AVCT_LCB_LL_OPEN_EVT, NULL); } } AVCT_TRACE_DEBUG("ch_state cfi: %d ", p_lcb->ch_state); } }
/******************************************************************************* ** ** Function avct_lcb_dealloc ** ** Description Deallocate a link control block. ** ** ** Returns void. ** *******************************************************************************/ void avct_lcb_dealloc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data) { UNUSED(p_data); AVCT_TRACE_DEBUG("%s allocated: %d", __func__, p_lcb->allocated); // Check if the LCB is still referenced tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; for (size_t i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) { if (p_ccb->allocated && p_ccb->p_lcb == p_lcb) { AVCT_TRACE_DEBUG("%s LCB in use; lcb index: %d", __func__, i); return; } } // If not, de-allocate now... AVCT_TRACE_DEBUG("%s Freeing LCB", __func__); osi_free(p_lcb->p_rx_msg); fixed_queue_free(p_lcb->tx_q, NULL); memset(p_lcb, 0, sizeof(tAVCT_LCB)); }
/******************************************************************************* ** ** Function avct_bcb_dealloc ** ** Description Deallocate a browse control block. ** ** ** Returns void. ** *******************************************************************************/ void avct_bcb_dealloc(tAVCT_BCB *p_bcb, tAVCT_LCB_EVT *p_data) { tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; BOOLEAN found = FALSE; int i; if (p_bcb != NULL) { AVCT_TRACE_DEBUG("avct_bcb_dealloc %d", p_bcb->allocated); for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) { /* if ccb allocated and */ if (p_ccb->allocated) { if (p_ccb->p_bcb == p_bcb) { AVCT_TRACE_DEBUG("avct_lcb_dealloc used by ccb: %d", i); found = TRUE; break; } } } if (!found) { AVCT_TRACE_DEBUG("avct_bcb_dealloc now"); memset(p_bcb, 0, sizeof(tAVCT_BCB)); } } else { AVCT_TRACE_ERROR("### dealloc Null bcb"); } }
/******************************************************************************* ** ** Function avct_l2c_connect_ind_cback ** ** Description This is the L2CAP connect indication callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8 id) { tAVCT_LCB *p_lcb; UINT16 result = L2CAP_CONN_OK; tL2CAP_CFG_INFO cfg; UNUSED(psm); /* do we already have a channel for this peer? */ if ((p_lcb = avct_lcb_by_bd(bd_addr)) == NULL) { /* no, allocate lcb */ if ((p_lcb = avct_lcb_alloc(bd_addr)) == NULL) { /* no ccb available, reject L2CAP connection */ result = L2CAP_CONN_NO_RESOURCES; } } /* else we already have a channel for this peer */ else { if (!avct_l2c_is_passive (p_lcb) || (p_lcb->ch_state == AVCT_CH_OPEN)) { /* this LCB included CT role - reject */ result = L2CAP_CONN_NO_RESOURCES; } else { /* TG role only - accept the connection from CT. move the channel ID to the conflict list */ p_lcb->conflict_lcid = p_lcb->ch_lcid; AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback conflict_lcid:0x%x", p_lcb->conflict_lcid); } } if (p_lcb) { AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback: 0x%x, res: %d, ch_state: %d", lcid, result, p_lcb->ch_state); } /* Send L2CAP connect rsp */ L2CA_ConnectRsp(bd_addr, id, lcid, result, 0); /* if result ok, proceed with connection */ if (result == L2CAP_CONN_OK) { /* store LCID */ p_lcb->ch_lcid = lcid; /* transition to configuration state */ p_lcb->ch_state = AVCT_CH_CFG; /* Send L2CAP config req */ memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO)); cfg.mtu_present = TRUE; cfg.mtu = avct_cb.mtu; L2CA_ConfigReq(lcid, &cfg); AVCT_TRACE_DEBUG("avct_l2c snd Cfg Req"); } #if (BT_USE_TRACES == TRUE) if (p_lcb) { AVCT_TRACE_DEBUG("ch_state cni: %d ", p_lcb->ch_state); } #endif }
/******************************************************************************* ** ** Function avct_l2c_disconnect_ind_cback ** ** Description This is the L2CAP disconnect indication callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed) { tAVCT_LCB *p_lcb; UINT16 result = AVCT_RESULT_FAIL; /* look up lcb for this channel */ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) { AVCT_TRACE_DEBUG("avct_l2c_disconnect_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state); if (ack_needed) { /* send L2CAP disconnect response */ L2CA_DisconnectRsp(lcid); } avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result); AVCT_TRACE_DEBUG("ch_state di: %d ", p_lcb->ch_state); } }
/******************************************************************************* ** ** Function avct_l2c_disconnect_cfm_cback ** ** Description This is the L2CAP disconnect confirm callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_disconnect_cfm_cback(UINT16 lcid, UINT16 result) { tAVCT_LCB *p_lcb; UINT16 res; /* look up lcb for this channel */ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) { AVCT_TRACE_DEBUG("avct_l2c_disconnect_cfm_cback: 0x%x, ch_state: %d, res: %d", lcid, p_lcb->ch_state, result); /* result value may be previously stored */ res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result; p_lcb->ch_result = 0; avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &res); AVCT_TRACE_DEBUG("ch_state dc: %d ", p_lcb->ch_state); } }
/******************************************************************************* ** ** Function avct_l2c_connect_cfm_cback ** ** Description This is the L2CAP connect confirm callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result) { tAVCT_LCB *p_lcb; tL2CAP_CFG_INFO cfg; /* look up lcb for this channel */ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) { AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback lcid:0x%x result: %d ch_state: %d, conflict_lcid:0x%x", lcid, result, p_lcb->ch_state, p_lcb->conflict_lcid); /* if in correct state */ if (p_lcb->ch_state == AVCT_CH_CONN) { /* if result successful */ if (result == L2CAP_CONN_OK) { /* set channel state */ p_lcb->ch_state = AVCT_CH_CFG; /* Send L2CAP config req */ memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO)); cfg.mtu_present = TRUE; cfg.mtu = avct_cb.mtu; L2CA_ConfigReq(lcid, &cfg); AVCT_TRACE_DEBUG("avct_l2c snd Cfg Req"); } /* else failure */ else { AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback conflict_lcid:0x%x", p_lcb->conflict_lcid); if (p_lcb->conflict_lcid == lcid) { p_lcb->conflict_lcid = 0; } else { avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result); } } } else if (p_lcb->conflict_lcid == lcid) { /* we must be in AVCT_CH_CFG state for the ch_lcid channel */ AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback ch_state: %d, conflict_lcid:0x%x", p_lcb->ch_state, p_lcb->conflict_lcid); if (result == L2CAP_CONN_OK) { /* just in case the peer also accepts our connection - Send L2CAP disconnect req */ L2CA_DisconnectReq(lcid); } p_lcb->conflict_lcid = 0; } AVCT_TRACE_DEBUG("ch_state cnc: %d ", p_lcb->ch_state); } }
/******************************************************************************* ** ** Function avct_l2c_congestion_ind_cback ** ** Description This is the L2CAP congestion indication callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_congestion_ind_cback(UINT16 lcid, BOOLEAN is_congested) { tAVCT_LCB *p_lcb; AVCT_TRACE_DEBUG("avct_l2c_congestion_ind_cback: 0x%x", lcid); /* look up lcb for this channel */ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) { avct_lcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT *) &is_congested); } }
/***************************************************************************** ** ** Function avct_lcb_by_bcb ** ** Description This ** ** Returns pointer to the lcb, or NULL if none found. ** *******************************************************************************/ tAVCT_LCB *avct_lcb_by_bcb(tAVCT_BCB *p_bcb) { tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; int i; for (i = 0; i < AVCT_NUM_CONN; i++) { AVCT_TRACE_DEBUG("avct_lcb_alloc= %d", p_bcb->allocated); if(p_ccb[i].allocated && p_ccb[i].p_bcb == p_bcb) return avct_cb.ccb[i].p_lcb; } AVCT_TRACE_ERROR("###avct_lcb_by_bcb ERROR"); return NULL ; }
/******************************************************************************* ** ** Function avct_l2c_data_ind_cback ** ** Description This is the L2CAP data indication callback function. ** ** ** Returns void ** *******************************************************************************/ void avct_l2c_data_ind_cback(UINT16 lcid, BT_HDR *p_buf) { tAVCT_LCB *p_lcb; AVCT_TRACE_DEBUG("avct_l2c_data_ind_cback: 0x%x", lcid); /* look up lcb for this channel */ if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL) { avct_lcb_event(p_lcb, AVCT_LCB_LL_MSG_EVT, (tAVCT_LCB_EVT *) &p_buf); } else { /* prevent buffer leak */ AVCT_TRACE_WARNING("ERROR -> avct_l2c_data_ind_cback drop buffer"); osi_free(p_buf); } }
tAVCT_BCB *avct_bcb_by_lcid(UINT16 lcid) { AVCT_TRACE_DEBUG("avct_bcb_by_lcid :=%x",lcid); tAVCT_BCB *p_bcb = &avct_cb.bcb[0]; int i; for (i = 0; i < AVCT_NUM_LINKS; i++, p_bcb++) { if (p_bcb->allocated && ((p_bcb->ch_lcid == lcid))) { AVCT_TRACE_DEBUG("avct_bcb_by_lcid :=%x",p_bcb->ch_lcid); break; } } if (i == AVCT_NUM_LINKS) { /*out of bcbs */ p_bcb = NULL; AVCT_TRACE_WARNING("###No bcb for lcid %x", lcid); } return p_bcb; }
/***************************************************************************** ** ** Function avct_bcb_by_lcb ** ** Description This function finds bcb associated to a lcb ** ** Returns pointer to the bcb , or NULL if none found. ** *******************************************************************************/ tAVCT_BCB *avct_bcb_by_lcb(tAVCT_LCB *p_lcb) { int i; tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) { AVCT_TRACE_DEBUG("avct_bcb_by_lcb %d , ccb ", p_ccb->allocated); if ( p_ccb->p_lcb == p_lcb ) { return avct_cb.ccb[i].p_bcb; } } AVCT_TRACE_ERROR("###avct_bcb_by_lcb ERROR"); return NULL ; }
/******************************************************************************* ** ** Function avct_lcb_has_pid ** ** Description See if any ccbs on this lcb have a particular pid. ** ** ** Returns Pointer to CCB if PID found, NULL otherwise. ** *******************************************************************************/ tAVCT_CCB *avct_lcb_has_pid(tAVCT_LCB *p_lcb, UINT16 pid) { tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; int i; for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) { if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb->cc.pid == pid)) { AVCT_TRACE_DEBUG("avct_lcb_has_pid, found"); return p_ccb; } } AVCT_TRACE_WARNING("avct_lcb_has_pid, not found"); return NULL; }
/******************************************************************************* ** ** Function avct_l2c_is_passive ** ** Description check is the CCB associated with the given LCB was created ** as passive ** ** Returns TRUE, if the given LCB is created as AVCT_PASSIVE ** *******************************************************************************/ static BOOLEAN avct_l2c_is_passive (tAVCT_LCB *p_lcb) { BOOLEAN is_passive = FALSE; tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; int i; for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) { if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb)) { AVCT_TRACE_DEBUG("avct_l2c_is_ct control:x%x", p_ccb->cc.control); if (p_ccb->cc.control & AVCT_PASSIVE) { is_passive = TRUE; break; } } } return is_passive; }
/******************************************************************************* ** ** Function avct_ccb_alloc ** ** Description Allocate a connection control block; copy parameters to ccb. ** ** ** Returns pointer to the ccb, or NULL if none could be allocated. ** *******************************************************************************/ tAVCT_CCB *avct_ccb_alloc(tAVCT_CC *p_cc) { tAVCT_CCB *p_ccb = &avct_cb.ccb[0]; int i; for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) { if (!p_ccb->allocated) { p_ccb->allocated = AVCT_ALOC_LCB; memcpy(&p_ccb->cc, p_cc, sizeof(tAVCT_CC)); AVCT_TRACE_DEBUG("avct_ccb_alloc %d", i); break; } } if (i == AVCT_NUM_CONN) { /* out of ccbs */ p_ccb = NULL; AVCT_TRACE_WARNING("Out of ccbs"); } return p_ccb; }
/******************************************************************************* ** ** Function avct_lcb_by_bd ** ** Description This lookup function finds the lcb for a BD address. ** ** ** Returns pointer to the lcb, or NULL if none found. ** *******************************************************************************/ tAVCT_LCB *avct_lcb_by_bd(BD_ADDR bd_addr) { tAVCT_LCB *p_lcb = &avct_cb.lcb[0]; int i; for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) { /* if allocated lcb has matching lcb */ if (p_lcb->allocated && (!memcmp(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN))) { break; } } if (i == AVCT_NUM_LINKS) { /* if no lcb found */ p_lcb = NULL; AVCT_TRACE_DEBUG("No lcb for addr %02x-%02x-%02x-%02x-%02x-%02x", bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]); } return p_lcb; }
/******************************************************************************* ** ** Function avct_ccb_dealloc ** ** Description Deallocate a connection control block and call application ** callback. ** ** ** Returns void. ** *******************************************************************************/ void avct_ccb_dealloc(tAVCT_CCB *p_ccb, UINT8 event, UINT16 result, BD_ADDR bd_addr) { tAVCT_CTRL_CBACK *p_cback = p_ccb->cc.p_ctrl_cback; AVCT_TRACE_DEBUG("avct_ccb_dealloc %d", avct_ccb_to_idx(p_ccb)); #if (AVCT_BROWSE_INCLUDED == TRUE) if (p_ccb->p_bcb == NULL) { memset(p_ccb, 0, sizeof(tAVCT_CCB)); } else { /* control channel is down, but the browsing channel is still connected 0 disconnect it now */ avct_bcb_event(p_ccb->p_bcb, AVCT_LCB_UL_UNBIND_EVT, (tAVCT_LCB_EVT *) &p_ccb); p_ccb->p_lcb = NULL; } #else memset(p_ccb, 0, sizeof(tAVCT_CCB)); #endif if (event != AVCT_NO_EVT) { (*p_cback)(avct_ccb_to_idx(p_ccb), event, result, bd_addr); } }
/******************************************************************************* ** ** Function avct_lcb_alloc ** ** Description Allocate a link control block. ** ** ** Returns pointer to the lcb, or NULL if none could be allocated. ** *******************************************************************************/ tAVCT_LCB *avct_lcb_alloc(BD_ADDR bd_addr) { tAVCT_LCB *p_lcb = &avct_cb.lcb[0]; int i; for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) { if (!p_lcb->allocated) { p_lcb->allocated = (UINT8)(i + 1); memcpy(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN); AVCT_TRACE_DEBUG("avct_lcb_alloc %d", p_lcb->allocated); p_lcb->tx_q = fixed_queue_new(SIZE_MAX); break; } } if (i == AVCT_NUM_LINKS) { /* out of lcbs */ p_lcb = NULL; AVCT_TRACE_WARNING("Out of lcbs"); } return p_lcb; }