/*

* Copyright (c) 2000, 2004 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   This module contains the implementation of CCrBer class. 

*

*/

//  INCLUDE FILES

#include "crber.h"

#include <e32math.h>    // Pow

// -----------------------------------------------------------------------------

// CCrBer

// Constructor 

// This function constructs CCrBer object

// -----------------------------------------------------------------------------

CCrBer::CCrBer(TInt aLevel /* = 0 */)

    {

    TReal size = 0;

    Math::Pow(size, 256, sizeof(TUint));

    iMaxUint = STATIC_CAST(TUint, size - 1);

    Math::Pow(size, 128, sizeof(TInt));

    iMaxInt = STATIC_CAST(TInt, size - 1);

    iEOCBytes[0] = 0x00;

    iEOCBytes[1] = 0x00;

    iType = KBerUnknown;

    iIndefinite = EFalse;

    iObjectBegin = 0;

    iContentBegin = 0;

    iContentLen = 0;

    iObjectLen = 0;

    iLevel = aLevel;

    iData = NULL;

    }

// -----------------------------------------------------------------------------

// CCrBer

// Destructor 

// This function destructs CCrBer object

// -----------------------------------------------------------------------------

EXPORT_C CCrBer::~CCrBer()

    {

    iData = NULL;

	iInt.Close();

    }

// -----------------------------------------------------------------------------

// CCrBer::ConstructL

// This function initializes CCrBer object's member objects.

// -----------------------------------------------------------------------------

TAny CCrBer::ConstructL()

    {

    }

// -----------------------------------------------------------------------------

// CCrBer::NewLC

// -----------------------------------------------------------------------------

EXPORT_C CCrBer* CCrBer::NewLC(TInt aLevel /* = 0 */)

    {

    CCrBer* self = new (ELeave) CCrBer(aLevel);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self; 

    }

// -----------------------------------------------------------------------------

// CCrBer::NewL

// -----------------------------------------------------------------------------

EXPORT_C CCrBer* CCrBer::NewL(TInt aLevel /* = 0 */)

    {

    CCrBer* self = NewLC(aLevel);

    CleanupStack::Pop();

    return self; 

    }

// -----------------------------------------------------------------------------

// CCrBer::Read

// Read next BER encoded object from the current position of

// given CCrData to this object. Return the type of the BER

// object, or KBerUnknown, if not of any known type. Only pointer

// to aData is stored into this object, so Get* functions are

// meaningful only if original data object is still existing,

// when these functions are used.

// -----------------------------------------------------------------------------

EXPORT_C TUint8 CCrBer::Read(CCrData* aData)

    {

    if ((iType = ReadType(aData)) != KBerUnknown)

        {

        TInt  move;

        TInt  pos = 0;

        TBool conLenKnown;

        // If type is known, this object begins right here,

        // well, to be exact, one byte before this point.

        if ((aData->Seek(ESeekCurrent, pos)) == KErrNone)

            {

            conLenKnown = ETrue;

            // Now we have at least something sensible. Store pointer to

            // the data object (and hope that the caller doesn't delete it :)

            iData = aData;

            iObjectBegin = pos - 1;

            // Read length.

            iContentLen = ReadLen(aData, iIndefinite, &iLenLen);

            // Content begins right after type tag and length bytes.

            iContentBegin = pos + iLenLen;

            // If length is indefinite and type isn't set, sequence,

            // or explicit/implicit constructed, find next end-of-content

            // tag to define exact length.

            if (iIndefinite)

                {

                if ((iType != KBerSeq) &&

                    (iType != KBerSet) &&

                    (iType != KBerImplicitConstructed) &&

                    (iType != KBerExplicitConstructed))

                    {

                    // Give special treatment to constructed encoding.

                    if ((iType & KBerConstructedBit) ||

                        (iType & KBerImplicitConstructed))

                        {

                        iContentLen = OpenConstructedEncodingWithTagL(

                                        aData, *this);

                        }

                    else

                        {

                        iContentLen = FindEndOfContent(aData);

                        }

                    }

                else

                    {

                    // We really can't know what the length is,

                    // until we open up the whole inner content.

                    conLenKnown = EFalse;

                    }

                }

            // Now, if we know content length, then we can calculate whole

            // object's length; it is tag + length bytes + content length.

            if (conLenKnown)

                {

                SetObjectLen();

                // Also move data pointer at the end of this object, except

                // if object was set or sequence, in which case don't move,

                // because we still have to open inner items.

                // At indefinite case this is already done (other than

                // sequence or set) or this can't be done (sequence or

                // set). So, if not indefinite and not sequence or set,

                // move data pointer the amount of content length.

                if (!(iIndefinite) && !(IsSeqOrSet(iType)))

                    {

                    move = iContentLen;

                    aData->Seek(ESeekCurrent, move);

                    }

                }

            // If tag was end-of-content tag, check that also length

            // was 0 and not indefinite, this guarantees that we really

            // have an end-of-content tag (00 00).

            if (iType == KBerEndOfContent)

                {

                if ((iContentLen != 0) || (iIndefinite))

                    {

                    iType = KBerUnknown;

                    }

                }

            }

		}

    return iType;

    }

// -----------------------------------------------------------------------------

// CCrBer::ReadType

// Read type tag from current position in given CCrData.

// Returns type tag or KBerUnknown, if not of any known type.

// -----------------------------------------------------------------------------

EXPORT_C TUint8 CCrBer::ReadType(CCrData* aData)

    {

    TBuf8<1> byte;

    TUint8   type = KBerUnknown;   // By default we are pessimists.

    // Read type.

    if ((aData != 0) &&

        (aData->Read(byte, 1) == KErrNone) &&

        (byte.Length() > 0))

        {

        type = byte[0];

        if (!IsKnownType(type))

            {

            // Don't let type to be whatever byte happened to be

            // at that place. Set it to unknown, which we all know.

            type = KBerUnknown;

            }

        }

    return type;

    }

// -----------------------------------------------------------------------------

// CCrBer::ReadLen

// Read length tags from current position in given CCrData.

// Returns length. If length is indefinite, aIndefinite is set

// to true, otherwise to false. In indefinite case length is 0.

// Also sets amount of length bytes in aLenLen, if given.

// -----------------------------------------------------------------------------

EXPORT_C TUint CCrBer::ReadLen(

    CCrData* aData,

    TBool&   aIndefinite,

    TUint8*  aLenLen/* = 0 */)

    {

    TBuf8<LEN_BYTES_MAX> bytes;

    TUint8               byte = 0;

    TUint                len = 0;

    // Originally assume that length is definite,

    aIndefinite = EFalse;

    // First byte tells if the length bytes are in short or in long form.

    if ((aData != 0) && (aData->Read(bytes, 1) == KErrNone))

        {

        if (bytes.Length() <= 0)        

            {

            User::Leave(KErrArgument);

            }

        byte = bytes[0];

        // We have at least one length byte.

        if (aLenLen != 0)

            {

            *aLenLen = 1;

            }

        if (byte & KBerLongLengthBit)

            {

            // We have length bytes, but how many?

            TUint8 lenBytes = (TUint8)(byte & ~KBerLongLengthBit);

            // If length is in long form, but there are zero

            // length bytes, then length is indefinite.

            if (lenBytes == 0)

                {

                aIndefinite = ETrue;

                }

            else

                {

                if (aLenLen != 0)

                    {

                    // Add amount of actual length bytes to one,

                    // which was for long length form byte.

                    for (TInt i = 0; i < lenBytes; i++)

                        {

                        (*aLenLen)++;

                        }

					}

                // Otherwise we have to interpret length bytes and

                // move the result into len variable. First check

                // that there aren't more bytes than fits to

                // unsigned integer, we don't want any troubles here.

                if (lenBytes > sizeof(TUint))

                    {

                    // Return max uint, caller can then decide

                    // what to do with this huge pile of...

                    return iMaxUint;

                    }

                // Read length bytes

                if (aData->Read(bytes, lenBytes) == KErrNone)

                    {

                    TUint8 i;

                    // and move them to len.

                    for (i = 0; i < lenBytes; i++)

                        {

                        len = len << 8;

                        len += bytes[i];

                        }

                    }

                }

            }

        else

            {

            // Otherwise length was in short form and length

            // byte alone tells us the length of the contens.

            len = byte;

            }

        }

    return len;

    }

// -----------------------------------------------------------------------------

// CCrBer::IsKnownType

// Returns true if given BER tag is identified one.

// Returns:  ETrue of EFalse.

// -----------------------------------------------------------------------------

EXPORT_C TBool CCrBer::IsKnownType(TBerTag aTag)

    {

    TBool isKnown = EFalse;

    // Remove constructed bit, if it is on without other upper byte tags.

    if ((aTag & 0xF0) == KBerConstructedBit)

        {

        aTag &= ~KBerConstructedBit;

        }

    // Remove implicit/explicit constructed bit, 

    // if it is on without other upper byte tags.

    if ((aTag & 0xF0) == KBerImplicitConstructed)

        {

        aTag &= ~KBerImplicitConstructed;

        }

    switch (aTag)

        {

        case KBerEndOfContent:

        case KBerBoolean:

        case KBerInteger:

        case KBerBitString:

        case KBerOctetString:

        case KBerNull:

        case KBerOid:

		case KBerNumS:

        case KBerPrS:

        case KBerT61S:

		case KBerVideoS:

        case KBerIA5S:

        case KBerUtc:

		case KBerGenTime:                                

		case KBerGraphS: 

		case KBerVisibleS:

		case KBerGeneralS:

        case KBerBmpS:

        case KBerSeq:

        case KBerSet:

        case KBerImplicitConstructed:

        // Same as KBerExplicitConstructed

        case KBerImplicit:

        // Same as KBerExplicit

            {

            isKnown = ETrue;

            break;

            }

        default:

            {

            isKnown = EFalse;

            break;

            }

        }

    return isKnown;

    }

// -----------------------------------------------------------------------------

// CCrBer::IsSeqOrSet

// Returns true if given BER tag is set, sequence,

// implicit contructed, or explicit constructed tag.

// -----------------------------------------------------------------------------

EXPORT_C TBool CCrBer::IsSeqOrSet(TBerTag aTag)

    {

    TBool isSeqOrSet = EFalse;

    if ((aTag == KBerSeq) ||

        (aTag == KBerSet) ||

        (aTag == KBerImplicit) ||

        (aTag == KBerExplicit) ||

        (aTag == KBerImplicitConstructed) ||

        (aTag == KBerExplicitConstructed))

        {

        isSeqOrSet = ETrue;

        }

    return isSeqOrSet;

    }

// -----------------------------------------------------------------------------

// CCrBer::FindEndOfContent

// Finds next end-of-content (00 00) tag from given data.

// Returns the distance between current place and the tag,

// or 0, if not found. Moves data pointer to the next byte

// _after_ the tag, i.e. two bytes longer than you might

// except from the return value.

// -----------------------------------------------------------------------------

EXPORT_C TUint CCrBer::FindEndOfContent(CCrData* aData)

    {

    TBool go = ETrue;

    TInt bufferOffset = 0;

    TInt dataOffset = 0;

    TInt move = 0;

    TBuf8<KReadBufMax> bytes;

    if (aData == 0)

        {

        return dataOffset;

        }

    // Read buffer of data. Go on, if there is something to go with.

    while ((aData->Read(bytes, KReadBufMax) == KErrNone) &&

           (bytes.Length() != 0) && go)

        {

        TBuf8<2> EOCBytes;

        EOCBytes.Append(iEOCBytes[0]);

        EOCBytes.Append(iEOCBytes[1]);

        // Try to find end-of-content tag.

        bufferOffset = bytes.Find(EOCBytes);

        // If found, move data pointer right _after_

        // the place of founded tag, and break.

        if (bufferOffset != KErrNotFound)

            {

            move = bufferOffset -

                       bytes.Length() +

                       EOCBytes.Length();

            aData->Seek(ESeekCurrent, move);

            dataOffset += bufferOffset;

            go = EFalse;                    //break;

            }

        else

            {

            // Otherwise keep searching. First check that the last

            // character of the buffer isn't 00. If it is, move the

            // data pointer one byte backwards to prevent us from

            // missing end-of-content tag, if it is divided between

            // buffers.

            if (bytes[bytes.Length() - 1] == KBerEndOfContent)

                {

                move = -1;

                aData->Seek(ESeekCurrent, move);

                dataOffset--;

                }

            dataOffset += bytes.Length();

            }

        }

    // If nothing was found, move data pointer back

    // to where it was and return 0.

    if (bytes.Length() == 0)

        {

        dataOffset = -dataOffset;

        aData->Seek(ESeekCurrent, dataOffset);

        dataOffset = 0;

        }

    return dataOffset;

    }

// -----------------------------------------------------------------------------

// CCrBer::OpenConstructedEncodingL

// Open constructed encoding from this object.  

// Parameters: aTarget; target for contentbytes.

// Return Values:  Number of objects in this contructed object.

// -----------------------------------------------------------------------------

EXPORT_C TInt CCrBer::OpenConstructedEncodingL(CCrData& aTarget)

    {      

    TInt err = KErrNone;

    TInt count = 0;

    TInt offset = iContentBegin;

    TInt objectNum = 0;

    TInt type = Type();

    CCrBer* object = NULL;

    if (type <= KBerConstructed)        // not valid type

        {

        User::Leave(KErrArgument);

        }

    else  

        {

        type -= KBerConstructed;        // type what we are looking for

        }

    CCrBerSet* newSet = CCrBerSet::NewL(1);

    CleanupStack::PushL(newSet);

    iData->Seek(ESeekStart, offset);    // seek right place; content begin

    newSet->OpenL(iData, KOpenAllLevels);

    count = newSet->Count();