// Copyright (c) 2003-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:
//

#include "Ctlsbrowsetoken.h"
#include "tlsprovider.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <tlstypedef_internal.h>
#endif


//
//  CTlsBrowseToken
//


CTlsBrowseToken* CTlsBrowseToken::NewL()
	{ 
	CTlsBrowseToken* aPtrClnt = new (ELeave)CTlsBrowseToken();
	return(aPtrClnt);
	}


CTlsBrowseToken::CTlsBrowseToken():CActive(0)
	{
	if(CActiveScheduler::Current()) //Already installed?
		{
		CActiveScheduler::Add( this );
		}
	}

void CTlsBrowseToken::StartBrowsingL(RArray<CTokenTypesAndTokens>& aListAllTokensAndTypes,
									TRequestStatus& aStatus)
	{
	
	
	aStatus = KRequestPending;
	User::LeaveIfError(iFs.Connect());
	iOriginalRequestStatus = &aStatus;

	iListAllTokensAndTypes = &aListAllTokensAndTypes;
	TLSPROV_LOG(_L("Listing all types and tokens"))

	//The following functions fills the tokentype info in iTokenTypeInfo array.
	TLSPROV_LOG(_L("Browsing for Tokens..."))
	ListTokenTypesL();		
	}

void CTlsBrowseToken::ListTokenTypesL()
	{
	iCurrentTokentype= 0;  
		
	//Filter defining the expected interface
	RArray<TUid> Interface;
	CleanupClosePushL(Interface);	
	User::LeaveIfError(Interface.Append(TUid::Uid(KInterfaceTLSTokenProvider)));
	User::LeaveIfError(Interface.Append(TUid::Uid(KInterfaceTLSSession)));
	TCTFindTokenTypesByInterface filter(Interface.Array());
			
	//List all the tokentypes supported [eg. Software Token, WIM1, WIM2, etc]	
	CCTTokenTypeInfo::ListL(iTokenTypeInfo, filter);
	CleanupStack::Pop(&Interface);	// Interface
	Interface.Close();

	iTotalTokenTypeCount = iTokenTypeInfo.Count();
	if(!iTotalTokenTypeCount)
		{
		//Not possible..Software token always present
		User::Leave(KErrNoTokenTypes);
		}	
	BrowseTokenTypesL();
	}

TInt CTlsBrowseToken::TotalTypeCount()
	{
	return iTotalTokenTypeCount;
	}

/*
The following function gets a handle to a new token type. If any of the interfaces in opening 
a token fails and if no other tokens are present in the token type, this function will be then called 
to browse for the next token type if any.
*/
void CTlsBrowseToken::BrowseTokenTypesL()
	{
	//Now we try opening the token types here
	TInt Error = KErrNone;
	while( iCurrentTokentype  < iTotalTokenTypeCount)
		{
		if(iPtrTokenType)
			iPtrTokenType->Release();
	
		TRAP(Error,(iPtrTokenType = MCTTokenType::NewL(*iTokenTypeInfo[iCurrentTokentype], iFs)));
		
		if(Error != KErrNone)
			{
			//This Token type couldnt be opened..try the next one if present
         iPtrTokenType = NULL;
			if((iCurrentTokentype + 1) <= iTotalTokenTypeCount)
				{
				(iCurrentTokentype++);
				continue;
				}
			else
				User::Leave(Error); 
			}
		else
			{
			//List all those tokens in that type
			iCurrentState = EGetTokenList;
			iStatus = KRequestPending;
			iTokenList.Close();
			iPtrTokenType->List(iTokenList,iStatus);
			SetActive();
			return;
			}		
		}

	//Will only come here if every token has been browsed
	iCurrentTokentype= 0;
	User::RequestComplete(iOriginalRequestStatus, Error); 
	}


void CTlsBrowseToken::OnEGetTokenListL()
	{

	TLSPROV_LOG(_L("Obtaining the list of Tokens in a type"))
				
	if(!iStatus.Int()) //Token list for a particular Token type obtained successfully
		{
		iTotalTokensinType = iTokenList.Count();
		iCurrentToken = 0;
		if(iTotalTokensinType)
			{
			iStatus = KRequestPending;
			iCurrentState = EOpenToken;	
			iPtrTokenType->OpenToken((*iTokenList[0]), iTokenHandle, iStatus);
			SetActive();
			return;							
			}
		}	
	//Try for any other TokenTypes? If not present BrowseTokenTypesL() will complete
	iCurrentTokentype++;
	BrowseTokenTypesL();									
	}

void CTlsBrowseToken::OnEOpenTokenL()
	{		
	if(!iStatus.Int())
		{		
		iStatus = KRequestPending;
		iCurrentState = EGetProviderInterface;
		iTokenHandle->GetInterface(UidProv,iTokenInterface,iStatus);
		SetActive();
		return;
		}		
	
	//This token failed, try another one
	iCurrentTokentype++;
	BrowseTokenTypesL();
	}

void CTlsBrowseToken::OnEGetProviderInterfaceL()
	{
	if(!iStatus.Int()) 
		{
		TLSPROV_LOG(_L("Provider Interface for this token obtained successfully"))
				
      CTokenTypesAndTokens* tempObj = new CTokenTypesAndTokens;
      if ( !tempObj || iListAllTokensAndTypes->Append(*tempObj) != KErrNone )
         {
   		delete tempObj;
         iTokenHandle->Release();
         iTokenHandle = NULL;
         User::Leave( KErrNoMemory );
         }
  		delete tempObj;
      CTokenTypesAndTokens& Tokens = (*iListAllTokensAndTypes)[iListAllTokensAndTypes->Count() - 1];
      Tokens.iTokenInfo = new CTokenInfo;
      if ( !Tokens.iTokenInfo  )
         {
         iTokenHandle->Release();
         iTokenHandle = NULL;
         User::Leave( KErrNoMemory );
         }

      iTokenHandle = NULL; //owned by iProviderInterface
		Tokens.iProviderInterface = static_cast<MTLSTokenProvider*>(iTokenInterface);
      iTokenInterface = NULL;
   
					
		iCurrentState = EGetCiphers;
		iStatus = KRequestPending;
		
		Tokens.iProviderInterface->CryptoCapabilities(
			Tokens.iTokenInfo->iSupportedProtocols,
			Tokens.iTokenInfo->aKeyExchAlgs,
			Tokens.iTokenInfo->aSignatureExchAlgs,
			iStatus);		
		SetActive();
		return;

		}
	
	iCurrentTokentype++;
	BrowseTokenTypesL();
	}


void CTlsBrowseToken::RunL()
	{
	if(iStatus.Int() == KErrNoMemory)
		{
		User::RequestComplete(iOriginalRequestStatus, iStatus.Int()); 
		iCurrentState = ENullState;
		return;
		}

	switch(iCurrentState)
		{
	case EGetTokenList:
		OnEGetTokenListL();
		break;
	case EOpenToken:
		OnEOpenTokenL();
		break;
	case EGetProviderInterface:
		{
		OnEGetProviderInterfaceL();
		}
		break;
	case EGetCiphers:
		{		

      CTokenTypesAndTokens& Tokens = (*iListAllTokensAndTypes)[iListAllTokensAndTypes->Count() - 1];
		Tokens.iTotalTokenCount = iTotalTokensinType;

		const TUid KSoftwareTokenType = {0x101FE20D};
		TLSPROV_LOG2(_L("loaded ECOM TLS tokentype plugin with uid = %08x"), ((Tokens.iProviderInterface->Token()).TokenType()).Type())
		if(((Tokens.iProviderInterface->Token()).TokenType()).Type() == KSoftwareTokenType)
			Tokens.iSoftwareToken = ETrue;
		else
			Tokens.iSoftwareToken = EFalse;

		
		iCurrentTokentype++;
		BrowseTokenTypesL();
		}
		break;
	case EGetSessionInterface:
		{
		TLSPROV_LOG(_L("Session Interface for this token obtained successfully"))
		*iSessionInterface = static_cast<MTLSSession*>(iTokenInterface);
      iTokenInterface = NULL;
		User::RequestComplete(iOriginalRequestStatus, iStatus.Int()); 
		}
		break;
	default:
		break;
		}

	}


void CTlsBrowseToken::GetSessionInterface(MTLSTokenProvider* aProviderInterface,
										  MTLSSession*& aSessionInterface,
										  TRequestStatus& aStatus)
	{
	aStatus = KRequestPending;	
	iSessionInterface = &aSessionInterface;
	iCurrentState = EGetSessionInterface;
	iOriginalRequestStatus = &aStatus;
	iTokenInterface = 0;
	iStatus = KRequestPending;
	iTokenProvider = aProviderInterface;
	(aProviderInterface->Token()).GetInterface(UidSess,iTokenInterface,iStatus);
	SetActive();
	return;
	}

TInt CTlsBrowseToken::RunError(TInt aError)
	{
	User::RequestComplete(iOriginalRequestStatus, aError); 
	return KErrNone;
	}

void CTlsBrowseToken::CancelRequest()
	{
	Cancel();
	return;
	}
void CTlsBrowseToken::DoCancel()
	{
	switch (iCurrentState)
		{
	case EGetTokenList:
		iPtrTokenType->CancelList();
		break;
		
	case EOpenToken:
		iPtrTokenType->CancelOpenToken();
		break;
		
	case EGetProviderInterface:
		iTokenHandle->CancelGetInterface();
		break;
	
	case EGetSessionInterface:
		(iTokenProvider->Token()).CancelGetInterface();
		break;		

	case EGetCiphers:
		MTLSTokenProvider* provider = static_cast<MTLSTokenProvider*>(iTokenInterface);
		provider->CancelCryptoCapabilities();
		break;

		}
	iCurrentState=ENullState;
	User::RequestComplete(iOriginalRequestStatus, KErrCancel);
	return;
	}

CTlsBrowseToken::~CTlsBrowseToken()
	{
	if(iPtrTokenType)
		{
		iPtrTokenType->Release();
		}
		
	iTokenTypeInfo.Close();
	iTokenList.Close();
	
	if ( iTokenInterface )
		{
		iTokenInterface->Release();
		}
		
	if(iTokenHandle)
		{
		iTokenHandle->Release();
		}
		
	iFs.Close();
	
	return;
	}