/*
* Copyright (c) 2008 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:  ?Description
 *  Version     : %version: 7 % << Don't touch! Updated by Synergy at check-out.
 *
*/


#include <s32mem.h>
#include <liwcommon.h>
#include <e32std.h>

#include "cpsecuritypolicy.h"
#include "cpdebug.h"
#include "cpglobals.h"

_LIT( KHex, "0x" );
_LIT( KTCB, "TCB" );
_LIT( KLocalServices, "LocalServices" );
_LIT( KLocation, "Location" );
_LIT( KNetworkServices, "NetworkServices" );
_LIT( KReadUserData, "ReadUserData" );
_LIT( KUserEnvironment, "UserEnvironment" );
_LIT( KWriteUserData, "WriteUserData" );
_LIT( KAllFiles, "AllFiles" );
_LIT( KCommDD, "CommDD" );
_LIT( KDiskAdmin, "DiskAdmin" );
_LIT( KDrm, "Drm" );
_LIT( KMultimediaDD, "MultimediaDD" );
_LIT( KNetworkControl, "NetworkControl" );
_LIT( KPowerMgmt, "PowerMgmt" );
_LIT( KProtServ, "ProtServ" );
_LIT( KReadDeviceData, "ReadDeviceData" );
_LIT( KSurroundingsDD, "SurroundingsDD" );
_LIT( KSwEvent, "SwEvent" );
_LIT( KTrustedUI, "TrustedUI" );
_LIT( KWriteDeviceData, "WriteDeviceData" );


// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPSecurityPolicy::CCPSecurityPolicy( const RMessage2& aMessage ): 
                                                           iMessage( aMessage )
    {

    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CCPSecurityPolicy::ConstructL()
    {
  
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPSecurityPolicy* CCPSecurityPolicy::NewL( const RMessage2& aMessage )
    {
    CCPSecurityPolicy* self = CCPSecurityPolicy::NewLC( aMessage );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPSecurityPolicy* CCPSecurityPolicy::NewLC( const RMessage2& aMessage )
    {
    CCPSecurityPolicy* self = new( ELeave ) CCPSecurityPolicy( aMessage );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CCPSecurityPolicy::~CCPSecurityPolicy()
    {
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CCPSecurityPolicy::GetDefaultSecurityL( RBuf8& aResult ) const
    {
    CLiwDefaultMap* aclMap = CLiwDefaultMap::NewLC();
    CLiwDefaultMap* writeMap = CLiwDefaultMap::NewLC();
    CLiwDefaultMap* deleteMap = CLiwDefaultMap::NewLC();
    
    TUint32 publisherUid = iMessage.SecureId();
    
    TBuf<10> uidString;
    uidString.Append( KHex );
    uidString.AppendNumFixedWidth(publisherUid,EHex,8);
    
    writeMap->InsertL( KUIDs, TLiwVariant( uidString ) );
    deleteMap->InsertL( KUIDs, TLiwVariant( uidString ) );
    
    aclMap->InsertL( KACLWrite, TLiwVariant( writeMap ) );
    aclMap->InsertL( KACLDelete, TLiwVariant( deleteMap ) );

    //externalize
    aResult.CreateL( aclMap->Size() );
    RDesWriteStream strm( aResult );
    CleanupClosePushL( strm );
    aclMap->ExternalizeL( strm );
    strm.CommitL( );
     
    CleanupStack::PopAndDestroy( &strm );    
    CleanupStack::PopAndDestroy( deleteMap );
    CleanupStack::PopAndDestroy( writeMap );
    CleanupStack::PopAndDestroy( aclMap );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CCPSecurityPolicy::CheckSecurityL( TPtrC8& aBinary, 
                                        TACLPolicy aPolicy ) const
    {
    TBool error( ETrue );    
    RDesReadStream datastrm( aBinary );
    CleanupClosePushL( datastrm );
    CLiwDefaultMap* map = CLiwDefaultMap::NewLC( datastrm );
    TLiwVariant variant;
    variant.PushL();
    switch( aPolicy )
        {
        case ERead:
            if( map->FindL( KACLRead, variant ) )
                {
                error = DoCheckSecurityL( variant.AsMap() );
                }
        break;
        case EWrite:
            if( map->FindL( KACLWrite, variant ) )
                {
                error = DoCheckSecurityL( variant.AsMap() );
                }
        break;
        case EDelete:
            if( map->FindL( KACLDelete, variant ) )
                {
                error = DoCheckSecurityL( variant.AsMap() );
                }
        break;
        default:
            User::Leave( KErrNotSupported );
        }
    CleanupStack::PopAndDestroy( &variant );
    CleanupStack::PopAndDestroy( map );
    CleanupStack::PopAndDestroy( &datastrm );
    return error;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
TBool CCPSecurityPolicy::DoCheckSecurityL( const CLiwMap* aMap ) const
    {
    TLiwVariant variant;
    variant.PushL();
    TBool denyAccess( ETrue );
    if( aMap->FindL( KUIDs, variant ) )
        {
        TPtrC uidList( KNullDesC );
        if( variant.Get( uidList) )
            {
            denyAccess = CheckUids( uidList );
            }
        }
    if( denyAccess && aMap->FindL( KCapability, variant ) )
        {
        TPtrC capList( KNullDesC );
        if( variant.Get( capList ) )
            {
            denyAccess = CheckCapabilities( capList );
            }
        }
    CleanupStack::PopAndDestroy( &variant );
    return !denyAccess;
    }

 // ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//   
TBool CCPSecurityPolicy::CheckUids( const TDesC& aList ) const
    {
    TInt i( 1 );
    TBool denyAccess( ETrue );
    TPtrC singleUid( KNullDesC );
    while( i )
        {
        ExctractNextToken( aList , singleUid, i );
        TLex converter( singleUid );
        converter.Inc( KHex().Length() );
        TUint32 aclUid( 0 );
        converter.Val( aclUid , EHex );
        if( iMessage.SecureId().iId == aclUid )
            {
            denyAccess = EFalse;
            break;
            }
        ++i;    
        }
    return denyAccess;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CCPSecurityPolicy::CheckCapabilities( const TDesC& aList ) const
    {
    TInt i( 1 );
    TBool denyAccess( EFalse );
    TPtrC singleCap( KNullDesC );
    while( i )
        {
        ExctractNextToken( aList , singleCap, i );
        if( !iMessage.HasCapability( GetCapability( singleCap ) ) )
            {
            denyAccess = ETrue;
            break;
            }  
        ++i;    
        }
    return denyAccess;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CCPSecurityPolicy::ExctractNextToken( const TDesC& aList, 
                                            TPtrC& aResult , TInt& aPos ) const
    {
    TPtrC buf( aList );
    for( TInt x(0); x < aPos; x++ )
        {
        TInt pos = buf.Locate(':');
        if( pos!= KErrNotFound )
            {
            aResult.Set( buf.Left( pos ) );
            buf.Set( buf.Right( buf.Length() - pos - 1 ) );
            }
        else
            {
            aResult.Set( buf );
            aPos = -1;
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
TCapability CCPSecurityPolicy::GetCapability( const TDesC& aCapability ) const
    {
    TCapability ret( ECapability_None );
    if( aCapability == KTCB )
        {
        ret = ECapabilityTCB;
        }
    else if( aCapability == KLocalServices )
        {
        ret = ECapabilityLocalServices;
        }
    else if( aCapability == KLocation )
        {
        ret = ECapabilityLocation;
        }
    else if( aCapability == KNetworkServices )
        {
        ret = ECapabilityNetworkServices;
        }
    else if( aCapability == KReadUserData )
        {
        ret = ECapabilityReadUserData;
        }
    else if( aCapability == KUserEnvironment )
        {
        ret = ECapabilityUserEnvironment;
        }
    else if( aCapability == KWriteUserData )
        {
        ret = ECapabilityWriteUserData;
        }
    else if( aCapability == KAllFiles )
        {
        ret = ECapabilityAllFiles;
        }
    else if( aCapability == KDiskAdmin )
        {
        ret = ECapabilityDiskAdmin;
        }
    else if( aCapability == KCommDD )
        {
        ret = ECapabilityCommDD;
        }
    else if( aCapability == KDrm )
        {
        ret = ECapabilityDRM;
        }
    else if( aCapability == KMultimediaDD )
        {
        ret = ECapabilityMultimediaDD;
        }
    else if( aCapability == KNetworkControl )
        {
        ret = ECapabilityNetworkControl;
        }
    else if( aCapability == KPowerMgmt )
        {
        ret = ECapabilityPowerMgmt;
        }
    else if( aCapability == KProtServ )
        {
        ret = ECapabilityProtServ;
        }                            
    else if( aCapability == KReadDeviceData )
        {
        ret = ECapabilityReadDeviceData;
        }                            
    else if( aCapability == KSurroundingsDD )
        {
        ret = ECapabilitySurroundingsDD;
        }
    else if( aCapability == KSwEvent )
        {
        ret = ECapabilitySwEvent;
        }
    else if( aCapability == KTrustedUI )
        {
        ret = ECapabilityTrustedUI;
        }                        
    else if( aCapability == KWriteDeviceData )
        {
        ret = ECapabilityWriteDeviceData;
        }
    else ret = ECapability_None;                        
    return ret;
    }