/*

* Copyright (c) 2001-2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  EAP and WLAN authentication protocols.

*

*/

// This is enumeration of EAPOL source code.

#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

	#undef EAP_FILE_NUMBER_ENUM

	#define EAP_FILE_NUMBER_ENUM 438 

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

// INCLUDE FILES

#include "EapTlsPeapUtils.h"

#include "EapTlsPeapDbDefaults.h"

#include "EapTlsPeapDbParameterNames.h"

#include <x500dn.h>

#include <x509cert.h>

#include <x509certext.h>

#ifdef USE_FAST_EAP_TYPE

#include "pac_store_db_parameters.h"

#endif //#ifdef USE_FAST_EAP_TYPE

#include "eap_am_trace_symbian.h"

#include "EapTlsPeapCertFetcher.h"

const TUint KMaxSqlQueryLength = 2048;

const TInt	KMicroSecsInAMinute = 60000000; // 60000000 micro seconds is 1 minute.

const TInt	KDefaultColumnInView_One = 1; // For DB view.

const TInt 	KMaxEapDbTableNameLength = 64;

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

void EapTlsPeapUtils::OpenDatabaseL(

	RDbNamedDatabase& aDatabase, 

	RDbs& aSession, 

	const TIndexType aIndexType,

	const TInt aIndex, 

	const eap_type_value_e aTunnelingType,

	eap_type_value_e aEapType)

{

#ifdef USE_EAP_EXPANDED_TYPES

	EAP_TRACE_DEBUG_SYMBIAN(

		(_L("EapTlsPeapUtils::OpenDatabaseL -Start- aIndexType=%d, aIndex=%d, Tunneling vendor type=%d, Eap vendor type=%d \n"),

		aIndexType,aIndex, aTunnelingType.get_vendor_type(), aEapType.get_vendor_type()));

#else

	EAP_TRACE_DEBUG_SYMBIAN(

		(_L("EapTlsPeapUtils::OpenDatabaseL -Start- aIndexType=%d, aIndex=%d, aTunnelingType=%d, aEapType=%d \n"),

		aIndexType,aIndex, aTunnelingType, aEapType));

#endif //#ifdef USE_EAP_EXPANDED_TYPES

	if (aEapType == eap_type_tls)

	{

		OpenTlsDatabaseL(aDatabase, aSession, aIndexType, aIndex, aTunnelingType);

	} 

	else if (aEapType == eap_type_peap)

	{

		OpenPeapDatabaseL(aDatabase, aSession, aIndexType, aIndex, aTunnelingType);

	} 

#if defined(USE_TTLS_EAP_TYPE)

	else if (aEapType == eap_type_ttls)

	{

		OpenTtlsDatabaseL(aDatabase, aSession, aIndexType, aIndex, aTunnelingType);

	} 

#endif // #if defined(USE_TTLS_EAP_TYPE)

#if defined(USE_FAST_EAP_TYPE)

	else if (aEapType == eap_type_fast)

	{

		OpenFastDatabaseL(aDatabase, aSession, aIndexType, aIndex, aTunnelingType);

	} 

#endif // #if defined(USE_FAST_EAP_TYPE)

	else if ( aEapType == eap_type_ttls_plain_pap )

		{

		OpenTtlsDatabaseL( aDatabase, aSession, aIndexType, aIndex, aTunnelingType);

		}

	else

	{

		// Unsupported EAP type

		User::Leave(KErrNotSupported);

	}	

} // EapTlsPeapUtils::OpenDatabaseL()

void EapTlsPeapUtils::OpenTlsDatabaseL(

		RDbNamedDatabase& aDatabase, 

		RDbs& aSession, 

		const TIndexType aIndexType, 

		const TInt aIndex,

		const eap_type_value_e aTunnelingType)

{

#ifdef USE_EAP_EXPANDED_TYPES

	TUint aTunnelingVendorType = aTunnelingType.get_vendor_type();

#else

	TUint aTunnelingVendorType = static_cast<TUint>(aTunnelingType);

#endif //#ifdef USE_EAP_EXPANDED_TYPES

	EAP_TRACE_DEBUG_SYMBIAN(

		(_L("EapTlsPeapUtils::OpenTlsDatabaseL -Start- aIndexType=%d, aIndex=%d, Tunneling vendor type=%d \n"),

		aIndexType,aIndex, aTunnelingVendorType));

	// 1. Open/create a database	

	// Connect to the DBMS server.

	User::LeaveIfError(aSession.Connect());		

	CleanupClosePushL(aSession);	

	// aSession and aDatabase are pushed to the cleanup stack even though they may be member

	// variables of the calling class and would be closed in the destructor anyway. This ensures

	// that if they are not member variables they will be closed. Closing the handle twice

	// does no harm.	

#ifdef SYMBIAN_SECURE_DBMS

	// Create the secure shared database with the specified secure policy.

	// Database will be created in the data caging path for DBMS (C:\private\100012a5).

	TInt err = aDatabase.Create(aSession, KTlsDatabaseName, KSecureUIDFormat);

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapTlsPeapUtils::OpenTlsDatabaseL - Created Secure DB for eaptls.dat. err=%d\n"), err) );

	if(err == KErrNone)

	{

		aDatabase.Close();

	} else if (err != KErrAlreadyExists) 

	{

		User::LeaveIfError(err);

	}

	User::LeaveIfError(aDatabase.Open(aSession, KTlsDatabaseName, KSecureUIDFormat));

	CleanupClosePushL(aDatabase);		

#else

	// For non-secured database. The database will be created in the old location (c:\system\data).

	RFs fsSession;		

	User::LeaveIfError(fsSession.Connect());

	CleanupClosePushL(fsSession);	

	TInt err = aDatabase.Create(fsSession, KTlsDatabaseName);

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapTlsPeapUtils::OpenTlsDatabaseL - Created Non-Secure DB for eaptls.dat. err=%d\n"), err) );

	if(err == KErrNone)

	{

		aDatabase.Close();

	} else if (err != KErrAlreadyExists) 

	{

		User::LeaveIfError(err);

	}

	User::LeaveIfError(aDatabase.Open(fsSession, KTlsDatabaseName));

	CleanupStack::PopAndDestroy(); // close fsSession

	CleanupClosePushL(aDatabase);		

#endif // #ifdef SYMBIAN_SECURE_DBMS

	// 2. Create the eaptls table to database (ignore error if exists)

// Table columns:

//// NAME ////////////////////////////////////////// TYPE //////////// Constant ////////////////////

//| ServiceType									| UNSIGNED INTEGER | KServiceType         |//

//| ServiceIndex								| UNSIGNED INTEGER | KServiceIndex        |//

//| TunnelingType								| UNSIGNED INTEGER | KTunnelingType		|//

//| EAP_TLS_PEAP_use_manual_realm				| UNSIGNED INTEGER | cf_str_EAP_TLS_PEAP_use_manual_realm_literal      |//

//| EAP_TLS_PEAP_manual_realm					| VARCHAR(255)     | cf_str_EAP_TLS_PEAP_manual_realm_literal				|//

//| EAP_TLS_PEAP_use_manual_username			| UNSIGNED INTEGER | cf_str_EAP_TLS_PEAP_use_manual_username_literal   |//

//| EAP_TLS_PEAP_manual_username				| VARCHAR(255)     | cf_str_EAP_TLS_PEAP_manual_username_literal			|//

//| EAP_TLS_PEAP_cipher_suite					| UNSIGNED INTEGER | cf_str_EAP_TLS_PEAP_cipher_suite_literal	    |//

//| EAP_TLS_server_authenticates_client			| UNSIGNED INTEGER | cf_str_TLS_server_authenticates_client_policy_in_client_literal |//

//| CA_cert_label								| VARCHAR(255)     | KCACertLabelOld	    |//

//| client_cert_label							| VARCHAR(255)     | KClientCertLabel	    |//

//| EAP_TLS_PEAP_saved_session_id				| BINARY(32)       | cf_str_EAP_TLS_PEAP_saved_session_id_literal		    |//

//| EAP_TLS_PEAP_saved_master_secret			| BINARY(48)       | cf_str_EAP_TLS_PEAP_saved_master_secret_literal	    |//

//| EAP_TLS_PEAP_saved_cipher_suite				| UNSIGNED INTEGER | cf_str_EAP_TLS_PEAP_saved_cipher_suite_literal    |//

//| EAP_TLS_PEAP_verify_certificate_realm		| UNSIGNED INTEGER | cf_str_EAP_TLS_PEAP_verify_certificate_realm_literal		    |//

//| EAP_TLS_max_session_validity_time			| BIGINT	   	 	| cf_str_EAP_TLS_max_session_validity_time_literal   |//

//| EAP_TLS_last_full_authentication_time		| BIGINT	   		| KTLSLastFullAuthTime	   	|//	

//| EAP_TLS_PEAP_use_identity_privacy	    	| UNSIGNED INTEGER 	| cf_str_EAP_TLS_PEAP_use_identity_privacy_literal|//

///////////////////////////////////////////////////////////////////////////////////////////////////////////////	

	HBufC* buf = HBufC::NewLC(KMaxSqlQueryLength);

	TPtr sqlStatement = buf->Des();

	// Table creation is divided into two parts because otherwise the SQL string would get too long

	_LIT(KSQLCreateTable1, "CREATE TABLE %S (%S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S VARCHAR(%d),     \

											 %S UNSIGNED INTEGER, \

											 %S VARCHAR(%d),     \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S VARCHAR(%d),	  \

											 %S VARCHAR(%d),     \

											 %S BINARY(%d),		  \

											 %S BINARY(%d),		  \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S BIGINT, \

											 %S BIGINT, \

											 %S UNSIGNED INTEGER)");

	sqlStatement.Format(KSQLCreateTable1,

		&KTlsDatabaseTableName,

		&KServiceType,

		&KServiceIndex,

		&KTunnelingType,

		&cf_str_EAP_TLS_PEAP_use_manual_realm_literal,

		&cf_str_EAP_TLS_PEAP_manual_realm_literal, KMaxManualRealmLengthInDB,

		&cf_str_EAP_TLS_PEAP_use_manual_username_literal,

		&cf_str_EAP_TLS_PEAP_manual_username_literal, KMaxManualUsernameLengthInDB,

		&cf_str_EAP_TLS_PEAP_cipher_suite_literal, 

		&cf_str_TLS_server_authenticates_client_policy_in_client_literal,

		&KCACertLabelOld, KMaxCertLabelLengthInDB,

		&KClientCertLabel, KMaxCertLabelLengthInDB,

		&cf_str_EAP_TLS_PEAP_saved_session_id_literal, KMaxSessionIdLengthInDB,

		&cf_str_EAP_TLS_PEAP_saved_master_secret_literal, KMaxMasterSecretLengthInDB,

		&cf_str_EAP_TLS_PEAP_saved_cipher_suite_literal,

		&cf_str_EAP_TLS_PEAP_verify_certificate_realm_literal,		

		&cf_str_EAP_TLS_max_session_validity_time_literal,

		&KTLSLastFullAuthTime,

		&cf_str_EAP_TLS_PEAP_use_identity_privacy_literal);	

	err = aDatabase.Execute(sqlStatement);

	if (err == KErrAlreadyExists)

	{

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapTlsPeapUtils::OpenTlsDatabaseL - Alter Table err=%d\n"), err) );

	_LIT( KColumnDef, "UNSIGNED INTEGER" );

	AlterTableL( aDatabase, EAddColumn , KTlsDatabaseTableName,

			cf_str_EAP_TLS_PEAP_use_identity_privacy_literal, KColumnDef);

	}

	else if (err != KErrNone)

		{

		User::Leave(err);

		}

	// Create table for _allowed_ user certificates

//// NAME ////////////////// TYPE ////////////// Constant ///////////

//| ServiceType			| UNSIGNED INTEGER | KServiceType        |//

//| ServiceIndex		| UNSIGNED INTEGER | KServiceIndex       |//

//| TunnelingType		| UNSIGNED INTEGER | KTunnelingType		|//

//| CertLabel			| VARCHAR(255)     | KCertLabel        |//	

//| SubjectKeyId		| BINARY(20)	   | KSubjectKeyIdentifier |// This is Symbian subjectkey id

//| ActualSubjectKeyId  | BINARY(20)	   | KActualSubjectKeyIdentifier |// This is the actual subjectkeyid present in the certificate.

//| SubjectName			| VARCHAR(255)     | KSubjectName        |//	

//| IssuerName			| VARCHAR(255)     | KIssuerName        |//	

//| SerialNumber		| VARCHAR(255)     | KSerialNumber        |//	

//| Thumbprint			| BINARY(64)	   | KThumbprint        |//	

//////////////////////////////////////////////////////////////////////////////////////////////////////	

	_LIT(KSQLCreateTable2, "CREATE TABLE %S (%S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S VARCHAR(%d), \

											 %S BINARY(%d), \

											 %S BINARY(%d), \

											 %S VARCHAR(%d), \

											 %S VARCHAR(%d), \

											 %S VARCHAR(%d), \

											 %S BINARY(%d))");											 

	sqlStatement.Format(KSQLCreateTable2, &KTlsAllowedUserCertsDatabaseTableName, 

		&KServiceType, 

		&KServiceIndex, 

		&KTunnelingType, 

		&KCertLabel, KMaxCertLabelLengthInDB,

		&KSubjectKeyIdentifier, KMaxSubjectKeyIdLengthInDB,

		&KActualSubjectKeyIdentifier, KKeyIdentifierLength,

		&KSubjectName, KGeneralStringMaxLength,

		&KIssuerName, KGeneralStringMaxLength,

		&KSerialNumber, KGeneralStringMaxLength,

		&KThumbprint, KThumbprintMaxLength);

	err = aDatabase.Execute(sqlStatement);

	if (err != KErrNone && err != KErrAlreadyExists)

	{

		User::Leave(err);

	}

	// Create table for _allowed_ CA certs

//// NAME ////////////////// TYPE ////////////// Constant ///////////

//| ServiceType		    | UNSIGNED INTEGER | KServiceType        |//

//| ServiceIndex		| UNSIGNED INTEGER | KServiceIndex       |//

//| TunnelingType		| UNSIGNED INTEGER | KTunnelingType		|//

//| CertLabel			| VARCHAR(255)     | KCACertLabel        |//	

//| SubjectKeyId		| BINARY(255)	   | KSubjectKeyIdentifier |// This is Symbian subjectkey id

//| ActualSubjectKeyId  | BINARY(20)	   | KActualSubjectKeyIdentifier |// This is the actual subjectkeyid present in the certificate.

//| SubjectName			| VARCHAR(255)     | KSubjectName        |//	

//| IssuerName			| VARCHAR(255)     | KIssuerName        |//	

//| SerialNumber		| VARCHAR(255)     | KSerialNumber        |//	

//| Thumbprint			| BINARY(64)	   | KThumbprint        |//	

//////////////////////////////////////////////////////////////////////////////////////////////////////	

	_LIT(KSQLCreateTable3, "CREATE TABLE %S (%S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S VARCHAR(%d), \

											 %S BINARY(%d), \

											 %S BINARY(%d), \

											 %S VARCHAR(%d), \

											 %S VARCHAR(%d), \

											 %S VARCHAR(%d), \

											 %S BINARY(%d))");											 

	sqlStatement.Format(KSQLCreateTable3, &KTlsAllowedCACertsDatabaseTableName, 

		&KServiceType, 

		&KServiceIndex, 

		&KTunnelingType, 

		&KCertLabel, KMaxCertLabelLengthInDB,

		&KSubjectKeyIdentifier, KMaxSubjectKeyIdLengthInDB,

		&KActualSubjectKeyIdentifier, KKeyIdentifierLength,

		&KSubjectName, KGeneralStringMaxLength,

		&KIssuerName, KGeneralStringMaxLength,

		&KSerialNumber, KGeneralStringMaxLength,

		&KThumbprint, KThumbprintMaxLength);

	err = aDatabase.Execute(sqlStatement);

	if (err != KErrNone && err != KErrAlreadyExists)

	{

		User::Leave(err);

	}

	// Create table for allowed cipher suites

//// NAME ///////////////// TYPE ////////////// Constant ///////////

//| ServiceType			| UNSIGNED INTEGER | KServiceType        |//

//| ServiceIndex		| UNSIGNED INTEGER | KServiceIndex       |//

//| TunnelingType		| UNSIGNED INTEGER | KTunnelingType		|//

//| CipherSuite			| UNSIGNED INTEGER | KCipherSuite        |//	

//////////////////////////////////////////////////////////////////////////////////////////////////////	

	_LIT(KSQLCreateTable4, "CREATE TABLE %S (%S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER, \

											 %S UNSIGNED INTEGER)");

	sqlStatement.Format(KSQLCreateTable4, &KTlsAllowedCipherSuitesDatabaseTableName, 

		&KServiceType, 

		&KServiceIndex, 

		&KTunnelingType, 

		&KCipherSuite);

	err = aDatabase.Execute(sqlStatement);

	if (err != KErrNone && err != KErrAlreadyExists)

	{

		User::Leave(err);

	}

	// 4. Check if database table contains a row for this service type and id 

	_LIT(KSQLQueryRow, "SELECT %S FROM %S WHERE %S=%d AND %S=%d AND %S=%d");

	sqlStatement.Format(KSQLQueryRow, &cf_str_EAP_TLS_PEAP_cipher_suite_literal, &KTlsDatabaseTableName, 

		&KServiceType, aIndexType, &KServiceIndex, aIndex, &KTunnelingType, aTunnelingVendorType);	

	RDbView view;

	User::LeaveIfError(view.Prepare(aDatabase, TDbQuery(sqlStatement), TDbWindow::EUnlimited));

	// View must be closed when no longer needed

	CleanupClosePushL(view);

	User::LeaveIfError(view.EvaluateAll());

	// 5. If row is not found then add it

	TInt rows = view.CountL();

	CleanupStack::PopAndDestroy(); // view

	if (rows == 0)

	{

		_LIT(KSQLInsert, "SELECT * FROM %S");

		sqlStatement.Format(KSQLInsert, &KTlsDatabaseTableName);	

		User::LeaveIfError(view.Prepare(aDatabase, TDbQuery(sqlStatement), TDbWindow::EUnlimited, RDbView::EInsertOnly));

		CleanupClosePushL(view);

		view.InsertL();

		// Get column set so we get the correct column numbers

		CDbColSet* colSet = view.ColSetL();

		CleanupStack::PushL(colSet);

		// Set the default values. The other three tables (certs, ca certs & cipher suites) are empty by default.

		view.SetColL(colSet->ColNo(KServiceType), static_cast<TInt>(aIndexType));

		view.SetColL(colSet->ColNo(KServiceIndex), aIndex);

		view.SetColL(colSet->ColNo(KTunnelingType), aTunnelingVendorType);

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_use_manual_realm_literal), default_EAP_TLS_PEAP_use_manual_realm);

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_manual_realm_literal), default_EAP_TLS_PEAP_manual_realm);

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_use_manual_username_literal), default_EAP_TLS_PEAP_use_manual_username);

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_manual_username_literal), default_EAP_TLS_PEAP_manual_username);

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_cipher_suite_literal), default_EAP_TLS_PEAP_cipher_suite);

		view.SetColL(colSet->ColNo(cf_str_TLS_server_authenticates_client_policy_in_client_literal), default_EAP_TLS_server_authenticates_client);

		view.SetColL(colSet->ColNo(KCACertLabelOld), default_CA_cert_label);

		view.SetColL(colSet->ColNo(KClientCertLabel), default_client_cert_label);

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_verify_certificate_realm_literal), default_EAP_TLS_PEAP_verify_certificate_realm);

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_max_session_validity_time_literal), default_MaxSessionTime);		

		view.SetColL(colSet->ColNo(KTLSLastFullAuthTime), default_FullAuthTime);		

		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_use_identity_privacy_literal), default_EAP_TLS_PEAP_TLS_Privacy);		

		view.PutL();

		CleanupStack::PopAndDestroy( colSet ); // Delete colSet.		

		CleanupStack::PopAndDestroy( &view ); // Close view.

		// Add default disabled cipher suites

		_LIT(KSQLInsert2, "SELECT * FROM %S");

		sqlStatement.Format(KSQLInsert2, &KTlsAllowedCipherSuitesDatabaseTableName);

		User::LeaveIfError(view.Prepare(aDatabase, TDbQuery(sqlStatement), TDbWindow::EUnlimited, RDbView::EInsertOnly));

		CleanupClosePushL(view);

		// Get column set so we get the correct column numbers

		colSet = view.ColSetL();

		CleanupStack::PushL(colSet);

		TInt i(0);

		while (default_allowed_cipher_suites[i] != 0)

		{

			view.InsertL();

			view.SetColL(colSet->ColNo(KServiceType), static_cast<TInt>(aIndexType));

			view.SetColL(colSet->ColNo(KServiceIndex), aIndex);			

			view.SetColL(colSet->ColNo(KTunnelingType), aTunnelingVendorType);

			view.SetColL(colSet->ColNo(KCipherSuite), default_allowed_cipher_suites[i]);

			view.PutL();

			i++;

		}

		CleanupStack::PopAndDestroy( colSet ); // Delete colSet.		

		CleanupStack::PopAndDestroy( &view ); // Close view.

	}

	// 6. Do the altering of tables here. 

	//    Add columns to existing certificate DB tables for Serial number, Issuer name etc. 

	TBufC<KDbMaxColName> tableName;

	// For the table _allowed_ USER certificates

	tableName = KTlsAllowedUserCertsDatabaseTableName;	

	AddExtraCertColumnsL(aDatabase,tableName);

	// For the table _allowed_ CA certificates	

	tableName = KTlsAllowedCACertsDatabaseTableName;	

	AddExtraCertColumnsL(aDatabase,tableName);

	CleanupStack::PopAndDestroy( buf ); // Delete buf or sqlStatement	

	CleanupStack::Pop( &aDatabase );	

	CleanupStack::Pop( &aSession );	

	aDatabase.Compact();

}

void EapTlsPeapUtils::OpenPeapDatabaseL(

		RDbNamedDatabase& aDatabase, 

		RDbs& aSession, 

		const TIndexType aIndexType, 

		const TInt aIndex,

		const eap_type_value_e aTunnelingType)

{

#ifdef USE_EAP_EXPANDED_TYPES

	TUint aTunnelingVendorType = aTunnelingType.get_vendor_type();

#else

	TUint aTunnelingVendorType = static_cast<TUint>(aTunnelingType);

#endif //#ifdef USE_EAP_EXPANDED_TYPES

	EAP_TRACE_DEBUG_SYMBIAN(

		(_L("EapTlsPeapUtils::OpenPeapDatabaseL -Start- aIndexType=%d, aIndex=%d, Tunneling vendor type=%d \n"),

		aIndexType,aIndex, aTunnelingVendorType));

	// 1. Open/create a database	

	// Connect to the DBMS server.

	User::LeaveIfError(aSession.Connect());		

	CleanupClosePushL(aSession);	

	// aSession and aDatabase are pushed to the cleanup stack even though they may be member

	// variables of the calling class and would be closed in the destructor anyway. This ensures

	// that if they are not member variables they will be closed. Closing the handle twice

	// does no harm.	

#ifdef SYMBIAN_SECURE_DBMS

	// Create the secure shared database with the specified secure policy.

	// Database will be created in the data caging path for DBMS (C:\private\100012a5).

	TInt err = aDatabase.Create(aSession, KPeapDatabaseName, KSecureUIDFormat);

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapTlsPeapUtils::OpenPeapDatabaseL - Created Secure DB for eappeap.dat. err=%d\n"), err) );

	if(err == KErrNone)

	{

		aDatabase.Close();

	} else if (err != KErrAlreadyExists) 

	{