/*

* Copyright (c) 2008 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:

 *

*/

// INCLUDE FILES

#include "cstsasn1sequence.h"

namespace java

{

namespace satsa

{

// CONSTANTS

const TInt KSTSDefaultGranularity = 5;

const TUint8 KSTSPaddingByte = 0xFF;

const TUint8 KSTSRemovedRecordTag = 0x00;

const TInt KSTSRecordHeaderLength = 2;

// ============================ MEMBER FUNCTIONS ===============================

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

// CSTSASN1Sequence::CSTSASN1Sequence

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSTSASN1Sequence::CSTSASN1Sequence()

{

}

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

// CSTSASN1Sequence::DecodeSequenceLC

// Decodes raw-data to ASN.1 modules, pushes items to cleanupstack

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

CArrayPtr<TASN1DecGeneric>* CSTSASN1Sequence::DecodeSequenceLC(TBool aCheckTag,

        const TDesC8& aRawData)

{

    CArrayPtr<TASN1DecGeneric>* items = NULL;

    // Check we've got a sequence

    TASN1DecGeneric decGen(aRawData);

    decGen.InitL();

    TTagType tag = decGen.Tag();

    // Accept only sequences or set if tag must be checked

    if ((tag != EASN1Sequence) && (tag != EASN1Set) && (aCheckTag))

    {

        User::Leave(KErrArgument);

    }

    else

    {

        // Decode sequences to array

        items = DecodeItemsLC(decGen);

    }

    return items;

}

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

// CSTSASN1Sequence::DecodeSequenceLC

// Decodes raw-data to ASN.1 modules, pushes items to cleanupstack

// Validates that there is right number of modules, leaves with KErrArgument if

// not.

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

CArrayPtr<TASN1DecGeneric>* CSTSASN1Sequence::DecodeSequenceLC(TBool aCheckTag,

        const TDesC8& aRawData, TInt aMinTerms, TInt aMaxTerms)

{

    CArrayPtr<TASN1DecGeneric>* items = DecodeSequenceLC(aCheckTag, aRawData);

    TInt count = items->Count();

    if ((count < aMinTerms) || (count > aMaxTerms))

    {

        // not in the range, leave

        User::Leave(KErrArgument);

    }

    return items;

}

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

// CSTSASN1Sequence::DecodeSequenceLC

// Decodes raw-data to ASN.1 modules, pushes items to cleanupstack

// Validates that there is right number of modules, leaves with KErrArgument if

// not.

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

CArrayPtr<TASN1DecGeneric>* CSTSASN1Sequence::DecodeSequenceLC(TBool aCheckTag,

        const TDesC8& aRawData, TInt aMinTerms)

{

    CArrayPtr<TASN1DecGeneric>* items = DecodeSequenceLC(aCheckTag, aRawData);

    TInt count = items->Count();

    if (count < aMinTerms)

    {

        // not in the range, leave

        User::Leave(KErrArgument);

    }

    return items;

}

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

// CSTSASN1Sequence::DecodeItemsLC

// Decodes raw-data to ASN.1 modules, pushes items to cleanupstack

// Checks removed records and padding bytes and ignores them.

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

CArrayPtrFlat<TASN1DecGeneric>* CSTSASN1Sequence::DecodeItemsLC(

    const TASN1DecGeneric& aRawData)

{

    CArrayPtrFlat<TASN1DecGeneric>* items = new(ELeave) CArrayPtrFlat<

    TASN1DecGeneric> (KSTSDefaultGranularity);

    TCleanupItem cleanupSeq(CleanupSequence, items);

    CleanupStack::PushL(cleanupSeq);

    TPtrC8 source(aRawData.GetContentDER());

    TInt sourceLength = source.Length();

    TInt pos = 0;

    while (pos < sourceLength)

    {

        TPtrC8 restOfData(source.Right(sourceLength - pos));

        TUint8 tag = restOfData[0];//first byte is tag

        TInt restOfDataLength = restOfData.Length();

        //check does contains removed record or padding bytes

        if (tag == KSTSRemovedRecordTag)

        {

            //we can jump over this record

            if (restOfDataLength >= KSTSRecordHeaderLength)

            {

                //2. byte is record length

                TInt recordDataLength = restOfData[1];

                //update position after this record

                pos += recordDataLength + KSTSRecordHeaderLength;

            }

            else

            {

                //there is only one byte left so in this Removed Tag case

                //we can ignore this and continue without leaving

                pos++;

            }

        }

        else if (tag == KSTSPaddingByte)

        {

            //we can jump over padding bytes

            TInt amountOfPaddingBytes = 1; //one padding byte is already found

            TBool paddingByte = ETrue;

            //we start from second byte, because first is already read

            for (TInt i = 1; (i < restOfDataLength) && (paddingByte); i++)

            {

                //take next value

                TUint8 nextByte = restOfData[i];

                //if padding byte, increase amount of padding bytes

                if (nextByte == KSTSPaddingByte)

                {

                    amountOfPaddingBytes++;

                }

                else //end loop

                {

                    paddingByte = EFalse;

                }

            }

            //update position after padding bytes

            pos += amountOfPaddingBytes;

        }

        else //we can append record to array

        {

            //take next record

            TASN1DecGeneric* decGenRecord =

                new(ELeave) TASN1DecGeneric(restOfData);

            CleanupStack::PushL(decGenRecord);

            decGenRecord->InitL();

            //append record to array

            items->AppendL(decGenRecord);

            //update position after record

            pos += decGenRecord->LengthDER();

            CleanupStack::Pop(decGenRecord);

        }

    }

    return items;

}

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

// CSTSASN1Sequence::CleanupSequence

//

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

void CSTSASN1Sequence::CleanupSequence(TAny* aArray)

{

    CArrayPtrFlat< TASN1DecGeneric>* array =

        REINTERPRET_CAST(CArrayPtrFlat< TASN1DecGeneric>*, aArray);

    array->ResetAndDestroy();

    delete array;

}

} // namespace satsa

} // namespace java

//  End of File