/*

* Copyright (c) 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:  SW Installer DM Adapter.

*

*/

// INCLUDE

#include <implementationproxy.h>

#include <smldmadapter.h>

#include <data_caging_path_literals.hrh>

#include <centralrepository.h>

#include <hwrmpowerstatesdkpskeys.h> // For power state

#include <DevEncExternalCRKeys.h>

#include <DevEncDef.h>

#include "DevEncLog.h" 

#include "DevEncAdapter.h"

#include "DevEncUids.hrh"

// CONSTANTS

_LIT8( KIntType,"int" ); // Leaf inputs

_LIT8( KTextType,"text/plain" ); // Leaf inputs

_LIT8( KDevEncAdapterVersion, "1.0" ); // Adapter version

_LIT8( KDevEncRootNode, "DevEnc" ); // root URI

_LIT8( KPhoneMemoryCmdNode, "PhoneMemoryCmd" ); // URI postfix

_LIT8( KMemoryCardCmdNode, "MemoryCardCmd" ); // URI postfix

_LIT8( KPhoneMemoryStatusNode, "PhoneMemoryStatus" ); // URI postfix

_LIT8( KMemoryCardStatusNode, "MemoryCardStatus" ); // URI postfix

_LIT8( KMemoryCardEncKeyNode, "MemoryCardEncKey" ); // URI postfix

_LIT8( KUIStateNode, "UIState" ); // URI postfix

_LIT8( KPhoneMemoryProgNode, "PhoneMemoryProgress" ); // URI postfix

_LIT8( KMemoryCardProgNode, "MemoryCardProgress" ); // URI postfix

_LIT8( KPhoneMemoryCmdDescription, "Phone memory encryption command" ); // Description

_LIT8( KMemoryCardCmdDescription, "Memory card encryption command" ); // Description

_LIT8( KPhoneMemoryStatusDescription, "Phone memory encryption status" ); // Description

_LIT8( KMemoryCardStatusDescription, "Memory card encryption status" ); // Description

_LIT8( KMemoryCardEncKeyDescription, "Memory card encryption key" ); // Description

_LIT8( KUIStateDescription, "State of encryption settings" ); // Description

_LIT8( KPhoneMemoryProgDescription, "En/Decryption progress in percents (phone)" ); // Description

_LIT8( KMemoryCardProgDescription, "En/Decryption progress in percents (memory card)" ); // Description

_LIT8( KSeparator, "/" );

static const TUint32 KSizeOfSettingId = 16; // Contanst size declaration

static const TInt KBufGranularity = 8;

static const TDriveNumber KPhoneMemoryDriveNum = EDriveC;

static const TDriveNumber KMemoryCardDriveNum = EDriveF;

static const TUid KPSCategory = { 0x101F9A02 }; // DM client SID

static const TInt KPkcs5PSKey = KDevEncOmaDmPluginImplUid;

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

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

// CDevEncAdapter::NewL

// Symbian 1st phase contructor

// (static, may leave)

// Status : Draft

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

//

CDevEncAdapter* CDevEncAdapter::NewL( MSmlDmCallback* aCallback )

    {

    CDevEncAdapter* self = NewLC( aCallback );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDevEncAdapter::NewLC

// Symbian 1st phase contructor. Push object to cleanup-stack

// (static, may leave)

// Status : Draft

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

//

CDevEncAdapter* CDevEncAdapter::NewLC( MSmlDmCallback* aCallback )

    {

    CDevEncAdapter* self = new ( ELeave ) CDevEncAdapter( aCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CDevEncAdapter::CDevEncAdapter()

// C++ Constructor

// Status : Draft

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

CDevEncAdapter::CDevEncAdapter( TAny* aEcomArguments )

    : CSmlDmAdapter::CSmlDmAdapter( aEcomArguments ),

        iPhoneMemOpPending( EFalse ),

        iMemCardOpPending( EFalse )

    {

    DFLOG( "CDevEncAdapter Constructor" );

    }

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

// CDevEncAdapter::ConstructL

// 2nd phase contructor

// (may leave)

// Status : Draft

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

//

void CDevEncAdapter::ConstructL()

    {

    DFLOG( "CDevEncAdapter::ConstructL Begin" );

    iDiskUtils = new (ELeave) CDevEncDiskUtils();

    iKeyUtils  = new (ELeave) CDevEncKeyUtils();

    iPhoneMemorySession = new (ELeave) CDevEncSession( KPhoneMemoryDriveNum );

    iMemoryCardSession  = new (ELeave) CDevEncSession( KMemoryCardDriveNum );

    User::LeaveIfError(iPhoneMemorySession->Connect());

    User::LeaveIfError(iMemoryCardSession->Connect());

    iTimer.CreateLocal();

    iUiCenRep = CRepository::NewL( TUid::Uid( KCRDevEncUiSettings ) );

    DFLOG( "CDevEncAdapter::ConstructL End" );

    }

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

// CDevEncAdapter::~CDevEncAdapter()

// C++ Destructor

// Status : Draft

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

//

CDevEncAdapter::~CDevEncAdapter()

    {

    DFLOG( "CDevEncAdapter Destructor Begin" );

    if (iDiskUtils)

        {

        delete iDiskUtils;

        iDiskUtils = NULL;

        }

    if (iKeyUtils)

        {

        delete iKeyUtils;

        iKeyUtils = NULL;

        }

    if (iPhoneMemorySession)

        {

        iPhoneMemorySession->Close();

        delete iPhoneMemorySession;

        iPhoneMemorySession = NULL;

        }

    if (iMemoryCardSession)

        {

        iMemoryCardSession->Close();

        delete iMemoryCardSession;

        iMemoryCardSession = NULL;

        }

    if ( iPkcs5Key )

        {

        delete iPkcs5Key;

        iPkcs5Key = NULL;

        }

    if (iTimer.Handle())

        iTimer.Close();

    if (iUiCenRep)

        {

        delete iUiCenRep;

        iUiCenRep = NULL;

        }

    DFLOG( "CDevEncAdapter Destructor End" );

    }

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

// CDevEncAdapter::DDFVersionL

// Return DM plug-in version

// (may leave)

// Status : Draft

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

//

void CDevEncAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {

    // Insert version information

    DFLOG( "CDevEncAdapter::DDFVersionL Begin" );

    aDDFVersion.InsertL( 0, KDevEncAdapterVersion );

    DFLOG( "CDevEncAdapter::DDFVersionL End" );

    }

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

// CDevEncAdapter::DDFStructureL

// Return DM plug-in structure

// (may leave)

// Status : Draft

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

//

void CDevEncAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    // Declare accesses

    DFLOG( "CDevEncAdapter::DDFStructureL Begin" );

    TSmlDmAccessTypes accessTypes;

    accessTypes.SetGet();

    // Create root node 

    MSmlDmDDFObject& root = aDDF.AddChildObjectL( KDevEncRootNode );

    FillNodeInfoL( root,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::ENode,

                   MSmlDmDDFObject::EOne,

                   KNullDesC8(),

                   KNullDesC8() );

    // Create leaf nodes

    accessTypes.Reset();

    accessTypes.SetReplace(); // Command nodes are write-only

    MSmlDmDDFObject& node1 = root.AddChildObjectL( KPhoneMemoryCmdNode );

    FillNodeInfoL( node1,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EInt,

                   MSmlDmDDFObject::EOne,

                   KPhoneMemoryCmdDescription,

                   KIntType );

    MSmlDmDDFObject& node2 = root.AddChildObjectL( KMemoryCardCmdNode );

    FillNodeInfoL( node2,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EInt,

                   MSmlDmDDFObject::EOne,

                   KMemoryCardCmdDescription,

                   KIntType );

    accessTypes.Reset();

    accessTypes.SetGet(); // Status nodes are read-only

    MSmlDmDDFObject& node3 = root.AddChildObjectL( KPhoneMemoryStatusNode );

    FillNodeInfoL( node3,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EInt,

                   MSmlDmDDFObject::EOne,

                   KPhoneMemoryStatusDescription,

                   KIntType );

    MSmlDmDDFObject& node4 = root.AddChildObjectL( KMemoryCardStatusNode );

    FillNodeInfoL( node4,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EInt,

                   MSmlDmDDFObject::EOne,

                   KMemoryCardStatusDescription,

                   KIntType );

    accessTypes.SetReplace();

    MSmlDmDDFObject& node5 = root.AddChildObjectL( KMemoryCardEncKeyNode );

    FillNodeInfoL( node5,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EB64,

                   MSmlDmDDFObject::EOne,

                   KMemoryCardEncKeyDescription,

                   KTextType );

    MSmlDmDDFObject& node6 = root.AddChildObjectL( KUIStateNode );

    FillNodeInfoL( node6,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EInt,

                   MSmlDmDDFObject::EOne,

                   KUIStateDescription,

                   KIntType );

    accessTypes.Reset();

    accessTypes.SetGet(); // Progress nodes are read-only

    MSmlDmDDFObject& node7 = root.AddChildObjectL( KPhoneMemoryProgNode );

    FillNodeInfoL( node7,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EInt,

                   MSmlDmDDFObject::EOne,

                   KPhoneMemoryProgDescription,

                   KIntType );

    MSmlDmDDFObject& node8 = root.AddChildObjectL( KMemoryCardProgNode );

    FillNodeInfoL( node8,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::EInt,

                   MSmlDmDDFObject::EOne,

                   KMemoryCardProgDescription,

                   KIntType );

    DFLOG( "CDevEncAdapter::DDFStructureL End" );

    }

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

// CDevEncAdapter::StreamingSupport

// Return streaming support status, set supported item size

// Status : Draft

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

//

TBool CDevEncAdapter::StreamingSupport( TInt& /* aItemSize */ )

    {

    // Not supported

    DFLOG( "CDevEncAdapter::StreamingSupport" );

    return EFalse;

    }

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

// CDevEncAdapter::StreamCommittedL

// Commit stream buffer

// (may leave)

// Status : Draft

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

//

void CDevEncAdapter::StreamCommittedL()

    {        

    DFLOG( "CDevEncAdapter::StreamCommitted" );

    // Intentionally left empty 

    }

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

// CDevEncAdapter::CompleteOutstandingCmdsL

// Complete outstanding commands

// (may leave)

// Status : Draft

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

//

void CDevEncAdapter::CompleteOutstandingCmdsL()

    {

    DFLOG( "CDevEncAdapter::CompleteOutstandingCmdsL Begin" );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    TInt status;

    TRequestStatus reqStatus;

    TBool pending = ( iPhoneMemOpPending || iMemCardOpPending );

    DFLOG2( "CDevEncAdapter: pending %d", ( pending ? 1 : 0 ) );

    if ( iPhoneMemOpPending )

        {

        iPhoneMemOpPending = EFalse;

        DFLOG2( "CDevEncAdapter: iPendingCommand %d", iPendingCommand );

        switch ( iPendingCommand )

            {           

            case EDmDecrypt:

                iPhoneMemorySession->DiskStatus( status );

                if ( status == EEncrypted )

                    {

                    DFLOG( "CDevEncAdapter: phone memory decrypt" );

                    iPhoneMemorySession->StartDiskDecrypt();

                    }

                else

                    {

                    DFLOG2( "CDevEncAdapter: Cannot decrypt, phone mem status %d",

                            status );

                    retValue =  CSmlDmAdapter::EError;

                    }

                break;

            case EDmEncryptDefault:

                iPhoneMemorySession->DiskStatus( status );

                if ( status == EDecrypted )

                    {

                    // if FOTA couldn't be disabled then the encryption cannot be performed

                    if( retValue != CSmlDmAdapter::EError )

                    	{

                    	DFLOG( "CDevEncAdapter: phone memory encrypt" );

                        iPhoneMemorySession->StartDiskEncrypt();

                    	}

                    }

                else

                    {

                    DFLOG2( "CDevEncAdapter: Cannot encrypt, phone mem status %d",

                            status );

                    retValue = CSmlDmAdapter::EError;

                    }

                break;

            default:

                // Unknown or not valid command for phone memory

                DFLOG2( "CDevEncAdapter: Invalid command %d",

                        iPendingCommand );

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

            }

        }

    if ( iMemCardOpPending )

        {

        iMemCardOpPending = EFalse;

        switch ( iPendingCommand )

            {

            case EDmDecrypt:

                iMemoryCardSession->DiskStatus( status );

                if ( status == EEncrypted )

                    {

                    DFLOG( "CDevEncAdapter: memory card decrypt" );

                    TInt opStatus = iMemoryCardSession->StartDiskDecrypt();

                    }

                else

                    {

                    DFLOG2( "CDevEncAdapter: Cannot decrypt, card status %d",

                            status );

                    retValue =  CSmlDmAdapter::EError;

                    }

                break;

            case EDmEncryptRestore:

            case EDmEncryptBackup:

                iMemoryCardSession->DiskStatus( status );

                if ( status == EDecrypted )

                    {                  

                    HBufC8* passwd = AskPassWordL();

                    if ( iPendingCommand == EDmEncryptBackup )

                        {

                        DFLOG( "CDevEncAdapter: memory card backup" );

                        _LIT_SECURITY_POLICY_S0( KPSSecurityPolicy, KPSCategory.iUid );

                        RProperty::Define( KPkcs5PSKey,

                                           RProperty::EByteArray,

                                           KPSSecurityPolicy,

                                           KPSSecurityPolicy );

                        iKeyUtils->CreateSetKey( reqStatus,

                                                 iPkcs5Key,

                                                 *passwd,

                                                 KEncryptionKeyLength );

                        User::WaitForRequest( reqStatus );

                        User::LeaveIfError( reqStatus.Int() );

                        TInt ret = RProperty::Set( KPSCategory,

                                                   KPkcs5PSKey,

                                                   *iPkcs5Key );

                        if ( ret != KErrNone )

                            {

                            DFLOG2( "CDevEncAdapter: Error storing key: %d", ret );

                            User::Leave( ret );

                            }

                        }

                    else if ( iPendingCommand == EDmEncryptRestore )

                        {

                        DFLOG( "CDevEncAdapter: memory card restore" );

                        iKeyUtils->SetKey( reqStatus, *iPkcs5Key, *passwd );

                        User::WaitForRequest( reqStatus );

                        DFLOG2( "CDevEncAdapter::CompleteOutstandingCmdsL: \

                                    SetKey: %d", reqStatus.Int() );

                        User::LeaveIfError( reqStatus.Int() );

                        }

                    DFLOG( "CDevEncAdapter: memory card encrypt" );

                    TInt opStatus = iMemoryCardSession->StartDiskEncrypt();

                    delete passwd;

                    passwd = NULL;

                    }

                else

                    {

                    DFLOG2( "CDevEncAdapter: Cannot encrypt, card status %d",

                            status );

                    retValue = CSmlDmAdapter::EError;

                    }

                break;

            case EDmEncryptDefault:

                iMemoryCardSession->DiskStatus( status );

                if ( status == EDecrypted )

                    {

                    DFLOG( "CDevEncAdapter: memory card encrypt" );

                    TInt opStatus = iMemoryCardSession->StartDiskEncrypt();

                    }

                else

                    {

                    DFLOG2( "CDevEncAdapter: Cannot encrypt, card status %d",

                            status );

                    retValue = CSmlDmAdapter::EError;

                    }

                break;

            default:

                // Unknown or not valid command for memory card

                DFLOG2( "CDevEncAdapter: Invalid command %d",

                        iPendingCommand );

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

            }

        }

    if ( pending )

        {

        Callback().SetStatusL( iStatusRef, retValue );

        }

    DFLOG( "CDevEncAdapter::CompleteOutstandingCmdsL End" );

    }

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

// CDevEncAdapter::FillNodeInfoL

// Fill node info

// (may leave)

// Status : Draft

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

//

void CDevEncAdapter::FillNodeInfoL( MSmlDmDDFObject& aDDFObject, 

                                    TSmlDmAccessTypes& aAccessTypes, 

                                    MSmlDmDDFObject::TScope aScope,

                                    MSmlDmDDFObject::TDFFormat aFormat, 

                                    MSmlDmDDFObject::TOccurence aOccurence,

                                    const TDesC8& aDescription,

                                    const TDesC8& aMIMEType )

    {

    DFLOG( "CDevEncAdapter::FillNodeInfoL Begin" );

    aDDFObject.SetAccessTypesL( aAccessTypes );

    aDDFObject.SetScopeL( aScope );

    aDDFObject.SetOccurenceL( aOccurence );

    aDDFObject.SetDFFormatL( aFormat );

    aDDFObject.SetDescriptionL( aDescription );

    if ( aFormat != MSmlDmDDFObject::ENode )

        {

        aDDFObject.AddDFTypeMimeTypeL( aMIMEType );

        }

    DFLOG( "CDevEncAdapter::FillNodeInfoL End" );

    }

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

// CDevEncAdapter::CopyCommandL

// Copy object

// (may leave)

// Status : Draft

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

//

void CDevEncAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/,