Initial libnfc checkin

Source: Trusted_NFC_Device_Host_AA03.01e02_google.zip code drop (23-Sep-2010)

Change-Id: Ie47f18423f949a8d3e0815d13f55c814312add24
Signed-off-by: Nick Pelly <npelly@google.com>

1 files changed, 679 insertions, 0 deletions

diff --git a/src/phFriNfc_NdefReg.c b/src/phFriNfc_NdefReg.c
new file mode 100644
index 0000000..b39bf04
--- /dev/null
+++ b/src/phFriNfc_NdefReg.c
@@ -0,0 +1,679 @@
+/*
+ * 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);
+
+}
+
+