/*
* 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: This class is instantiated via ECom for a particular token type
*
*/
// INCLUDE FILES
#include "WimTokenType.h"
#include "WimToken.h"
#include "WimImplementationUID.hrh"
#include <ecom/implementationproxy.h>
#include "WimTrace.h"
//#include "WimDebug.h"
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CWimTokenType::CWimTokenType()
// Default constructor
// -----------------------------------------------------------------------------
//
CWimTokenType::CWimTokenType()
{
}
// -----------------------------------------------------------------------------
// CWimTokenType::ConstructL()
// Second phase constructor
// -----------------------------------------------------------------------------
//
void CWimTokenType::ConstructL()
{
_WIMTRACE ( _L( "CWimTokenType::ConstructL()" ) );
iWimSecModuleMgr = CWimSecModuleMgr::NewL();
}
// -----------------------------------------------------------------------------
// CWimTokenType::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWimTokenType* CWimTokenType::NewL()
{
CWimTokenType* self = new( ELeave ) CWimTokenType();
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CWimTokenType::~CWimTokenType()
// Destructor.
// -----------------------------------------------------------------------------
//
CWimTokenType::~CWimTokenType()
{
_WIMTRACE ( _L( "CWimTokenType::~CWimTokenType()" ) );
delete iWimSecModuleMgr;
}
// -----------------------------------------------------------------------------
// CWimTokenType::List()
// List all the tokens of this type.
// -----------------------------------------------------------------------------
//
void CWimTokenType::List( RCPointerArray<HBufC>& aTokens,
TRequestStatus& aStatus )
{
_WIMTRACE ( _L( "CWimTokenType::List" ) );
aStatus = KRequestPending;
iWimSecModuleMgr->GetEntries( aTokens, aStatus );
}
// -----------------------------------------------------------------------------
// CWimTokenType::CancelList()
// Cancel a list operation.
// -----------------------------------------------------------------------------
//
void CWimTokenType::CancelList()
{
_WIMTRACE ( _L( "CWimTokenType::CancelList" ) );
iWimSecModuleMgr->CancelList();
}
// -----------------------------------------------------------------------------
// CTokenTypeImplementation::OpenToken()
// Opens new token, which name is specified in aTokenInfo
// This is not true asynchronous function.
// -----------------------------------------------------------------------------
//
void CWimTokenType::OpenToken( const TDesC& aTokenInfo,
MCTToken*& aToken,
TRequestStatus& aStatus )
{
_WIMTRACE ( _L( "CWimTokenType::OpenToken with name" ) );
TInt err = KErrNone;
TInt i = 0;
aStatus = KRequestPending;
// Get the right Wim and pass it to CWimToken to be created.
// Stack Wim count for efficiency reasons
TInt count = iWimSecModuleMgr->WimCount();
for ( i = 0; i < count && err == KErrNone; i++ )
{
HBufC* label = NULL; // from heap
// Get Wim label
TRAP( err, label = iWimSecModuleMgr->WimLabelByIndexL( i ).AllocL() );
if ( err == KErrNone )
{
// If labels match...
if ( !aTokenInfo.Compare( label->Des() ) )
{
// Create token
TRAP( err, aToken = CWimToken::NewL( iWimSecModuleMgr->GetWimSecModuleByIndexL( i ), *this ) );
i = count + 1; // This completes for loop and separates
// from normal for loop end (i == count)
if ( err == KErrNone )
{
IncReferenceCount();
}
}
}
delete label;
}
if ( i == count && err == KErrNone ) // Not match found
{
err = KErrNotFound;
}
TRequestStatus* r = &aStatus;
User::RequestComplete( r, err );
}
// -----------------------------------------------------------------------------
// CWimTokenType::OpenToken()
// Open new token, The handle of the required token is used to get needed
// information. Before opening new token we need to compare token numbers.
// This is not true asynchronous function.
// -----------------------------------------------------------------------------
//
void CWimTokenType::OpenToken( TCTTokenHandle aHandle,
MCTToken*& aToken,
TRequestStatus& aStatus )
{
_WIMTRACE ( _L( "CWimTokenType::OpenToken with handle" ) );
TInt err = KErrNone;
TInt i = 0;
TInt count = 0;
aStatus = KRequestPending;
// Current tokentype and requested token's tokentype must be the same
if ( Type() == aHandle.iTokenTypeUid )
{
// Count of security modules:
count = iWimSecModuleMgr->WimCount();
// For effectivity reasons, stack the given handle
TInt mytokennumber = aHandle.iTokenId;
// Let's go through all Wims and try to match handles
for ( i = 0; i < count && err == KErrNone; i++ )
{
// Stack Wim handle
TInt histokennumber = 0;
TRAP( err, histokennumber = iWimSecModuleMgr->
WimTokenNumberByIndexL( i ) );
if ( err == KErrNone )
{
if ( mytokennumber == histokennumber )
{
HBufC* label = NULL;// From heap
// Let's get Wim label and use another
// API function to get token info
TRAP( err, label = iWimSecModuleMgr->
WimLabelByIndexL( i ).AllocL() );
if ( err == KErrNone )
{
// The completion of the next statement is handled
// in the associated function
OpenToken( label->Des(), aToken, aStatus );
delete label;
return; // Must quit here, RequestComplete is done
}
delete label; // Here we go if error in last TRAP
i = count + 1; // This completes for loop and
// separates from normal for loop end
}
}
} // for loop...
} // if ( Type()...
if ( i == count && err == KErrNone ) // No match found
{
err = KErrNotFound;
}
TRequestStatus* r = &aStatus;
User::RequestComplete( r, err );
}
// -----------------------------------------------------------------------------
// CWimTokenType::CancelOpenToken()
// Cancel an OpenToken operation.
// -----------------------------------------------------------------------------
//
void CWimTokenType::CancelOpenToken()
{
_WIMTRACE ( _L( "CWimTokenType::CancelOpenToken" ) );
// It's not really async, so you can't cancel.
}
// -----------------------------------------------------------------------------
// TImplementationProxy ImplementationTable[]
// An array listing the NewL functions of all the plugins.
// -----------------------------------------------------------------------------
//
const TImplementationProxy ImplementationTable[] =
{
{{WIM_IMPLEMENTATION_UID}, (TProxyNewLPtr) CWimTokenType::NewL} //CARD-WIM
};
// -----------------------------------------------------------------------------
// TImplementationProxy* ImplementationGroupProxy()
// This function is needed by ECom and is the only one exported function
// -----------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy*
ImplementationGroupProxy( TInt& aTableCount )
{
aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );
return ImplementationTable;
}