INT32 nativeNdef_createMime(char *mimeType, UINT8 *mimeData, UINT32 mimeDataLength,
UINT8*outNdefBuff, UINT32 outBufferLen)
{
tNFA_STATUS status = NFA_STATUS_FAILED;
UINT32 current_size = 0;
UINT32 mimeTypeLength = strlen(mimeType);
NXPLOG_API_D ("%s: enter, mime = %s", __FUNCTION__, mimeType);
if (mimeTypeLength + mimeDataLength >= (INT32)outBufferLen)
{
NXPLOG_API_E ("%s: data too large.", __FUNCTION__);
return 0;
}
status = NDEF_MsgAddRec(outNdefBuff, 1024, ¤t_size, NDEF_TNF_MEDIA, (UINT8 *)mimeType, mimeTypeLength, NULL, 0,
(UINT8*)mimeData, (UINT32)mimeDataLength);
if (status != NFA_STATUS_OK )
{
NXPLOG_API_E ("%s: couldn't create Ndef record", __FUNCTION__);
current_size = 0;
goto END;
}
END:
NXPLOG_API_D ("%s: exit", __FUNCTION__);
return current_size;
}
static tNFA_STATUS getDeviceCps(UINT8 *record, UINT8 *ref_name, UINT8 ref_len, nfc_handover_cps_t *power)
{
UINT8 *p_ac_record, *p_ac_payload;
UINT32 ac_payload_len;
UINT8 cps = HANDOVER_CPS_UNKNOWN;
UINT8 carrier_ref_name_len;
NXPLOG_API_D ("%s: enter\n", __FUNCTION__);
p_ac_record = NDEF_MsgGetFirstRecByType (record, NDEF_TNF_WELLKNOWN, RTD_Ac, sizeof(RTD_Ac));
while ((p_ac_record))
{
NXPLOG_API_D ("%s: find ac record\n", __FUNCTION__);
/* get payload */
p_ac_payload = NDEF_RecGetPayload (p_ac_record, &ac_payload_len);
if ((!p_ac_payload) || (ac_payload_len < 3))
{
NXPLOG_API_E ("%s: Failed to get ac payload", __FUNCTION__);
return NFA_STATUS_FAILED;
}
/* Carrier Power State */
cps = *p_ac_payload++;
/* Carrier Data Reference Length and Characters */
carrier_ref_name_len = *p_ac_payload++;
ac_payload_len -= 2;
/* remaining must have carrier data ref and Auxiliary Data Reference Count at least */
if (ac_payload_len > carrier_ref_name_len)
{
if (carrier_ref_name_len > NFA_CHO_MAX_REF_NAME_LEN)
{
NXPLOG_API_E ("%s: Too many bytes for carrier_ref_name, len = %d",
__FUNCTION__, carrier_ref_name_len);
return NFA_STATUS_FAILED;
}
}
else
{
NXPLOG_API_E ("%s: Failed to parse carrier_ref_name", __FUNCTION__);
return NFA_STATUS_FAILED;
}
if ((carrier_ref_name_len == ref_len) && (memcmp(p_ac_payload, ref_name, ref_len) == 0))
{
*power = (nfc_handover_cps_t)cps;
return NFA_STATUS_OK;
}
/* get next Alternative Carrier record */
p_ac_record = NDEF_MsgGetNextRecByType (p_ac_record, NDEF_TNF_WELLKNOWN, RTD_Ac, sizeof(RTD_Ac));
}
return NFA_STATUS_FAILED;
}
bool RoutingManager::initialize ()
{
unsigned long tech = 0;
UINT8 mActualNumEe = 0;
tNFA_EE_INFO mEeInfo [mActualNumEe];
if ((GetNumValue(NAME_NXP_FWD_FUNCTIONALITY_ENABLE, &tech, sizeof(tech))))
{
mFwdFuntnEnable = tech;
NXPLOG_API_E ("%s:NXP_FWD_FUNCTIONALITY_ENABLE=%d;", __FUNCTION__, mFwdFuntnEnable);
}
tNFA_STATUS nfaStat;
{
SyncEventGuard guard (mEeRegisterEvent);
NXPLOG_API_D ("%s: try ee register", "RoutingManager::initialize()");
nfaStat = NFA_EeRegister (nfaEeCallback);
if (nfaStat != NFA_STATUS_OK)
{
NXPLOG_API_E ("%s: fail ee register; error=0x%X",
"RoutingManager::initialize()", nfaStat);
return false;
}
mEeRegisterEvent.wait ();
}
if(mHostListnEnable)
{
// Tell the host-routing to only listen on Nfc-A/Nfc-B
nfaStat = NFA_CeRegisterAidOnDH (NULL, 0, stackCallback);
if (nfaStat != NFA_STATUS_OK)
{
NXPLOG_API_E ("Failed to register wildcard AID for DH");
}
// Tell the host-routing to only listen on Nfc-A/Nfc-B
nfaStat = NFA_CeSetIsoDepListenTech(NFA_TECHNOLOGY_MASK_A | NFA_TECHNOLOGY_MASK_B);
if (nfaStat != NFA_STATUS_OK)
{
NXPLOG_API_E ("Failed to configure CE IsoDep technologies");
}
}
memset(mRxDataBuffer, 0, MAX_CE_RX_BUFFER_SIZE);
if ((nfaStat = NFA_AllEeGetInfo (&mActualNumEe, mEeInfo)) != NFA_STATUS_OK)
{
NXPLOG_API_E ("%s: fail get info; error=0x%X",
"RoutingManager::initialize()", nfaStat);
mActualNumEe = 0;
}
return true;
}
void RoutingManager::handleData (const UINT8* data, UINT32 dataLen, tNFA_STATUS status)
{
tNFA_STATUS nfaStat = NFA_STATUS_OK;
if (dataLen <= 0)
{
NXPLOG_API_E("no data");
goto TheEnd;
}
if (status == NFA_STATUS_CONTINUE)
{
memcpy((mRxDataBuffer + mRxDataBufferLen), data, dataLen);
mRxDataBufferLen += dataLen;
return; //expect another NFA_CE_DATA_EVT to come
}
else if (status == NFA_STATUS_OK)
{
memcpy(mRxDataBuffer, data, dataLen);
mRxDataBufferLen = dataLen;
//entire data packet has been received; no more NFA_CE_DATA_EVT
}
else if (status == NFA_STATUS_FAILED)
{
NXPLOG_API_E("RoutingManager::handleData: read data fail");
goto TheEnd;
}
if (mSkipCheckNDEF
&& mRxDataBufferLen == T4T_CHECK_NDEF_APDU_LENGTH && memcmp(mRxDataBuffer, T4T_CHECK_NDEF_APDU, T4T_CHECK_NDEF_APDU_LENGTH) == 0)
{
//ignore check Ndef command, interop with PN544
nfaStat = NFA_Deactivate (FALSE);
if (nfaStat != NFA_STATUS_OK)
{
NXPLOG_API_E ("RoutingManager::handleData: deactivate failed; error=0x%X", nfaStat);
}
goto TheEnd;
}
if (nativeNfcManager_isNfcActive())
{
if (mCallback && (NULL != mCallback->onDataReceived))
{
mCallback->onDataReceived(mRxDataBuffer, mRxDataBufferLen);
}
}
TheEnd:
memset(mRxDataBuffer, 0, MAX_CE_RX_BUFFER_SIZE);
mRxDataBufferLen = 0;
}
INT32 nativeNfcLlcp_ConnLessReceiveMessage(UINT8* msg, UINT32 *length)
{
NXPLOG_API_D ("%s: enter\n", __FUNCTION__);
if(msg == NULL || length == NULL){
NXPLOG_API_E ("%s: Invalid buffer or length", __FUNCTION__);
return NFA_STATUS_FAILED;
}
NXPLOG_API_D("nfaLlcpServerCallBack: remote sap ID 0x%04x\n ", bDestSap);
if( (bServerReadState == FALSE) && (bClientReadState == FALSE) )
{
sNfaLlcpConnLessReadEvent.wait();
}
if(NFA_STATUS_OK != NFA_P2pReadUI ((size_t)sLlcpConnLessHandle,
LLCP_MAX_DATA_SIZE,
&bDestSap,
&dwLlcpReadLength,
&bLlcpReadData[0],
&blMoreDataRemaining))
{
NXPLOG_API_D ("%s: send response failed.", __FUNCTION__);
return NFA_STATUS_FAILED;
}
else
{
memcpy(msg,bLlcpReadData, dwLlcpReadLength);
*length = dwLlcpReadLength;
NXPLOG_API_D ("%s: exit\n", __FUNCTION__);
bServerReadState = FALSE;
bClientReadState = FALSE;
return NFA_STATUS_OK;
}
}
void nativeNfcSnep_stopServer()
{
NXPLOG_API_D ("%s:", __FUNCTION__);
gSyncMutex.lock();
if (!nativeNfcManager_isNfcActive())
{
NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
gSyncMutex.unlock();
return;
}
nativeNfcSnep_abortServerWaits();
sServerCallback = NULL;
sRfEnabled = isDiscoveryStarted();
if (sRfEnabled)
{
// Stop RF Discovery if we were polling
startRfDiscovery (FALSE);
}
NFA_SnepDeregister(sSnepServerHandle);
if (sRfEnabled)
{
startRfDiscovery (TRUE);
}
sSnepServerState = SNEP_SERVER_IDLE;
gSyncMutex.unlock();
}
void nativeNfcSnep_deregisterClientCallback()
{
NXPLOG_API_D ("%s:", __FUNCTION__);
gSyncMutex.lock();
if (!nativeNfcManager_isNfcActive())
{
NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
gSyncMutex.unlock();
return;
}
nativeNfcSnep_abortClientWaits();
sRfEnabled = isDiscoveryStarted();
if (sRfEnabled)
{
// Stop RF Discovery if we were polling
startRfDiscovery (FALSE);
}
NFA_SnepDeregister(sSnepClientHandle);
sClientCallback = NULL;
if (sRfEnabled)
{
startRfDiscovery (TRUE);
}
gSyncMutex.unlock();
}
void RoutingManager::enableRoutingToHost(bool skipCheckNDEF)
{
tNFA_STATUS nfaStat;
NXPLOG_API_D ("%s enter", "RoutingManager::enableRoutingToHost()");
mSkipCheckNDEF = skipCheckNDEF;
{
SyncEventGuard guard (mRoutingEvent);
// Route Nfc-A & B to host
if (mSeTechMask == 0)
{
nfaStat = NFA_EeSetDefaultProtoRouting(mDefaultEe ,
NFC_PROTOCOL_MASK_ISO7816|NFA_PROTOCOL_MASK_ISO_DEP,
0, 0, 0, 0);
if (nfaStat == NFA_STATUS_OK)
{
mRoutingEvent.wait ();
}
else
{
NXPLOG_API_E ("Fail to set iso7816 routing");
}
}
}
commitRouting();
}
INT32 nativeNfcLlcp_ConnLessRegisterClientCallback(nfcllcpConnlessClientCallback_t *clientCallback)
{
tNFA_STATUS status = NFA_STATUS_FAILED;
pthread_t llcpCleintRespThread;
int ret = 1;
NXPLOG_API_D ("%s:", __FUNCTION__);
gSyncMutex.lock();
if (!nativeNfcManager_isNfcActive())
{
NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
gSyncMutex.unlock();
return NFA_STATUS_FAILED;
}
sRfEnabled = isDiscoveryStarted();
if (sRfEnabled)
{
/* Stop RF Discovery if we were polling */
startRfDiscovery (FALSE);
}
{
SyncEventGuard g (sNfaLlcpClientRegEvent);
bClientReadState = FALSE;
if(NFA_STATUS_OK != (status = NFA_P2pRegisterClient(NFA_P2P_LLINK_TYPE, nfaLlcpClientCallback)))
{
NXPLOG_API_E ("%s: fail to register client callback for LLCP", __FUNCTION__);
if (sRfEnabled)
{
/* Rollback to default */
startRfDiscovery (TRUE);
gSyncMutex.unlock();
return status;
}
}
sNfaLlcpClientRegEvent.wait();
}
sClientCallback = clientCallback;
status = NFA_STATUS_OK;
gSyncMutex.unlock();
return status;
}
INT32 nativeNdef_createText(char *languageCode, char *text, UINT8*outNdefBuff, UINT32 outBufferLen)
{
static char * DEFAULT_LANGUAGE_CODE = "En";
tNFA_STATUS status = NFA_STATUS_FAILED;
UINT32 textLength = strlen(text);
UINT32 langCodeLength = 0;
UINT32 current_size = 0;
char *langCode = (char *)languageCode;
NXPLOG_API_D ("%s: enter, text = %s", __FUNCTION__, text);
if (langCode != NULL)
{
langCodeLength = strlen(langCode);
}
if (langCodeLength > 64)
{
NXPLOG_API_E ("%s: language code is too long, must be <64 bytes.", __FUNCTION__);
return 0;
}
if (langCodeLength == 0)
{
//set default language to 'EN'
langCode = DEFAULT_LANGUAGE_CODE;
langCodeLength = 2;
}
memset (outNdefBuff, 0, outBufferLen);
status = NDEF_MsgAddRec(outNdefBuff, outBufferLen, ¤t_size, NDEF_TNF_WKT, (UINT8*)RTD_TEXT, 1, NULL, 0,
(UINT8*)(&langCodeLength), 1);
status |= NDEF_MsgAppendPayload(outNdefBuff, outBufferLen, ¤t_size, outNdefBuff,
(UINT8*)langCode, langCodeLength);
status |= NDEF_MsgAppendPayload(outNdefBuff, outBufferLen, ¤t_size, outNdefBuff,
(UINT8*)text, textLength);
if (status != NFA_STATUS_OK )
{
NXPLOG_API_E ("%s: couldn't create Ndef record", __FUNCTION__);
current_size =0;
goto END;
}
END:
NXPLOG_API_D ("%s: exit", __FUNCTION__);
return current_size;
}
INT32 nativeNfcLlcp_ConnLessSendMessage(UINT8* msg, UINT32 length)
{
tNFA_STATUS bNfaStatus;
NXPLOG_API_D ("%s: enter\n", __FUNCTION__);
if(msg == NULL || length <= 0){
NXPLOG_API_E ("%s: Invalid buffer or length", __FUNCTION__);
return NFA_STATUS_FAILED;
}
NXPLOG_API_D("nfaLlcpServerCallBack: remote sap ID 0x%04x\n ", bDestSap);
bNfaStatus = NFA_P2pSendUI(sLlcpConnLessHandle,
bDestSap,
length,
msg);
if(bNfaStatus != NFA_STATUS_OK)
{
NXPLOG_API_E ("%s: Error in send message\n", __FUNCTION__);
return NFA_STATUS_FAILED;
}
NXPLOG_API_D ("%s: exit\n", __FUNCTION__);
return NFA_STATUS_OK;
}
INT32 nativeNfcSnep_registerClientCallback(nfcSnepClientCallback_t *clientCallback)
{
tNFA_STATUS status = NFA_STATUS_FAILED;
NXPLOG_API_D ("%s:", __FUNCTION__);
gSyncMutex.lock();
if (!nativeNfcManager_isNfcActive())
{
NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
gSyncMutex.unlock();
return NFA_STATUS_FAILED;
}
sRfEnabled = isDiscoveryStarted();
if (sRfEnabled)
{
// Stop RF Discovery if we were polling
startRfDiscovery (FALSE);
}
{
SyncEventGuard g (sNfaSnepClientRegEvent);
if(NFA_STATUS_OK != (status = NFA_SnepRegisterClient(nfaSnepClientCallback)))
{
NXPLOG_API_E ("%s: fail to register client callback for SNEP", __FUNCTION__);
goto clean_and_return;
}
sNfaSnepClientRegEvent.wait();
}
sClientCallback = clientCallback;
status = NFA_STATUS_OK;
clean_and_return:
if (sRfEnabled)
{
// Stop RF Discovery if we were polling
startRfDiscovery (TRUE);
}
gSyncMutex.unlock();
return status;
}
void RoutingManager::disableRoutingToHost()
{
tNFA_STATUS nfaStat;
NXPLOG_API_D ("%s enter", "RoutingManager::disableRoutingToHost()");
{
SyncEventGuard guard (mRoutingEvent);
// Default routing for NFC-A & B technology if we don't have a SE
if (mSeTechMask == 0)
{
nfaStat = NFA_EeSetDefaultProtoRouting(mDefaultEe, 0, 0, 0, 0, 0);
if (nfaStat == NFA_STATUS_OK)
{
mRoutingEvent.wait ();
}
else
{
NXPLOG_API_E ("Fail to set iso7816 routing");
}
}
}
commitRouting();
}
INT32 nativeNdef_createUri(char *uri, UINT8*outNdefBuff, UINT32 outBufferLen)
{
tNFA_STATUS status = NFA_STATUS_FAILED;
INT32 uriLength = strlen(uri);
UINT32 current_size = 0;
INT32 i, prefixLength;
NXPLOG_API_D ("%s: enter, uri = %s", __FUNCTION__, uri);
for (i = 1; i < URI_PREFIX_MAP_LENGTH; i++)
{
if (memcmp(URI_PREFIX_MAP[i], uri, strlen(URI_PREFIX_MAP[i])) == 0)
{
break;
}
}
if (i == URI_PREFIX_MAP_LENGTH)
{
i = 0;
}
prefixLength = strlen(URI_PREFIX_MAP[i]);
status = NDEF_MsgAddRec(outNdefBuff, outBufferLen, ¤t_size, NDEF_TNF_WKT, (UINT8*)RTD_URL, 1, NULL, 0,
(UINT8*)&i, 1);
status |= NDEF_MsgAppendPayload(outNdefBuff, outBufferLen, ¤t_size, outNdefBuff,
(UINT8*)(uri + prefixLength), (UINT32)(uriLength - prefixLength));
if (status != NFA_STATUS_OK )
{
NXPLOG_API_E ("%s: couldn't create Ndef record", __FUNCTION__);
current_size = 0;
goto END;
}
END:
NXPLOG_API_D ("%s: exit", __FUNCTION__);
return current_size;
}
INT32 nativeNdef_createHs(nfc_handover_cps_t cps, char *carrier_data_ref,
UINT8 *ndefBuff, UINT32 ndefBuffLen, UINT8 *outBuff, UINT32 outBuffLen)
{
UINT8 *p_msg_ac = NULL;
UINT32 cur_size_ac = 0, max_size, cur_ndef_size = 0;
if (ndefBuff == NULL || ndefBuffLen == 0
|| outBuff == NULL || outBuffLen == 0
|| carrier_data_ref == NULL)
{
return -1;
}
max_size = outBuffLen - ndefBuffLen;
p_msg_ac = (UINT8 *) malloc (max_size);
if (!p_msg_ac)
{
NXPLOG_API_E ("%s: Failed to allocate buffer", __FUNCTION__);
return 0;
}
NDEF_MsgInit (p_msg_ac, max_size, &cur_size_ac);
if (NDEF_OK != NDEF_MsgAddWktAc (p_msg_ac, max_size, &cur_size_ac,
cps, carrier_data_ref, 0, NULL))
{
NXPLOG_API_E ("%s: Failed to create ac message", __FUNCTION__);
cur_ndef_size = 0;
goto end_and_return;
}
/* Creare Handover Select Record */
if (NDEF_OK != NDEF_MsgCreateWktHs (outBuff, outBuffLen, &cur_ndef_size,
NFC_FORUM_HANDOVER_VERSION))
{
NXPLOG_API_E ("%s: Failed to create Hs message", __FUNCTION__);
cur_ndef_size = 0;
goto end_and_return;
}
/* Append Alternative Carrier Records */
if (NDEF_OK != NDEF_MsgAppendPayload (outBuff, outBuffLen, &cur_ndef_size,
outBuff, p_msg_ac, cur_size_ac))
{
NXPLOG_API_E ("%s: Failed to append Alternative Carrier Record", __FUNCTION__);
cur_ndef_size = 0;
goto end_and_return;
}
/* Append Alternative Carrier Reference Data */
if (NDEF_OK != NDEF_MsgAppendRec (outBuff, outBuffLen, &cur_ndef_size,
ndefBuff, ndefBuffLen))
{
NXPLOG_API_E ("%s: Failed to append Alternative Carrier Reference Data", __FUNCTION__);
cur_ndef_size = 0;
goto end_and_return;
}
end_and_return:
if (p_msg_ac)
{
free(p_msg_ac);
}
return cur_ndef_size;
}
INT32 nativeNfcSnep_startServer(nfcSnepServerCallback_t *serverCallback)
{
tNFA_STATUS status = NFA_STATUS_OK;
int ret;
pthread_t snepRespThread;
NXPLOG_API_D ("%s:", __FUNCTION__);
if (serverCallback == NULL)
{
NXPLOG_API_E ("%s: callback is NULL!", __FUNCTION__);
return NFA_STATUS_FAILED;
}
gSyncMutex.lock();
if (!nativeNfcManager_isNfcActive())
{
NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
gSyncMutex.unlock();
return NFA_STATUS_FAILED;
}
if (sSnepServerState == SNEP_SERVER_STARTED && serverCallback == sServerCallback)
{
NXPLOG_API_D ("%s: alread started!", __FUNCTION__);
gSyncMutex.unlock();
return NFA_STATUS_OK;
}
if (sSnepServerState != SNEP_SERVER_IDLE)
{
NXPLOG_API_E ("%s: Server is started or busy. State = 0x%X", __FUNCTION__, sSnepServerState);
gSyncMutex.unlock();
return NFA_STATUS_FAILED;
}
sServerCallback = serverCallback;
sSnepServerState = SNEP_SERVER_STARTING;
sRfEnabled = isDiscoveryStarted();
if (sRfEnabled)
{
// Stop RF Discovery if we were polling
startRfDiscovery (FALSE);
}
{
SyncEventGuard guard (sNfaSnepServerRegEvent);
if(NFA_STATUS_OK != NFA_SnepRegisterServer(0x04, SNEP_SERVER_NAME, nfaSnepServerCallback))
{
status = NFA_STATUS_FAILED;
sSnepServerState = SNEP_SERVER_IDLE;
sServerCallback = NULL;
goto clean_and_return;
}
sNfaSnepServerRegEvent.wait();
}
ret = pthread_create(&snepRespThread, NULL, snepServerThread, NULL);
if(ret != 0)
{
NXPLOG_API_E("Unable to create snep server thread");
sSnepServerState = SNEP_SERVER_IDLE;
NFA_SnepDeregister(sSnepServerHandle);
sServerCallback = NULL;
status = NFA_STATUS_FAILED;
goto clean_and_return;
}
sSnepServerState = SNEP_SERVER_STARTED;
clean_and_return:
if (sRfEnabled)
{
startRfDiscovery (TRUE);
}
gSyncMutex.unlock();
return status;
}
INT32 nativeNfcSnep_putMessage(UINT8* msg, UINT32 length)
{
tNFA_STATUS status = NFA_STATUS_FAILED;
NXPLOG_API_D ("%s: data length = %d", __FUNCTION__, length);
if (!sSnepClientHandle)
{
NXPLOG_API_E ("%s: no connection", __FUNCTION__);
return NFA_STATUS_FAILED;
}
if (!msg || length == 0)
{
NXPLOG_API_E ("%s: wrong param", __FUNCTION__);
return NFA_STATUS_FAILED;
}
if(NFA_STATUS_OK != NDEF_MsgValidate(msg, length, FALSE))
{
NXPLOG_API_E ("%s: not NDEF message", __FUNCTION__);
return NFA_STATUS_FAILED;
}
gSyncMutex.lock();
if (!nativeNfcManager_isNfcActive())
{
NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
status = NFA_STATUS_FAILED;
goto clean_and_return;
}
if (sSnepClientHandle){
SyncEventGuard guard (sNfaSnepClientConnEvent);
if(NFA_STATUS_OK != NFA_SnepConnect(sSnepClientHandle, SNEP_SERVER_NAME))
{
status = NFA_STATUS_FAILED;
goto clean_and_return;
}
sNfaSnepClientConnEvent.wait();
}
/* Send Put Request */
if (sSnepClientConnectionHandle != 0)
{
SyncEventGuard guard (sNfaSnepClientPutMsgEvent);
if(NFA_STATUS_OK != NFA_SnepPut (sSnepClientConnectionHandle, length, msg))
{
status = NFA_STATUS_FAILED;
goto clean_and_return;
}
sNfaSnepClientPutMsgEvent.wait();
if (sSnepClientPutState != NFA_STATUS_OK)
{
status = NFA_STATUS_FAILED;
}
else
{
status = NFA_STATUS_OK;
sSnepClientPutState = NFA_STATUS_FAILED;
}
}
/* Disconnect from Snep Server */
if (sSnepClientConnectionHandle != 0)
{
SyncEventGuard guard (sNfaSnepClientDisconnEvent);
if(NFA_STATUS_OK != NFA_SnepDisconnect (sSnepClientConnectionHandle, 0x01))
{
status = NFA_STATUS_FAILED;
goto clean_and_return;
}
sNfaSnepClientDisconnEvent.wait();
}
clean_and_return:
NXPLOG_API_D ("%s: return = %d", __FUNCTION__, status);
gSyncMutex.unlock();
return status;
}
INT32 nativeNdef_readHr(UINT8*ndefBuff, UINT32 ndefBuffLen, nfc_handover_request_t *hrInfo)
{
UINT8 *p_hr_record;
UINT8 *p_hr_payload;
UINT32 hr_payload_len = 0;
UINT8 *p_record;
UINT8 *p_payload;
UINT32 record_payload_len;
UINT8 *p_id;
UINT8 id_len;
UINT8 version = 0;
UINT32 index;
UINT8 len;
UINT8 type;
(void)ndefBuffLen;
if (hrInfo == NULL)
{
return -1;
}
memset(hrInfo, 0, sizeof(nfc_handover_request_t));
NXPLOG_API_D ("%s: enter", __FUNCTION__);
/* get Handover Request record */
p_hr_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_WELLKNOWN, (UINT8*)RTD_Hr, sizeof(RTD_Hr));
if (p_hr_record)
{
NXPLOG_API_E ("%s: Find Hr record", __FUNCTION__);
p_hr_payload = NDEF_RecGetPayload (p_hr_record, &hr_payload_len);
if ((!p_hr_payload) || (hr_payload_len < 7))
{
NXPLOG_API_E ("%s: Failed to get Hr payload (version, cr/ac record)", __FUNCTION__);
return -1;
}
/* Version */
if (NFC_FORUM_HANDOVER_VERSION != p_hr_payload[0])
{
NXPLOG_API_E ("%s: Version (0x%02x) not matched", __FUNCTION__, p_hr_payload[0]);
return -1;
}
p_hr_payload += 1;
hr_payload_len--;
/* NDEF message for Collision Resolution record and Alternative Carrier records */
if (NDEF_OK != NDEF_MsgValidate (p_hr_payload, hr_payload_len, FALSE))
{
NXPLOG_API_E ("%s: Failed to validate NDEF message for cr/ac records", __FUNCTION__);
return -1;
}
}
p_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_MEDIA,
BT_OOB_REC_TYPE, BT_OOB_REC_TYPE_LEN);
if (p_record)
{
NXPLOG_API_D ("%s: Found BT OOB record", __FUNCTION__);
if (p_hr_record)
{
p_id = NDEF_RecGetId(p_record, &id_len);
if (p_id == NULL || id_len == 0)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF ID", __FUNCTION__);
return -1;
}
if (getDeviceCps(p_hr_payload, p_id, id_len, &hrInfo->bluetooth.power_state)!=NFA_STATUS_OK)
{
hrInfo->bluetooth.power_state = HANDOVER_CPS_UNKNOWN;
}
}
p_payload = NDEF_RecGetPayload(p_record, &record_payload_len);
if (p_payload == NULL)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF payload", __FUNCTION__);
return -1;
}
hrInfo->bluetooth.type = HANDOVER_TYPE_BT;
hrInfo->bluetooth.ndef = p_record;
hrInfo->bluetooth.ndef_length = record_payload_len;
index = 2;
if (parseBluetoothAddress(&p_payload[index] , record_payload_len - index, hrInfo->bluetooth.address)!= 0)
{
NXPLOG_API_E ("%s: Failed to retreive device address", __FUNCTION__);
return -1;
}
index += BLUETOOTH_ADDRESS_LENGTH;
while(index < record_payload_len)
{
len = p_payload[index++];
type = p_payload[index++];
switch (type)
{
case BT_HANDOVER_TYPE_SHORT_LOCAL_NAME:
hrInfo->bluetooth.device_name = p_payload;
hrInfo->bluetooth.device_name_length = len;
break;
case BT_HANDOVER_TYPE_LONG_LOCAL_NAME:
if (hrInfo->bluetooth.device_name)
{
break; // prefer short name
}
hrInfo->bluetooth.device_name = p_payload;
hrInfo->bluetooth.device_name_length = len;
break;
default:
index += (len - 1);
break;
}
}
}
else
{
p_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_MEDIA,
BLE_OOB_REC_TYPE, BT_OOB_REC_TYPE_LEN);
if (p_record)
{
NXPLOG_API_D ("%s: Found BLE OOB record", __FUNCTION__);
if (p_hr_record)
{
p_id = NDEF_RecGetId(p_record, &id_len);
if (p_id == NULL || id_len == 0)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF ID", __FUNCTION__);
return -1;
}
if (getDeviceCps(p_hr_payload, p_id, id_len, &hrInfo->bluetooth.power_state)!=NFA_STATUS_OK)
{
hrInfo->bluetooth.power_state = HANDOVER_CPS_UNKNOWN;
}
}
p_payload = NDEF_RecGetPayload(p_record, &record_payload_len);
if (p_payload == NULL)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF payload", __FUNCTION__);
return -1;
}
hrInfo->bluetooth.type = HANDOVER_TYPE_BLE;
hrInfo->bluetooth.ndef = p_record;
hrInfo->bluetooth.ndef_length = record_payload_len;
index = 0;
while(index < record_payload_len)
{
len = p_payload[index++];
type = p_payload[index++];
switch (type)
{
case BT_HANDOVER_TYPE_MAC:
parseBluetoothAddress(&p_payload[index] , record_payload_len - index, hrInfo->bluetooth.address);
break;
case BT_HANDOVER_TYPE_SHORT_LOCAL_NAME:
hrInfo->bluetooth.device_name = p_payload;
hrInfo->bluetooth.device_name_length = len;
break;
case BT_HANDOVER_TYPE_LONG_LOCAL_NAME:
if (hrInfo->bluetooth.device_name)
{
break; // prefer short name
}
hrInfo->bluetooth.device_name = p_payload;
hrInfo->bluetooth.device_name_length = len;
break;
default:
index += (len - 1);
break;
}
}
}
}
p_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_MEDIA,
WIFI_WSC_REC_TYPE, WIFI_WSC_REC_TYPE_LEN);
if (p_record)
{
NXPLOG_API_D ("%s: Found WiFi record", __FUNCTION__);
hrInfo->wifi.has_wifi = TRUE;
hrInfo->wifi.ndef = p_record;
hrInfo->wifi.ndef_length = record_payload_len;
}
return 0;
}
/*******************************************************************************
**
** Function: nfaEeCallback
**
** Description: Receive execution environment-related events from stack.
** event: Event code.
** eventData: Event data.
**
** Returns: None
**
*******************************************************************************/
void RoutingManager::nfaEeCallback (tNFA_EE_EVT event, tNFA_EE_CBACK_DATA* eventData)
{
RoutingManager& routingManager = RoutingManager::getInstance();
switch (event)
{
case NFA_EE_REGISTER_EVT:
{
SyncEventGuard guard (routingManager.mEeRegisterEvent);
NXPLOG_API_D ("%s: NFA_EE_REGISTER_EVT; status=%u",
"RoutingManager::nfaEeCallback",
eventData->ee_register);
routingManager.mEeRegisterEvent.notifyOne();
}
break;
case NFA_EE_MODE_SET_EVT:
{
SyncEventGuard guard (routingManager.mEeSetModeEvent);
NXPLOG_API_D ("%s: NFA_EE_MODE_SET_EVT; status: 0x%04X handle: 0x%04X ",
"RoutingManager::nfaEeCallback",
eventData->mode_set.status,
eventData->mode_set.ee_handle);
routingManager.mEeSetModeEvent.notifyOne();
//se.notifyModeSet(eventData->mode_set.ee_handle, !(eventData->mode_set.status),eventData->mode_set.ee_status );
}
break;
case NFA_EE_SET_TECH_CFG_EVT:
{
NXPLOG_API_D ("%s: NFA_EE_SET_TECH_CFG_EVT; status=0x%X",
"RoutingManager::nfaEeCallback", eventData->status);
SyncEventGuard guard(routingManager.mRoutingEvent);
routingManager.mRoutingEvent.notifyOne();
}
break;
case NFA_EE_SET_PROTO_CFG_EVT:
{
NXPLOG_API_D ("%s: NFA_EE_SET_PROTO_CFG_EVT; status=0x%X",
"RoutingManager::nfaEeCallback", eventData->status);
SyncEventGuard guard(routingManager.mRoutingEvent);
routingManager.mRoutingEvent.notifyOne();
}
break;
case NFA_EE_ACTION_EVT:
{
tNFA_EE_ACTION& action = eventData->action;
checkforTranscation(NFA_EE_ACTION_EVT, (void *)eventData);
if (action.trigger == NFC_EE_TRIG_SELECT)
{
NXPLOG_API_D ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=select (0x%X)",
"RoutingManager::nfaEeCallback", action.ee_handle,
action.trigger);
}
else if (action.trigger == NFC_EE_TRIG_APP_INIT)
{
tNFC_APP_INIT& app_init = action.param.app_init;
NXPLOG_API_D ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=app-init (0x%X); aid len=%u; data len=%u",
"RoutingManager::nfaEeCallback", action.ee_handle,
action.trigger, app_init.len_aid,
app_init.len_data);
//if app-init operation is successful;
//app_init.data[] contains two bytes, which are the status codes of the event;
//app_init.data[] does not contain an APDU response;
//see EMV Contactless Specification for Payment Systems; Book B; Entry Point Specification;
//version 2.1; March 2011; section 3.3.3.5;
if ( (app_init.len_data > 1) &&
(app_init.data[0] == 0x90) &&
(app_init.data[1] == 0x00) )
{
//getInstance().notifyAidSelected(app_init.aid, app_init.len_aid, app_init.data, app_init.len_data);
}
}
else if (action.trigger == NFC_EE_TRIG_RF_PROTOCOL)
{
NXPLOG_API_D ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf protocol (0x%X)",
"RoutingManager::nfaEeCallback", action.ee_handle,
action.trigger);
}
else if (action.trigger == NFC_EE_TRIG_RF_TECHNOLOGY)
{
NXPLOG_API_D ("%s: NFA_EE_ACTION_EVT; h=0x%X; trigger=rf tech (0x%X)",
"RoutingManager::nfaEeCallback", action.ee_handle,
action.trigger);
}
else
{
NXPLOG_API_E ("%s: NFA_EE_ACTION_EVT; h=0x%X; unknown trigger (0x%X)",
"RoutingManager::nfaEeCallback", action.ee_handle,
action.trigger);
}
}
break;
case NFA_EE_DISCOVER_EVT:
{
NXPLOG_API_D ("%s: NFA_EE_DISCOVER_EVT; status=0x%X; num ee=%u",
__FUNCTION__,eventData->status,
eventData->ee_discover.num_ee);
}
break;
case NFA_EE_DISCOVER_REQ_EVT:
NXPLOG_API_D ("%s: NFA_EE_DISCOVER_REQ_EVT; status=0x%X; num ee=%u", __FUNCTION__,
eventData->discover_req.status, eventData->discover_req.num_ee);
break;
case NFA_EE_NO_CB_ERR_EVT:
NXPLOG_API_D ("%s: NFA_EE_NO_CB_ERR_EVT status=%u",
"RoutingManager::nfaEeCallback", eventData->status);
break;
case NFA_EE_ADD_AID_EVT:
{
NXPLOG_API_D ("%s: NFA_EE_ADD_AID_EVT status=%u",
"RoutingManager::nfaEeCallback", eventData->status);
}
break;
case NFA_EE_REMOVE_AID_EVT:
{
NXPLOG_API_D ("%s: NFA_EE_REMOVE_AID_EVT status=%u",
"RoutingManager::nfaEeCallback", eventData->status);
}
break;
case NFA_EE_NEW_EE_EVT:
{
NXPLOG_API_D ("%s: NFA_EE_NEW_EE_EVT h=0x%X; status=%u",
"RoutingManager::nfaEeCallback",
eventData->new_ee.ee_handle,
eventData->new_ee.ee_status);
}
break;
case NFA_EE_ROUT_ERR_EVT:
{
NXPLOG_API_D ("%s: NFA_EE_ROUT_ERR_EVT status=%u",
"RoutingManager::nfaEeCallback", eventData->status);
}
break;
default:
NXPLOG_API_E ("%s: unknown event=%u ????",
"RoutingManager::nfaEeCallback", event);
break;
}
}
INT32 nativeNdef_readHs(UINT8*ndefBuff, UINT32 ndefBuffLen, nfc_handover_select_t *hsInfo)
{
UINT8 *p_hs_record;
UINT8 *p_hs_payload;
UINT32 hs_payload_len = 0;
UINT8 *p_record;
UINT8 *p_payload;
UINT32 record_payload_len;
UINT8 *p_id;
UINT8 id_len;
UINT8 version = 0;
UINT32 index;
UINT8 bt_len;
UINT8 bt_type;
UINT16 wifi_len;
UINT16 wifi_type;
UINT8 status = -1;
(void)ndefBuffLen;
if (hsInfo == NULL)
{
return -1;
}
memset(hsInfo, 0, sizeof(nfc_handover_select_t));
/* get Handover Request record */
p_hs_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_WELLKNOWN, (UINT8*)RTD_Hs, sizeof(RTD_Hs));
if (p_hs_record)
{
p_hs_payload = NDEF_RecGetPayload (p_hs_record, &hs_payload_len);
if ((!p_hs_payload) || (hs_payload_len < 7))
{
NXPLOG_API_E ("%s: Failed to get Hs payload (version, cr/ac record)", __FUNCTION__);
return -1;
}
/* Version */
if (NFC_FORUM_HANDOVER_VERSION != p_hs_payload[0])
{
NXPLOG_API_E ("%s: Version (0x%02x) not matched", __FUNCTION__, p_hs_payload[0]);
return -1;
}
p_hs_payload += 1;
hs_payload_len--;
/* NDEF message for Collision Resolution record and Alternative Carrier records */
if (NDEF_OK != NDEF_MsgValidate (p_hs_payload, hs_payload_len, FALSE))
{
NXPLOG_API_E ("%s: Failed to validate NDEF message for cr/ac records", __FUNCTION__);
return -1;
}
}
else
{
NXPLOG_API_E ("%s: Hs record not found", __FUNCTION__);
return -1;
}
p_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_MEDIA,
BT_OOB_REC_TYPE, BT_OOB_REC_TYPE_LEN);
if (p_record)
{
status = 0;
NXPLOG_API_D ("%s: Found BT OOB record");
if (p_hs_record)
{
p_id = NDEF_RecGetId(p_record, &id_len);
if (p_id == NULL || id_len == 0)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF ID", __FUNCTION__);
return -1;
}
if (getDeviceCps(p_hs_payload, p_id, id_len, &hsInfo->bluetooth.power_state)!=NFA_STATUS_OK)
{
hsInfo->bluetooth.power_state = HANDOVER_CPS_UNKNOWN;
}
}
p_payload = NDEF_RecGetPayload(p_record, &record_payload_len);
if (p_payload == NULL)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF payload", __FUNCTION__);
return -1;
}
hsInfo->bluetooth.type = HANDOVER_TYPE_BT;
hsInfo->bluetooth.ndef = p_record;
hsInfo->bluetooth.ndef_length = record_payload_len;
index = 2;
if (parseBluetoothAddress(&p_payload[index] , record_payload_len - index, hsInfo->bluetooth.address)!= 0)
{
NXPLOG_API_E ("%s: Failed to retreive device address", __FUNCTION__);
return -1;
}
index += BLUETOOTH_ADDRESS_LENGTH;
while(index < record_payload_len)
{
bt_len = p_payload[index++];
bt_type = p_payload[index++];
switch (bt_type)
{
case BT_HANDOVER_TYPE_SHORT_LOCAL_NAME:
hsInfo->bluetooth.device_name = &p_payload[index];
hsInfo->bluetooth.device_name_length = bt_len-1;
break;
case BT_HANDOVER_TYPE_LONG_LOCAL_NAME:
if (hsInfo->bluetooth.device_name)
{
break; // prefer short name
}
hsInfo->bluetooth.device_name = &p_payload[index];
hsInfo->bluetooth.device_name_length = bt_len-1;
break;
default:
break;
}
}
}
else
{
p_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_MEDIA,
BLE_OOB_REC_TYPE, BT_OOB_REC_TYPE_LEN);
if (p_record)
{
status = 0;
NXPLOG_API_D ("%s: Found BLE OOB record", __FUNCTION__);
if (p_hs_record)
{
p_id = NDEF_RecGetId(p_record, &id_len);
if (p_id == NULL || id_len == 0)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF ID", __FUNCTION__);
return -1;
}
if (getDeviceCps(p_hs_payload, p_id, id_len, &hsInfo->bluetooth.power_state)!=NFA_STATUS_OK)
{
hsInfo->bluetooth.power_state = HANDOVER_CPS_UNKNOWN;
}
}
p_payload = NDEF_RecGetPayload(p_record, &record_payload_len);
if (p_payload == NULL)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF payload", __FUNCTION__);
return -1;
}
hsInfo->bluetooth.type = HANDOVER_TYPE_BLE;
hsInfo->bluetooth.ndef = p_record;
hsInfo->bluetooth.ndef_length = record_payload_len;
index = 0;
while(index < record_payload_len)
{
bt_len = p_payload[index++];
bt_type = p_payload[index++];
switch (bt_type)
{
case BT_HANDOVER_TYPE_MAC:
parseBluetoothAddress(&p_payload[index] , record_payload_len - index, hsInfo->bluetooth.address);
break;
case BT_HANDOVER_TYPE_SHORT_LOCAL_NAME:
hsInfo->bluetooth.device_name = &p_payload[index];
hsInfo->bluetooth.device_name_length = bt_len-1;
break;
case BT_HANDOVER_TYPE_LONG_LOCAL_NAME:
if (hsInfo->bluetooth.device_name)
{
break; // prefer short name
}
hsInfo->bluetooth.device_name = &p_payload[index];
hsInfo->bluetooth.device_name_length = bt_len-1;
break;
default:
break;
}
}
}
}
p_record = NDEF_MsgGetFirstRecByType (ndefBuff, NDEF_TNF_MEDIA,
WIFI_WSC_REC_TYPE, WIFI_WSC_REC_TYPE_LEN);
if (p_record)
{
status = 0;
NXPLOG_API_D ("%s: Found WiFi record", __FUNCTION__);
if (p_hs_record)
{
p_id = NDEF_RecGetId(p_record, &id_len);
if (p_id == NULL || id_len == 0)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF ID", __FUNCTION__);
return -1;
}
if (getDeviceCps(p_hs_payload, p_id, id_len, &hsInfo->wifi.power_state)!=NFA_STATUS_OK)
{
hsInfo->wifi.power_state = HANDOVER_CPS_UNKNOWN;
}
}
p_payload = NDEF_RecGetPayload(p_record, &record_payload_len);
if (p_payload == NULL)
{
NXPLOG_API_E ("%s: Failed to retreive NDEF payload", __FUNCTION__);
return -1;
}
hsInfo->wifi.ndef = p_record;
hsInfo->wifi.ndef_length = record_payload_len;
index = 0;
while(index < record_payload_len)
{
/* wifi type is a 2 byte field*/
wifi_type = p_payload[index++];
wifi_type = wifi_type << 8;
wifi_type += p_payload[index++];
/* wifi len is a 2 byte field */
wifi_len = p_payload[index++];
wifi_len = wifi_len << 8;
wifi_len += p_payload[index++];
switch (wifi_type)
{
case WIFI_HANDOVER_SSID_ID:
hsInfo->wifi.ssid_length = wifi_len;
hsInfo->wifi.ssid = &p_payload[index];
index += hsInfo->wifi.ssid_length;
break;
case WIFI_HANDOVER_NETWORK_KEY_ID:
hsInfo->wifi.key_length = wifi_len;
hsInfo->wifi.key = &p_payload[index];
index += hsInfo->wifi.key_length;
break;
default:
break;
}
}
}
return status;
}
INT32 nativeNfcLlcp_ConnLessStartServer(nfcllcpConnlessServerCallback_t *serverCallback)
{
tNFA_STATUS status = NFA_STATUS_OK;
int ret;
pthread_t llcpRespThread;
bServerReadState = FALSE;
NXPLOG_API_D ("%s:", __FUNCTION__);
if (serverCallback == NULL)
{
NXPLOG_API_E ("%s: callback is NULL!", __FUNCTION__);
return NFA_STATUS_FAILED;
}
gSyncMutex.lock();
if (!nativeNfcManager_isNfcActive())
{
NXPLOG_API_E ("%s: Nfc not initialized.", __FUNCTION__);
gSyncMutex.unlock();
return NFA_STATUS_FAILED;
}
if (sLlcpServerState == LLCP_SERVER_STARTED && serverCallback == sServerCallback)
{
NXPLOG_API_D ("%s: alread started!", __FUNCTION__);
gSyncMutex.unlock();
return NFA_STATUS_OK;
}
if (sLlcpServerState != LLCP_SERVER_IDLE)
{
NXPLOG_API_E ("%s: Server is started or busy. State = 0x%X", __FUNCTION__, sLlcpServerState);
gSyncMutex.unlock();
return NFA_STATUS_FAILED;
}
sServerCallback = serverCallback;
sLlcpServerState = LLCP_SERVER_STARTING;
sRfEnabled = isDiscoveryStarted();
if (sRfEnabled)
{
/* Stop RF Discovery if we were polling */
startRfDiscovery (FALSE);
}
SyncEventGuard guard (sNfaLlcpServerRegEvent);
if(NFA_STATUS_OK != NFA_P2pRegisterServer ( LLCP_CL_SAP_ID_DEFAULT,
NFA_P2P_LLINK_TYPE,
(char *)LLCP_SERVER_NAME,
nfaLlcpServerCallBack))
{
status = NFA_STATUS_FAILED;
sLlcpServerState = LLCP_SERVER_IDLE;
sServerCallback = NULL;
if (sRfEnabled)
{
/* Rollback to default */
startRfDiscovery (TRUE);
gSyncMutex.unlock();
return status;
}
}
sNfaLlcpServerRegEvent.wait();
gSyncMutex.unlock();
return status;
}
