/* * 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_NdefRecord.c * \brief NFC Ndef Record component file. * * Project: NFC-FRI * * $Date: Thu Jun 25 11:01:24 2009 $ * $Author: ing07336 $ * $Revision: 1.4 $ * $Aliases: 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 $ * */ /*! \ingroup grp_file_attributes * \name \name NDEF Record Tools Header * * File: \ref phFriNfc_NdefRecord.h * */ /*@{*/ #define PHFRINFCNDEFRECORD_FILEREVISION "$Revision: 1.4 $" #define PHFRINFCNDEFRECORD_FILEALIASES "$Aliases: 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 #include #include /* Harsha: To Fix: 0000358: phFriNfc_NdefRecord.h: includes should be moved */ #include /*! * * Get a specific NDEF record from the data, provided by the caller. The data is a buffer holding * one or more (nested) NDEF records within a NDEF packet (received via the NFC link, for example). * * \param[in] Buffer The data buffer holding the NDEF Message, as provided by the caller. * \param[in] BufferLength The data length, as provided by the caller. * \param[in,out] RawRecords Array of pointers, receiving the references to the found Ndef Records * in the Message. The caller has to provide the array of pointers. * The array is filled with valid pointers up to the number of records * found or the array size if the number of found records exceeds the size. * If the value is NULL the function only yields the number of records * without filling in pointers. * \param[in] IsChunked This boolean tells the user that the record of a certain position within * an array has the CHUNKED flag set (is a partial record). The number * of caller-provided array positions has to be the same as "NumberOfRawRecords". * In case that this parameter is NULL the function ignores it. * \param[in,out] NumberOfRawRecords Length of the Record pointer array. The caller has to provide * the number of pointers provided in the NDEF Type array. \n * The value is set by the extracting function to the actual number of * records found in the data. If the user specifies 0 (zero) the function * only yields the number of records without filling in pointers.\n * The value of NULL is invalid. * * \retval NFCSTATUS_SUCCESS Operation successful. * \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid. * * \note The correct number of found records is returned by the function also in case that: * - The "RawRecords" array is too short to hold all values: It is filled up to the allowed maximum. * - The "RawRecords" array is NULL: Only the number is returned. * - The "NumberOfRawRecords" parameter is 0 (zero): The array is not filled, just the number is returned. * . * This can be exploited for targeted memory allocation: Specify NULL for "RawRecords" and/or * 0 (zero) for "NumberOfRawRecords" and the function yields the correct array size to allocate * for a second call. * */ NFCSTATUS phFriNfc_NdefRecord_GetRecords( uint8_t *Buffer, uint32_t BufferLength, uint8_t *RawRecords[], uint8_t IsChunked[], uint32_t *NumberOfRawRecords) { NFCSTATUS Status = NFCSTATUS_SUCCESS; uint8_t PayloadLengthByte = 0, TypeLengthByte = 0, TypeLength = 0, IDLengthByte = 0, NoOfRecordsReturnFlag = 0, IDLength = 0; uint32_t Count = 0, PayloadLength = 0, BytesTraversed = 0; /* Validate the input parameters */ if (Buffer == NULL || BufferLength == 0 || NumberOfRawRecords == NULL) { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_PARAMETER); return Status; } if((*NumberOfRawRecords) > 0) { /* The number of caller-provided array positions for the array IsChunked has to be the same as NumberOfRawRecords. Hence, if NumberOfRawRecords > 0, the array IsChunked cannot be null */ if(IsChunked == NULL) { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_PARAMETER); return Status; } } /* Check Raw Records input is NULL and Number of Raw records is 0*/ if ( RawRecords == NULL || *NumberOfRawRecords == 0) { /* This flag is set, to return only number of records this is done when the Raw Records is NULL or Number of Raw records is 0 */ NoOfRecordsReturnFlag = 1; } /* Check for the MB bit*/ if ((*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_MB) != PH_FRINFC_NDEFRECORD_FLAGS_MB ) { /* MB Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); /* Number of valid records found in the message is 0 */ *NumberOfRawRecords = 0; return Status; } /* Check for Tnf bits 0x07 is reserved for future use */ if ((*Buffer & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) == PH_FRINFC_NDEFRECORD_TNF_RESERVED) { /* TNF 07 Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); /* Number of valid records found in the message is 0 */ *NumberOfRawRecords = 0; return Status; } /* Check the First Record(MB = 0) for TNF = 0x06(Unchanged) */ if ((*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_MB) == PH_FRINFC_NDEFRECORD_FLAGS_MB && (*Buffer & PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) == PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); /* Number of valid records found in the message is 0 */ *NumberOfRawRecords = 0; return Status; } /* First Record i.e., MB = 1, TNF != 0x05 and TypeLength = 0 */ if ( (*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_MB) == PH_FRINFC_NDEFRECORD_FLAGS_MB && (*Buffer & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) != PH_FRINFC_NDEFRECORD_TNF_UNKNOWN && (*Buffer & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) != PH_FRINFC_NDEFRECORD_TNF_EMPTY && *(Buffer + 1) == 0) { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); /* Number of valid records found in the message is 0 */ *NumberOfRawRecords = 0; return Status; } /* Check till Buffer Length exceeds */ while ( BytesTraversed < BufferLength ) { if (Buffer == NULL) { break; } /* For Each Record Check whether it contains the ME bit set and CF bit Set if YES return ERROR*/ if ((*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_CF) == PH_FRINFC_NDEFRECORD_FLAGS_CF && (*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_ME) == PH_FRINFC_NDEFRECORD_FLAGS_ME) { /* CF and ME Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); break; } if (NoOfRecordsReturnFlag == 0) { /* Harsha: Fix for 0000241: [gk], NDEF Tools: GetRecords() overshoots a given array boundary if the number of records != 0. */ /* Actual Number of Records should not exceed Number of records required by caller*/ if(Count >= *NumberOfRawRecords) { break; } /* To fix the mantis entry 0388 */ if((Buffer != NULL)&&(RawRecords!=NULL))/*QMOR FIX*/ { RawRecords[Count] = Buffer; } else { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_PARAMETER); break; } } /* To Calculate the IDLength and PayloadLength for short or normal record */ Status = phFriNfc_NdefRecord_RecordIDCheck ( Buffer, &TypeLength, &TypeLengthByte, &PayloadLengthByte, &PayloadLength, &IDLengthByte, &IDLength); if (Status != NFCSTATUS_SUCCESS) { break; } /* Check for the Chunk Flag */ if (NoOfRecordsReturnFlag == 0) { /* If NoOfRecordsReturnFlag = 0, that means we have enough space */ /* in the array IsChunked, to write */ if ((*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_CF) == PH_FRINFC_NDEFRECORD_FLAGS_CF) { IsChunked [Count] = PHFRINFCNDEFRECORD_CHUNKBIT_SET; } else { IsChunked [Count] = PHFRINFCNDEFRECORD_CHUNKBIT_SET_ZERO; } } /* Check the record is not the first record */ if (Count > 0) { /* Not a first record, if chunk record is present and IL bit is set also if the MB bit is set */ if(((*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_CF) == PH_FRINFC_NDEFRECORD_FLAGS_CF && (*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_IL) == PH_FRINFC_NDEFRECORD_FLAGS_IL && (*Buffer & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) == PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) || (*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_MB) == PH_FRINFC_NDEFRECORD_FLAGS_MB) { /* IL or MB Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); break; } /* Check for the Chunk Flag */ if (NoOfRecordsReturnFlag == 0) { /* If NoOfRecordsReturnFlag = 0, that means the array IsChunked contains valid values. So, cannot check the value of IsChunked if NoOfRecordsReturnFlag = 1. */ /* Check whether the previous record has the chunk flag and TNF of present record is not 0x06 */ if (IsChunked [Count - 1] == PHFRINFCNDEFRECORD_CHUNKBIT_SET && (*Buffer & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) != PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) { /* CF or TNF Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); break; } /* Check whether the previous record doesnot have the chunk flag and TNF of present record is 0x06 */ if (IsChunked [Count - 1] == PHFRINFCNDEFRECORD_CHUNKBIT_SET_ZERO && (*Buffer & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) == PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) { /* CF or TNF Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); break; } /* Check for the last chunk */ if (IsChunked [Count - 1] == PHFRINFCNDEFRECORD_CHUNKBIT_SET && IsChunked [Count] == PHFRINFCNDEFRECORD_CHUNKBIT_SET_ZERO) { /* Check for the TypeLength, IDLength = 0 */ if (TypeLength != 0 || IDLength != 0) { /* last chunk record Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); break; } } } /* if (NoOfRecordsReturnFlag == 0) */ } /* if (Count > 0) */ /* Calculate the bytes already traversed. */ BytesTraversed = (BytesTraversed + PayloadLengthByte + IDLengthByte + TypeLength + IDLength + TypeLengthByte + PayloadLength + PH_FRINFC_NDEFRECORD_BUF_INC1); if(BytesTraversed == BufferLength) { /* We have reached the last record, and everything is fine. */ /* Check for the ME Byte */ if ((*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_ME) == PH_FRINFC_NDEFRECORD_FLAGS_ME) { Count++; break; } else { /* Each message must have ME flag in the last record, Since ME is not set raise an error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); break; } } else { /* Buffer Overshoot: Inconsistency in the message length and actual value of the bytes in the message detected. Report error.*/ if(BytesTraversed > BufferLength) { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); break; } } /* For Each Record Check whether it contains the ME bit set if YES return*/ if ((*Buffer & PH_FRINFC_NDEFRECORD_FLAGS_ME) == PH_FRINFC_NDEFRECORD_FLAGS_ME) { Count++; break; } /* +1 is for first byte */ Buffer = (Buffer + PayloadLengthByte + IDLengthByte + TypeLength + TypeLengthByte + IDLength + PayloadLength + PH_FRINFC_NDEFRECORD_BUF_INC1); /* Increment the number of valid records found in the message */ Count++; } /* Whatever is the error, update the NumberOfRawRecords with the number of proper records found till the error was detected in the message. */ *NumberOfRawRecords = Count; return Status; } /* to check the bitfields in the Flags Byte and return the status flag */ static uint8_t phFriNfc_NdefRecord_NdefFlag(uint8_t Flags,uint8_t Mask) { uint8_t check_flag = 0x00; check_flag = Flags & Mask; return check_flag; } uint32_t phFriNfc_NdefRecord_GetLength(phFriNfc_NdefRecord_t *Record) { uint32_t RecordLength=1; uint8_t FlagCheck=0; FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Tnf,PH_FRINFC_NDEFRECORD_TNFBYTE_MASK); /* Type length is present only for following TNF PH_FRINFC_NDEFRECORD_TNF_NFCWELLKNOWN PH_FRINFC_NDEFRECORD_TNF_MEDIATYPE PH_FRINFC_NDEFRECORD_TNF_ABSURI PH_FRINFC_NDEFRECORD_TNF_NFCEXT */ /* ++ is for the Type Length Byte */ RecordLength++; if( FlagCheck != PH_FRINFC_NDEFRECORD_TNF_EMPTY && FlagCheck != PH_FRINFC_NDEFRECORD_TNF_UNKNOWN && FlagCheck != PH_FRINFC_NDEFRECORD_TNF_UNCHANGED ) { RecordLength += Record->TypeLength; } /* to check if payloadlength is 8bit or 32bit*/ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Flags,PH_FRINFC_NDEFRECORD_FLAGS_SR); if(FlagCheck!=0) { /* ++ is for the Payload Length Byte */ RecordLength++;/* for short record*/ } else { /* + PHFRINFCNDEFRECORD_NORMAL_RECORD_BYTE is for the Payload Length Byte */ RecordLength += PHFRINFCNDEFRECORD_NORMAL_RECORD_BYTE;/* for normal record*/ } /* for non empty record */ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Tnf,PH_FRINFC_NDEFRECORD_TNFBYTE_MASK); if(FlagCheck != PH_FRINFC_NDEFRECORD_TNF_EMPTY) { RecordLength += Record->PayloadLength; } /* ID and IDlength are present only if IL flag is set*/ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Flags,PH_FRINFC_NDEFRECORD_FLAGS_IL); if(FlagCheck!=0) { RecordLength +=Record->IdLength; /* ++ is for the ID Length Byte */ RecordLength ++; } return RecordLength; } /*! * * Extract a specific NDEF record from the data, provided by the caller. The data is a buffer holding * at least the entire NDEF record (received via the NFC link, for example). * * \param[out] Record The NDEF record structure. The storage for the structure has to be provided by the * caller matching the requirements for \b Extraction, as described in the compound * documentation. * \param[in] RawRecord The Pointer to the buffer, selected out of the array returned by * the \ref phFriNfc_NdefRecord_GetRecords function. * * \retval NFCSTATUS_SUCCESS Operation successful. * \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid. * * \note There are some caveats: * - The "RawRecord" Data buffer must exist at least as long as the function execution time plus the time * needed by the caller to evaluate the extracted information. No copying of the contained data is done. * - Using the "RawRecord" and "RawRecordMaxSize" parameters the function internally checks whether the * data to extract are within the bounds of the buffer. * * */ NFCSTATUS phFriNfc_NdefRecord_Parse(phFriNfc_NdefRecord_t *Record, uint8_t *RawRecord) { NFCSTATUS Status = NFCSTATUS_SUCCESS; uint8_t PayloadLengthByte = 0, TypeLengthByte = 0, TypeLength = 0, IDLengthByte = 0, IDLength = 0, Tnf = 0; uint32_t PayloadLength = 0; if (Record == NULL || RawRecord == NULL) { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_PARAMETER); } else { /* Calculate the Flag Value */ Record->Flags = phFriNfc_NdefRecord_RecordFlag ( RawRecord); /* Calculate the Type Namr format of the record */ Tnf = phFriNfc_NdefRecord_TypeNameFormat( RawRecord); if(Tnf != 0xFF) { Record->Tnf = Tnf; /* To Calculate the IDLength and PayloadLength for short or normal record */ Status = phFriNfc_NdefRecord_RecordIDCheck ( RawRecord, &TypeLength, &TypeLengthByte, &PayloadLengthByte, &PayloadLength, &IDLengthByte, &IDLength); Record->TypeLength = TypeLength; Record->PayloadLength = PayloadLength; Record->IdLength = IDLength; RawRecord = (RawRecord + PayloadLengthByte + IDLengthByte + TypeLengthByte + PH_FRINFC_NDEFRECORD_BUF_INC1); Record->Type = RawRecord; RawRecord = (RawRecord + Record->TypeLength); if (Record->IdLength != 0) { Record->Id = RawRecord; } RawRecord = RawRecord + Record->IdLength; Record->PayloadData = RawRecord; } else { Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_PARAMETER); } } return Status; } /*! * The function writes one NDEF record to a specified memory location. Called within a loop, it is possible to * write more records into a contiguous buffer, in each cycle advancing by the number of bytes written for * each record. * * \param[in] Record The Array of NDEF record structures to append. The structures * have to be filled by the caller matching the requirements for * \b Composition, as described in the documentation of * the \ref phFriNfc_NdefRecord_t "NDEF Record" structure. * \param[in] Buffer The pointer to the buffer. * \param[in] MaxBufferSize The data buffer's maximum size, provided by the caller. * \param[out] BytesWritten The actual number of bytes written to the buffer. This can be used by * the caller to serialise more than one record into the same buffer before * handing it over to another instance. * * \retval NFCSTATUS_SUCCESS Operation successful. * \retval NFCSTATUS_INVALID_PARAMETER At least one parameter of the function is invalid. * \retval NFCSTATUS_BUFFER_TOO_SMALL The data buffer, provided by the caller is to small to * hold the composed NDEF record. The existing content is not changed. * */ NFCSTATUS phFriNfc_NdefRecord_Generate(phFriNfc_NdefRecord_t *Record, uint8_t *Buffer, uint32_t MaxBufferSize, uint32_t *BytesWritten) { uint8_t FlagCheck, TypeCheck=0, *temp, i; uint32_t i_data=0; if(Record==NULL ||Buffer==NULL||BytesWritten==NULL||MaxBufferSize == 0) { return (PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_PARAMETER)); } if (Record->Tnf == PH_FRINFC_NDEFRECORD_TNF_RESERVED) { return (PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT)); } /* calculate the length of the record and check with the buffersize if it exceeds return */ i_data=phFriNfc_NdefRecord_GetLength(Record); if(i_data > MaxBufferSize) { return (PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_BUFFER_TOO_SMALL)); } *BytesWritten = i_data; /*fill the first byte of the message(all the flags) */ /*increment the buffer*/ *Buffer = ( (Record->Flags & PH_FRINFC_NDEFRECORD_FLAG_MASK) | (Record->Tnf & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK)); Buffer++; /* check the TypeNameFlag for PH_FRINFC_NDEFRECORD_TNF_EMPTY */ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Tnf,PH_FRINFC_NDEFRECORD_TNFBYTE_MASK); if(FlagCheck == PH_FRINFC_NDEFRECORD_TNF_EMPTY) { /* fill the typelength idlength and payloadlength with zero(empty message)*/ for(i=0;i<3;i++) { *Buffer=PH_FRINFC_NDEFRECORD_BUF_TNF_VALUE; Buffer++; } return (PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS)); } /* check the TypeNameFlag for PH_FRINFC_NDEFRECORD_TNF_RESERVED */ /* TNF should not be reserved one*/ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Tnf,PH_FRINFC_NDEFRECORD_TNFBYTE_MASK); if(FlagCheck == PH_FRINFC_NDEFRECORD_TNF_RESERVED) { return (PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_PARAMETER)); } /* check for TNF Unknown or Unchanged */ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Tnf,PH_FRINFC_NDEFRECORD_TNFBYTE_MASK); if(FlagCheck == PH_FRINFC_NDEFRECORD_TNF_UNKNOWN || \ FlagCheck == PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) { *Buffer = PH_FRINFC_NDEFRECORD_BUF_TNF_VALUE; Buffer++; } else { *Buffer = Record->TypeLength; Buffer++; TypeCheck=1; } /* check for the short record bit if it is then payloadlength is only one byte */ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Flags,PH_FRINFC_NDEFRECORD_FLAGS_SR); if(FlagCheck!=0) { *Buffer = (uint8_t)(Record->PayloadLength & 0x000000ff); Buffer++; } else { /* if it is normal record payloadlength is 4 byte(32 bit)*/ *Buffer = (uint8_t)((Record->PayloadLength & 0xff000000) >> PHNFCSTSHL24); Buffer++; *Buffer = (uint8_t)((Record->PayloadLength & 0x00ff0000) >> PHNFCSTSHL16); Buffer++; *Buffer = (uint8_t)((Record->PayloadLength & 0x0000ff00) >> PHNFCSTSHL8); Buffer++; *Buffer = (uint8_t)((Record->PayloadLength & 0x000000ff)); Buffer++; } /*check for IL bit set(Flag), if so then IDlength is present*/ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Flags,PH_FRINFC_NDEFRECORD_FLAGS_IL); if(FlagCheck!=0) { *Buffer=Record->IdLength; Buffer++; } /*check for TNF and fill the Type*/ temp=Record->Type; if(TypeCheck!=0) { for(i=0;i<(Record->TypeLength);i++) { *Buffer = *temp; Buffer++; temp++; } } /*check for IL bit set(Flag), if so then IDlength is present and fill the ID*/ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Flags,PH_FRINFC_NDEFRECORD_FLAGS_IL); temp=Record->Id; if(FlagCheck!=0) { for(i=0;i<(Record->IdLength);i++) { *Buffer = *temp; Buffer++; temp++; } } temp=Record->PayloadData; /*check for SR bit and then correspondingly use the payload length*/ FlagCheck=phFriNfc_NdefRecord_NdefFlag(Record->Flags,PH_FRINFC_NDEFRECORD_FLAGS_SR); for(i_data=0;i_data < (Record->PayloadLength) ;i_data++) { *Buffer = *temp; Buffer++; temp++; } return (PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS)); } /* Calculate the Flags of the record */ static uint8_t phFriNfc_NdefRecord_RecordFlag ( uint8_t *Record) { uint8_t flag = 0; if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_MB) == PH_FRINFC_NDEFRECORD_FLAGS_MB ) { flag = flag | PH_FRINFC_NDEFRECORD_FLAGS_MB; } if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_ME) == PH_FRINFC_NDEFRECORD_FLAGS_ME ) { flag = flag | PH_FRINFC_NDEFRECORD_FLAGS_ME; } if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_CF) == PH_FRINFC_NDEFRECORD_FLAGS_CF ) { flag = flag | PH_FRINFC_NDEFRECORD_FLAGS_CF; } if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_SR) == PH_FRINFC_NDEFRECORD_FLAGS_SR ) { flag = flag | PH_FRINFC_NDEFRECORD_FLAGS_SR; } if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_IL) == PH_FRINFC_NDEFRECORD_FLAGS_IL ) { flag = flag | PH_FRINFC_NDEFRECORD_FLAGS_IL; } return flag; } /* Calculate the Type Name Format for the record */ static uint8_t phFriNfc_NdefRecord_TypeNameFormat ( uint8_t *Record) { uint8_t tnf = 0; switch (*Record & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) { case PH_FRINFC_NDEFRECORD_TNF_EMPTY: tnf = PH_FRINFC_NDEFRECORD_TNF_EMPTY; break; case PH_FRINFC_NDEFRECORD_TNF_NFCWELLKNOWN: tnf = PH_FRINFC_NDEFRECORD_TNF_NFCWELLKNOWN; break; case PH_FRINFC_NDEFRECORD_TNF_MEDIATYPE: tnf = PH_FRINFC_NDEFRECORD_TNF_MEDIATYPE; break; case PH_FRINFC_NDEFRECORD_TNF_ABSURI: tnf = PH_FRINFC_NDEFRECORD_TNF_ABSURI; break; case PH_FRINFC_NDEFRECORD_TNF_NFCEXT: tnf = PH_FRINFC_NDEFRECORD_TNF_NFCEXT; break; case PH_FRINFC_NDEFRECORD_TNF_UNKNOWN: tnf = PH_FRINFC_NDEFRECORD_TNF_UNKNOWN; break; case PH_FRINFC_NDEFRECORD_TNF_UNCHANGED: tnf = PH_FRINFC_NDEFRECORD_TNF_UNCHANGED; break; case PH_FRINFC_NDEFRECORD_TNF_RESERVED: tnf = PH_FRINFC_NDEFRECORD_TNF_RESERVED; break; default : tnf = 0xFF; break; } return tnf; } static NFCSTATUS phFriNfc_NdefRecord_RecordIDCheck ( uint8_t *Record, uint8_t *TypeLength, uint8_t *TypeLengthByte, uint8_t *PayloadLengthByte, uint32_t *PayloadLength, uint8_t *IDLengthByte, uint8_t *IDLength) { NFCSTATUS Status = NFCSTATUS_SUCCESS; /* Check for Tnf bits 0x07 is reserved for future use */ if ((*Record & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) == PH_FRINFC_NDEFRECORD_TNF_RESERVED) { /* TNF 07 Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); return Status; } /* Check for Type Name Format depending on the TNF, Type Length value is set*/ if ((*Record & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK)== PH_FRINFC_NDEFRECORD_TNF_EMPTY) { *TypeLength = *(Record + PH_FRINFC_NDEFRECORD_BUF_INC1); if (*(Record + PH_FRINFC_NDEFRECORD_BUF_INC1) != 0) { /* Type Length Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); return Status; } *TypeLengthByte = 1; /* Check for Short Record */ if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_SR) == PH_FRINFC_NDEFRECORD_FLAGS_SR) { /* For Short Record, Payload Length Byte is 1 */ *PayloadLengthByte = 1; /* 1 for Header byte */ *PayloadLength = *(Record + *TypeLengthByte + 1); if (*PayloadLength != 0) { /* PayloadLength Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); return Status; } } else { /* For Normal Record, Payload Length Byte is 4 */ *PayloadLengthByte = PHFRINFCNDEFRECORD_NORMAL_RECORD_BYTE; *PayloadLength = ((((uint32_t)(*(Record + PH_FRINFC_NDEFRECORD_BUF_INC2))) << PHNFCSTSHL24) + (((uint32_t)(*(Record + PH_FRINFC_NDEFRECORD_BUF_INC3))) << PHNFCSTSHL16) + (((uint32_t)(*(Record + PH_FRINFC_NDEFRECORD_BUF_INC4))) << PHNFCSTSHL8) + *(Record + PH_FRINFC_NDEFRECORD_BUF_INC5)); if (*PayloadLength != 0) { /* PayloadLength Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); return Status; } } /* Check for ID Length existence */ if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_IL) == PH_FRINFC_NDEFRECORD_FLAGS_IL) { /* Length Byte exists and it is 1 byte */ *IDLengthByte = 1; /* 1 for Header byte */ *IDLength = (uint8_t)*(Record + *PayloadLengthByte + *TypeLengthByte + PH_FRINFC_NDEFRECORD_BUF_INC1); if (*IDLength != 0) { /* IDLength Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); return Status; } } else { *IDLengthByte = 0; *IDLength = 0; } } else { if ((*Record & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK)== PH_FRINFC_NDEFRECORD_TNF_UNKNOWN || (*Record & PH_FRINFC_NDEFRECORD_TNFBYTE_MASK) == PH_FRINFC_NDEFRECORD_TNF_UNCHANGED) { if (*(Record + PH_FRINFC_NDEFRECORD_BUF_INC1) != 0) { /* Type Length Error */ Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_RECORD, NFCSTATUS_INVALID_FORMAT); return Status; } *TypeLength = 0; *TypeLengthByte = 1; } else { /* 1 for Header byte */ *TypeLength = *(Record + PH_FRINFC_NDEFRECORD_BUF_INC1); *TypeLengthByte = 1; } /* Check for Short Record */ if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_SR) == PH_FRINFC_NDEFRECORD_FLAGS_SR) { /* For Short Record, Payload Length Byte is 1 */ *PayloadLengthByte = 1; /* 1 for Header byte */ *PayloadLength = *(Record + *TypeLengthByte + PH_FRINFC_NDEFRECORD_BUF_INC1); } else { /* For Normal Record, Payload Length Byte is 4 */ *PayloadLengthByte = PHFRINFCNDEFRECORD_NORMAL_RECORD_BYTE; *PayloadLength = ((((uint32_t)(*(Record + PH_FRINFC_NDEFRECORD_BUF_INC2))) << PHNFCSTSHL24) + (((uint32_t)(*(Record + PH_FRINFC_NDEFRECORD_BUF_INC3))) << PHNFCSTSHL16) + (((uint32_t)(*(Record + PH_FRINFC_NDEFRECORD_BUF_INC4))) << PHNFCSTSHL8) + *(Record + PH_FRINFC_NDEFRECORD_BUF_INC5)); } /* Check for ID Length existence */ if ((*Record & PH_FRINFC_NDEFRECORD_FLAGS_IL) == PH_FRINFC_NDEFRECORD_FLAGS_IL) { *IDLengthByte = 1; /* 1 for Header byte */ *IDLength = (uint8_t)*(Record + *PayloadLengthByte + *TypeLengthByte + PH_FRINFC_NDEFRECORD_BUF_INC1); } else { *IDLengthByte = 0; *IDLength = 0; } } return Status; }