/*

* 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 CCrBerSet class. 

*

*/

//  INCLUDE FILES

#include "crber.h"

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

//CCrBerSet

//Constructor

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

CCrBerSet::CCrBerSet(TInt aGranularity)

    : CArrayPtrSeg<CCrBer>(aGranularity), iLevel(0)

    {

    }

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

// CCrBerSet

// Destructor

// This function destructs CCrBerSet object

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

CCrBerSet::~CCrBerSet()

    {

    ResetAndDestroy();

    }

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

// CCrBerSet::ConstructL

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

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

TAny CCrBerSet::ConstructL()

    {

    }

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

// CCrBerSet::NewLC

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

EXPORT_C CCrBerSet* CCrBerSet::NewLC(TInt aGranularity)

    {

    CCrBerSet* self = new (ELeave) CCrBerSet(aGranularity);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self; 

    }

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

// CCrBerSet::NewL

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

EXPORT_C CCrBerSet* CCrBerSet::NewL(TInt aGranularity)

    {

    CCrBerSet* self = NewLC(aGranularity);

    CleanupStack::Pop();

    return self; 

    }

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

// CCrBerSet::OpenL

// 

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

// given CCrData to this object set. Opens also all nested BER

// objects as deep as aRecursionLevel tells. If it is zero, one

// object is read, if it is one, all objects at first level are

// read, and if it is 0xff, all objects at 255 first levels are

// extracted. This function cannot be used to extract deeper

// structures than that, if you want to go deeper, implement

// a function of your own. Returns the amount of extracted

// objects. The data pointer of CCrData points right after the

// opened BER object after this function is finished.

// Parameters: CCrData* aData    Data object containing the BER

//                               object to be opened.

// Returns:    TUint             Amount of BER objects extracted.

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

EXPORT_C TUint CCrBerSet::OpenL(

    CCrData* aData,

    TUint8   aRecursionLevel /* = 1 */)

    {

    TInt    i       = 0;

    TUint   level   = 0;

    TUint8  amount  = 0;

    TInt definiteObjectEnd [255]= {0};

    TBerTag  type    = KBerEndOfContent;

    CCrBer* newObject = 0;

    while (type != KBerUnknown)

        {

        // Don't create new object if old is to be recycled.

        if (newObject == 0)

            {

            newObject = CCrBer::NewLC(level);

            }

        // Read next BER object.

        if ((type = newObject->Read(aData)) != KBerUnknown)

            {                   

            i = 0;

            // check definite seq(e.g) end, and if so, take away 1 level. 

            while (definiteObjectEnd[i] != 0)

                {

                if ((definiteObjectEnd[i]  <= newObject->ObjectLen() 

                    + newObject->ObjectBegin()) &&

                    (definiteObjectEnd[i]) &&

                   !(newObject->IsSeqOrSet(type)))                                    

                    {                

                    level--;                

                    definiteObjectEnd[i] = 0;

                    }

                i++;

                }

            // If type is explicit or implicit constructed or sequence

            // or set with indefinite length, we are one level deeper.

            if (CCrBer::IsSeqOrSet(type))

                 {

                if (newObject->Indefinite())

                    {

                    level++;

                    }

                else 

                    {               

                    level++;

                    i = 0;

                    while (definiteObjectEnd[i] != 0)

                        {

                        i++;

                        }

                    definiteObjectEnd[i] = newObject->ObjectLen() 

                        + newObject->ObjectBegin();                                      

                    }

				// Changed by junuutin on 3.5.2004:				

				if ((type == KBerImplicit) || (type == KBerExplicit))

					{

						// Don't try to parse the content of context-specified stuff

			            // Jump to next object.

						TInt currentPos = 0;

						aData->Seek(ESeekCurrent, currentPos);

                        TInt pos = currentPos + newObject->ContentLen(); 

                        aData->Seek(ESeekStart, pos);

                        level--;

					} 

				else if ((type == KBerImplicitConstructed) || (type == KBerExplicitConstructed))

                    {

                     TInt currentPos = 0;

                     aData->Seek(ESeekCurrent, currentPos);

                     CCrBer* tempObject = CCrBer::NewL();

                     // Read next BER object.

                     TBerTag tempType = tempObject->Read(aData);

                     if (!(CCrBer::IsKnownType(tempType)))

                        {

                        // Jump to next object.

                        TInt pos = currentPos + newObject->ContentLen(); 

                        aData->Seek(ESeekStart, pos);

                        level--;

                        }

                     else // return current position.

                         {

                         aData->Seek(ESeekStart, currentPos);

                         }

                    delete tempObject;

                    tempObject = NULL;

                    } 

                } 

            // If type is end-of-content tag, last constructed object,

            // sequence or set with indefinite length has ended, we

            // are one level lower.

            if (type == KBerEndOfContent)

                {

                level--;

                // Also set new object's level to current,

                // because that's where it actually belongs.

                newObject->SetLevel(level);

                // Close last sequence or set.

                CloseLastSeqOrSet(level);

                }

            // If it is of known type, append object to this set,

            // null the pointer and continue to look for next objects.

            // Append only if wanted recursion level not exceeded.

            if ((level <= aRecursionLevel) || (aRecursionLevel == 255))

                {

                AppendAndUpdateL(newObject);

                CleanupStack::Pop(); //newObject

                newObject = NULL;

                }

            else

                {

                // Anyway previous open objects have to be

                // updated with the length of this object.

                Update(newObject);

                }

            // Anyway we have one item more.

            amount++;

            }

        else

            {

            // Otherwise delete object and stop the whole thing.

            // Don't return those bloody errors, because we cannot

            // know what the caller was looking for, let him evaluate

            // the results and decide whether this was a failure or not.

            //delete newObject;

            CleanupStack::PopAndDestroy();

            // go to return 

            type = KBerUnknown;         

            }

        }

    return amount;

    }

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

// CCrBerSet::AppendAndUpdateL

// Appends given new object into this set. Updates all previous

// items in this set, which have indefinite length, with the

// length of the new object.

// Parameters: CCrBer* aBerObject    New BER object to be added to this set

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

EXPORT_C TAny CCrBerSet::AppendAndUpdateL(CCrBer* aBerObject)

    {

    Update(aBerObject);

    AppendL(aBerObject);

    }

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

// CCrBerSet::Update

// Updates all previous items in this set, which have

// indefinite length, with the length of the new object.

// Parameters: CCrBer* aBerObject    New BER object with whom

//                                   this set is updated.

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

EXPORT_C TAny CCrBerSet::Update(CCrBer* aBerObject)

    {

    TInt  add = 0;

    TInt  index = 0;

    TInt  size = 0;

    TUint berObjectLevel = 0; 

    CCrBer* obj;

    if (aBerObject == 0)

        {

        return;

        }

    // Loop backwards through set and append length of the new object

    // to the lengths of each found upper constructed, sequence or set

    // objects with indefinite lengths, until first 'closed' from upper

    // level found.

    // Use object length, unless this is an object, whose total length is

    // not yet known. In that case use tag length (always 1) combined with

    // the amount of the length bytes.

    if ((add = aBerObject->ObjectLen()) == 0)

        {

        add = 1 + aBerObject->LenLen();

        // If new object is of indefinite length, still

        // add two more bytes for the end-of-content tag.

        if (aBerObject->Indefinite())

            {

            add += 2;

            }

        }

    berObjectLevel = aBerObject->Level();

    size = Count();

    for (index = size - 1; index >= 0; index--)

        {

        obj = At(index);

        if ((obj != 0) &&

            (obj->Level() < berObjectLevel) &&

            (obj->Indefinite()))

            {

            if ((obj->Type() == KBerSeq) ||

                (obj->Type() == KBerSet) ||

                (obj->Type() == KBerImplicitConstructed) ||

                (obj->Type() == KBerExplicitConstructed))

                {

                if (obj->ObjectLen() == 0)

                    {

                    obj->AddToContentLen(add);

                    }

                else

                    {

                    index = -1;                 // break;

                    }

                }

            }

        }

    }

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

// CCrBerSet::CloseLastSeqOrSet

// Finds last open indefinite length sequence

// or set from this set at given level and closes it.

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

EXPORT_C TAny CCrBerSet::CloseLastSeqOrSet(TUint aLevel)

    {

    TInt    index = 0;

    TInt    size  = 0;

    TBerTag type  = KBerUnknown;

    CCrBer* obj = NULL;

    // Loop backwards through set and find first sequence or set with

    // indefinite length at same level. 'Close' it by setting its object

    // length.

    size = Count();

    for (index = size - 1; index >= 0; index--)

        {

        obj = At(index);

        if ((obj != 0) &&

            (obj->Level() == aLevel) &&

            (obj->Indefinite()))

            {

            type = obj->Type();

            if ((type == KBerSeq) ||

                (type == KBerSet) ||

                (type == KBerImplicitConstructed) ||

                (type == KBerExplicitConstructed))

                {

                obj->SetObjectLen();

                // Update upper objects with closed object.

                Update(obj);

                index = -1;             // break;

                }

            }

        }

    }

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

//  Encoding

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

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

// CCrBerSet::AppendBool

// Write boolean object to CCrData.

// Parameters:     Boolean value. ETrue or EFalse ( 0 / 1 ).

// Return Values:  Error code

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

TInt CCrBerSet::AppendBoolL(TBool aBool)

    {

    TInt err = KErrNone;

    TBuf8<1> value;

    if (aBool)           

        {

        value.Append(KBerBooleanTrue);            

        }

    else                  

        {

        value.Append(KBerBooleanFalse);

        }

    err = AppendStringL(KBerBoolean, value);                       

    return err;

    }

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

// CCrBerSet::AppendInt

// Write integer (0x02) object to CCrData. Parameter is either

// a positive whole number, or a negative whole number, or zero.

// value : from - 0xFFFFFFF to +0xFFF FFFF

// Parameters:     Integer value e.g. 1024 or 0xABC. 

// Return Values:  Error code

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

TInt CCrBerSet::AppendIntL(TInt aData)

    {

    TInt err = KErrNone;

    TBuf8<8> indexBuf;

    TUint len   = 0;

    HBufC8* buf = NULL;

    buf = HBufC8::NewLC(KIntBufSize);

    TPtr8 data  = buf->Des();

    if (aData >= 0)

        { 

        if (aData >= KBerLongLengthBit)

            {      

            while (aData > 0)                    

                {

                TInt8 byte;

                byte = TInt8(aData);        // Take byte

                indexBuf.Append(byte);      // and add it to indexBuf   

                aData >>= KOctetWidth;      // Next byte

                len++;                 

                }       

            if (indexBuf[len-1] >= KBerLongLengthBit)   // if high order bit=1

                {

                indexBuf.Append(0);         // e.g. content 00 FF no FF 

                len++;                      // (FF = neg num)

                }

            }

        else                                // only one byte

            {

            indexBuf.Append(aData);         // so add directly

            len++;

            }

        }

    else

        {

        aData = -(aData + 1);               // convert to positive

        while ((aData > 0) || (len < 1))    // (len < 1) because -1 -> 0 ->FF            

            {

            TInt8 byte;

            byte = TInt8(aData);            // Take byte

            indexBuf.Append(~byte);         // and add complement to buf

            aData >>= KOctetWidth;          // Next byte

            len++;                 

            }

        if (indexBuf[len-1] < KBerLongLengthBit) // if high order bit=0

                {

                indexBuf.Append(0xFF);  

                len++;                  

                }

        }

    for (TInt i=len ; i > 0 ; i--)

        {

        data.Append(indexBuf[i - 1]);       // add data to buffer

        }

    err = AppendStringL(KBerInteger, data);        // write data to file

    CleanupStack::PopAndDestroy();

    buf = NULL;

    return err;

    }

TInt CCrBerSet::AppendLongIntL(RInteger& aData)

    {

    TInt err = KErrNone;

    err = AppendStringL(KBerInteger, *aData.BufferLC());

    CleanupStack::PopAndDestroy(); 

    return err;

    }

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

// CCrBerSet::AppendNull

// Write null (05 00) object to CCrData.

// Parameters:     None

// Return Values:  Error code

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

TInt CCrBerSet::AppendNull()

    {

    TInt err = KErrNone;

    TBuf8<2> data;

    data.Append(KBerNull);                      // Add Null tag 05

    data.Append(KBerNullContent);               // and null;    00

    err = iTarget->Write(data);                 // write data-buffer to CCrData 

    return err;

    }

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

// CCrBerSet::CloseIndefinite

// Write end of indefinite length (add 00 00) to CCrData.

// Return Values:  Error code

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

TInt CCrBerSet::CloseIndefinite()

    {   

    TInt err = KErrNone;

    TBuf8<2> data;                  

    data.Append(KBerEndOfContent);              // add end of indefinite length 

    data.Append(KBerEndOfContent);              // ( 00 00 )

    err = iTarget->Write(data);                 // write data-buffer to file

    return err;

    }

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

// CCrBerSet::AppendConstructed

// Write constructed type to CCrData.

// Parameters:     First param is type of constructed tag

//                 e.g. 04 for octetS.  Second parameter is length or 0 for

//                 indefinite length. e.g. if params are 4 and 0 --> 24 00

// Return Values:  Error code

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