/*

* Copyright (c) 2002-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:  The main interface class providing services of ScriptEngine module

*

*/

#include <e32math.h>

#include <e32svr.h>

#include <s32mem.h>

#include <bautils.h>

#include <s32file.h>

#include <centralrepository.h>

#include <gmxmldocument.h>

#include <gmxmlelement.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include "CFScriptHandler.h"

#include "CFScript.h"

#include "ContextFrameworkPrivateCRKeys.h"

#include "cftrace.h"

#include "cfextendedcontextinterface.h"

#include "cfoperationpluginmanager.h"

#include "cfpersistentdata.h"

#include "cfcommon.h"

#include "cfscriptowner.h"

// CONSTANTS

#ifdef USE_TEMP_RULE_FOLDER

    _LIT( KDefaultRuleFilePath, "c:\\Silmaril\\Rules\\" );

#else

    _LIT( KDefaultRuleFilePath, "!:\\private\\10282BC4\\Rules\\" );

#endif

// Default script search pattern

_LIT( KDefaultRuleFileSearchPattern, "*.rul" );

_LIT( KWildCardChar, "*" );

const TInt KInitialScriptId = 1;

const TInt KUidLength = 8;

const TInt KTempScriptId = 0;

const TUint KLimit = 0xFFFFFFFF;

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

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

// CCFScriptHandler::CCFScriptHandler

// C++ default constructor can NOT contain any code, that might leave.

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

//

CCFScriptHandler::CCFScriptHandler(

	MCFExtendedContextInterface& aCF,

    RFs& aFs,

    MCFActionHandler& aScriptEventListener,

    MCFSecurityChecker& aSecurityChecker )

    :   iParserDataProvidingState( KError ),

        iNextId( KInitialScriptId ),

        iCF( aCF ),

        iFs( aFs ),

        iScriptEventListener( aScriptEventListener ),

        iSecurityChecker( aSecurityChecker )

    {

    FUNC_LOG;

    }

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

// CCFScriptHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCFScriptHandler::ConstructL()

    {

    FUNC_LOG;

    iParser = CMDXMLParser::NewL( this );

    iWaitParsing = new( ELeave ) CActiveSchedulerWait;

    iOperationPluginManager = CCFOperationPluginManager::NewL( *this );

#ifdef RD_MULTIPLE_DRIVE

    User::LeaveIfError( DriveInfo::GetDefaultDrive(

        DriveInfo::EDefaultRom, iDefaultRomDrive ) );

    User::LeaveIfError( DriveInfo::GetDefaultDrive(

        DriveInfo::EDefaultSystem, iDefaultSystemDrive ) );

#else

    iDefaultRomDrive = 'Z';

    iDefaultSystemDrive = 'C';

#endif

    }

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

// CCFScriptHandler::NewL

// Two-phased constructor.

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

//

EXPORT_C CCFScriptHandler* CCFScriptHandler::NewL(

	MCFExtendedContextInterface& aCF,

    RFs& aFs,

    MCFActionHandler& aScriptEventListener,

    MCFSecurityChecker& aSecurityChecker )

    {

    FUNC_LOG;

    CCFScriptHandler* self = NewLC( aCF, aFs, aScriptEventListener,

    	aSecurityChecker );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCFScriptHandler::NewLC

// Two-phased constructor.

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

//

EXPORT_C CCFScriptHandler* CCFScriptHandler::NewLC(

	MCFExtendedContextInterface& aCF,

    RFs& aFs,

    MCFActionHandler& aScriptEventListener,

    MCFSecurityChecker& aSecurityChecker )

    {

    FUNC_LOG;

    CCFScriptHandler* self =

        new( ELeave ) CCFScriptHandler( aCF, aFs, aScriptEventListener,

        aSecurityChecker );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

EXPORT_C CCFScriptHandler::~CCFScriptHandler()

    {

    FUNC_LOG;

    iRollbackList.ResetAndDestroy();

    iLoadedScripts.Close();

    iScripts.ResetAndDestroy();

    iScriptIds.Close();

    delete iParser;

    delete iWaitParsing;

    delete iOperationPluginManager;

    }

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

// CCFScriptHandler::AddScript

// Adds a new script. Calls AddScriptL that does the actual work.

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

//

TInt CCFScriptHandler::AddScript( const TDesC& aName,

    const TDesC8& aScript,

    const TUid& aOwner,

    const RThread& aOwnerThread,

    MCFActionHandler& aActionHandler,

    MCFScriptOwner* aScriptOwner )

    {

    FUNC_LOG;

    TInt err = KErrNone;

    // Check that script with the name does not exist - notice script object

    // ownership is not transfered

    RPointerArray< CCFScript > scripts;

    GetScriptsByUid( aOwner, scripts );

    for( TInt i = 0; i < scripts.Count(); ++i )

        {

        // Compare names only if we are not updating existing script.

        if ( scripts[ i ]->ScriptId() != iNextId )

            {

            TPtrC scriptName( scripts[ i ]->Name() );

            if( scriptName.CompareF( aName ) == KErrNone )

                {

                err = KErrAlreadyExists;

                ERROR_2( err, "Script name %S already in use in client 0x%x",

                    &aName, aOwner );

                break;

                }

            }

        }

    scripts.Close();

    // Add script

    TInt ret = err;

    if( err == KErrNone )

        {

        TRAP( err, ret = AddScriptL( aName,

            aScript,

            aOwner,

            aOwnerThread,

            aActionHandler,

            ETrue,

            aScriptOwner ) );

        if ( err != KErrNone )

            {

            ERROR( ret, "Unable to add script" );

            ret = err;

            }

        }

    // return script Id ( >0 ) or error code if error ( <0 )

    return ret;

    }

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

// CCFScriptHandler::NumberOfScriptsByOwner

//

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

//

TInt CCFScriptHandler::NumberOfScriptsByOwner( const TUid& aOwner )

    {

    FUNC_LOG;

    TInt result( KErrNone );

    // iterate thru all the existing scripts

    for ( TInt i = 0; i < iScripts.Count(); i++  )

        {

        // check if the owner Uid matches

        if ( iScripts[ i ]->OwnerUid() == aOwner )

            {

            // increment script count

            result++;

            }

        }

    return result;

    }

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

// CCFScriptHandler::NumberOfScripts

//

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

//

TInt CCFScriptHandler::NumberOfScripts()

    {

    FUNC_LOG;

    return iScripts.Count();

    }

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

// CCFScriptHandler::ScriptLength

//

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

//

TInt CCFScriptHandler::ScriptLength( TInt aScriptId )

    {

    FUNC_LOG;

    TInt result ( KErrNotFound );

    // iterate thru all the existing scripts

    for ( TInt i = 0; i < iScripts.Count(); i++  )

        {

        // check if the script id matches

        if ( iScripts[ i ]->ScriptId() == aScriptId )

            {

            // get the descriptor length of the script

            result = iScripts[ i ]->Length();

            }

        }

    return result;

    }

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

// CCFScriptHandler::GetEveryScriptId

//

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

//

const RArray< TInt >& CCFScriptHandler::GetEveryScriptId()

    {

    FUNC_LOG;

    // local variable declarations

    TInt err( KErrNone );

    // reset array

    iScriptIds.Reset();

    // go thru all the scripts

    for ( TInt i = 0; i < iScripts.Count(); i++ )

        {

        // add Id to result array

        err = iScriptIds.Append( iScripts[ i ]->ScriptId() );

        // handle error

        if ( err != KErrNone )

            {

            // return what we have created so far

            return iScriptIds;

            }

        }

    return iScriptIds;

    }

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

// CCFScriptHandler::GetEveryScriptIdByOwner

//

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

//

const RArray< TInt >& CCFScriptHandler::GetEveryScriptIdByOwner( 

    const TUid& aScriptOwner )

    {

    FUNC_LOG;

    // local variable declarations

    TInt err( KErrNone );

    // reset array

    iScriptIds.Reset();

    // go thru all the scripts

    for ( TInt i = 0; i < iScripts.Count(); i++ )

        {

        // if the owner Uid matches

        if ( iScripts[ i ]->OwnerUid() == aScriptOwner )

            {

            // add Id to result array

            err = iScriptIds.Append( iScripts[ i ]->ScriptId() );

            // handle error

            if ( err != KErrNone )

                {

                // return what we have created so far

                return iScriptIds;

                }

            }

        }

    return iScriptIds;

    }

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

// CCFScriptHandler::UpdateScript

//

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

//

TInt CCFScriptHandler::UpdateScript( TInt aScriptID, 

	const RThread& aOwnerThread,

    const TDesC8& aUpdatedScript,

    MCFScriptOwner* aScriptOwner )

    {

    FUNC_LOG;

    // local variable declaration & initialization

    TInt err( KErrNotFound );

    TInt index = iScripts.Count() - 1;

    TBool found( EFalse );

    // search for the script

    while ( !found &&    // script not found yet

            index >= 0 ) // still scripts left

        {

        if ( iScripts[ index ]->ScriptId() == aScriptID )

            {

            found = ETrue;

            err = KErrNone;

            break; // skip to not found

            }

        index--;

        }

    // not found

    if ( !found )

        {

        // return immediately with error code

        return err;

        }

    // script found

    else

        {

        // store session and owner Uid temporarily

        MCFActionHandler& scriptSession 

            = ( iScripts[ index ]->ActionHandler() );

        // handle Script Ids correctly

        TInt nextAvailableScriptId = iNextId;

        iNextId = iScripts[ index ]->ScriptId();

        TUid scriptOwner = iScripts[ index ]->OwnerUid();

        // remove found script from array and delete it

        CCFScript* outdatedScript = iScripts [ index ];

        // add the new script; note that the existing script

        // file in filestore is removed automatically

        iUpdatedScript = outdatedScript;

        err = AddScript( outdatedScript->Name(),

            aUpdatedScript,

        	scriptOwner,

        	aOwnerThread,

        	scriptSession,

            aScriptOwner );

        iUpdatedScript = NULL;

        // remove the outdated script only if the new one is succesully added.

        if( err > 0 )

            {

            iScripts.Remove( index );

            delete outdatedScript;

            }

        // restore Next available Script Id

        iNextId = nextAvailableScriptId;

        }

    // script added successfully

    if ( err > 0 )

        {

        err = KErrNone;

        }

    return err;

    }

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

// CCFScriptHandler::SaveScript

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

//

TInt CCFScriptHandler::SaveScript( const TDesC8& aScript,

    TInt aScriptId,

    const TUid& aOwnerUid )

    {

    FUNC_LOG;

    TInt err = KErrNotFound;

    for( TInt i = 0; i < iScripts.Count(); i++ )

        {

        CCFScript* script = iScripts[i];

        // Check script ID

        if( script->ScriptId() == aScriptId )

            {

            // Check script owner

            if( script->OwnerUid() == aOwnerUid ||

                KCFServerSid == aOwnerUid )

                {

                // found matching uid - construct file path

                HBufC* name = ScriptFilePath( script->Info() );

                if( name )

                    {

                    err = DoSave( *name, aScript );

                    }

                else

                    {

                    err = KErrNoMemory;

                    }

                delete name;

                name = NULL;

                break;

                }

            else

                {

                err = KErrAccessDenied;

                }

            }

        }

    return err;

    }

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

// CCFScriptHandler::DeleteScriptByName

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

//

TInt CCFScriptHandler::DeleteScriptByName( const TDesC& aScriptName,

    const TUid& aOwnerUid )

    {

    FUNC_LOG;

    TInt err = KErrNotFound;

    // Get script name

    TParsePtrC parse( aScriptName );

    TPtrC scriptName( parse.Name() );

    // Get scripts added by the owner

    RPointerArray<CCFScript> scripts;

    GetScriptsByUid( aOwnerUid, scripts );

    // If the script being deleted has already been deregistered, try to resolve

    // the script path from the script name and owner uid

    if( scripts.Count() )

        {

        for( TInt i = 0; i < scripts.Count(); i++ )

            {

            CCFScript* script = scripts[i];

            if( script->Name().CompareF( scriptName ) == KErrNone )

                {

                // correct owner uid - delete script

                HBufC* name = ScriptFilePath( script->Info() );

                if( name )

                    {

                    // Delete script file

                    TPtrC namePtrC( *name );

                    err = DeleteScriptFile( namePtrC, aOwnerUid );

                    }

                else

                    {

                    err = KErrNoMemory;

                    }

                delete name;

                name = NULL;

                break;

                }

            }

        }

    // Check manually from the system drive if the script was not found

    if( err == KErrNotFound )

        {

        // Resolve script name from owner uid and script name

        HBufC* name = ScriptFilePath( scriptName, aOwnerUid );

        if( name )

            {

            // Delete script file

            TPtrC namePtrC( *name );