/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 "ber_tlv.h"        // ber-tlv classes

#include "satutil.h"        // sat utility class

#include "tsylogger.h"      // for logging

#include <tisi.h>           // isi message

#include <uiccisi.h>        // UICC server

#ifdef OST_TRACE_COMPILER_IN_USE

#endif

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

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

// TTlvBase::Begin

// Start ber-tlv construction

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

//

void TTlvBase::Begin

        (

        TUint8 aTag //tag

        )

    {

    OstTrace0( TRACE_DETAILED, TTLVBASE_BEGIN, "TTlvBase::Begin" );

    TFLOGSTRING("TSY: TTlvBase::Begin");

    iData.Zero();

    iData.Append( aTag );

    iData.Append( 0 );

    }

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

// TTlvBase::AddTag

// Start new simple tlv

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

//

void TTlvBase::AddTag

        (

        TUint8 aTag //tag

        )

    {

    OstTrace0( TRACE_DETAILED, TTLVBASE_ADDTAG, "TTlvBase::AddTag" );

    TFLOGSTRING("TSY: TTlvBase::AddTag");

    iData.Append( aTag );           // tag

    iData.Append( 0 );              // length

    iLenIndex = iData.Length() - 1; // index to tag length

    }

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

// TTlvBase::AddByte

// Add byte data to simple tlv

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

//

void TTlvBase::AddByte

        (

        TUint8 aValue

        )

    {

    OstTrace0( TRACE_DETAILED, TTLVBASE_ADDBYTE, "TTlvBase::AddByte" );

    TFLOGSTRING("TSY: TTlvBase::AddByte");

    iData.Append( aValue );

    iData[iLenIndex]++;

    }

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

// TTlvBase::End

// Add desctiptor data to simple tlv

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

//

void TTlvBase::AddData

        (

        const TDesC8& aValue

        )

    {

    OstTrace0( TRACE_DETAILED, TTLVBASE_ADDDATA, "TTlvBase::AddData" );

    TFLOGSTRING("TSY: TTlvBase::AddData");

    iData.Append( aValue );

    iData[iLenIndex] = TUint8(iData[iLenIndex] + aValue.Length());

    }

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

// TTlvBase::End

// End ber-tlv construction. Adds extra length byte to all simple

// TLVs that are longer than KMaxOneByteLength (0x7f) and

// returns descriptor to the new valid ber-tlv.

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

//

const TDesC8& TTlvBase::End()

    {

    OstTrace0( TRACE_DETAILED, TTLVBASE_END, "TTlvBase::End" );

    TFLOGSTRING("TSY: TTlvBase::End");

    _LIT8( KLenTag, "\x81" );

    TInt i( 3 ); // index to tag length

    // scan through all lenghts and insert 'length tag'

    while ( i < iData.Length() )

        {

        if ( KMaxOneByteLength < iData[i] )

            {

            iData.Insert( i, KLenTag );

            i++;

            }

        i += iData[i] + 2; // jump to next tag length

        }

    // calculate total ber-tlv length

    iData[1] = TUint8( iData.Length() - 2 );

    // insert 'length tag'

    if ( KMaxOneByteLength < iData[1] )

        {

        iData.Insert( 1, KLenTag );

        }

    // done, return ber-tlv

    return iData;

    }

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

// TTlvBase::GetDataWithoutTopLevelTag

// End TLV construction. Adds extra length byte to all simpleV.

// TLVs that are longer than KMaxOneByteLength (0x7f) and

// returns descriptor to the valid tlvs. To be used without

// Begin(), nor End() in situations where TLV simple tags are

// used without top level tag.

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

//

const TDesC8& TTlvBase::GetDataWithoutTopLevelTag()

    {

    OstTrace0( TRACE_DETAILED, TTLVBASE_GETDATAWITHOUTTOPLEVELTAG, "TTlvBase::GetDataWithoutTopLevelTag" );

    TFLOGSTRING("TSY: TTlvBase::GetDataWithoutTopLevelTag");

    _LIT8( KLenTag, "\x81" );

    TInt i( 1 ); // index to tag length

    // scan through all lenghts and insert 'length tag'

    while ( i < iData.Length() )

        {

        if ( KMaxOneByteLength < iData[i] )

            {

            iData.Insert( i, KLenTag );

            i++;

            }

        i += iData[i] + 2; // jump to next tag length

        }

    // done, return ber-tlv

    return iData;

    }

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

// CBerTlv::CBerTlv

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

// might leave.

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

//

CBerTlv::CBerTlv()

    {

    OstTrace0( TRACE_DETAILED, CBERTLV_CBERTLV, "CBerTlv::CBerTlv" );

    TFLOGSTRING("TSY: CBerTlv::CBerTlv");

    //none

    }

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

// CBerTlv::TlvByTagValue

// Find TLV by tag value. aTlv is set to point to found TLV.

// If there are more than one TLV with the same tag then

// itemNbr can be used to select which one is returned.

// If no tags are found return KErrNotFound else KErrNone.

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

//

TInt CBerTlv::TlvByTagValue

        (

        CTlv* aTlv,                 //TLV

        TUint8 aTlvTagValue,        //TLV identifier

        TInt aItemNbr                //item number

        )

    {

    OstTrace0( TRACE_DETAILED, CBERTLV_TLVBYTAGVALUE, "CBerTlv::TlvByTagValue" );

    TFLOGSTRING("TSY: CBerTlv::TlvByTagValue");

    TInt currentTlv( 0 );

    TInt tlvLength( 0 );

    TInt index( 0 );

    //tlv start index

    TInt ind( KCommonTlvHeaderLength );

    TUint8 berTlvLength( 0 );

    if ( KTwoByteLengthCoding == iData[KTlvLengthStartPosition] )

        {

        berTlvLength = iData[KTlvLengthStartPosition + 1];

        ind = ind + 1;

        }

    else

        {

        berTlvLength = iData[KTlvLengthStartPosition];

        }

    for ( TInt i = 0; i < berTlvLength; i += tlvLength )

        {

        //first determine if the length of the TLV is coded with 1 or 2 bytes.

        if ( KTwoByteLengthCoding == iData[ind + 1] )

            {

            //length is coded with 2 bytes -> 1 extra byte required to be

            //added to total length. Also TLV header bytes (2) must be added

            //to total length

            tlvLength = iData[ind + 2] + KTlvHeaderLength + 1;

            }

        else

            {

            //TLV header bytes (2) must be added to total length

            tlvLength = iData[ind + 1] + KTlvHeaderLength;

            }

        currentTlv = iData[ind]&KTagValueMask;

        //check if TLV in current index is the one that we are searching for

        if ( aTlvTagValue == currentTlv )

            {

            if( index == aItemNbr )

                {

                // check that len of tlv object to be search doesn't

                // go outside BER-TLV object

                if ( ( ind + tlvLength ) <= GetSize() )

                    {

                    // len of tlv object to be search is inside

                    // len of BER-TLV object

                    TPtrC8 data( iData.Mid( ind , tlvLength ) );

                    aTlv->SetData( data );

                    return KErrNone;

                    }

                else

                    {

                    // len of tlv object to be search goes

                    // over len of BER-TLV object, let's return

                    // error value.

                    return KErrNotFound;

                    }

                }

            else

                {

                index++;

                }

            }

        ind += tlvLength;

        }

    return KErrNotFound;

    }

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

// CBerTlv::TlvByTagValueMulti

// Find several TLVs by tag value. It is assumed that TLVs are

// sequential. aTlv is set to point to TLV sequence.

// If no tags are found return KErrNotFound else KErrNone.

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

//

TInt CBerTlv::TlvByTagValueMulti

        (

        CTlv* aTlv,                 //TLV to fill

        TUint8 aTlvTagValue         // tag of tlv to find

        )

    {

    OstTrace0( TRACE_DETAILED, CBERTLV_TLVBYTAGVALUEMULTI, "CBerTlv::TlvByTagValueMulti" );

    TFLOGSTRING("TSY: CBerTlv::TlvByTagValueMulti");

    TInt currentTlv( 0 );

    TInt16 tlvLength( 0 );

    TInt indMulti( 0 );

    TInt16 multiLength( 0 );

    //tlv start index

    TInt ind( KCommonTlvHeaderLength );

    TUint8 berTlvLength;

    //first determine if the length of the BerTLV is coded with 1 or 2 bytes.

    if ( KTwoByteLengthCoding == iData[KTlvLengthStartPosition] )

        {

        berTlvLength = iData[KTlvLengthStartPosition + 1];

        ind = ind + 1;

        }

    else

        {

        berTlvLength = iData[KTlvLengthStartPosition];

        }

    for ( TInt i = 0; i < berTlvLength; i+= tlvLength)

        {

        //first determine if the length of the TLV is coded with 1 or 2 bytes.

        if ( KTwoByteLengthCoding == iData[ind + 1] )

            {

            //length is coded with 2 bytes -> real length is in second byte.

            // first byte is 81 and it is tag for 2 byte length coding.

            tlvLength = (TInt16) ( iData[ind + 0x02] + KTlvHeaderLength + 1 );

            }

        else

            {

            //TLV header bytes (2) must be added to total length

            tlvLength = (TInt16) ( iData[ind + 1]  + KTlvHeaderLength );

            }

        currentTlv = iData[ind]&KTagValueMask;

        //check if TLV in current index is the one that we are searching for

        if ( ( aTlvTagValue == currentTlv ) && ( multiLength == 0x00 ) )

            {

            // save fist tag position

            indMulti = ind;

            multiLength = tlvLength;

            }

        // add length

        if ( ( aTlvTagValue == currentTlv ) && ( indMulti != ind ) )

            {

            multiLength = (TInt16) ( multiLength + tlvLength );

            }

        // if last tag, return

        if ( (i + tlvLength) >= berTlvLength )

            {

            TPtrC8 data = ( iData.Mid( indMulti , multiLength ) );

            aTlv->SetData( data );

            return KErrNone;

            }

        ind += tlvLength;

        }

    return KErrNotFound;

    }

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

// CTlv::CTlv

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

// might leave.

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

//

CTlv::CTlv()

    {

    OstTrace0( TRACE_DETAILED, CTLV_CTLV, "CTlv::CTlv" );

    TFLOGSTRING("TSY: CTlv::CTlv");

    //none

    }

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

// CTlv::GetShortInfo

// Returns the short info (one byte).

// Returned data depends on data type.

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

//

TUint8 CTlv::GetShortInfo

        (

        TTlvSpesificDataType aType //Info spesific data type

        )

    {

    OstTrace0( TRACE_DETAILED, CTLV_GETSHORTINFO, "CTlv::GetShortInfo" );

    TFLOGSTRING("TSY: CTlv::GetShortInfo");

    //information is generally at index 2. NOTE! This method should be optimised

    //after the code maturity is high enough.

    TInt ind ( KTlvDataAreaStartPosition );

    TUint8 offset( 0 );

    //first determine if the length of the TLV is coded with 1 or 2 bytes to

    //determine the offset

    if ( KTwoByteLengthCoding == iData[KTlvLengthStartPosition] )

        {

        offset = 1;

        }

    //Start getting the contents of TLV data

    if ( ETLV_TonAndNpi == aType )

        {

        //TON/NPI is coded as for EFADN.

        ind = KTlvDataAreaStartPosition + offset;

        }

    else if ( ETLV_CommandNumber == aType )

        {

        //Command number

        //

        //For contents and coding, see subclause 6.5.1.

        ind = KTlvDataAreaStartPosition + offset;

        }

    else if ( ETLV_TypeOfCommand == aType )

        {

        //Type of command:

        //

        //Contents:

        // The Type of Command specifies the required interpretation of the

        // data objects which follow, and the required ME procedure.

        //

        //Coding:

        // See section 13.4

        // The ME shall respond to reserved values (i.e. values not listed)

        // with the result "Command type not understood".

        ind = KTlvDataAreaStartPosition + offset + 1;

        }

    else if ( ETLV_CommandQualifier == aType )

        {

        //Command Qualifier:

        //

        //Contents:

        // Qualifiers specific to the command. See 3GPP TS 11.14 V8.8.0,

        // chapter 12.6 Command details for more details.

        ind = KTlvDataAreaStartPosition + offset + 2;

        }

    else if ( ETLV_SourceDeviceIdentity == aType )

        {

        //Source device identity

        //

        //Contents:

        // the source device for information held in the data objects which

        // follow.

        //

        //Coding:

        // both Source and Destination device identities are coded as follows:

        //  '01'         = Keypad

        //  '02'         = Display

        //  '03'         = Earpiece

        //  '10' to '17' = Additional Card Reader x (0 to 7). Value assigned

        //                 by ME.

        //  '21' to '27' = Channel x (1 to 7). Value assigned by ME (if class

        //                 "e" is supported).

        //  '81'         = SIM

        //  '82'         = ME

        //  '83'         = Network

        //  All other values are reserved.

        ind = KTlvDataAreaStartPosition;

        }

    else if ( ETLV_DestinationDeviceIdentity == aType )

        {

        //Destination device identity

        //

        //Contents:

        // the destination device for information held in the data objects

        // which follow.

        //

        // NOTE: Only some combinations of Type of Command, Data Download type

        // and Device identities are allowed defined in clause 14.

        //

        //Coding:

        // both Source and Destination device identities are coded as follows:

        //  '01'         = Keypad

        //  '02'         = Display

        //  '03'         = Earpiece

        //  '10' to '17' = Additional Card Reader x (0 to 7). Value assigned

        //                 by ME.

        //  '21' to '27' = Channel x (1 to 7). Value assigned by ME (if class

        //                 "e" is supported).

        //  '81'         = SIM

        //  '82'         = ME

        //  '83'         = Network

        //  All other values are reserved.

        ind = KTlvDataAreaStartPosition + 1;

        }

    else if ( ETLV_TimeUnit == aType )

        {

        //Time unit

        //

        //Contents:

        // time unit used; minutes, seconds or tenths of seconds.

        //

        //Coding:

        //  '00'    Minutes

        //  '01'    Seconds

        //  '02'    Tenths of seconds

        //  All other values are reserved.

        ind = KTlvDataAreaStartPosition;

        }

    else if ( ETLV_TimeInteval == aType )

        {

        //Time interval

        //

        //Contents:

        // the length of time required, expressed in units.

        //

        //Coding:

        // The time interval is coded in integer multiples of the time unit

        // used. The range is from 1 unit to 255 units. The encoding is:

        //  '00':    reserved

        //  '01':    1 unit

        //  '02':    2 units

        //   :  :    :

        //  'FF':    255 units

        ind = KTlvDataAreaStartPosition + 1;

        }

    else if ( ETLV_IdentifierOfItem == aType )

        {

        //The identifier is a single byte between '01' and 'FF'. Each item

        //shall have a unique identifier within an Item list.

        ind = KTlvDataAreaStartPosition + offset;

        }

    else if ( ETLV_IdentifierOfItemChosen == aType )

        {

        //The identifier is a single byte between '01' and 'FF', exactly the

        //same as for the Item data object. A null item identifier is

        //coded '00'.

        ind = KTlvDataAreaStartPosition;

        }

    else if ( ETLV_MinimumLengthOfResponse == aType )

        {

        //The range of length is between '00' and 'FF'. A minimum length coding