/*

* Copyright (c) 2002-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:  Services for authentication object management

*

*/

// INCLUDE FILES

#include    "WimServer.h"

#include    "Wimi.h"            //WIMI definitions

#include    "WimClsv.h"

#include    "WimAuthObjHandler.h"

#include    "WimMemMgmt.h"

#include    "WimResponse.h"

#include    "WimUtilityFuncs.h"

#include    "WimSecurityDlgHandler.h"

#include    "WimTrace.h"

#include    "WimCallbackImpl.h"

#include    "WimCleanup.h"

#include    "JavaUtils.h"

#include    <random.h>

#ifdef _DEBUG

_LIT( KWimAuthObjPanic, "WimAuthObj" );

#endif

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

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

// CWimAuthObjHandler::CWimAuthObjHandler

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

// might leave.

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

//

CWimAuthObjHandler::CWimAuthObjHandler() : CActive( EPriorityStandard )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::CWimAuthObjHandler | Begin"));

    iDisablePINBlocked = EFalse;

    iUnblockPING = EFalse;

    }

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

// CWimAuthObjHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWimAuthObjHandler::ConstructL()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::ConstructL | Begin"));

    CActiveScheduler::Add( this );

    iWimUtilFuncs = CWimUtilityFuncs::NewL();

    iWimSecDlg = CWimSecurityDlgHandler::NewL();

    }

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

// CWimAuthObjHandler::NewL

// Two-phased constructor.

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

//

CWimAuthObjHandler* CWimAuthObjHandler::NewL()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::NewL | Begin"));

    CWimAuthObjHandler* self = new( ELeave ) CWimAuthObjHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CWimAuthObjHandler::~CWimAuthObjHandler()

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::~CWimAuthObjHandler | Begin"));

    Cancel();

    delete iWimUtilFuncs;

    delete iWimSecDlg;

    }

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

// CWimAuthObjHandler::GetPINCountL

// Fetches the count of PINs in WIM.

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

//

void CWimAuthObjHandler::GetPINCountL( const RMessage2& aMessage ) const

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINCountL | Begin"));

    WIMI_Ref_pt pWimStruct = const_cast<WIMI_Ref_pt>( aMessage.Ptr0() ); 

    TUint16 pinNum;

    WIMI_RefList_t refList;

    WIMI_STAT status = WIMI_Ok; 

    status = WIMI_GetPINList( pWimStruct, &pinNum, &refList );

    if ( status == WIMI_Ok )

        {

        free_WIMI_RefList_t( refList );

        TPckgBuf<TUint> pckg( pinNum );

        aMessage.WriteL( 1, pckg );

        }

    aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

    }

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

// CWimAuthObjHandler::GetPINRefListL

// Get reference list for PINs.

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

//

void CWimAuthObjHandler::GetPINRefListL( 

    const RMessage2& aMessage, 

    CWimMemMgmt* aWimMgmt )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINRefListL | Begin"));

    WIMI_Ref_pt pWimStruct = const_cast<WIMI_Ref_pt>( aMessage.Ptr0() );

    __ASSERT_ALWAYS( pWimStruct, User::Leave( KErrArgument ) );

    HBufC8* buf = iWimUtilFuncs->DesLC( 2, aMessage );

    TUint32* pinArr = ( TUint32* )( buf->Des().Ptr() );

    TUint16 pinNum;

    WIMI_RefList_t pinRefLst;

    WIMI_STAT status = WIMI_Ok;

    status = WIMI_GetPINList( pWimStruct, &pinNum, &pinRefLst );

    if ( status == WIMI_Ok )

        {

        aWimMgmt->AppendWIMRefLstL( pinRefLst );    // takes ownership

        TPckgBuf<TUint32> lstAddr( ( TUint32 ) pinRefLst );

        for ( TUint8 index = 0; index < pinNum; index++ )

            {

            pinArr[index] = ( TUint32 ) pinRefLst[index];

            }

        iPinGRef =  const_cast< WIMI_Ref_pt >( pinRefLst[0] );

        aMessage.WriteL( 1, lstAddr );

        aMessage.WriteL( 2, buf->Des() );

        }

    CleanupStack::PopAndDestroy( buf );

    aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

    }

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

// CWimAuthObjHandler::GetPINInfoL

// Get detailed information about the PIN.

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

//

void CWimAuthObjHandler::GetPINInfoL( const RMessage2& aMessage ) 

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINInfoL | Begin"));

    WIMI_Ref_pt pPinStruct = const_cast<WIMI_Ref_pt>( aMessage.Ptr0() );

    __ASSERT_ALWAYS( pPinStruct, User::Leave( KErrArgument ) );

    TUint8 flags;

    TUint8 minLength;

    TUint8 pinNumber = 0;

    WIMI_BinData_t ptLabel;

    WIMI_STAT status = WIMI_Ok;

    if ( pPinStruct )

        {

        iPinValue.Zero();

        TRequestStatus status1;

        CWimCallBack::SetSignTextRequestStatus( &status1 );

        status = WIMI_VerifyPINReq( NULL,pPinStruct, 

                             ( TUint8 )iPinValue.Length(),

                             ( TUint8* )iPinValue.Ptr() );

        if ( status != WIMI_Ok )

            {

        	aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

        	return;

            }

        User::WaitForRequest( status1 );   

        CWimCallBack::SetSignTextRequestStatus( NULL );          

        WIMI_Ref_t* cmeWimRef = NULL;

        status = WIMI_GetPINStatus( pPinStruct,

                                    &cmeWimRef,

                                    &flags,

                                    &minLength,

                                    &pinNumber,

                                    &ptLabel );

        if ( status == WIMI_Ok )

            {

            // Code MAY NOT leave before cmeWimRef and ptLabel.pb_buf are deallocated.

            TPckgBuf<TWimPinStruct> infoPckg;

            TInt readErr = aMessage.Read( 1, infoPckg );

            if( readErr )

                {

                free_WIMI_Ref_t( cmeWimRef );

                WSL_OS_Free( ptLabel.pb_buf );

                // Code can leave after this point.

                User::Leave( readErr );

                }

            TBuf<KLabelLen> label;

            label.Copy( TPtr8( ptLabel.pb_buf,

                               ptLabel.ui_buf_length, 

                               ptLabel.ui_buf_length ) );

            // Possible values of iStatus are:

            // EEnabled		    = 0x80,

            // EChangeDisabled	= 0x40,

            // EUnblockDisabled	= 0x20,

            // EDisableAllowed	= 0x10,

            if( status1.Int() == KErrLocked )

                {

                infoPckg().iStatus = flags & KPINStatusMask;

                infoPckg().iStatus = infoPckg().iStatus | KWimAuthObjectBlocked;	

                }

            else if( iDisablePINBlocked )

                {

                infoPckg().iStatus = flags & KPINStatusMask;

            	infoPckg().iStatus = infoPckg().iStatus | KWimAuthObjectBlocked;

                }

            else

                {

                infoPckg().iStatus = flags & KPINStatusMask;	

                }

            infoPckg().iPinNumber = pinNumber;

            infoPckg().iLabel = label;

            TInt writeErr = aMessage.Write( 1, infoPckg );

            free_WIMI_Ref_t( cmeWimRef );

            WSL_OS_Free( ptLabel.pb_buf );

            // Code can leave after this point.

            User::LeaveIfError( writeErr );

            }

        }

    else

        {

        status = WIMI_ERR_BadParameters;

        }

    aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

    }

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

// CWimAuthObjHandler::GetPINsInfoL

// Get detailed information about the all of the PINs on a certain SecMod.

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

//

void CWimAuthObjHandler::GetPINsInfoL( const RMessage2& aMessage ) 

    {

    //Get pin number and reflist

    _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINsInfoL | Begin"));

    WIMI_Ref_pt pWimStruct = const_cast<WIMI_Ref_pt>( aMessage.Ptr0() ); 

    TUint16 pinNum;

    WIMI_RefList_t refList;

    WIMI_STAT status = WIMI_Ok;

    status = WIMI_GetPINList( pWimStruct, &pinNum, &refList );

    CleanupPushWimRefListL( refList );

    CArrayFixFlat<TWimPinStruct>* pinsInfo = new( ELeave ) CArrayFixFlat<TWimPinStruct>( pinNum );

    CleanupStack::PushL( pinsInfo );

    RArray<WIMI_Ref_pt> pinRefsArray;

    CleanupClosePushL( pinRefsArray );

    if( status == WIMI_Ok )

        {

        if( pinNum != aMessage.Int2() )

            {

            status = WIMI_ERR_Internal;

            CleanupStack::PopAndDestroy( 3, refList );  // pinRefsArray, pinsInfo, refList

            aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

            return;

            }

        for ( TUint8 index = 0; index < pinNum; index++ )

            {

            pinRefsArray.Append( refList[index] );

            }

        }

    else

        {

        CleanupStack::PopAndDestroy( 3, refList );  // pinRefsArray, pinsInfo, refList

        aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

        return;

        }

    //Get pin details bt pin reference

    for ( TUint8 index = 0; index < pinNum; index++ )

        {

        WIMI_Ref_pt pPinStruct = pinRefsArray[ index ];

	    __ASSERT_ALWAYS( pPinStruct, User::Leave( KErrArgument ) );

        TUint8 flags;

        TUint8 minLength;

        TUint8 pinNumber = 0;

        WIMI_BinData_t ptLabel;

        WIMI_STAT status = WIMI_Ok;

        TRequestStatus status1;

        iPinValue.Zero();

        CWimCallBack::SetSignTextRequestStatus( &status1 );

        status = WIMI_VerifyPINReq( NULL,pPinStruct, 

                 ( TUint8 )iPinValue.Length(),

                 ( TUint8* )iPinValue.Ptr() );

        _WIMTRACE2(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINsInfoL status %d "), status );    

        if ( status != WIMI_Ok )

            {

            CleanupStack::PopAndDestroy( 3, refList );  // pinRefsArray, pinsInfo, refList

            aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

            return;

            }

        User::WaitForRequest( status1 );

        CWimCallBack::SetSignTextRequestStatus( NULL );

        WIMI_Ref_t* cmeWimRef = NULL;

        status = WIMI_GetPINStatus( pPinStruct,

                        &cmeWimRef,

                        &flags,

                        &minLength,

                        &pinNumber,

                        &ptLabel );

        if ( status == WIMI_Ok )

            {

            free_WIMI_Ref_t( cmeWimRef );

            CleanupPushWimBufL( ptLabel );

            TWimPinStruct pinStruct;

            pinStruct.iLabel.Copy( TPtr8( ptLabel.pb_buf,

                    ptLabel.ui_buf_length,

                    ptLabel.ui_buf_length ) );

            CleanupStack::PopAndDestroy( ptLabel.pb_buf );

            // Possible values of iStatus are:

            // EEnabled		    = 0x80,

            // EChangeDisabled	= 0x40,

            // EUnblockDisabled	= 0x20,

            // EDisableAllowed	= 0x10,

            if( status1.Int() == KErrLocked )

                {

                pinStruct.iStatus = flags & KPINStatusMask;

                pinStruct.iStatus = pinStruct.iStatus | KWimAuthObjectBlocked;

                }

            else if( iDisablePINBlocked )

                {

                pinStruct.iStatus = flags & KPINStatusMask;

                pinStruct.iStatus = pinStruct.iStatus | KWimAuthObjectBlocked;

                }

            else

                {

                pinStruct.iStatus = flags & KPINStatusMask;

                }

            pinStruct.iPinNumber = pinNumber;

            pinsInfo->AppendL( pinStruct );

            }

        else

            {

            status = WIMI_ERR_BadParameters;

            break;

            }

        }

    TInt16 length = ( TInt16 )pinsInfo->Count()*( sizeof( TWimPinStruct ) );

    TPtrC8 pinInfoPtr;

    pinInfoPtr.Set( (TText8*)&(*pinsInfo)[0], length );  

    if( status == WIMI_Ok )

        {

        aMessage.WriteL( 1, pinInfoPtr );

        }

    CleanupStack::PopAndDestroy( 3, refList );  // pinRefsArray, pinsInfo, refList

    aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) );

    }

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

// CWimAuthObjHandler::VerifyDisabledPINRequestL

// Verifies Disabled PIN number.

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

//

void CWimAuthObjHandler::VerifyDisabledPINRequestL( 

     const RMessage2& aMessage )

    {

    __ASSERT_DEBUG( iResponseID == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) );

    iResponseID = new ( ELeave )CWimResponse( aMessage );

    iResponseID->iOpcode = EVerifyDisabledPinReq;

    if( iDisablePINBlocked ) 

    	{   

        iResponseID->iStatus = WIMI_ERR_PINBlocked;

        iResponseID->CompleteMsgAndDelete();

        iResponseID = NULL;

    	}

    else

    	{    

        iResponseID->iStatus = WIMI_Ok;

        iResponseID->CompleteMsgAndDelete();

        iResponseID = NULL;

    	}

    }

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

// CWimAuthObjHandler::VerifyPINRequestL

// Verifies PIN number.

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

//

void CWimAuthObjHandler::VerifyPINRequestL(

    const RMessage2& aMessage,

    TBool aShowDialog )

    {

    _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::VerifyPINRequestL|Begin"));

    __ASSERT_DEBUG( iResponseID == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) );

    iResponseID = new ( ELeave )CWimResponse( aMessage );

    iResponseID->iOpcode = EVerifyPinReq;

    __ASSERT_DEBUG( iTrId == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) );

    iTrId = iWimUtilFuncs->TrIdLC( iResponseID, EWimMgmtReq );

    CleanupStack::Pop( iTrId );

    iShowDialog = aShowDialog;

    if ( aShowDialog ) // Ask PIN from user

        {

        _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::Verify|Show dialog"));

        TPckgBuf<TPINParams> infoPckg;

        aMessage.ReadL( 1, infoPckg );

        _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::Verify|PINParamas read"));

        iPinParams.iPINLabel = infoPckg().iPINLabel;

        iPinParams.iTokenLabel = infoPckg().iTokenLabel;

        iPinParams.iMinLength = infoPckg().iMinLength;

	    iPinParams.iMaxLength = infoPckg().iMaxLength;

        _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::Verify|Call dialog"));

        iRetry = EFalse;

        VerifyPINAskPIN();

        }

    else // Do not ask PIN from user, just try if PIN is blocked with empty PIN

        {

        iRequest = EVerifyPINAskPIN;

        iStatus = KRequestPending;

        SetActive();

        iPinValue.Zero();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        }

    }

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

// CWimAuthObjHandler::VerifyPINAskPIN

//

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

//

void CWimAuthObjHandler::VerifyPINAskPIN()

    {

	iRequest = EVerifyPINAskPIN;

    iStatus = KRequestPending;

    SetActive();

    iWimSecDlg->EnterPIN( iRetry,

                          iPinParams,

                          iPinValue,

                          iStatus );

    }

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

// CWimAuthObjHandler::ContinueVerifyPINReqL

// Continue verify PIN request. Calls WIMI.

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

//

void CWimAuthObjHandler::ContinueVerifyPINReqL( ) 

    {

    __ASSERT_DEBUG( iResponseID, User::Panic( KWimAuthObjPanic, KErrGeneral ) );

    WIMI_Ref_pt pPINref = const_cast<WIMI_Ref_pt>( (iResponseID->iMessage).Ptr0() );

    HBufC8* pinBuf = HBufC8::NewLC( iPinValue.Length() );

    TPtr8 pinPtr = pinBuf->Des();

    pinPtr.Copy( iPinValue );

    if ( iShowDialog )

        {

        iStatus = KRequestPending;

        TRequestStatus* status = &iStatus;

        iRequest = EVerifyPINCallBackResponse;

        SetActive();

        iResponseID->iStatus = WIMI_VerifyPINReq( iTrId,

                                             pPINref, 

                                             ( TUint8 )pinPtr.Length(),

                                             ( TUint8* )pinPtr.Ptr() );

        if ( iResponseID->iStatus != WIMI_Ok )

            {

            iRequest = EWIMIError;

            User::RequestComplete( status, iResponseID->iStatus );	 

            }

        }

    else