/*

* 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:   Policy store

*

*/

#include <e32math.h>

#include <cmconnectionmethod.h>

#include <cmpluginvpndef.h> // vpn plugin

#include "policystore.h"

#include "pinparser.h"

#include "ikepolparser.h"

#include "pkiserviceapi.h"

#include "policyimporter.h"

#include "uuid.h"

#include "log_r6.h"

CPolicyStore* CPolicyStore::NewL(RFs& aFs)

    {

    CPolicyStore* self = new (ELeave) CPolicyStore(aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

    }

CPolicyStore::CPolicyStore(RFs& aFs) : iFs(aFs), iFileUtil(aFs)

    {

    }

inline void CPolicyStore::ConstructL()

    {

    LOG_("CPolicyStore::ConstructL");    

    ConstructPolicyListL();

    LOG_("CPolicyStore::ConstructL:end");    

    }

CPolicyStore::~CPolicyStore()

    {

    delete iPolicyListAll;

    delete iPolicyListVisible;

    }

void CPolicyStore::ConstructPolicyListL()

    {

    // Using two policy lists (one for all and one for the visible

    // ones) makes it easy to support the concept of hidden and

    // visible policies. There's a slight memory penalty but this

    // is not serious as the number of policies is typically small).

    // Hidden policies differ from visible ones in only one aspect - 

    // they are not included in the policy listing returned to

    // the caller.

    // A list of all policies (both visible and hidden)

    iPolicyListAll = new (ELeave) CArrayFixFlat<TVpnPolicyInfo>(2);

    // A list of visible policies only

    iPolicyListVisible = new (ELeave) CArrayFixFlat<TVpnPolicyInfo>(2);

    TFindFile fileFinder(iFs);

    CDir* fileList; 

    TPath privateDir;

    User::LeaveIfError(iFs.PrivatePath(privateDir));

    TInt ret = fileFinder.FindWildByDir(KPolFilePat, privateDir, fileList);

    if (ret == KErrNone)

        {

        CleanupStack::PushL(fileList);

        for (TInt i = 0; i < fileList->Count(); i++)

            {

            TParse fileNameParser;

            fileNameParser.Set((*fileList)[i].iName, &fileFinder.File(), NULL);

            TVpnPolicyId policyId;

            // Only add the policy to the list its ID length is

            // acceptable (this is the case with all policies

            // that have been properly imported to the store)

            if (fileNameParser.Name().Length() <= policyId.MaxLength())

                {

                policyId.Copy(fileNameParser.Name());

                HBufC* pinFile = iFileUtil.GetPinFileNameLC(policyId);

                if (iFileUtil.FileExists(*pinFile))

                    {

                    AddPolicyL(policyId);

                    }

                CleanupStack::PopAndDestroy(pinFile);

                }

            }

        CleanupStack::PopAndDestroy(); // fileList

        }

    }

TUint8* CPolicyStore::RawPolicyData()

    {

    // The list of policies returned to the caller contains ONLY

    // visible policies. 

    return reinterpret_cast<TUint8*>(&(iPolicyListVisible->At(0)));

    }

void CPolicyStore::ImportPolicyL(

    const TFileName& aPinFile, const TFileName& aPolFile,

    TVpnPolicyId* aNewPolicyId)

    {

    LOG_("-> CPolicyStore::ImportPolicyL()");            

    TVpnPolicyId policyId = NewPolicyIdL();

    // Write the new policy ID to the caller

    if (aNewPolicyId)

        {

        aNewPolicyId->Copy(policyId);

        }

    // Create new PIN and POL file names

    // (Dynamic allocation to conserve stack space)

    HBufC* pinFileP = iFileUtil.GetPinFileNameLC(policyId);

    HBufC* polFileP = iFileUtil.GetPolFileNameLC(policyId);

    // Move the files from the install directory

    // to the target directory (the policy store)

    iFileUtil.CopyFileL(aPinFile, *pinFileP);

    iFileUtil.CopyFileL(aPolFile, *polFileP);

    CleanupStack::PopAndDestroy(polFileP);

    // Make sure that the name of the new policy

    // does not collide with an existing name

    EnsureUniquePolicyNameL(*pinFileP);

    CleanupStack::PopAndDestroy(pinFileP);

    // Add the imported policy to the policy list

    AddPolicyL(policyId);

    LOG(Log::Printf(_L("<- CPolicyStore::ImportPolicyL()")));            

    }

TInt CPolicyStore::DeletePolicyL(const TVpnPolicyId& aPolicyId)

    {

    LOG(Log::Printf(_L("-> CPolicyStore::DeletePolicyL()")));            

    // Delete the policy from the list of all policies

    TInt itemToDelete = PolicyIndex(aPolicyId);

    if (itemToDelete != KUnfoundIndex)

        {

        iPolicyListAll->Delete(itemToDelete);

        iPolicyListAll->Compress();

        }

    // Delete the policy also from the list of

    // visible policies if it happens to be there

    TInt itemToDeleteVisible = PolicyIndexVisible(aPolicyId);

    if (itemToDeleteVisible != KUnfoundIndex)

        {

        iPolicyListVisible->Delete(itemToDeleteVisible);

        iPolicyListVisible->Compress();

        }

    // Delete the PIN and POL files

    HBufC* pinFile = iFileUtil.GetPinFileNameLC(aPolicyId);    

    HBufC* polFile = iFileUtil.GetPolFileNameLC(aPolicyId);

    if (iFileUtil.FileExists(*pinFile))

        {

        iFileUtil.DeleteFileL(*pinFile); 

        }

    if (iFileUtil.FileExists(*polFile))

        {

        iFileUtil.DeleteFileL(*polFile);

        }

    CleanupStack::PopAndDestroy(2); // polFile, pinFile

    LOG(Log::Printf(_L("<- CPolicyStore::DeletePolicyL()")));            

    return KErrNone;

    }

TInt CPolicyStore::PolicyCount()

    {

    // The list of policies returned to the caller contains ONLY

    // visible policies. Thus we return just the count of those.

    return iPolicyListVisible->Count();

    }

TInt CPolicyStore::GetPolicyInfo(const TVpnPolicyId& aPolicyId, TVpnPolicyInfo& aPolicyInfo)

    {

    TInt policyIndex = PolicyIndex(aPolicyId);

    if (policyIndex == KUnfoundIndex)

        {

        return KVpnErrPolicyNotFound;

        }

    else

        {

        aPolicyInfo = iPolicyListAll->At(policyIndex);

        return KErrNone;

        }

    }

TInt CPolicyStore::GetPolicyDetailsL(

    const TVpnPolicyId& aPolicyId, 

    TVpnPolicyDetails& aPolicyDetails)

    {

    LOG(Log::Printf(_L("-> CPolicyStore::GetPolicyDetailsL()")));            

    TInt policyIndex = PolicyIndex(aPolicyId);

    if (policyIndex == KUnfoundIndex)

        {

        LOG(Log::Printf(_L("<- CPolicyStore::GetPolicyDetailsL() (KVpnErrPolicyNotFound)")));

        return KVpnErrPolicyNotFound;

        }

    else

        {

        STACK_LEFT;

        // Get static policy information from the PIN file

        TPinParser* pinParser = new (ELeave) TPinParser(iFileUtil);

        CleanupStack::PushL(pinParser);

        HBufC* pinFile = iFileUtil.GetPinFileNameLC(aPolicyId);

        pinParser->ParsePolicyDetailsL(*pinFile, aPolicyDetails);

        CleanupStack::PopAndDestroy(2); // pinFile, pinParser

        // Find out dynamic policy information from the system

        aPolicyDetails.iPkiStatus = PolicyPkiStatusL(aPolicyId);

        aPolicyDetails.iUsageStatus = 

            PolicyUsageStatusL(aPolicyId);

        // Set the policy ID as well

        aPolicyDetails.iId.Copy(aPolicyId);

        LOG(Log::Printf(_L("<- CPolicyStore::GetPolicyDetailsL()")));

        return KErrNone;

        }

    }

TInt CPolicyStore::LoadPolicyDataL(const TVpnPolicyId& aPolicyId, 

    HBufC8*& aPolicyData)

    {

    TInt policyIndex = PolicyIndex(aPolicyId);

    if (policyIndex == KUnfoundIndex)

        {

        return KVpnErrPolicyNotFound;

        }

    HBufC* polFile = iFileUtil.GetPolFileNameLC(aPolicyId);

    aPolicyData = iFileUtil.LoadFileDataL(*polFile);

    CleanupStack::PopAndDestroy();

    return KErrNone;

    }

void CPolicyStore::AddPolicyL(const TVpnPolicyId& aPolicyId)

    {

    LOG(Log::Printf(_L("-> CPolicyStore::AddPolicyL")));    

    TVpnPolicyInfo* policyInfo = new (ELeave) TVpnPolicyInfo();

    CleanupStack::PushL(policyInfo);

    policyInfo->iId = aPolicyId;

    // Policy name is read from the PIN file

    HBufC* pinFile = iFileUtil.GetPinFileNameLC(aPolicyId);

    TPinParser* pinParser = new (ELeave) TPinParser(iFileUtil);

    CleanupStack::PushL(pinParser);

    pinParser->ParsePolicyInfoL(*pinFile, *policyInfo);

    CleanupStack::PopAndDestroy(pinParser);

    CleanupStack::PopAndDestroy(pinFile);

    LOG(Log::Printf(_L("pinParser.ParsePolicyInfoL completed")));

    iPolicyListAll->AppendL(*policyInfo);

    // A visible policy is added also

    // to the list of visible policies

    if (!IsHiddenPolicyL(policyInfo->iId))

        {

        iPolicyListVisible->AppendL(*policyInfo);

        }

    CleanupStack::PopAndDestroy(policyInfo);

    LOG(Log::Printf(_L("<- CPolicyStore::AddPolicyL")));            

    }

TVpnPolicyId CPolicyStore::NewPolicyIdL()

    {

    TUuid uuid;

    TUuidString uuidString;

    Uuid::MakeUuidL(uuid);

    // It has become apparent that certain

    // Symbian OS devices generate duplicate random

    // number sequences after gold boot due to improper

    // seeding of the random number generator. Should

    // this happen to be the case, we insert at least

    // one component to the UUID that depends on the 

    // current system time. This is not perfect, but 

    // should give us policy IDs that are unique enough.

    TTime now;

	now.UniversalTime();

    TInt64 randSeed = now.Int64();

    TInt randomNum = Math::Rand(randSeed);

    uuid.iTimeLow = static_cast<TUint32>(randomNum);

    Uuid::UuidToString(uuid, uuidString);

    TVpnPolicyId newPolicyId;

    newPolicyId.Copy(uuidString);

    return newPolicyId;

    }

TInt CPolicyStore::PolicyIndex(const TVpnPolicyId& aPolicyId)

    {

    for (TInt i = 0; i < iPolicyListAll->Count(); i++)

        {

        if (iPolicyListAll->At(i).iId.Compare(aPolicyId) == 0)

            {

            return i;

            }

        }

    LOG_1("CPolicyStore::PolicyIndex not found:%S", &aPolicyId);

    return KUnfoundIndex;

    }

TInt CPolicyStore::PolicyIndexVisible(const TVpnPolicyId& aPolicyId)

    {

    for (TInt i = 0; i < iPolicyListVisible->Count(); i++)

        {

        if (iPolicyListVisible->At(i).iId.Compare(aPolicyId) == 0)

            {

            return i;

            }

        }

    return KUnfoundIndex;

    }

TPolicyUsageStatus CPolicyStore::PolicyUsageStatusL(

    const TVpnPolicyId& aPolicyId )

    {

    LOG(Log::Printf(_L("-> CPolicyStore::PolicyUsageStatusL")));

    STACK_LEFT;

    TPolicyUsageStatus usageStatus = EUsageStatusUnused;

using namespace CMManager;    

    RCmManager cmManager;

    cmManager.OpenL(); // Do not use LC it's not working yet

    CleanupClosePushL( cmManager );

    TBool policyActive(EFalse);

    if (PolicyAssignedToIapL(cmManager, aPolicyId, policyActive))

        {

        usageStatus = policyActive ? EUsageStatusActive : 

            EUsageStatusAssignedToIap;

        }

    CleanupStack::PopAndDestroy(); // cmManager

    LOG(Log::Printf(_L("<- CPolicyStore::PolicyUsageStatusL")));

    return usageStatus;

    }

TBool CPolicyStore::PolicyAssignedToIapL(

    RCmManager& aCmManager,

    const TVpnPolicyId& aPolicyId,

    TBool& aPolicyActive)

    {

    STACK_LEFT;

    RArray<TUint32> vpnConnections;

    ConnectionMethodsLC( 

        vpnConnections, aCmManager, aPolicyId, aPolicyActive );

    TBool policyAssignedToIap( vpnConnections.Count() ? ETrue : EFalse );

    CleanupStack::PopAndDestroy(); // vpnConnections

    LOG_1("CPolicyStore::PolicyAssignedToIapL %d", policyAssignedToIap); 

    return policyAssignedToIap;

    }

void CPolicyStore::ConnectionMethodsLC(

    RArray<TUint32>& aVpnConnections,

    RCmManager& aCmManager,

    const TVpnPolicyId& aPolicyId,

    TBool& aPolicyActive)

    {

using namespace CMManager;         

    LOG_1("CPolicyStore::ConnectionMethodsLC : %S", &aPolicyId);

    CleanupClosePushL( aVpnConnections );

    aCmManager.ConnectionMethodL( 

        aVpnConnections,

        ETrue,

        EFalse,

        EFalse ); 

    LOG_1("CPolicyStore::ConnectionMethodsLC cnt: %d", 

        aVpnConnections.Count());

    TInt index(aVpnConnections.Count());

    while( index )

        {

        --index;

        LOG_1("CPolicyStore::ConnectionMethodsLC at: %d", index);

        TUint32 id(aVpnConnections[index]);

        RCmConnectionMethod connectioMethod = 

            aCmManager.ConnectionMethodL( id );

        CleanupClosePushL( connectioMethod );  

        if( connectioMethod.GetIntAttributeL(ECmBearerType) != 

            KPluginVPNBearerTypeUid )

            {

            aVpnConnections.Remove( index );

            }

        else

            {

            HBufC* policyId = connectioMethod.GetStringAttributeL(

                EVpnServicePolicy);

            if( aPolicyId.Compare( *policyId ) )

                {

                aVpnConnections.Remove( index );

                }

            else

                {

                if( connectioMethod.GetBoolAttributeL(ECmConnected) )

                    {

                    LOG_1("PolicyActiveL:%d", index);

                    aPolicyActive = ETrue;

                    }

                }

            delete policyId;      

            }

        CleanupStack::PopAndDestroy(); // connectioMethod 

        }

    }

TPolicyPkiStatus CPolicyStore::PolicyPkiStatusL(const TVpnPolicyId& aPolicyId)

    {

    HBufC8* policyData;

    if (LoadPolicyDataL(aPolicyId, policyData) != KErrNone)

        {

        return EPkiStatusUnknown;

        }

    CleanupStack::PushL(policyData);

    HBufC* policyData16 = HBufC::NewL(policyData->Length());

    CleanupStack::PushL(policyData16);

    policyData16->Des().Copy(*policyData);

    CIkeDataArray* ikeDataArray = CIkeDataArray::NewL(1);

    CleanupStack::PushL(ikeDataArray);

    TIkeParser ikeParser(*policyData16);

    ikeParser.ParseIKESectionsL(ikeDataArray);

    // Go through each IKE section (VPN gateway definition)

    // to find out the collective policy PKI status:

    // - EPkiStatusReady if a valid user certificate is present for

    // each VPN gateway defined in the policy

    // - EPkiStatusNoCert if no user certificate is present for

    // one or more VPN gateway defined in the policy

    // - EPkiStatusCertExpired if a user certificate related

    // to one or more VPN gateway has expired

    // - EPkiStatusCertNotValidYet if a user certificate related

    // to one or more VPN gateway is not yet valid

    TPolicyPkiStatus policyPkiStatus = EPkiStatusReady;

    for (TInt i = 0; i < ikeDataArray->Count(); i++)

        {

        CIkeData* ikeData = ikeDataArray->At(i);

        TCertStatus gwPkiStatus = PolicyCertificateStatusL(ikeData);

        // Determine the overall policy PKI status

        if (gwPkiStatus == ECertValid ||

            gwPkiStatus == ECertNotNeeded)

            {

            continue;

            }

        else if (gwPkiStatus == ECertNotFound)

            {

            policyPkiStatus = EPkiStatusNoCert;

            break;

            }

        else if (gwPkiStatus == ECertExpired)

            {

            policyPkiStatus = EPkiStatusCertExpired;

            break;

            }

        else if (gwPkiStatus == ECertNotValidYet)

            {

            policyPkiStatus = EPkiStatusCertNotValidYet;

            }

        }

    CleanupStack::PopAndDestroy(3); // ikeDataArray, policyData16, policyData

    return policyPkiStatus;

    }

TCertStatus CPolicyStore::PolicyCertificateStatusL(CIkeData* aIkeData) const