// 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 "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:

// Name          : CSIPSecSIMCredentialsProvider.cpp

// Part of       : SIPSec

// Version       : SIP/6.0

//

#include <commsdat.h>

#include <commsdattypesv1_1.h>

#include <mmretrieve.h>

#include <etelmmerr.h>

#include <cdblen.h>

#include "SipLogs.h"

#include "SipAssert.h"

#include "CSIPSecSIMCredentialsProvider.h"

#include "CSIPSecSIMRecord.h"

#include "CSIPSecDigestPlugin.h"

#include "sipsecdigestcontext.h"

// CONSTANTS

_LIT8( KSIPSecCK, "ck" );

_LIT8( KSIPSecIK, "ik" );

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

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

// CSIPSecIMSAuthentication::NewL

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

//

CSIPSecIMSAuthentication* CSIPSecIMSAuthentication::NewL(

         MSIPSecIMSAuthenticationDataObserver& aObserver )

    {

    return new ( ELeave ) CSIPSecIMSAuthentication( aObserver );    

    }

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

// CSIPSecIMSAuthentication::CSIPSecIMSAuthentication

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

//

CSIPSecIMSAuthentication::CSIPSecIMSAuthentication( 

            MSIPSecIMSAuthenticationDataObserver& aObserver ) :

    CActive( CActive::EPriorityStandard ),

    iObserver( aObserver ),

    iPhone( NULL ),    

    iMessage( iData )

    {

    CActiveScheduler::Add( this );

    }

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

// CSIPSecIMSAuthentication::~CSIPSecIMSAuthentication

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

//

CSIPSecIMSAuthentication::~CSIPSecIMSAuthentication()

    {

    Cancel();

    }

#ifndef USE_TEST_STUB

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

// CSIPSecIMSAuthentication::Request

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

//

void CSIPSecIMSAuthentication::Request( RMobilePhone& aPhone )

    {

    __SIP_LOG( "CSIPSecIMSAuthen:Request" )

	__ASSERT_ALWAYS( !IsActive(),

					 User::Panic( _L( "IMSAuthentic:Req" ), KErrInUse ) );

	iMessage.Copy( RMobilePhone::TImsAuthenticateDataV5Pckg( iData ) );

    __SIP_LOG( "CSIPSecIMSAuthen:Request Asking ISIM to Authenticate" )

	aPhone.ImsAuthenticate( iStatus, iMessage );

    SetActive();

    iPhone = &aPhone;	

    }

#endif // #ifndef USE_TEST_STUB

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

// CSIPSecIMSAuthentication::Response

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

//

RMobilePhone::TImsAuthenticateDataV5& CSIPSecIMSAuthentication::Response()

    {

    return iData;

    }

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

// CSIPSecIMSAuthentication::RunL

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

//

void CSIPSecIMSAuthentication::RunL()

    {

	__SIP_INT_LOG1( "SIPSecIMSAuthen:RunL status", iStatus.Int() )    

    if ( iStatus.Int() == KErrNone )

        {

        iObserver.AuthenticatedL();

        }

    else

        {

        iObserver.AuthenticationFailedL( iStatus.Int() );        

        }

   	iPhone = NULL;

    }

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

// CSIPSecIMSAuthentication::RunError

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

//

TInt CSIPSecIMSAuthentication::RunError( TInt aError )

    {

	return iObserver.PassErrorToFramework( aError, ETrue );

	}

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

// CSIPSecIMSAuthentication::DoCancel

// As there is a pending request, iPhone must be defined.

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

//

void CSIPSecIMSAuthentication::DoCancel()

    {

#if defined( USE_TEST_STUB )

    // If CSIPSecDigestTest::AKAAuthWWWChallengeFailuresTestL leaves before it

    // called iSIMStub->CallBack, this is needed to cancel the active object.

	TRequestStatus* status = &iStatus;

   	User::RequestComplete( status, KErrCancel );

#else

 	__SIP_LOG( "CSIPSecIMSAuthen:DoCancel" )

    __SIP_ASSERT_RETURN( iPhone, KErrNotFound );    

	iPhone->CancelAsyncRequest( EMobilePhoneIMSAuthenticate );	

#endif

    }

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

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

// CSIPSecIMSAuthorization::NewL

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

//

CSIPSecIMSAuthorization*

CSIPSecIMSAuthorization::NewL( MSIPSecIMSAuthenticationDataObserver& aObserver )

    {

    CSIPSecIMSAuthorization* self = 

        new ( ELeave ) CSIPSecIMSAuthorization( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

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

// CSIPSecIMSAuthorization::CSIPSecIMSAuthorization

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

//

CSIPSecIMSAuthorization::CSIPSecIMSAuthorization( 

        MSIPSecIMSAuthenticationDataObserver& aObserver ) :

    CActive( CActive::EPriorityStandard ),

    iObserver( aObserver )

    {

    }

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

// CSIPSecIMSAuthorization::~CSIPSecIMSAuthorization

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

//

CSIPSecIMSAuthorization::~CSIPSecIMSAuthorization()

    {

    Cancel();

    delete iRetriever;

    delete iData;

    }

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

// CSIPSecIMSAuthorization::ConstructL

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

//

void CSIPSecIMSAuthorization::ConstructL()

    {    

    iData = RMobilePhone::CImsAuthorizationInfoV5::NewL();

    CActiveScheduler::Add( this );    

    }

#ifndef USE_TEST_STUB

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

// CSIPSecIMSAuthorization::RequestL

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

//

void CSIPSecIMSAuthorization::RequestL( RMobilePhone& aPhone )

    {

    delete iRetriever;

    iRetriever = NULL;

    iRetriever = CAsyncRetrieveAuthorizationInfo::NewL( aPhone, *iData );

    iRetriever->Start( iStatus );

    SetActive();

    }

#endif // #ifndef USE_TEST_STUB

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

// CSIPSecIMSAuthorization::Response

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

//

RMobilePhone::CImsAuthorizationInfoV5& CSIPSecIMSAuthorization::Response()

    {

    return *iData;

    }   

#ifndef USE_TEST_STUB

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

// CSIPSecIMSAuthorization::RunL

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

//

void CSIPSecIMSAuthorization::RunL()

    {

	if ( iStatus.Int() == KErrNone &&

		 iRetriever &&

		 iRetriever->AuthInfoValid() )

        {

        iObserver.Authorized();

        }

    else

        {

        iObserver.AuthorizationFailedL();

        }

    }

#endif // #ifndef USE_TEST_STUB

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

// CSIPSecIMSAuthorization::RunError

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

//

TInt CSIPSecIMSAuthorization::RunError( TInt aError )	

    {

	return iObserver.PassErrorToFramework( aError, EFalse );	

	}

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

// CSIPSecIMSAuthorization::DoCancel

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

//

void CSIPSecIMSAuthorization::DoCancel()

    {

#if defined( USE_TEST_STUB )

    // If using test stub, must cancel own request as iRetriever is always NULL

	TRequestStatus* status = &iStatus;

   	User::RequestComplete( status, KErrCancel );

#endif

    __SIP_LOG( "CSIPSecIMSAuthor:DoCancel" )

	if ( iRetriever )

		{

		iRetriever->Cancel();

		}

    delete iRetriever;

    iRetriever = NULL;

    }

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

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

// CSIPSecSIMCredentialsProvider::NewL

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

//

CSIPSecSIMCredentialsProvider*

CSIPSecSIMCredentialsProvider::NewL( CSIPSecSIMRecord& aRecord )

    {

    CSIPSecSIMCredentialsProvider* self =

		new ( ELeave ) CSIPSecSIMCredentialsProvider( aRecord );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSIPSecSIMCredentialsProvider::CSIPSecSIMCredentialsProvider

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

//

CSIPSecSIMCredentialsProvider::CSIPSecSIMCredentialsProvider(

	CSIPSecSIMRecord& aRecord ) :

	CSIPSecCredentialsProvider( aRecord )

	{

	}

#ifndef USE_TEST_STUB

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

// CSIPSecSIMCredentialsProvider::ConstructL

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

//

void CSIPSecSIMCredentialsProvider::ConstructL()

    {

	TBuf<KCommsDbSvrMaxFieldLength> tsyModuleName;

	GetTsyModuleNameL( tsyModuleName );

	PreparePhoneL( tsyModuleName );

    iAuthentication = CSIPSecIMSAuthentication::NewL( *this );

    iAuthorization = CSIPSecIMSAuthorization::NewL( *this );

    }

#endif // #ifndef USE_TEST_STUB

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

// CSIPSecSIMCredentialsProvider::~CSIPSecSIMCredentialsProvider

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

//

CSIPSecSIMCredentialsProvider::~CSIPSecSIMCredentialsProvider()

    {

    __SIP_LOG( "~SIPSecSIMCredProv" )

    delete iAuthentication;

    delete iAuthorization;

    delete iOutboundProxy;

    iPhone.Close();

    iEtelServer.Close();

	__SIP_LOG( "~SIPSecSIMCredProv ends" )

    }

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

// CSIPSecSIMCredentialsProvider::GetTsyModuleNameL

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

//

void

CSIPSecSIMCredentialsProvider::GetTsyModuleNameL( TDes& aTsyModuleName ) const

    {

    __ASSERT_ALWAYS( aTsyModuleName.MaxSize() >= KCommsDbSvrMaxFieldLength,

		User::Leave( KErrArgument ) );

    using namespace CommsDat;

    CMDBSession* db = CMDBSession::NewLC( KCDVersion1_1 ); 

    CMDBField<TUint32>* globalSettingField =

    	new ( ELeave ) CMDBField<TUint32>( KCDTIdModemPhoneServicesSMS );

    CleanupStack::PushL( globalSettingField );

    globalSettingField->SetRecordId( 1 );

    globalSettingField->LoadL( *db );

    TUint32 modemId = *globalSettingField; 

    CMDBField<TDesC>* tsyField =

    	new ( ELeave ) CMDBField<TDesC>( KCDTIdTsyName );

    CleanupStack::PushL( tsyField );

    tsyField->SetRecordId( modemId ); 

    tsyField->LoadL( *db );

    aTsyModuleName = *tsyField;

    CleanupStack::PopAndDestroy( tsyField );

    CleanupStack::PopAndDestroy( globalSettingField );

    CleanupStack::PopAndDestroy( db );

    }

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

// CSIPSecSIMCredentialsProvider::PreparePhoneL

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

//

void CSIPSecSIMCredentialsProvider::PreparePhoneL( const TDes& aTsyModuleName )

	{

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

    User::LeaveIfError( iEtelServer.LoadPhoneModule( aTsyModuleName ) );

    // Get number of phones supported by all currently loaded TSY modules

    TInt phoneCount( 0 );

    User::LeaveIfError( iEtelServer.EnumeratePhones( phoneCount ) );

    RTelServer::TPhoneInfo phoneInfo;

	TName searchTsyName;

	TInt phoneIndex( KErrNotFound );

    while ( phoneIndex == KErrNotFound && phoneCount-- > 0 )

        {

        // Check if this phone belongs to the loaded TSY

        if ( ( iEtelServer.GetTsyName( phoneCount, searchTsyName ) == KErrNone )

             &&

             ( searchTsyName.CompareF( aTsyModuleName ) == 0 ) )

        	{

        	phoneIndex = phoneCount;        	

        	}

        }

	if ( phoneIndex == KErrNotFound )

		{

		User::Leave( KErrNotFound );

		}

    User::LeaveIfError( iEtelServer.GetPhoneInfo( phoneIndex, phoneInfo ) );

    User::LeaveIfError( iPhone.Open( iEtelServer, phoneInfo.iName ) );	

    RPhone::TStatus phoneStatus;

    User::LeaveIfError( iPhone.GetStatus( phoneStatus ) );

    // Check if the phone is already initialised

    if ( phoneStatus.iMode == RPhone::EModeUnknown )

        {

        TInt err = iPhone.Initialise();

        if ( err != KErrNone )

            {

            iPhone.Close();

            User::Leave( err );

            }

        }

    }

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

// CSIPSecSIMCredentialsProvider::RequestL

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

//

void CSIPSecSIMCredentialsProvider::RequestL( TSIPSecDigestCtxSetup& aContext )

    {

    iPlugin = &aContext.Parent().Plugin();

    delete iOutboundProxy;

    iOutboundProxy = NULL;

    iOutboundProxy = aContext.Parent().OutboundProxy().AllocL();

    static_cast<CSIPSecSIMRecord&>( UserRecord() ).SetAuthenticationDataL(

    	aContext.Nonce() );

    if ( UserRecord().UserName().Length() == 0 )

        {

        RequestUserNameL();

        }

    else

        {

        RequestPassword();

        }

    }

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

// CSIPSecSIMCredentialsProvider::RequestUserNameL

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

//

void CSIPSecSIMCredentialsProvider::RequestUserNameL()

    {

    RMobilePhone::CImsAuthorizationInfoV5& data = iAuthorization->Response();

    data.iIMPI.Zero();

    data.iIMPUArray.Reset();

    data.iHomeNetworkDomainName.Zero();

    iAuthorization->RequestL( iPhone );

    }

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

// CSIPSecSIMCredentialsProvider::RequestPassword

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

//

void CSIPSecSIMCredentialsProvider::RequestPassword()

    {

    CSIPSecSIMRecord& record = static_cast<CSIPSecSIMRecord&>( UserRecord() );

    RMobilePhone::TImsAuthenticateDataV5& data = iAuthentication->Response();

    data.iRAND.Zero();

    data.iAUTN.Zero();

    data.iRES.Zero();

	data.iIK.Zero();

    data.iCK.Zero();

    data.iAUTS.Zero();

    data.iRAND.Copy( record.RAND() );

	data.iAUTN.Copy( record.AUTN() );

	__SIP_INT_LOG2( "SIPSecSIMCredProv:RequestPassword, RAND len, AUTN len",

	                record.RAND().Length(), record.AUTN().Length() )

	HexDumpToLog( _L8( "RAND=" ), record.RAND() );	

	HexDumpToLog( _L8( "AUTN=" ), record.AUTN() );

    iAuthentication->Request( iPhone );

    }

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

// CSIPSecSIMCredentialsProvider::Cancel

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

//

void CSIPSecSIMCredentialsProvider::Cancel()

    {

    iAuthentication->Cancel();

    iAuthorization->Cancel();

    }

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

// CSIPSecSIMCredentialsProvider::AuthenticatedL

// For AKA, use the challenge's realm, not the SIM's realm. AUTS does not exist.

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

//

void CSIPSecSIMCredentialsProvider::AuthenticatedL()

    {

    __SIP_LOG( "SIPSecSIMCredProv:AuthenticatedL" )

    __SIP_ASSERT_LEAVE( iPlugin && iOutboundProxy, KErrNotFound );

    RMobilePhone::CImsAuthorizationInfoV5& authorization =

    	iAuthorization->Response();

    RMobilePhone::TImsAuthenticateDataV5& authentication =

		iAuthentication->Response();

	__SIP_INT_LOG2( "Lengths: IK, CK",

	                authentication.iIK.Length(),

			        authentication.iCK.Length() )

	__SIP_INT_LOG2( "Lengths: IMPI, RES",       

			        authorization.iIMPI.Length(),

			        authentication.iRES.Length() )

	__SIP_INT_LOG1( "Lengths: AUTS", authentication.iAUTS.Length() )

	HexDumpToLog( _L8( "IK=" ), authentication.iIK );

	HexDumpToLog( _L8( "CK=" ), authentication.iCK );

	HexDumpToLog( _L8( "RES=" ), authentication.iRES );