/*

* Copyright (c) 2002 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:  Startup place for client & server, message handling.

*

*/

//INCLUDES

#include "WimMgmt.h"

#include "WimTrace.h"

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

// RWimMgmt::RWimMgmt()

// Default constructor

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

//

RWimMgmt::RWimMgmt()

    {

    _WIMTRACE ( _L( "RWimMgmt::RWimMgmt()" ) );

    iPinStateRequestBufAllocated = EFalse;

    iPinParamsBufAllocated = EFalse;

    iPinInfoLstPtr = NULL;

    iPinModule = NULL;

    }

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

// RWimMgmt::~RWimMgmt()

// Destructor

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

//

RWimMgmt::~RWimMgmt()

    {

    _WIMTRACE ( _L( "RWimMgmt::~RWimMgmt()" ) );

    delete iPinInfoLstPtr;

    delete iPinModule;

    }

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

// RWimMgmt::WIMCount()

// Returns  TUint - the number of WIMs

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

//

TUint RWimMgmt::WIMCount()

    {

    _WIMTRACE ( _L( "RWimMgmt::WIMCount()" ) );

    TPckgBuf<TUint> pckg;

    TIpcArgs args;

    args.Set( 0, &pckg );

    if ( SendReceiveData( EGetWIMCount, args ) == KErrNone )

        {

        return pckg();

        }

    else

        {

        return 0;

        }

    }

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

// RWimMgmt::IsOpen()

// Tests whether WIM is open or not.

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

//

TBool RWimMgmt::IsOpen( const TWimAddress aWimAddr )

    {

    _WIMTRACE ( _L( "RWimMgmt::IsOpen()" ) );

    TPckgBuf<TBool> pckg;

    TIpcArgs args;

    args.Set( 0, aWimAddr );

    args.Set( 1, &pckg );

    SendReceiveData( EIsWIMOpen, args );

    return pckg();

    }

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

// RWimMgmt::CloseWIM()

// Closes the WIM and returns the status of the WIMI_CloseWIM()

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

//

TInt RWimMgmt::CloseWIM( const TWimAddress aWimAddr )

    {

    _WIMTRACE ( _L( "RWimMgmt::CloseWIM()" ) );

    TIpcArgs args;

    args.Set( 0, aWimAddr );

    return SendReceiveData( EWIMClose, args );

    }

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

// RWimMgmt::CloseAfter()

// Returns the time which is set as WIM closeout time

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

//

TInt RWimMgmt::CloseAfter()

    {

    _WIMTRACE ( _L( "RWimMgmt::CloseAfter()" ) );

    TPckgBuf<TInt> pckg;

    TIpcArgs args;

    args.Set( 0, &pckg );

    if ( SendReceiveData( EGetCloseWIMAfter, args ) == KErrNone )

        {

        return pckg();

        }

    else

        {

        return 0;

        }

    }

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

// RWimMgmt::CloseAfter()

// Returns TUint - the timeout in minutes, which tells how long 

// WIM Security Module will be open

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

//

TInt RWimMgmt::TimeRemaining()

    {

    _WIMTRACE ( _L( "RWimMgmt::TimeRemaining()" ) );

    TPckgBuf<TInt> pckg;

    TIpcArgs args;

    args.Set( 0, &pckg );

    if ( SendReceiveData( EWimTimeRemaining, args ) == KErrNone )

        {

        return pckg();

        }

    else

        {

        return 0;

        }

    }

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

// RWimMgmt::SetCloseAfter()

// Sets closing time for WIM.

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

//

void RWimMgmt::SetCloseAfter( const TUint aCloseAfter )

    {

    _WIMTRACE ( _L( "RWimMgmt::SetCloseAfter()" ) );

    TIpcArgs args;

    args.Set( 0, aCloseAfter );

    SendReceiveData( ECloseWIMAfter, args );

    }

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

// RWimMgmt::WIMRefs()

// Gets the array of WIM structures. aCount is the number of WIMs

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

//

TInt RWimMgmt::WIMRefs( TWimAddressList aWimAddrLst, TUint8 aCount )

    {

    _WIMTRACE ( _L( "RWimMgmt::WIMRefs()" ) );

    TInt length = ( TInt )( aCount * sizeof( TWimAddress ) );

    TPtr8 pt( ( TUint8* )aWimAddrLst, length, length );

    TIpcArgs args;

    args.Set( 0, &pt );

    return SendReceiveData( EGetWIMRefs, args );

    }

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

// RWimMgmt::WIMInfo()

// Gets the WIM information in to aTWimSecModuleStruct

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

//

TInt RWimMgmt::WIMInfo( const TWimAddress aWimAddr, 

                        TWimSecModuleStruct& aTWimSecModuleStruct )

    {

    _WIMTRACE ( _L( "RWimMgmt::WIMInfo()" ) );

    TPckg<TWimSecModuleStruct> wimModule( aTWimSecModuleStruct );

    TIpcArgs args;

    args.Set( 0, aWimAddr );

    args.Set( 1, &wimModule );

    return SendReceiveData( EGetWIMInfo, args );

    }

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

// RWimMgmt::PINCount()

// Returns  TUint - the number of PINs

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

//

TUint RWimMgmt::PINCount( const TWimAddress aWimAddr )

    {

    _WIMTRACE ( _L( "RWimMgmt::PINCount()" ) );

    TPckgBuf<TUint> pckg;

    TIpcArgs args;

    args.Set( 0, aWimAddr );

    args.Set( 1, &pckg );

    if ( SendReceiveData( EGetPINCount, args ) == KErrNone )

        {

        return pckg();

        }

    else

        {

        return 0;

        }

    }

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

// RWimMgmt::IsBlocked()

// Checks is PIN blocked or not.

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

//

TInt RWimMgmt::IsBlocked( const TPinAddress aPinAddr )

    {

    _WIMTRACE ( _L( "RWimMgmt::IsBlocked()" ) );

    TIpcArgs args;

    args.Set( 0, aPinAddr );

    return SendReceiveData( EIsPinBlocked, args );

    }

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

// RWimMgmt::IsDisabledPINBlocked()

// Checks is PIN blocked or not.

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

//

TInt RWimMgmt::IsDisabledPINBlocked( const TPinAddress aPinAddr )

    {

    _WIMTRACE ( _L( "RWimMgmt::IsDisabledPINBlocked()" ) );

    TIpcArgs args;

    args.Set( 0, aPinAddr );

    return SendReceiveData( EIsDisabledPinBlocked, args );

    }

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

// RWimMgmt::PINInfo()

// Gets the PIN information in to rPinStruct

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

//

void RWimMgmt::PINInfo( const TPinAddress aPinAddr, 

                        TWimPinStruct& aPinStruct,

                        TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimMgmt::PINInfo()" ) );

    if( iPinModule != NULL )

    {

    delete iPinModule;

    iPinModule = NULL; 	

    }

    iPinModule = new TPckg<TWimPinStruct>( aPinStruct );

    TIpcArgs args;

    args.Set( 0, aPinAddr );

    args.Set( 1, iPinModule );

    SendReceiveData( EGetPINInfo, args, aStatus );

    }

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

// RWimMgmt::PINRefs()

// Gets the array of PIN structures.

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

//

TInt RWimMgmt::PINRefs( const TWimAddress aWimAddr, 

                        TUint32& aPinLstAddr, 

                        TPinAddressList aPinAddrLst, 

                        TUint8 aCount )

    {

    _WIMTRACE ( _L( "RWimMgmt::PINRefs()" ) );

    TInt status = 0;

    TInt16 length = ( TInt16 ) ( aCount * sizeof( TWimAddress ) );

    TPtr8 pt( ( TUint8* ) aPinAddrLst, length, length );

    TPckgBuf<TUint32> lstAddr;

    TIpcArgs args;

    args.Set( 0, aWimAddr );

    args.Set( 1, &lstAddr );

    args.Set( 2, &pt );

    status = SendReceiveData( EGetPINRefs, args );

    if ( status == KErrNone )

        {

        aPinLstAddr = lstAddr();

        }

    else

        {

        aPinLstAddr = NULL;

        }

    return status;

    }

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

// RWimMgmt::PINsInfo() Asynchronous

// Initialize elements in PinNR array

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

//    

void RWimMgmt::PINsInfo( const TWimAddress aWimAddr, 

               CArrayFixFlat<TWimPinStruct>& aPinInfoLst,

               TUint8 aCount,

               TRequestStatus& aStatus )

  {

   _WIMTRACE ( _L( "RWimMgmt::PINsInfo()" ) );

   TInt16 length = ( TInt16 ) ( aCount * sizeof( TWimPinStruct ) );

   if( iPinInfoLstPtr == NULL )

	  {

	  iPinInfoLstPtr = new TPtr8( (TText8*)&aPinInfoLst[0],length, length ); 

	  }

   else

      {

      iPinInfoLstPtr->Set( (TText8*)&aPinInfoLst[0], length, length );

      } 

   TIpcArgs args;

   args.Set( 0, aWimAddr );

   args.Set( 1, iPinInfoLstPtr );

   args.Set( 2, aCount );

   aStatus = KRequestPending;

   SendReceiveData( EGetPINsInfo, args, aStatus );         	

   }

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

// RWimMgmt::PINsInfo() Synchronous

// Initialize elements in PinNR array

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

// 

TInt RWimMgmt::PINsInfo( const TWimAddress aWimAddr, 

               CArrayFixFlat<TWimPinStruct>& aPinInfoLst,

               TUint8 aCount )

  {

  _WIMTRACE ( _L( "RWimMgmt::PINsInfo() synchronous" ) );

  TInt16 length = ( TInt16 ) ( aCount * sizeof( TWimPinStruct ) );

  if( iPinInfoLstPtr == NULL )

	  {

	  iPinInfoLstPtr = new TPtr8( (TText8*)&aPinInfoLst[0],length,length );	

	  }

  else

      {

      iPinInfoLstPtr->Set( (TText8*)&aPinInfoLst[0], length, length );	

      }  

   TIpcArgs args;

   args.Set( 0, aWimAddr );

   args.Set( 1, iPinInfoLstPtr );

   args.Set( 2, aCount );

   return SendReceiveData( EGetPINsInfo, args );

   }

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

// RWimMgmt::EnableDisablePinQueryL()

// Handles Enable and Disable PIN requests. Server

// knows wanted operation by flag which is set in TPINStateRequest.

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

//

void RWimMgmt::EnableDisablePinQueryL( const TPinAddress aPinAddr, 

                                       const TPINStateRequest& aPinStateRequest,

                                       const TPINParams& aPinParams,

                                       TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimMgmt::EnableDisablePinQuery()" ) );

    iPinStateRequestBuf = new( ELeave )  

        CWimCertPckgBuf<TPINStateRequest>( aPinStateRequest );

    iPinStateRequestBufAllocated = ETrue;

    iPinParamsBuf = new( ELeave )  

        CWimCertPckgBuf<TPINParams>( aPinParams );

    iPinParamsBufAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, aPinAddr );

    args.Set( 1, iPinStateRequestBuf->PckgBuf() );

    args.Set( 2, iPinParamsBuf->PckgBuf() );

    aStatus = KRequestPending;

    SendReceiveData( EEnablePINReq, args, aStatus );

    }

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

// RWimMgmt::CancelEnableDisablePinQueryL()

// Cancel Enable and Disable PIN requests. Server

// knows wanted operation by flag which is set in TPINStateRequest.

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

//

void RWimMgmt::CancelEnableDisablePin( const TPinAddress aPinAddr )

    {

    _WIMTRACE ( _L( "RWimMgmt::CancelEnableDisablePinQuery()" ) );

    TIpcArgs args;

    args.Set( 0, aPinAddr );

    SendReceiveData( ECancelEnablePin, args );

    }

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

// RWimMgmt::DeallocMemoryFromEnableDisablePinQuery()

// Deallocates memory from pckgBuf member variables

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

//

void RWimMgmt::DeallocMemoryFromEnableDisablePinQuery()

    {

    _WIMTRACE ( _L( "RWimMgmt::DeallocMemoryFromEnableDisablePinQuery()" ) );

    if ( iPinStateRequestBufAllocated )

        {

        delete iPinStateRequestBuf;

        iPinStateRequestBuf = NULL;

        iPinStateRequestBufAllocated = EFalse;

        }

    if ( iPinParamsBufAllocated )

        {

        delete iPinParamsBuf;

        iPinParamsBuf = NULL;

        iPinParamsBufAllocated = EFalse;

        }

    }

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

// RWimMgmt::PinOperationL()

// PinOperationL handles several PIN operations: it can be

// verify PIN request, change PIN request or unblock PIN request. The 

// type of request is handled via aOpCode.

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

//

void RWimMgmt::PinOperationL( const TPinAddress aPinAddr,

                              const TPINParams aPinParams,

                              const TWimServRqst aOpCode,

                              TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "RWimMgmt::PinOperationL" ) );

    iPinParamsBuf = new( ELeave ) CWimCertPckgBuf<TPINParams>( aPinParams );

    iPinParamsBufAllocated = ETrue;

    TIpcArgs args;

    args.Set( 0, aPinAddr );

    args.Set( 1, iPinParamsBuf->PckgBuf() );

    aStatus = KRequestPending;

    SendReceiveData( aOpCode, args, aStatus );

    }

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

// RWimMgmt::CancelPinOperationL()

// PinOperationL handles several PIN operations: it can be

// verify PIN request, change PIN request or unblock PIN request. The 

// type of request is handled via aOpCode.

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

//

void RWimMgmt::CancelPinOperation( const TPinAddress aPinAddr,

                                   const TWimServRqst aOpCode )

    {

    _WIMTRACE ( _L( "RWimMgmt::CancelPinOperation" ) );

    TIpcArgs args;

    args.Set( 0, aPinAddr );

    SendReceiveData( aOpCode, args );

    }

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

// RWimMgmt::ClientSessionL()

// Returns new RWimMgmt object

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

//

RWimMgmt* RWimMgmt::ClientSessionL()

    {

    _WIMTRACE ( _L( "RWimMgmt::ClientSessionL()" ) );

    return new( ELeave ) RWimMgmt();

    }

// End of File