--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/eapol/eapol_framework/eapol_symbian/am/type/tls_peap/symbian/plugin/src/EapTlsPeapUiEapTypes.cpp	Thu Dec 17 08:47:43 2009 +0200
@@ -0,0 +1,395 @@
+/*
+* 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 433 
+	#undef EAP_FILE_NUMBER_DATE 
+	#define EAP_FILE_NUMBER_DATE 1127594498 
+#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)
+
+
+// INCLUDE FILES
+#include <e32base.h>
+#include "EapTlsPeapUtils.h"
+#include <EapTlsPeapUiConnection.h>
+#include <EapTlsPeapUiEapTypes.h>
+#include <EapTlsPeapUiEapType.h>
+#include "eap_am_trace_symbian.h"
+
+const TUint KNumberOfSupportedEAPTypes = 10; //Now 10, including EAP-FAST & TTLS-PAP
+
+CEapTlsPeapUiEapTypes::CEapTlsPeapUiEapTypes(CEapTlsPeapUiConnection * const aUiConn)
+: iIsOpened(EFalse)
+, iUiConn(aUiConn)
+, iDataPtr(NULL)
+{
+}
+
+
+CEapTlsPeapUiEapTypes::~CEapTlsPeapUiEapTypes()
+{
+    if (iUiConn)
+    {
+        Close();
+        iUiConn = NULL;
+    }
+}
+
+
+TInt CEapTlsPeapUiEapTypes::Open()
+{
+    if (iIsOpened)
+    {
+        return KErrAlreadyExists;
+    }
+
+    TInt err = iUiConn->GetDatabase(iDatabase);
+    if (err != KErrNone)
+    {
+        return err;
+    }
+
+    iIsOpened = ETrue;
+
+    return KErrNone;
+}
+
+
+TInt CEapTlsPeapUiEapTypes::GetEapTypes(CArrayFixFlat<TEapTlsPeapUiEapType> ** aDataPtr)
+{
+    if (aDataPtr == NULL)
+    {
+        return KErrArgument;
+    }
+    if (iIsOpened == EFalse)
+    {
+        return KErrSessionClosed;
+    }
+    if (iDataPtr != 0)
+    {
+    	*aDataPtr = iDataPtr;
+    	return KErrNone;
+    }
+    iDataPtr = new CArrayFixFlat<TEapTlsPeapUiEapType>(KNumberOfSupportedEAPTypes);
+    if (!iDataPtr)
+    {
+        return KErrNoMemory;
+    }
+
+#ifdef USE_EAP_EXPANDED_TYPES
+
+    TRAPD(err, FetchExpandedDataL());
+
+#else
+
+    TRAPD(err, FetchDataL());
+
+#endif //#ifdef USE_EAP_EXPANDED_TYPES
+        
+    if (err != KErrNone)
+    {
+        delete iDataPtr;
+        return err;
+    }
+
+   	*aDataPtr = iDataPtr;
+
+    return KErrNone;
+}
+
+
+TInt CEapTlsPeapUiEapTypes::Update()
+{
+
+#ifdef USE_EAP_EXPANDED_TYPES
+
+	TRAPD(err, UpdateExpandedDataL());
+
+#else
+
+	TRAPD(err, UpdateL());
+
+#endif //#ifdef USE_EAP_EXPANDED_TYPES
+
+	return err;
+}
+
+#ifndef USE_EAP_EXPANDED_TYPES
+
+void CEapTlsPeapUiEapTypes::UpdateL()
+{
+	TEapArray eapTypes;
+	TEap* eapTmp; 	
+	
+	TInt i(0);
+	
+	for(i = 0; i < iDataPtr->Count(); i++)
+	{
+		eapTmp = new (ELeave) TEap;
+		CleanupStack::PushL(eapTmp);
+		eapTmp->Enabled	= iDataPtr->At(i).iIsEnabled;
+		eapTmp->UID.Copy(iDataPtr->At(i).iEapType);
+		User::LeaveIfError(eapTypes.Append(eapTmp));
+		CleanupStack::Pop(eapTmp);
+	}	
+
+	TRAPD(err, EapTlsPeapUtils::SetEapDataL(
+			iDatabase, 
+			0, 
+			eapTypes, 
+			iUiConn->GetIndexType(),
+			iUiConn->GetIndex(),
+			static_cast<eap_type_value_e>(iUiConn->GetTunnelingType()),
+			static_cast<eap_type_value_e>(iUiConn->GetEapType())));
+
+	eapTypes.ResetAndDestroy();	
+	if (err != KErrNone)
+	{
+		User::Leave(err);
+	}
+}
+#endif // #ifndef USE_EAP_EXPANDED_TYPES
+
+
+TInt CEapTlsPeapUiEapTypes::Close()
+{
+    if (iIsOpened == EFalse)
+    {
+        return KErrNone;
+    }
+    
+    delete iDataPtr;
+    iDataPtr = 0;
+		
+    iUiConn = NULL;
+    return KErrNone;
+}
+
+#ifndef USE_EAP_EXPANDED_TYPES
+
+void CEapTlsPeapUiEapTypes::FetchDataL()
+{		
+	TEapArray eapTypes;
+	
+	TRAPD(err, EapTlsPeapUtils::GetEapDataL(
+			iDatabase, 
+			0, 
+			eapTypes, 
+			iUiConn->GetIndexType(), 
+			iUiConn->GetIndex(), 
+			static_cast<eap_type_value_e>(iUiConn->GetTunnelingType()),
+			static_cast<eap_type_value_e>(iUiConn->GetEapType())));
+
+	if (err != KErrNone)
+	{
+		eapTypes.ResetAndDestroy();
+		User::Leave(err);
+	}
+	
+	TInt i(0);
+	for	(i = 0; i < eapTypes.Count(); i++)	
+	{
+		TEapTlsPeapUiEapType tmp;
+
+		tmp.iIsEnabled = eapTypes[i]->Enabled;
+		
+		tmp.iEapType.Copy(eapTypes[i]->UID);
+		
+		TRAPD(err, iDataPtr->AppendL(tmp));
+		if (err != KErrNone)
+		{
+			eapTypes.ResetAndDestroy();
+			User::Leave(err);
+		}
+	}
+	eapTypes.ResetAndDestroy();	
+}
+#endif // #ifndef USE_EAP_EXPANDED_TYPES
+
+#ifdef USE_EAP_EXPANDED_TYPES
+
+void CEapTlsPeapUiEapTypes::FetchExpandedDataL()
+{
+	EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapUiEapTypes::FetchExpandedDataL: Start\n")));
+
+	RExpandedEapTypePtrArray enabledEAPTypes;
+	RExpandedEapTypePtrArray disabledEAPTypes;
+
+	eap_type_value_e tunnelingType(static_cast<eap_type_ietf_values_e>(iUiConn->GetTunnelingType()));
+	eap_type_value_e eapType(static_cast<eap_type_ietf_values_e>(iUiConn->GetEapType()));
+
+	TRAPD(err, EapTlsPeapUtils::GetTunnelingExpandedEapDataL(
+			iDatabase, 
+			0, 
+			enabledEAPTypes,
+			disabledEAPTypes, 
+			iUiConn->GetIndexType(), 
+			iUiConn->GetIndex(), 
+			tunnelingType,
+			eapType));
+
+	if (err != KErrNone)
+	{
+		enabledEAPTypes.ResetAndDestroy();
+		disabledEAPTypes.ResetAndDestroy();
+		
+		EAP_TRACE_DEBUG_SYMBIAN(
+			(_L("CEapTlsPeapUiEapTypes::FetchExpandedDataL: Error from GetTunnelingExpandedEapDataL:%d\n"),
+			err));		
+		
+		User::Leave(err);
+	}
+	
+	EAP_TRACE_DEBUG_SYMBIAN(
+		(_L("CEapTlsPeapUiEapTypes::FetchExpandedDataL: Got tunneling EAPs from DB: enabled=%d,disabled=%d\n"),
+		enabledEAPTypes.Count(), disabledEAPTypes.Count()));		
+	
+	TInt i(0);
+	
+	// First fill the enabled EAP types.	
+	for	(i = 0; i < enabledEAPTypes.Count(); i++)	
+	{
+		TEapTlsPeapUiEapType tmpEAP;
+
+		tmpEAP.iIsEnabled = ETrue; // All EAP types here are enabled.
+		
+		tmpEAP.iEapType.Copy(enabledEAPTypes[i]->iExpandedEAPType);
+		
+		TRAPD(err, iDataPtr->AppendL(tmpEAP));
+		if (err != KErrNone)
+		{
+			enabledEAPTypes.ResetAndDestroy();
+			User::Leave(err);
+		}
+		
+		EAP_TRACE_DATA_DEBUG_SYMBIAN(("CEapTlsPeapUiEapTypes::FetchExpandedDataL:Appended ENABLED EAP type:",
+			tmpEAP.iEapType.Ptr(), 
+			tmpEAP.iEapType.Size() ) );		
+	}
+
+	// Now fill the disabled EAP types.	
+	for	(i = 0; i < disabledEAPTypes.Count(); i++)	
+	{
+		TEapTlsPeapUiEapType tmpEAP;
+
+		tmpEAP.iIsEnabled = EFalse; // All EAP types here are disabled.
+		
+		tmpEAP.iEapType.Copy(disabledEAPTypes[i]->iExpandedEAPType);
+		
+		TRAPD(err, iDataPtr->AppendL(tmpEAP));
+		if (err != KErrNone)
+		{
+			disabledEAPTypes.ResetAndDestroy();
+			User::Leave(err);
+		}
+		
+		EAP_TRACE_DATA_DEBUG_SYMBIAN(("CEapTlsPeapUiEapTypes::FetchExpandedDataL:Appended DISABLED EAP type:",
+			tmpEAP.iEapType.Ptr(), 
+			tmpEAP.iEapType.Size() ) );		
+	}
+	
+	enabledEAPTypes.ResetAndDestroy();		
+	disabledEAPTypes.ResetAndDestroy();
+	
+	EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapUiEapTypes::FetchExpandedDataL: End\n")));	
+}
+
+void CEapTlsPeapUiEapTypes::UpdateExpandedDataL()
+{
+	EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapUiEapTypes::UpdateExpandedDataL: Start\n")));
+
+	RExpandedEapTypePtrArray enabledEAPTypes;
+	RExpandedEapTypePtrArray disabledEAPTypes;
+	SExpandedEAPType* expandedEAPTmp;
+	
+	for(TInt i=0 ; i < iDataPtr->Count(); i++)
+	{
+		expandedEAPTmp = new (ELeave) SExpandedEAPType;
+		CleanupStack::PushL(expandedEAPTmp);
+		
+		expandedEAPTmp->iExpandedEAPType.Copy(iDataPtr->At(i).iEapType);
+		
+		if(iDataPtr->At(i).iIsEnabled)
+		{
+			// Enabled
+			TInt error = enabledEAPTypes.Append(expandedEAPTmp);
+
+			if (error != KErrNone)
+			{
+				enabledEAPTypes.ResetAndDestroy();
+				disabledEAPTypes.ResetAndDestroy();
+				User::LeaveIfError(error);
+			}
+		
+			EAP_TRACE_DATA_DEBUG_SYMBIAN(("CEapTlsPeapUiEapTypes::UpdateExpandedDataL:Appended ENABLED EAP type:",
+				expandedEAPTmp->iExpandedEAPType.Ptr(), 
+				expandedEAPTmp->iExpandedEAPType.Size() ) );
+		}
+		else
+		{
+			// Disabled
+			TInt error = disabledEAPTypes.Append(expandedEAPTmp);
+
+			if (error != KErrNone)
+			{
+				enabledEAPTypes.ResetAndDestroy();
+				disabledEAPTypes.ResetAndDestroy();
+				User::LeaveIfError(error);
+			}
+
+			EAP_TRACE_DATA_DEBUG_SYMBIAN(("CEapTlsPeapUiEapTypes::UpdateExpandedDataL:Appended DISABLED EAP type:",
+				expandedEAPTmp->iExpandedEAPType.Ptr(), 
+				expandedEAPTmp->iExpandedEAPType.Size() ) );
+		}
+		
+		CleanupStack::Pop(expandedEAPTmp);	
+	}	
+
+	eap_type_value_e tunnelingType(static_cast<eap_type_ietf_values_e>(iUiConn->GetTunnelingType()));
+	eap_type_value_e eapType(static_cast<eap_type_ietf_values_e>(iUiConn->GetEapType()));
+
+	TRAPD(err, EapTlsPeapUtils::SetTunnelingExpandedEapDataL(
+			iDatabase, 
+			0, 
+			enabledEAPTypes,
+			disabledEAPTypes, 
+			iUiConn->GetIndexType(),
+			iUiConn->GetIndex(),
+			tunnelingType,
+			eapType));
+
+	enabledEAPTypes.ResetAndDestroy();
+	disabledEAPTypes.ResetAndDestroy();
+		
+	if (err != KErrNone)
+	{
+		EAP_TRACE_DEBUG_SYMBIAN(
+			(_L("CEapTlsPeapUiEapTypes::UpdateExpandedDataL: Error from SetTunnelingExpandedEapDataL:%d\n"),
+			err));		
+	
+		User::Leave(err);
+	}
+	
+	EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapUiEapTypes::UpdateExpandedDataL: End\n")));	
+}
+    
+#endif // #ifdef USE_EAP_EXPANDED_TYPES
+
+// End of file