| /* |
| * Copyright (C) 2010 NXP Semiconductors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /*! |
| * \file phFriNfc_NdefReg.c |
| * \Contains Registry and module functions. |
| * |
| * Project: NDEFT |
| * |
| * $Date: Mon May 25 13:59:32 2009 $ |
| * $Author: ing08150 $ |
| * $Revision: 1.4 $ |
| * $Aliases: NFC_FRI1.1_WK920_R25_1,NFC_FRI1.1_WK922_PREP1,NFC_FRI1.1_WK922_R26_1,NFC_FRI1.1_WK924_PREP1,NFC_FRI1.1_WK924_R27_1,NFC_FRI1.1_WK926_R28_1,NFC_FRI1.1_WK928_R29_1,NFC_FRI1.1_WK930_R30_1,NFC_FRI1.1_WK934_PREP_1,NFC_FRI1.1_WK934_R31_1,NFC_FRI1.1_WK941_PREP1,NFC_FRI1.1_WK941_PREP2,NFC_FRI1.1_WK941_1,NFC_FRI1.1_WK943_R32_1,NFC_FRI1.1_WK949_PREP1,NFC_FRI1.1_WK943_R32_10,NFC_FRI1.1_WK943_R32_13,NFC_FRI1.1_WK943_R32_14,NFC_FRI1.1_WK1007_R33_1,NFC_FRI1.1_WK1007_R33_4,NFC_FRI1.1_WK1017_PREP1,NFC_FRI1.1_WK1017_R34_1,NFC_FRI1.1_WK1017_R34_2,NFC_FRI1.1_WK1023_R35_1 $ |
| * |
| */ |
| |
| |
| #include "phNfcTypes.h" |
| #include "phNfcStatus.h" |
| #include "phNfcCompId.h" |
| #include "phNfcHalTypes.h" |
| #include "phFriNfc.h" |
| #include "phFriNfc_NdefReg.h" |
| #include "phFriNfc_NdefRecord.h" |
| |
| /* Harsha: To Fix: 0000358: phFriNfc_NdefRecord.h: includes should be moved */ |
| #include <string.h> |
| static int16_t phFriNfc_NdefReg_Strncmp (const int8_t *s1, const int8_t *s2, uint32_t count); |
| |
| /********* String functions *********/ |
| |
| static int16_t phFriNfc_NdefReg_Strncmp (const int8_t *s1, const int8_t *s2, uint32_t count) |
| { |
| return (int16_t)strncmp((const char*)s1,(const char*)s2, count); |
| } |
| int16_t phFriNfc_NdefReg_Strnicmp(const int8_t *s1, const int8_t *s2, uint32_t count) |
| { |
| int8_t c1, c2; |
| int16_t returnvalue; |
| do |
| { |
| c1 = *s1; |
| s1++; |
| if (c1 >=97) |
| c1 = (c1 - 32); |
| c2 = *s2; |
| s2++; |
| if (c2 >=97) |
| c2 = (c2 - 32); |
| --count; |
| } |
| while ( (c1 == c2) && (c1 != '\0') && (c2 != '\0') && (count > 0) ); |
| |
| if ( (count == 0) || (c1 == c2) ) |
| returnvalue = 0; |
| |
| else if ( (c1 > c2) ) |
| returnvalue = 1; |
| else |
| returnvalue = -1; |
| |
| return(returnvalue); |
| } |
| |
| /********* REGISTRY AND LISTENER MODULE *********/ |
| |
| NFCSTATUS phFriNfc_NdefReg_Reset(phFriNfc_NdefReg_t *NdefReg, |
| uint8_t **NdefTypesarray, |
| phFriNfc_NdefRecord_t *RecordsExtracted, |
| phFriNfc_NdefReg_CbParam_t *CbParam, |
| uint8_t *ChunkedRecordsarray, |
| uint32_t NumberOfRecords) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| |
| /* Reset/Initialise the values of the Context structure */ |
| /* Store the required pointers in the context structure */ |
| if(NdefReg == NULL || NdefTypesarray == NULL || RecordsExtracted == NULL || CbParam == NULL) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| NdefReg->State=PH_FRINFC_NDEFREG_STATE_INIT; |
| NdefReg->NdefData=NULL; |
| NdefReg->NdefDataLength=0; |
| NdefReg->NdefTypeList=NULL; |
| NdefReg->NdefTypes = NdefTypesarray ; |
| NdefReg->RecordsExtracted = RecordsExtracted; |
| NdefReg->CbParam = CbParam; |
| NdefReg->validPreviousTnf = 0xff; |
| NdefReg->IsChunked = ChunkedRecordsarray; |
| NdefReg->NumberOfRecords = NumberOfRecords; |
| NdefReg->newRecordextracted = 0; |
| NdefReg->MainTnfFound = 0; |
| } |
| return(status); |
| } |
| |
| /* Adds a NDEF type listener to the internal list of listeners*/ |
| /*Libraray does no allocation of the memory*/ |
| NFCSTATUS phFriNfc_NdefReg_AddCb(phFriNfc_NdefReg_t *NdefReg, |
| phFriNfc_NdefReg_Cb_t *NdefCb) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| |
| if( NdefReg == NULL || NdefCb ==NULL) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| /* Check whether we can accomodate all these records in a single node */ |
| if(NdefCb->NumberOfRTDs <= PH_FRINFC_NDEFREG_MAX_RTD_REGISTERED) |
| { |
| /* Yes, all these Records can be accomodated in a single node */ |
| /* No existing node. This will be the first Node */ |
| if(NdefReg->NdefTypeList==NULL) |
| { |
| NdefCb->Previous =NULL; |
| NdefCb->Next =NULL; |
| NdefReg->NdefTypeList = NdefCb; |
| } |
| else |
| { |
| /* Some nodes are existing. Add the new CB node at the front |
| of the List and update pointers */ |
| NdefCb->Next = NdefReg->NdefTypeList; |
| NdefCb->Previous = NULL; |
| NdefReg->NdefTypeList->Previous = NdefCb; |
| NdefReg->NdefTypeList = NdefReg->NdefTypeList->Previous; |
| } |
| } |
| else |
| { |
| /* We cannot accomodate more records than PH_FRINFC_NDEFREG_MAX_RTD_REGISTERED |
| in this node. |
| So return warning NFCSTATUS_INVALID_PARAMETER. */ |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, |
| NFCSTATUS_INVALID_PARAMETER); |
| } |
| } |
| |
| return(status); |
| } |
| |
| /*Removes a specific listener from the list. The element to remove is specified by its address.*/ |
| /*Libraray does no deallocation of the memory*/ |
| NFCSTATUS phFriNfc_NdefReg_RmCb(phFriNfc_NdefReg_t *NdefReg, |
| phFriNfc_NdefReg_Cb_t *NdefCb) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| phFriNfc_NdefReg_Cb_t *tempNode; |
| uint8_t found=0;/* to check for the node present or not */ |
| |
| if( NdefReg==NULL || NdefCb ==NULL) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| tempNode = NdefReg->NdefTypeList; |
| /* if the list is empty */ |
| if(NdefReg->NdefTypeList == NULL) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_NOT_REGISTERED); |
| } |
| else |
| { |
| while(tempNode!=NULL) |
| { |
| if(NdefCb == tempNode) |
| { |
| found=1;/* if the node is present */ |
| |
| /* node is present in the front of the list so |
| update the NdefReg->NdefTypeList pointer */ |
| if(tempNode->Previous==NULL && tempNode->Next!=NULL) |
| { |
| NdefReg->NdefTypeList =NdefReg->NdefTypeList->Next; |
| NdefReg->NdefTypeList->Previous = NULL; |
| break; |
| } |
| /* only one node in the list so update the head node */ |
| if(tempNode->Next==NULL && tempNode->Previous==NULL) |
| { |
| NdefReg->NdefTypeList=NULL; |
| break; |
| } |
| if (tempNode->Previous != NULL) |
| { |
| tempNode->Previous->Next = tempNode->Next; |
| } |
| if (tempNode->Next != NULL) |
| { |
| tempNode->Next->Previous = tempNode->Previous; |
| } |
| break; |
| } |
| /* move to the next node */ |
| tempNode = tempNode->Next; |
| } |
| } |
| if(!found ) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_NOT_REGISTERED); |
| } |
| } |
| return(status); |
| } |
| |
| /* Copy the relevant pointers to the context structure, change the |
| FSM state, so as to trigger the process and return pending. This function is non-blocking, |
| it returns once the operation is initiated or an error occurs */ |
| |
| NFCSTATUS phFriNfc_NdefReg_DispatchPacket(phFriNfc_NdefReg_t *NdefReg, |
| uint8_t *PacketData, |
| uint16_t PacketDataLength) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| |
| if(NdefReg==NULL ||PacketData==NULL || PacketDataLength==0) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| NdefReg->NdefData = PacketData; |
| NdefReg->NdefDataLength = PacketDataLength; |
| NdefReg->State = PH_FRINFC_NDEFREG_STATE_DIS_PKT; |
| NdefReg->NumberOfNdefTypes = 0; |
| NdefReg->RecordIndex = 0; |
| NdefReg->RtdIndex = 0; |
| status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS); |
| } |
| return(status); |
| } |
| |
| /* Copy the relevant pointers to the context structure, change the |
| FSM state, so as to trigger the process and return pending */ |
| NFCSTATUS phFriNfc_NdefReg_DispatchRecord(phFriNfc_NdefReg_t *NdefReg, |
| phFriNfc_NdefRecord_t *RecordsExtracted) |
| { |
| NFCSTATUS status = NFCSTATUS_SUCCESS; |
| if(NdefReg==NULL || RecordsExtracted==NULL) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_INVALID_PARAMETER); |
| } |
| else |
| { |
| NdefReg->RecordsExtracted = RecordsExtracted; |
| NdefReg->State = PH_FRINFC_NDEFREG_STATE_DIS_RCD; |
| |
| status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS); |
| } |
| return(status); |
| } |
| |
| uint8_t phFriNfc_NdefReg_Process(phFriNfc_NdefReg_t *NdefReg, |
| NFCSTATUS *Status) |
| { |
| uint8_t count = 0, |
| ret_val=0, |
| TnfMatchFound = 0, |
| index = 0, |
| matchFound = 0; |
| |
| |
| |
| if(NdefReg->NdefTypeList == NULL) |
| { |
| /* No Nodes added. Return error */ |
| *Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_NOT_REGISTERED); |
| return(1); |
| } |
| |
| *Status = NFCSTATUS_SUCCESS; |
| switch(NdefReg->State) |
| { |
| case PH_FRINFC_NDEFREG_STATE_DIS_RCD: |
| |
| /* for START ( each node in the list NdefReg->NdefTypeList), do the following */ |
| for(index=0;index<NdefReg->NdefTypeList->NumberOfRTDs;index++) |
| { |
| /* First, Match should be done with The TNF*/ |
| if( (NdefReg->NdefTypeList->Tnf[index] & PH_FRINFC_NDEFRECORD_TNF_MASK ) == |
| (NdefReg->RecordsExtracted->Tnf & PH_FRINFC_NDEFRECORD_TNF_MASK ) ) |
| { |
| /* Second, Match should be done with The Typelength*/ |
| if( NdefReg->NdefTypeList->NdeftypeLength[index] == \ |
| NdefReg->RecordsExtracted->TypeLength ) |
| { |
| /* Third, Match should be done with The Type*/ |
| matchFound = 0; |
| switch(NdefReg->NdefTypeList->Tnf[index]) |
| { |
| case 1: |
| /* TNF = 0X01 NFC Forum well-known type : Case sensitive */ |
| /* comparison is to be made. */ |
| if( !phFriNfc_NdefReg_Strncmp( (const int8_t *)NdefReg->NdefTypeList->NdefType[index] , |
| (const int8_t *)(NdefReg->RecordsExtracted->Type), |
| NdefReg->RecordsExtracted->TypeLength)) |
| { |
| matchFound = 1; |
| } |
| break; |
| |
| case 2: |
| case 4: |
| /* For TNF = 0X02 Media-type as defined in RFC 2046 |
| From iana.org, it has never been found any registered media type |
| with non-ascii character ==> Comparison to be used for *types* in |
| *registry*: case INSENSITIVE comparison. |
| |
| For TNF = 0X04 NFC Forum external type : ==> Comparison to be used |
| for *types* in *registry* : case INSENSITIVE comparison */ |
| if( !phFriNfc_NdefReg_Strnicmp( (int8_t *)NdefReg->NdefTypeList->NdefType[index] , |
| (int8_t *)(NdefReg->RecordsExtracted->Type), |
| NdefReg->RecordsExtracted->TypeLength)) |
| { |
| matchFound = 1; |
| } |
| break; |
| |
| case 3: |
| /* TNF = 0X03 Absolute URI as defined in RFC 3986 [RFC 3986] |
| Big issue concerning the Encoding, which is actually determined |
| by the application.Conclusion is that: Comparison to be used for |
| *types* in *registry*: NONE. only TNF ; type should be ignored, |
| and its comparison shall be done by the application. */ |
| matchFound = 1; |
| break; |
| default: |
| break; |
| } |
| if(matchFound) |
| { |
| /* Copy the chunked flag info to the callback parameter */ |
| NdefReg->CbParam->Chunked[count] = (NdefReg->RecordsExtracted->Flags & \ |
| PH_FRINFC_NDEFRECORD_FLAGS_CF ); |
| |
| /* NOTE: Raw record and the raw record size cannot be |
| copied as this itself is an extracted record ! */ |
| |
| /* Copy the record in the format phFriNfc_NdefRecord_t |
| to the callback parameter */ |
| (void) memcpy( &NdefReg->CbParam->Records[count], |
| NdefReg->RecordsExtracted, |
| sizeof(phFriNfc_NdefRecord_t)); |
| count++; |
| } |
| } |
| } |
| } |
| |
| /* now, we have all the matching entries for the RTDs present |
| in this particular node NdefReg->NdefTypeList. |
| call the callback */ |
| if(count>0) |
| { |
| NdefReg->CbParam->Count = count; |
| NdefReg->CbParam->CbContext = NdefReg->NdefTypeList->CbContext; |
| NdefReg->NdefTypeList->NdefCallback (NdefReg->CbParam); |
| } |
| else |
| { |
| NdefReg->CbParam->Count = 0; |
| } |
| |
| /* for END ( each node in the list NdefReg->NdefTypeList), do the following */ |
| if(NdefReg->NdefTypeList->Next==NULL) |
| { |
| NdefReg->State = PH_FRINFC_NDEFREG_STATE_INIT; |
| while(NdefReg->NdefTypeList->Previous!=NULL) |
| { |
| NdefReg->NdefTypeList = NdefReg->NdefTypeList->Previous; |
| } |
| /* No further node present in the list. End of process function call */ |
| ret_val=1; |
| } |
| else |
| { |
| /* Move the linked list by one node.*/ |
| NdefReg->NdefTypeList = NdefReg->NdefTypeList->Next; |
| /* list is not empty so come again */ |
| ret_val=0; |
| } |
| break; |
| |
| case PH_FRINFC_NDEFREG_STATE_DIS_PKT: |
| |
| if(NdefReg->NumberOfNdefTypes == 0) |
| { |
| /* First, Get all the records present in the data packet NdefReg->NdefData |
| using NDEF tool library */ |
| /* and, get the NumberOfNdefTypes from NdefData */ |
| *Status = phFriNfc_NdefRecord_GetRecords( NdefReg->NdefData, |
| NdefReg->NdefDataLength, |
| NULL, |
| NdefReg->IsChunked, |
| &NdefReg->NumberOfNdefTypes); |
| if((*Status)!= NFCSTATUS_SUCCESS) |
| { |
| /* Error in the Packet. Exit from the process */ |
| ret_val = 1; |
| NdefReg->NumberOfNdefTypes = 0; |
| break; |
| } |
| |
| if(NdefReg->NumberOfNdefTypes > NdefReg->NumberOfRecords) |
| { |
| /* There is not enough space in the arrays NdefReg->NdefTypes |
| and NdefReg->IsChunked, to write NdefReg->NumberOfRecords |
| number of records. Return error. */ |
| *Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_BUFFER_TOO_SMALL); |
| ret_val = 1; |
| NdefReg->NumberOfNdefTypes = 0; |
| break; |
| } |
| |
| /* Now, get the NdefTypes */ |
| *Status = phFriNfc_NdefRecord_GetRecords( NdefReg->NdefData, |
| NdefReg->NdefDataLength, |
| NdefReg->NdefTypes, |
| NdefReg->IsChunked, |
| &NdefReg->NumberOfNdefTypes); |
| if((*Status)!= NFCSTATUS_SUCCESS) |
| { |
| /* Error in the Packet. Exit from the process */ |
| ret_val = 1; |
| NdefReg->NumberOfNdefTypes = 0; |
| break; |
| } |
| } |
| |
| /* For each record, in the arry NdefReg->NdefTypes, check |
| whether it matches with any of the registered RTD in the |
| present node. If it matches, copy this to the Callback |
| parameter array and increment count. |
| If count is 8, call the callback function. |
| Remember the record index that we last processed, before |
| calling the callback. */ |
| |
| /* for each record in the Message */ |
| while(NdefReg->RecordIndex < NdefReg->NumberOfNdefTypes) |
| { |
| /* Extract a record from the Message */ |
| *Status = phFriNfc_NdefRecord_Parse(NdefReg->RecordsExtracted, |
| NdefReg->NdefTypes[NdefReg->RecordIndex]); |
| if((*Status)!= NFCSTATUS_SUCCESS) |
| { |
| /* Error in the Record. Exit from the process */ |
| NdefReg->NumberOfNdefTypes = 0; |
| return 1; |
| } |
| |
| NdefReg->newRecordextracted = 1; |
| |
| /* for each RTD in the present node */ |
| while(NdefReg->RtdIndex < NdefReg->NdefTypeList->NumberOfRTDs) |
| { |
| /* Harsha: Fix for 0000243: [JF] phFriNfc_NdefReg_Process |
| won't parse correctly chunked records */ |
| |
| /* Check whether the TNF = 0x06 |
| PH_FRINFC_NDEFRECORD_TNF_UNCHANGED */ |
| |
| if((NdefReg->RecordsExtracted->Tnf & PH_FRINFC_NDEFRECORD_TNF_MASK ) == |
| PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) |
| { |
| if(NdefReg->MainTnfFound == 1) |
| { |
| /* Matching RTD is there */ |
| TnfMatchFound = 1; |
| } |
| } |
| else |
| { |
| if(NdefReg->newRecordextracted) |
| { |
| NdefReg->MainTnfFound = 0; |
| } |
| /* This is a tnf other than 0x06. |
| that means, this is a valid tnf */ |
| NdefReg->validPreviousTnf = NdefReg->RecordsExtracted->Tnf; |
| |
| /* First, Match should be done with The TNF*/ |
| /* Second, Match should be done with The Typelength*/ |
| /* Third, Match should be done with The Type*/ |
| if((NdefReg->NdefTypeList->Tnf[NdefReg->RtdIndex] & |
| PH_FRINFC_NDEFRECORD_TNF_MASK ) == |
| (NdefReg->RecordsExtracted->Tnf & PH_FRINFC_NDEFRECORD_TNF_MASK ) && |
| (NdefReg->NdefTypeList->NdeftypeLength[NdefReg->RtdIndex] == |
| NdefReg->RecordsExtracted->TypeLength)) |
| { |
| matchFound = 0; |
| switch(NdefReg->NdefTypeList->Tnf[NdefReg->RtdIndex]) |
| { |
| case 1: |
| /* TNF = 0X01 NFC Forum well-known type : Case sensitive |
| comparison is to be made. */ |
| if(!phFriNfc_NdefReg_Strncmp((const int8_t *)NdefReg->NdefTypeList->NdefType[NdefReg->RtdIndex], |
| (const int8_t *)(NdefReg->RecordsExtracted->Type), |
| NdefReg->RecordsExtracted->TypeLength)) |
| { |
| matchFound = 1; |
| } |
| break; |
| |
| case 2: |
| case 4: |
| /* For TNF = 0X02 Media-type as defined in RFC 2046 |
| From iana.org, it has never been found any registered media type |
| with non-ascii character ==> Comparison to be used for *types* in |
| *registry*: case INSENSITIVE comparison. */ |
| |
| /* For TNF = 0X04 NFC Forum external type : ==> Comparison to be used |
| for *types* in *registry* : case INSENSITIVE comparison */ |
| if( !phFriNfc_NdefReg_Strnicmp( (int8_t *)NdefReg->NdefTypeList->NdefType[NdefReg->RtdIndex], |
| (int8_t *)(NdefReg->RecordsExtracted->Type), |
| NdefReg->RecordsExtracted->TypeLength)) |
| { |
| matchFound = 1; |
| } |
| break; |
| |
| case 3: |
| /* TNF = 0X03 Absolute URI as defined in RFC 3986 [RFC 3986] |
| Big issue concerning the Encoding, which is actually determined |
| by the application.Conclusion is that: Comparison to be used for |
| *types* in *registry*: NONE. only TNF ; type should be ignored, |
| and its comparison shall be done by the application. */ |
| matchFound = 1; |
| break; |
| default: |
| break; |
| } |
| if(matchFound == 1) |
| { |
| TnfMatchFound = 1; |
| NdefReg->MainTnfFound = 1; |
| } |
| else |
| { |
| TnfMatchFound = 0; |
| } |
| } |
| else |
| { |
| TnfMatchFound = 0; |
| } |
| } |
| |
| /* we have found a matching TNF */ |
| if(TnfMatchFound == 1) |
| { |
| /* Copy the chunked flag info to the callback parameter */ |
| NdefReg->CbParam->Chunked[count] = NdefReg->IsChunked[NdefReg->RecordIndex]; |
| |
| /* Copy the raw record to the callback parameter */ |
| NdefReg->CbParam->RawRecord[count] = NdefReg->NdefTypes[NdefReg->RecordIndex]; |
| |
| /* Copy the raw record size to the callback parameter */ |
| NdefReg->CbParam->RawRecordSize[count] = phFriNfc_NdefRecord_GetLength(NdefReg->RecordsExtracted); |
| |
| /* Copy the record in the format phFriNfc_NdefRecord_t |
| to the callback parameter */ |
| (void) memcpy( &NdefReg->CbParam->Records[count], |
| NdefReg->RecordsExtracted, |
| sizeof(phFriNfc_NdefRecord_t)); |
| |
| |
| /*if count is greater than PH_FRINFC_NDEFREG_MAX_RTD (presently 8) |
| then call the callback since there can be more than |
| PH_FRINFC_NDEFREG_MAX_RTD of a single type with in the packet,as a result |
| call the callback and initialize count to zero.This may also happen |
| when there are chunked records */ |
| |
| count++; |
| if(count >= PH_FRINFC_NDEFREG_MAX_RTD ) |
| { |
| NdefReg->CbParam->Count = count; |
| NdefReg->CbParam->CbContext = NdefReg->NdefTypeList->CbContext; |
| NdefReg->NdefTypeList->NdefCallback (NdefReg->CbParam); |
| count=0; |
| /* Only one callback per node. */ |
| NdefReg->RecordIndex++; |
| return(0); |
| } |
| } |
| |
| /* If the match is already found for the UNCHANGED_TNF, |
| don't comapre it again */ |
| if((NdefReg->RecordsExtracted->Tnf & PH_FRINFC_NDEFRECORD_TNF_MASK ) |
| == PH_FRINFC_NDEFRECORD_TNF_UNCHANGED && |
| TnfMatchFound == 1) |
| { |
| TnfMatchFound = 0; |
| break; |
| } |
| |
| NdefReg->RtdIndex++; |
| |
| NdefReg->newRecordextracted = 0; |
| } /* for each RTD in the present node |
| while(NdefReg->RtdIndex < NdefReg->NdefTypeList->NumberOfRTDs) */ |
| |
| /* One Record processing done for this node */ |
| |
| NdefReg->RtdIndex = 0; |
| NdefReg->RecordIndex++; |
| } /* while(NdefReg->RecordIndex<NdefReg->NumberOfNdefTypes) */ |
| |
| /* One node has been checked. Move to the next node */ |
| |
| if(count>0) |
| { |
| NdefReg->CbParam->Count = count; |
| NdefReg->CbParam->CbContext = NdefReg->NdefTypeList->CbContext; |
| NdefReg->NdefTypeList->NdefCallback (NdefReg->CbParam); |
| } |
| else |
| { |
| NdefReg->CbParam->Count = 0; |
| } |
| |
| if(NdefReg->NdefTypeList->Next==NULL) |
| { |
| /* All the nodes have been checked. Return */ |
| NdefReg->State = PH_FRINFC_NDEFREG_STATE_INIT; |
| while(NdefReg->NdefTypeList->Previous!=NULL) |
| { |
| NdefReg->NdefTypeList = NdefReg->NdefTypeList->Previous; |
| } |
| /* No further node present in the list. |
| End of Dispatch packet function. Return TRUE*/ |
| ret_val = 1; |
| } |
| else |
| { |
| /* Move the linked list by one node.*/ |
| NdefReg->NdefTypeList = NdefReg->NdefTypeList->Next; |
| /* list is not empty so come again */ |
| ret_val = 0; |
| } |
| |
| /* Start from the first record again. */ |
| NdefReg->RecordIndex = 0; |
| NdefReg->RtdIndex = 0; |
| |
| break; |
| |
| default: |
| /* return error */ |
| *Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_REGISTRY, NFCSTATUS_INVALID_DEVICE_REQUEST); |
| /* Unknown state Error exit from the process function */ |
| ret_val= 1; |
| break; |
| |
| } |
| |
| return(ret_val); |
| |
| } |
| |
| |
