/*

* Copyright (c) 2005-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:   Implementation of the CSecModUIModel class

*

*/

#include <unifiedkeystore.h>

#include <mctauthobject.h>

#include <mctkeystore.h>

#include <securityerr.h>

#include <qvector.h>

#include <qpair.h>

#include <qlabel.h>

#include <qerrormessage.h>

#include <qstring.h>

#include <hbmessagebox.h>

#include "cpsecmodmodel.h"

#include "cpsecmodsyncwrapper.h"

const TInt KWIMStoreUid ( 0x101F79D9 );

_LIT(KSecModUIPanic, "Security Module UI panic");

// ============================= LOCAL FUNCTIONS ===============================

GLDEF_C void Panic(TInt aPanic)

  {

  User::Panic(KSecModUIPanic, aPanic);

  }

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

// CSecModUIModel::NewL()

// Two-phased constructor.

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

//

CSecModUIModel* CSecModUIModel::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CSecModUIModel::CSecModUIModel

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

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

//

CSecModUIModel::CSecModUIModel()

    {}

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

// CSecModUIModel::~CSecModUIModel

// C++ destructor

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

//

CSecModUIModel::~CSecModUIModel()

    {

    delete iWrapper;

    ResetAndDestroyCTObjects();

    }

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

// CSecModUIModel::ResetAndDestroyCTObjects(): Cleans up all objects referenced

// through the crypto token framework.

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

//

void CSecModUIModel::ResetAndDestroyCTObjects()

    {

    ResetAndDestroyAOs();

    iAOKeyStores.Reset();

    delete iUnifiedKeyStore;

    iUnifiedKeyStore = NULL;

    iKeyStore = NULL;

    }

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

// CSecModUIModel::ResetAndDestroyAOs(): Cleans up the list of auth objects.

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

//

void CSecModUIModel::ResetAndDestroyAOs()

    {

    if (iAOList)

        {

        iAOList->Release();

        iAOList = NULL;

        }

    if (iAOArray.Count() > 0 &&

        iAOArray[0]->Token().TokenType().Type().iUid == KTokenTypeFileKeystore)

        {

        iAOArray.Reset();

        }

    else

        {

        iAOArray.Close();

        }

    }

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

// CSecModUIModel::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CSecModUIModel::ConstructL()

    {

    InitializeKeyStoreL();

    }

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

// CSecModUIModel::InitializeKeyStoreL()

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

//

void CSecModUIModel::InitializeKeyStoreL()

    {

    ResetAndDestroyCTObjects();

    // Ensure that file server session is succesfully created

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

    iUnifiedKeyStore = CUnifiedKeyStore::NewL(iRfs);

    if (iWrapper == NULL)

        {

        iWrapper = CSecModUISyncWrapper::NewL();

        }

    TInt err = iWrapper->Initialize(*iUnifiedKeyStore);

    ShowErrorNote(err);

    if (KErrNone != err && KErrHardwareNotAvailable != err)

        {

        User::Leave(err);

        }

    TInt keyStoreCount = iUnifiedKeyStore->KeyStoreCount();

    if (0 >= keyStoreCount)

        {

        return;

        }

    RMPointerArray<CCTKeyInfo> keyInfos;

    CleanupClosePushL(keyInfos);

    TCTKeyAttributeFilter filter;

    TInt keyInfoCount = 0;

    filter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;

    for (TInt i = 0; i < keyStoreCount; i++)

        {

		err = iWrapper->ListKeys(iUnifiedKeyStore->KeyStore(i), keyInfos, filter);

		User::LeaveIfError(err);

        //If list ok, append the AO, otherwise go next

		keyInfoCount = keyInfos.Count();

		for (TInt j = 0; j < keyInfoCount; j++)

			{

			// Check that keystore has at least one AO.

			if (NULL != keyInfos[j]->Protector())

				{

				// If keystore has AO, add it to the array.

				User::LeaveIfError(

					iAOKeyStores.Append(&(iUnifiedKeyStore->KeyStore(i))));

				break;

				}

			}     

        }

    CleanupStack::PopAndDestroy(&keyInfos);

    }

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

// CSecModUIModel::LoadTokenLabelsL()

// Retrieves the description and location of all tokens.

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

//

QMap<QString,QString> CSecModUIModel::LoadTokenLabelsL()

    {

    TInt keyStoreCount = iAOKeyStores.Count();

    QMap<QString, QString> labelList;

    if (0 == keyStoreCount)

        {

        return labelList;

        }

    for (TInt i = 0; i < keyStoreCount; i++)

        {

		QString keystoreLabel = 0;

        if (iAOKeyStores[i]->Token().TokenType().Type().iUid == KTokenTypeFileKeystore )

            {

			keystoreLabel = "Phone keystore";

            }

        else if(iAOKeyStores[i]->Token().TokenType().Type().iUid == KWIMStoreUid )

            {                

			const TDesC& label = iAOKeyStores[i]->Token().Label();

			keystoreLabel = QString( (QChar*) label.Ptr(), label.Length());

            }

        else

        	{

			continue;

        	}

         QString location = Location(iAOKeyStores[i]->Token().TokenType().Type());

        labelList.insert(keystoreLabel,location);

        }

    return labelList;

    }

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

// CSecModUIModel::Location() 

// Identifies the location of the keystore based on the Uid.

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

//

QString CSecModUIModel::Location( TUid aUid ) const

    {

    QString location = 0;

    switch ( aUid.iUid )

        {

        case KTokenTypeFileKeystore:

            {

            location = "\nPhone memory";

            break;

            }

        case KWIMStoreUid:

            {

            location = "\nSmart card";

            break;

            }

        default:

            {

            break;

            }

        }

    return location;

    }

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

// CSecModUIModel::ShowErrorNote(TInt aError) const

// Displays appropriate error message based on the error code.

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

//

void CSecModUIModel::ShowErrorNote(TInt aError) const

    {

	QString sError;

    switch (aError)

        {

        case KErrCancel:

        case KErrLocked:

        case KErrNone:

            {

            break;

            }

        case KErrInUse:

            {

            sError = "Key is currently in use. Unable to delete. Close applications and try again.";

            break;

            }

        case KErrBadPassphrase:

            {

            sError = "Code incorrect";

            break;

            }

        case KErrHardwareNotAvailable: // flow thru

        default:

            {

            sError = "Security module internal error";

            break;

            }

        }

    if ( sError.length() != 0 )

		{

		HbMessageBox::information(sError);

		}

    }

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

// CSecModUIModel::OpenTokenL(TInt aTokenIndex)

// Retrieves the appropriate token based on the index.

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

//

void CSecModUIModel::OpenTokenL(TInt aTokenIndex)

    {

    ResetAndDestroyAOs();

    iKeyStore = iAOKeyStores[aTokenIndex];

    }

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

// CSecModUIModel::CheckCodeViewStringsL()

// Initialize the auth objects and return the total count.

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

//

TInt CSecModUIModel::CheckCodeViewStringsL()

    {

    InitAuthObjectsL();

    ListAuthObjectsL();

    return iAOArray.Count();

    }

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

// CSecModUIModel::InitAuthObjectsL()

// Retrieve the authentication object associated with the appropriate key store 

// implementation.

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

//

void CSecModUIModel::InitAuthObjectsL()

    {

    TInt err = KErrNone;

    // Symbian's file key store does not support

    // MCTAuthenticationObjectList interface, so we need to use

    // other way to get AO.

    if (iKeyStore->Token().TokenType().Type().iUid == KTokenTypeFileKeystore)

        {

        if (iAOArray.Count()==0)

            {

            RMPointerArray<CCTKeyInfo> keyInfos;

            CleanupClosePushL(keyInfos);

            TCTKeyAttributeFilter filter;

            TInt keyInfoCount = 0;

            filter.iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;

            err = iWrapper->ListKeys(*iKeyStore, keyInfos, filter);

            ShowErrorNote(err);

            User::LeaveIfError(err);

            keyInfoCount = keyInfos.Count();

            for (TInt j = 0; j < keyInfoCount; j++)

                {

                // Check that keystore has at least one AO.

                if (NULL != keyInfos[j]->Protector())

                    {

                    // If keystore has AO, add it to the array.

                    User::LeaveIfError(iAOArray.Append(keyInfos[j]->Protector()));

                    break;

                    }

                }

            CleanupStack::PopAndDestroy(&keyInfos);  //keyInfos

            }

        }

    else

        {

        if (NULL == iAOList)

            {

            MCTTokenInterface* tokenInterface = NULL;

            err = iWrapper->GetAuthObjectInterface(

                iKeyStore->Token(), tokenInterface);

            if ( KErrNone != err || NULL == tokenInterface )

                {

                ShowErrorNote(err);

                User::Leave(err);

                }

            iAOList = (MCTAuthenticationObjectList*)tokenInterface;

            }

        }

    }

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

// CSecModUIModel::ListAuthObjectsL()

// list the auth objects.

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

//

void CSecModUIModel::ListAuthObjectsL()

    {

    if (0 >= iAOArray.Count())

        {

        __ASSERT_ALWAYS(iAOList, Panic(EPanicNullPointer));

        TInt err = iWrapper->ListAuthObjects(*iAOList, iAOArray);

        if (err)

            {

            ShowErrorNote(err);

            User::Leave(err);

            }

        }

    }

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

// CSecModUIModel::TokenLabelForTitle() const

// Retrieves description of the token based on UID of the current active keystore.

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

//

QString CSecModUIModel::TokenLabelForTitle() const

    {

	QString qLabel;

    if (iKeyStore->Token().TokenType().Type().iUid 

        == KTokenTypeFileKeystore)

        {

        qLabel = "Phone keystore";   

        }

    else

        {            

        const TDesC& label = iKeyStore->Token().Label();

        qLabel = QString((QChar*)label.Ptr(),label.Length());

        }

    return qLabel;

    }

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

// CSecModUIModel::AuthStatus(TInt aIndex) const

// Returns status of the selected auth object. 

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

//

TUint32 CSecModUIModel::AuthStatus(TInt aIndex) const

		{

		return iAOArray[aIndex]->Status();

		}

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

// CSecModUIModel::PINStatus( TInt aIndex, TBool aShowBlockedNote ) const

// Returns status of the auth object based on its persistent properties set

// by security module implementation.

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

//

QString CSecModUIModel::PINStatus(  TInt aIndex, TBool aShowBlockedNote ) const

    {

    __ASSERT_ALWAYS(aIndex < iAOArray.Count(), Panic(EPanicIndexOutOfRange));

    QString pinStatus;

    TUint32 status = iAOArray[aIndex]->Status();

    if (status & EAuthObjectBlocked)

        {

        if (aShowBlockedNote)

            {

			QString information = 0;

            if (status & EUnblockDisabled)

                {

				information = " totalblocked, contact your module vendor.";

                }

            else

                {

				information = " is blocked. PUK code is needed to unblock the code";

                }

            information.prepend(QString( (QChar*)(iAOArray[aIndex]->Label()).Ptr(),iAOArray[aIndex]->Label().Length() ) );

            HbMessageBox::information(information);        

            }            

        pinStatus = "Blocked";

        }

    else if ( PinOpen(aIndex) )

        {

		pinStatus = "Open";

        }

    else

        {

		pinStatus = "Closed";

        }

    return pinStatus;

    }

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

// CSecModUIModel::PinOpen(TInt aIndex) const

// Checks whether the Pin is still available.

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

//

TBool CSecModUIModel::PinOpen(TInt aIndex) const

    {

    __ASSERT_ALWAYS(aIndex < iAOArray.Count(), Panic(EPanicIndexOutOfRange));

    TInt timeRemaining = 0;

    TInt err = iWrapper->TimeRemaining(*(iAOArray[aIndex]), timeRemaining);

    TBool ret = ETrue;

    if ( 0 < timeRemaining )

        {

        ret = ETrue;

        }

    else if( timeRemaining == -1 )

        {

        ret = ETrue;

        }

    else

        {

        ret = EFalse;

        }

    return ret;

    }

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

// CSecModUIModel::ChangeOrUnblockPinL(TInt aIndex)

// Based on the property of auth object the pin can be changed or unblocked.

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

//

void CSecModUIModel::ChangeOrUnblockPinL(TInt aIndex)

    {

    __ASSERT_ALWAYS(aIndex < iAOArray.Count(), Panic(EPanicIndexOutOfRange));

    TUint32 status = iAOArray[aIndex]->Status();

    if ((status & EAuthObjectBlocked) && (status & EUnblockDisabled))

        {

        return; // We cannot do anything. PIN is total bolcked.

        }

    else if (status & EAuthObjectBlocked)

        {

        // Let's unblock the PIN

        UnblockPinL(aIndex);

        }

    else if (status & EEnabled)

        {

        // PIN is enabled. Let's change the PIN.

        ChangePinL(aIndex);

        }

    }

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

// CSecModUIModel::UnblockPinL(TInt aIndex)

// Unblocks PIN.

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

//

void CSecModUIModel::UnblockPinL(TInt aIndex)

    {

    __ASSERT_ALWAYS(aIndex < iAOArray.Count(), Panic(EPanicIndexOutOfRange));

    TInt err = iWrapper->UnblockAuthObject(*(iAOArray[aIndex]));

    if (KErrNone == err)

        {

        HbMessageBox::information("Code unblocked");

        }

    else

        {

        ShowErrorNote(err);

        }

    }

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

// CSecModUIModel::ChangePinL(TInt aIndex)