/*******************************************************************************
**
** Function BTA_HdRegisterApp
**
** Description This function is called when application should be registered
**
** Returns void
**
*******************************************************************************/
extern void BTA_HdRegisterApp(tBTA_HD_APP_INFO *p_app_info, tBTA_HD_QOS_INFO *p_in_qos,
tBTA_HD_QOS_INFO *p_out_qos)
{
tBTA_HD_REGISTER_APP *p_buf;
APPL_TRACE_API("%s", __FUNCTION__);
if ((p_buf = (tBTA_HD_REGISTER_APP *) GKI_getbuf(sizeof(tBTA_HD_REGISTER_APP))) != NULL)
{
p_buf->hdr.event = BTA_HD_API_REGISTER_APP_EVT;
if (p_app_info->p_name)
{
BCM_STRNCPY_S(p_buf->name, sizeof(p_buf->name),
p_app_info->p_name, BTA_HD_APP_NAME_LEN);
p_buf->name[BTA_HD_APP_NAME_LEN] = '\0';
}
else
{
p_buf->name[0]= '\0';
}
if (p_app_info->p_description)
{
BCM_STRNCPY_S(p_buf->description, sizeof(p_buf->description), p_app_info->p_description,
BTA_HD_APP_DESCRIPTION_LEN);
p_buf->description[BTA_HD_APP_DESCRIPTION_LEN] = '\0';
}
else
{
p_buf->description[0]= '\0';
}
if (p_app_info->p_provider)
{
BCM_STRNCPY_S(p_buf->provider, sizeof(p_buf->provider), p_app_info->p_provider,
BTA_HD_APP_PROVIDER_LEN);
p_buf->provider[BTA_HD_APP_PROVIDER_LEN] = '\0';
}
else
{
p_buf->provider[0]= '\0';
}
p_buf->subclass = p_app_info->subclass;
p_buf->d_len = p_app_info->descriptor.dl_len;
memcpy(p_buf->d_data, p_app_info->descriptor.dsc_list, p_app_info->descriptor.dl_len);
// copy qos data as-is
memcpy(&p_buf->in_qos, p_in_qos, sizeof(tBTA_HD_QOS_INFO));
memcpy(&p_buf->out_qos, p_out_qos, sizeof(tBTA_HD_QOS_INFO));
bta_sys_sendmsg(p_buf);
}
}
/*******************************************************************************
**
** Function BTA_PanSetRole
**
** Description Sets PAN roles. When the enable operation is complete
** the callback function will be called with a BTA_PAN_SET_ROLE_EVT.
**
** Returns void
**
*******************************************************************************/
void BTA_PanSetRole(tBTA_PAN_ROLE role, tBTA_PAN_ROLE_INFO *p_user_info, tBTA_PAN_ROLE_INFO *p_gn_info,
tBTA_PAN_ROLE_INFO *p_nap_info)
{
tBTA_PAN_API_SET_ROLE *p_buf;
if ((p_buf = (tBTA_PAN_API_SET_ROLE *) GKI_getbuf(sizeof(tBTA_PAN_API_SET_ROLE))) != NULL)
{
p_buf->hdr.event = BTA_PAN_API_SET_ROLE_EVT;
p_buf->role = role;
if(p_user_info && (role & BTA_PAN_ROLE_PANU))
{
if(p_user_info->p_srv_name)
BCM_STRNCPY_S(p_buf->user_name, sizeof(p_buf->user_name), p_user_info->p_srv_name, BTA_SERVICE_NAME_LEN);
else
p_buf->user_name[0] = 0;
p_buf->user_name[BTA_SERVICE_NAME_LEN] = 0;
p_buf->user_app_id = p_user_info->app_id;
p_buf->user_sec_mask = p_user_info->sec_mask;
}
if(p_gn_info && (role & BTA_PAN_ROLE_GN))
{
if(p_gn_info->p_srv_name)
BCM_STRNCPY_S(p_buf->gn_name, sizeof(p_buf->gn_name), p_gn_info->p_srv_name, BTA_SERVICE_NAME_LEN);
else
p_buf->gn_name[0] = 0;
p_buf->gn_name[BTA_SERVICE_NAME_LEN] = 0;
p_buf->gn_app_id = p_gn_info->app_id;
p_buf->gn_sec_mask = p_gn_info->sec_mask;
}
if(p_nap_info && (role & BTA_PAN_ROLE_NAP))
{
if(p_nap_info->p_srv_name)
BCM_STRNCPY_S(p_buf->nap_name, sizeof(p_buf->nap_name), p_nap_info->p_srv_name, BTA_SERVICE_NAME_LEN);
else
p_buf->nap_name[0] = 0;
p_buf->nap_name[BTA_SERVICE_NAME_LEN] = 0;
p_buf->nap_app_id = p_nap_info->app_id;
p_buf->nap_sec_mask = p_nap_info->sec_mask;
}
bta_sys_sendmsg(p_buf);
}
}
/*******************************************************************************
**
** Function BTM_SetLocalDeviceName
**
** Description This function is called to set the local device name.
**
** Returns status of the operation
**
*******************************************************************************/
tBTM_STATUS BTM_SetLocalDeviceName (char *p_name)
{
UINT8 *p;
if (!p_name || !p_name[0] || (strlen ((char *)p_name) > BD_NAME_LEN))
return (BTM_ILLEGAL_VALUE);
if (!controller_get_interface()->get_is_ready())
return (BTM_DEV_RESET);
#if BTM_MAX_LOC_BD_NAME_LEN > 0
/* Save the device name if local storage is enabled */
p = (UINT8 *)btm_cb.cfg.bd_name;
if (p != (UINT8 *)p_name)
{
BCM_STRNCPY_S(btm_cb.cfg.bd_name, sizeof(btm_cb.cfg.bd_name), p_name, BTM_MAX_LOC_BD_NAME_LEN);
btm_cb.cfg.bd_name[BTM_MAX_LOC_BD_NAME_LEN] = '\0';
}
#else
p = (UINT8 *)p_name;
#endif
if (btsnd_hcic_change_name(p))
return (BTM_CMD_STARTED);
else
return (BTM_NO_RESOURCES);
}
/*******************************************************************************
**
** Function BTA_AgRegister
**
** Description Register an Audio Gateway service.
**
**
** Returns void
**
*******************************************************************************/
void BTA_AgRegister(tBTA_SERVICE_MASK services, tBTA_SEC sec_mask,tBTA_AG_FEAT features,
char * p_service_names[], UINT8 app_id)
{
tBTA_AG_API_REGISTER *p_buf;
int i;
if ((p_buf = (tBTA_AG_API_REGISTER *) GKI_getbuf(sizeof(tBTA_AG_API_REGISTER))) != NULL)
{
p_buf->hdr.event = BTA_AG_API_REGISTER_EVT;
p_buf->features = features;
p_buf->sec_mask = sec_mask;
p_buf->services = services;
p_buf->app_id = app_id;
for (i = 0; i < BTA_AG_NUM_IDX; i++)
{
if(p_service_names[i])
{
BCM_STRNCPY_S(p_buf->p_name[i], BTA_SERVICE_NAME_LEN+1, p_service_names[i], BTA_SERVICE_NAME_LEN);
p_buf->p_name[i][BTA_SERVICE_NAME_LEN] = 0;
}
else
{
p_buf->p_name[i][0] = 0;
}
}
bta_sys_sendmsg(p_buf);
}
}
/*******************************************************************************
**
** Function NFA_SnepRegisterServer
**
** Description This function is called to listen to a SAP as SNEP server.
**
** If server_sap is set to NFA_SNEP_ANY_SAP, then NFA will allocate
** a SAP between LLCP_LOWER_BOUND_SDP_SAP and LLCP_UPPER_BOUND_SDP_SAP
**
** NFC Forum default SNEP server ("urn:nfc:sn:snep") may be launched
** by NFA_SnepStartDefaultServer().
**
** NFA_SNEP_REG_EVT will be returned with status, handle and service name.
**
** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT
** should happen before calling this function
**
** Returns NFA_STATUS_OK if successfully initiated
** NFA_STATUS_INVALID_PARAM if p_service_name or p_cback is NULL
** NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_SnepRegisterServer (UINT8 server_sap,
char *p_service_name,
tNFA_SNEP_CBACK *p_cback)
{
tNFA_SNEP_API_REG_SERVER *p_msg;
SNEP_TRACE_API2 ("NFA_SnepRegisterServer (): SAP:0x%X, SN:<%s>", server_sap, p_service_name);
if ((p_service_name == NULL) || (p_cback == NULL))
{
SNEP_TRACE_ERROR0 ("NFA_SnepRegisterServer (): p_service_name or p_cback is NULL");
return (NFA_STATUS_INVALID_PARAM);
}
if ((p_msg = (tNFA_SNEP_API_REG_SERVER *) GKI_getbuf (sizeof (tNFA_SNEP_API_REG_SERVER))) != NULL)
{
p_msg->hdr.event = NFA_SNEP_API_REG_SERVER_EVT;
p_msg->server_sap = server_sap;
BCM_STRNCPY_S (p_msg->service_name, sizeof (p_msg->service_name),
p_service_name, LLCP_MAX_SN_LEN);
p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
p_msg->p_cback = p_cback;
nfa_sys_sendmsg (p_msg);
return (NFA_STATUS_OK);
}
return (NFA_STATUS_FAILED);
}
/*******************************************************************************
**
** Function app_op_add_param
**
** Description Add parameter strings to a property string.
**
**
** Returns Pointer to the next byte after the end of the string.
**
*******************************************************************************/
UINT8 *app_op_add_param(tAPP_OP_FMT fmt, const tAPP_OP_PROP_TBL *p_tbl, UINT8 *p, tAPP_OP_PROP *p_prop)
{
UINT8 i_e, i_c, i_s;
int i;
UINT8 app_op_param_type_delimit = 0;
if (p_prop->parameters != 0)
{
APP_OP_GET_PARAM(p_prop->parameters, i_e, i_c, i_s);
/* add encoding parameter */
if (app_op_encodings[i_e].p_name != NULL)
{
*p++ = ';';
BCM_STRCPY_S((char *) p, APP_OP_REM_MEMORY, app_op_encoding);
p += APP_OP_ENCODING_LEN;
BCM_STRCPY_S((char *) p, APP_OP_REM_MEMORY, app_op_encodings[i_e].p_name);
p += app_op_encodings[i_e].len - APP_OP_ENCODING_LEN - 1;
}
/* add character set parameter */
if (app_op_charsets[i_c].p_name != NULL)
{
*p++ = ';';
BCM_STRCPY_S((char *) p, APP_OP_REM_MEMORY, app_op_charset);
p += APP_OP_CHARSET_LEN;
BCM_STRCPY_S((char *) p, APP_OP_REM_MEMORY, app_op_charsets[i_c].p_name);
p += app_op_charsets[i_c].len - APP_OP_CHARSET_LEN - 1;
}
/* add any property-specific parameters */
if (p_tbl[p_prop->name].p_param_tbl != NULL)
{
for (i = 1; (i_s != 0) && (i <= p_tbl[p_prop->name].p_param_tbl[0].len); i++)
{
if (i_s & 1)
{
if (app_op_param_type_delimit)
{
*p++ = ',';
}
else
{
*p++ = ';';
if (fmt == APP_OP_VCARD30_FMT)
{
BCM_STRNCPY_S((char *) p, APP_OP_PARAM_TYPE_HDR_LEN+1, app_op_param_type_hdr, APP_OP_PARAM_TYPE_HDR_LEN);
p += APP_OP_PARAM_TYPE_HDR_LEN;
app_op_param_type_delimit++;
}
}
BCM_STRCPY_S((char *) p, APP_OP_REM_MEMORY, p_tbl[p_prop->name].p_param_tbl[i].p_name);
p += p_tbl[p_prop->name].p_param_tbl[i].len - 1;
}
i_s >>= 1;
}
}
}
/*******************************************************************************
**
** Function NFA_HciDeregister
**
** Description This function is called to deregister an application
** from HCI. The app will be notified by NFA_HCI_DEREGISTER_EVT
** after deleting all the pipes owned by the app and deallocating
** all the gates allocated to the app or if an error occurs.
** Even if deregistration fails, the app has to register again
** to provide a new cback function.
**
** Returns NFA_STATUS_OK if the application is deregistered successfully
** NFA_STATUS_FAILED otherwise
*******************************************************************************/
tNFA_STATUS NFA_HciDeregister (char *p_app_name)
{
tNFA_HCI_API_DEREGISTER_APP *p_msg;
int xx;
UINT8 app_name_len;
if (p_app_name == NULL)
{
NFA_TRACE_API0 ("NFA_HciDeregister (): Invalid Application");
return (NFA_STATUS_FAILED);
}
NFA_TRACE_API1 ("NFA_HciDeregister (): Application Name: %s", p_app_name);
app_name_len = (UINT8) strlen (p_app_name);
if (app_name_len > NFA_MAX_HCI_APP_NAME_LEN)
return (NFA_STATUS_FAILED);
/* Find the application registration */
for (xx = 0; xx < NFA_HCI_MAX_APP_CB; xx++)
{
if ( (nfa_hci_cb.cfg.reg_app_names[xx][0] != 0)
&&(!strncmp (p_app_name, &nfa_hci_cb.cfg.reg_app_names[xx][0], app_name_len)) )
break;
}
if (xx == NFA_HCI_MAX_APP_CB)
{
NFA_TRACE_ERROR1 ("NFA_HciDeregister (): Application Name: %s NOT FOUND", p_app_name);
return (NFA_STATUS_FAILED);
}
/* Deregister the application with HCI */
if ( (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
&&((p_msg = (tNFA_HCI_API_DEREGISTER_APP *) GKI_getbuf (sizeof (tNFA_HCI_API_DEREGISTER_APP))) != NULL) )
{
p_msg->hdr.event = NFA_HCI_API_DEREGISTER_APP_EVT;
memset (p_msg->app_name, 0, sizeof (p_msg->app_name));
BCM_STRNCPY_S (p_msg->app_name, sizeof (p_msg->app_name), p_app_name, NFA_MAX_HCI_APP_NAME_LEN);
nfa_sys_sendmsg (p_msg);
return (NFA_STATUS_OK);
}
return (NFA_STATUS_FAILED);
}
/*******************************************************************************
**
** Function NFA_P2pConnectByName
**
** Description This function is called to create a connection-oriented transport
** by a service name.
** NFA_P2P_CONNECTED_EVT if success
** NFA_P2P_DISC_EVT if failed
**
** Returns NFA_STATUS_OK if successfully initiated
** NFA_STATUS_BAD_HANDLE if client is not registered
** NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_P2pConnectByName (tNFA_HANDLE client_handle,
char *p_service_name,
UINT16 miu,
UINT8 rw)
{
tNFA_P2P_API_CONNECT *p_msg;
tNFA_HANDLE xx;
P2P_TRACE_API4 ("NFA_P2pConnectByName (): client_handle:0x%x, SN:<%s>, MIU:%d, RW:%d",
client_handle, p_service_name, miu, rw);
xx = client_handle & NFA_HANDLE_MASK;
if ( (xx >= NFA_P2P_NUM_SAP)
||(nfa_p2p_cb.sap_cb[xx].p_cback == NULL) )
{
P2P_TRACE_ERROR0 ("NFA_P2pConnectByName (): Client Handle is not valid");
return (NFA_STATUS_BAD_HANDLE);
}
if ( (miu < LLCP_DEFAULT_MIU)
||(nfa_p2p_cb.llcp_state != NFA_P2P_LLCP_STATE_ACTIVATED)
||(nfa_p2p_cb.local_link_miu < miu) )
{
P2P_TRACE_ERROR3 ("NFA_P2pConnectByName (): MIU(%d) must be between %d and %d or LLCP link is not activated",
miu, LLCP_DEFAULT_MIU, nfa_p2p_cb.local_link_miu);
}
else if ((p_msg = (tNFA_P2P_API_CONNECT *) GKI_getbuf (sizeof (tNFA_P2P_API_CONNECT))) != NULL)
{
p_msg->hdr.event = NFA_P2P_API_CONNECT_EVT;
BCM_STRNCPY_S (p_msg->service_name, sizeof (p_msg->service_name), p_service_name, LLCP_MAX_SN_LEN);
p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
p_msg->dsap = LLCP_INVALID_SAP;
p_msg->miu = miu;
p_msg->rw = rw;
p_msg->client_handle = client_handle;
nfa_sys_sendmsg (p_msg);
return (NFA_STATUS_OK);
}
return (NFA_STATUS_FAILED);
}
/*******************************************************************************
**
** Function NFA_P2pRegisterServer
**
** Description This function is called to listen to a SAP as server on LLCP.
**
** NFA_P2P_REG_SERVER_EVT will be returned with status and handle.
**
** If server_sap is set to NFA_P2P_ANY_SAP, then NFA will allocate
** a SAP between LLCP_LOWER_BOUND_SDP_SAP and LLCP_UPPER_BOUND_SDP_SAP
** Otherwise, server_sap must be between (LLCP_SDP_SAP + 1) and
** LLCP_UPPER_BOUND_SDP_SAP
**
** link_type : NFA_P2P_LLINK_TYPE and/or NFA_P2P_DLINK_TYPE
**
** Note: If RF discovery is started, NFA_StopRfDiscovery()/NFA_RF_DISCOVERY_STOPPED_EVT
** should happen before calling this function
**
** Returns NFA_STATUS_OK if successfully initiated
** NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_P2pRegisterServer (UINT8 server_sap,
tNFA_P2P_LINK_TYPE link_type,
char *p_service_name,
tNFA_P2P_CBACK *p_cback)
{
tNFA_P2P_API_REG_SERVER *p_msg;
P2P_TRACE_API3 ("NFA_P2pRegisterServer (): server_sap:0x%02x, link_type:0x%x, SN:<%s>",
server_sap, link_type, p_service_name);
if ( (server_sap != NFA_P2P_ANY_SAP)
&&((server_sap <= LLCP_SAP_SDP) ||(server_sap > LLCP_UPPER_BOUND_SDP_SAP)) )
{
P2P_TRACE_ERROR2 ("NFA_P2pRegisterServer (): server_sap must be between %d and %d",
LLCP_SAP_SDP + 1, LLCP_UPPER_BOUND_SDP_SAP);
return (NFA_STATUS_FAILED);
}
else if ( ((link_type & NFA_P2P_LLINK_TYPE) == 0x00)
&&((link_type & NFA_P2P_DLINK_TYPE) == 0x00) )
{
P2P_TRACE_ERROR1 ("NFA_P2pRegisterServer(): link type (0x%x) must be specified", link_type);
return (NFA_STATUS_FAILED);
}
if ((p_msg = (tNFA_P2P_API_REG_SERVER *) GKI_getbuf (sizeof (tNFA_P2P_API_REG_SERVER))) != NULL)
{
p_msg->hdr.event = NFA_P2P_API_REG_SERVER_EVT;
p_msg->server_sap = server_sap;
p_msg->link_type = link_type;
BCM_STRNCPY_S (p_msg->service_name, sizeof (p_msg->service_name), p_service_name, LLCP_MAX_SN_LEN);
p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
p_msg->p_cback = p_cback;
nfa_sys_sendmsg (p_msg);
return (NFA_STATUS_OK);
}
return (NFA_STATUS_FAILED);
}
/*******************************************************************************
**
** Function BTA_AvRegister
**
** Description Register the audio or video service to stack. When the
** operation is complete the callback function will be
** called with a BTA_AV_REGISTER_EVT. This function must
** be called before AVDT stream is open.
**
**
** Returns void
**
*******************************************************************************/
void BTA_AvRegister(tBTA_AV_CHNL chnl, const char *p_service_name, UINT8 app_id, tBTA_AV_DATA_CBACK *p_data_cback, tBTA_AV_CO_FUNCTS *bta_av_cos)
{
tBTA_AV_API_REG *p_buf;
if ((p_buf = (tBTA_AV_API_REG *) GKI_getbuf(sizeof(tBTA_AV_API_REG))) != NULL) {
p_buf->hdr.layer_specific = chnl;
p_buf->hdr.event = BTA_AV_API_REGISTER_EVT;
if (p_service_name) {
BCM_STRNCPY_S(p_buf->p_service_name, sizeof(p_buf->p_service_name), p_service_name, BTA_SERVICE_NAME_LEN);
p_buf->p_service_name[BTA_SERVICE_NAME_LEN - 1] = 0;
} else {
p_buf->p_service_name[0] = 0;
}
p_buf->app_id = app_id;
p_buf->p_app_data_cback = p_data_cback;
p_buf->bta_av_cos = bta_av_cos;
bta_sys_sendmsg(p_buf);
}
}
/*******************************************************************************
**
** Function NFA_HciRegister
**
** Description This function will register an application with hci and
** returns an application handle and provides a mechanism to
** register a callback with HCI to receive NFA HCI event notification.
** When the application is registered (or if an error occurs),
** the app will be notified with NFA_HCI_REGISTER_EVT. Previous
** session information including allocated gates, created pipes
** and pipes states will be returned as part of tNFA_HCI_REGISTER data.
**
** Returns NFA_STATUS_OK if successfully initiated
** NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_HciRegister (char *p_app_name, tNFA_HCI_CBACK *p_cback, BOOLEAN b_send_conn_evts)
{
tNFA_HCI_API_REGISTER_APP *p_msg;
UINT8 app_name_len;
if (p_app_name == NULL)
{
NFA_TRACE_API0 ("NFA_HciRegister (): Invalid Application name");
return (NFA_STATUS_FAILED);
}
if (p_cback == NULL)
{
NFA_TRACE_API0 ("NFA_HciRegister (): Application should provide callback function to register!");
return (NFA_STATUS_FAILED);
}
NFA_TRACE_API1 ("NFA_HciRegister (): Application Name: %s", p_app_name);
app_name_len = (UINT8) strlen (p_app_name);
/* Register the application with HCI */
if ( (nfa_hci_cb.hci_state != NFA_HCI_STATE_DISABLED)
&&(p_app_name != NULL)
&&(app_name_len <= NFA_MAX_HCI_APP_NAME_LEN)
&&((p_msg = (tNFA_HCI_API_REGISTER_APP *) GKI_getbuf (sizeof (tNFA_HCI_API_REGISTER_APP))) != NULL))
{
p_msg->hdr.event = NFA_HCI_API_REGISTER_APP_EVT;
/* Save application name and callback */
memset (p_msg->app_name, 0, sizeof (p_msg->app_name));
BCM_STRNCPY_S (p_msg->app_name, sizeof (p_msg->app_name), p_app_name, NFA_MAX_HCI_APP_NAME_LEN);
p_msg->p_cback = p_cback;
p_msg->b_send_conn_evts = b_send_conn_evts;
nfa_sys_sendmsg (p_msg);
return (NFA_STATUS_OK);
}
return (NFA_STATUS_FAILED);
}
/*******************************************************************************
**
** Function NFA_SnepConnect
**
** Description This function is called by client to create data link connection
** to SNEP server on peer device.
**
** Client handle and service name of server to connect shall be provided.
** A conn_handle will be returned in NFA_SNEP_CONNECTED_EVT, if
** successfully connected. Otherwise NFA_SNEP_DISC_EVT will be returned.
**
** Returns NFA_STATUS_OK if successfully initiated
** NFA_STATUS_BAD_HANDLE if handle is not valid
** NFA_STATUS_INVALID_PARAM if p_service_name or p_cback is NULL
** NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_SnepConnect (tNFA_HANDLE client_handle,
char *p_service_name)
{
tNFA_SNEP_API_CONNECT *p_msg;
tNFA_HANDLE xx;
SNEP_TRACE_API1 ("NFA_SnepConnect(): client_handle:0x%X", client_handle);
xx = client_handle & NFA_HANDLE_MASK;
if ( (xx >= NFA_SNEP_MAX_CONN)
||(nfa_snep_cb.conn[xx].p_cback == NULL)
||(!(nfa_snep_cb.conn[xx].flags & NFA_SNEP_FLAG_CLIENT)) )
{
SNEP_TRACE_ERROR0 ("NFA_SnepConnect (): Client handle is invalid");
return (NFA_STATUS_BAD_HANDLE);
}
if (p_service_name == NULL)
{
SNEP_TRACE_ERROR0 ("NFA_SnepConnect (): p_service_name is NULL");
return (NFA_STATUS_INVALID_PARAM);
}
if ((p_msg = (tNFA_SNEP_API_CONNECT*) GKI_getbuf (sizeof (tNFA_SNEP_API_CONNECT))) != NULL)
{
p_msg->hdr.event = NFA_SNEP_API_CONNECT_EVT;
p_msg->client_handle = client_handle;
BCM_STRNCPY_S (p_msg->service_name, sizeof (p_msg->service_name),
p_service_name, LLCP_MAX_SN_LEN);
p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
nfa_sys_sendmsg (p_msg);
return (NFA_STATUS_OK);
}
return (NFA_STATUS_FAILED);
}
/*******************************************************************************
**
** Function BTA_HfClientRegister
**
** Description Register an HF Client service.
**
**
** Returns void
**
*******************************************************************************/
BTA_API void BTA_HfClientRegister(tBTA_SEC sec_mask, tBTA_HF_CLIENT_FEAT features,
char *p_service_name)
{
tBTA_HF_CLIENT_API_REGISTER *p_buf;
if ((p_buf = (tBTA_HF_CLIENT_API_REGISTER *) GKI_getbuf(sizeof(tBTA_HF_CLIENT_API_REGISTER))) != NULL)
{
p_buf->hdr.event = BTA_HF_CLIENT_API_REGISTER_EVT;
p_buf->features = features;
p_buf->sec_mask = sec_mask;
if(p_service_name)
{
BCM_STRNCPY_S(p_buf->name, BTA_SERVICE_NAME_LEN+1, p_service_name, BTA_SERVICE_NAME_LEN);
p_buf->name[BTA_SERVICE_NAME_LEN] = 0;
}
else
{
p_buf->name[0] = '\0';
}
bta_sys_sendmsg(p_buf);
}
}
/*******************************************************************************
**
** Function NFA_P2pGetRemoteSap
**
** Description This function is called to get SAP associated by service name
** on connected remote LLCP.
** NFA_P2P_SDP_EVT will be returned.
**
** Returns NFA_STATUS_OK if successfully initiated
** NFA_STATUS_BAD_HANDLE if server or client is not registered
** NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_P2pGetRemoteSap (tNFA_HANDLE handle,
char *p_service_name)
{
tNFA_P2P_API_GET_REMOTE_SAP *p_msg;
tNFA_HANDLE xx;
P2P_TRACE_API2 ("NFA_P2pGetRemoteSap(): handle:0x%x, SN:<%s>", handle, p_service_name);
if (nfa_p2p_cb.llcp_state != NFA_P2P_LLCP_STATE_ACTIVATED)
{
P2P_TRACE_ERROR0 ("NFA_P2pGetRemoteSap(): LLCP link is not activated");
return (NFA_STATUS_FAILED);
}
xx = handle & NFA_HANDLE_MASK;
if ( (xx >= NFA_P2P_NUM_SAP)
||(nfa_p2p_cb.sap_cb[xx].p_cback == NULL) )
{
P2P_TRACE_ERROR0 ("NFA_P2pGetRemoteSap (): Handle is invalid or not registered");
return (NFA_STATUS_BAD_HANDLE);
}
if ((p_msg = (tNFA_P2P_API_GET_REMOTE_SAP *) GKI_getbuf (sizeof (tNFA_P2P_API_GET_REMOTE_SAP))) != NULL)
{
p_msg->hdr.event = NFA_P2P_API_GET_REMOTE_SAP_EVT;
p_msg->handle = handle;
BCM_STRNCPY_S (p_msg->service_name, sizeof (p_msg->service_name), p_service_name, LLCP_MAX_SN_LEN);
p_msg->service_name[LLCP_MAX_SN_LEN] = 0;
nfa_sys_sendmsg (p_msg);
return (NFA_STATUS_OK);
}
return (NFA_STATUS_FAILED);
}
/*******************************************************************************
**
** Function AVDT_SendReport
**
** Description
**
**
**
** Returns
**
*******************************************************************************/
UINT16 AVDT_SendReport(UINT8 handle, AVDT_REPORT_TYPE type,
tAVDT_REPORT_DATA *p_data)
{
tAVDT_SCB *p_scb;
UINT16 result = AVDT_BAD_PARAMS;
BT_HDR *p_pkt;
tAVDT_TC_TBL *p_tbl;
UINT8 *p, *plen, *pm1, *p_end;
#if AVDT_MULTIPLEXING == TRUE
UINT8 *p_al = NULL, u;
#endif
UINT32 ssrc;
UINT16 len;
/* map handle to scb && verify parameters */
if (((p_scb = avdt_scb_by_hdl(handle)) != NULL)
&& (p_scb->p_ccb != NULL)
&& (((type == AVDT_RTCP_PT_SR) && (p_scb->cs.tsep == AVDT_TSEP_SRC)) ||
((type == AVDT_RTCP_PT_RR) && (p_scb->cs.tsep == AVDT_TSEP_SNK)) ||
(type == AVDT_RTCP_PT_SDES)) ) {
result = AVDT_NO_RESOURCES;
/* build SR - assume fit in one packet */
p_tbl = avdt_ad_tc_tbl_by_type(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb);
if ((p_tbl->state == AVDT_AD_ST_OPEN) &&
(p_pkt = (BT_HDR *)GKI_getbuf(p_tbl->peer_mtu)) != NULL) {
p_pkt->offset = L2CAP_MIN_OFFSET;
p = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
#if AVDT_MULTIPLEXING == TRUE
if (p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX) {
/* Adaptation Layer header later */
p_al = p;
p += 2;
}
#endif
pm1 = p;
*p++ = AVDT_MEDIA_OCTET1 | 1;
*p++ = type;
/* save the location for length */
plen = p;
p += 2;
ssrc = avdt_scb_gen_ssrc(p_scb);
UINT32_TO_BE_STREAM(p, ssrc);
switch (type) {
case AVDT_RTCP_PT_SR: /* Sender Report */
*pm1 = AVDT_MEDIA_OCTET1;
UINT32_TO_BE_STREAM(p, p_data->sr.ntp_sec);
UINT32_TO_BE_STREAM(p, p_data->sr.ntp_frac);
UINT32_TO_BE_STREAM(p, p_data->sr.rtp_time);
UINT32_TO_BE_STREAM(p, p_data->sr.pkt_count);
UINT32_TO_BE_STREAM(p, p_data->sr.octet_count);
break;
case AVDT_RTCP_PT_RR: /* Receiver Report */
*p++ = p_data->rr.frag_lost;
AVDT_TRACE_API("packet_lost: %d\n", p_data->rr.packet_lost);
p_data->rr.packet_lost &= 0xFFFFFF;
AVDT_TRACE_API("packet_lost: %d\n", p_data->rr.packet_lost);
UINT24_TO_BE_STREAM(p, p_data->rr.packet_lost);
UINT32_TO_BE_STREAM(p, p_data->rr.seq_num_rcvd);
UINT32_TO_BE_STREAM(p, p_data->rr.jitter);
UINT32_TO_BE_STREAM(p, p_data->rr.lsr);
UINT32_TO_BE_STREAM(p, p_data->rr.dlsr);
break;
case AVDT_RTCP_PT_SDES: /* Source Description */
*p++ = AVDT_RTCP_SDES_CNAME;
len = strlen((char *)p_data->cname);
if (len > AVDT_MAX_CNAME_SIZE) {
len = AVDT_MAX_CNAME_SIZE;
}
*p++ = (UINT8)len;
BCM_STRNCPY_S((char *)p, len + 1, (char *)p_data->cname, len + 1);
p += len;
break;
}
p_end = p;
len = p - pm1 - 1;
UINT16_TO_BE_STREAM(plen, len);
#if AVDT_MULTIPLEXING == TRUE
if (p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX) {
/* Adaptation Layer header */
p = p_al;
len++;
UINT16_TO_BE_STREAM(p_al, len );
/* TSID, no-fragment bit and coding of length(9-bit length field) */
u = *p;
*p = (p_scb->curr_cfg.mux_tsid_report << 3) | AVDT_ALH_LCODE_9BITM0;
if (u) {
*p |= AVDT_ALH_LCODE_9BITM1;
}
}
#endif
/* set the actual payload length */
p_pkt->len = p_end - p;
/* send the packet */
if (L2CAP_DW_FAILED != avdt_ad_write_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb, p_pkt)) {
result = AVDT_SUCCESS;
}
}
}
return result;
}
/*******************************************************************************
**
** Function btm_sec_alloc_dev
**
** Description Look for the record in the device database for the record
** with specified handle
**
** Returns Pointer to the record
**
*******************************************************************************/
tBTM_SEC_DEV_REC *btm_sec_alloc_dev (BD_ADDR bd_addr)
{
tBTM_SEC_DEV_REC *p_dev_rec = NULL;
tBTM_INQ_INFO *p_inq_info;
int i;
BTM_TRACE_EVENT0 ("btm_sec_alloc_dev");
for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++)
{
if (!(btm_cb.sec_dev_rec[i].sec_flags & BTM_SEC_IN_USE))
{
p_dev_rec = &btm_cb.sec_dev_rec[i];
break;
}
}
if (!p_dev_rec)
p_dev_rec = btm_find_oldest_dev();
memset (p_dev_rec, 0, sizeof (tBTM_SEC_DEV_REC));
p_dev_rec->sec_flags = BTM_SEC_IN_USE;
/* Check with the BT manager if details about remote device are known */
/* outgoing connection */
if ((p_inq_info = BTM_InqDbRead(bd_addr)) != NULL)
{
memcpy (p_dev_rec->dev_class, p_inq_info->results.dev_class, DEV_CLASS_LEN);
#if BLE_INCLUDED == TRUE
p_dev_rec->device_type = p_inq_info->results.device_type;
p_dev_rec->ble.ble_addr_type = p_inq_info->results.ble_addr_type;
/* update conn params, use default value for background connection params */
memset(&p_dev_rec->conn_params, 0xff, sizeof(tBTM_LE_CONN_PRAMS));
#endif
#if BTM_INQ_GET_REMOTE_NAME == TRUE
if (p_inq_info->remote_name_state == BTM_INQ_RMT_NAME_DONE)
{
BCM_STRNCPY_S ((char *)p_dev_rec->sec_bd_name, sizeof (p_dev_rec->sec_bd_name),
(char *)p_inq_info->remote_name, BTM_MAX_REM_BD_NAME_LEN);
p_dev_rec->sec_flags |= BTM_SEC_NAME_KNOWN;
}
#endif
}
else
{
#if BLE_INCLUDED == TRUE
/* update conn params, use default value for background connection params */
memset(&p_dev_rec->conn_params, 0xff, sizeof(tBTM_LE_CONN_PRAMS));
#endif
if (!memcmp (bd_addr, btm_cb.connecting_bda, BD_ADDR_LEN))
memcpy (p_dev_rec->dev_class, btm_cb.connecting_dc, DEV_CLASS_LEN);
}
memcpy (p_dev_rec->bd_addr, bd_addr, BD_ADDR_LEN);
p_dev_rec->hci_handle = BTM_GetHCIConnHandle (bd_addr);
p_dev_rec->timestamp = btm_cb.dev_rec_count++;
p_dev_rec->pin_key_len = 0;
return(p_dev_rec);
}
/*******************************************************************************
**
** Function BTM_SecAddDevice
**
** Description Add/modify device. This function will be normally called
** during host startup to restore all required information
** stored in the NVRAM.
**
** Parameters: bd_addr - BD address of the peer
** dev_class - Device Class
** bd_name - Name of the peer device. NULL if unknown.
** features - Remote device's features (up to 3 pages). NULL if not known
** trusted_mask - Bitwise OR of services that do not
** require authorization. (array of UINT32)
** link_key - Connection link key. NULL if unknown.
** pin_len - length of pin key
**
** Returns TRUE if added OK, else FALSE
**
*******************************************************************************/
BOOLEAN BTM_SecAddDevice (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name,
UINT8 *features, UINT32 trusted_mask[],
LINK_KEY link_key, UINT8 key_type, tBTM_IO_CAP io_cap, UINT8 pin_len)
{
tBTM_SEC_DEV_REC *p_dev_rec;
int i, j;
BOOLEAN found = FALSE;
p_dev_rec = btm_find_dev (bd_addr);
if (!p_dev_rec)
{
/* There is no device record, allocate one.
* If we can not find an empty spot for this one, let it fail. */
for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++)
{
if (!(btm_cb.sec_dev_rec[i].sec_flags & BTM_SEC_IN_USE))
{
p_dev_rec = &btm_cb.sec_dev_rec[i];
/* Mark this record as in use and initialize */
memset (p_dev_rec, 0, sizeof (tBTM_SEC_DEV_REC));
p_dev_rec->sec_flags = BTM_SEC_IN_USE;
memcpy (p_dev_rec->bd_addr, bd_addr, BD_ADDR_LEN);
p_dev_rec->hci_handle = BTM_GetHCIConnHandle (bd_addr);
#if BLE_INCLUDED == TRUE
/* use default value for background connection params */
/* update conn params, use default value for background connection params */
memset(&p_dev_rec->conn_params, 0xff, sizeof(tBTM_LE_CONN_PRAMS));
#endif
break;
}
}
if (!p_dev_rec)
return(FALSE);
}
p_dev_rec->timestamp = btm_cb.dev_rec_count++;
if (dev_class)
memcpy (p_dev_rec->dev_class, dev_class, DEV_CLASS_LEN);
memset(p_dev_rec->sec_bd_name, 0, sizeof(tBTM_BD_NAME));
if (bd_name && bd_name[0])
{
p_dev_rec->sec_flags |= BTM_SEC_NAME_KNOWN;
BCM_STRNCPY_S ((char *)p_dev_rec->sec_bd_name, sizeof (p_dev_rec->sec_bd_name),
(char *)bd_name, BTM_MAX_REM_BD_NAME_LEN);
}
p_dev_rec->num_read_pages = 0;
if (features)
{
memcpy (p_dev_rec->features, features, sizeof (p_dev_rec->features));
for (i = HCI_EXT_FEATURES_PAGE_MAX; i >= 0; i--)
{
for (j = 0; j < HCI_FEATURE_BYTES_PER_PAGE; j++)
{
if (p_dev_rec->features[i][j] != 0)
{
found = TRUE;
break;
}
}
if (found)
{
p_dev_rec->num_read_pages = i + 1;
break;
}
}
}
else
memset (p_dev_rec->features, 0, sizeof (p_dev_rec->features));
BTM_SEC_COPY_TRUSTED_DEVICE(trusted_mask, p_dev_rec->trusted_mask);
if (link_key)
{
BTM_TRACE_EVENT6 ("BTM_SecAddDevice() BDA: %02x:%02x:%02x:%02x:%02x:%02x",
bd_addr[0], bd_addr[1], bd_addr[2],
bd_addr[3], bd_addr[4], bd_addr[5]);
p_dev_rec->sec_flags |= BTM_SEC_LINK_KEY_KNOWN;
memcpy (p_dev_rec->link_key, link_key, LINK_KEY_LEN);
p_dev_rec->link_key_type = key_type;
}
p_dev_rec->pin_key_len = pin_len;
#if defined(BTIF_MIXED_MODE_INCLUDED) && (BTIF_MIXED_MODE_INCLUDED == TRUE)
if (key_type < BTM_MAX_PRE_SM4_LKEY_TYPE)
p_dev_rec->sm4 = BTM_SM4_KNOWN;
else
p_dev_rec->sm4 = BTM_SM4_TRUE;
#endif
p_dev_rec->rmt_io_caps = io_cap;
return(TRUE);
}
