1 /*

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

    15 *

    16 */

    17 

    18 /*

    19 * %version: 24 %

    20 */

    21 

    22 // This is enumeration of EAPOL source code.

    23 #if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

    24 	#undef EAP_FILE_NUMBER_ENUM

    25 	#define EAP_FILE_NUMBER_ENUM 759 

    26 	#undef EAP_FILE_NUMBER_DATE 

    27 	#define EAP_FILE_NUMBER_DATE 1127594498 

    28 #endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

    29 

    30 #include "eap_am_tools.h"

    31 #include "eap_am_export.h"

    32 #include "eap_method_settings.h"

    33 #include "eap_array_algorithms.h"

    34 #include "eap_automatic_variable.h"

    35 

    36 //-------------------------------------------------------------------------------

    37 

    38 eap_certificate_entry_c::~eap_certificate_entry_c()

    39 {

    40 }

    41 

    42 //-------------------------------------------------------------------------------

    43 

    44 eap_certificate_entry_c::eap_certificate_entry_c(

    45 	abs_eap_am_tools_c * const tools)

    46 : m_am_tools(tools)

    47 , m_CertType(eap_certificate_type_none)

    48 , m_SubjectNamePresent(false)

    49 , m_SubjectName(tools)

    50 , m_IssuerNamePresent(false)

    51 , m_IssuerName(tools)

    52 , m_SerialNumberPresent(false)

    53 , m_SerialNumber(tools)

    54 , m_SubjectKeyIDPresent(false)

    55 , m_SubjectKeyID(tools)

    56 , m_ThumbprintPresent(false)

    57 , m_Thumbprint(tools)

    58 , m_LabelPresent(false)

    59 , m_Label(tools)

    60 , m_PrimaryNamePresent(false)

    61 , m_PrimaryName(tools)

    62 , m_SecondaryNamePresent(false)

    63 , m_SecondaryName(tools)

    64 , m_iIsEnabledPresent(false)

    65 , m_iIsEnabled(false)

    66 {

    67 }

    68 

    69 //-------------------------------------------------------------------------------

    70 

    71 bool eap_certificate_entry_c::get_is_valid()

    72 {

    73 	return true;

    74 }

    75 

    76 //-------------------------------------------------------------------------------

    77 

    78 bool eap_certificate_entry_c::get_is_valid_data()

    79 {

    80 	return get_is_valid();

    81 }

    82 

    83 //-------------------------------------------------------------------------------

    84 

    85 eap_certificate_entry_c * eap_certificate_entry_c::copy()

    86 {

    87 	eap_certificate_entry_c * const new_entry = new eap_certificate_entry_c(m_am_tools);

    88 

    89 	eap_automatic_variable_c<eap_certificate_entry_c> automatic_new_entry(

    90 		m_am_tools,

    91 		new_entry);

    92 

    93 	if (new_entry == 0

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

    95 	{

    96 		(void) EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

    97 		return 0;

    98 	}

    99 

   100 	eap_status_e status(eap_status_ok);

   101 

   102 	new_entry->m_CertType = m_CertType;

   103 

   104 	new_entry->m_SubjectNamePresent = m_SubjectNamePresent;

   105 	if (m_SubjectNamePresent == true)

   106 	{

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

   108 		if (status != eap_status_ok)

   109 		{

   110 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   111 			return 0;

   112 		}

   113 	}

   114 

   115 	new_entry->m_IssuerNamePresent = m_IssuerNamePresent;

   116 	if (m_IssuerNamePresent == true)

   117 	{

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

   119 		if (status != eap_status_ok)

   120 		{

   121 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   122 			return 0;

   123 		}

   124 	}

   125 

   126 	new_entry->m_SerialNumberPresent = m_SerialNumberPresent;

   127 	if (m_SerialNumberPresent == true)

   128 	{

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

   130 		if (status != eap_status_ok)

   131 		{

   132 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   133 			return 0;

   134 		}

   135 	}

   136 

   137 	new_entry->m_SubjectKeyIDPresent = m_SubjectKeyIDPresent;

   138 	if (m_SubjectKeyIDPresent == true)

   139 	{

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

   141 		if (status != eap_status_ok)

   142 		{

   143 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   144 			return 0;

   145 		}

   146 	}

   147 

   148 	new_entry->m_ThumbprintPresent = m_ThumbprintPresent;

   149 	if (m_ThumbprintPresent == true)

   150 	{

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

   152 		if (status != eap_status_ok)

   153 		{

   154 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   155 			return 0;

   156 		}

   157 	}

   158 

   159 	new_entry->m_LabelPresent = m_LabelPresent;

   160 	if (m_LabelPresent == true)

   161 	{

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

   163 		if (status != eap_status_ok)

   164 		{

   165 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   166 			return 0;

   167 		}

   168 	}

   169 

   170 	new_entry->m_PrimaryNamePresent = m_PrimaryNamePresent;

   171 	if (m_PrimaryNamePresent == true)

   172 	{

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

   174 		if (status != eap_status_ok)

   175 		{

   176 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   177 			return 0;

   178 		}

   179 	}

   180 

   181 	new_entry->m_SecondaryNamePresent = m_SecondaryNamePresent;

   182 	if (m_SecondaryNamePresent == true)

   183 	{

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

   185 		if (status != eap_status_ok)

   186 		{

   187 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   188 			return 0;

   189 		}

   190 	}

   191 

   192 	new_entry->m_iIsEnabledPresent = m_iIsEnabledPresent;

   193 	new_entry->m_iIsEnabled = m_iIsEnabled;

   194 

   195 	automatic_new_entry.do_not_free_variable();

   196 

   197 	return new_entry;

   198 }

   199 

   200 //-------------------------------------------------------------------------------

   201 

   202 void eap_certificate_entry_c::trace() const

   203 {

   204 	EAP_TRACE_DEBUG(

   205 		m_am_tools,

   206 		TRACE_FLAGS_DEFAULT,

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

   208 		m_CertType));

   209 

   210 	EAP_TRACE_DEBUG(

   211 		m_am_tools,

   212 		TRACE_FLAGS_DEFAULT,

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

   214 		m_SubjectNamePresent));

   215 	if (m_SubjectNamePresent == true)

   216 	{

   217 		EAP_TRACE_DATA_DEBUG(

   218 			m_am_tools, 

   219 			TRACE_FLAGS_DEFAULT, 

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

   221 			m_SubjectName.get_data(),

   222 			m_SubjectName.get_data_length()));

   223 	}

   224 

   225 	EAP_TRACE_DEBUG(

   226 		m_am_tools,

   227 		TRACE_FLAGS_DEFAULT,

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

   229 		m_IssuerNamePresent));

   230 	if (m_IssuerNamePresent == true)

   231 	{

   232 		EAP_TRACE_DATA_DEBUG(

   233 			m_am_tools, 

   234 			TRACE_FLAGS_DEFAULT, 

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

   236 			m_IssuerName.get_data(),

   237 			m_IssuerName.get_data_length()));

   238 	}

   239 

   240 	EAP_TRACE_DEBUG(

   241 		m_am_tools,

   242 		TRACE_FLAGS_DEFAULT,

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

   244 		m_SerialNumberPresent));

   245 	if (m_SerialNumberPresent == true)

   246 	{

   247 		EAP_TRACE_DATA_DEBUG(

   248 			m_am_tools, 

   249 			TRACE_FLAGS_DEFAULT, 

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

   251 			m_SerialNumber.get_data(),

   252 			m_SerialNumber.get_data_length()));

   253 	}

   254 

   255 	EAP_TRACE_DEBUG(

   256 		m_am_tools,

   257 		TRACE_FLAGS_DEFAULT,

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

   259 		m_SubjectKeyIDPresent));

   260 	if (m_SubjectKeyIDPresent == true)

   261 	{

   262 		EAP_TRACE_DATA_DEBUG(

   263 			m_am_tools, 

   264 			TRACE_FLAGS_DEFAULT, 

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

   266 			m_SubjectKeyID.get_data(),

   267 			m_SubjectKeyID.get_data_length()));

   268 	}

   269 

   270 	EAP_TRACE_DEBUG(

   271 		m_am_tools,

   272 		TRACE_FLAGS_DEFAULT,

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

   274 		m_ThumbprintPresent));

   275 	if (m_ThumbprintPresent == true)

   276 	{

   277 		EAP_TRACE_DATA_DEBUG(

   278 			m_am_tools, 

   279 			TRACE_FLAGS_DEFAULT, 

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

   281 			m_Thumbprint.get_data(),

   282 			m_Thumbprint.get_data_length()));

   283 	}

   284 

   285 	EAP_TRACE_DEBUG(

   286 		m_am_tools,

   287 		TRACE_FLAGS_DEFAULT,

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

   289 		m_LabelPresent));

   290 	if (m_LabelPresent == true)

   291 	{

   292 		EAP_TRACE_DATA_DEBUG(

   293 			m_am_tools, 

   294 			TRACE_FLAGS_DEFAULT, 

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

   296 			m_Label.get_data(),

   297 			m_Label.get_data_length()));

   298 	}

   299 

   300 	EAP_TRACE_DEBUG(

   301 		m_am_tools,

   302 		TRACE_FLAGS_DEFAULT,

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

   304 		m_PrimaryNamePresent));

   305 	if (m_PrimaryNamePresent == true)

   306 	{

   307 		EAP_TRACE_DATA_DEBUG(

   308 			m_am_tools, 

   309 			TRACE_FLAGS_DEFAULT, 

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

   311 			m_PrimaryName.get_data(),

   312 			m_PrimaryName.get_data_length()));

   313 	}

   314 

   315 	EAP_TRACE_DEBUG(

   316 		m_am_tools,

   317 		TRACE_FLAGS_DEFAULT,

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

   319 		m_SecondaryNamePresent));

   320 	if (m_SecondaryNamePresent == true)

   321 	{

   322 		EAP_TRACE_DATA_DEBUG(

   323 			m_am_tools, 

   324 			TRACE_FLAGS_DEFAULT, 

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

   326 			m_SecondaryName.get_data(),

   327 			m_SecondaryName.get_data_length()));

   328 	}

   329 

   330 	EAP_TRACE_DEBUG(

   331 		m_am_tools,

   332 		TRACE_FLAGS_DEFAULT,

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

   334 		m_iIsEnabledPresent));

   335 	if (m_iIsEnabledPresent == true)

   336 	{

   337 		EAP_TRACE_DEBUG(

   338 			m_am_tools,

   339 			TRACE_FLAGS_DEFAULT,

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

   341 			m_iIsEnabled));

   342 	}

   343 }

   344 

   345 //-------------------------------------------------------------------------------

   346 //-------------------------------------------------------------------------------

   347 //-------------------------------------------------------------------------------

   348 

   349 eap_method_values_c::~eap_method_values_c()

   350 {

   351 }

   352 

   353 //-------------------------------------------------------------------------------

   354 

   355 eap_method_values_c::eap_method_values_c(

   356 	abs_eap_am_tools_c * const tools)

   357 : m_am_tools(tools)

   358 , m_is_valid(false)

   359 , m_completion_status(eap_status_process_general_error)

   360 , m_EAPType(eap_type_none)

   361 , m_IndexType(0ul)

   362 , m_Index(0ul)

   363 , m_UseAutomaticCACertificatePresent(false)

   364 , m_UseAutomaticCACertificate(false)

   365 , m_UseAutomaticUsernamePresent(false)

   366 , m_UseAutomaticUsername(false)

   367 , m_UseAutomaticRealmPresent(false)

   368 , m_UseAutomaticRealm(false)

   369 , m_UsernamePresent(false)

   370 , m_Username_fix(tools)

   371 , m_PasswordExistPresent(false)

   372 , m_PasswordPresent(false)

   373 , m_Password(tools)

   374 , m_RealmPresent(false)

   375 , m_Realm(tools)

   376 , m_UsePseudonymsPresent(false)

   377 , m_UsePseudonyms(false)

   378 , m_VerifyServerRealmPresent(false)

   379 , m_VerifyServerRealm(false)

   380 , m_RequireClientAuthenticationPresent(false)

   381 , m_RequireClientAuthentication(false)

   382 , m_SessionValidityTimePresent(false)

   383 , m_SessionValidityTime(0ul)

   384 , m_CipherSuitesPresent(false)

   385 , m_CipherSuites(tools)

   386 , m_PEAPVersionsPresent(false)

   387 , m_PEAPv0Allowed(false)

   388 , m_PEAPv1Allowed(false)

   389 , m_PEAPv2Allowed(false)

   390 , m_CertificatesPresent(false)

   391 , m_Certificates(tools)

   392 , m_EnabledEncapsulatedEAPTypesPresent(false)

   393 , m_EnabledEncapsulatedEAPTypes(tools)

   394 , m_DisabledEncapsulatedEAPTypesPresent(false)

   395 , m_DisabledEncapsulatedEAPTypes(tools)

   396 , m_AuthProvModeAllowedPresent(false)

   397 , m_AuthProvModeAllowed(false)

   398 , m_UnauthProvModeAllowedPresent(false)

   399 , m_UnauthProvModeAllowed(false)

   400 , m_PACGroupReferencePresent(false)

   401 , m_PACGroupReference(tools)

   402 , m_WarnADHPNoPACPresent(false)

   403 , m_WarnADHPNoPAC(false)

   404 , m_WarnADHPNoMatchingPACPresent(false)

   405 , m_WarnADHPNoMatchingPAC(false)

   406 , m_WarnNotDefaultServerPresent(false)

   407 , m_WarnNotDefaultServer(false)

   408 , m_SelectedEAPTypesPresent(false)

   409 , m_active_eap_methods(tools)

   410 , m_disabled_eap_methods(tools)

   411 , m_TunnelingTypePresent(false)

   412 , m_TunnelingType(eap_type_none)

   413 , m_DestinationIndexAndTypePresent(false)

   414 , m_DestinationIndexType(0ul)

   415 , m_DestinationIndex(0ul)

   416 , m_MethodInfoPresent(false)

   417 , m_KReleaseDate(tools)

   418 , m_KEapTypeVersion(tools)

   419 , m_KManufacturer(tools)

   420 , m_ButtonIdPresent(false)

   421 , m_ButtonId(0)

   422 , m_ShowPassWordPromptPresent(false)

   423 , m_ShowPassWordPrompt(false)

   424 , m_UseIdentityPrivacyPresent(false)

   425 , m_UseIdentityPrivacy(false)

   426 {

   427 }

   428 

   429 //-------------------------------------------------------------------------------

   430 

   431 abs_eap_am_tools_c * eap_method_values_c::get_am_tools() const

   432 {

   433 	return m_am_tools;

   434 }

   435 

   436 

   437 //-------------------------------------------------------------------------------

   438 //-------------------------------------------------------------------------------

   439 //-------------------------------------------------------------------------------

   440 

   441 eap_method_settings_c::~eap_method_settings_c()

   442 {

   443 }

   444 

   445 //-------------------------------------------------------------------------------

   446 

   447 eap_method_settings_c::eap_method_settings_c(

   448 	abs_eap_am_tools_c * const tools)

   449 	: eap_method_values_c(tools)

   450 {

   451 	m_is_valid = true;

   452 }

   453 

   454 //-------------------------------------------------------------------------------

   455 

   456 eap_method_settings_c::eap_method_settings_c(

   457 	abs_eap_am_tools_c * const tools,

   458 	const eap_method_settings_c * const init)

   459 	: eap_method_values_c(tools)

   460 {

   461 	eap_status_e status(eap_status_ok);

   462 

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

   464 	m_completion_status = eap_status_allocation_error;

   465 

   466 	m_EAPType = init->m_EAPType;

   467 

   468 	m_IndexType = init->m_IndexType;

   469 

   470 	m_Index = init->m_Index;

   471 

   472 	m_UseAutomaticCACertificatePresent = init->m_UseAutomaticCACertificatePresent;

   473 	m_UseAutomaticCACertificate = init->m_UseAutomaticCACertificate;

   474 

   475 	m_UseAutomaticUsernamePresent = init->m_UseAutomaticUsernamePresent;

   476 	m_UseAutomaticUsername = init->m_UseAutomaticUsername;

   477 

   478 	m_UseAutomaticRealmPresent = init->m_UseAutomaticRealmPresent;

   479 	m_UseAutomaticRealm = init->m_UseAutomaticRealm;

   480 

   481 	m_UsernamePresent = init->m_UsernamePresent;

   482 	if (m_UsernamePresent == true)

   483 	{

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

   485 		if (status != eap_status_ok)

   486 		{

   487 			return;

   488 		}

   489 	}

   490 

   491 	m_PasswordExistPresent = init->m_PasswordExistPresent;

   492 	m_PasswordExist = init->m_PasswordExist;

   493 

   494 	m_PasswordPresent = init->m_PasswordPresent;

   495 	if (m_PasswordPresent == true)

   496 	{

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

   498 		if (status != eap_status_ok)

   499 		{

   500 			return;

   501 		}

   502 	}

   503 

   504 	m_RealmPresent = init->m_RealmPresent;

   505 	if (m_RealmPresent == true)

   506 	{

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

   508 		if (status != eap_status_ok)

   509 		{

   510 			return;

   511 		}

   512 	}

   513 

   514 	m_UsePseudonymsPresent = init->m_UsePseudonymsPresent;

   515 	m_UsePseudonyms = init->m_UsePseudonyms;

   516 

   517 	m_VerifyServerRealmPresent = init->m_VerifyServerRealmPresent;

   518 	m_VerifyServerRealm = init->m_VerifyServerRealm;

   519 

   520 	m_RequireClientAuthenticationPresent = init->m_RequireClientAuthenticationPresent;

   521 	m_RequireClientAuthentication = init->m_RequireClientAuthentication;

   522 

   523 	m_SessionValidityTimePresent = init->m_SessionValidityTimePresent;

   524 	m_SessionValidityTime = init->m_SessionValidityTime;

   525 

   526 	m_CipherSuitesPresent = init->m_CipherSuitesPresent;

   527 	if (m_CipherSuitesPresent == true)

   528 	{

   529 		status = copy_simple<u16_t>(

   530 			&(init->m_CipherSuites),

   531 			&m_CipherSuites,

   532 			tools,

   533 			false);

   534 		if (status != eap_status_ok)

   535 		{

   536 			return;

   537 		}

   538 	}

   539 

   540 	m_PEAPVersionsPresent = init->m_PEAPVersionsPresent;

   541 	m_PEAPv0Allowed = init->m_PEAPv0Allowed;

   542 	m_PEAPv1Allowed = init->m_PEAPv1Allowed;

   543 	m_PEAPv2Allowed = init->m_PEAPv2Allowed;

   544 

   545 	m_CertificatesPresent = init->m_CertificatesPresent;

   546 	if (m_CertificatesPresent == true)

   547 	{

   548 		status = copy<eap_certificate_entry_c>(

   549 			&(init->m_Certificates),

   550 			&m_Certificates,

   551 			tools,

   552 			false);

   553 		if (status != eap_status_ok)

   554 		{

   555 			return;

   556 		}

   557 	}

   558 

   559 	m_EnabledEncapsulatedEAPTypesPresent = init->m_EnabledEncapsulatedEAPTypesPresent;

   560 	if (m_EnabledEncapsulatedEAPTypesPresent == true)

   561 	{

   562 		status = copy<eap_type_value_e>(

   563 			&(init->m_EnabledEncapsulatedEAPTypes),

   564 			&m_EnabledEncapsulatedEAPTypes,

   565 			tools,

   566 			false);

   567 		if (status != eap_status_ok)

   568 		{

   569 			return;

   570 		}

   571 	}

   572 

   573 	m_DisabledEncapsulatedEAPTypesPresent = init->m_DisabledEncapsulatedEAPTypesPresent;

   574 	if (m_DisabledEncapsulatedEAPTypesPresent == true)

   575 	{

   576 		status = copy<eap_type_value_e>(

   577 			&(init->m_DisabledEncapsulatedEAPTypes),

   578 			&m_DisabledEncapsulatedEAPTypes,

   579 			tools,

   580 			false);

   581 		if (status != eap_status_ok)

   582 		{

   583 			return;

   584 		}

   585 	}

   586 

   587 	m_AuthProvModeAllowedPresent = init->m_AuthProvModeAllowedPresent;

   588 	m_AuthProvModeAllowed = init->m_AuthProvModeAllowed;

   589 

   590 	m_UnauthProvModeAllowedPresent = init->m_UnauthProvModeAllowedPresent;

   591 	m_UnauthProvModeAllowed = init->m_UnauthProvModeAllowed;

   592 

   593 	m_PACGroupReferencePresent = init->m_PACGroupReferencePresent;

   594 	if (m_PACGroupReferencePresent == true)

   595 	{

   596 		status = m_PACGroupReference.set_copy_of_buffer(&(init->m_PACGroupReference));

   597 		if (status != eap_status_ok)

   598 		{

   599 			return;

   600 		}

   601 	}

   602 

   603 	m_WarnADHPNoPACPresent = init->m_WarnADHPNoPACPresent;

   604 	m_WarnADHPNoPAC = init->m_WarnADHPNoPAC;

   605 

   606 	m_WarnADHPNoMatchingPACPresent = init->m_WarnADHPNoMatchingPACPresent;

   607 	m_WarnADHPNoMatchingPAC = init->m_WarnADHPNoMatchingPAC;

   608 

   609 	m_WarnNotDefaultServerPresent = init->m_WarnNotDefaultServerPresent;

   610 	m_WarnNotDefaultServer = init->m_WarnNotDefaultServer;

   611 

   612 	m_SelectedEAPTypesPresent = init->m_SelectedEAPTypesPresent;

   613 	if (m_SelectedEAPTypesPresent == true)

   614 	{

   615 		status = copy<eap_type_value_e>(

   616 			&(init->m_active_eap_methods),

   617 			&m_active_eap_methods,

   618 			tools,

   619 			false);

   620 		if (status != eap_status_ok)

   621 		{

   622 			return;

   623 		}

   624 

   625 		status = copy<eap_type_value_e>(

   626 			&(init->m_disabled_eap_methods),

   627 			&m_disabled_eap_methods,

   628 			tools,

   629 			false);

   630 		if (status != eap_status_ok)

   631 		{

   632 			return;

   633 		}

   634 	}

   635 

   636 	m_TunnelingTypePresent = init->m_TunnelingTypePresent;

   637 	m_TunnelingType = init->m_TunnelingType;

   638 

   639 	m_DestinationIndexAndTypePresent = init->m_DestinationIndexAndTypePresent;

   640 	m_DestinationIndexType = init->m_DestinationIndexType;

   641 	m_DestinationIndex = init->m_DestinationIndex;

   642 

   643 	m_MethodInfoPresent = init->m_MethodInfoPresent;

   644 	if (m_MethodInfoPresent == true)

   645 	{

   646 		status = m_KReleaseDate.set_copy_of_buffer(&(init->m_KReleaseDate));

   647 		if (status != eap_status_ok)

   648 		{

   649 			return;

   650 		}

   651 

   652 		status = m_KEapTypeVersion.set_copy_of_buffer(&(init->m_KEapTypeVersion));

   653 		if (status != eap_status_ok)

   654 		{

   655 			return;

   656 		}

   657 

   658 		status = m_KManufacturer.set_copy_of_buffer(&(init->m_KManufacturer));

   659 		if (status != eap_status_ok)

   660 		{

   661 			return;

   662 		}

   663 	}

   664 

   665 	m_ButtonIdPresent = init->m_ButtonIdPresent;

   666 	m_ButtonId = init->m_ButtonId;

   667 

   668 	m_ShowPassWordPromptPresent = init->m_ShowPassWordPromptPresent;

   669 	m_ShowPassWordPrompt = init->m_ShowPassWordPrompt;

   670 

   671 	m_UseIdentityPrivacyPresent = init->m_UseIdentityPrivacyPresent;

   672 	m_UseIdentityPrivacy = init->m_UseIdentityPrivacy;

   673 

   674 	m_completion_status = init->m_completion_status;

   675 

   676 	m_is_valid = true;

   677 }

   678 

   679 //-------------------------------------------------------------------------------

   680 

   681 void eap_method_settings_c::trace() const

   682 {

   683 	u32_t ind = 0ul;

   684 

   685 	EAP_TRACE_DEBUG(

   686 		get_am_tools(),

   687 		TRACE_FLAGS_DEFAULT,

   688 		(EAPL("eap_method_settings_c::trace(): m_is_valid=%d\n"),

   689 		m_is_valid));

   690 

   691 	EAP_TRACE_DEBUG(

   692 		get_am_tools(),

   693 		TRACE_FLAGS_DEFAULT,

   694 		(EAPL("eap_method_settings_c::trace(): m_completion_status=%d\n"),

   695 		m_completion_status));

   696 

   697 	EAP_TRACE_DEBUG(

   698 		get_am_tools(),

   699 		TRACE_FLAGS_DEFAULT,

   700 		(EAPL("eap_method_settings_c::trace(): m_EAPType=0xfe%06x%08x\n"),

   701 		m_EAPType.get_vendor_id(),

   702 		m_EAPType.get_vendor_type()));

   703 

   704 	EAP_TRACE_DEBUG(

   705 		get_am_tools(),

   706 		TRACE_FLAGS_DEFAULT,

   707 		(EAPL("eap_method_settings_c::trace(): m_IndexType=%d\n"),

   708 		m_IndexType));

   709 

   710 	EAP_TRACE_DEBUG(

   711 		get_am_tools(),

   712 		TRACE_FLAGS_DEFAULT,

   713 		(EAPL("eap_method_settings_c::trace(): m_Index=%d\n"),

   714 		m_Index));

   715 

   716 	EAP_TRACE_DEBUG(

   717 		get_am_tools(),

   718 		TRACE_FLAGS_DEFAULT,

   719 		(EAPL("eap_method_settings_c::trace(): m_UseAutomaticCACertificatePresent=%d\n"),

   720 		m_UseAutomaticCACertificatePresent));

   721 	if (m_UseAutomaticCACertificatePresent == true)

   722 	{

   723 		EAP_TRACE_DEBUG(

   724 			get_am_tools(),

   725 			TRACE_FLAGS_DEFAULT,

   726 			(EAPL("eap_method_settings_c::trace():  m_UseAutomaticCACertificate=%d\n"),

   727 			m_UseAutomaticCACertificate));

   728 	}

   729 

   730 	EAP_TRACE_DEBUG(

   731 		get_am_tools(),

   732 		TRACE_FLAGS_DEFAULT,

   733 		(EAPL("eap_method_settings_c::trace(): m_UseAutomaticUsernamePresent=%d\n"),

   734 		m_UseAutomaticUsernamePresent));

   735 	if (m_UseAutomaticUsernamePresent == true)

   736 	{

   737 		EAP_TRACE_DEBUG(

   738 			get_am_tools(),

   739 			TRACE_FLAGS_DEFAULT,

   740 			(EAPL("eap_method_settings_c::trace():  m_UseAutomaticUsername=%d\n"),

   741 			m_UseAutomaticUsername));

   742 	}

   743 

   744 	EAP_TRACE_DEBUG(

   745 		get_am_tools(),

   746 		TRACE_FLAGS_DEFAULT,

   747 		(EAPL("eap_method_settings_c::trace(): m_UseAutomaticRealmPresent=%d\n"),

   748 		m_UseAutomaticRealmPresent));

   749 	if (m_UseAutomaticRealmPresent == true)

   750 	{

   751 		EAP_TRACE_DEBUG(

   752 			get_am_tools(),

   753 			TRACE_FLAGS_DEFAULT,

   754 			(EAPL("eap_method_settings_c::trace():  m_UseAutomaticRealm=%d\n"),

   755 			m_UseAutomaticRealm));

   756 	}

   757 

   758 	EAP_TRACE_DEBUG(

   759 		get_am_tools(),

   760 		TRACE_FLAGS_DEFAULT,

   761 		(EAPL("eap_method_settings_c::trace(): m_UsernamePresent=%d\n"),

   762 		m_UsernamePresent));

   763 	if (m_UsernamePresent == true)

   764 	{

   765 		EAP_TRACE_DATA_DEBUG(

   766 			get_am_tools(), 

   767 			TRACE_FLAGS_DEFAULT, 

   768 			(EAPL("eap_method_settings_c::trace():     m_Username_fix"),

   769 			m_Username_fix.get_data(),

   770 			m_Username_fix.get_data_length()));

   771 	}

   772 

   773 	EAP_TRACE_DEBUG(

   774 		get_am_tools(),

   775 		TRACE_FLAGS_DEFAULT,

   776 		(EAPL("eap_method_settings_c::trace(): m_PasswordExistPresent=%d\n"),

   777 		m_PasswordExistPresent));

   778 	if (m_PasswordExistPresent == true)

   779 	{

   780 		EAP_TRACE_DEBUG(

   781 			get_am_tools(),

   782 			TRACE_FLAGS_DEFAULT,

   783 			(EAPL("eap_method_settings_c::trace():     m_PasswordExist=%d\n"),

   784 			m_PasswordExist));

   785 	}

   786 

   787 

   788 	EAP_TRACE_DEBUG(

   789 		get_am_tools(),

   790 		TRACE_FLAGS_DEFAULT,

   791 		(EAPL("eap_method_settings_c::trace(): m_PasswordPresent=%d\n"),

   792 		m_PasswordPresent));

   793 	if (m_PasswordPresent == true)

   794 	{

   795 		EAP_TRACE_DATA_DEBUG(

   796 			get_am_tools(), 

   797 			TRACE_FLAGS_DEFAULT, 

   798 			(EAPL("eap_method_settings_c::trace():     m_Password"),

   799 			m_Password.get_data(),

   800 			m_Password.get_data_length()));

   801 	}

   802 

   803 	EAP_TRACE_DEBUG(

   804 		get_am_tools(),

   805 		TRACE_FLAGS_DEFAULT,

   806 		(EAPL("eap_method_settings_c::trace(): m_RealmPresent=%d\n"),

   807 		m_RealmPresent));

   808 	if (m_RealmPresent == true)

   809 	{

   810 		EAP_TRACE_DATA_DEBUG(

   811 			get_am_tools(), 

   812 			TRACE_FLAGS_DEFAULT, 

   813 			(EAPL("eap_method_settings_c::trace():     m_Realm"),

   814 			m_Realm.get_data(),

   815 			m_Realm.get_data_length()));

   816 	}

   817 

   818 	EAP_TRACE_DEBUG(

   819 		get_am_tools(),

   820 		TRACE_FLAGS_DEFAULT,

   821 		(EAPL("eap_method_settings_c::trace(): m_UsePseudonymsPresent=%d\n"),

   822 		m_UsePseudonymsPresent));

   823 	if (m_UsePseudonymsPresent == true)

   824 	{

   825 		EAP_TRACE_DEBUG(

   826 			get_am_tools(),

   827 			TRACE_FLAGS_DEFAULT,

   828 			(EAPL("eap_method_settings_c::trace():     m_UsePseudonyms=%d\n"),

   829 			m_UsePseudonyms));

   830 	}

   831 

   832 	EAP_TRACE_DEBUG(

   833 		get_am_tools(),

   834 		TRACE_FLAGS_DEFAULT,

   835 		(EAPL("eap_method_settings_c::trace(): m_VerifyServerRealmPresent=%d\n"),

   836 		m_VerifyServerRealmPresent));

   837 	if (m_VerifyServerRealmPresent == true)

   838 	{

   839 		EAP_TRACE_DEBUG(

   840 			get_am_tools(),

   841 			TRACE_FLAGS_DEFAULT,

   842 			(EAPL("eap_method_settings_c::trace():     m_VerifyServerRealm=%d\n"),

   843 			m_VerifyServerRealm));

   844 	}

   845 

   846 	EAP_TRACE_DEBUG(

   847 		get_am_tools(),

   848 		TRACE_FLAGS_DEFAULT,

   849 		(EAPL("eap_method_settings_c::trace(): m_RequireClientAuthenticationPresent=%d\n"),

   850 		m_RequireClientAuthenticationPresent));

   851 	if (m_RequireClientAuthenticationPresent == true)

   852 	{

   853 		EAP_TRACE_DEBUG(

   854 			get_am_tools(),

   855 			TRACE_FLAGS_DEFAULT,

   856 			(EAPL("eap_method_settings_c::trace():     m_RequireClientAuthentication=%d\n"),

   857 			m_RequireClientAuthentication));

   858 	}

   859 

   860 	EAP_TRACE_DEBUG(

   861 		get_am_tools(),

   862 		TRACE_FLAGS_DEFAULT,

   863 		(EAPL("eap_method_settings_c::trace(): m_SessionValidityTimePresent=%d\n"),

   864 		m_SessionValidityTimePresent));

   865 	if (m_SessionValidityTimePresent == true)

   866 	{

   867 		EAP_TRACE_DEBUG(

   868 			get_am_tools(),

   869 			TRACE_FLAGS_DEFAULT,

   870 			(EAPL("eap_method_settings_c::trace():     m_SessionValidityTime=%d\n"),

   871 			m_SessionValidityTime));

   872 	}

   873 

   874 	EAP_TRACE_DEBUG(

   875 		get_am_tools(),

   876 		TRACE_FLAGS_DEFAULT,

   877 		(EAPL("eap_method_settings_c::trace(): m_CipherSuitesPresent=%d\n"),

   878 		m_CipherSuitesPresent));

   879 	if (m_CipherSuitesPresent == true)

   880 	{

   881 		EAP_TRACE_DEBUG(

   882 			get_am_tools(),

   883 			TRACE_FLAGS_DEFAULT,

   884 			(EAPL("eap_method_settings_c::trace():     m_CipherSuites=%d\n"),

   885 			m_CipherSuites.get_object_count()));

   886 		for (ind = 0ul; ind < m_CipherSuites.get_object_count(); ++ind)

   887 		{

   888 			u16_t * cipher_suite = m_CipherSuites.get_object(ind);

   889 			if (cipher_suite != 0)

   890 			{

   891 				EAP_TRACE_DEBUG(

   892 					get_am_tools(),

   893 					TRACE_FLAGS_DEFAULT,

   894 					(EAPL("eap_method_settings_c::trace():     cipher_suite=%d\n"),

   895 					*cipher_suite));

   896 			}

   897 		}

   898 	}

   899 

   900 	EAP_TRACE_DEBUG(

   901 		get_am_tools(),

   902 		TRACE_FLAGS_DEFAULT,

   903 		(EAPL("eap_method_settings_c::trace(): m_PEAPVersionsPresent=%d\n"),

   904 		m_PEAPVersionsPresent));

   905 	if (m_PEAPVersionsPresent == true)

   906 	{

   907 		EAP_TRACE_DEBUG(

   908 			get_am_tools(),

   909 			TRACE_FLAGS_DEFAULT,

   910 			(EAPL("eap_method_settings_c::trace():     m_PEAPv0Allowed=%d\n"),

   911 			m_PEAPv0Allowed));

   912 		EAP_TRACE_DEBUG(

   913 			get_am_tools(),

   914 			TRACE_FLAGS_DEFAULT,

   915 			(EAPL("eap_method_settings_c::trace():     m_PEAPv1Allowed=%d\n"),

   916 			m_PEAPv1Allowed));

   917 		EAP_TRACE_DEBUG(

   918 			get_am_tools(),

   919 			TRACE_FLAGS_DEFAULT,

   920 			(EAPL("eap_method_settings_c::trace():     m_PEAPv2Allowed=%d\n"),

   921 			m_PEAPv2Allowed));

   922 	}

   923 

   924 	EAP_TRACE_DEBUG(

   925 		get_am_tools(),

   926 		TRACE_FLAGS_DEFAULT,

   927 		(EAPL("eap_method_settings_c::trace(): m_CertificatesPresent=%d\n"),

   928 		m_CertificatesPresent));

   929 	if (m_CertificatesPresent == true)

   930 	{

   931 		EAP_TRACE_DEBUG(

   932 			get_am_tools(),

   933 			TRACE_FLAGS_DEFAULT,

   934 			(EAPL("eap_method_settings_c::trace():     m_Certificates=%d\n"),

   935 			m_Certificates.get_object_count()));

   936 		for (ind = 0ul; ind < m_Certificates.get_object_count(); ++ind)

   937 		{

   938 			eap_certificate_entry_c * entry = m_Certificates.get_object(ind);

   939 			if (entry != 0)

   940 			{

   941 				entry->trace();

   942 			}

   943 		}

   944 	}

   945 

   946 	EAP_TRACE_DEBUG(

   947 		get_am_tools(),

   948 		TRACE_FLAGS_DEFAULT,

   949 		(EAPL("eap_method_settings_c::trace(): m_EnabledEncapsulatedEAPTypesPresent=%d\n"),

   950 		m_EnabledEncapsulatedEAPTypesPresent));

   951 	if (m_EnabledEncapsulatedEAPTypesPresent == true)

   952 	{

   953 		EAP_TRACE_DEBUG(

   954 			get_am_tools(),

   955 			TRACE_FLAGS_DEFAULT,

   956 			(EAPL("eap_method_settings_c::trace():     m_EnabledEncapsulatedEAPTypes=%d\n"),

   957 			m_EnabledEncapsulatedEAPTypes.get_object_count()));

   958 		for (ind = 0ul; ind < m_EnabledEncapsulatedEAPTypes.get_object_count(); ++ind)

   959 		{

   960 			eap_type_value_e * type = m_EnabledEncapsulatedEAPTypes.get_object(ind);

   961 			if (type != 0)

   962 			{

   963 				EAP_TRACE_DEBUG(

   964 					get_am_tools(),

   965 					TRACE_FLAGS_DEFAULT,

   966 					(EAPL("eap_method_settings_c::trace():     EAP-type=0xfe%06x%08x\n"),

   967 					type->get_vendor_id(),

   968 					type->get_vendor_type()));

   969 			}

   970 		}

   971 	}

   972 

   973 	EAP_TRACE_DEBUG(

   974 		get_am_tools(),

   975 		TRACE_FLAGS_DEFAULT,

   976 		(EAPL("eap_method_settings_c::trace(): m_DisabledEncapsulatedEAPTypesPresent=%d\n"),

   977 		m_DisabledEncapsulatedEAPTypesPresent));

   978 	if (m_DisabledEncapsulatedEAPTypesPresent == true)

   979 	{

   980 		EAP_TRACE_DEBUG(

   981 			get_am_tools(),

   982 			TRACE_FLAGS_DEFAULT,

   983 			(EAPL("eap_method_settings_c::trace():     m_DisabledEncapsulatedEAPTypes=%d\n"),

   984 			m_DisabledEncapsulatedEAPTypes.get_object_count()));

   985 		for (ind = 0ul; ind < m_DisabledEncapsulatedEAPTypes.get_object_count(); ++ind)

   986 		{

   987 			eap_type_value_e * type = m_DisabledEncapsulatedEAPTypes.get_object(ind);

   988 			if (type != 0)

   989 			{

   990 				EAP_TRACE_DEBUG(

   991 					get_am_tools(),

   992 					TRACE_FLAGS_DEFAULT,

   993 					(EAPL("eap_method_settings_c::trace():     EAP-type=0xfe%06x%08x\n"),

   994 					type->get_vendor_id(),

   995 					type->get_vendor_type()));

   996 			}

   997 		}

   998 	}

   999 

  1000 	EAP_TRACE_DEBUG(

  1001 		get_am_tools(),

  1002 		TRACE_FLAGS_DEFAULT,

  1003 		(EAPL("eap_method_settings_c::trace(): m_AuthProvModeAllowedPresent=%d\n"),

  1004 		m_AuthProvModeAllowedPresent));

  1005 	if (m_AuthProvModeAllowedPresent == true)

  1006 	{

  1007 		EAP_TRACE_DEBUG(

  1008 			get_am_tools(),

  1009 			TRACE_FLAGS_DEFAULT,

  1010 			(EAPL("eap_method_settings_c::trace():     m_AuthProvModeAllowed=%d\n"),

  1011 			m_AuthProvModeAllowed));

  1012 	}

  1013 

  1014 	EAP_TRACE_DEBUG(

  1015 		get_am_tools(),

  1016 		TRACE_FLAGS_DEFAULT,

  1017 		(EAPL("eap_method_settings_c::trace(): m_UnauthProvModeAllowedPresent=%d\n"),

  1018 		m_UnauthProvModeAllowedPresent));

  1019 	if (m_UnauthProvModeAllowedPresent == true)

  1020 	{

  1021 		EAP_TRACE_DEBUG(

  1022 			get_am_tools(),

  1023 			TRACE_FLAGS_DEFAULT,

  1024 			(EAPL("eap_method_settings_c::trace():     m_UnauthProvModeAllowed=%d\n"),

  1025 			m_UnauthProvModeAllowed));

  1026 	}

  1027 

  1028 	EAP_TRACE_DEBUG(

  1029 		get_am_tools(),

  1030 		TRACE_FLAGS_DEFAULT,

  1031 		(EAPL("eap_method_settings_c::trace(): m_PACGroupReferencePresent=%d\n"),

  1032 		m_PACGroupReferencePresent));

  1033 	if (m_PACGroupReferencePresent == true)

  1034 	{

  1035 		EAP_TRACE_DATA_DEBUG(

  1036 			get_am_tools(), 

  1037 			TRACE_FLAGS_DEFAULT, 

  1038 			(EAPL("eap_method_settings_c::trace():     m_PACGroupReference"),

  1039 			m_PACGroupReference.get_data(),

  1040 			m_PACGroupReference.get_data_length()));

  1041 	}

  1042 

  1043 	EAP_TRACE_DEBUG(

  1044 		get_am_tools(),

  1045 		TRACE_FLAGS_DEFAULT,

  1046 		(EAPL("eap_method_settings_c::trace(): m_WarnADHPNoPACPresent=%d\n"),

  1047 		m_WarnADHPNoPACPresent));

  1048 	if (m_WarnADHPNoPACPresent == true)

  1049 	{

  1050 		EAP_TRACE_DEBUG(

  1051 			get_am_tools(),

  1052 			TRACE_FLAGS_DEFAULT,

  1053 			(EAPL("eap_method_settings_c::trace():     m_WarnADHPNoPAC=%d\n"),

  1054 			m_WarnADHPNoPAC));

  1055 	}

  1056 

  1057 	EAP_TRACE_DEBUG(

  1058 		get_am_tools(),

  1059 		TRACE_FLAGS_DEFAULT,

  1060 		(EAPL("eap_method_settings_c::trace(): m_WarnADHPNoMatchingPACPresent=%d\n"),

  1061 		m_WarnADHPNoMatchingPACPresent));

  1062 	if (m_WarnADHPNoMatchingPACPresent == true)

  1063 	{

  1064 		EAP_TRACE_DEBUG(

  1065 			get_am_tools(),

  1066 			TRACE_FLAGS_DEFAULT,

  1067 			(EAPL("eap_method_settings_c::trace():     m_WarnADHPNoMatchingPAC=%d\n"),

  1068 			m_WarnADHPNoMatchingPAC));

  1069 	}

  1070 

  1071 	EAP_TRACE_DEBUG(

  1072 		get_am_tools(),

  1073 		TRACE_FLAGS_DEFAULT,

  1074 		(EAPL("eap_method_settings_c::trace(): m_WarnNotDefaultServerPresent=%d\n"),

  1075 		m_WarnNotDefaultServerPresent));

  1076 	if (m_WarnNotDefaultServerPresent == true)

  1077 	{

  1078 		EAP_TRACE_DEBUG(

  1079 			get_am_tools(),

  1080 			TRACE_FLAGS_DEFAULT,

  1081 			(EAPL("eap_method_settings_c::trace():     m_WarnNotDefaultServer=%d\n"),

  1082 			m_WarnNotDefaultServer));

  1083 	}

  1084 

  1085 	EAP_TRACE_DEBUG(

  1086 		get_am_tools(),

  1087 		TRACE_FLAGS_DEFAULT,

  1088 		(EAPL("eap_method_settings_c::trace(): m_SelectedEAPTypesPresent=%d\n"),

  1089 		m_SelectedEAPTypesPresent));

  1090 	if (m_SelectedEAPTypesPresent == true)

  1091 	{

  1092 		EAP_TRACE_DEBUG(

  1093 			get_am_tools(),

  1094 			TRACE_FLAGS_DEFAULT,

  1095 			(EAPL("eap_method_settings_c::trace():     m_active_eap_methods=%d\n"),

  1096 			m_active_eap_methods.get_object_count()));

  1097 		for (ind = 0ul; ind < m_active_eap_methods.get_object_count(); ++ind)

  1098 		{

  1099 			eap_type_value_e * type = m_active_eap_methods.get_object(ind);

  1100 			if (type != 0)

  1101 			{

  1102 				EAP_TRACE_DEBUG(

  1103 					get_am_tools(),

  1104 					TRACE_FLAGS_DEFAULT,

  1105 					(EAPL("eap_method_settings_c::trace():         active EAP-type=0xfe%06x%08x\n"),

  1106 					type->get_vendor_id(),

  1107 					type->get_vendor_type()));

  1108 			}

  1109 		}

  1110 		EAP_TRACE_DEBUG(

  1111 			get_am_tools(),

  1112 			TRACE_FLAGS_DEFAULT,

  1113 			(EAPL("eap_method_settings_c::trace():     m_disabled_eap_methods=%d\n"),

  1114 			m_disabled_eap_methods.get_object_count()));

  1115 		for (ind = 0ul; ind < m_disabled_eap_methods.get_object_count(); ++ind)

  1116 		{

  1117 			eap_type_value_e * type = m_disabled_eap_methods.get_object(ind);

  1118 			if (type != 0)

  1119 			{

  1120 				EAP_TRACE_DEBUG(

  1121 					get_am_tools(),

  1122 					TRACE_FLAGS_DEFAULT,

  1123 					(EAPL("eap_method_settings_c::trace():         disabled EAP-type=0xfe%06x%08x\n"),

  1124 					type->get_vendor_id(),

  1125 					type->get_vendor_type()));

  1126 			}

  1127 		}

  1128 	}

  1129 

  1130 	EAP_TRACE_DEBUG(

  1131 		get_am_tools(),

  1132 		TRACE_FLAGS_DEFAULT,

  1133 		(EAPL("eap_method_settings_c::trace(): m_TunnelingTypePresent=%d\n"),

  1134 		m_TunnelingTypePresent));