/*

* 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:  Key management services

*

*/

// INCLUDE FILES

#include    "WimKeyMgmtHandler.h"

#include    "WimSession.h"

#include    "WimConsts.h"

#include    "WimMemMgmt.h"

#include    "WimUtilityFuncs.h"

#include    "WimTrace.h"

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

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

// CWimKeyMgmtHandler::CWimKeyMgmtHandler

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

// might leave.

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

//

CWimKeyMgmtHandler::CWimKeyMgmtHandler()

    {

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

    }

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

// CWimKeyMgmtHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWimKeyMgmtHandler::ConstructL()

    {

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

    iWimUtilFuncs = CWimUtilityFuncs::NewL();

    }

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

// CWimKeyMgmtHandler::NewL

// Two-phased constructor.

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

//

CWimKeyMgmtHandler* CWimKeyMgmtHandler::NewL()

    {

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

    CWimKeyMgmtHandler* self = new( ELeave ) CWimKeyMgmtHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CWimKeyMgmtHandler::~CWimKeyMgmtHandler()

    {

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

    delete iWimUtilFuncs;

    }

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

// CWimKeyMgmtHandler::DoesKeyExistL

// Checks if the given key exists.

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

//

void CWimKeyMgmtHandler::DoesKeyExistL( const RMessage2& aMessage )

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimKeyMgmtHandler::DoesKeyExistL | Begin"));

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

    TUint8* keyHash = const_cast<TUint8*>( buf->Des().Ptr() );

    WIMI_Ref_t* tmpKeyRef = NULL;

    WIMI_STAT status = WIMI_GetKeyByHash( keyHash, &tmpKeyRef );

    if ( status == WIMI_Ok )

        {

        free_WIMI_Ref_t( tmpKeyRef );

        }

    CleanupStack::PopAndDestroy( buf );

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

    }

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

// CWimKeyMgmtHandler::GetKeyDetailsL

// Fetches the details of the given key.

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

//

void CWimKeyMgmtHandler::GetKeyDetailsL( const RMessage2& aMessage )

    { 

    _WIMTRACE(_L("WIM | WIMServer | CWimKeyMgmtHandler::GetKeyDetailsL | Begin"));

    WIMI_Ref_t* pKeyRef = const_cast<WIMI_Ref_pt>( aMessage.Ptr0() );

    WIMI_Ref_t* pWimRef;    

    TUint8 keyType;

    TUint8 keyNumber;

    TUint8 pinNumber;

    TUint16 usage;

    TUint16 key_length;

    WIMI_BinData_t pt_label;

    WIMI_BinData_t pt_keyid;

    WIMI_STAT callStatus = WIMI_GetKeyInfo( pKeyRef,

                                            &pWimRef,

                                            NULL,

                                            &keyType,

                                            &keyNumber,

                                            &pinNumber,

                                            &usage,

                                            &pt_keyid,

                                            &pt_label,

                                            &key_length );

    if ( callStatus == WIMI_Ok )

        {

        // Code MAY NOT leave before pWimRef, pt_keyid.pb_buf, and

        // pt_label.pb_buf are deallocated.

        free_WIMI_Ref_t( pWimRef );

        TPckgBuf<TKeyInfo> keyInfoPckg;

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

        if( readErr )

            {

            WSL_OS_Free( pt_label.pb_buf );

            WSL_OS_Free( pt_keyid.pb_buf );

            // Code can leave after this point.

            User::Leave( readErr );

            }

        keyInfoPckg().iLabel.Copy( TPtr8(

                pt_label.pb_buf, pt_label.ui_buf_length,

                pt_label.ui_buf_length ) );

        keyInfoPckg().iKeyId.Copy( TPtr8(

                pt_keyid.pb_buf, pt_keyid.ui_buf_length,

                pt_keyid.ui_buf_length ) );

        keyInfoPckg().iType = keyType;

        keyInfoPckg().iUsage = usage;

        keyInfoPckg().iLength = key_length;

        keyInfoPckg().iKeyNumber = keyNumber;

        keyInfoPckg().iPinNumber = pinNumber;

        WSL_OS_Free( pt_label.pb_buf );

        WSL_OS_Free( pt_keyid.pb_buf );

        // Code can leave after this point.

        aMessage.WriteL( 1, keyInfoPckg );

        }

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

    }

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

// CWimKeyMgmtHandler::GetKeyListL

// Fetches the list of keys in a Wim.

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

//

void CWimKeyMgmtHandler::GetKeyListL(

    const RMessage2& aMessage,

    CWimMemMgmt* aWimMgmt ) const

    {

    _WIMTRACE(_L("WIM | WIMServer | CWimKeyMgmtHandler::GetKeyListL | Begin"));

    HBufC8* keyInfo = HBufC8::NewLC( KLabelLen );

    TPtr8 ptr = keyInfo->Des();

    WIMI_STAT status;

    WIMI_Ref_t* wimRef = aWimMgmt->WimRef();

    TUint16 keyNum = 0;

    WIMI_RefList_t refList;

    status = WIMI_GetKeyListByWIM( wimRef, &keyNum, &refList );

    if ( status == WIMI_Ok )

        {

        for ( TUint8 keyIndex = 0; keyIndex < keyNum; keyIndex++ )

            {

            ptr.AppendNum( ( TInt32 ) refList[keyIndex], EDecimal );

            ptr.Append( _L8(" ") ); //Space character

            }

        aWimMgmt->AppendWIMRefLstL( refList );

        }

    aMessage.WriteL( 0, keyInfo->Des() );

    TPckg<TInt> pckg( keyNum );

    aMessage.WriteL( 1, pckg );

    CleanupStack::PopAndDestroy( keyInfo );

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

    }

//  End of File