/*****************************************************************************
NAME
headsetHandleIoCapabilityInd
DESCRIPTION
This function is called on receipt on an CL_SM_IO_CAPABILITY_REQ_IND
RETURNS
void
*/
void headsetHandleIoCapabilityInd(const CL_SM_IO_CAPABILITY_REQ_IND_T* ind)
{
/* Only send IO capabilities if we are pairable */
if (AuthCanHeadsetPair())
{
cl_sm_io_capability local_io_caps = cl_sm_io_cap_display_yes_no;/*cl_sm_io_cap_no_input_no_output;*/
AUTH_DEBUG(("auth: sending IO capability\n"));
ConnectionSmIoCapabilityResponse(&ind->bd_addr, local_io_caps, FALSE, TRUE, FALSE, 0, 0);
}
else /* send a reject response */
{
AUTH_DEBUG(("auth: rejecting IO capability req\n"));
ConnectionSmIoCapabilityResponse(&ind->bd_addr, cl_sm_reject_request, FALSE, FALSE, FALSE, 0, 0);
}
}
void ConnectionSmIoCapabilityResponseTestExtraDefault(
bdaddr* bd_addr,
cl_sm_io_capability io_capability,
bool force_mitm,
bool bonding
)
{
ConnectionSmIoCapabilityResponse(
bd_addr,
io_capability,
force_mitm,
bonding,
0,
0,
0
);
}
void ConnectionSmIoCapabilityResponseTestExtra(
uint8 type,
bdaddr* bd_addr,
uint16 transport,
cl_sm_io_capability io_capability,
uint16 mitm,
bool bonding,
uint16 key_distribution,
uint16 oob_setting,
uint8 size_oob_data,
uint8* oob_data
)
{
tp_bdaddr tpaddr;
uint16 rand_r_offset = 0;
uint8 *rand_r_ptr = NULL;
tpaddr.transport = (TRANSPORT_T)transport;
tpaddr.taddr.type = type;
tpaddr.taddr.addr = *bd_addr;
if (oob_setting & oob_data_p256)
rand_r_offset += CL_SIZE_OOB_DATA;
if (
transport == TRANSPORT_BREDR_ACL &&
(oob_setting & oob_data_p192)
)
rand_r_offset += CL_SIZE_OOB_DATA;
if (rand_r_offset)
rand_r_ptr = oob_data + rand_r_offset;
ConnectionSmIoCapabilityResponse(
&tpaddr,
io_capability,
mitm,
bonding,
key_distribution,
oob_setting,
oob_data,
rand_r_ptr
);
}
void ConnectionSmIoCapabilityResponseTestExtra(
bdaddr* bd_addr,
cl_sm_io_capability io_capability,
bool force_mitm,
bool bonding,
uint8 size_oob_data,
uint8* oob_data
)
{
ConnectionSmIoCapabilityResponse(
bd_addr,
io_capability,
force_mitm,
bonding,
TRUE,
oob_data,
oob_data + CL_SIZE_OOB_DATA
);
}
void ConnectionSmIoCapabilityResponseTestExtraDefault(
bdaddr* bd_addr,
cl_sm_io_capability io_capability,
uint16 mitm,
bool bonding
)
{
tp_bdaddr tpaddr;
tpaddr.taddr.type = TYPED_BDADDR_PUBLIC;
tpaddr.taddr.addr = *bd_addr;
tpaddr.transport = TRANSPORT_BREDR_ACL;
ConnectionSmIoCapabilityResponse(
&tpaddr,
io_capability,
mitm,
bonding,
0, /* Key distribution */
0, /* OOB Data setting */
0, /* OOB HASH_C */
0 /* OOB RAND_R */
);
}
/* Task handler function */
void BtTaskHandler(Task task, MessageId id, Message message)
{
sppDevState state = btApp.spp_state;
switch(id)
{
case CL_INIT_CFM:
DEBUG(("CL_INIT_CFM\n"));
if(((CL_INIT_CFM_T*)message)->status == success)
{
/* Connection Library initialisation was a success */
/*sppDevInit(); */
spp_init_params init;
init.client_recipe = 0;
init.size_service_record = 0;
init.service_record = 0;
init.no_service_record = 0;
/* Initialise the spp profile lib, stating that this is device B */
SppInitLazy(&btApp.task, &btApp.task, &init);
}
/*else
Some reset function*/
break;
case CL_DM_LINK_SUPERVISION_TIMEOUT_IND:
DEBUG(("CL_DM_LINK_SUPERVISION_TIMEOUT_IND\n"));
break;
case CL_DM_SNIFF_SUB_RATING_IND:
DEBUG(("CL_DM_SNIFF_SUB_RATING_IND\n"));
break;
case SPP_INIT_CFM:
DEBUG(("SPP_INIT_CFM\n"));
switch(state)
{
case sppDevInitialising:
/* Check for spp_init_success. What do we do if it failed? */
if (((SPP_INIT_CFM_T *) message)->status == spp_init_success)
{
setSppState(sppDevReady);
/* Turn off security */
ConnectionSmRegisterIncomingService(0x0000, 0x0001, 0x0000);
/* Write class of device */
ConnectionWriteClassOfDevice(0x1F00);
/* Start Inquiry mode */
setSppState(sppDevPairable);
/* Set devB device to inquiry scan mode, waiting for discovery */
ConnectionWriteInquiryscanActivity(0x400, 0x200);
ConnectionSmSetSdpSecurityIn(TRUE);
/* Make this device discoverable (inquiry scan), and connectable (page scan) */
ConnectionWriteScanEnable(hci_scan_enable_inq_and_page);
}
break;
case sppDevReady:
case sppDevPairable:
case sppDevConnecting:
case sppDevConnected:
default:
DEBUG(("SPP_INIT_CFM unhandled: state = %d, id = %d\n", state, id));
break;
}
break;
case SPP_CONNECT_CFM:
{
SPP_CONNECT_CFM_T *cfm = (SPP_CONNECT_CFM_T *) message;
DEBUG(("SPP_CONNECT_CFM result = %d\n", cfm->status));
switch(state)
{
case sppDevConnecting:
/* Connect cfm, but must check status as connection may have failed */
if (cfm->status == rfcomm_connect_success)
{
/* Connection Success */
DEBUG(("Device connected...\n"));
/* Connect Uart to Rfcomm */
/*(void) StreamConnect(StreamUartSource(), cfm->sink);
(void) StreamConnect(StreamSourceFromSink(cfm->sink), StreamUartSink());*/
/* (void) StreamConnectDispose(StreamSourceFromSink(cfm->sink)); */
btApp.spp = cfm->spp;
btApp.sink = cfm->sink;
setSppState(sppDevConnected);
ConnectionWriteScanEnable(hci_scan_enable_off);
}
else
{
/* Connection failed */
setSppState(sppDevPairable);
DEBUG(("Connection failed\n"));
}
break;
case sppDevPairable:
/* Connect cfm, but must check status as connection may have failed */
if (cfm->status == rfcomm_connect_success)
{
/* Device has been reset to pairable mode. Disconnect from current device */
SppDisconnect(cfm->spp);
}
break;
case sppDevInitialising:
case sppDevReady:
case sppDevConnected:
default:
DEBUG(("SPP_CONNECT_CFM unhandled: state = %d, id = %d\n", state, id));
break;
}
}
break;
case SPP_CONNECT_IND:
{
DEBUG(("SPP_CONNECT_IND\n"));
/*CAST_TYPED_MSG(SPP_CONNECT_IND, ind, message);*/
switch(state)
{
case sppDevPairable:
/* Received command that a device is trying to connect. Send response. */
SppConnectResponseLazy(((SPP_CONNECT_IND_T*)message)->spp, TRUE, &((SPP_CONNECT_IND_T*)message)->addr, 1, FRAME_SIZE);
/*sppDevAuthoriseConnectInd(btApp,(SPP_CONNECT_IND_T*)message);*/
setSppState(sppDevConnecting);
break;
case sppDevInitialising:
case sppDevConnecting:
case sppDevReady:
case sppDevConnected:
default:
DEBUG(("SPP_CONNECT_IND unhandled: state = %d, id = %d\n", state, id));
break;
}
}
break;
case SPP_DISCONNECT_IND:
DEBUG(("SPP_DISCONNECT_IND\n"));
/* Disconnect message has arrived */
switch(state)
{
case sppDevConnected:
/* Turn off security */
ConnectionSmRegisterIncomingService(0x0000, 0x0001, 0x0000);
/* Write class of device */
ConnectionWriteClassOfDevice(0x1F00);
/* Start Inquiry mode */
setSppState(sppDevPairable);
/* Set devB device to inquiry scan mode, waiting for discovery */
ConnectionWriteInquiryscanActivity(0x400, 0x200);
ConnectionSmSetSdpSecurityIn(TRUE);
/* Make this device discoverable (inquiry scan), and connectable (page scan) */
ConnectionWriteScanEnable(hci_scan_enable_inq_and_page);
break;
case sppDevInitialising:
case sppDevPairable:
case sppDevConnecting:
case sppDevReady:
default:
DEBUG(("SPP_DISCONNECT_IND unhandled: state = %d, id = %d\n", state, id));
break;
}
break;
case CL_DM_ACL_OPENED_IND:
DEBUG(("CL_DM_ACL_OPENED_IND\n"));
break;
case CL_DM_ACL_CLOSED_IND:
DEBUG(("CL_DM_ACL_CLOSED_IND\n"));
break;
case CL_SM_PIN_CODE_IND:
DEBUG(("CL_SM_PIN_CODE_IND\n"));
ConnectionSmPinCodeResponse(&((CL_SM_PIN_CODE_IND_T*)message)->bd_addr, 4, (uint8*)"1234");
/*sppDevHandlePinCodeRequest((CL_SM_PIN_CODE_IND_T *) message);*/
break;
case CL_SM_AUTHORISE_IND:
DEBUG(("CL_SM_PIN_CODE_IND\n"));
/*sppDevAuthoriseResponse((CL_SM_AUTHORISE_IND_T*) message);*/
ConnectionSmAuthoriseResponse(&((CL_SM_AUTHORISE_IND_T*)message)->bd_addr,
((CL_SM_AUTHORISE_IND_T*)message)->protocol_id,
((CL_SM_AUTHORISE_IND_T*)message)->channel,
((CL_SM_AUTHORISE_IND_T*)message)->incoming,
TRUE);
break;
case CL_SM_AUTHENTICATE_CFM:
DEBUG(("CL_SM_AUTHENTICATE_CFM\n"));
/*sppDevSetTrustLevel((CL_SM_AUTHENTICATE_CFM_T*)message); */
/*CAST_TYPED_MSG(CL_SM_AUTHENTICATE_CFM, cfm, message); */
if(((CL_SM_AUTHENTICATE_CFM_T*)message)->status == auth_status_success)
{
/* Pairing success, now set the trust level*/
ConnectionSmSetTrustLevel(&((CL_SM_AUTHENTICATE_CFM_T*)message)->bd_addr, TRUE);
}
else if(((CL_SM_AUTHENTICATE_CFM_T*)message)->status == auth_status_fail)
{
DEBUG(("Pairing failed\n"));
}
break;
case CL_SM_ENCRYPTION_KEY_REFRESH_IND:
DEBUG(("CL_SM_ENCRYPTION_KEY_REFRESH_IND\n"));
break;
case CL_DM_LINK_POLICY_IND:
DEBUG(("CL_DM_LINK_POLICY_IND\n"));
break;
case CL_SM_IO_CAPABILITY_REQ_IND:
DEBUG(("CL_SM_IO_CAPABILITY_REQ_IND\n"));
ConnectionSmIoCapabilityResponse( &btApp.bd_addr,
cl_sm_io_cap_no_input_no_output,
FALSE,
TRUE,
FALSE,
0,
0 );
break;
case CL_SM_REMOTE_IO_CAPABILITY_IND:
{
CAST_TYPED_MSG(CL_SM_REMOTE_IO_CAPABILITY_IND, csricit, message);
DEBUG(("CL_SM_REMOTE_IO_CAPABILITY_REQ_IND\n"));
DEBUG(("\t Remote Addr: nap %04x uap %02x lap %08lx\n",
csricit->bd_addr.nap,
csricit->bd_addr.uap,
csricit->bd_addr.lap ));
btApp.bd_addr = csricit->bd_addr;
}
break;
case SPP_MESSAGE_MORE_DATA:
DEBUG(("SPP_MESSAGE_MORE_DATA\n"));
ParseSppData(task, ((SPP_MESSAGE_MORE_DATA_T*)message)->source);
break;
case SPP_MESSAGE_MORE_SPACE:
DEBUG(("SPP_MESSAGE_MORE_SPACE\n"));
break;
/*case BUTTON_RESET_PRESS:
DEBUG(("Button pressed\n"));
switch(btApp.spp_state)
{
case sppDevInitialising:
return;
break;
case sppDevReady:
case sppDevPairable:
case sppDevConnecting:
sppDevInquire(btApp);
break;
case sppDevConnected:
SppDisconnect(btApp.spp);
break;
}
break;*/
case CL_RFCOMM_CONTROL_IND:
DEBUG(("CL_RFCOMM_CONTROL_IND\n"));
break;
default:
/* An unexpected message has arrived - must handle it */
DEBUG(("bt app - msg type not yet handled 0x%x\n", id));
break;
}
}
/****************************************************************************
NAME
clMsgHandleLibMessage
DESCRIPTION
Handles the CL library messages and calls the relevant function.
*/
void clMsgHandleLibMessage(MessageId id, Message message)
{
switch(id)
{
case CL_INIT_CFM:
{
DEBUG_CL(("CL_INIT_CFM status = %u\n", ((CL_INIT_CFM_T *)message)->status));
handleClInitCfm((CL_INIT_CFM_T *)message);
break;
}
case CL_DM_WRITE_INQUIRY_MODE_CFM:
{
DEBUG_CL(("CL_DM_WRITE_INQUIRY_MODE_CFM\n"));
/* Read the local name to put in our EIR data */
ConnectionReadInquiryTx(&the_app->task);
break;
}
case CL_DM_READ_INQUIRY_TX_CFM:
{
the_app->inquiry_tx = ((CL_DM_READ_INQUIRY_TX_CFM_T*)message)->tx_power;
ConnectionReadLocalName(&the_app->task);
break;
}
case CL_DM_LOCAL_NAME_COMPLETE:
{
DEBUG_CL(("CL_DM_LOCAL_NAME_COMPLETE\n"));
/* Write EIR data and initialise the codec task */
scanWriteEirData((CL_DM_LOCAL_NAME_COMPLETE_T*)message);
break;
}
case CL_DM_ACL_OPENED_IND:
{
DEBUG_CL(("CL_DM_ACL_OPENED_IND from: 0x%X 0x%X 0x%lX\n", ((CL_DM_ACL_OPENED_IND_T *)message)->bd_addr.nap, ((CL_DM_ACL_OPENED_IND_T *)message)->bd_addr.uap, ((CL_DM_ACL_OPENED_IND_T *)message)->bd_addr.lap));
/* Ignore this message for now */
DEBUG_CL((" - ignored\n"));
break;
}
case CL_DM_ACL_CLOSED_IND:
{
DEBUG_CL(("CL_DM_ACL_CLOSED_IND from: 0x%X 0x%X 0x%lX\n", ((CL_DM_ACL_CLOSED_IND_T *)message)->bd_addr.nap, ((CL_DM_ACL_CLOSED_IND_T *)message)->bd_addr.uap, ((CL_DM_ACL_CLOSED_IND_T *)message)->bd_addr.lap));
/* Ignore this message for now */
DEBUG_CL((" - ignored\n"));
break;
}
case CL_SM_PIN_CODE_IND:
{
DEBUG_CL(("CL_SM_PIN_CODE_IND from: 0x%X 0x%X 0x%lX\n", (uint16)((CL_SM_PIN_CODE_IND_T *)message)->bd_addr.nap, (uint16)((CL_SM_PIN_CODE_IND_T *)message)->bd_addr.uap, (uint32)((CL_SM_PIN_CODE_IND_T *)message)->bd_addr.lap));
handleClSmPinCodeInd((CL_SM_PIN_CODE_IND_T *)message);
break;
}
case CL_SM_IO_CAPABILITY_REQ_IND:
{
DEBUG_CL(("CL_SM_IO_CAPABILITY_REQUEST_IND\n"));
{
CL_SM_IO_CAPABILITY_REQ_IND_T *prim = (CL_SM_IO_CAPABILITY_REQ_IND_T *)message;
ConnectionSmIoCapabilityResponse(&prim->bd_addr, cl_sm_io_cap_no_input_no_output, FALSE, TRUE, FALSE, NULL, NULL);
}
break;
}
case CL_SM_USER_CONFIRMATION_REQ_IND:
{
DEBUG_CL(("CL_SM_USER_CONFIRMATION_REQ_IND\n"));
/* Shouldn't get this so if we do reject it! */
ConnectionSmUserConfirmationResponse(&((CL_SM_USER_CONFIRMATION_REQ_IND_T*)message)->bd_addr, FALSE);
break;
}
case CL_SM_AUTHORISE_IND:
{
DEBUG_CL(("CL_SM_AUTHORISE_IND\n"));
{ /* For now, blindly accept this request */
CL_SM_AUTHORISE_IND_T *prim = (CL_SM_AUTHORISE_IND_T *)message;
ConnectionSmAuthoriseResponse(&prim->bd_addr, prim->protocol_id, prim->channel, prim->incoming, TRUE);
}
break;
}
case CL_SM_AUTHENTICATE_CFM:
{
DEBUG_CL(("CL_SM_AUTHENTICATE_CFM status = %u\n", ((CL_SM_AUTHENTICATE_CFM_T *)message)->status));
if ( ((CL_SM_AUTHENTICATE_CFM_T *)message)->status == auth_status_success )
{ /* Pin code will be stored on a successful SLC/A2DP connection */
}
break;
}
case CL_SM_SECURITY_LEVEL_CFM:
{
DEBUG_CL(("CL_SM_SECURITY_LEVEL_CFM success = %u\n", ((CL_SM_SECURITY_LEVEL_CFM_T *)message)->success));
break;
}
case CL_DM_INQUIRE_RESULT:
{
DEBUG_CL(("CL_DM_INQUIRE_RESULT status = %u\n", ((CL_DM_INQUIRE_RESULT_T *)message)->status));
handleClDmInquireResult((CL_DM_INQUIRE_RESULT_T *)message);
break;
}
case CL_SDP_OPEN_SEARCH_CFM:
{
DEBUG_CL(("CL_SDP_OPEN_SEARCH_CFM status = %u\n", ((CL_SDP_OPEN_SEARCH_CFM_T *)message)->status));
handleClSdpOpenSearchCfm((CL_SDP_OPEN_SEARCH_CFM_T *)message);
break;
}
case CL_SDP_CLOSE_SEARCH_CFM:
{
DEBUG_CL(("CL_SDP_CLOSE_SEARCH_CFM status = %u\n", ((CL_SDP_CLOSE_SEARCH_CFM_T *)message)->status));
handleClSdpCloseSearchCfm();
break;
}
case CL_SDP_SERVICE_SEARCH_CFM:
{
DEBUG_CL(("CL_SDP_SERVICE_SEARCH_CFM status = %u\n", ((CL_SDP_SERVICE_SEARCH_CFM_T *)message)->status));
handleClSdpServiceSearchCfm((CL_SDP_SERVICE_SEARCH_CFM_T *)message);
break;
}
case CL_SM_SEC_MODE_CONFIG_CFM:
{
DEBUG_CL(("CL_SM_SEC_MODE_CONFIG_CFM\n"));
DEBUG_CL((" - ignored\n"));
break;
}
case CL_SM_REMOTE_IO_CAPABILITY_IND:
{
DEBUG_CL(("CL_SM_REMOTE_IO_CAPABILITY_IND\n"));
DEBUG_CL((" - ignored\n"));
break;
}
case CL_DM_LINK_SUPERVISION_TIMEOUT_IND:
{
DEBUG_CL(("CL_DM_LINK_SUPERVISION_TIMEOUT_IND:\n"));
DEBUG_CL((" timeout:[0x%x] bdaddr:[0x%x%x%lx]\n",
((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->timeout,
((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->bd_addr.nap,
((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->bd_addr.uap,
((CL_DM_LINK_SUPERVISION_TIMEOUT_IND_T *)message)->bd_addr.lap));
break;
}
case CL_DM_ROLE_IND:
{
DEBUG_CL(("CL_DM_ROLE_IND\n"));
handleClRoleInd((CL_DM_ROLE_IND_T *)message);
break;
}
case CL_DM_ROLE_CFM:
{
DEBUG_CL(("CL_DM_ROLE_CFM\n"));
handleClRoleCfm((CL_DM_ROLE_CFM_T *)message);
break;
}
case CL_DM_SNIFF_SUB_RATING_IND:
{
DEBUG_CL(("CL_DM_SNIFF_SUB_RATING_IND\n"));
break;
}
case CL_DM_REMOTE_FEATURES_CFM:
{
DEBUG_CL(("CL_DM_REMOTE_FEATURES_CFM\n"));
handleClDmRemoteFeaturesConfirm((CL_DM_REMOTE_FEATURES_CFM_T *)message);
return;
}
case CL_DM_REMOTE_NAME_COMPLETE:
{
CL_DM_REMOTE_NAME_COMPLETE_T *name = (CL_DM_REMOTE_NAME_COMPLETE_T*)message;
DEBUG_CL(("CL_DM_REMOTE_NAME_COMPLETE\n"));
if(name->status == hci_success)
{
char *name_str = PanicUnlessMalloc(name->size_remote_name+1);
memcpy(name_str,name->remote_name,name->size_remote_name);
name_str[name->size_remote_name] = 0;
UartPrintf("\r\n+RNM=%s\r\n",name_str);
free(name_str);
}
else
UartPrintf("\r\nERROR\r\n");
break;
}
case CL_DM_RSSI_CFM:
{
DEBUG_CL(("CL_DM_RSSI_CFM_T %d (%d)\n",((CL_DM_RSSI_CFM_T*)message)->status,((CL_DM_RSSI_CFM_T*)message)->rssi));
UartPrintf("\r\n+RSSI=%d\r\n",((CL_DM_RSSI_CFM_T*)message)->rssi);
break;
}
default:
{
DEBUG_CL(("Unhandled CL message 0x%X\n", (uint16)id));
break;
}
}
}
