/*
* Copyright (c) 2006 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:  Utility class for location triggering container
*
*/


// INCLUDE FILES
#include <e32base.h>
#include <lbttriggerfilterbyattribute.h>
#include <s32mem.h>
#include <lbttriggerfilterbyarea.h>
#include <lbttriggerfiltercomposite.h>
#include <lbtstartuptrigger.h>
#include <lbtgeocircle.h>
#include <lbtgeohybrid.h>
#include <lbtgeocell.h>
#include "lbtcontainerutilities.h"
#include "lbttriggerfilterbyattribute.h"
#include "lbtlisttriggeroptions.h"
#include "lbtcontainerlistoptions.h"
#include "lbtcontainertriggerfilter.h"
#include "lbtcontainerareafilter.h"
#include "lbtcontainerattrfilter.h"
#include "lbtcontainercompfilter.h"
#include "lbtcontainerupdatefilter.h"
#include "lbtsecuritypolicy.h"
#include "lbtcontainertriggerentry.h"
#include "lbtlogger.h"

//----------------------------------------------------------------------------
// LbtContainerUtilities::GetContainerFilterBaseType
//----------------------------------------------------------------------------
//
CLbtContainerFilterBase* LbtContainerUtilities::GetContainerFilterFromListOptionsLC( CLbtContainerListOptions* aListOptions )
	{
	FUNC_ENTER("LbtContainerUtilities::GetContainerFilterFromListOptions");
	if(aListOptions == NULL)
		{
		User::Leave(KErrArgument);
		}

	CLbtListTriggerOptions* listOptions = aListOptions->ListOptions();
	CLbtTriggerFilterBase *filter = NULL;
	
	if( listOptions != NULL )
        {
        filter = CloneFilterL(listOptions->Filter());
        }
    
    if(filter == NULL)
    	{
    	filter = CLbtTriggerFilterByAttribute::NewL();    	
        CLbtTriggerFilterByAttribute* attrFilter = static_cast<CLbtTriggerFilterByAttribute*> (filter);
        attrFilter->AddTriggerStateL(CLbtTriggerEntry::EStateEnabled);
        attrFilter->AddTriggerStateL(CLbtTriggerEntry::EStateDisabled);
    	}
    CleanupStack::PushL(filter);
    
    CLbtContainerFilter* contFilter = NULL;
    TBool containerFilterOnStack = EFalse;    
    if(aListOptions->ContainerFilter() != NULL)
    	{
    	containerFilterOnStack = ETrue;
    	contFilter = CLbtContainerFilter::NewL(aListOptions->ContainerFilter());
    	CleanupStack::PushL(contFilter);
    	}

    CLbtContainerFilterBase* retContainerFilter = NULL;
	switch(filter->Type())
		{
		case CLbtTriggerFilterBase::EFilterByArea:
			{
			CLbtContainerAreaFilter* areaFilter = CLbtContainerAreaFilter::NewL(filter ,contFilter);
		    retContainerFilter = areaFilter;
		    break;
			}
		case CLbtTriggerFilterBase::EFilterByAttribute:
			{
			CLbtContainerAttrFilter* attrFilter = CLbtContainerAttrFilter::NewL(filter, contFilter);
			retContainerFilter = attrFilter;
			break;
			}
		case CLbtTriggerFilterBase::EFilterComposite:
			{
			CLbtContainerCompFilter* compFilter = CLbtContainerCompFilter::NewL(filter, contFilter);
			retContainerFilter = compFilter;
			break;
			}
		default:
			{
			// This is some filter which is not supported
			User::Leave(KErrNotSupported);
			break;
			}
		}	
	if(containerFilterOnStack)
		{
		CleanupStack::Pop(contFilter); // Ownership taken by container filter
		}	
	CleanupStack::Pop(filter); // Ownership taken by container filter
	CleanupStack::PushL(retContainerFilter);
	return retContainerFilter;
	}

//----------------------------------------------------------------------------
// LbtContainerUtilities::GetContainerFilterFromUpdateFilterLC
//----------------------------------------------------------------------------
//
CLbtContainerFilterBase* LbtContainerUtilities::GetContainerFilterFromUpdateFilterLC( CLbtContainerUpdateFilter* aListOptions )
	{
	FUNC_ENTER("LbtContainerUtilities::GetContainerFilterFromUpdateFilterLC");
	
	if(aListOptions == NULL)
		{
		User::Leave(KErrArgument);
		}
	
	CLbtTriggerFilterBase* filterBase = CloneFilterL(aListOptions->TrigInfoFilter());
	CleanupStack::PushL(filterBase);
	
	CLbtContainerFilter* contFilter = NULL;
	TBool containerFilterOnStack = EFalse;
	if(aListOptions->ContainerFilter() != NULL)
		{
		containerFilterOnStack = ETrue;
		contFilter = CLbtContainerFilter::NewL(aListOptions->ContainerFilter());
		CleanupStack::PushL(contFilter);
		}
    CLbtContainerFilterBase* filter = NULL;
    
    switch(filterBase->Type())
    	{
		case CLbtTriggerFilterBase::EFilterByAttribute: 	
			{
			CLbtContainerAttrFilter* attrFilter = CLbtContainerAttrFilter::NewL(filterBase, contFilter);
			filter = attrFilter;
			break;
			}
		case CLbtTriggerFilterBase::EFilterByArea:
			{
			CLbtContainerAreaFilter* areaFilter = CLbtContainerAreaFilter::NewL(filterBase, contFilter);
			filter = areaFilter;
			break;
			}									
		case CLbtTriggerFilterBase::EFilterComposite:
			{
			CLbtContainerCompFilter* compFilter = CLbtContainerCompFilter::NewL(filterBase, contFilter);
			filter = compFilter;
			break;
			}
		default:
			{
			User::Leave(KErrNotSupported);
			break;
			}
    	}
    if(containerFilterOnStack)
		{
		CleanupStack::Pop(contFilter); // Ownership taken by container filter
		}
    CleanupStack::Pop(); //filterBase, 
    CleanupStack::PushL(filter);
    return filter;
	}

//----------------------------------------------------------------------------
// LbtContainerUtilities::CopyGeoAreaL
//----------------------------------------------------------------------------
//
CLbtGeoAreaBase* LbtContainerUtilities::CopyGeoAreaL( CLbtGeoAreaBase* aGeoAreaBase )
    {
    CBufFlat* buffer = CBufFlat::NewL(512);
    CleanupStack::PushL(buffer);
                        
    RBufWriteStream writeStream;
    writeStream.Open( *buffer );
    CleanupClosePushL(writeStream);
    
    aGeoAreaBase->ExternalizeL( writeStream );
    writeStream.CommitL();
    CleanupStack::PopAndDestroy(&writeStream);
    
    RBufReadStream readStream;
    readStream.Open( *buffer );
    CleanupClosePushL(readStream);
    CLbtGeoAreaBase* trigArea = NULL;
    
    switch( aGeoAreaBase->Type() )
        {
        case CLbtGeoAreaBase::ECircle:
            {
            trigArea = CLbtGeoCircle::NewLC();
            break;
            }
        case CLbtGeoAreaBase::ECellular:
            {
            trigArea = CLbtGeoCell::NewLC();
            break;
            }
        case CLbtGeoAreaBase::EHybrid:
            {
            trigArea = CLbtGeoHybrid::NewLC();
            break;
            }
        default:
            {
            User::Leave( KErrArgument );
            }
        }
    
    trigArea->InternalizeL( readStream );
    CleanupStack::Pop(3); //trigArea, readStream and buffer
    readStream.Close();
    delete buffer;
    return trigArea; 
    }

//----------------------------------------------------------------------------
// LbtContainerUtilities::GetContainerFilterBaseType
//----------------------------------------------------------------------------
//
CLbtTriggerFilterBase* LbtContainerUtilities::CloneFilterL(CLbtTriggerFilterBase* aFilter)
	{
	FUNC_ENTER("CLbtDbTriggersManager::CloneFilterL");

	if(aFilter == NULL)
		{
		return NULL;
		}

	CBufFlat* buffer = CBufFlat::NewL(512);
	CleanupStack::PushL(buffer);
	
	RBufWriteStream writeStream(*buffer);
	CleanupClosePushL(writeStream);
	
	aFilter->ExternalizeL(writeStream);
	CleanupStack::PopAndDestroy(); //writeStream

	CLbtTriggerFilterBase* retFilter = NULL;
	RBufReadStream stream(*buffer);
	CleanupClosePushL(stream);

	switch(aFilter->Type())
		{
		case CLbtTriggerFilterBase::EFilterByAttribute:
			{
			CLbtTriggerFilterByAttribute* attributeFilter = 
								CLbtTriggerFilterByAttribute::NewLC();
			attributeFilter->InternalizeL(stream);			
			CleanupStack::Pop(attributeFilter);
			retFilter = attributeFilter;
			break;
			}
		case CLbtTriggerFilterBase::EFilterByArea:
			{
			CLbtTriggerFilterByArea* areaFilter = 
								CLbtTriggerFilterByArea::NewLC();			
			areaFilter->InternalizeL(stream);			
			CleanupStack::Pop(areaFilter);
			retFilter = areaFilter;
			break;
			}
		case CLbtTriggerFilterBase::EFilterComposite:
			{
			CLbtTriggerFilterComposite* compositeFilter = 
								CLbtTriggerFilterComposite::NewLC();
			compositeFilter->InternalizeL(stream);			
			CleanupStack::Pop(compositeFilter);
			retFilter = compositeFilter;
			break;
			}
		default:
			{
			User::Leave(KErrNotSupported);
			break;
			}
		}
	CleanupStack::PopAndDestroy(2); //stream, buffer
	return retFilter;
	}

//----------------------------------------------------------------------------
// LbtContainerUtilities::RunSecurityPolicy
//----------------------------------------------------------------------------
//
TBool LbtContainerUtilities::RunSecurityPolicy( CLbtContainerTriggerEntry* aTriggerEntry, 
												TLbtSecurityPolicy& aSecurityPolicy )
	{
	FUNC_ENTER("LbtContainerUtilities::RunSecurityPolicy");
	// Check if the security policy is NULL
	if(aSecurityPolicy.IsNull())
		{
		// No security policy required
		return ETrue;
		}
	
	// Check if the trigger's owner SID matches the secure id of the client
	TSecureId ownerSecureId = aSecurityPolicy.GetOwnerSecureId();
	
	if(ownerSecureId.iId != KNullUidValue)
		{
		if(aTriggerEntry->ExtendedTriggerInfo()->OwnerSid() == ownerSecureId)
			{
			// The Secure ID of the policy matches the owner SID.
			return ETrue;
			}
		
		// Check if the secure id specified in the security policy matches the manager ui
		if( aTriggerEntry->TriggerEntry()->ManagerUi() == ownerSecureId )
			{
			return ETrue;
			}
		}
	
	// Check if the security policies owner secure id and the secure id of the 
	// trigger handling process are the same. If yes then the security check passes
	CLbtTriggerEntry* triggerEntry = aTriggerEntry->TriggerEntry();	
	if( triggerEntry->Type() == CLbtTriggerEntry::ETypeStartup)
		{
		CLbtStartupTrigger* startupTrigger = static_cast<CLbtStartupTrigger*>(triggerEntry);
		TSecureId secureId;
		TBuf16<KMaxFileName> fileName;
		startupTrigger->GetProcessId(fileName, secureId);
		if( secureId == aSecurityPolicy.GetOwnerSecureId() )
			{
			return ETrue;
			}
		}		
	return EFalse;
	}

//----------------------------------------------------------------------------
// LbtContainerUtilities::RunSecurityPolicy
//----------------------------------------------------------------------------
//
TBool LbtContainerUtilities::RunSecurityPolicy( TUid& aOwnerUid,
												TUid& aManagerUid,
												TSecureId& aStartupProcessUid,
												TLbtSecurityPolicy& aSecurityPolicy )
	{
	FUNC_ENTER("LbtContainerUtilities::RunSecurityPolicy-UID");
	
	// Check if the security policy is NULL
	if(aSecurityPolicy.IsNull())
		{
		// No security policy required
		return ETrue;
		}
	
	// Check if the trigger's owner SID matches the secure id of the client
	TSecureId ownerSecureId = aSecurityPolicy.GetOwnerSecureId();
	
	if(ownerSecureId.iId != KNullUidValue)
		{
		if( aOwnerUid == ownerSecureId )
			{
			// The Secure ID of the policy matches the owner SID.
			return ETrue;
			}
		
		// Check if the secure id specified in the security policy matches the manager ui
		if( aManagerUid == ownerSecureId )
			{
			return ETrue;
			}
		
		if( aStartupProcessUid == ownerSecureId )
			{
			return ETrue;
			}	
		}		
	return EFalse;
	}

//end of file