/*

* Copyright (c) 2001-2010 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-settings class.

*

*/

/*

* %version: 24 %

*/

// This is enumeration of EAPOL source code.

#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

	#undef EAP_FILE_NUMBER_ENUM

	#define EAP_FILE_NUMBER_ENUM 759 

	#undef EAP_FILE_NUMBER_DATE 

	#define EAP_FILE_NUMBER_DATE 1127594498 

#endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

#include "eap_am_tools.h"

#include "eap_am_export.h"

#include "eap_method_settings.h"

#include "eap_array_algorithms.h"

#include "eap_automatic_variable.h"

//-------------------------------------------------------------------------------

eap_certificate_entry_c::~eap_certificate_entry_c()

{

}

//-------------------------------------------------------------------------------

eap_certificate_entry_c::eap_certificate_entry_c(

	abs_eap_am_tools_c * const tools)

: m_am_tools(tools)

, m_CertType(eap_certificate_type_none)

, m_SubjectNamePresent(false)

, m_SubjectName(tools)

, m_IssuerNamePresent(false)

, m_IssuerName(tools)

, m_SerialNumberPresent(false)

, m_SerialNumber(tools)

, m_SubjectKeyIDPresent(false)

, m_SubjectKeyID(tools)

, m_ThumbprintPresent(false)

, m_Thumbprint(tools)

, m_LabelPresent(false)

, m_Label(tools)

, m_PrimaryNamePresent(false)

, m_PrimaryName(tools)

, m_SecondaryNamePresent(false)

, m_SecondaryName(tools)

, m_iIsEnabledPresent(false)

, m_iIsEnabled(false)

{

}

//-------------------------------------------------------------------------------

bool eap_certificate_entry_c::get_is_valid()

{

	return true;

}

//-------------------------------------------------------------------------------

bool eap_certificate_entry_c::get_is_valid_data()

{

	return get_is_valid();

}

//-------------------------------------------------------------------------------

eap_certificate_entry_c * eap_certificate_entry_c::copy()

{

	eap_certificate_entry_c * const new_entry = new eap_certificate_entry_c(m_am_tools);

	eap_automatic_variable_c<eap_certificate_entry_c> automatic_new_entry(

		m_am_tools,

		new_entry);

	if (new_entry == 0

		|| new_entry->get_is_valid() == false)

	{

		(void) EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

		return 0;

	}

	eap_status_e status(eap_status_ok);

	new_entry->m_CertType = m_CertType;

	new_entry->m_SubjectNamePresent = m_SubjectNamePresent;

	if (m_SubjectNamePresent == true)

	{

		status = new_entry->m_SubjectName.set_copy_of_buffer(&m_SubjectName);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_IssuerNamePresent = m_IssuerNamePresent;

	if (m_IssuerNamePresent == true)

	{

		status = new_entry->m_IssuerName.set_copy_of_buffer(&m_IssuerName);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_SerialNumberPresent = m_SerialNumberPresent;

	if (m_SerialNumberPresent == true)

	{

		status = new_entry->m_SerialNumber.set_copy_of_buffer(&m_SerialNumber);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_SubjectKeyIDPresent = m_SubjectKeyIDPresent;

	if (m_SubjectKeyIDPresent == true)

	{

		status = new_entry->m_SubjectKeyID.set_copy_of_buffer(&m_SubjectKeyID);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_ThumbprintPresent = m_ThumbprintPresent;

	if (m_ThumbprintPresent == true)

	{

		status = new_entry->m_Thumbprint.set_copy_of_buffer(&m_Thumbprint);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_LabelPresent = m_LabelPresent;

	if (m_LabelPresent == true)

	{

		status = new_entry->m_Label.set_copy_of_buffer(&m_Label);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_PrimaryNamePresent = m_PrimaryNamePresent;

	if (m_PrimaryNamePresent == true)

	{

		status = new_entry->m_PrimaryName.set_copy_of_buffer(&m_PrimaryName);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_SecondaryNamePresent = m_SecondaryNamePresent;

	if (m_SecondaryNamePresent == true)

	{

		status = new_entry->m_SecondaryName.set_copy_of_buffer(&m_SecondaryName);

		if (status != eap_status_ok)

		{

			(void) EAP_STATUS_RETURN(m_am_tools, status);

			return 0;

		}

	}

	new_entry->m_iIsEnabledPresent = m_iIsEnabledPresent;

	new_entry->m_iIsEnabled = m_iIsEnabled;

	automatic_new_entry.do_not_free_variable();

	return new_entry;

}

//-------------------------------------------------------------------------------

void eap_certificate_entry_c::trace() const

{

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_CertType=%d\n"),

		m_CertType));

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_SubjectNamePresent=%d\n"),

		m_SubjectNamePresent));

	if (m_SubjectNamePresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_SubjectName"),

			m_SubjectName.get_data(),

			m_SubjectName.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_IssuerNamePresent=%d\n"),

		m_IssuerNamePresent));

	if (m_IssuerNamePresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_IssuerName"),

			m_IssuerName.get_data(),

			m_IssuerName.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_SerialNumberPresent=%d\n"),

		m_SerialNumberPresent));

	if (m_SerialNumberPresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_SerialNumber"),

			m_SerialNumber.get_data(),

			m_SerialNumber.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_SubjectKeyIDPresent=%d\n"),

		m_SubjectKeyIDPresent));

	if (m_SubjectKeyIDPresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_SubjectKeyID"),

			m_SubjectKeyID.get_data(),

			m_SubjectKeyID.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_ThumbprintPresent=%d\n"),

		m_ThumbprintPresent));

	if (m_ThumbprintPresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_Thumbprint"),

			m_Thumbprint.get_data(),

			m_Thumbprint.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_LabelPresent=%d\n"),

		m_LabelPresent));

	if (m_LabelPresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_Label"),

			m_Label.get_data(),

			m_Label.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_PrimaryNamePresent=%d\n"),

		m_PrimaryNamePresent));

	if (m_PrimaryNamePresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_PrimaryName"),

			m_PrimaryName.get_data(),

			m_PrimaryName.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_SecondaryNamePresent=%d\n"),

		m_SecondaryNamePresent));

	if (m_SecondaryNamePresent == true)

	{

		EAP_TRACE_DATA_DEBUG(

			m_am_tools, 

			TRACE_FLAGS_DEFAULT, 

			(EAPL("eap_certificate_entry_c::trace():     m_SecondaryName"),

			m_SecondaryName.get_data(),

			m_SecondaryName.get_data_length()));

	}

	EAP_TRACE_DEBUG(

		m_am_tools,

		TRACE_FLAGS_DEFAULT,

		(EAPL("eap_certificate_entry_c::trace(): m_iIsEnabledPresent=%d\n"),

		m_iIsEnabledPresent));

	if (m_iIsEnabledPresent == true)

	{

		EAP_TRACE_DEBUG(

			m_am_tools,

			TRACE_FLAGS_DEFAULT,

			(EAPL("eap_certificate_entry_c::trace():     m_iIsEnabled=%d\n"),

			m_iIsEnabled));

	}

}

//-------------------------------------------------------------------------------

//-------------------------------------------------------------------------------

//-------------------------------------------------------------------------------

eap_method_values_c::~eap_method_values_c()

{

}

//-------------------------------------------------------------------------------

eap_method_values_c::eap_method_values_c(

	abs_eap_am_tools_c * const tools)

: m_am_tools(tools)

, m_is_valid(false)

, m_completion_status(eap_status_process_general_error)

, m_EAPType(eap_type_none)

, m_IndexType(0ul)

, m_Index(0ul)

, m_UseAutomaticCACertificatePresent(false)

, m_UseAutomaticCACertificate(false)

, m_UseAutomaticUsernamePresent(false)

, m_UseAutomaticUsername(false)

, m_UseAutomaticRealmPresent(false)

, m_UseAutomaticRealm(false)

, m_UsernamePresent(false)

, m_Username_fix(tools)

, m_PasswordExistPresent(false)

, m_PasswordPresent(false)

, m_Password(tools)

, m_RealmPresent(false)

, m_Realm(tools)

, m_UsePseudonymsPresent(false)

, m_UsePseudonyms(false)

, m_VerifyServerRealmPresent(false)

, m_VerifyServerRealm(false)

, m_RequireClientAuthenticationPresent(false)

, m_RequireClientAuthentication(false)

, m_SessionValidityTimePresent(false)

, m_SessionValidityTime(0ul)

, m_CipherSuitesPresent(false)

, m_CipherSuites(tools)

, m_PEAPVersionsPresent(false)

, m_PEAPv0Allowed(false)

, m_PEAPv1Allowed(false)

, m_PEAPv2Allowed(false)

, m_CertificatesPresent(false)

, m_Certificates(tools)

, m_EnabledEncapsulatedEAPTypesPresent(false)

, m_EnabledEncapsulatedEAPTypes(tools)

, m_DisabledEncapsulatedEAPTypesPresent(false)

, m_DisabledEncapsulatedEAPTypes(tools)

, m_AuthProvModeAllowedPresent(false)

, m_AuthProvModeAllowed(false)

, m_UnauthProvModeAllowedPresent(false)

, m_UnauthProvModeAllowed(false)

, m_PACGroupReferencePresent(false)

, m_PACGroupReference(tools)

, m_WarnADHPNoPACPresent(false)

, m_WarnADHPNoPAC(false)

, m_WarnADHPNoMatchingPACPresent(false)

, m_WarnADHPNoMatchingPAC(false)

, m_WarnNotDefaultServerPresent(false)

, m_WarnNotDefaultServer(false)

, m_SelectedEAPTypesPresent(false)

, m_active_eap_methods(tools)

, m_disabled_eap_methods(tools)

, m_TunnelingTypePresent(false)

, m_TunnelingType(eap_type_none)

, m_DestinationIndexAndTypePresent(false)

, m_DestinationIndexType(0ul)

, m_DestinationIndex(0ul)

, m_MethodInfoPresent(false)

, m_KReleaseDate(tools)

, m_KEapTypeVersion(tools)

, m_KManufacturer(tools)

, m_ButtonIdPresent(false)

, m_ButtonId(0)

, m_ShowPassWordPromptPresent(false)

, m_ShowPassWordPrompt(false)

, m_UseIdentityPrivacyPresent(false)

, m_UseIdentityPrivacy(false)

{

}

//-------------------------------------------------------------------------------

abs_eap_am_tools_c * eap_method_values_c::get_am_tools() const

{

	return m_am_tools;

}

//-------------------------------------------------------------------------------

//-------------------------------------------------------------------------------

//-------------------------------------------------------------------------------

eap_method_settings_c::~eap_method_settings_c()

{

}

//-------------------------------------------------------------------------------

eap_method_settings_c::eap_method_settings_c(

	abs_eap_am_tools_c * const tools)

	: eap_method_values_c(tools)

{

	m_is_valid = true;

}

//-------------------------------------------------------------------------------

eap_method_settings_c::eap_method_settings_c(

	abs_eap_am_tools_c * const tools,

	const eap_method_settings_c * const init)

	: eap_method_values_c(tools)

{

	eap_status_e status(eap_status_ok);

	// The correct status is set in the end of this function.

	m_completion_status = eap_status_allocation_error;

	m_EAPType = init->m_EAPType;

	m_IndexType = init->m_IndexType;

	m_Index = init->m_Index;

	m_UseAutomaticCACertificatePresent = init->m_UseAutomaticCACertificatePresent;

	m_UseAutomaticCACertificate = init->m_UseAutomaticCACertificate;

	m_UseAutomaticUsernamePresent = init->m_UseAutomaticUsernamePresent;

	m_UseAutomaticUsername = init->m_UseAutomaticUsername;

	m_UseAutomaticRealmPresent = init->m_UseAutomaticRealmPresent;

	m_UseAutomaticRealm = init->m_UseAutomaticRealm;

	m_UsernamePresent = init->m_UsernamePresent;

	if (m_UsernamePresent == true)

	{

		status = m_Username_fix.set_copy_of_buffer(&(init->m_Username_fix));

		if (status != eap_status_ok)

		{

			return;

		}

	}

	m_PasswordExistPresent = init->m_PasswordExistPresent;

	m_PasswordExist = init->m_PasswordExist;

	m_PasswordPresent = init->m_PasswordPresent;

	if (m_PasswordPresent == true)

	{

		status = m_Password.set_copy_of_buffer(&(init->m_Password));

		if (status != eap_status_ok)

		{

			return;

		}

	}

	m_RealmPresent = init->m_RealmPresent;

	if (m_RealmPresent == true)

	{

		status = m_Realm.set_copy_of_buffer(&(init->m_Realm));

		if (status != eap_status_ok)

		{

			return;

		}

	}

	m_UsePseudonymsPresent = init->m_UsePseudonymsPresent;

	m_UsePseudonyms = init->m_UsePseudonyms;

	m_VerifyServerRealmPresent = init->m_VerifyServerRealmPresent;

	m_VerifyServerRealm = init->m_VerifyServerRealm;

	m_RequireClientAuthenticationPresent = init->m_RequireClientAuthenticationPresent;

	m_RequireClientAuthentication = init->m_RequireClientAuthentication;

	m_SessionValidityTimePresent = init->m_SessionValidityTimePresent;

	m_SessionValidityTime = init->m_SessionValidityTime;

	m_CipherSuitesPresent = init->m_CipherSuitesPresent;

	if (m_CipherSuitesPresent == true)

	{

		status = copy_simple<u16_t>(