#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmconnectionmethoddef.h>

#include <cmconnectionmethodext.h>

const TInt KDelayBeforeProtection = 1000000; // 1 Sec

const TInt KMaxProtectionRetries = 10; 

    {

    RDEBUG("CCommsDatEnforcement::~CCommsDatEnforcement()");

    iCentRepServer.Close();

    iDMUtil.Close();

    }

    {

    RDEBUG("CCommsDatEnforcement::ConstructL()");

    //no implementation needed

    }

CCommsDatEnforcement* CCommsDatEnforcement::NewL(const TDesC8& aEnforcementId)

    {

    RDEBUG("CCommsDatEnforcement::NewL()");

    if (aEnforcementId == PolicyLanguage::Constants::EAPEnforcementPolicy)

        {

        RDEBUG("	-> EAPEnforcementPolicy");

        self->iSettingType = EAPEnforcement;

        }

    else if (aEnforcementId

            == PolicyLanguage::Constants::EWLANEnforcementPolicy)

        {

        RDEBUG("    -> EWLANEnforcementPolicy");

        self->iSettingType = EWLANEnforcement;

        }

TBool CCommsDatEnforcement::ValidEnforcementElement(

        const TDesC8& aEnforcementId)

    {

    RDEBUG("CCommsDatEnforcement::ValidEnforcementElement()");

    if (aEnforcementId == PolicyLanguage::Constants::EAPEnforcementPolicy

            || aEnforcementId

                    == PolicyLanguage::Constants::EWLANEnforcementPolicy)

        {

        RDEBUG("   -> valid EnforcementPolicy");

        return ETrue;

        }

    return EFalse;

    }

void CCommsDatEnforcement::InitEnforcementL(TRequestStatus& aRequestStatus)

    {

    RDEBUG("CCommsDatEnforcement::InitEnforcementL()");

    RDEBUG_2("CCommsDatEnforcement@@iInitState %d )", iInitState );

    //set restore flag

    if (iAccessControlList->Count())

        {

        iRestore = EFalse;

        }

    else

        {

        iRestore = ETrue;

        iInitState++;

        }

    //in first phase open connections to centreptool

    if (iInitState == 0 || iRestore)

        {

        RDEBUG("	-> Opening connections ... ");

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

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

        RDEBUG("	-> Opening connections ... DONE!");

        }

    //init each session in own cycle....

    switch (iInitState)

        {

        case 0:

            {

            //Protect the destinations

            SetProtectionL(EProtLevel1);

            //compelete request

            TRequestStatus * status = &aRequestStatus;

            User::RequestComplete(status, KErrNone);

            }

            break;

        case 1:

            {

            RDEBUG("CCommsDatEnforcement:InitEnforcementL Case 1");

            TRequestStatus * status = &aRequestStatus;

            User::RequestComplete(status, KErrNone);

            }

            break;

        default:

            {

            RDEBUG("**** CCommsDatEnforcement PANIC, invalid switch-case!");

            User::Panic(KCommsDatEnformentPanic, KErrAbort);

            }

            break;

        }

    iInitState++;

    }

void CCommsDatEnforcement::DoEnforcementL(TRequestStatus& aRequestStatus)

    {

    RDEBUG("CCommsDatEnforcement::DoEnforcementL()");

    if (!iRestore)

        {

        CPolicyStorage::PolicyStorage()->ActivateEnforcementFlagL(

                iSettingType);

        //ACL...

        RDEBUG("	making ACL modifications for enforcement ... ");

        User::LeaveIfError(iDMUtil.SetMngSessionCertificate(

                SessionCertificate()));

        User::LeaveIfError(iDMUtil.AddACLForNode(KAPURI, EForChildrens,

                EACLDelete));

        User::LeaveIfError(iDMUtil.AddACLForNode(KAPURI, EForNode, EACLGet));

        User::LeaveIfError(iDMUtil.SetACLForNode(KAPURI, EForNode, EACLAdd));

        RDEBUG("	making ACL modifications for enforcement ... DONE!");

        }

    else

        {

        //Unprotect the destinations

        SetProtectionL(EProtLevel0);

        CPolicyStorage::PolicyStorage()->DeactivateEnforcementFlagL(

                iSettingType);

void CCommsDatEnforcement::FinishEnforcementL(TBool aFlushSettings)

    {

    RDEBUG("CCommsDatEnforcement::FinishEnforcementL()");

    //Close sessions

    if (aFlushSettings)

        {

        iDMUtil.Flush();

        }

    //Close centrep server...

    iCentRepServer.Close();

    iDMUtil.Close();

    }

void CCommsDatEnforcement::AccessRightList(

        RAccessControlList& aAccessControlList)

    {

    RDEBUG("CCommsDatEnforcement::AccessRightList()");

    iAccessControlList = &aAccessControlList;

    }

    {

    RDEBUG("CCommsDatEnforcement::ResetEnforcementL()");

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

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

    //ACL...

    User::LeaveIfError(iDMUtil.RemoveACL(KAPURI, ETrue));

    iCentRepServer.Close();

    iDMUtil.Close();

    }

// CCommsDatEnforcement::SetProtectionL()

// Sets Protection level to all the destinations

void CCommsDatEnforcement::SetProtectionL(TProtectionLevel aProtLevel)

    {

    RDEBUG("CCommsDatEnforcement::SetProtectionL() Start");

    RCmManagerExt cmm;

    cmm.OpenL();

    CleanupClosePushL(cmm);

    RArray<TUint32> destinations;

    cmm.AllDestinationsL(destinations);

    CleanupClosePushL(destinations);

    TInt destcount = destinations.Count();

    RCmDestinationExt destination;

    //Set the Protection level for all the destinations

    for (TInt i = 0; i < destcount; i++)

        TInt err = KErrNone;

        TInt retries = 1;

        // Retry, at the max, 10 times, if transaction fails due to KErrLocked

        // This is not an optimal solution for this problem, but, due to limitations

        // from CMManager, after a lot of Development and testing effort, below code

        // is found out to be a working one for most of the cases

        do

            {

            if (retries > 1)

                {

                User::After( KDelayBeforeProtection);

                }

            RDEBUG_2(

                    "CCommsDatEnforcement::SetProtectionL() DestinationL Retry No.  %d",

                    retries);

            TRAP(err, destination = cmm.DestinationL(destinations[i]));

            retries++;

            }

        while (err == KErrLocked && retries <= KMaxProtectionRetries);

        RDEBUG_2(

                "CCommsDatEnforcement::SetProtectionL() DestinationL error is  %d",

                err);

        if ((err != KErrNone && err != KErrLocked) || (err == KErrLocked

                && retries > KMaxProtectionRetries))

            User::Leave(err);

            }

        CleanupClosePushL(destination);

        RDEBUG("CCommsDatEnforcement::SetProtectionL() SetProtectionL Start");

        destination.SetProtectionL(aProtLevel);

        RDEBUG("CCommsDatEnforcement::SetProtectionL() SetProtectionL End");

        //Connection Methods are not getting unlocked, eventhough the destinations are unlocked

        // Unlocking the Connecting Methods in the destination

        if (aProtLevel == EProtLevel0)

            {

            SetCMProtectionL(destination, EProtLevel0);

        RDEBUG("CCommsDatEnforcement::SetProtectionL() UpdateL  Start");

        err = KErrNone;

        retries = 1;

        do

            {

            if (retries > 1)

                {

                User::After( KDelayBeforeProtection);

                }

            RDEBUG_2(

                    "CCommsDatEnforcement::SetProtectionL() UpdateL Retry No.  %d",

                    retries);

            TRAP(err, destination.UpdateL());

            retries++;

            }

        while (err == KErrLocked && retries <= KMaxProtectionRetries);

        RDEBUG_2(

                "CCommsDatEnforcement::SetProtectionL() UpdateL error is  %d",

                err);

        if ((err != KErrNone && err != KErrLocked) || (err == KErrLocked

                && retries > KMaxProtectionRetries))

            {

            User::Leave(err);

            }

        RDEBUG("CCommsDatEnforcement::SetProtectionL() UpdateL  End");

        CleanupStack::PopAndDestroy();

        }

    CleanupStack::PopAndDestroy(2);

    RDEBUG("CCommsDatEnforcement::SetProtectionL() End");

    }

// CCommsDatEnforcement::SetCMProtectionL()

// Sets Protection level to all the Connection Methods in the  destination

//

void CCommsDatEnforcement::SetCMProtectionL(RCmDestinationExt& aDestination,

        TProtectionLevel aProtLevel)

    {

    RDEBUG("CCommsDatEnforcement::SetCMProtectionL() Start");

    TInt APSNAPCount = aDestination.ConnectionMethodCount();

    RCmConnectionMethodExt connection;

    if (APSNAPCount)

        {

        for (TInt j = 0; j < APSNAPCount; j++)

            {

            connection = aDestination.ConnectionMethodL(j);

            CleanupClosePushL(connection);

            if (aProtLevel == EProtLevel0)

                {

                connection.SetBoolAttributeL(ECmProtected, EFalse);

                }

            else if (aProtLevel == EProtLevel1 || aProtLevel == EProtLevel3)

                {

                connection.SetBoolAttributeL(ECmProtected, ETrue);

                }

            CleanupStack::PopAndDestroy();

            }

        }

    RDEBUG("CCommsDatEnforcement::SetCMProtectionL() End");

    }