/*
* 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:  Implementation of RemoteLock Settings API
*
*/



// INCLUDE FILES 
#include <RemoteLockSettings.h>
#include <hash.h>
#include <centralrepository.h>
#include "RemoteLockPrivateCRKeys.h"
#include "RemoteLockTrace.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS
_LIT( KRLockLeadingHexZero, "0" );

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS


// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CRemoteLockSettings::NewL
// Two-Phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CRemoteLockSettings* CRemoteLockSettings::NewL( 
    MRemoteLockSettingsHandler* aHandler )
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] NewL() ");
    
    CRemoteLockSettings* self = CRemoteLockSettings::NewLC( aHandler );
         
    CleanupStack::Pop( self );
    RL_TRACE_PRINT(" [ rlsetting.dll ] exit NewL() ");
    return self;
    }


// -----------------------------------------------------------------------------
// CRemoteLockSettings::NewLC
// Two-Phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CRemoteLockSettings* CRemoteLockSettings::NewLC( 
    MRemoteLockSettingsHandler* aHandler )
    {
    
    CRemoteLockSettings* self = new ( ELeave ) CRemoteLockSettings( aHandler );
    
    CleanupStack::PushL( self );
    
    self->ConstructL();
    return self;
    }


// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
EXPORT_C CRemoteLockSettings::~CRemoteLockSettings()
    {
    if ( iNotifyHandler )
        {
        iNotifyHandler->StopListening();
        delete iNotifyHandler;
        }

    delete iSession;
    }


// ----------------------------------------------------------------------
// CRemoteLockSettings::GetLockCode
// Gets remote lock code
// Returns: ETrue
//          EFalse  
// ----------------------------------------------------------------------
//
EXPORT_C TBool CRemoteLockSettings::GetLockCode( TDes& aLockCode ) const                                               
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] Getlockcode() ");
    TInt err = iSession->Get( KRLLockCode, aLockCode ); 
    RL_TRACE_PRINT(" [ rlsetting.dll ] exit Getlockcode() ");   
    return ( err == KErrNone );
    }


// ----------------------------------------------------------------------
// CRemoteLockSettings::GetLockCode
// Gets remote lock code and trimmed remote lock code
// Returns: ETrue
//          EFalse  
// ----------------------------------------------------------------------
//
EXPORT_C TBool CRemoteLockSettings::GetLockCode( 
    TDes& aLockCode, 
    TDes& aLockCodeTrimmed ) const 
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] Getlockcode() ");
    TInt err = iSession->Get( KRLLockCode, aLockCode );    
    
    if ( err != KErrNone )
        {
        return EFalse;
        }
    
    err = iSession->Get( KRLLockCode2, aLockCodeTrimmed );
    
    if ( err == KErrNone )
        {
        RL_TRACE_PRINT(" [ rlsetting.dll ] exit Getlockcode() noError");
        return ETrue;
        }
    else
        {
        RL_TRACE_PRINT(" [ rlsetting.dll ] exit Getlockcode() Error");
        return EFalse;
        }
    }


// -----------------------------------------------------------------------------
// CRemoteLockSettings::SetEnabled
// Enables and sets remote lock code
// Returns   ETrue
//           EFalse  
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CRemoteLockSettings::SetEnabledL( const TDesC& aLockCode )
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] SetEnabledL() ");
    if ( aLockCode.Length() > KRLockMaxLockCodeLength )
       {
       return EFalse;
       }  
       
    // Creates MD5 object.
    CMD5* hash = CMD5::NewL();
    CleanupStack::PushL( hash );

    TBuf<KRLockMaxLockCodeLength> tempBuf;
    tempBuf = aLockCode;
       
    HBufC8* hashBuf = HBufC8::NewLC( KRLockMaxLockCodeLength * 2 );        
    TPtr8 tempPtr = hashBuf->Des();
    tempPtr.Copy( tempBuf );
       
    // Calculate the digest.
    TPtrC8 hashPtr = hash->Hash( *hashBuf );
    HBufC* storeBuf = HBufC::NewLC( hash->HashSize());     
    storeBuf->Des().Copy( hashPtr );

       // Convert digest into hexadecimal representation
    HBufC* hexStoreBuf = HBufC::NewLC( storeBuf->Length() * 2);
    TBuf<2> singleHex;
    TInt i = 0;
    for ( i = 0; i < storeBuf->Length(); i++ )
        {
        singleHex.Num( storeBuf->Des()[i], EHex );
        if ( singleHex.Length() == 1 )
            hexStoreBuf->Des().Append( KRLockLeadingHexZero );
        hexStoreBuf->Des().Append( singleHex );
        }
       
    // Saves the digest into repository file.
    TInt err = 0;
    err = iSession->Set( KRLLockCode, *hexStoreBuf );
       
    if ( err != KErrNone )
        {
        CleanupStack::PopAndDestroy( 4 ); 
        return EFalse;
        }
        
     // Then process the trimmed password the same way.
    tempBuf.TrimAll();
    tempPtr.Copy( tempBuf );
    // Calculate the digest.
    hash->Reset();
    TPtrC8 hashPtr1 = hash->Hash( *hashBuf );
    storeBuf->Des().Copy( hashPtr1 );
    // Convert digest into hexadecimal representation
    hexStoreBuf->Des().Zero();
    for ( i = 0; i < storeBuf->Length(); i++ )
        {
        singleHex.Num( storeBuf->Des()[i], EHex );
        if ( singleHex.Length() == 1 )
            hexStoreBuf->Des().Append( KRLockLeadingHexZero );
        hexStoreBuf->Des().Append( singleHex );
        }
        
    // Saves the digest into ini file.
    err = iSession->Set( KRLLockCode2, *hexStoreBuf );
        
    if ( err != KErrNone )
        {
        RL_TRACE_PRINT(" [ rlsetting.dll ] SetenabledL() exit Error ");
        CleanupStack::PopAndDestroy( 4 );
        return EFalse;
        }
    
    err = iSession->Set( KRLEnable, 1 );
        
    if ( err != KErrNone )
        {
        RL_TRACE_PRINT(" [ rlsetting.dll ] SetenabledL() exit Error ");
        CleanupStack::PopAndDestroy( 4 );
        return EFalse;
        }
    RL_TRACE_PRINT(" [ rlsetting.dll ] SetenabledL() exit no Error ");
    CleanupStack::PopAndDestroy( 4 );//MD5, 3 Heap buffer
    return ETrue;
    }


// -----------------------------------------------------------------------------
// CRemoteLockSettings::SetDisabled
// Disables remote lock
// Returns   ETrue
//           EFalse  
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CRemoteLockSettings::SetDisabled()
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] SetDisabled() ");
    TInt err;
    err = iSession->Set( KRLEnable, 0 );
    RL_TRACE_PRINT(" [ rlsetting.dll ] exit SetDisabled() ");
    return ( err == KErrNone );
    }

// -----------------------------------------------------------------------------
// CRemoteLockSettings::GetEnabled
// Returns whether remote lock is enabled or disabled
// Returns    ETrue
//            EFalse  
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CRemoteLockSettings::GetEnabled( TBool& aEnable ) const
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] GetEnabled() ");  
    TInt err;
    err = iSession->Get( KRLEnable, aEnable );
    RL_TRACE_PRINT(" [ rlsetting.dll ] Exit GetEnabled() ");
    return ( err == KErrNone );
    }
    
   
// -----------------------------------------------------------------------------
// CRemoteLockSettings::CompareLockCodes
// Compares the given remote lock code to the stored one.
// Returns   ETrue
//           EFalse  
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CRemoteLockSettings::CompareLockCodesL( 
    const TDesC& aLockCode, 
    const TDesC& aCorrectLockCode ) const
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] CompareLockCodesL() ");
    if ( aLockCode.Length() > KRLockMaxLockCodeLength || 
        aCorrectLockCode.Length() > KRLockStoredLockCodeLength )
        {
        RL_TRACE_PRINT(" [ rlsetting.dll ] exit CompareLockCodeL() lockcode length is illegal ");
        return EFalse;
        }

    // Creates MD5 object.
    CMD5* hash = CMD5::NewL();
    CleanupStack::PushL( hash );

    HBufC8* hashBuf = HBufC8::NewLC( KRLockMaxLockCodeLength * 2 );
    TPtr8 tempPtr = hashBuf->Des();
    tempPtr.Copy( aLockCode );

    // Hashes data.
    TPtrC8 hashPtr = hash->Hash( *hashBuf );

    HBufC* lockCode = HBufC::NewLC( hash->HashSize() );

    // Copies hashPtr to lockCode.
    lockCode->Des().Copy( hashPtr );

    // Convert digest into hexadecimal representation
    HBufC* hexLockCode = HBufC::NewLC( lockCode->Length() * 2);
    TBuf<2> singleHex;
    for ( TInt i = 0; i < lockCode->Length(); i++ )
        {
        singleHex.Num( lockCode->Des()[i], EHex );
        if ( singleHex.Length() == 1 )
            hexLockCode->Des().Append( KRLockLeadingHexZero );
        hexLockCode->Des().Append( singleHex );
        }

    RL_TRACE_PRINT(" [ rlsetting.dll ] CompareLockCodeL() compare ");
    if ( hexLockCode->Compare( aCorrectLockCode ) == 0 )
        {
        // When two hash results matches each other.
        RL_TRACE_PRINT(" [ rlsetting.dll ] ComparelockcodeL() match ");
        CleanupStack::PopAndDestroy( 4 );
        return ETrue;
        }
    else
        {
        RL_TRACE_PRINT(" [ rlsetting.dll ] CompareLockCodeL() dismatch ");
        CleanupStack::PopAndDestroy( 4 );
        return EFalse;
        }
    }


// -----------------------------------------------------------------------------
// CRemoteLockSettings::RemoteLockNotifyL
// Setup RemoteLock notifier
// Returns:   ETrue
//            EFalse
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CRemoteLockSettings::RemoteLockNotifyL( 
    const TBool aNotifyEnable ) 
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] RemotelockNotifyL() ");
    if ( !iNotifyHandler )
        {
        iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iSession ); 
        }

    if ( aNotifyEnable )
        {
        iNotifyHandler->StartListeningL();  
        }
    else
        {
        iNotifyHandler->StopListening();
        }
    RL_TRACE_PRINT(" [ rlsetting.dll ] exit RemotelockNotifyL() ");
    return ETrue;
    }

// ----------------------------------------------------------------------------
// CRemoteLockSettings::CRemoteLockSettings
// default constructor
// ----------------------------------------------------------------------------
CRemoteLockSettings::CRemoteLockSettings( MRemoteLockSettingsHandler* aHandler ) 
    {    
    iHandler = aHandler;
    } 
    
      
// -----------------------------------------------------------------------------
// CRemoteLockSettings::ConstructL
// Symbian 2nd phase constructor can leave
//------------------------------------------------------------------------------
//
void CRemoteLockSettings::ConstructL()
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] ConstructL() ");  
    iSession = CRepository::NewL( KCRUidRemoteLock ); 
    RL_TRACE_PRINT(" [ rlsetting.dll ] exit ConstructL() ");
    }
    

// -----------------------------------------------------------------------------
// CRemoteLockSettings::HandleNotifyGeneric
// Notify handler
//
// -----------------------------------------------------------------------------
//
void CRemoteLockSettings::HandleNotifyGeneric( 
    TUint32 /*aId*/ ) 
    {
    RL_TRACE_PRINT(" [ rlsetting.dll ] HandleNotifyGeneric() ");
    TRAPD( error, iHandler->HandleRemoteLockNotifyL() );
    error = error;
    RL_TRACE_PRINT(" [ rlsetting.dll ] exit HandleNotifyGeneric() ");
    }