/*

* 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 "IptvDebug.h"

#include <sysutil.h>

#include <3des.h>               // For C3DES

#include <centralrepository.h>  // link against centralrepository.lib

#include <e32math.h>

#include <mmtsy_names.h>

#include "ciptvsecureprovisioningparameters.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TUid    KCRUidPnpUtil   = {0x1020433A};

const TInt KMaxKeyInfoLength  = 20;

const TInt KNonceLength       = 8;

const TUint32 KPnPUtilNonce   = 0x00000002;

const TUint32 KPnPUtilHomeMcc = 0x00000004;

const TUint32 KPnPUtilHomeMnc = 0x00000005;

const TUint32 KPnPUtilKeyInfo = 0x00000008;

_LIT8( K3DesKey, "111111111111111111111111" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CIptvSecureProvisioningParameters::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIptvSecureProvisioningParameters::ConstructL()

    {

    User::LeaveIfError( iServer.Connect() );

    User::LeaveIfError( iServer.LoadPhoneModule( KMmTsyModuleName ) );

    User::LeaveIfError( iPhone.Open( iServer, KMmTsyPhoneName ) );

    User::LeaveIfError( iPhone.Initialise() );

    iRepository = CRepository::NewL( KCRUidPnpUtil );

#ifndef __WINS__ // calling C3DESEncryptor::NewL crashes emulator

    iEncryptor = C3DESEncryptor::NewL( K3DesKey );

#endif 

    }

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

// CIptvSecureProvisioningParameters::NewL

// Two-phased constructor.

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

//

CIptvSecureProvisioningParameters* CIptvSecureProvisioningParameters::NewL()

    {

    CIptvSecureProvisioningParameters* self = new( ELeave ) CIptvSecureProvisioningParameters;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CIptvSecureProvisioningParameters::~CIptvSecureProvisioningParameters()

    {

    delete iRepository;

#ifndef __WINS__

    delete iEncryptor;

#endif

    iPhone.Close();

    iServer.Close();

    }

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

// CIptvSecureProvisioningParameters::SecureProvisioningUrlParametersL()

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

//

HBufC* CIptvSecureProvisioningParameters::SecureProvisioningUrlParametersL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvService::SecureProvisioningUrlParametersL() start");

    // home country code and home network id

    FetchHomeNetworkInfoL();

    RMobilePhone::TMobilePhoneNetworkCountryCode homeMcc = HomeMccL();

    RMobilePhone::TMobilePhoneNetworkIdentity homeMnc    = HomeMncL();

    const TInt HomeCountryCodeLength = 4;

    const TInt HomeNetworkCodeLength = 8;

    TBuf<HomeCountryCodeLength> hmcc16;

    TBuf<HomeNetworkCodeLength> hmnc16;

    hmcc16.Copy( homeMcc );

    hmnc16.Copy( homeMnc );

    // keyinfo, nonce

    TBuf8<KMaxKeyInfoLength> keyInfo;

    TBuf<KMaxKeyInfoLength> keyInfo16;

    GetKeyInfoL( keyInfo );

    keyInfo16.Copy( keyInfo );

    TBuf8<KNonceLength> nonce;

    TBuf<KNonceLength> nonce16;

    TInt timeout( 0 );

    CreateNewNonceL( timeout, nonce );

    nonce16.Copy( nonce );

    // product model

    TBuf8<KSysUtilVersionTextLength> deviceinfo;

    TBuf<KSysUtilVersionTextLength> deviceinfo16;

    FetchProductModelL( deviceinfo );

    deviceinfo16.Copy( deviceinfo );

    // 1. Keyinfo

    // 2. Nonce

    // 3. Home MCC

    // 4. Home MNC

    // 5. Network (current) MCC

    // 6. Network MNC

    // 7. Version

    // 8. deviceinfo

    _LIT( KVersionDes, "NPnP-MSS60-1.01" );

    const TInt KVersionDesLength = 16; 

    TBuf<KVersionDesLength> version16;

    version16    = KVersionDes;

    // These are for the test service, comments kept here until we get the real thing up.

    //version16    = _L("email-0.1");

    //deviceinfo16 = _L("n80");

    _LIT(KParameterFormatDes,

        "?sType=4&Key=%S&Nonce=%S&MCC=%S&MNC=%S&cVersion=%S&deviceinfo=%S&VCSW=1&action=activate");

    const TInt KParameterFormatDesLength = 150;

    HBufC* parameters = HBufC::NewL(

        KParameterFormatDesLength +

        keyInfo16.Length() +

        nonce16.Length() +

        hmcc16.Length() +

        hmnc16.Length() +

        KVersionDesLength +

        deviceinfo16.Length() );

    TPtr parametersPtr( parameters->Des() );

    parametersPtr.Format(

        KParameterFormatDes,

        &keyInfo16,

        &nonce16,

        &hmcc16,

        &hmnc16,

        &version16,

        &deviceinfo16);

    IPTVLOGSTRING2_HIGH_LEVEL( "%S", &parametersPtr );

    IPTVLOGSTRING_LOW_LEVEL("CIptvService::SecureProvisioningUrlParametersL() exit");

    return parameters;

    }

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

// CIptvSecureProvisioningParameters::FetchProductModelL()

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

//

void CIptvSecureProvisioningParameters::FetchProductModelL( TDes8& aModel )

    {

    HBufC* tmpVersion = HBufC::NewLC( KSysUtilVersionTextLength );

    TPtr ptr( tmpVersion->Des() );

    User::LeaveIfError( SysUtil::GetSWVersion( ptr ) );

    _LIT(KVerStrStart,"V ");

    _LIT(KVerStrEnd,"\n");

    TInt pos1 = tmpVersion->Find(KVerStrStart);

    TInt pos2 = tmpVersion->Find(KVerStrEnd);

    TInt verlen = ((TDesC)(KVerStrStart)).Length();

    // Example version string:

    // V 10.0.053

    // 21-09-07

    // RM-179

    // (c) Nokia N81 (92.03)

    // RM-179 is extracted from it

    if( pos1==KErrNotFound) // Version does not start with "V "

        {

        pos1=0;

        verlen=0;

        }

    if(    (pos1!=KErrNotFound) 

        && (pos2!=KErrNotFound) 

        && (pos2 > (pos1 + verlen) ) 

      )

        {

        TPtrC ptrSeek(ptr);

        pos1 = ptrSeek.Find(KVerStrEnd);

        if(pos1>=0)

            {

            ptrSeek.Set(ptrSeek.Mid(pos1+1)); //removes "V 10.0.053"

            pos1 = ptrSeek.Find(KVerStrEnd);

            if( pos1 >= 0 )

                {

                ptrSeek.Set(ptrSeek.Mid(pos1+1)); // removes "21-09-07"

                pos1 = ptrSeek.Find(KVerStrEnd);

                if( pos1 < 0 )

                    {

                    ptrSeek.Set(ptrSeek.Mid(1));

                    aModel.Copy(ptrSeek);

                    }

                else if( pos1 > 0 )

                    {

                    ptrSeek.Set(ptrSeek.Mid(1,pos1-1));

                    aModel.Copy(ptrSeek);

                    }

                }

            }

        }

    CleanupStack::PopAndDestroy();

    }

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

// CIptvSecureProvisioningParameters::FetchHomeNetworkInfoL

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

//

void CIptvSecureProvisioningParameters::FetchHomeNetworkInfoL()

    {

    // Get home (sim) MCC&MNC info

    RMobilePhone::TMobilePhoneNetworkInfoV1 info;

    RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infoPckg( info );

#ifndef __WINS__

    TRequestStatus status( KRequestPending );

    iPhone.GetHomeNetwork( status, infoPckg );

    User::WaitForRequest( status );

    User::LeaveIfError( status.Int() );

#else

    info.iCountryCode.Copy( _L("244") );

    info.iNetworkId.Copy( _L("05") );

#endif

    RMobilePhone::TMobilePhoneNetworkIdentity formattedMnc;

    FormatMncCodeL( info.iCountryCode, info.iNetworkId, formattedMnc );

    SetHomeMncL( formattedMnc );

    SetHomeMccL( info.iCountryCode );

    }

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

// CIptvSecureProvisioningParameters::FormatMncCodeL

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

//

void CIptvSecureProvisioningParameters::FormatMncCodeL(

    const RMobilePhone::TMobilePhoneNetworkCountryCode aMcc,

    const RMobilePhone::TMobilePhoneNetworkIdentity aUnformattedMnc,

    RMobilePhone::TMobilePhoneNetworkIdentity& aFormattedMnc )

    {

    RMobilePhone::TMobilePhoneNetworkIdentity formattedMnc;

    // Check that codes only contain valid characters

    TInt mncValue(0);

    TInt mccValue(0);

    TLex mncParser( aUnformattedMnc );

    TInt err = mncParser.Val( mncValue );

    if( err != KErrNone )

        {

        User::Leave( KErrCorrupt );

        }

    TLex mccParser( aMcc );

    err = mccParser.Val( mccValue );

    if( err != KErrNone )

        {

        User::Leave( KErrCorrupt );

        }

    // In N7610 the MNC given by RMobilePhone::GetHomeNetwork is

    // always three digits

    // But for example in N6630 the MNC seems to be correctly formatted

    // The initial value is the given MNC:

    formattedMnc.Copy( aUnformattedMnc );

    // Reformat only if needed

    if( aUnformattedMnc.Length() == 3 )

        {

        // Assume two digits, exceptions follow

        formattedMnc.Copy( aUnformattedMnc.Left(2) );

        if( aMcc.Compare( _L("302") ) == 0 ||

            aMcc.Compare( _L("346") ) == 0 ||

            aMcc.Compare( _L("348") ) == 0 ||

            aMcc.Compare( _L("356") ) == 0 ||

            aMcc.Compare( _L("365") ) == 0 ||

            aMcc.Compare( _L("376") ) == 0 ||

            aMcc.Compare( _L("467") ) == 0 ||

            aMcc.Compare( _L("732") ) == 0 )

            {

            // MNC should be three digits

            formattedMnc.Copy( aUnformattedMnc );

            }

        else if( aMcc.Compare( _L("310") ) == 0 )

            {

            // MNC is always three digits in this case

            // For example: 000, 011, 110, 020, 200, ...

            formattedMnc.Copy( aUnformattedMnc );

            }

        else if( aMcc.Compare( _L("311") ) == 0 )

            {

            // 3 digit (USA) some exceptions

            // See previous case for comments

            formattedMnc.Copy( aUnformattedMnc );

            }

        else if( aMcc.Compare( _L("338") ) == 0 )

            {

            // 2 digit, but 3 digit if 180 (JAM)

            if( aUnformattedMnc.Compare( _L("180") ) == 0 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        else if( aMcc.Compare( _L("342") ) == 0 )

            {

            // 2 digit, but 3 digit if larger than 510

            if( mncValue >= 510 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        else if( aMcc.Compare( _L("344") ) == 0 )

            {

            // 2 digit, but 3 digit if larger than 310

            if( mncValue >= 310 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        else if( aMcc.Compare( _L("352") ) == 0 )

            {

            // 2 digit, but 3 digit if smaller than 300

            if( mncValue < 300 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        else if( aMcc.Compare( _L("358") ) == 0 )

            {

            // 2 digit, but 3 digit if smaller than 300

            if( mncValue < 300 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        else if( aMcc.Compare( _L("360") ) == 0 )

            {

            // 2 digit, but 3 digit if 110

            if( aUnformattedMnc.Compare( _L("110") ) == 0 )

                {

                formattedMnc.Copy( aUnformattedMnc  );

                }

            }

        else if( aMcc.Compare( _L("362") ) == 0 )

            {

            // 2 digit, but 3 digit if larger than 920

            if( mncValue >= 920 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        else if( aMcc.Compare( _L("366") ) == 0 )

            {

            // 2 digit, but 3 digit if 110

            if( aUnformattedMnc.Compare( _L("110") ) == 0 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        else if( aMcc.Compare( _L("722") ) == 0 )

            {

            // 2 digit, but 3 digit if 310

            if( aUnformattedMnc.Compare( _L("310") ) == 0 )

                {

                formattedMnc.Copy( aUnformattedMnc );

                }

            }

        }

    aFormattedMnc.Copy( formattedMnc );

    }

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

// CIptvSecureProvisioningParameters::HomeMccL

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

//

const RMobilePhone::TMobilePhoneNetworkCountryCode CIptvSecureProvisioningParameters::HomeMccL()

    {

    RMobilePhone::TMobilePhoneNetworkIdentity mcc;

    User::LeaveIfError( iRepository->Get( KPnPUtilHomeMcc, mcc ) );

    return mcc;

    }

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

// CIptvSecureProvisioningParameters::SetHomeMncL

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

//

void CIptvSecureProvisioningParameters::SetHomeMncL( const RMobilePhone::TMobilePhoneNetworkIdentity aMnc )

    {

    User::LeaveIfError( iRepository->Set( KPnPUtilHomeMnc, aMnc ) );

    }

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

// CIptvSecureProvisioningParameters::HomeMncL

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

//

const RMobilePhone::TMobilePhoneNetworkIdentity CIptvSecureProvisioningParameters::HomeMncL()

    {

    RMobilePhone::TMobilePhoneNetworkIdentity mnc;

    User::LeaveIfError( iRepository->Get( KPnPUtilHomeMnc, mnc ) );

    return mnc;    

    }

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

// CIptvSecureProvisioningParameters::SetHomeMccL

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

//

void CIptvSecureProvisioningParameters::SetHomeMccL( const RMobilePhone::TMobilePhoneNetworkCountryCode aMcc )

    {

    User::LeaveIfError( iRepository->Set( KPnPUtilHomeMcc, aMcc ) );

    }

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

// CIptvSecureProvisioningParameters::GetKeyInfoL

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

//

void CIptvSecureProvisioningParameters::GetKeyInfoL( TDes8& aKeyInfo )

    {

    if( aKeyInfo.MaxLength() < KMaxKeyInfoLength )

        {

        User::Leave( KErrArgument );

        }

    // read keyinfo from cenrep

    TBuf<KMaxKeyInfoLength> buffer;

    User::LeaveIfError( iRepository->Get( KPnPUtilKeyInfo, buffer) );

    aKeyInfo.Copy( buffer );

    }

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

// CIptvSecureProvisioningParameters::CreateNewNonceL

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

//

void CIptvSecureProvisioningParameters::CreateNewNonceL( const TUint /*aTimeOut*/, TDes8& aNonce )

    {

    if( aNonce.MaxLength() < KNonceLength )

        {

        User::Leave( KErrArgument );

        }

    TBuf8<KNonceLength> buffer;

    TTime time;

    time.HomeTime();

    TInt64 seed = time.Int64();

    for( TInt i(0); i < KNonceLength; i++ )

        {

        TChar character( RandomCharacter( seed ) );

        buffer.Append( character );

        }

    aNonce.Copy( buffer );

    // Encrypt

#ifndef __WINS__

    iEncryptor->Transform( buffer );

#endif

    // Save the nonce

    User::LeaveIfError( iRepository->Set( KPnPUtilNonce, buffer ) );

    }

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

// CIptvSecureProvisioningParameters::RandomCharacter

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

//

TUint CIptvSecureProvisioningParameters::RandomCharacter( TInt64& aSeed )

    {

    // Create random number value for token

    TInt value = Math::Rand( aSeed );

    if( value < 0 )

        {

        value = -value;

        }