//-------------------------------------------------------------------------
// Desc:	Read a record from the database.
// Tabs:	3
//
//		Copyright (c) 1991-2006 Novell, Inc. All Rights Reserved.
//
//		This program is free software; you can redistribute it and/or
//		modify it under the terms of version 2 of the GNU General Public
//		License as published by the Free Software Foundation.
//
//		This program is distributed in the hope that it will be useful,
//		but WITHOUT ANY WARRANTY; without even the implied warranty of
//		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//		GNU General Public License for more details.
//
//		You should have received a copy of the GNU General Public License
//		along with this program; if not, contact Novell, Inc.
//
//		To contact Novell about this file by physical or electronic mail,
//		you may find current contact information at www.novell.com
//
// $Id: fsrecget.cpp 12329 2006-01-20 17:49:30 -0700 (Fri, 20 Jan 2006) ahodgkinson $
//-------------------------------------------------------------------------

#include "flaimsys.h"

typedef struct Field_State
{
	// State information to position to the field within the element
	FLMBYTE *		pElement;				// Points to the element within block
	FLMUINT			uiFieldType;				// Storage field type
	FLMUINT			uiFieldLen;				// Length of storage if known
	FLMUINT			uiPosInElm;				// Position within the element
	FLMUINT			uiTagNum;				// Field tag/data dictionary number
	FLMUINT			uiLevel;					// Current level number
	FLMUINT			uiEncId;					// EncDef ID if encrypted
	FLMUINT			uiEncFieldLen;			// Encrypted field length
} FSTATE;						

typedef struct Data_Piece
{													// Data is garbage when uiFieldLen is 0.
	FLMBYTE *		pData;					// Points to data within the block.
	FLMUINT			uiLength;				// Length of this data piece
	struct Data_Piece * pNext;				// Next data piece or NULL
} DATAPIECE;

typedef struct Temporary_Field
{
	FLMUINT			uiLevel;
	FLMUINT			uiFieldID;
	FLMUINT			uiFieldType;
	FLMUINT			uiFieldLen;
	FLMUINT			uiEncId;
	FLMUINT			uiEncFieldLen;
	DATAPIECE		DataPiece;
} TEMPFIELD;

#define NUM_FIELDS_IN_ARRAY			16

typedef struct Field_Group
{
	TEMPFIELD				pFields[ NUM_FIELDS_IN_ARRAY];	// Allocated array of fields
	struct Field_Group * pNext;									// Next temporary field group
} FLDGROUP;

typedef struct Locked_Block
{
	SCACHE *			pSCache;
	struct Locked_Block *pNext;
} LOCKED_BLOCK;
	
FSTATIC RCODE FSGetFldOverhead(
	FDB_p			pDb,
	FSTATE *		fState);

/***************************************************************************
Desc:	Retrieves a record given a DRN
*****************************************************************************/
RCODE FSReadRecord(						// Was FSRecordGet
	FDB_p				pDb,
	LFILE * 			pLFile,
	FLMUINT			uiDrn,
	FlmRecord **	ppRecord,				// [out] returned record
	FLMUINT *		puiRecTransId,			// [out] record's transaction ID
	FLMBOOL *		pbMostCurrent)			// [out] true if record is most current
{
	RCODE			rc;
	BTSK			stackBuf[ BH_MAX_LEVELS ];
	BTSK_p		pStack = NULL;
	FLMBYTE		pKeyBuf[ DIN_KEY_SIZ ];
	FLMBYTE		pDrnBuf[ DIN_KEY_SIZ ];

	FSInitStackCache( &stackBuf [0], BH_MAX_LEVELS);

	pStack = stackBuf;							// Initialize the stack
	pStack->pKeyBuf = pKeyBuf;

	// Search the B-TREE for the record
	flmUINT32ToBigEndian( (FLMUINT32)uiDrn, pDrnBuf);
	if( RC_OK( rc = FSBtSearch( pDb, pLFile, &pStack, pDrnBuf, 4, 0)))
	{
		rc = RC_SET( FERR_NOT_FOUND);
		if( ( pStack->uiCmpStatus == BT_EQ_KEY) && (uiDrn != DRN_LAST_MARKER))
		{
			rc = FSReadElement( pDb, &pDb->TempPool, pLFile, uiDrn, pStack,
				TRUE, ppRecord, puiRecTransId, pbMostCurrent);
		}
	}
	FSReleaseStackCache( stackBuf, BH_MAX_LEVELS, FALSE);
	return( rc );
}

/**************************************************************************
Desc:	Low level routine to retrieve and build an internal tree record.
		The caller is responsible for freeing memory that the record
		is placed into.  This routine is called by FSRecordGet()
Ret:	FERR_OK (0)
		FERR_NOT_FOUND - field not found
		FERR_MEM - ran out of memeory
		FERR_DATA_ERROR - the data is somehow corrupt
**************************************************************************/
RCODE FSReadElement(
	FDB_p				pDb,
	POOL *			pPool,
	LFILE *	  		pLFile,
	FLMUINT			uiDrn,
	BTSK_p			pStack,
	FLMBOOL			bOkToPreallocSpace,
	FlmRecord **	ppRecord,				// [out] returned record
	FLMUINT *		puiRecTransId,			// [out] record's transaction ID
	FLMBOOL *		pbMostCurrent)			// [out] true if record is most current
{
	RCODE				rc = FERR_OK;
	FlmRecord *		pRecord = NULL;
	FLMBYTE *		pCurElm;				// Points to the current element
	void  *			pvPoolMark = GedPoolMark( pPool);
	FLMUINT			uiElmRecLen;		// Length of element's record
	FLMUINT			uiFieldLen;			// Length of the field
	FLMUINT			uiLowestTransId;	// Lowest transaction ID.
	FLMUINT			uiFieldCount;
	FLMUINT			uiTrueDataSpace;
	FLMUINT			uiFieldPos;
	FLMBOOL			bMostCurrent;
	TEMPFIELD *		pField;
	FLDGROUP *		pFldGroup = NULL;
	FLDGROUP *		pFirstFldGroup = NULL;
	DATAPIECE *		pDataPiece;
	LOCKED_BLOCK * pLockedBlock = NULL;
	FSTATE			fState;
	FLMUINT			uiEncFieldLen;
#ifdef FLM_DBG_LOG
	char				szTmpBuf[ 80];
#endif

#ifdef FLM_DBG_LOG
	flmAssert( pStack->uiKeyLen == DIN_KEY_SIZ && 
		flmBigEndianToUINT32( pStack->pKeyBuf) == uiDrn);
#endif

	// Initialize variables
	fState.uiLevel = 0;
	uiFieldCount = 0;
	uiTrueDataSpace = 0;
	uiFieldPos = NUM_FIELDS_IN_ARRAY;

	// Check to make sure we are positioned at the first element.
	pCurElm = CURRENT_ELM( pStack );	
	if( !BBE_IS_FIRST( pCurElm))
	{
		rc = RC_SET( FERR_DATA_ERROR);
		goto Exit;
	}

	uiLowestTransId = FB2UD( &pStack->pBlk[ BH_TRANS_ID]);
	bMostCurrent = (pStack->pSCache->uiHighTransID == 0xFFFFFFFF) ? TRUE : FALSE;

#ifdef FLM_DBG_LOG
	f_sprintf( szTmpBuf, "Rd1:L%X,H%X", 
		(unsigned)uiLowestTransId, (unsigned)pStack->pSCache->uiHighTransID);

	flmDbgLogWrite( pDb->pFile->uiFFileId, pStack->pSCache->uiBlkAddress, uiDrn,
		pDb->LogHdr.uiCurrTransID, szTmpBuf);
#endif

	// Loop on each element in the record
	for( ;;)
	{
		// Setup all variables to process the current element

		uiElmRecLen = BBE_GET_RL( pCurElm );
		if( uiElmRecLen == 0)
		{
			rc = RC_SET( FERR_EOF_HIT);
			break;
		}
		pCurElm += BBE_REC_OFS( pCurElm );
		fState.uiPosInElm = 0;

		// Loop on each field within this element.
		while( fState.uiPosInElm < uiElmRecLen)
		{
			fState.pElement = pCurElm;
			if( RC_BAD( rc = FSGetFldOverhead( pDb, &fState)))
			{
				goto Exit;
			}
			uiFieldLen = fState.uiFieldLen;
			uiEncFieldLen = fState.uiEncFieldLen;

			// Old record info data - skip past for now
			if( fState.uiTagNum == 0)
			{
				fState.uiPosInElm += (uiEncFieldLen ? uiEncFieldLen : uiFieldLen);
				continue;
			}

			if( !pRecord)
			{
				// Create a new data record or use the existing data record.

				if( *ppRecord)
				{
					if( (*ppRecord)->isReadOnly())
					{
						(*ppRecord)->Release();
						*ppRecord = NULL;

						if( (pRecord = f_new FlmRecord) == NULL)
						{
							rc = RC_SET( FERR_MEM);
							goto Exit;
						}
					}
					else
					{
						// Reuse the existing FlmRecord object.

						pRecord = *ppRecord;
						*ppRecord = NULL;
						pRecord->clear();
					}
				}
				else
				{
					if( (pRecord = f_new FlmRecord) == NULL)
					{
						rc = RC_SET( FERR_MEM);
						goto Exit;
					}
				}

				pRecord->setContainerID( pLFile->uiLfNum);
				pRecord->setID( uiDrn);
				if (pLFile->bMakeFieldIdTable)
				{
					pRecord->enableFieldIdTable();
				}
			}

			// Check if out of fields in the tempoary field group.
			if( uiFieldPos >= NUM_FIELDS_IN_ARRAY)
			{
				FLDGROUP *		pTempFldGroup;

				uiFieldPos = 0;
				// Allocate the first field group from the pool.
				if( (pTempFldGroup = (FLDGROUP *) GedPoolAlloc( 
					pPool, sizeof( FLDGROUP))) == NULL)
				{
					rc = RC_SET( FERR_MEM);
					goto Exit;
				}

				pTempFldGroup->pNext = NULL;
				if( pFldGroup)
				{
					pFldGroup->pNext = pTempFldGroup;
				}
				else
				{
					pFirstFldGroup = pTempFldGroup;
				}
				pFldGroup = pTempFldGroup;
			}
			
			uiFieldCount++;
			pField = &pFldGroup->pFields[ uiFieldPos++];
			pField->uiLevel = fState.uiLevel;
			pField->uiFieldID = fState.uiTagNum;
			pField->uiFieldType = fState.uiFieldType;
			pField->uiFieldLen = fState.uiFieldLen;
			pField->uiEncId = fState.uiEncId;
			pField->uiEncFieldLen = fState.uiEncFieldLen;
			pDataPiece = &pField->DataPiece;

			if( uiFieldLen || uiEncFieldLen)
			{
				FLMUINT		uiDataPos = 0;

				if( fState.uiEncFieldLen)
				{
					uiTrueDataSpace += FLM_ENC_FLD_OVERHEAD;

					// Binary data needs to account for alignment issues.

					if (fState.uiFieldType == FLM_BINARY_TYPE)
					{
						// Adjust for the decrypted data.
						uiTrueDataSpace = ((uiTrueDataSpace + FLM_ALLOC_ALIGN) & 
												(~(FLM_ALLOC_ALIGN) & 0x7FFFFFFF));
					}

					uiTrueDataSpace += fState.uiFieldLen + fState.uiEncFieldLen;

					// Store the encrypted field length rather than the decrypted field length
					// This will allow the gathering of the encrypted or decrypted field data
					// to use the same code.
					uiFieldLen = uiEncFieldLen;

				}
				else if( fState.uiFieldLen > 4)
				{

					// Binary data needs to account for alignment issues.

					if (fState.uiFieldType == FLM_BINARY_TYPE)
					{
						if( fState.uiFieldLen >= 0xFF)
						{
							// Align so that the data is aligned - not the length

							uiTrueDataSpace += sizeof( FLMUINT16);
							uiTrueDataSpace = ((uiTrueDataSpace + FLM_ALLOC_ALIGN) &
											(~(FLM_ALLOC_ALIGN) & 0x7FFFFFFF));
							uiTrueDataSpace -= sizeof( FLMUINT16);
						}
						else
						{
							uiTrueDataSpace = ((uiTrueDataSpace + FLM_ALLOC_ALIGN) & 
													(~(FLM_ALLOC_ALIGN) & 0x7FFFFFFF));
						}
					}

					uiTrueDataSpace += fState.uiFieldLen;

					// Field values with lengths greater than 255 bytes are
					// stored length-preceded.  A single byte flags field precedes the length.

					if (fState.uiFieldLen >= 0xFF)
					{
						uiTrueDataSpace += sizeof( FLMUINT16) + 1;
					}
				}

				// Value may start in the next element.

				while( uiDataPos < uiFieldLen)
				{
					// Need to read next element for the value portion? 

					if( fState.uiPosInElm >= uiElmRecLen)
					{
						if( BBE_IS_LAST( CURRENT_ELM( pStack )))
						{
							rc = RC_SET( FERR_DATA_ERROR);
							goto Exit;
						}

						// If we are going to the next block, lock down this block
						// beacause data pointers are pointing to it.

						if( RC_BAD( FSBlkNextElm( pStack))) // Better be FERR_BT_END_OF_DATA
						{
							LOCKED_BLOCK * pLastLockedBlock = pLockedBlock;
								
							if( (pLockedBlock = (LOCKED_BLOCK *) GedPoolAlloc( pPool,
								sizeof( LOCKED_BLOCK))) == NULL)
							{
								rc = RC_SET( FERR_MEM);
								goto Exit;
							}

							ScaHoldCache( pStack->pSCache);
							pLockedBlock->pSCache = pStack->pSCache;
							pLockedBlock->pNext = pLastLockedBlock;

							if( RC_BAD(rc = FSBtNextElm( pDb, pLFile, pStack)))
							{
								rc = (rc == FERR_BT_END_OF_DATA)
										  ? RC_SET( FERR_DATA_ERROR)
										  : rc;
								goto Exit;
							}

							if( uiLowestTransId > FB2UD( &pStack->pBlk[ BH_TRANS_ID]))
							{
								uiLowestTransId = FB2UD( &pStack->pBlk[ BH_TRANS_ID]);
							}

							if( !bMostCurrent)
							{
								bMostCurrent = (pStack->pSCache->uiHighTransID == 
														0xFFFFFFFF) ? TRUE : FALSE;
							}

#ifdef FLM_DBG_LOG
							f_sprintf( szTmpBuf, "Rd2:L%X,H%X",  
								(unsigned)FB2UD( &pStack->pBlk[ BH_TRANS_ID]),
								(unsigned)pStack->pSCache->uiHighTransID);

							flmDbgLogWrite( pDb->pFile->uiFFileId, 
								pStack->pSCache->uiBlkAddress, uiDrn,
								pDb->LogHdr.uiCurrTransID, szTmpBuf);
#endif
						}

						pCurElm = CURRENT_ELM( pStack);
						uiElmRecLen = BBE_GET_RL( pCurElm);
						pCurElm += BBE_REC_OFS( pCurElm);
						fState.uiPosInElm = 0;
					}

					// Compare number of bytes left if value <= # bytes left in element

					if( uiFieldLen - uiDataPos <= uiElmRecLen - fState.uiPosInElm)
					{
						FLMUINT		uiDelta = uiFieldLen - uiDataPos;
						
						pDataPiece->pData = &pCurElm[ fState.uiPosInElm];
						pDataPiece->uiLength = uiDelta;
						fState.uiPosInElm += uiDelta;
						pDataPiece->pNext = NULL;
						break;
					}
					else
					{
						// Take what is there and get next element to grab some more.
						FLMUINT		uiBytesToMove = uiElmRecLen - fState.uiPosInElm;
						DATAPIECE *	pNextDataPiece;

						pDataPiece->pData = &pCurElm[ fState.uiPosInElm];
						pDataPiece->uiLength = uiBytesToMove;
						fState.uiPosInElm += uiBytesToMove;
						uiDataPos += uiBytesToMove;

						if( (pNextDataPiece = (DATAPIECE *) 
							GedPoolAlloc( pPool, sizeof( DATAPIECE))) == NULL)
						{
							rc = RC_SET( FERR_MEM);
							goto Exit;
						}
						pDataPiece->pNext = pNextDataPiece;
						pDataPiece = pNextDataPiece;
					}
				}
			}  // End if uiFieldLen
		}	// End of while(  fState.uiPosInElm < uiElmRecLen)

		// Done?

		if( BBE_IS_LAST( CURRENT_ELM( pStack)))
		{
			break;
		}

		// Position to next element

		if( RC_BAD( FSBlkNextElm( pStack))) // Better be FERR_BT_END_OF_DATA
		{
			LOCKED_BLOCK * pLastLockedBlock = pLockedBlock;
				
			if( (pLockedBlock = (LOCKED_BLOCK *) GedPoolAlloc( pPool,
				sizeof( LOCKED_BLOCK))) == NULL)
			{
				rc = RC_SET( FERR_MEM);
				goto Exit;
			}

			ScaHoldCache( pStack->pSCache);
			pLockedBlock->pSCache = pStack->pSCache;
			pLockedBlock->pNext = pLastLockedBlock;

			if( RC_BAD(rc = FSBtNextElm( pDb, pLFile, pStack)))
			{
				if (rc == FERR_BT_END_OF_DATA)
				{
					rc = RC_SET( FERR_DATA_ERROR);
				}
				goto Exit;
			}

			if( uiLowestTransId > FB2UD( &pStack->pBlk[ BH_TRANS_ID]))
			{
				uiLowestTransId = FB2UD( &pStack->pBlk[ BH_TRANS_ID]);
			}

			if( !bMostCurrent)
			{
				bMostCurrent = (pStack->pSCache->uiHighTransID == 
										0xFFFFFFFF) ? TRUE : FALSE;
			}

#ifdef FLM_DBG_LOG
			f_sprintf( szTmpBuf, "Rd3:L%X,H%X", 
				(unsigned)FB2UD( &pStack->pBlk[ BH_TRANS_ID]),
				(unsigned)pStack->pSCache->uiHighTransID);

			flmDbgLogWrite( pDb->pFile->uiFFileId, 
				pStack->pSCache->uiBlkAddress, uiDrn,
				pDb->LogHdr.uiCurrTransID, szTmpBuf);
#endif
		}

		// Corruption Check.

		pCurElm = CURRENT_ELM( pStack );	
		if( BBE_IS_FIRST( pCurElm))
		{
			rc = RC_SET( FERR_DATA_ERROR);
			goto Exit;
		}
	}

	if( pRecord)
	{
		void *		pvField;

		if( bOkToPreallocSpace)
		{
			if( RC_BAD( rc = pRecord->preallocSpace( uiFieldCount, uiTrueDataSpace)))
			{
				goto Exit;
			}
		}

		pFldGroup = pFirstFldGroup;

		for( uiFieldPos = 0; uiFieldCount--; uiFieldPos++)
		{

			if( uiFieldPos >= NUM_FIELDS_IN_ARRAY)
			{
				uiFieldPos = 0;
				if( (pFldGroup = pFldGroup->pNext) == NULL)
					break;
			}
			pField = &pFldGroup->pFields[ uiFieldPos];

			if( RC_BAD( rc = pRecord->insertLast( pField->uiLevel, 
				pField->uiFieldID, pField->uiFieldType, &pvField)))
			{
				goto Exit;
			}

			if( pField->uiFieldLen)
			{
				FLMBYTE *	pDataPtr;
				FLMBYTE *	pEncDataPtr;

				pDataPiece = &pField->DataPiece;
				if (RC_BAD( rc = pRecord->allocStorageSpace(
																	pvField,
																	pField->uiFieldType,
																	pField->uiFieldLen,
																	pField->uiEncFieldLen,
																	pField->uiEncId,
																	(pField->uiEncId
																		? FLD_HAVE_ENCRYPTED_DATA
																		: 0),
																	&pDataPtr,
																	&pEncDataPtr)))
				{
					goto Exit;
				}

				do
				{
					if (pField->uiEncId)
					{
						f_memcpy( pEncDataPtr, pDataPiece->pData, pDataPiece->uiLength);
						pEncDataPtr += pDataPiece->uiLength;
					}
					else
					{
						f_memcpy( pDataPtr, pDataPiece->pData, pDataPiece->uiLength);
						pDataPtr += pDataPiece->uiLength;
					}
					pDataPiece = pDataPiece->pNext;
				} while( pDataPiece);
				
				// If the field is encrypted, then we must decrypt it here.
				if (pField->uiEncId && !pDb->pFile->bInLimitedMode)
				{
					if (RC_BAD( rc = flmDecryptField( pDb->pDict,
																 pRecord,
																 pvField,
																 pField->uiEncId,
																 &pDb->TempPool)))
					{
						goto Exit;
					}
				}
			}
		}
	}

	if( puiRecTransId)
	{
		*puiRecTransId = uiLowestTransId;
	}

	if( pbMostCurrent)
	{
		*pbMostCurrent = bMostCurrent;
	}

	if( *ppRecord)
	{
		// We shouldn't hit this case, but in case we do we will deal
		// with it.

		flmAssert( 0);
		(*ppRecord)->Release();
	}
	
	pRecord->sortFieldIdTable();

	*ppRecord = pRecord;
	pRecord = NULL;

Exit:

	// Release all locked down blocks except the current block.

	while( pLockedBlock)
	{
		ScaReleaseCache( pLockedBlock->pSCache, FALSE);
		pLockedBlock = pLockedBlock->pNext;
	}

	GedPoolReset( pPool, pvPoolMark);

	if( pRecord)
	{
		pRecord->Release();
	}

	// You are now positioned to the last element in the record

	return( rc);
}

/**************************************************************************
Desc: Read field overhead (level, field drn, and length information.
		This isolates the complexity of the storage formats.
Out: 	fstate updated according to data
Ret:	FERR_OK or FERR_NOT_FOUND if the field is not found
Notes:The entire field overhead MUST always be together (not split).
		The data may be in another element.
**************************************************************************/
FSTATIC RCODE FSGetFldOverhead(
	FDB_p				pDb,
	FSTATE *			fState)
{
	RCODE			rc = FERR_OK;
	FLMBYTE *	pFieldOvhd = &fState->pElement[ fState->uiPosInElm ];
	FLMBYTE *	pElement = fState->pElement;
	FLMBOOL		bDoesntHaveFieldDef = TRUE;
	FLMUINT		uiFieldLen;	
	FLMUINT		uiFieldType = 0;
	FLMUINT		uiTagNum;
	FLMBYTE		byTemp;
	FLMUINT		uiEncId = 0;
	FLMUINT		uiEncFieldLen = 0;

	/**
	***	See FO_xxx_FLD definitions in FS.H
	***	If maintaining, see also FSRecUpd.c to see how codes were written.
	**/

	if( FOP_IS_STANDARD( pFieldOvhd))
	{
		if( FSTA_LEVEL( pFieldOvhd))
		{
			fState->uiLevel++;
		}

		uiFieldLen = FSTA_FLD_LEN( pFieldOvhd );
		uiTagNum   = FSTA_FLD_NUM( pFieldOvhd );
		pFieldOvhd    += FSTA_OVHD;
	}
	else if( FOP_IS_OPEN( pFieldOvhd))
	{
		if( FOPE_LEVEL( pFieldOvhd))
		{
			fState->uiLevel++;
		}

		byTemp   = (FLMBYTE)(FOP_GET_FLD_FLAGS( pFieldOvhd++ ));

		uiTagNum = (FLMUINT) *pFieldOvhd++;
		if( FOP_2BYTE_FLDNUM(byTemp))
		{
			uiTagNum += ((FLMUINT) *pFieldOvhd++) << 8;
		}

		uiFieldLen = (FLMUINT) *pFieldOvhd++;
		if( FOP_2BYTE_FLDLEN( byTemp ))
		{
			uiFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
		}
	}
	else if( FOP_IS_NO_VALUE( pFieldOvhd))
	{
		if( FNOV_LEVEL( pFieldOvhd ))
		{
			fState->uiLevel++;
		}

		byTemp  = (FLMBYTE)(FOP_GET_FLD_FLAGS( pFieldOvhd++ ));
		uiTagNum = (FLMUINT) *pFieldOvhd++;
		if( FOP_2BYTE_FLDNUM(byTemp))
		{
			uiTagNum += ((FLMUINT) *pFieldOvhd++) << 8;
		}
		uiFieldLen= uiFieldType = 0;
	}
	else if( FOP_IS_SET_LEVEL( pFieldOvhd))
	{
		// SET THE LEVEL
		//
		// Must be continuous with the next field

		fState->uiLevel -= FSLEV_GET( pFieldOvhd++);
		fState->uiPosInElm = (FLMUINT)(pFieldOvhd - pElement);

		rc = FSGetFldOverhead( pDb, fState);
		goto Exit;
	}
	else if( FOP_IS_TAGGED( pFieldOvhd))
	{
		bDoesntHaveFieldDef = FALSE;

		if( FTAG_LEVEL( pFieldOvhd))
		{
			fState->uiLevel++;
		}

		byTemp  = (FLMBYTE)(FOP_GET_FLD_FLAGS( pFieldOvhd));
		uiFieldType = (FLMUINT)(FTAG_FLD_TYPE( pFieldOvhd ));
		pFieldOvhd += FTAG_OVHD;
		uiTagNum = (FLMUINT) *pFieldOvhd++;

		if( FOP_2BYTE_FLDNUM(byTemp))
		{
			uiTagNum += ((FLMUINT) *pFieldOvhd++) << 8;
		}
	
		// When storing the unregistered fields we cleared the high bit
		// to save on storage for VER11.  The problem is that if a tag that is
		// not in the unregistered range (FLAIM TAGS) cannot be represented.  
		// SO, we will XOR the high bit so 0x0111 is stored as 0x8111 and 
		// 0x8222 is stored as 0x0222.

		uiTagNum ^= 0x8000;
		uiFieldLen = (FLMUINT) *pFieldOvhd++;
		if( FOP_2BYTE_FLDLEN( byTemp))
		{
			uiFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
		}
	}
	else if( FOP_IS_RECORD_INFO( pFieldOvhd))
	{
		bDoesntHaveFieldDef = FALSE;
		byTemp = *pFieldOvhd++;
		uiFieldLen = *pFieldOvhd++;
		if( FOP_2BYTE_FLDLEN( byTemp ))
			uiFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
		uiTagNum = 0;
	}
	else if (FOP_IS_ENCRYPTED( pFieldOvhd))
	{
		FLMBOOL		bTagSz;
		FLMBOOL		bLenSz;
		FLMBOOL		bENumSz;
		FLMBOOL		bELenSz;

		bDoesntHaveFieldDef = FALSE;

		if( FENC_LEVEL( pFieldOvhd ))
		{
			fState->uiLevel++;
		}

		uiFieldType = (FLMUINT)(FENC_FLD_TYPE( pFieldOvhd ));
		bTagSz = FENC_TAG_SZ( pFieldOvhd);
		bLenSz = FENC_LEN_SZ( pFieldOvhd);
		bENumSz = FENC_ETAG_SZ( pFieldOvhd);
		bELenSz = FENC_ELEN_SZ( pFieldOvhd);

		pFieldOvhd += 2;

		uiTagNum = (FLMUINT) *pFieldOvhd++;
		if ( bTagSz)
		{
			uiTagNum += ((FLMUINT) *pFieldOvhd++) << 8;
		}

		uiFieldLen = (FLMUINT)*pFieldOvhd++;
		if (bLenSz)
		{
			uiFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
		}

		uiEncId = (FLMUINT) *pFieldOvhd++;
		if (bENumSz)
		{
			uiEncId += ((FLMUINT) *pFieldOvhd++) << 8;
		}

		uiEncFieldLen = (FLMUINT) *pFieldOvhd++;
		if (bELenSz)
		{
			uiEncFieldLen += ((FLMUINT) *pFieldOvhd++) << 8;
		}
	}
	else
	{
		flmAssert( 0);
		rc = RC_SET( FERR_DATA_ERROR);
		goto Exit;
	}

	if( bDoesntHaveFieldDef)
	{
		// Get the field's storage type.

		if( RC_BAD( fdictGetField( pDb->pDict, uiTagNum, &uiFieldType,
				NULL, NULL)))
		{
			rc = RC_SET( FERR_DATA_ERROR);
			goto Exit;
		}
	}

	// Set the fState return values

	fState->uiFieldType = uiFieldType;
	fState->uiFieldLen  = uiFieldLen;
	fState->uiPosInElm  = (FLMUINT) (pFieldOvhd - pElement);
	fState->uiTagNum	  = uiTagNum;
	fState->uiEncId	  = uiEncId;
	fState->uiEncFieldLen = uiEncFieldLen;

Exit:

	return( rc);
}