/*
* 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
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "ber_tlvTraces.h"
#endif


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

// -----------------------------------------------------------------------------
// TTlvBase::Begin
// Start ber-tlv construction
// -----------------------------------------------------------------------------
//
void TTlvBase::Begin
        (
        TUint8 aTag //tag
        )
    {
    OstTrace0( TRACE_INTERNALS,  TTLVBASE_BEGIN_TD, "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_INTERNALS,  TTLVBASE_ADDTAG_TD, "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_INTERNALS,  TTLVBASE_ADDBYTE_TD, "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_INTERNALS,  TTLVBASE_ADDDATA_TD, "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_INTERNALS,  TTLVBASE_END_TD, "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_INTERNALS,  TTLVBASE_GETDATAWITHOUTTOPLEVELTAG_TD, "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_INTERNALS,  CBERTLV_CBERTLV_TD, "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_INTERNALS,  CBERTLV_TLVBYTAGVALUE_TD, "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_INTERNALS,  CBERTLV_TLVBYTAGVALUEMULTI_TD, "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_INTERNALS,  CTLV_CTLV_TD, "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_INTERNALS,  CTLV_GETSHORTINFO_TD, "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
        //of '00' indicates that there is no minimum length requirement; a
        //maximum length coding of 'FF' indicates that there is no maximum
        //length requirement. If a fixed length is required the minimum and
        //maximum values are identical.
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_MaximumLengthOfResponse == aType )
        {
        //The range of length is between '00' and 'FF'. A minimum length coding
        //of '00' indicates that there is no minimum length requirement; a
        //maximum length coding of 'FF' indicates that there is no maximum
        //length requirement. If a fixed length is required the minimum and
        //maximum values are identical.
        ind = KTlvDataAreaStartPosition + 1;
        }
    else if ( ETLV_GeneralResult == aType )
        {
        //General result
        //
        //Contents:
        // General result specifies the result and indicates appropriate SIM
        // action. See 3GPP TS 11.14 V8.8.0, chapter 12.12 Result for more
        // details.
        ind = KTlvDataAreaStartPosition + offset;
        }
    else if ( ETLV_DataCodingScheme == aType )
        {
        //Data coding scheme is coded as for SMS Data coding scheme defined
        //in TS 23.038 [5].
        ind = KTlvDataAreaStartPosition + offset;
        }
    else if ( ETLV_Tone == aType )
        {
        //Tone
        //
        //Contents:
        // Tones can be either the standard supervisory tone, as defined in TS
        //02.40 [18], or proprietary tones defined by the ME manufacturer. The
        //code values for proprietary tones shall be supported by the ME. If
        //proprietary tones are not supported the ME shall map these codings to
        //tones that it can generate. The tones to be used are left as an
        //implementation decision by the manufacturer.
        //
        //Coding:
        // Standard supervisory tones:
        //  '01'    Dial tone
        //  '02'    Called subscriber busy
        //  '03'    Congestion
        //  '04'    Radio path acknowledge
        //  '05'    Radio path not available / Call dropped
        //  '06'    Error / Special information
        //  '07'    Call waiting tone
        //  '08'    Ringing tone
        // ME proprietary tones:
        //  '10'    General beep
        //  '11'    Positive acknowledgement tone
        //  '12'    Negative acknowledgement or error tone
        // All other values are reserved.
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_NumberOfFiles == aType )
        {
        //Number of files:
        //This is the number of files that will be described in the following
        //list.
        ind = KTlvDataAreaStartPosition + offset;
        }
    else if ( ETLV_LocationStatus == aType )
        {
        //Location status
        //
        //Contents:
        // this data object indicates the current service state
        // of the MS.
        //  -   "Normal service" shall indicate that the MS is in a state
        //       where all requests for services are treated normally.
        //  -   "Limited service" shall indicate that the MS is in a state
        //       where only emergency call services are offered.
        //  -   "No service" shall indicate that the MS is in a state
        //       where no services are offered.
        //
        //Coding:
        // Each byte in the event list shall be coded with one of
        // the values below:
        //  -   '00' = Normal service
        //  -   '01' = Limited service
        //  -   '02' = No service
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_IconQualifier == aType )
        {
        //Icon qualifier:
        //Contents: The icon qualifier indicates to the ME how the icon is
        //to be used.
        //Coding:
        //bit 1:        0 = icon is self-explanatory, i.e. if displayed, it
        //                  replaces the alpha identifier or text string
        //              1 = icon is not self-explanatory, i.e. if
        //                  displayed, it shall be displayed together with
        //                  the alpha identifier or text string
        //bits 2?8      = 0 RFU.
        ind = KTlvDataAreaStartPosition;
    }
    else if ( ETLV_IconIdentifier == aType )
        {
        //Icon identifier:
        //Contents: The icon identifier addresses a record in EFIMG as
        //defined in TS 11.11 [20].
        //Coding:   Binary.
        ind = KTlvDataAreaStartPosition + 1;
        }
    else if ( ETLV_IconListQualifier == aType )
        {
        //Icon list qualifier:
        //Contents: The icon list qualifier indicates to the ME how the
        //icons are to be used.
        //Coding:
        //bit 1:        0 = icon is self-explanatory, i.e. if displayed, it
        //                  replaces the item text
        //              1 = icon is not self-explanatory, i.e. if displayed,
        //                  it shall be displayed together with the item text
        // bits 2?8 = 0 RFU.

        //All icons in the list shall be treated in the same manner by the
        //ME, i.e. either none of the icons in this list are displayed, or
        //for each item its related icon is displayed.
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_CardReaderStatus == aType )
        {
        //Card reader status:
        //Contents :
        //This contains the identity of the card reader, and flags to
        //indicate the status of the reader with respect to:
        //- whether the card reader is removable or permanently connected;
        //- whether the card reader is present (this can only be false if
        //  the card reader is removable)
        //- whether the card reader present accepts ID-1 size cards (this
        //  can only be true if the card reader is present)
        //- whether there is a card present in the card reader (this can
        //  only be true if the card reader is present)
        //- whether power is being applied to the card (this can only be true if a card is present).

        //Coding :
        //The value of this byte indicates the identity and status of a
        //card reader.
        // bits 1-3       = identity of card reader x.
        // bit 4        0 = Card reader is not removable
        //              1 = Card reader is removable
        // bit 5        0 = Card reader is not present
        //              1 = Card reader is present
        // bit 6        0 = Card reader present is not ID-1 size
        //              1 = Card reader present is ID-1 size
        // bit 7        0 = No card present
        //              1 = Card is present in reader
        // bit 8        0 = No card power ON
        //              1 = Card in reader is power ON
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_CommandClassCLA == aType )
        {
        //This object contains the command APDU for Card x in the format
        //defined in ISO/IEC 7816?4 [25]. Command class CLA, instruction
        //code INS, P1 and P2 parameters, Lc, Data and Le are coded as
        //defined in ISO/IEC 7816?4 [25]. Extended lengths are not
        //supported.
        //Note: The maximum size of the value part of this Simple TLV
        //(value of X) is limited to 241 bytes, so the maximum length for
        //the Data (value of Lc) in a Case 3 type of APDU is 236 bytes.
        ind = KTlvDataAreaStartPosition + offset;
        }
    else if ( ETLV_CommandInstructionCodeIns == aType )
        {
        //This object contains the command APDU for Card x in the format
        //defined in ISO/IEC 7816?4 [25]. Command class CLA, instruction
        //code INS, P1 and P2 parameters, Lc, Data and Le are coded as
        //defined in ISO/IEC 7816?4 [25]. Extended lengths are not
        //supported.
        //Note: The maximum size of the value part of this Simple TLV
        //(value of X) is limited to 241 bytes, so the maximum length for
        //the Data (value of Lc) in a Case 3 type of APDU is 236 bytes.
        ind = KTlvDataAreaStartPosition + offset + 1;
        }
    else if ( ETLV_P1Parameter == aType )
        {
        //This object contains the command APDU for Card x in the format
        //defined in ISO/IEC 7816?4 [25]. Command class CLA, instruction
        //code INS, P1 and P2 parameters, Lc, Data and Le are coded as
        //defined in ISO/IEC 7816?4 [25]. Extended lengths are not
        //supported.
        //Note: The maximum size of the value part of this Simple TLV
        //(value of X) is limited to 241 bytes, so the maximum length for
        //the Data (value of Lc) in a Case 3 type of APDU is 236 bytes.
        ind = KTlvDataAreaStartPosition + offset + 2;
        }
    else if ( ETLV_P2Parameter == aType )
        {
        //This object contains the command APDU for Card x in the format
        //defined in ISO/IEC 7816?4 [25]. Command class CLA, instruction
        //code INS, P1 and P2 parameters, Lc, Data and Le are coded as
        //defined in ISO/IEC 7816?4 [25]. Extended lengths are not
        //supported.
        //Note: The maximum size of the value part of this Simple TLV
        //(value of X) is limited to 241 bytes, so the maximum length for
        //the Data (value of Lc) in a Case 3 type of APDU is 236 bytes.
        ind = KTlvDataAreaStartPosition + offset + 3;
        }
    else if ( ETLV_Lc == aType )
        {
        //This object contains the command APDU for Card x in the format
        //defined in ISO/IEC 7816?4 [25]. Command class CLA, instruction
        //code INS, P1 and P2 parameters, Lc, Data and Le are coded as
        //defined in ISO/IEC 7816?4 [25]. Extended lengths are not
        //supported.
        //Note: The maximum size of the value part of this Simple TLV
        //(value of X) is limited to 241 bytes, so the maximum length for
        //the Data (value of Lc) in a Case 3 type of APDU is 236 bytes.
        if ( KCApduLengthWithoutLc < GetLongInfo( ETLV_Lc ) )
            {
            ind = KTlvDataAreaStartPosition + offset + 4;
            }
        else
            {
            return 0;
            }
        }
    else if ( ETLV_Le == aType )
        {
        //This object contains the command APDU for Card x in the format
        //defined in ISO/IEC 7816?4 [25]. Command class CLA, instruction
        //code INS, P1 and P2 parameters, Lc, Data and Le are coded as
        //defined in ISO/IEC 7816?4 [25]. Extended lengths are not
        //supported.
        //Note: The maximum size of the value part of this Simple TLV
        //(value of X) is limited to 241 bytes, so the maximum length for
        //the Data (value of Lc) in a Case 3 type of APDU is 236 bytes.
        ind = KTlvDataAreaStartPosition + offset + 5 + GetShortInfo( ETLV_Lc );
        }
    else if ( ETLV_StatusWordSW1 == aType )
        {
        //This object contains the response APDU from Card x in the format
        //defined in ISO/IEC 7816?4 [25]. The R-APDU data and status words SW1
        //and SW2 are coded as defined in ISO/IEC 7816?4 [25]. It is possible
        //for no R-APDU data to be present; this is indicated by the length of
        //the data object.
        //Note: The maximum size of the value part of this Simple TLV (value of
        //X) is limited to 239 bytes, so the maximum length of the R-APDU data
        //is 237 bytes.
        ind = KTlvDataAreaStartPosition + offset
            + GetLength() - 2 + 1;
        }
    else if ( ETLV_StatusWordSW2 == aType )
        {
        //This object contains the response APDU from Card x in the format
        //defined in ISO/IEC 7816?4 [25]. The R-APDU data and status words SW1
        //and SW2 are coded as defined in ISO/IEC 7816?4 [25]. It is possible
        //for no R-APDU data to be present; this is indicated by the length of
        //the data object.
        //Note: The maximum size of the value part of this Simple TLV (value of
        //X) is limited to 239 bytes, so the maximum length of the R-APDU data
        //is 237 bytes.
        ind = KTlvDataAreaStartPosition + offset
            + GetLength() - 2 + 2;
        }
    else if ( ETLV_TimerIdentifier == aType )
        {
        //Timer identifier:
        //Contents: identifier of a timer
        //Coding:
        //'01'  Timer 1
        //'02'  Timer 2
        //'03'  Timer 3
        //'04'  Timer 4
        //'05'  Timer 5
        //'06'  Timer 6
        //'07'  Timer 7
        //'08'  Timer 8
        //All other values are reserved
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_BcRepeatIndicatorValues == aType )
        {
        //Contents : The BC repeat indicator is structured exactly as defined
        //in TS 04.08 [08], which may be alternate mode or sequential mode.
        //
        //Coding :  '01' = Alternate mode
        //          '03' = Sequential mode
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_MeStatus == aType )
        {
        //Coding of ME status:
        //'00' = ME is in the idle state
        //'01' = ME is not in idle state
        //'02' to'FF'= reserved values
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_TimingAdvance == aType )
        {
        //The Timing Advance is coded as for the Timing Advance information
        //element in TS 04.08 [8], starting at octet 2 (the IEI is removed, as
        //this information is duplicated by the data object tag).
        ind = KTlvDataAreaStartPosition + 1;
        }
    else if ( ETLV_BrowserIdentity == aType )
        {
        //Coding :
        //00 = Default Browser shall be used.
        //Other values are RFU.
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_BrowserTerminationCause == aType )
        {
        //Coding:
        //00 = User Termination.
        //01 = Error Termination.
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_BearerType == aType )
        {
        //Bearer Type coding
        //'0x00': Bearer type not set
        //'0x01': CSD
        //'0x02': GPRS
        //'0x03': Default bearer for requested transport layer.
        //'0x04': Local link technology independent
        //'0x05': Bluetooth
        //'0x06': IrDA
        //'0x07': RS232
        //'0x10': USB
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_ChannelDataLength == aType )
        {
        //The Channel data length codes :
        //- either the number of bytes that are available in a channel buffer
        //  (Tx or Rx buffers negotiated during OPEN CHANNEL) using TERMINAL
        //  RESPONSE. Since the Tx or Rx buffer size can be larger than 255
        //  bytes, 'FF' means "more than 255 bytes are available".
        //- or the number of bytes that are requested in a RECEIVE DATA command
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_TypeOfAddress == aType )
        {
        //A null Local address shall be coded with Length = '00', and no Value
        //part. In that case, the ME shall request a dynamic address.
        //
        //Coding of Type of address: according to packet data protocol address
        //in TS 04.08 [8].
        //'21' = IPv4 address
        //'97' = IPv6 address
        //'others' = reserved
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_TransportProtocolType == aType )
        {
        //Transport protocol type coding:
        //- '01' : UDP (as defined in RFC 768 [33])
        //- '02' : TCP (as defined in RFC 793 [34])
        //all other value are reserved
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_UtranMeasurementQualifier == aType )
        {
        // UTRAN Measurement Qualifier coding:
        //'01' Intra-frequency measurements
        //'02' Inter-frequency measurements
        //'03' Inter-RAT (GSM) measurements
        // All other values are reserved
        ind = KTlvDataAreaStartPosition;
        }
    else if ( ETLV_RemoteEntityAddressCoding == aType )
        {
        // Remote Entity Address Coding Type:
        // '00' IEEE-802 48-bit address
        // '01' to 'FF' are reserved values
        ind = KTlvDataAreaStartPosition;
        }
    else
        {
        // Data type did not match with any of enumerations
        TFLOGSTRING2("TSY: CTlv::GetShortInfo, Unknown data type:0x%x", aType);
        OstTrace1( TRACE_INTERNALS,  DUP1_CTLV_GETSHORTINFO_TD, "CTlv::GetShortInfo Unknown data type: %{TTlvSpesificDataType}", aType );

        }

    return iData[ind];

    }

// -----------------------------------------------------------------------------
// CTlv::GetData
// Returns the data. Returned data depends on data type.
// -----------------------------------------------------------------------------
//
TPtrC8 CTlv::GetData
        (
        TTlvSpesificDataType aType //Info spesific data type
        )
    {
    OstTrace0( TRACE_INTERNALS,  CTLV_GETDATA_TD, "CTlv::GetData" );
    TFLOGSTRING("TSY: CTlv::GetData");

    //information is generally at index 2.
    TInt ind ( 2 );
    TUint8 offset( 0 );
    TInt length( 1 );

    //first determine if the length of the TLV is coded with 1 or 2 bytes.
    if ( KTwoByteLengthCoding == iData[KTlvLengthStartPosition] )
        {
        offset = 1;
        }

    //start getting TLV data elements
    if ( ETLV_DiallingNumberString == aType )
        {
        ind = KTlvDataAreaStartPosition + 1 + offset;
        //Dialling number string is coded as for EFADN, and may include
        //DTMF separators and DTMF digits, which the ME shall send in the
        //same way as for EFADN but without locally generating audible DTMF
        //tones to the user.
        //-----------------------------------------------------------
        // Byte(s)              | Description             |  Length  |
        //-----------------------------------------------------------
        // 1                    | Address tag             |  1       |
        // 2 to (Y-1)+2         | Length (X)              |  Y       |
        // (Y-1)+3              | TON and NPI             |  1       |
        // (Y-1)+4 to (Y-1)+X+2 | Dialling number string  |  X-1     |
        //------------------------------------------------------------
        length = GetLength() - 1;
        }
    else if ( ETLV_AlphaIdentifier == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //The alpha identifier is coded as for EFADN. See TS 11.11 [20] for
        //the coding of all EFs.
        length = GetLength();
        }
    else if ( ETLV_SubAddress == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Subaddress contains information as defined for this purpose in
        //TS 04.08 [8] (calling party subaddress or called party
        //subaddress). All information defined in TS 04.08 shall be given
        //in the value part of the data object, except the information
        //element identifier and the length of subaddress contents (which
        //is given by the length part of the data object).
        length = GetLength();
        }
    else if ( ETLV_CapabilityConfigurationParameters == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Capability configuration parameters are coded as for EFCCP. If
        //it is being provided by the SIM, the SIM shall supply all information
        //required to complete the Bearer Capability Information Element in the
        //Call Set-up message (see TS 04.08 [8]). Any unused bytes at the end
        //of the value part shall be coded 'FF'. See TS 11.11 [20] for the
        //coding of all EFs.
        //
        //NOTE: The second byte of this TLV contains the Length of the TLV and
        //the third byte contains the Length of the bearer capability contents,
        //followed by the actual contents.

        length = GetLength();
        }
    else if ( ETLV_CellBroadcastPage == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //The Cell Broadcast page is formatted in the same way as described
        //in TS 23.041 [7].
        length = GetLength();
        }
    else if ( ETLV_TextStringOfItem == aType )
        {
        ind = KTlvDataAreaStartPosition + offset + 1;
        //The text string is coded in the same way as the alpha identifier
        //for EFADN. Any unused bytes at the end of the value part shall be
        //coded 'FF'.
        length = GetLength() - 1;
        }
    else if ( ETLV_AdditionalInformationOnResult == aType )
        {
        ind = KTlvDataAreaStartPosition + offset + 1;
        //Contents: For the general result "Command performed successfully",
        //some proactive commands require additional information in the command
        //result. This is defined in the subclauses below. For the general
        //results '20', '21', '26', '34', '35', '37', '38' and '39' and '3A',
        //it is mandatory for the ME to provide a specific cause value as
        //additional information, as defined in the subclauses below. For the
        //other general results, the ME may optionally supply additional
        //information. If additional information is not supplied, then the
        //length of the value part of the data object need only contain the
        //general result.
        length = GetLength() - 1;
        }
    else if ( ETLV_SmsTPdu == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //The TPDU is formatted as described in TS 23.040 [6]. Where the TPDU
        //is being sent from the SIM to the ME (to be forwarded to the
        //network), and where it includes a TP-Message-Reference which is to be
        //incremented by the ME for every outgoing message, the
        //TP-Message-Reference as provided by the SIM need not be the valid
        //value. TP-Message-Reference shall be checked and corrected by the ME
        //to the value described in TS 23.040 [6].
        length = GetLength();
        }
    else if ( ETLV_SsOrUssdString == aType )
        {
        ind = KTlvDataAreaStartPosition + offset + 1;
        //SS or USSD control string are coded as for EFADN, where the ADN
        //record relates to a Supplementary Service Control string.
        //See TS 11.11 [20] for the coding of EFADN.
        length = GetLength() - 1;
        }
    else if ( ( ETLV_TextString == aType ) ||
        ( ETLV_DefaultText == aType ) )
        {
        ind = KTlvDataAreaStartPosition + offset + 1;
        //A null text string shall be coded with Length = '00', and no Value
        //part.
        length = GetLength() - 1;
        }
    else if ( ETLV_UssdString == aType )
        {
        ind = KTlvDataAreaStartPosition + offset + 1;
        //The coding of the USSD string is defined in TS 02.30 [4].
        length = GetLength() - 1;
        }
    else if ( ETLV_Files == aType )
        {
        ind = KTlvDataAreaStartPosition + offset + 1;
        //Files:
        //Full paths are given to files. Each of these shall be at least 4
        //octets in length (e.g. '3F002FE2' or '3F007F206FAD'). Each entry in
        //the file description is composed of two bytes, where the first byte
        //identifies the type of file (see TS 11.11). An entry in the file
        //description shall therefore always begin with '3FXX'. There can be
        //any number of Dedicated File entries between the Master File and
        //Elementary File. There shall be no delimiters between files, as this
        //is implied by the fact that the full path to any EF starts with
        //'3FXX' and ends with an Elementary type file.
        length = GetLength() - 1;
        }
    else if ( ETLV_MccAndMnc == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //The mobile country code (MCC), the mobile network code (MNC), the
        //location area code (LAC) and the cell ID are coded as in
        //TS 04.08 [8].
        length = KMccAndMncLength;
        }
    else if ( ETLV_Imei == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //The IMEI is coded as in TS 04.08 [8].
        length = GetLength();
        }
    else if ( ETLV_NetworkMeasurementResults == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //The Network Measurement Results are coded as for the Measurement
        //Results information element in TS 04.08 [8], starting at octet 2 (the
        //IEI is removed, as this information is duplicated by the data object
        //tag).
        length = GetLength();
        }
    else if ( ETLV_ItemsNextActionIndicator == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //Contents :
        //Each item of a list of items has a next action indicator coded on one
        //byte. The length of the Items Next Action Indicator list shall be the
        //number of items of the list of items (X shall be the number of items
        //in the list). The order of each item next action indicator, shall
        //reflect the order o the items in the list of items.

        //The Item Next action indicator gives the possible actions that will
        //be initiated by the SIM in case of selection by the user.

        //Coding :  If the value is equal to '00' or if the value is reserved
        //(that is, value not listed), the ME shall ignore the next action
        //indicator type.

        //See subclause 13.4 for further information.
        //Example :
        //For the following list of items :
        //          - item #1;
        //          - item #2;
        //          - item #3;
        //          - ....
        //          - item #n,
        //the Items Next Action Indicator (NAI) shall be as follows :
        //
        //  ------------------------------------------------------------
        // |    Tag    |   Length   |   NAI#1   |   NAI#2   |   NAI#3   |
        //  ------------------------------------------------------------

        length = GetLength();
        }
    else if ( ETLV_EventList == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Event list
        //Contents: A list of events, of variable length. Each byte in the list
        //defines an event. Each event type shall not appear more than once
        //within the list.
        //Coding: Each byte in the event list shall be coded with one of the
        //values below:
        // -    '00' = MT call
        // -    '01' = Call connected
        // -    '02' = Call disconnected
        // -    '03' = Location status
        // -    '04' = User activity
        // -    '05' = Idle screen available
        // -    '06' = Card reader status    (if class "a" is supported)
        // -    '07' = Language selection
        // -    '08' = Browser Termination    (if class "c" is supported)
        // -    '09' = Data available    (if class "e" is supported)
        // -    '0A' = Channel status   (if class "e" is supported)
        length = GetLength();
        }
    else if ( ETLV_Cause == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //The Cause data object is coded as for the Cause call control
        //information element in TS 04.08 [8], starting at octet 3 (the IEI and
        //Length information are removed, as this information is duplicated by
        //the data object tag and length). Radio Link Timeout is indicated by
        //the Cause data object having a value part of zero length (only the
        //Tag and Length components are sent).
        length = GetLength();
        }
    else if ( ETLV_TransactionIdentifier == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //Transaction identifier list
        //Contents: A list of transaction identifiers, of variable length. Each
        //byte in the list defines a transaction identifier. Each transaction
        //identifier shall not appear more than once within the list.
        //Coding: Each byte in the transaction identifier list shall be coded
        //as defined below:
        //bits 1 to 4   = RFU
        //bits 5 to 7   = value
        //bit  8        = flag
        //value and flag are coded as defined in TS 24.007 [23].
        length = GetLength();
        }
    else if ( ETLV_BcchChannelList == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //BCCH channel list
        //Contents: the list of absolute RF channels for BCCH carriers, as
        //known by the ME from the SYSTEM INFORMATION messages. The BCCH
        //channel list is composed of one to three BCCH channel sub lists, each
        //sub list is derived from the set of frequencies defined by reference
        //neighbour cells description information element or elements. In the
        //latter case the set is the union of the different subsets defined by
        //the neighbour cells description information elements
        //(see TS 04.08 [8]). The length of the BCCH channel list field depends
        //on the length of the received BCCH channel list derived from the
        //different SYSTEM INFORMATION messages to be considered.
        //Coding: Each ARFCN is represented by 10 bits. Spare bit(s) are to be
        //filled with 0.

        //         Bit 8   Bit 7   Bit 6   Bit 5   Bit 4   Bit 3   Bit 2  Bit 1
        //---------------------------------------------------------------------
        // Byte 1 |                        ARFCN#1 (high part)
        // Byte 2 |ARFCN#1 (low part)              ARFCN#2 (high part)
        // Byte 3 |        ARFCN#2 (low part)              ARFCN#3 (high part)
        // Byte n |                        n
        // ByteX-1|        ARFCN#m-1 (low part)            ARFCN#m (high part)
        // Byte X |                ARFCN#m (low part)              Spare  Spare
        //                                                          (0)     (0)

        //SIM applications should take into account that early implementations
        //of SIM application toolkit may have coded this field differently,
        //because of an inconsistancy between the content and the coding of
        //this element in previous versions of 11.14. The SIM is able to
        //identify MEs that are using the coding described above by evaluating
        //the indication "BCCH Channel List coding" in the TERMINAL PROFILE
        //command.
        length = GetLength();
        }
    else if ( ETLV_CallControlRequestedAction == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Call control requested action
        //Contents: The action given in response to the ENVELOPE (CALL
        //CONTROL). It may contain, in the same order as given by the SIM, the
        //address or SS string, the capability configuration parameters, the
        //called party sub-address and the alpha identifier.

        //Coding: as described in subclause 9.1.6, starting with the first
        //optional element given in the response data to the ENVELOPE (CALL
        //CONTROL).
        length = GetLength();
        }
    else if ( ETLV_IconIdentifierList == aType )
        {
        ind = KTlvDataAreaStartPosition + 1;
        //Icon identifier list:
        //Contents :
        //Each item of a list of items has an icon identifier coded on one
        //byte. The length of the Items icon identifier list shall be the
        //number of items of the list of items (X-1 shall be the number of
        //items in the list). The order of each item icon identifier, shall
        //reflect the order of the items in the list of items.
        //Each icon identifier addresses a record in EFIMG as defined in
        //TS 11.11 [20].

        //Coding :  Binary.
        //Example :
        //For the following list of items : - item #1
        //                                  - item #2
        //                                  - item #3
        //                                  - ....
        //                                  - item #n,

        //the Items icon identifier list shall be as follows :
        //---------------------------------------------------------
        // Tag | Length |icon         |icon         |icon         |
        //---------------------------------------------------------
        //     |        |identifier#1 |identifier#2 |identifier#3 |
        //---------------------------------------------------------
        length = GetLength() - 1;
        }
    else if ( ETLV_Atr == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //ATR:
        //Contents :
        //This is the Answer To Reset returned by the card.

        //Coding :
        //The coding of the Answer To Reset is defined in ISO/IEC 7816-3 [16].
        length = GetLength();
        }
    else if ( ETLV_Data == aType )
        {
        TUint8 dataLength( GetShortInfo( ETLV_Lc ) );
        if ( dataLength )
            {
            ind = KTlvDataAreaStartPosition + offset + 5;
            //This object contains the command APDU for Card x in the format
            //defined in ISO/IEC 7816?4 [25]. Command class CLA, instruction
            //code INS, P1 and P2 parameters, Lc, Data and Le are coded as
            //defined in ISO/IEC 7816?4 [25]. Extended lengths are not
            //supported.
            //Note: The maximum size of the value part of this Simple TLV
            //(value of X) is limited to 241 bytes, so the maximum length for
            //the Data (value of Lc) in a Case 3 type of APDU is 236 bytes.
            length = dataLength;
            }
        else
            {
            return 0;
            }
        }
    else if ( ETLV_RApduData == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //This object contains the response APDU from Card x in the format
        //defined in ISO/IEC 7816?4 [25]. The R-APDU data and status words SW1
        //and SW2 are coded as defined in ISO/IEC 7816?4 [25]. It is possible
        //for no R-APDU data to be present; this is indicated by the length of
        //the data object.
        //Note: The maximum size of the value part of this Simple TLV (value of
        //X) is limited to 239 bytes, so the maximum length of the R-APDU data
        //is 237 bytes.
        length = GetLength() - 2;
        }
    else if ( ETLV_TimerValue == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //Timer value:
        //Contents: value of a timer, expressed using the format hour, minute,
        //second.
        //Coding:
        // -    byte 3: hour; this byte is coded exactly in the same way as the
        //              hour field of the TP-Service-Centre-Time-Stamp in
        //              TS 23.040 [6].
        // -    byte 4: minute; this byte is coded exactly in the same way as
        //              the minute field of the TP-Service-Centre-Time-Stamp in
        //              TS 23.040 [6].
        // -    byte 5: second; this byte is coded exactly in the same way as
        //              the second field of the TP-Service-Centre-Time-Stamp in
        //              TS 23.040 [6].
        length = GetLength();
        }
    else if ( ETLV_DateTimeAndTimeZone == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //The Date-Time and Time zone is coded as for the Time Zone and Time
        //information element in TS 04.08 [8], starting at octet 2 (i.e. 1 byte
        //for year, month, day, hour, minute, second and time zone). Each byte
        //is encoded in exactly the same way as the corresponding field of the
        //TP-Service-Centre-Time-Stamp in TS 23.040 [6]. For the time zone
        //field, 'FF' indicates an unknown value.
        length = GetLength();
        }
    else if ( ETLV_AtCommand == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Contents :
        // The AT Command string is structured exactly as the AT Command line
        // as defined in GSM 27.007 [27], which may contain single or
        // concatenated AT commands.
        length = GetLength();
        }
    else if ( ETLV_AtResponse == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Contents:
        // The AT Response string is structured exactly as the response to a
        // command line as defined in GSM 27.007 [27], which may contain single
        // or concatenated responses appropriate to the issued AT command.
        // If the AT Response string is longer than the maximum length capable
        // of being transmitted to the SIM then the AT Response string shall be
        // truncated to this length by the ME.
        length = GetLength();
        }
    else if ( ETLV_DtmfString == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Contents : The DTMF string which can be single or multiple characters
        //is coded in BCD, in the same way as the Dialling number string
        //defined for EFADN in TS 11.11 [20].  It may include extended BCD
        //coding. There is no need for a DTMF control digit separator at the
        //beginning of the string, but if present it shall be interpreted as
        //PAUSE.
        length = GetLength();
        }
    else if ( ETLV_Url == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //A null URL shall be coded with Length = '00', and no Value part. In
        //that case, the ME shall use the default  URL.
        //
        //Coding :
        //The data used for the URL shall be coded as defined in [32] on using
        //the "SMS 7bits default alphabet" with bit 8 set to 0;
        length = GetLength();
        }
    else if ( ETLV_ListOfBearers == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //The ME shall use this list to choose which bearers are allowed in
        //order of priority.

        //Coding of the bearers :
        //'00' = SMS
        //'01' = CSD
        //'02' = USSD
        //'03' = GPRS
        //'04' to 'FF' = RFU.
        length = GetLength();
        }
    else if ( ETLV_PathToProvisioningFile == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Note : the path is the concatenation of file identifiers starting
        //from the Master File, e.g. : 3F007F206FXY...
        //The file shall contain a single unambiguous set of parameters
        //required to make the connection. The content of the file shall be
        //consistent with the format defined for provisioning information for
        //the requested type of browser.
        length = GetLength();
        }
    else if ( ETLV_BearerParameters == aType )
        {
        ind = KTlvDataAreaStartPosition + offset + 1;
        //see 3GPP spec: 12.52.1
        //12.52.1 Bearer parameters for CSD
        //12.52.2 Bearer parameters for GPRS / packet service
        //12.52.3 Default bearer
        length = GetLength() - 1;
        }
    else if ( ETLV_ChannelDataString == aType )
        {
        ind = KTlvDataAreaStartPosition + offset;
        //Contents:
        //The Channel data object contains application data read from or
        //written to a specific channel buffer in the ME.
        //Coding:
        //The Channel data string must be considered by the ME as binary coded
        //on 8 bits.
        length = GetLength();
        }
    else if ( ETLV_IdentifierOfCardReader == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //Coding :
        //The identifier of card reader is coded in hexadecimal.
        length = GetLength();
        }
    else if ( ETLV_Address == aType )
        {
        ind = KTlvDataAreaStartPosition + 1;
        //Coding of address: according to packet data protocol address in
        //TS 04.08 [8].
        //If type of address indicates IPv4, the Address information in octet 4
        //to octet 7 contains the IPv4 address. Bit 8 of octet 4 represents the
        //most significant bit of the IP address and bit 1 of octet 7 the least
        //significant bit .
        //If type of address indicates IPv6, the Address information in octet 4
        //to octet 19 contains the IPv6 address. Bit 8 of octet 4 represents
        //the most significant bit of the IP address and bit 1 of octet 19 the
        //least significant bit.
        length = GetLength() - 1;  // Length minus 1 because there is a byte
                                   //before the address data
        }
    else if ( ETLV_NetworkAccessName == aType )
        {
        ind = KTlvDataAreaStartPosition;
        //Content:
        //The Network Access Name is used to identify the Gateway entity, which
        //provides interworking with an external packet data network. For GPRS,
        //the Network Access Name is an APN.
        //Coding:   As defined in TS 23.003 [36].
        length = GetLength();
        }
    else if ( ETLV_AID == aType )
        {
        ind = KTlvDataAreaStartPosition;
        // Application identifier as defined in TS 31.110
        // Byte(s)        Description
        // 1            AID tag
        // 2            Length (X)
        // 3 to (X+2)    AID

        length = GetLength();
        }
    else if ( ETLV_RemoteEntityAddress == aType )
        {
        ind = KTlvDataAreaStartPosition + 1;
        // Remote Entity Address:
        // According to Coding Type
        // --------------------------------------------------
        // | Byte(s):     | Description:          | Length: |
        // --------------------------------------------------
        // | 1            | Item Tag              | 1       |
        // | 2 to Y+1     | Lenght (X+1)          | Y       |
        // | Y+2          | Coding Type           | 1       |
        // | Y+3 to Y+X+2 | Remote entity Address | X       |
        // --------------------------------------------------
        // Length minus 1 because there is a coding type byte
        // before the remote entity address data
        length = GetLength() - 1;
        }
    else
        {
        // Data type did not match
        TFLOGSTRING2("TSY: CTlv::GetData, Unknown data type: 0x%x", aType );
        OstTrace1( TRACE_INTERNALS,  DUP2_CTLV_GETDATA_TD, "CTlv::GetData Unknown data type: %{TTlvSpesificDataType}", aType );

        }

    return iData.Mid( ind, length );

    }

// -----------------------------------------------------------------------------
// CTlv::GetLongInfo
// Returns the the data.
// Returned data depends on data type.
// -----------------------------------------------------------------------------
//
 TUint16 CTlv::GetLongInfo
        (
        TTlvSpesificDataType aType //Info spesific data type
        )
    {
    OstTrace0( TRACE_INTERNALS,  CTLV_GETLONGINFO_TD, "CTlv::GetLongInfo" );
    TFLOGSTRING("TSY: CTlv::GetLongInfo");

    TUint16 ret( 0x0000 );

    if ( ETLV_LocationAreaCode == aType )
        {
        //The mobile country code (MCC), the mobile network code (MNC), the
        //location area code (LAC) and the cell ID are coded as
        //in TS 04.08 [8].
        TSatUtility::GetWord
            ( ret, iData, KTlvLengthStartPosition + KMccAndMncLength );
        }
    else if ( ETLV_CellIdentityValue == aType )
        {
        //The mobile country code (MCC), the mobile network code (MNC), the
        //location area code (LAC) and the cell ID are coded as
        //in TS 04.08 [8].
        TSatUtility::GetWord( ret, iData, KTlvLengthStartPosition
            + KMccAndMncLength + KLocationAreaCodeLength );
        }
    else if ( ETLV_Language == aType )
        {
        //Coding:
        // each language code is a pair of alpha-numeric characters, defined in
        // ISO 639 [29].  Each alpha-numeric character shall be coded on one
        // byte using the SMS default 7-bit coded alphabet as defined in
        // TS 23.038 [5] with bit 8 set to 0.
        TSatUtility::GetWord( ret, iData, KTlvDataAreaStartPosition );
        }
    else if ( ETLV_BufferSize == aType )
        {
        //Coding:
        // The Buffer size codes the number of bytes requested by the SIM in an
        // OPEN CHANNEL command or what the ME can offer the SIM (placed in
        // TERMINAL RESPONSE).
        TSatUtility::GetWord( ret, iData, KTlvDataAreaStartPosition );
        }
    else if ( ETLV_ChannelStatus == aType )
        {
        //Contents :
        //The Channel status is a string of binary coded characters.
        //Coding of byte 3:
        //bit 1 to 3:   Channel identifier : 1..7
        //              Channel identifier 0 means "No channel available"
        //bit 4 to 7:   RFU
        //bit 8:        0 = Link not established or PDP context not activated
        //              1 = Link established or PDP context activated
        //
        //Coding of byte 4:
        //- '00' = No further info can be given
        //- '01' = Not used
        //- '02' = Not used
        //- '03' = Not used
        //- '04' = Not used
        //- '05' = Link dropped
        //all other values are reserved for future use
        TSatUtility::GetWord( ret, iData, KTlvLengthStartPosition );
        }
    else if ( ETLV_PortNumber == aType )
        {
        //Port number coding: integer
        TSatUtility::GetWord( ret, iData, KTlvDataAreaStartPosition + 1 );
        }
    else
        {
        // Data type did not match
        TFLOGSTRING2("TSY: CTlv::GetLongInfo, Unknown data type:0x%x", aType );
        OstTrace1( TRACE_INTERNALS,  DUP1_CTLV_GETLONGINFO_TD, "CTlv::GetLongInfo, Unknown data type: %{TTlvSpesificDataType}", aType );

        }
    return ret;

    }


// -----------------------------------------------------------------------------
// CBerTlv::BerTlv
// Set ber-tlv to proactive sim command ber-tlv in
// UICC_CAT_IND(UICC_CAT_FETCHED_CMD)  ISI message.
// -----------------------------------------------------------------------------
//
TInt CBerTlv::BerTlv( const TIsiReceiveC& aIsiMessage )
    {
    OstTrace0( TRACE_INTERNALS,  CBERTLV_BERTLV_TD, "CBerTlv::BerTlv" );
    TFLOGSTRING("TSY: CBerTlv::BerTlv");

    TInt result ( KErrNotFound );
    TUint16 berTlvLength( 0 );

    // BER-TLV data is in subblock UICC_SB_APDU
    TUint uiccSbApduOffset( 0 );
    if ( KErrNone == aIsiMessage.FindSubBlockOffsetById(
        ISI_HEADER_SIZE + SIZE_UICC_CAT_IND,
        UICC_SB_APDU,
        EIsiSubBlockTypeId16Len16,
        uiccSbApduOffset ) )
        {
        berTlvLength = aIsiMessage.Get16bit(
            uiccSbApduOffset + UICC_SB_APDU_OFFSET_APDULENGTH );

        // Check the proactive command tag
        if ( KBerTlvProactiveSimCommandTag == aIsiMessage.Get8bit(
            uiccSbApduOffset + UICC_SB_APDU_OFFSET_APDU ) )
            {
            TPtrC8 data( aIsiMessage.GetData(
                uiccSbApduOffset + UICC_SB_APDU_OFFSET_APDU,
                berTlvLength ) );
            SetData( data );
            result = KErrNone;
            }
        }
    return result;
    }


// ========================== OTHER EXPORTED FUNCTIONS =========================
// none

//End Of File
