/*******************************************************************************
**
** Function AVDT_ConnectReq
**
** Description This function initiates an AVDTP signaling connection
** to the peer device. When the connection is completed, an
** AVDT_CONNECT_IND_EVT is sent to the application via its
** control callback function. If the connection attempt fails
** an AVDT_DISCONNECT_IND_EVT is sent. The security mask
** parameter overrides the outgoing security mask set in
** AVDT_Register().
**
** Returns AVDT_SUCCESS if successful, otherwise error.
**
*******************************************************************************/
UINT16 AVDT_ConnectReq(BD_ADDR bd_addr, UINT8 sec_mask, tAVDT_CTRL_CBACK *p_cback)
{
tAVDT_CCB *p_ccb = NULL;
UINT16 result = AVDT_SUCCESS;
tAVDT_CCB_EVT evt;
/* find channel control block for this bd addr; if none, allocate one */
if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
} else if (p_ccb->ll_opened == FALSE) {
AVDT_TRACE_WARNING("AVDT_ConnectReq: CCB LL is in the middle of opening");
/* ccb was already allocated for the incoming signalling. */
result = AVDT_BUSY;
}
if (result == AVDT_SUCCESS) {
/* send event to ccb */
evt.connect.p_cback = p_cback;
evt.connect.sec_mask = sec_mask;
avdt_ccb_event(p_ccb, AVDT_CCB_API_CONNECT_REQ_EVT, &evt);
}
return result;
}
/*******************************************************************************
**
** Function avdt_sec_check_complete_orig
**
** Description The function called when Security Manager finishes
** verification of the service side connection
**
** Returns void
**
*******************************************************************************/
static void avdt_sec_check_complete_orig (BD_ADDR bd_addr, tBT_TRANSPORT trasnport,
void *p_ref_data, UINT8 res)
{
tAVDT_CCB *p_ccb = NULL;
tL2CAP_CFG_INFO cfg;
tAVDT_TC_TBL *p_tbl;
UNUSED(p_ref_data);
AVDT_TRACE_DEBUG("avdt_sec_check_complete_orig res: %d\n", res);
if (bd_addr) {
p_ccb = avdt_ccb_by_bd(bd_addr);
}
p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_SEC_INT);
if (p_tbl == NULL) {
return;
}
if ( res == BTM_SUCCESS ) {
/* set channel state */
p_tbl->state = AVDT_AD_ST_CFG;
/* Send L2CAP config req */
memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
cfg.mtu_present = TRUE;
cfg.mtu = p_tbl->my_mtu;
cfg.flush_to_present = TRUE;
cfg.flush_to = p_tbl->my_flush_to;
L2CA_ConfigReq(p_tbl->lcid, &cfg);
} else {
L2CA_DisconnectReq (p_tbl->lcid);
avdt_ad_tc_close_ind(p_tbl, L2CAP_CONN_SECURITY_BLOCK);
}
}
/*******************************************************************************
**
** Function AVDT_OpenReq
**
** Description This function initiates a connection to the AVDTP service
** on the peer device, if not already present, and connects
** to a stream endpoint on a peer device. When the connection
** is completed, an AVDT_OPEN_CFM_EVT is sent to the
** application via the control callback function for this handle.
**
** Returns AVDT_SUCCESS if successful, otherwise error.
**
*******************************************************************************/
UINT16 AVDT_OpenReq(UINT8 handle, BD_ADDR bd_addr, UINT8 seid, tAVDT_CFG *p_cfg)
{
tAVDT_CCB *p_ccb = NULL;
tAVDT_SCB *p_scb = NULL;
UINT16 result = AVDT_SUCCESS;
tAVDT_SCB_EVT evt;
/* verify SEID */
if ((seid < AVDT_SEID_MIN) || (seid > AVDT_SEID_MAX)) {
result = AVDT_BAD_PARAMS;
}
/* map handle to scb */
else if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) {
result = AVDT_BAD_HANDLE;
}
/* find channel control block for this bd addr; if none, allocate one */
else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
}
/* send event to scb */
if (result == AVDT_SUCCESS) {
evt.msg.config_cmd.hdr.seid = seid;
evt.msg.config_cmd.hdr.ccb_idx = avdt_ccb_to_idx(p_ccb);
evt.msg.config_cmd.int_seid = handle;
evt.msg.config_cmd.p_cfg = p_cfg;
avdt_scb_event(p_scb, AVDT_SCB_API_SETCONFIG_REQ_EVT, &evt);
}
return result;
}
/*******************************************************************************
**
** Function avdt_get_cap_req
**
** Description internal function to serve both AVDT_GetCapReq and
** AVDT_GetAllCapReq
**
** Returns AVDT_SUCCESS if successful, otherwise error.
**
*******************************************************************************/
static UINT16 avdt_get_cap_req(BD_ADDR bd_addr, tAVDT_CCB_API_GETCAP *p_evt)
{
tAVDT_CCB *p_ccb = NULL;
UINT16 result = AVDT_SUCCESS;
/* verify SEID */
if ((p_evt->single.seid < AVDT_SEID_MIN) || (p_evt->single.seid > AVDT_SEID_MAX)) {
AVDT_TRACE_ERROR("seid: %d\n", p_evt->single.seid);
result = AVDT_BAD_PARAMS;
}
/* find channel control block for this bd addr; if none, allocate one */
else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
}
if (result == AVDT_SUCCESS) {
/* make sure no discovery or get capabilities req already in progress */
if (p_ccb->proc_busy) {
result = AVDT_BUSY;
}
/* send event to ccb */
else {
avdt_ccb_event(p_ccb, AVDT_CCB_API_GETCAP_REQ_EVT, (tAVDT_CCB_EVT *)p_evt);
}
}
return result;
}
/*******************************************************************************
**
** Function AVDT_DiscoverReq
**
** Description This function initiates a connection to the AVDTP service
** on the peer device, if not already present, and discovers
** the stream endpoints on the peer device. (Please note
** that AVDTP discovery is unrelated to SDP discovery).
** This function can be called at any time regardless of whether
** there is an AVDTP connection to the peer device.
**
** When discovery is complete, an AVDT_DISCOVER_CFM_EVT
** is sent to the application via its callback function.
** The application must not call AVDT_GetCapReq() or
** AVDT_DiscoverReq() again to the same device until
** discovery is complete.
**
** The memory addressed by sep_info is allocated by the
** application. This memory is written to by AVDTP as part
** of the discovery procedure. This memory must remain
** accessible until the application receives the
** AVDT_DISCOVER_CFM_EVT.
**
** Returns AVDT_SUCCESS if successful, otherwise error.
**
*******************************************************************************/
UINT16 AVDT_DiscoverReq(BD_ADDR bd_addr, tAVDT_SEP_INFO *p_sep_info,
UINT8 max_seps, tAVDT_CTRL_CBACK *p_cback)
{
tAVDT_CCB *p_ccb;
UINT16 result = AVDT_SUCCESS;
tAVDT_CCB_EVT evt;
/* find channel control block for this bd addr; if none, allocate one */
if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* could not allocate channel control block */
result = AVDT_NO_RESOURCES;
}
}
if (result == AVDT_SUCCESS) {
/* make sure no discovery or get capabilities req already in progress */
if (p_ccb->proc_busy) {
result = AVDT_BUSY;
}
/* send event to ccb */
else {
evt.discover.p_sep_info = p_sep_info;
evt.discover.num_seps = max_seps;
evt.discover.p_cback = p_cback;
avdt_ccb_event(p_ccb, AVDT_CCB_API_DISCOVER_REQ_EVT, &evt);
}
}
return result;
}
/*******************************************************************************
**
** Function AVDT_GetSignalChannel
**
** Description Get the L2CAP CID used by the signal channel of the given handle.
**
** Returns CID if successful, otherwise 0.
**
*******************************************************************************/
UINT16 AVDT_GetSignalChannel(UINT8 handle, BD_ADDR bd_addr)
{
tAVDT_SCB *p_scb;
tAVDT_CCB *p_ccb;
UINT8 tcid = 0; /* tcid is always 0 for signal channel */
UINT16 lcid = 0;
/* map handle to scb */
if (((p_scb = avdt_scb_by_hdl(handle)) != NULL)
&& ((p_ccb = p_scb->p_ccb) != NULL)) {
lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid;
} else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) != NULL) {
lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid;
}
return (lcid);
}
/*******************************************************************************
**
** Function AVDT_DisconnectReq
**
** Description This function disconnect an AVDTP signaling connection
** to the peer device. When disconnected an
** AVDT_DISCONNECT_IND_EVT is sent to the application via its
** control callback function.
**
** Returns AVDT_SUCCESS if successful, otherwise error.
**
*******************************************************************************/
UINT16 AVDT_DisconnectReq(BD_ADDR bd_addr, tAVDT_CTRL_CBACK *p_cback)
{
tAVDT_CCB *p_ccb = NULL;
UINT16 result = AVDT_SUCCESS;
tAVDT_CCB_EVT evt;
/* find channel control block for this bd addr; if none, error */
if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
result = AVDT_BAD_PARAMS;
}
if (result == AVDT_SUCCESS) {
/* send event to ccb */
evt.disconnect.p_cback = p_cback;
avdt_ccb_event(p_ccb, AVDT_CCB_API_DISCONNECT_REQ_EVT, &evt);
}
return result;
}
/*******************************************************************************
**
** Function avdt_sec_check_complete_term
**
** Description The function called when Security Manager finishes
** verification of the service side connection
**
** Returns void
**
*******************************************************************************/
static void avdt_sec_check_complete_term (BD_ADDR bd_addr, tBT_TRANSPORT transport,
void *p_ref_data, UINT8 res)
{
tAVDT_CCB *p_ccb = NULL;
tL2CAP_CFG_INFO cfg;
tAVDT_TC_TBL *p_tbl;
UNUSED(p_ref_data);
AVDT_TRACE_DEBUG("avdt_sec_check_complete_term res: %d\n", res);
if (!bd_addr) {
AVDT_TRACE_WARNING("avdt_sec_check_complete_term: NULL BD_ADDR");
return;
}
p_ccb = avdt_ccb_by_bd(bd_addr);
p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_SEC_ACP);
if (p_tbl == NULL) {
return;
}
if (res == BTM_SUCCESS) {
/* Send response to the L2CAP layer. */
L2CA_ConnectRsp (bd_addr, p_tbl->id, p_tbl->lcid, L2CAP_CONN_OK, L2CAP_CONN_OK);
/* store idx in LCID table, store LCID in routing table */
avdt_cb.ad.lcid_tbl[p_tbl->lcid - L2CAP_BASE_APPL_CID] = avdt_ad_tc_tbl_to_idx(p_tbl);
avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].lcid = p_tbl->lcid;
/* transition to configuration state */
p_tbl->state = AVDT_AD_ST_CFG;
/* Send L2CAP config req */
memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
cfg.mtu_present = TRUE;
cfg.mtu = p_tbl->my_mtu;
cfg.flush_to_present = TRUE;
cfg.flush_to = p_tbl->my_flush_to;
L2CA_ConfigReq(p_tbl->lcid, &cfg);
} else {
L2CA_ConnectRsp (bd_addr, p_tbl->id, p_tbl->lcid, L2CAP_CONN_SECURITY_BLOCK, L2CAP_CONN_OK);
avdt_ad_tc_close_ind(p_tbl, L2CAP_CONN_SECURITY_BLOCK);
}
}
/*******************************************************************************
**
** Function avdt_l2c_connect_ind_cback
**
** Description This is the L2CAP connect indication callback function.
**
**
** Returns void
**
*******************************************************************************/
void avdt_l2c_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8 id)
{
tAVDT_CCB *p_ccb;
tAVDT_TC_TBL *p_tbl = NULL;
UINT16 result;
tL2CAP_CFG_INFO cfg;
tBTM_STATUS rc;
UNUSED(psm);
/* do we already have a control channel for this peer? */
if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) {
/* no, allocate ccb */
if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) {
/* no ccb available, reject L2CAP connection */
result = L2CAP_CONN_NO_RESOURCES;
} else {
/* allocate and set up entry; first channel is always signaling */
p_tbl = avdt_ad_tc_tbl_alloc(p_ccb);
p_tbl->my_mtu = avdt_cb.rcb.ctrl_mtu;
p_tbl->my_flush_to = L2CAP_DEFAULT_FLUSH_TO;
p_tbl->tcid = AVDT_CHAN_SIG;
p_tbl->lcid = lcid;
p_tbl->id = id;
p_tbl->state = AVDT_AD_ST_SEC_ACP;
p_tbl->cfg_flags = AVDT_L2C_CFG_CONN_ACP;
/* Check the security */
rc = btm_sec_mx_access_request (bd_addr, AVDT_PSM,
FALSE, BTM_SEC_PROTO_AVDT,
AVDT_CHAN_SIG,
&avdt_sec_check_complete_term, NULL);
if (rc == BTM_CMD_STARTED) {
L2CA_ConnectRsp (p_ccb->peer_addr, p_tbl->id, lcid, L2CAP_CONN_PENDING, L2CAP_CONN_OK);
}
return;
}
}
/* deal with simultaneous control channel connect case */
else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_CONN)) != NULL) {
/* reject their connection */
result = L2CAP_CONN_NO_RESOURCES;
}
/* this must be a traffic channel; are we accepting a traffic channel
** for this ccb?
*/
else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_MEDIA, p_ccb, AVDT_AD_ST_ACP)) != NULL) {
/* yes; proceed with connection */
result = L2CAP_CONN_OK;
}
#if AVDT_REPORTING == TRUE
/* this must be a reporting channel; are we accepting a reporting channel
** for this ccb?
*/
else if ((p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_REPORT, p_ccb, AVDT_AD_ST_ACP)) != NULL) {
/* yes; proceed with connection */
result = L2CAP_CONN_OK;
}
#endif
/* else we're not listening for traffic channel; reject */
else {
result = L2CAP_CONN_NO_PSM;
}
/* Send L2CAP connect rsp */
L2CA_ConnectRsp(bd_addr, id, lcid, result, 0);
/* if result ok, proceed with connection */
if (result == L2CAP_CONN_OK) {
/* store idx in LCID table, store LCID in routing table */
avdt_cb.ad.lcid_tbl[lcid - L2CAP_BASE_APPL_CID] = avdt_ad_tc_tbl_to_idx(p_tbl);
avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].lcid = lcid;
/* transition to configuration state */
p_tbl->state = AVDT_AD_ST_CFG;
/* Send L2CAP config req */
memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
cfg.mtu_present = TRUE;
cfg.mtu = p_tbl->my_mtu;
cfg.flush_to_present = TRUE;
cfg.flush_to = p_tbl->my_flush_to;
L2CA_ConfigReq(lcid, &cfg);
}
}