/*

* Copyright (c) 2002-2005 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:          

*

*/

#include "senwspolicymanager.h"

#include "seninternalwspolicy.h"

#include <s32mem.h>

#include <s32file.h>

#include <sysutil.h>

#include <SenFacet.h>

#include <SenXmlUtils.h>

#include "sendebug.h"               // internal \Utils\inc - filelogging MACROs

#include "msencoreservicemanager.h" // internal \Framework\inc

#include "SenParser.h"

#include "SenDateUtils.h"

#include "senservicepolicy.h"

#include "wspolicyutils.h"

#include "wspolicy.h"

#include "senguidgen.h"

#include "senxmldebug.h"

#include "senlogger.h"

#include <SenServiceConnection.h> 

#include <xmlengnodelist.h> 

using namespace WSPolicy;

using namespace SenWSInternalPolicy;

namespace

    {

#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )

    _LIT(KWsPolicyFile,           "C:\\system\\data\\senwspolicies.xml");

#else

    _LIT(KWsPolicyFile,           "senwspolicies.xml");

#endif

    const TInt KStateParsingContainer   = 99;

    const TInt KStateParsingIdentifier  = 100;

    const TInt KStateParsingProperties  = 102;

    const TInt KStateParsingPolicy            = 104;

    const TInt KFlatBufSize                       = 128;

    const TUint KValidityTime = +7;

    }

EXPORT_C CSenWSPolicyManager* CSenWSPolicyManager::NewL(MSenCoreServiceManager& aManager)

    {

    CSenWSPolicyManager* pNew = NewLC(aManager);

    CleanupStack::Pop(pNew);

    return(pNew);

    }

EXPORT_C CSenWSPolicyManager* CSenWSPolicyManager::NewLC(MSenCoreServiceManager& aManager)

    {

    CSenWSPolicyManager* pNew = new (ELeave) CSenWSPolicyManager(aManager);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

EXPORT_C CSenWSPolicyManager::~CSenWSPolicyManager()

    {

    delete iPolicDataLoader;

    iPolicyArray.ResetAndDestroy();

    iConsumerArray.ResetAndDestroy();

    }

CSenWSPolicyManager::CSenWSPolicyManager(MSenCoreServiceManager& aManager) 

:iManager(aManager),

iLog((RFileLogger*)aManager.Log())

    {

    }

void CSenWSPolicyManager::ConstructL()

    {

        iPolicDataLoader  = CSenWSPolicyLoader::NewL(iManager);

        RefreshPolicyContainerL();	//codescannerwarnings

    }

RFileLogger* CSenWSPolicyManager::Log()

    {

    return iLog;

    }

EXPORT_C TInt CSenWSPolicyManager::RegisterWsPolicyL(CSenWSDescription* aPattern,

                                                    TInt& aErrorTo)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RegisterWsPolicyL");                

        TInt retVal(KErrGeneral);

        if(iPolicDataLoader == NULL)

        {

          iPolicDataLoader  = CSenWSPolicyLoader::NewL(iManager);

        }

        retVal = iPolicDataLoader->RegisterWsPolicyL(aPattern, aErrorTo);

        if(retVal == KErrNone)

            RefreshPolicyContainerL();	//codescannerwarnings

        if(iPolicDataLoader)

        {

            delete iPolicDataLoader;

            iPolicDataLoader = NULL;

        }

        return retVal;

    }

EXPORT_C TInt CSenWSPolicyManager::UnRegisterWsPolicyL(CSenWSDescription* aPattern, 

                                                        TInt& aErrorTo)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::UnRegisterWsPolicyL");

        TInt retVal(KErrGeneral);

        if(iPolicDataLoader == NULL)

        {

          iPolicDataLoader  = CSenWSPolicyLoader::NewL(iManager);

        }

        retVal = iPolicDataLoader->UnRegisterWsPolicyL(aPattern, aErrorTo);

        if(retVal == KErrNone)

            RefreshPolicyContainerL();	//codescannerwarnings

        if(iPolicDataLoader)

        {

            delete iPolicDataLoader;

            iPolicDataLoader = NULL;

        }

        return retVal;

}

EXPORT_C TInt CSenWSPolicyManager::AddWsPolicyL(CSenWSDescription* aPattern, const TDesC8& aUri,

                                               const TDesC8& aPolicy, TInt& aErrorTo)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::AddWsPolicyL");        

        TInt retVal(KErrGeneral);

        if(iPolicDataLoader == NULL)

        {

          iPolicDataLoader  = CSenWSPolicyLoader::NewL(iManager);

        }

        retVal = iPolicDataLoader->AddWsPolicyL(aPattern, aUri, aPolicy, aErrorTo);

        if(retVal == KErrNone)

            RefreshPolicyContainerL();	//codescannerwarnings

        if(iPolicDataLoader)

        {

            delete iPolicDataLoader;

            iPolicDataLoader = NULL;

        }

        return retVal;

    }

EXPORT_C TInt CSenWSPolicyManager::RemoveWsPolicyL( CSenWSDescription* aPattern, 

                                                const TDesC8& aUri, TInt& aErrorTo)

    {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RemoveWsPolicyL");

        TInt retVal(KErrGeneral);

        if(iPolicDataLoader == NULL)

        {

          iPolicDataLoader  = CSenWSPolicyLoader::NewL(iManager);

        }

        retVal = iPolicDataLoader->RemoveWsPolicyL(aPattern, aUri, aErrorTo);

        if(retVal == KErrNone)

            RefreshPolicyContainerL();  //codescannerwarnings

        if(iPolicDataLoader)

        {

            delete iPolicDataLoader;

            iPolicDataLoader = NULL;

        }

        return retVal;

    }

TInt CSenWSPolicyManager::IsConsumerExist(const TDesC8& aEndpoint, const TDesC8& aConsumerId)

{

    TInt count(iConsumerArray.Count());

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

    {

        CConsumerContainer* consumer = iConsumerArray[i];

        if(consumer->Uri() == aEndpoint && consumer->ConsumerId() == aConsumerId)

            return i;

    }

    return KErrNotFound;

}

TInt CSenWSPolicyManager::PolicyConsumerCountL(CSenInternalWsPolicy* aInternalPolicy)	//codescannerwarnings

	{

    TInt retVal(KErrNone);

	if (aInternalPolicy)

		{

	    TPtrC8 metadata = aInternalPolicy->IdentifierL().MetadataEndpointL();	//codescannerwarnings

	    TInt count(iConsumerArray.Count());

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

			{

			CConsumerContainer* consumer = iConsumerArray[i];

			if(consumer->Uri() == metadata)

			    retVal++;

			}

		}    

    return retVal;

	}

EXPORT_C TInt CSenWSPolicyManager::AddPolicyConsumerL(const TDesC8& aUri, const TDesC8& aConsumerId)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::AddPolicyConsumerL");

    TInt indx = IsConsumerExist(aUri,aConsumerId);

    if(indx == KErrNotFound)

    {

        CConsumerContainer* consumer = CConsumerContainer::NewL(aUri,aConsumerId);    

        if(consumer) 

        {

            iConsumerArray.Append(consumer);

            RefreshPolicyContainerL();	//codescannerwarnings

        }

        else

        {

        }

    }

    return KErrNone;

    }

EXPORT_C TInt CSenWSPolicyManager::RemovePolicyConsumerL(const TDesC8& aUri, const TDesC8& aConsumerId)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RemovePolicyConsumerL");

    TInt indx = IsConsumerExist(aUri,aConsumerId);

    if(indx > KErrNotFound)

        {

        CConsumerContainer* consumer = iConsumerArray[indx];

        if(consumer) 

            {

            TInt count (iPolicyArray.Count());

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

                {

                CNormalizedPolicyConatiner* container =  iPolicyArray[i];

                if(container->IsSameContainer(aUri))

                   {

                    container->CountDec();

                    if(container->ConsumerCount() < 1)

                        { //we no longer ahve any consumer for this conatiner

                        iPolicyArray.Remove(i);

                        delete container;

                        container = NULL;

                        }

                    }

            }

            iConsumerArray.Remove(indx);

            delete consumer;

            consumer = NULL;

            return KErrNone;

            }

        }

    return KErrNotFound;

    }

EXPORT_C CSenElement*  CSenWSPolicyManager::WsPolicyL( CSenWSDescription* aPattern, 

                                                const TDesC8& aUri, TInt& aErrorTo)

    {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::WsPolicyL");

        aErrorTo = KErrNotFound;

        CSenElement* ele = NULL;

        if(aPattern == NULL && aUri.Length() > 0) //special case for MS

            {

            TInt count (iPolicyArray.Count());

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

                {

                CNormalizedPolicyConatiner* container =  iPolicyArray[i];

                if(container->URI() == aUri)

                    {

                    aErrorTo = KErrNone;

                    return container->Policy();

                    }

                }

            }

        if(aUri.Length() == 0)

            {

            ele = PolicyFromSDL(aPattern);	//codescannerwarnings

            }

        else

            {

            ele = PolicyFromUri(aPattern, aUri);   

            }

        if(ele != NULL)

            aErrorTo = KErrNone;

        return ele;

    }

CSenElement* CSenWSPolicyManager::PolicyByProviderId(const TDesC8& aProviderId, TInt&  aErrorTo)

{

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::PolicyByProviderId");

    TInt count (iPolicyArray.Count());

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

    {

       CNormalizedPolicyConatiner* container =  iPolicyArray[i];

       if(container->ProviderId() == aProviderId)

       {

       CSenElement* ele = container->Policy();

       if(ele)

           {

            aErrorTo = KErrNone;

            return ele;

           }

       }

    }

    aErrorTo = KErrNotFound;

    return NULL;

}

CSenElement* CSenWSPolicyManager::PolicyFromUri(CSenWSDescription* /*aPolicy*/, const TDesC8& aUri)

{

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::PolicyFromUri");

    TInt count (iPolicyArray.Count());

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

    {

       CNormalizedPolicyConatiner* container =  iPolicyArray[i];

       if(container->IsSameContainer(aUri))

       {

        return container->Policy();

       }

    }

    return NULL;

}

CSenElement* CSenWSPolicyManager::PolicyFromSDL(CSenWSDescription* aPolicy)	//codescannerwarnings

{

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::PolicyFromSD");

    if( aPolicy )

        {

        CSenServicePolicy* pol = (CSenServicePolicy*)aPolicy->ServicePolicy();

        CSenElement& servicePolicy = pol->AsElement();

        CSenElement* clientPolicy = servicePolicy.Element( KClientPolicyLocalName );

        if(clientPolicy)

            {

            RPointerArray<CSenElement> metaDataPoliciesUris;

            CleanupClosePushL(metaDataPoliciesUris);

            clientPolicy->ElementsL(metaDataPoliciesUris, KMetadataEndpointLocalname);

            TInt count(metaDataPoliciesUris.Count());

            if(count> 0)

                {

                CSenElement* metaData = NULL;

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

                    {

                    metaData = metaDataPoliciesUris[i];

                    if(metaData && metaData->HasContent())

                        {

                         TPtrC8 uriName = metaData->Content();

                         CleanupStack::PopAndDestroy(&metaDataPoliciesUris);            

                         return PolicyFromUri(aPolicy, uriName);                   

                        }

                    }

                }

             CleanupStack::PopAndDestroy(&metaDataPoliciesUris);            

            }

        }

    return NULL;

    }

TInt CSenWSPolicyManager::UpdatePolicyContainerL(CSenInternalWsPolicy* aInternalPolicy) //codescannerwarnings

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::UpdatePolicyContainer");

        TInt indx(IsContainerL(aInternalPolicy));

        CNormalizedPolicyConatiner* container =  iPolicyArray[indx];

        if(container && container->URI().Compare(aInternalPolicy->IdentifierL().MetadataEndpointL()) == 0)	//codescannerwarnings

        {

            TBool retval = container->UpdateL(aInternalPolicy);

            container->SetConsumerCount(PolicyConsumerCountL(aInternalPolicy));//codescannerwarnings

            return KErrNone;

        }

    return KErrNotFound;

    }

TInt CSenWSPolicyManager::IsContainerL(CSenInternalWsPolicy* aInternalPolicy) //codescannerwarnings

    {

    TInt count (iPolicyArray.Count());

    for(TInt i = 0; i< count && aInternalPolicy; i++)

    {

        CNormalizedPolicyConatiner* container =  iPolicyArray[i];

        TPtrC8 endpoint = aInternalPolicy->IdentifierL().MetadataEndpointL();	//codescannerwarnings

        if(container)

        {

            if(container->URI().Compare(endpoint) == 0)

                return i;

        }

    }

    return KErrNotFound;

    }    

TInt CSenWSPolicyManager::CreatePolicyContainerL(CSenInternalWsPolicy* aInternalPolicy)	//codescannerwarnings

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::CreatePolicyContainer");

    TInt retVal(KErrNone);

    TInt indx = IsContainerL(aInternalPolicy);	//codescannerwarnings

    if(indx == KErrNotFound)

        {

        TPtrC8 metaendpoint = aInternalPolicy->IdentifierL().MetadataEndpointL();	//codescannerwarnings

        CSenElement* metadta = aInternalPolicy->IdentifierL().MetadataEndpointElementL();	//codescannerwarnings

        {

        if(metadta && metadta->HasContent())

            {

            TPtrC8 endpoint = metadta->Content();

            CNormalizedPolicyConatiner* container = 

            CNormalizedPolicyConatiner::NewL(aInternalPolicy, endpoint);

            TPtrC8 metaendpoint = aInternalPolicy->IdentifierL().MetadataEndpointL();	//codescannerwarnings

            if(container && container->IsSameContainer(metaendpoint))

                {

                container->UpdateL(aInternalPolicy);

                retVal = iPolicyArray.Append(container);

                }

            }

        }

        }

    return retVal;

    }    

TInt CSenWSPolicyManager::RefreshPolicyContainerL()	//codescannerwarnings

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RefreshPolicyContainer");

    TInt retVal(KErrGeneral);

    if(iPolicDataLoader == NULL)

        {

        iPolicDataLoader  = CSenWSPolicyLoader::NewL(iManager);

        }

    RSenWSPolicyArray policies;

    CleanupClosePushL(policies);

    retVal = iPolicDataLoader->InternalWsPoliciesL(policies);

    if(retVal == KErrNone)

        {

        TInt count(policies.Count());

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

            {

            CSenInternalWsPolicy* policy =  policies[i];

            TInt consumerCount = PolicyConsumerCountL(policy);//codescannerwarnings

            if( consumerCount > 0)

            {

            //for every internal policy we should have a container here            

            if(policy && IsContainerL(policy) != KErrNotFound)	//codescannerwarnings

                {//We have alreadya  containere

                // we already have this Policy container

                // we just got a new consumer for this policy

                // so the count will be increased

                retVal = UpdatePolicyContainerL(policy); //codescannerwarnings

                if(retVal == KErrNone)

                { //we got proper update

                }

                }

            else

                {//create a new container

				retVal = CreatePolicyContainerL(policy); //codescannerwarnings

                }

            }

            }

        }

    CleanupStack::PopAndDestroy(&policies);

    if(iPolicDataLoader)

        {

        delete iPolicDataLoader;

        iPolicDataLoader = NULL;

        }

    return retVal;

    }

EXPORT_C TInt CSenWSPolicyManager::ExpiredPoliciesL(RExpiredPolicyArray& aArray,  TInt& aErrorTo)

{

TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::ExpiredPoliciesL");    

    TTime now;

    now.UniversalTime();

    TInt count (iPolicyArray.Count());

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

    {

        CNormalizedPolicyConatiner* container =  iPolicyArray[i];