/*

* Copyright (c) 2008-2009 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:  Haptics uid implementation.

*

*/

#include <s32file.h>

#include <f32file.h>

#include <pathinfo.h>

#include "hwrmhapticsuid.h"

#include "hwrmhapticstrace.h"

//drive char and colon string length, e.g. "c:"

const TInt KDriveAndColon = 2; 

// Maximum uid file line length

const TInt KMaxLineLength( 100 );

// New line character used to terminate each line in uid file

const TInt KNewLine( '\n' );

// format specifier used to match valid UIDs

_LIT8( KMatchUid, "0x????????" );

// format specifier used to match valid enabled sign

_LIT8( KMatchPlusSign, "+" );

// valid vendor id definition

_LIT8( KVid, "VID" );

// valid secure id definition

_LIT8( KSid, "SID" );

// ---------------------------------------------------------------------------

// C++ constructor

// ---------------------------------------------------------------------------

//

TUidItem::TUidItem( const TDesC8& aUidType, TUid aUid, TBool aAllowed )

            : iUidType( aUidType ), iUid( aUid ), iAllowed( aAllowed )

    {

    }

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CHWRMHapticsUid* CHWRMHapticsUid::NewL( const TDesC& aFilename )

    {

    CHWRMHapticsUid* self = NewLC( aFilename );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Two-phased constructor. Leaves instance on the cleanup stack.

// ---------------------------------------------------------------------------

//

CHWRMHapticsUid* CHWRMHapticsUid::NewLC( const TDesC& aFilename )

    {

    CHWRMHapticsUid* self = new( ELeave ) CHWRMHapticsUid();

    CleanupStack::PushL( self );

    self->ConstructL( aFilename );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CHWRMHapticsUid::~CHWRMHapticsUid()

    {

    // Delete all the array objects

    iUidArray.Close();

    }

// ---------------------------------------------------------------------------

// C++ constructor

// ---------------------------------------------------------------------------

//

CHWRMHapticsUid::CHWRMHapticsUid()

    {

    }

// ---------------------------------------------------------------------------

// By default Symbian 2nd phase constructor is private.

// ---------------------------------------------------------------------------

//

void CHWRMHapticsUid::ConstructL( const TDesC& aFilename )

    {

    RFs fs;

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

    CleanupClosePushL( fs );

    // Buffer to store the full path and filename

    TFileName filename;

    // Get private file path

    User::LeaveIfError( fs.PrivatePath( filename ) );

    // add the filename to path

    filename.Insert( 0, PathInfo::RomRootPath().Left( KDriveAndColon ) );

    filename.Append( aFilename );

    // Parse the file and construct the array of UIDs

    ParseUidFileL( fs, filename );

    CleanupStack::PopAndDestroy( &fs );

    }

// ---------------------------------------------------------------------------

// Checks if automated license setting is allowed for VID/SID combination

// found from aMessage. If definition for SID is found then VID checking

// is omitted.

// ---------------------------------------------------------------------------

//

TBool CHWRMHapticsUid::LicenseAutoSetAllowed( const RMessage2& aMessage )

    {

    TUid sid = aMessage.SecureId();

    TUid vid = aMessage.VendorId();

    TBool allowed = EFalse;

    TBool sidFound = EFalse;

    for ( TInt n=0; n < iUidArray.Count(); n++ )

        {

        if ( iUidArray[n].iUidType == KSid &&

             sid == iUidArray[n].iUid )

            {

            allowed = iUidArray[n].iAllowed;

            sidFound = ETrue;

            }

        if ( !sidFound && 

             iUidArray[n].iUidType == KVid &&

             vid == iUidArray[n].iUid )

            {

            allowed = iUidArray[n].iAllowed;

            }

        }

    return allowed;

    }

// ---------------------------------------------------------------------------

// Method constructs the array of UIDs from the given file.

// A valid line in the file contains only UID

// ---------------------------------------------------------------------------

//

void CHWRMHapticsUid::ParseUidFileL( RFs& aFs, 

                                     const TDesC& aFilename )

    {

    TLex8 lex;

    TPtrC8 sign;

    TPtrC8 uidType;

    TPtrC8 id;

    TUid uid;

    TInt err( KErrNone );

    // Buffer to read each line of the file into

    TBuf8<KMaxLineLength> fileline;

    TChar newLine( KNewLine );  

    RFileReadStream stream;    

    COMPONENT_TRACE( ( _L( "CHWRMHapticsUid::ParseUidFileL - Opening UID file: %S" ), &aFilename ) );

    // Open the file and attach to stream 

    err = stream.Open( aFs, aFilename, EFileRead );

    // Return without error if file is not found

    if ( err != KErrNone )

        {

        COMPONENT_TRACE( ( _L( "CHWRMHapticsUid::ParseUidFileL - UID file open failed: %S, error: %d" ), &aFilename, err ) );

        }

    else

        {

        CleanupClosePushL( stream );

        while( err != KErrEof )

            {

            // read from the file upto the newline character

            TRAP( err, stream.ReadL( fileline, newLine ) );

            lex.Assign( fileline );

            sign.Set( lex.NextToken() );            

            uidType.Set( lex. NextToken() );

            id.Set( lex.NextToken() );

            TBool allowed = EFalse;

            if( sign.Match( KMatchPlusSign ) == 0 )

                {

                allowed = ETrue;

                }

            if( id.Match( KMatchUid ) == 0 )

                {

                // convert it

                if( ConvertId( id, uid ) != KErrCorrupt )

                    {

                    // add UID to array

                    iUidArray.AppendL( TUidItem( uidType, uid, allowed ) );

                    }

                }

            }

        // Close stream

        CleanupStack::PopAndDestroy( &stream );

        }

    }

// ---------------------------------------------------------------------------

// Helper method to convert and validate UID from a descriptor

// ---------------------------------------------------------------------------

//

TInt CHWRMHapticsUid::ConvertId( const TDesC8& aUidDes, 

                                    TUid& aUid ) const

    {

    TInt ret( KErrNone );

    TUint32 id;

    // this is a matching id

    TLex8 lex( aUidDes.Right( 8 ) );

    if( lex.Val( id, EHex ) != KErrNone )

        {

        // Failed to convert to int

        ret = KErrCorrupt;

        }

    else

        {

        // conversion ok so set the uid

        aUid.iUid = id;

        }

    return ret;

    }

// End of File