// 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        : sipapnconfigurationhandler.cpp

// Part of     : SIP Profile Server

// implementation

// Version     : 1.0

//

#include <commsdattypesv1_1.h>

#include <commdb.h>

#include <commsdat.h>

#include "sipapnconfigurationhandler.h"

#include "SipProfileLog.h"

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

// CSIPApnConfigurationHandler::NewL

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

//

CSIPApnConfigurationHandler* CSIPApnConfigurationHandler::NewL( 

    MSIPApnChangeObserver& aObserver, TUint32 aIapId)

	{

	CSIPApnConfigurationHandler* self = 

	    CSIPApnConfigurationHandler::NewLC( aObserver, aIapId );

	CleanupStack::Pop( self );

	return self;

	}

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

// CSIPApnConfigurationHandler::NewLC

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

//

CSIPApnConfigurationHandler* CSIPApnConfigurationHandler::NewLC( 

    MSIPApnChangeObserver& aObserver, TUint32 aIapId)

	{

	CSIPApnConfigurationHandler* self = 

	    new ( ELeave ) CSIPApnConfigurationHandler( aObserver, aIapId );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

// CSIPApnConfigurationHandler::~CSIPApnConfigurationHandler

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

//

CSIPApnConfigurationHandler::~CSIPApnConfigurationHandler()

	{

	PROFILE_DEBUG1( 

	        "CSIPApnConfigurationHandler::~CSIPApnConfigurationHandler()" )

	Cancel();

	iConnection.Close();

	iSocketSrv.Close();

	delete iApnProposal;

	delete iCurrentApn;

    delete iPrimaryApn;

    delete iSecondaryApn;

	delete iCommsDatabase;

	PROFILE_DEBUG1( 

	        "CSIPApnConfigurationHandler::~CSIPApnConfigurationHandler() exit" )

	}

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

// CSIPApnConfigurationHandler::SetApnL

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

//

void CSIPApnConfigurationHandler::SetApnL( 

    const TDesC8& aApn, 

    TBool aUseSecureAuthentication,

    TBool aAllowAsync )

    {

    PROFILE_DEBUG6( 

            "CSIPApnConfigurationHandler::SetApnL() apn", aApn )

    // Cancel if waiting for connection closure, will be re-issued if needed

      Cancel();

    // Store current apn setting

    HBufC8* apn = aApn.AllocL();

    delete iApnProposal;

    iApnProposal = apn;

    iApnUseSecureAuthProposal = aUseSecureAuthentication;

    if ( !ApnChangeNeededL( *iApnProposal ) )

        {

        PROFILE_DEBUG1( 

                "CSIPApnConfigurationHandler::SetApnL() apn already correct" )

        SendApnChangedNotificationL( *iApnProposal );

        return;

        }

    iMonitoringRetryCount = 0;

    ChangeApnIfNotInUseL( aAllowAsync );

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::SetApnL() exit" )

    }

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

// CSIPApnConfigurationHandler::IsPrimaryApnUsed

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

//

TBool CSIPApnConfigurationHandler::IsPrimaryApnUsed()

    {

    return ( iCurrentApn && iCurrentApn->Compare( PrimaryApn() ) == 0 );

    }

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

// CSIPApnConfigurationHandler::ReadCurrentApnL

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

//

HBufC8* CSIPApnConfigurationHandler::ReadCurrentApnL()

	{

	HBufC8* apn(NULL);

	using namespace CommsDat;

	CMDBSession* db = CMDBSession::NewL( CMDBSession::LatestVersion() );

    CleanupStack::PushL( db );

    // Set any attributes if any

    db->SetAttributeMask( ECDHidden ); 

    // Create an iap record

    CCDIAPRecord* iapRecord = 

        static_cast<CCDIAPRecord*>( 

            CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

    CleanupStack::PushL( iapRecord );

    iapRecord->SetRecordId( iIapId );

    iapRecord->LoadL( *db );

    // serviceType identifies the servicing table to use

    CMDBField<TDesC>* serviceType = 

        ( CMDBField<TDesC>* )iapRecord->GetFieldByIdL( KCDTIdIAPServiceType );

    __ASSERT_ALWAYS( serviceType && !serviceType->IsNull(), 

                     User::Leave( KErrNotFound ) );

	// Only this service type has APN in the service record

    if ( TPtrC( KCDTypeNameOutgoingWCDMA ).Compare( *serviceType ) == 0 )

        {

        PROFILE_DEBUG1(  

        "CSIPApnConfigurationHandler::ReadCurrentApnL(), wcdma service" )

        // iapRecord->iService field is a link to the servicing table. It tells

        // which record to use from the table.

        iapRecord->iService.LoadL( *db );

        if ( !iapRecord->iService.iLinkedRecord )

            {

            PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::ReadCurrentApnL(), creating linked" )

            // Ownership of created record is transferred

            iapRecord->iService.iLinkedRecord = 

                static_cast<CCDOutgoingGprsRecord*>(

                    CCDRecordBase::RecordFactoryL( KCDTIdOutgoingGprsRecord ) );

            iapRecord->iService.iLinkedRecord->SetRecordId( iapRecord->iService );

            iapRecord->iService.iLinkedRecord->LoadL( *db );

            }

        PROFILE_DEBUG1( 

        "CSIPApnConfigurationHandler::ReadCurrentApnL(), linked service loaded" )

        CCDOutgoingGprsRecord* serviceRecord = 

        static_cast<CCDOutgoingGprsRecord*>( iapRecord->iService.iLinkedRecord ); 

        TDesC& currApn = serviceRecord->iGPRSAPN.GetL();

        PROFILE_DEBUG6( 

        	"CSIPApnConfigurationHandler::ReadCurrentApnL(), current apn",

        	currApn );

		apn = HBufC8::NewL( currApn.Length() );

		apn->Des().Copy( currApn );

		delete iCurrentApn;

		iCurrentApn = NULL;

		iCurrentApn = apn->AllocL();

        }

    db->ClearAttributeMask( ECDHidden );

    CleanupStack::PopAndDestroy( iapRecord );

    CleanupStack::PopAndDestroy( db );

    return apn;

	}

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

// CSIPApnConfigurationHandler::HasPendingTasks

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

//

TBool CSIPApnConfigurationHandler::HasPendingTasks() const

    {

    return MonitoringState() != EMonitoringIdle;

    }

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

// CSIPApnConfigurationHandler::DoCancel

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

//

void CSIPApnConfigurationHandler::DoCancel()

	{	

	TSipApnMonitoringState currentState = MonitoringState();

	PROFILE_DEBUG3( 

	        "CSIPApnConfigurationHandler::DoCancel() state", currentState );

	if ( currentState == EMonitoringConnection )

	    {

	    iConnection.CancelProgressNotification();

	    }

	else if ( currentState == EMonitoringDatabase )

	    {

	    if ( iCommsDatabase )

	        {

	        iCommsDatabase->CancelRequestNotification();

	        }

	    }

	else

	    {

	    // NOP

	    }

	SetMonitoringState( EMonitoringIdle );

	PROFILE_DEBUG1( 

	        "CSIPApnConfigurationHandler::DoCancel() exit" )

	}

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

// CSIPApnConfigurationHandler::RunL

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

//

void CSIPApnConfigurationHandler::RunL()

	{	

	TInt error = iStatus.Int();

	TSipApnMonitoringState currentState = MonitoringState();

	PROFILE_DEBUG3( 

	        "CSIPApnConfigurationHandler::RunL() err", error );

	PROFILE_DEBUG3( 

	        "CSIPApnConfigurationHandler::RunL() state", currentState );

	SetMonitoringState( EMonitoringIdle ); // Clear current state

	if ( currentState == EMonitoringConnection )

	    {

	    ConnectionMonitoringCompletedL( error );

	    }

	else if ( currentState == EMonitoringDatabase )

	    {

	    DatabaseMonitoringCompletedL( error );

	    }

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::RunL() exit" )

	}

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

// CSIPApnConfigurationHandler::RunError

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

//

TInt CSIPApnConfigurationHandler::RunError( TInt aError )

    {

    PROFILE_DEBUG3( 

            "CSIPApnConfigurationHandler::RunError() err", aError );

    if ( aError != KErrNoMemory && aError != KErrNone )

        {

        iObserver.ApnChanged( *iApnProposal, iIapId, aError );

        aError = KErrNone;

        }

    return aError;

    }

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

// CSIPApnConfigurationHandler::CSIPApnConfigurationHandler

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

//

CSIPApnConfigurationHandler::CSIPApnConfigurationHandler( 

    MSIPApnChangeObserver& aObserver, TUint32 aIapId ) : 

    CActive( CActive::EPriorityStandard ),

    iObserver( aObserver ),

    iMonitoringState( EMonitoringIdle )

	{

	CActiveScheduler::Add( this );

	iIapId = aIapId;

	}

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

// CSIPApnConfigurationHandler::ConstructL

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

//

void CSIPApnConfigurationHandler::ConstructL()

	{	

	PROFILE_DEBUG1( 

	        "CSIPApnConfigurationHandler::ConstructL()" )

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

	PROFILE_DEBUG1( 

	        "CSIPApnConfigurationHandler::ConstructL() exit" )

	}

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

// CSIPApnConfigurationHandler::IsInUseL

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

//

TBool CSIPApnConfigurationHandler::IsInUseL( TConnectionInfo& aConnectionInfo )

    {

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::IsInUseL()" )

    TBool inUse( EFalse );

    RConnection rcon;

    User::LeaveIfError( rcon.Open( iSocketSrv ) );

    CleanupClosePushL( rcon );

    TUint activeCount( 0 );

    User::LeaveIfError( rcon.EnumerateConnections( activeCount ) );

    if ( activeCount > 0  )

        {

        // Indexing is unordinary

        for( TUint i = 1; i <= activeCount && !inUse; i++ )

            {

            TPckgBuf<TConnectionInfoV2> connectionInfo;

            User::LeaveIfError( rcon.GetConnectionInfo( i, connectionInfo ) );

            if ( connectionInfo().iIapId == iIapId )

                {

                inUse = ETrue;

                aConnectionInfo = connectionInfo();

                }

            }

        }

    CleanupStack::PopAndDestroy( &rcon );

    PROFILE_DEBUG3( 

            "CSIPApnConfigurationHandler::IsInUseL() inuse", inUse )

    return inUse;

    }

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

// CSIPApnConfigurationHandler::StartMonitoringConnectionL

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

//

void CSIPApnConfigurationHandler::StartMonitoringConnectionL( 

    TConnectionInfo& aConnectionInfo )

    {

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::StartMonitoringConnectionL()" )

    __ASSERT_ALWAYS( !IsActive(), User::Leave( KErrInUse ) );

    if ( iConnection.SubSessionHandle() )

        {

        PROFILE_DEBUG1( 

        "CSIPApnConfigurationHandler::   close existing connection" )

        iConnection.Close();

        }

    iConnectionInfo = aConnectionInfo;   

    User::LeaveIfError( iConnection.Open( iSocketSrv ) );    

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::   attaching" )

    User::LeaveIfError( 

        iConnection.Attach( iConnectionInfo, RConnection::EAttachTypeMonitor ) );

    WatchConnectionStatusChange();

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::StartMonitoringConnectionL() exit" )

    }

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

// CSIPApnConfigurationHandler::WatchConnectionStatusChange

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

//	

void CSIPApnConfigurationHandler::WatchConnectionStatusChange()

    {

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::WatchConnectionStatusChange()" )

    Cancel();

    iConnection.ProgressNotification( iProgress, iStatus, KConnectionClosed );

    SetActive();

    SetMonitoringState( EMonitoringConnection );

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::WatchConnectionStatusChange(), exit" )

    }

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

// CSIPApnConfigurationHandler::WatchDatabaseStatusChangeL

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

//	

void CSIPApnConfigurationHandler::WatchDatabaseStatusChangeL( TUint32 aIapId )

    {

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::WatchDatabaseStatusChangeL()" )

    Cancel();

    if ( !iCommsDatabase )

        {

        PROFILE_DEBUG1( 

                "CSIPApnConfigurationHandler::   create commsdb" )

        iCommsDatabase = CCommsDatabase::NewL();

        }

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::   request notification" )

    // Start monitoring for db events, there will be lots of them pouring in

    // as there's no filtering feature. We are interested only in

    // unlocked events.    

    User::LeaveIfError( iCommsDatabase->RequestNotification( iStatus ) );

    SetActive();

    iIapId = aIapId;

    SetMonitoringState( EMonitoringDatabase );

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::WatchDatabaseStatusChangeL(), exit" )

    }

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

// CSIPApnConfigurationHandler::ApnChangeNeededL

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

//

TBool CSIPApnConfigurationHandler::ApnChangeNeededL( const TDesC8& aApn )

    {

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::ApnChangeNeededL()" )

 	TBool apnChangeNeeded( EFalse );

 	HBufC8* currentApn = ReadCurrentApnL();

	if ( currentApn && currentApn->Compare( aApn ) != 0 )

        {

        // Apn is not the same as wanted

        apnChangeNeeded = ETrue;

        }

	delete currentApn;

	PROFILE_DEBUG3( 

	        "CSIPApnConfigurationHandler::ApnChangeNeededL(), apnChangeNeeded",

	        apnChangeNeeded )

    return apnChangeNeeded;

    }

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

// CSIPApnConfigurationHandler::ChangeApnIfNotInUseL

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

//

TBool CSIPApnConfigurationHandler::ChangeApnIfNotInUseL( TBool aAllowAsync )

    {

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::ChangeApnIfNotInUseL()" )

    TBool apnChanged( EFalse );

    TConnectionInfo connectionInfo;

    if ( IsInUseL( connectionInfo ) )

        {

        // If iap is in use, apn cannot be changed until everyone has stopped

        // using it

        __ASSERT_ALWAYS( aAllowAsync, User::Leave( KErrInUse ) );

        StartMonitoringConnectionL( connectionInfo );

        }

    else

        {

        apnChanged = IssueApnChangeL(

                iIapId, *iApnProposal, iApnUseSecureAuthProposal, aAllowAsync );

        }

    PROFILE_DEBUG3( 

            "CSIPApnConfigurationHandler::ChangeApnIfNotInUseL(), apnChanged",

            apnChanged )

    return apnChanged;

    }

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

// CSIPApnConfigurationHandler::IssueApnChangeL

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

//

TBool CSIPApnConfigurationHandler::IssueApnChangeL( 

    TUint32 aIapId, 

    const TDesC8& aApn,

    TBool aUseSecureAuthentication,

    TBool aAllowAsync )

    {

    PROFILE_DEBUG1( 

            "CSIPApnConfigurationHandler::IssueApnChangeL()" )