1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  EAP and WLAN authentication protocols.

    15 *

    16 */

    17 

    18 

    19 // This is enumeration of EAPOL source code.

    20 #if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

    21 	#undef EAP_FILE_NUMBER_ENUM

    22 	#define EAP_FILE_NUMBER_ENUM 438 

    23 	#undef EAP_FILE_NUMBER_DATE 

    24 	#define EAP_FILE_NUMBER_DATE 1127594498 

    25 #endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

    26 

    27 

    28 // INCLUDE FILES

    29 #include "EapTlsPeapUtils.h"

    30 #include "EapTlsPeapDbDefaults.h"

    31 #include "EapTlsPeapDbParameterNames.h"

    32 #include <x500dn.h>

    33 #include <x509cert.h>

    34 #include <x509certext.h>

    35 

    36 #ifdef USE_FAST_EAP_TYPE

    37 #include "pac_store_db_parameters.h"

    38 #endif //#ifdef USE_FAST_EAP_TYPE

    39 

    40 #include "eap_am_trace_symbian.h"

    41 #include "EapTlsPeapCertFetcher.h"

    42 

    43 const TUint KMaxSqlQueryLength = 2048;

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

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

    46 const TInt 	KMaxEapDbTableNameLength = 64;

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

    48 

    49 void EapTlsPeapUtils::OpenDatabaseL(

    50 	RDbNamedDatabase& aDatabase, 

    51 	RDbs& aSession, 

    52 	const TIndexType aIndexType,

    53 	const TInt aIndex, 

    54 	const eap_type_value_e aTunnelingType,

    55 	eap_type_value_e aEapType)

    56 {

    57 #ifdef USE_EAP_EXPANDED_TYPES

    58 

    59 	EAP_TRACE_DEBUG_SYMBIAN(

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

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

    62 #else

    63 

    64 	EAP_TRACE_DEBUG_SYMBIAN(

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

    66 		aIndexType,aIndex, aTunnelingType, aEapType));

    67 

    68 #endif //#ifdef USE_EAP_EXPANDED_TYPES

    69 

    70 	if (aEapType == eap_type_tls)

    71 	{

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

    73 	} 

    74 	else if (aEapType == eap_type_peap)

    75 	{

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

    77 	} 

    78 #if defined(USE_TTLS_EAP_TYPE)

    79 	else if (aEapType == eap_type_ttls)

    80 	{

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

    82 	} 

    83 #endif // #if defined(USE_TTLS_EAP_TYPE)

    84 #if defined(USE_FAST_EAP_TYPE)

    85 	else if (aEapType == eap_type_fast)

    86 	{

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

    88 	} 

    89 #endif // #if defined(USE_FAST_EAP_TYPE)

    90 	

    91 	else if ( aEapType == eap_type_ttls_plain_pap )

    92 		{

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

    94 		}

    95 	

    96 	else

    97 	{

    98 		// Unsupported EAP type

    99 		User::Leave(KErrNotSupported);

   100 	}	

   101 } // EapTlsPeapUtils::OpenDatabaseL()

   102 

   103 void EapTlsPeapUtils::OpenTlsDatabaseL(

   104 		RDbNamedDatabase& aDatabase, 

   105 		RDbs& aSession, 

   106 		const TIndexType aIndexType, 

   107 		const TInt aIndex,

   108 		const eap_type_value_e aTunnelingType)

   109 {

   110 #ifdef USE_EAP_EXPANDED_TYPES

   111 

   112 	TUint aTunnelingVendorType = aTunnelingType.get_vendor_type();

   113 

   114 #else

   115 

   116 	TUint aTunnelingVendorType = static_cast<TUint>(aTunnelingType);

   117 

   118 #endif //#ifdef USE_EAP_EXPANDED_TYPES

   119 

   120 	EAP_TRACE_DEBUG_SYMBIAN(

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

   122 		aIndexType,aIndex, aTunnelingVendorType));

   123 

   124 	// 1. Open/create a database	

   125 	

   126 	// Connect to the DBMS server.

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

   128 	CleanupClosePushL(aSession);	

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

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

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

   132 	// does no harm.	

   133 	

   134 #ifdef SYMBIAN_SECURE_DBMS

   135 	

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

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

   138 	

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

   140 	

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

   142 	

   143 	if(err == KErrNone)

   144 	{

   145 		aDatabase.Close();

   146 		

   147 	} else if (err != KErrAlreadyExists) 

   148 	{

   149 		User::LeaveIfError(err);

   150 	}

   151 	

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

   153 	CleanupClosePushL(aDatabase);		

   154 		

   155 #else

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

   157 	

   158 	RFs fsSession;		

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

   160 	CleanupClosePushL(fsSession);	

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

   162 

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

   164 	

   165 	if(err == KErrNone)

   166 	{

   167 		aDatabase.Close();

   168 		

   169 	} else if (err != KErrAlreadyExists) 

   170 	{

   171 		User::LeaveIfError(err);

   172 	}

   173 	

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

   175 	

   176 	CleanupStack::PopAndDestroy(); // close fsSession

   177 	

   178 	CleanupClosePushL(aDatabase);		

   179 	    

   180 #endif // #ifdef SYMBIAN_SECURE_DBMS

   181 

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

   183 	

   184 // Table columns:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   201 //| EAP_TLS_max_session_validity_time			| BIGINT	   	 	| cf_str_EAP_TLS_max_session_validity_time_literal   |//

   202 //| EAP_TLS_last_full_authentication_time		| BIGINT	   		| KTLSLastFullAuthTime	   	|//	

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

   204 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////	

   205 

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

   207 	TPtr sqlStatement = buf->Des();

   208 	

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

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

   211 											 %S UNSIGNED INTEGER, \

   212 											 %S UNSIGNED INTEGER, \

   213 											 %S UNSIGNED INTEGER, \

   214 											 %S VARCHAR(%d),     \

   215 											 %S UNSIGNED INTEGER, \

   216 											 %S VARCHAR(%d),     \

   217 											 %S UNSIGNED INTEGER, \

   218 											 %S UNSIGNED INTEGER, \

   219 											 %S VARCHAR(%d),	  \

   220 											 %S VARCHAR(%d),     \

   221 											 %S BINARY(%d),		  \

   222 											 %S BINARY(%d),		  \

   223 											 %S UNSIGNED INTEGER, \

   224 											 %S UNSIGNED INTEGER, \

   225 											 %S BIGINT, \

   226 											 %S BIGINT, \

   227 											 %S UNSIGNED INTEGER)");

   228 											 

   229 	sqlStatement.Format(KSQLCreateTable1,

   230 		&KTlsDatabaseTableName,

   231 		&KServiceType,

   232 		&KServiceIndex,

   233 		&KTunnelingType,

   234 		&cf_str_EAP_TLS_PEAP_use_manual_realm_literal,

   235 		&cf_str_EAP_TLS_PEAP_manual_realm_literal, KMaxManualRealmLengthInDB,

   236 		&cf_str_EAP_TLS_PEAP_use_manual_username_literal,

   237 		&cf_str_EAP_TLS_PEAP_manual_username_literal, KMaxManualUsernameLengthInDB,

   238 		&cf_str_EAP_TLS_PEAP_cipher_suite_literal, 

   239 		&cf_str_TLS_server_authenticates_client_policy_in_client_literal,

   240 		&KCACertLabelOld, KMaxCertLabelLengthInDB,

   241 		&KClientCertLabel, KMaxCertLabelLengthInDB,

   242 		&cf_str_EAP_TLS_PEAP_saved_session_id_literal, KMaxSessionIdLengthInDB,

   243 		&cf_str_EAP_TLS_PEAP_saved_master_secret_literal, KMaxMasterSecretLengthInDB,

   244 		&cf_str_EAP_TLS_PEAP_saved_cipher_suite_literal,

   245 		&cf_str_EAP_TLS_PEAP_verify_certificate_realm_literal,		

   246 		&cf_str_EAP_TLS_max_session_validity_time_literal,

   247 		&KTLSLastFullAuthTime,

   248 		&cf_str_EAP_TLS_PEAP_use_identity_privacy_literal);	

   249 	

   250 	err = aDatabase.Execute(sqlStatement);

   251 	if (err == KErrAlreadyExists)

   252 	{

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

   254 	_LIT( KColumnDef, "UNSIGNED INTEGER" );

   255 	AlterTableL( aDatabase, EAddColumn , KTlsDatabaseTableName,

   256 			cf_str_EAP_TLS_PEAP_use_identity_privacy_literal, KColumnDef);

   257 	}

   258 	else if (err != KErrNone)

   259 		{

   260 		User::Leave(err);

   261 		}

   262 

   263 	// Create table for _allowed_ user certificates

   264 	

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

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

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

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

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

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

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

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

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

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

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

   276 //////////////////////////////////////////////////////////////////////////////////////////////////////	

   277 	

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

   279 											 %S UNSIGNED INTEGER, \

   280 											 %S UNSIGNED INTEGER, \

   281 											 %S VARCHAR(%d), \

   282 											 %S BINARY(%d), \

   283 											 %S BINARY(%d), \

   284 											 %S VARCHAR(%d), \

   285 											 %S VARCHAR(%d), \

   286 											 %S VARCHAR(%d), \

   287 											 %S BINARY(%d))");											 

   288 											 

   289 	sqlStatement.Format(KSQLCreateTable2, &KTlsAllowedUserCertsDatabaseTableName, 

   290 		&KServiceType, 

   291 		&KServiceIndex, 

   292 		&KTunnelingType, 

   293 		&KCertLabel, KMaxCertLabelLengthInDB,

   294 		&KSubjectKeyIdentifier, KMaxSubjectKeyIdLengthInDB,

   295 		&KActualSubjectKeyIdentifier, KKeyIdentifierLength,

   296 		&KSubjectName, KGeneralStringMaxLength,

   297 		&KIssuerName, KGeneralStringMaxLength,

   298 		&KSerialNumber, KGeneralStringMaxLength,

   299 		&KThumbprint, KThumbprintMaxLength);

   300 				

   301 	err = aDatabase.Execute(sqlStatement);

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

   303 	{

   304 		User::Leave(err);

   305 	}

   306 

   307 	// Create table for _allowed_ CA certs

   308 

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

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

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

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

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

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

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

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

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

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

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

   320 //////////////////////////////////////////////////////////////////////////////////////////////////////	

   321 

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

   323 											 %S UNSIGNED INTEGER, \

   324 											 %S UNSIGNED INTEGER, \

   325 											 %S VARCHAR(%d), \

   326 											 %S BINARY(%d), \

   327 											 %S BINARY(%d), \

   328 											 %S VARCHAR(%d), \

   329 											 %S VARCHAR(%d), \

   330 											 %S VARCHAR(%d), \

   331 											 %S BINARY(%d))");											 

   332 											 

   333 	sqlStatement.Format(KSQLCreateTable3, &KTlsAllowedCACertsDatabaseTableName, 

   334 		&KServiceType, 

   335 		&KServiceIndex, 

   336 		&KTunnelingType, 

   337 		&KCertLabel, KMaxCertLabelLengthInDB,

   338 		&KSubjectKeyIdentifier, KMaxSubjectKeyIdLengthInDB,

   339 		&KActualSubjectKeyIdentifier, KKeyIdentifierLength,

   340 		&KSubjectName, KGeneralStringMaxLength,

   341 		&KIssuerName, KGeneralStringMaxLength,

   342 		&KSerialNumber, KGeneralStringMaxLength,

   343 		&KThumbprint, KThumbprintMaxLength);

   344 		

   345 	err = aDatabase.Execute(sqlStatement);

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

   347 	{

   348 		User::Leave(err);

   349 	}

   350 

   351 	// Create table for allowed cipher suites

   352 

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

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

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

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

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

   358 //////////////////////////////////////////////////////////////////////////////////////////////////////	

   359 	

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

   361 											 %S UNSIGNED INTEGER, \

   362 											 %S UNSIGNED INTEGER, \

   363 											 %S UNSIGNED INTEGER)");

   364 

   365 	sqlStatement.Format(KSQLCreateTable4, &KTlsAllowedCipherSuitesDatabaseTableName, 

   366 		&KServiceType, 

   367 		&KServiceIndex, 

   368 		&KTunnelingType, 

   369 		&KCipherSuite);

   370 		

   371 	err = aDatabase.Execute(sqlStatement);

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

   373 	{

   374 		User::Leave(err);

   375 	}

   376 	

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

   378 		

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

   380 	

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

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

   383 	

   384 	RDbView view;

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

   386 	// View must be closed when no longer needed

   387 	CleanupClosePushL(view);

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

   389 	

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

   391 	

   392 	TInt rows = view.CountL();

   393 	CleanupStack::PopAndDestroy(); // view

   394 	if (rows == 0)

   395 	{

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

   397 		sqlStatement.Format(KSQLInsert, &KTlsDatabaseTableName);	

   398 

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

   400 		CleanupClosePushL(view);

   401 		view.InsertL();

   402 

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

   404 		CDbColSet* colSet = view.ColSetL();

   405 		CleanupStack::PushL(colSet);

   406 

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

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

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

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

   411 		

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

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

   414 		

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

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

   417 		

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

   419 		

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

   421 		

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

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

   424 		

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

   426 		

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

   428 		

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

   430 

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

   432 		view.PutL();

   433 

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

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

   436 		

   437 		// Add default disabled cipher suites

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

   439 		sqlStatement.Format(KSQLInsert2, &KTlsAllowedCipherSuitesDatabaseTableName);

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

   441 		CleanupClosePushL(view);

   442 

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

   444 		colSet = view.ColSetL();

   445 		CleanupStack::PushL(colSet);

   446 

   447 		TInt i(0);

   448 		while (default_allowed_cipher_suites[i] != 0)

   449 		{

   450 			view.InsertL();

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

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

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

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

   455 			view.PutL();

   456 			i++;

   457 		}

   458 		

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

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

   461 	}

   462 	

   463 	// 6. Do the altering of tables here. 

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

   465 

   466 	TBufC<KDbMaxColName> tableName;

   467 

   468 	// For the table _allowed_ USER certificates

   469 	tableName = KTlsAllowedUserCertsDatabaseTableName;	

   470 	AddExtraCertColumnsL(aDatabase,tableName);

   471 	

   472 	// For the table _allowed_ CA certificates	

   473 	tableName = KTlsAllowedCACertsDatabaseTableName;	

   474 	AddExtraCertColumnsL(aDatabase,tableName);

   475 	

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

   477 	CleanupStack::Pop( &aDatabase );	

   478 	CleanupStack::Pop( &aSession );	

   479 	

   480 	aDatabase.Compact();

   481 }

   482 

   483 void EapTlsPeapUtils::OpenPeapDatabaseL(

   484 		RDbNamedDatabase& aDatabase, 

   485 		RDbs& aSession, 

   486 		const TIndexType aIndexType, 

   487 		const TInt aIndex,

   488 		const eap_type_value_e aTunnelingType)

   489 {

   490 #ifdef USE_EAP_EXPANDED_TYPES

   491 

   492 	TUint aTunnelingVendorType = aTunnelingType.get_vendor_type();

   493 

   494 #else

   495 

   496 	TUint aTunnelingVendorType = static_cast<TUint>(aTunnelingType);

   497 

   498 #endif //#ifdef USE_EAP_EXPANDED_TYPES

   499 

   500 	EAP_TRACE_DEBUG_SYMBIAN(

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

   502 		aIndexType,aIndex, aTunnelingVendorType));

   503 

   504 	// 1. Open/create a database	

   505 	

   506 	// Connect to the DBMS server.

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

   508 	CleanupClosePushL(aSession);	

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

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

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

   512 	// does no harm.	

   513 	

   514 #ifdef SYMBIAN_SECURE_DBMS

   515 	

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

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

   518 	

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

   520 	

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

   522 	

   523 	if(err == KErrNone)

   524 	{

   525 		aDatabase.Close();

   526 		

   527 	} else if (err != KErrAlreadyExists) 

   528 	{

   529 		User::LeaveIfError(err);

   530 	}

   531 	

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

   533 	CleanupClosePushL(aDatabase);		

   534 		

   535 #else

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

   537 	

   538 	RFs fsSession;		

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

   540 	CleanupClosePushL(fsSession);	

   541 	TInt err = aDatabase.Create(fsSession, KPeapDatabaseName);

   542 	

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

   544 	

   545 	if(err == KErrNone)

   546 	{

   547 		aDatabase.Close();

   548 		

   549 	} else if (err != KErrAlreadyExists) 

   550 	{

   551 		User::LeaveIfError(err);

   552 	}

   553 	

   554 	User::LeaveIfError(aDatabase.Open(fsSession, KPeapDatabaseName));

   555 	

   556 	CleanupStack::PopAndDestroy(); // close fsSession

   557 	

   558 	CleanupClosePushL(aDatabase);		

   559 	    

   560 #endif // #ifdef SYMBIAN_SECURE_DBMS

   561 

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

   563 	

   564 // Table columns:

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

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

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

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

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

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

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

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

   573 //| EAP_TLS_PEAP_max_count_of_session_resumes		| UNSIGNED INTEGER 	| cf_str_EAP_TLS_PEAP_max_count_of_session_resumes_literal    |//

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

   575 //| EAP_TLS_PEAP_used_PEAP_version					| UNSIGNED INTEGER 	| cf_str_EAP_TLS_PEAP_used_PEAP_version_literal		    |//

   576 //| EAP_TLS_PEAP_accepted_PEAP_versions				| BINARY(12)	    | cf_str_EAP_TLS_PEAP_accepted_PEAP_versions_literal|//

   577 //| PEAP_accepted_tunneled_client_types			   	| VARBINARY(240) 	| cf_str_PEAP_accepted_tunneled_client_types_hex_data_literal      |//

   578 //| PEAP_unaccepted_tunneled_client_types		   	| VARBINARY(240) 	| cf_str_PEAP_unaccepted_tunneled_client_types_hex_data_literal      |//

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

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

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

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

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

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

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

   586 //| EAP_PEAP_max_session_validity_time				| BIGINT	   		| cf_str_EAP_PEAP_max_session_validity_time_literal   |//

   587 //| EAP_PEAP_last_full_authentication_time			| BIGINT	   		| KPEAPLastFullAuthTime	   	|//	

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

   589 //////////////////////////////////////////////////////////////////////////////////////////////////////////////	

   590 

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

   592 	TPtr sqlStatement = buf->Des();

   593 

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

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

   596 											 %S UNSIGNED INTEGER, \

   597 											 %S UNSIGNED INTEGER, \

   598 											 %S UNSIGNED INTEGER, \

   599 											 %S VARCHAR(%d),     \

   600 											 %S UNSIGNED INTEGER, \

   601 											 %S VARCHAR(%d),     \

   602 											 %S UNSIGNED INTEGER, \

   603 											 %S UNSIGNED INTEGER, \

   604 											 %S BINARY(%d),		  \

   605 											 %S VARBINARY(%d),	  \

   606 											 %S VARBINARY(%d),	  \

   607 											 %S UNSIGNED INTEGER, \

   608 											 %S VARCHAR(%d),	  \

   609 											 %S VARCHAR(%d),     \

   610 											 %S BINARY(%d),		  \

   611 											 %S BINARY(%d),		  \

   612 											 %S UNSIGNED INTEGER, \

   613 											 %S UNSIGNED INTEGER, \

   614 											 %S BIGINT, \

   615 											 %S BIGINT, \

   616 											 %S UNSIGNED INTEGER)");

   617 	sqlStatement.Format(KSQLCreateTable1,

   618 		&KPeapDatabaseTableName,

   619 		&KServiceType,

   620 		&KServiceIndex,

   621 		&KTunnelingType,

   622 		&cf_str_EAP_TLS_PEAP_use_manual_realm_literal,

   623 		&cf_str_EAP_TLS_PEAP_manual_realm_literal, KMaxManualRealmLengthInDB,

   624 		&cf_str_EAP_TLS_PEAP_use_manual_username_literal,

   625 		&cf_str_EAP_TLS_PEAP_manual_username_literal, KMaxManualUsernameLengthInDB,

   626 		&cf_str_EAP_TLS_PEAP_cipher_suite_literal,

   627 		&cf_str_EAP_TLS_PEAP_used_PEAP_version_literal,

   628 		&cf_str_EAP_TLS_PEAP_accepted_PEAP_versions_literal, KMaxPEAPVersionsStringLengthInDB,

   629 		&cf_str_PEAP_accepted_tunneled_client_types_hex_data_literal, KMaxTunneledTypeStringLengthInDB,

   630 		&cf_str_PEAP_unaccepted_tunneled_client_types_hex_data_literal, KMaxTunneledTypeStringLengthInDB,

   631 		&cf_str_TLS_server_authenticates_client_policy_in_client_literal,

   632 		&KCACertLabelOld, KMaxCertLabelLengthInDB,

   633 		&KClientCertLabel, KMaxCertLabelLengthInDB,

   634 		&cf_str_EAP_TLS_PEAP_saved_session_id_literal, KMaxSessionIdLengthInDB,

   635 		&cf_str_EAP_TLS_PEAP_saved_master_secret_literal,  KMaxMasterSecretLengthInDB,

   636 		&cf_str_EAP_TLS_PEAP_saved_cipher_suite_literal,

   637 		&cf_str_EAP_TLS_PEAP_verify_certificate_realm_literal,

   638 		&cf_str_EAP_PEAP_max_session_validity_time_literal,

   639 		&KPEAPLastFullAuthTime,	

   640 		&cf_str_EAP_TLS_PEAP_use_identity_privacy_literal);		

   641 					

   642 	err = aDatabase.Execute(sqlStatement);

   643 	if (err == KErrAlreadyExists)

   644 		{

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

   646 		_LIT( KColumnDef, "UNSIGNED INTEGER" );

   647 		AlterTableL( aDatabase, EAddColumn , KPeapDatabaseTableName,

   648 				cf_str_EAP_TLS_PEAP_use_identity_privacy_literal, KColumnDef);

   649 		}

   650 		else if (err != KErrNone)

   651 			{

   652 			User::Leave(err);

   653 			}

   654 

   655 	// Create table for _allowed_ user certificates

   656 	

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

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

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

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

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

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

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

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

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

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

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

   668 //////////////////////////////////////////////////////////////////////////////////////////////////////	

   669 	

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

   671 											 %S UNSIGNED INTEGER, \

   672 											 %S UNSIGNED INTEGER, \

   673 											 %S VARCHAR(%d), \

   674 											 %S BINARY(%d), \

   675 											 %S BINARY(%d), \

   676 											 %S VARCHAR(%d), \

   677 											 %S VARCHAR(%d), \

   678 											 %S VARCHAR(%d), \

   679 											 %S BINARY(%d))");											 

   680 											 

   681 	sqlStatement.Format(KSQLCreateTable2, &KPeapAllowedUserCertsDatabaseTableName, 

   682 		&KServiceType, 

   683 		&KServiceIndex, 

   684 		&KTunnelingType, 

   685 		&KCertLabel, KMaxCertLabelLengthInDB,

   686 		&KSubjectKeyIdentifier, KMaxSubjectKeyIdLengthInDB,

   687 		&KActualSubjectKeyIdentifier, KKeyIdentifierLength,

   688 		&KSubjectName, KGeneralStringMaxLength,

   689 		&KIssuerName, KGeneralStringMaxLength,

   690 		&KSerialNumber, KGeneralStringMaxLength,

   691 		&KThumbprint, KThumbprintMaxLength);

   692 		

   693 	err = aDatabase.Execute(sqlStatement);

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

   695 	{

   696 		User::Leave(err);

   697 	}	

   698 

   699 	// Create table for _allowed_ CA certs

   700 

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

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

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

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

   705 //| CACertLabel			| VARCHAR(255)     | KCACertLabel        |//	

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

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

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

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

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

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

   712 //////////////////////////////////////////////////////////////////////////////////////////////////////	

   713 

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

   715 											 %S UNSIGNED INTEGER, \

   716 											 %S UNSIGNED INTEGER, \

   717 											 %S VARCHAR(%d), \

   718 											 %S BINARY(%d), \

   719 											 %S BINARY(%d), \

   720 											 %S VARCHAR(%d), \

   721 											 %S VARCHAR(%d), \

   722 											 %S VARCHAR(%d), \

   723 											 %S BINARY(%d))");

   724 											 											 

   725 	sqlStatement.Format(KSQLCreateTable3, &KPeapAllowedCACertsDatabaseTableName, 

   726 		&KServiceType, 

   727 		&KServiceIndex, 

   728 		&KTunnelingType, 

   729 		&KCertLabel, KMaxCertLabelLengthInDB,

   730 		&KSubjectKeyIdentifier, KMaxSubjectKeyIdLengthInDB,

   731 		&KActualSubjectKeyIdentifier, KKeyIdentifierLength,

   732 		&KSubjectName, KGeneralStringMaxLength,

   733 		&KIssuerName, KGeneralStringMaxLength,

   734 		&KSerialNumber, KGeneralStringMaxLength,

   735 		&KThumbprint, KThumbprintMaxLength);

   736 		

   737 	err = aDatabase.Execute(sqlStatement);

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

   739 	{

   740 		User::Leave(err);

   741 	}

   742 

   743 	// Create table for _allowed_ cipher suites

   744 

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

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

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

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

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

   750 //////////////////////////////////////////////////////////////////////////////////////////////////////	

   751 	

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

   753 											 %S UNSIGNED INTEGER, \

   754 											 %S UNSIGNED INTEGER, \

   755 											 %S UNSIGNED INTEGER)");

   756 

   757 	sqlStatement.Format(KSQLCreateTable4, &KPeapAllowedCipherSuitesDatabaseTableName, 

   758 		&KServiceType, &KServiceIndex, &KTunnelingType, &KCipherSuite);

   759 	err = aDatabase.Execute(sqlStatement);

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

   761 	{

   762 		User::Leave(err);

   763 	}

   764 

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

   766 	 	

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

   768 	

   769 	sqlStatement.Format(KSQLQueryRow, &KPeapDatabaseTableName, 

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

   771 			

   772 	RDbView view;

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

   774 	// View must be closed when no longer needed

   775 	CleanupClosePushL(view);

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

   777 	

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

   779 	

   780 	TInt rows = view.CountL();

   781 	CleanupStack::PopAndDestroy(); // view

   782 	if (rows == 0)

   783 	{

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

   785 		sqlStatement.Format(KSQLInsert, &KPeapDatabaseTableName);	

   786 

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

   788 		CleanupClosePushL(view);

   789 		view.InsertL();

   790 

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

   792 		CDbColSet* colSet = view.ColSetL();

   793 		CleanupStack::PushL(colSet);

   794 

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

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

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

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

   799 		

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

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

   802 		

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

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

   805 		

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

   807 		

   808 		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_used_PEAP_version_literal), default_EAP_TLS_PEAP_used_PEAP_version);

   809 

   810 		TInt i(0);

   811 

   812 		while (default_EAP_TLS_PEAP_accepted_PEAP_versions[i] != -1)

   813 		{

   814 			i++;

   815 		}

   816 		

   817 		TBuf8<KMaxPEAPVersionsStringLengthInDB> tmp;

   818 		

   819 		tmp.Copy(reinterpret_cast<const TUint8 *> (default_EAP_TLS_PEAP_accepted_PEAP_versions), i * sizeof(TInt));

   820 		

   821 		view.SetColL(colSet->ColNo(cf_str_EAP_TLS_PEAP_accepted_PEAP_versions_literal), tmp);

   822 

   823 		view.SetColL(colSet->ColNo(cf_str_PEAP_accepted_tunneled_client_types_hex_data_literal), default_PEAP_tunneled_types);

   824 		view.SetColL(colSet->ColNo(cf_str_PEAP_unaccepted_tunneled_client_types_hex_data_literal), default_PEAP_tunneled_types);

   825 		

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

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

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

   829 

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

   831 

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

   833 		

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

   835 

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

   837 

   838 		view.PutL();

   839 		

   840 		CleanupStack::PopAndDestroy(colSet); 

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

   842 

   843 		// Add default disabled cipher suites

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

   845 		sqlStatement.Format(KSQLInsert2, &KPeapAllowedCipherSuitesDatabaseTableName);

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

   847 		CleanupClosePushL(view);

   848 

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

   850 		colSet = view.ColSetL();

   851 		CleanupStack::PushL(colSet);

   852 

   853 		i = 0;

   854 		while (default_allowed_cipher_suites[i] != 0)

   855 		{

   856 			view.InsertL();

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

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

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

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

   861 			view.PutL();

   862 			i++;

   863 		}

   864 		

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

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

   867 	} 

   868 	

   869 	// 6. Do the altering of tables here. 

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

   871 

   872 	TBufC<KDbMaxColName> tableName;

   873 

   874 	// For the table _allowed_ USER certificates

   875 	tableName = KPeapAllowedUserCertsDatabaseTableName;	

   876 	AddExtraCertColumnsL(aDatabase,tableName);

   877 	

   878 	// For the table _allowed_ CA certificates	

   879 	tableName = KPeapAllowedCACertsDatabaseTableName;	

   880 	AddExtraCertColumnsL(aDatabase,tableName);

   881 

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

   883 	CleanupStack::Pop( &aDatabase );	

   884 	CleanupStack::Pop( &aSession );	

   885 	

   886 	aDatabase.Compact();

   887 }

   888 

   889 #if defined(USE_TTLS_EAP_TYPE)

   890 

   891 // ---------------------------------------------------------

   892 // EapTlsPeapUtils::OpenTtlsDatabaseL()

   893 // ---------------------------------------------------------

   894 //

   895 void EapTlsPeapUtils::OpenTtlsDatabaseL(

   896 		RDbNamedDatabase& aDatabase, 

   897 		RDbs& aSession, 

   898 		const TIndexType aIndexType, 

   899 		const TInt aIndex,

   900 		const eap_type_value_e aTunnelingType)

   901 {

   902 #ifdef USE_EAP_EXPANDED_TYPES

   903 

   904 	TUint aTunnelingVendorType = aTunnelingType.get_vendor_type();

   905 

   906 #else

   907 

   908 	TUint aTunnelingVendorType = static_cast<TUint>(aTunnelingType);

   909 

   910 #endif //#ifdef USE_EAP_EXPANDED_TYPES

   911 

   912 	EAP_TRACE_DEBUG_SYMBIAN(

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

   914 		aIndexType,aIndex, aTunnelingVendorType));

   915 

   916 	// 1. Open/create a database	

   917 	

   918 	// Connect to the DBMS server.

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

   920 	CleanupClosePushL(aSession);	

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

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

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

   924 	// does no harm.	

   925 	

   926 #ifdef SYMBIAN_SECURE_DBMS

   927 	

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

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

   930 	

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

   932 

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

   934 	

   935 	if(err == KErrNone)

   936 	{

   937 		aDatabase.Close();

   938 		

   939 	} else if (err != KErrAlreadyExists) 

   940 	{

   941 		User::LeaveIfError(err);

   942 	}

   943 	

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

   945 	CleanupClosePushL(aDatabase);		

   946 		

   947 #else

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

   949 	

   950 	RFs fsSession;		

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

   952 	CleanupClosePushL(fsSession);	

   953 	TInt err = aDatabase.Create(fsSession, KTtlsDatabaseName);

   954 

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

   956 	

   957 	if(err == KErrNone)

   958 	{

   959 		aDatabase.Close();

   960 		

   961 	} else if (err != KErrAlreadyExists) 

   962 	{

   963 		User::LeaveIfError(err);

   964 	}

   965 	

   966 	User::LeaveIfError(aDatabase.Open(fsSession, KTtlsDatabaseName));

   967 	

   968 	CleanupStack::PopAndDestroy(); // close fsSession

   969 	

   970 	CleanupClosePushL(aDatabase);		

   971 	    

   972 #endif // #ifdef SYMBIAN_SECURE_DBMS

   973 

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

   975 	

   976 // Table columns:

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

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

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

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

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

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

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

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

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

   986 //| EAP_TLS_PEAP_used_PEAP_version				| UNSIGNED INTEGER 	| cf_str_EAP_TLS_PEAP_used_PEAP_version_literal		    |//

   987 //| EAP_TLS_PEAP_accepted_PEAP_versions			| BINARY(12)	    | cf_str_EAP_TLS_PEAP_accepted_PEAP_versions_literal|//

   988 //| PEAP_accepted_tunneled_client_types			| VARBINARY(240) 	| cf_str_PEAP_accepted_tunneled_client_types_hex_data_literal      |//

   989 //| PEAP_unaccepted_tunneled_client_types		| VARBINARY(240) 	| cf_str_PEAP_unaccepted_tunneled_client_types_hex_data_literal      |//

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

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

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

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

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

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

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

   997 //| EAP_TTLS_max_session_validity_time			| BIGINT	   		| cf_str_EAP_TTLS_max_session_validity_time_literal   |//

   998 //| EAP_TTLS_last_full_authentication_time		| BIGINT	   		| KTTLSLastFullAuthTime	   	|//	

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

  1000 

  1001 

  1002 //| EAP_TLS_PEAP_ttls_pap_password_prompt               | UNSIGNED INTEGER  | cf_str_EAP_TLS_PEAP_ttls_pap_password_prompt_literal           |//

  1003 //| EAP_TLS_PEAP_ttls_pap_username                      | VARCHAR(253)      | cf_str_EAP_TLS_PEAP_ttls_pap_username_literal                  |//

  1004 //| EAP_TLS_PEAP_ttls_pap_password                      | VARCHAR(128)      | cf_str_EAP_TLS_PEAP_ttls_pap_password_literal                  |//

  1005 //| EAP_TLS_PEAP_ttls_pap_max_session_validity_time		| BIGINT		   	| cf_str_EAP_TLS_PEAP_ttls_pap_max_session_validity_time_literal |//

  1006 //| EAP_TLS_PEAP_ttls_pap_last_full_authentication_time	| BIGINT		   	| KTTLSPAPLastFullAuthTime	                             |//

  1007 

  1008 

  1009 //////////////////////////////////////////////////////////////////////////////////////////////////////////////	

  1010 	

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

  1012 	TPtr sqlStatement = buf->Des();

  1013 	

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

  1015 	_LIT(KSQLCreateTable1,

  1016 		"CREATE TABLE %S (%S UNSIGNED INTEGER, \

  1017 			              %S UNSIGNED INTEGER, \

  1018 			              %S UNSIGNED INTEGER, \

  1019 			              %S UNSIGNED INTEGER, \

  1020 			              %S VARCHAR(%d),     \

  1021 			              %S UNSIGNED INTEGER, \

  1022 			              %S VARCHAR(%d),     \

  1023 			              %S UNSIGNED INTEGER, \

  1024 			              %S UNSIGNED INTEGER, \

  1025 			              %S BINARY(%d),		  \

  1026 			              %S VARBINARY(%d),	  \

  1027 			              %S VARBINARY(%d),	  \

  1028 			              %S UNSIGNED INTEGER, \

  1029 			              %S VARCHAR(%d),	  \

  1030 			              %S VARCHAR(%d),     \

  1031 			              %S BINARY(%d),		  \

  1032 			              %S BINARY(%d),		  \

  1033 			              %S UNSIGNED INTEGER, \

  1034 			              %S UNSIGNED INTEGER, \

  1035 			              %S BIGINT, \

  1036 			              %S BIGINT, \

  1037 				      			%S UNSIGNED INTEGER, \

  1038 			              %S UNSIGNED INTEGER, \

  1039 			              %S VARCHAR(%d), \

  1040 			              %S VARCHAR(%d), \

  1041                     %S BIGINT, \

  1042                     %S BIGINT)");

  1043 

  1044     sqlStatement.Format( KSQLCreateTable1,

  1045         &KTtlsDatabaseTableName,

  1046         &KServiceType,

  1047         &KServiceIndex,

  1048         &KTunnelingType,

  1049         &cf_str_EAP_TLS_PEAP_use_manual_realm_literal,

  1050         &cf_str_EAP_TLS_PEAP_manual_realm_literal, KMaxManualRealmLengthInDB,

  1051         &cf_str_EAP_TLS_PEAP_use_manual_username_literal,

  1052         &cf_str_EAP_TLS_PEAP_manual_username_literal, KMaxManualUsernameLengthInDB,

  1053         &cf_str_EAP_TLS_PEAP_cipher_suite_literal,

  1054         &cf_str_EAP_TLS_PEAP_used_PEAP_version_literal,

  1055         &cf_str_EAP_TLS_PEAP_accepted_PEAP_versions_literal, KMaxPEAPVersionsStringLengthInDB,

  1056         &cf_str_PEAP_accepted_tunneled_client_types_hex_data_literal, KMaxTunneledTypeStringLengthInDB,

  1057         &cf_str_PEAP_unaccepted_tunneled_client_types_hex_data_literal,	KMaxTunneledTypeStringLengthInDB,	

  1058         &cf_str_TLS_server_authenticates_client_policy_in_client_literal,

  1059         &KCACertLabelOld, KMaxCertLabelLengthInDB,

  1060         &KClientCertLabel, KMaxCertLabelLengthInDB,

  1061         &cf_str_EAP_TLS_PEAP_saved_session_id_literal, KMaxSessionIdLengthInDB,

  1062         &cf_str_EAP_TLS_PEAP_saved_master_secret_literal, KMaxMasterSecretLengthInDB,

  1063         &cf_str_EAP_TLS_PEAP_saved_cipher_suite_literal,

  1064         &cf_str_EAP_TLS_PEAP_verify_certificate_realm_literal,

  1065         &cf_str_EAP_TTLS_max_session_validity_time_literal,

  1066         &KTTLSLastFullAuthTime,

  1067 		&cf_str_EAP_TLS_PEAP_use_identity_privacy_literal,		

  1068         &cf_str_EAP_TLS_PEAP_ttls_pap_password_prompt_literal,

  1069         &cf_str_EAP_TLS_PEAP_ttls_pap_username_literal, KMaxPapUserNameLengthInDb,

  1070         &cf_str_EAP_TLS_PEAP_ttls_pap_password_literal, KMaxPapPasswordLengthInDb,

  1071         &cf_str_EAP_TLS_PEAP_ttls_pap_max_session_validity_time_literal,

  1072         &KTTLSPAPLastFullAuthTime );	

  1073 

  1074 

  1075 	

  1076 	err = aDatabase.Execute(sqlStatement);

  1077 	if (err == KErrAlreadyExists)

  1078 		{

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

  1080 		

  1081 		_LIT( KColumnDef, "UNSIGNED INTEGER" );

  1082 		AlterTableL( aDatabase, EAddColumn , KTtlsDatabaseTableName,

  1083 				cf_str_EAP_TLS_PEAP_use_identity_privacy_literal, KColumnDef);

  1084 

  1085 		_LIT( KColumnDef1, "UNSIGNED INTEGER" );

  1086 		AlterTableL( aDatabase, EAddColumn , KTtlsDatabaseTableName,

  1087 				cf_str_EAP_TLS_PEAP_ttls_pap_password_prompt_literal, KColumnDef1);

  1088 

  1089         HBufC* buf1 = HBufC::NewLC(KMaxSqlQueryLength);

  1090         TPtr sqlStatement = buf1->Des();

  1091        

  1092         _LIT(KSQLAlterTableForVar, "VARCHAR (%d)");                                          

  1093     

  1094         sqlStatement.Format(KSQLAlterTableForVar, KMaxPapUserNameLengthInDb);

  1095  

  1096 		AlterTableL( aDatabase, EAddColumn , KTtlsDatabaseTableName,

  1097 				cf_str_EAP_TLS_PEAP_ttls_pap_username_literal, sqlStatement);

  1098 

  1099         sqlStatement.Format(KSQLAlterTableForVar, KMaxPapPasswordLengthInDb);

  1100         

  1101 		AlterTableL( aDatabase, EAddColumn , KTtlsDatabaseTableName,

  1102 				cf_str_EAP_TLS_PEAP_ttls_pap_password_literal, sqlStatement);

  1103 

  1104 		CleanupStack::PopAndDestroy(buf1);

  1105 		

  1106 		_LIT( KColumnDef4, "BIGINT" );

  1107 		AlterTableL( aDatabase, EAddColumn , KTtlsDatabaseTableName,

  1108 				cf_str_EAP_TLS_PEAP_ttls_pap_max_session_validity_time_literal, KColumnDef4);

  1109 				

  1110 		_LIT( KColumnDef5, "BIGINT" );

  1111 		AlterTableL( aDatabase, EAddColumn , KTtlsDatabaseTableName,

  1112 				KTTLSPAPLastFullAuthTime, KColumnDef5);

  1113 				

  1114 		}

  1115 	else if (err != KErrNone)

  1116 		{

  1117 		User::Leave(err);

  1118 		}

  1119 

  1120 	// Create table for _allowed_ user certificates

  1121 	

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

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

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

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

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

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

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

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

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

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

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

  1133 //////////////////////////////////////////////////////////////////////////////////////////////////////	

  1134