/*

* Copyright (c) 2007-2008 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 "satutil.h"            // sat utility class

#include "ber_tlv.h"            // ber-tlv classes

#include <ctsy/serviceapi/cmmsmsutility.h>      // ton/npi constants

#include "tsylogger.h"          // for logging

#include <tisi.h>               // isi message

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "satutilTraces.h"

#endif

// CONSTANTS

// Transaction id numbers

const TUint KSatTransIdMaxCountPlusOne          = 255;

const TUint8 KTransactionIdMinNumber            = 0xC0;

// Masking

const TUint8 KPacked7BitTextMask                = 0x0C;

// Shifting

const TUint8 KCrShiftedOneBitToLeft             = 0x1A;

const TUint8 KSiftedSixTimes                    = 0x06;

const TUint8 KCarriageReturn                    = 0x0D;

// Extended table

const TUint8 KExtendedTable                     = 0x1B;

// MODULE DATA STRUCTURES

// Bcd->ascii translation table

static const TUint8 KAscii[16] =

    {

     '0', '1', '2', '3', '4', '5', '6', '7',

     '8', '9', '*', '#', 'p', 'w', '.',  0

    };

// GSM 7-bit ->unicode translation table

// See 3GPP TS 23.038

static const TUint16 KUnicode[128] =

    {

     0x0040, 0x00A3, 0x0024, 0x00A5, 0x00E8, 0x00E9, 0x00F9, 0x00EC,

     0x00F2, 0x00E7, 0x000A, 0x00D8, 0x00F8, 0x000D, 0x00C5, 0x00E5,

     0x0394, 0x005F, 0x03A6, 0x0393, 0x039B, 0x03A9, 0x03A0, 0x03A8,

     0x03A3, 0x0398, 0x039E, 0x00A0, 0x00C6, 0x00E6, 0x00DF, 0x00C9,

     0x0020, 0x0021, 0x0022, 0x0023, 0x00A4, 0x0025, 0x0026, 0x0027,

     0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,

     0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,

     0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,

     0x00A1, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,

     0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,

     0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,

     0x0058, 0x0059, 0x005A, 0x00C4, 0x00D6, 0x00D1, 0x00DC, 0x00A7,

     0x00BF, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,

     0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,

     0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,

     0x0078, 0x0079, 0x007A, 0x00E4, 0x00F6, 0x00F1, 0x00FC, 0x00E0

    };

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

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

// TTransIdMessage::TTransIdMessage

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

// might leave.

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

//

TTransIdMessage::TTransIdMessage() : iTransNum(KTransactionIdMinNumber)

    {

    OstTrace0( TRACE_NORMAL, TTRANSIDMESSAGE_TTRANSIDMESSAGE, "TTransIdMessage::TTransIdMessage" );

    }

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

// TTransIdMessage::GetTransactionId

// Gets a new transactionID

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

//

TUint8 TTransIdMessage::GetTransactionId()

    {

    OstTrace0( TRACE_NORMAL, TTRANSIDMESSAGE_GETTRANSACTIONID, "TTransIdMessage::GetTransactionId" );

    TFLOGSTRING("TSY: TTransIdMessage::GetTransactionId");

    // 0xff and 0x00 are

    // not valid transaction id's and will not be generated. This is done

    // to avoid generating transaction ids that are used in terminal resp

    iTransNum++;

    if ( KSatTransIdMaxCountPlusOne == iTransNum )

        {

        iTransNum = KTransactionIdMinNumber;

        }

    return iTransNum;

    }

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

// TSatUtility::GetTonAndNpi

// Map TON and NPI to RSat TON and NPI values

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

//

void TSatUtility::GetTonAndNpi

        (

        TInt aTonAndNpi,                // TON and NPI

        RSat::TTypeOfNumber* aTon,      // Type of number

        RSat::TNumberingPlan* aNpi      // Number plan identification

        )

    {

    OstTrace0( TRACE_NORMAL, TSATUTILITY_GETTONANDNPI, "TSatUtility::GetTonAndNpi: RSat" );

    TFLOGSTRING("TSY: TSatUtility::GetTonAndNpi: RSat");

    TInt ton( ( aTonAndNpi >> 4 ) & KTONMask );

    switch ( ton )

        {

        case KTonUnknown:

            *aTon = RSat::EUnknownNumber;

            break;

        case KInternationalNumber:

            *aTon = RSat::EInternationalNumber;

            break;

        case KNationalNumber:

            *aTon = RSat::ENationalNumber;

            break;

        case KNetworkSpecificNumber:

            *aTon = RSat::ENetworkSpecificNumber;

            break;

        case KSubscriberNumber:

            *aTon = RSat::EDedicatedNumber;

            break;

        case KAlphanumeric:

            *aTon = RSat::EAlphanumericNumber;

            break;

        case KAbbreviatedNumber:

            *aTon = RSat::EAbbreviatedNumber;

            break;

        default:

            *aTon = RSat::ETypeOfNumberNotSet;

            break;

        }

    // Numbering plan

    TInt npi( aTonAndNpi & KNPIMask );

    switch ( npi )

        {

        case KNpiUnknown:

            *aNpi = RSat::EUnknownNumberingPlan;

            break;

        case KIsdnTelephoneNumPlan:

            *aNpi = RSat::EIsdnNumberPlan;

            break;

        case KDataNumPlan:

            *aNpi = RSat::EDataNumberPlan;

            break;

        case KTelexNumPlan:

            *aNpi = RSat::ETelexNumberPlan;

            break;

        case KNationalNumPlan:

            *aNpi = RSat::ENationalNumberPlan;

            break;

        case KPrivateNumPlan:

            *aNpi = RSat::EPrivateNumberPlan;

            break;

        case KServiceCentreSpecificPlan1:

            *aNpi = RSat::EServiceCentreSpecificPlan1;

            break;

        case KServiceCentreSpecificPlan2:

            *aNpi = RSat::EServiceCentreSpecificPlan2;

            break;

        case KErmesNumPlan:

            *aNpi = RSat::EERMESNumberPlan;

            break;

        default:

            *aNpi = RSat::ENumberingPlanNotSet;

            break;

        }

    }

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

// TSatUtility::GetTonAndNpi

// Map TON and NPI to Etel MM TON and NPI values

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

//

void TSatUtility::GetTonAndNpi

        (

        TInt aTonAndNpi,

        RMobilePhone::TMobileTON& aTon,

        RMobilePhone::TMobileNPI& aNpi

        )

    {

    OstTrace0( TRACE_NORMAL, DUP1_TSATUTILITY_GETTONANDNPI, "TSatUtility::GetTonAndNpi: Etel MM" );

    TFLOGSTRING("TSY: TSatUtility::GetTonAndNpi: Etel MM");

    TInt ton( ( aTonAndNpi >> 4 ) & KTONMask );

    switch ( ton )

        {

        case KInternationalNumber:

            aTon = RMobilePhone::EInternationalNumber;

            break;

        case KNationalNumber:

            aTon = RMobilePhone::ENationalNumber;

            break;

        case KNetworkSpecificNumber:

            aTon = RMobilePhone::ENetworkSpecificNumber;

            break;

        case KSubscriberNumber:

            aTon = RMobilePhone::ESubscriberNumber;

            break;

        case KAlphanumeric:

            aTon = RMobilePhone::EAlphanumericNumber;

            break;

        case KAbbreviatedNumber:

            aTon = RMobilePhone::EAbbreviatedNumber;

            break;

        case KTonUnknown:

        default:

            aTon = RMobilePhone::EUnknownNumber;

            break;

        }

    // Numbering plan

    TInt npi( aTonAndNpi & KNPIMask );

    switch ( npi )

        {

        case KIsdnTelephoneNumPlan:

            aNpi = RMobilePhone::EIsdnNumberPlan;

            break;

        case KDataNumPlan:

            aNpi = RMobilePhone::EDataNumberPlan;

            break;

        case KTelexNumPlan:

            aNpi = RMobilePhone::ETelexNumberPlan;

            break;

        case KNationalNumPlan:

            aNpi = RMobilePhone::ENationalNumberPlan;

            break;

        case KPrivateNumPlan:

            aNpi = RMobilePhone::EPrivateNumberPlan;

            break;

        case KServiceCentreSpecificPlan1:

            aNpi = RMobilePhone::EServiceCentreSpecificPlan1;

            break;

        case KServiceCentreSpecificPlan2:

            aNpi = RMobilePhone::EServiceCentreSpecificPlan2;

            break;

        case KErmesNumPlan:

            aNpi = RMobilePhone::EERMESNumberPlan;

            break;

        case KNpiUnknown:

        default:

            aNpi = RMobilePhone::EUnknownNumberingPlan;

            break;

        }

    }

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

// TSatUtility::Packed7to8Unpacked

// Converts 7-bit packed string to 8-bit unpacked format.

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

//

void TSatUtility::Packed7to8Unpacked

        (

        TPtrC8 aString,   //7-bit packed string

        TDes8& aOutput    //8-bit unpacked string

        )

    {

    OstTrace0( TRACE_NORMAL, TSATUTILITY_PACKED7TO8UNPACKED, "TSatUtility::Packed7to8Unpacked" );

    TFLOGSTRING("TSY: TSatUtility::Packed7to8Unpacked");

    // The string is in packed GSM default alphabet format.

    // Converted to 8-bit format

    TUint8 maskRightPartOfCurrentByte( 0x7F );

    TUint8 shiftLeft( 0 );

    TUint8 leftPartFromPreviousByte( 0 );

    aOutput.Zero();

    for ( TInt i = 0; i < aString.Length(); i++ )

        {

        TUint8 leftPartOfCurrentChar =  ( aString[i] & maskRightPartOfCurrentByte )

            << shiftLeft;

        // append the character in the output text string

        aOutput.Append( leftPartOfCurrentChar | leftPartFromPreviousByte );

        // updates

        if ( KSiftedSixTimes == shiftLeft)

            {

            // After 6 shifts, the character is in bit7..bit1, therefore it has to

            // be shifted one bit to the right.

            TUint8 character = aString[i] >> 1;

            // Check if this is the end character of USSD string 0x0D

            TBool lastCharacter( ( i + 1 ) == aString.Length() );

            if ( !lastCharacter || KCarriageReturn != character )

                {

                // Continue unpacking

                aOutput.Append( character );

                // Restart

                leftPartFromPreviousByte = 0;

                shiftLeft=0;

                maskRightPartOfCurrentByte = 0x7F;

                }

            }

        else

            {

            leftPartFromPreviousByte = (aString[i]) >> (7-shiftLeft);

            maskRightPartOfCurrentByte = maskRightPartOfCurrentByte>>1;

            shiftLeft++;

            }

        }

    }

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

// TSatUtility::UCSToPacket7

// Converts UCS2 string to 7-bit packed format

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

//

void TSatUtility::UCSToPacket7

        (

        TPtrC aString,   //UCS2 string

        TDes8& aOutput   //7-bit packed format output string

        )

    {

    OstTrace0( TRACE_NORMAL, TSATUTILITY_UCSTOPACKET7, "TSatUtility::UCSToPacket7" );

    TFLOGSTRING("TSY: TSatUtility::UCSToPacket7");

    TBuf8<255> string;

    TSatUtility::ConvertUnicode16ToSms7( string, aString );

    TUint8 move( 0 );

    TInt i( 0 );

    for ( i = 0; i < string.Length(); i += 1 )

        {

        // get first character

        TUint8 char1 = TUint8( string[i] >> move );

        TUint8 char2;

        if ( ( i + 1 ) < string.Length() )

            {

            //  get next character

            char2 = TUint8( string[i + 1]  << ( 7 - move ) );

            }

        else

            {

            // no more characters

            char2 = 0;

            }

        // append packed character

        aOutput.Append( TUint8( char1 | char2 ) );

        if ( ( 6 == move ) && char2 )

            {

            i++;

            move = 0;

            }

        else

            {

            move++;

            }

        }

    if ( !( ( string.Length() + 1 ) % 8 ) )

        {

        // If the total number of characters in the text string equals (8n-1)

        // where n=1,2,3 etc. then there are 7 spare bits at the end of the

        // message. To avoid the situation where the receiving entity confuses

        // 7 binary zero pad bits as the @ character, the carriage return

        // (i.e. <CR>) character shall be used for padding in this situation,

        // as defined in TS 23.038.

        aOutput[  aOutput.Length() - 1 ] =

            TUint8( aOutput[  aOutput.Length() - 1 ] | KCrShiftedOneBitToLeft );

        }

    }

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

// TSatUtility::BCDToAscii

// Converts BCD string to ASCII format

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

//

void TSatUtility::BCDToAscii

        (

        TPtrC8 aString,  //BCD string

        TDes8& aOutput   //Ascii format output string

        )

    {

    OstTrace0( TRACE_NORMAL, TSATUTILITY_BCDTOASCII, "TSatUtility::BCDToAscii" );

    TFLOGSTRING("TSY: TSatUtility::BCDToAscii");

    // Convert Abbreviated dialling numbers format back to ASCII format.

    // See 3GPP TS 11.11, EFadn

    aOutput.Zero();

    TInt len( aString.Length() );

    TInt outputMaxLength( aOutput.MaxLength() );

    for ( TInt i=0; ( i < len ) && ( aOutput.Length()

            < outputMaxLength ); i++ )

        {

        // two bcd string chars are coded in one byte,

        // 1st char is in low nibble and 2nd is in high nibble

        // if the high nibble doesn't contain a char it's value is 0xf

        TUint8 byte = aString[i];

        aOutput.Append( KAscii[byte & 0xf] );

        if ( 0xf0 != ( byte & 0xf0 )

            && ( aOutput.Length() < outputMaxLength ) )

            {

            aOutput.Append( KAscii[byte >> 4] );

            }

        }

    if ( aOutput.Length() == outputMaxLength )

        {

        OstTrace0( TRACE_NORMAL, DUP1_TSATUTILITY_BCDTOASCII, "TSatUtility::BCDToAscii, probably dropped characters" );

        OstTraceExt2( TRACE_NORMAL, DUP2_TSATUTILITY_BCDTOASCII, "Input buffer length: %d, possible characters: %d", len, len * 2 );

        OstTraceExt2( TRACE_NORMAL, DUP3_TSATUTILITY_BCDTOASCII, "Converted characters: %d, dropped: %d", aOutput.Length(), ( len * 2 ) - aOutput.Length() );

        TFLOGSTRING("TSY: TSatUtility::BCDToAscii, \

            probably dropped characters");

        TFLOGSTRING3("TSY: Input buffer length: %d, possible characters: %d",

            len, len * 2 );

        TFLOGSTRING3("TSY: Converted characters: %d, dropped: %d",

            aOutput.Length(), ( len * 2 ) - aOutput.Length() );

        }

    }

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

// TSatUtility::RemoveExpansionDigit

// Expansion digit '.' from phone number string.

// Used in SetUpCall proactive command.

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

//

void TSatUtility::RemoveExpansionDigit

        (

        TDes8& aPhoneNumber // Number to be converted

        )

    {

    OstTrace0( TRACE_NORMAL, TSATUTILITY_REMOVEEXPANSIONDIGIT, "TSatUtility::RemoveExpansionDigit" );

    TFLOGSTRING("TSY: TSatUtility::RemoveExpansionDigit");

    TInt pos( 0 );

    // Search and delete until no more '.'-characters found

    while ( KErrNotFound != ( pos = aPhoneNumber.Locate( '.' ) ) )

        {

        aPhoneNumber.Delete( pos, 1 );

        }

   }

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

// TSatUtility::AsciiToBCD

// Convert ASCII string to binary coded decimal, invalid

// characters are dropped and will not be part of bcd string.

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

//

void TSatUtility::AsciiToBCD

        (

        const TDesC8& aString, //unicode string

        TDes8& aOutput         //binary code decimal output string

        )

    {

    OstTrace0( TRACE_NORMAL, TSATUTILITY_ASCIITOBCD, "TSatUtility::AsciiToBCD" );

    TFLOGSTRING("TSY: TSatUtility::AsciiToBCD");

    TInt i;

    TInt outLen( 0 );

    aOutput.Zero();

    for ( i = 0; i < aString.Length(); i++ )

        {

        // encode as BCD

        TUint8 bcd;

        switch ( aString[i] )

            // do ascii to bcd mapping

            // See 3GPP TS 11.11, EFadn

            {

            case '0': bcd = 0x0; break;

            case '1': bcd = 0x1; break;

            case '2': bcd = 0x2; break;

            case '3': bcd = 0x3; break;

            case '4': bcd = 0x4; break;

            case '5': bcd = 0x5; break;

            case '6': bcd = 0x6; break;

            case '7': bcd = 0x7; break;

            case '8': bcd = 0x8; break;

            case '9': bcd = 0x9; break;

            case '*': bcd = 0xa; break;

            case '#': bcd = 0xb; break;

            case 'p': bcd = 0xc; break; // DTMF

            case 'w': bcd = 0xd; break; // wild

            case '.': bcd = 0xe; break; // RFU

            default:  bcd = 0xf;        // should never be part of number

               TFLOGSTRING3("TSY: TSatUtility::AsciiToBCD -- dropped character %d at i=%d", TInt(aString[i]), i );

               OstTraceExt2( TRACE_NORMAL, DUP1_TSATUTILITY_ASCIITOBCD, "TSatUtility::AsciiToBCD -- dropped character %d at i=%d", TInt(aString[i]), i );

               break;

            }

        // add only valid bcd characters...

        if ( 0xf != bcd )

            {

            if( aOutput.MaxLength() >= aOutput.Length()+1 )

                {

                // store to string

                if ( 0 == ( outLen%2 ) )

                    {