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: 23 %

    20 */

    21 

    22 #include "eap_am_tools.h"

    23 #include "eap_am_export.h"

    24 #include "eap_method_settings.h"

    25 #include "eap_array_algorithms.h"

    26 #include "eap_automatic_variable.h"

    27 

    28 //-------------------------------------------------------------------------------

    29 

    30 eap_certificate_entry_c::~eap_certificate_entry_c()

    31 {

    32 }

    33 

    34 //-------------------------------------------------------------------------------

    35 

    36 eap_certificate_entry_c::eap_certificate_entry_c(

    37 	abs_eap_am_tools_c * const tools)

    38 : m_am_tools(tools)

    39 , m_CertType(eap_certificate_type_none)

    40 , m_SubjectNamePresent(false)

    41 , m_SubjectName(tools)

    42 , m_IssuerNamePresent(false)

    43 , m_IssuerName(tools)

    44 , m_SerialNumberPresent(false)

    45 , m_SerialNumber(tools)

    46 , m_SubjectKeyIDPresent(false)

    47 , m_SubjectKeyID(tools)

    48 , m_ThumbprintPresent(false)

    49 , m_Thumbprint(tools)

    50 , m_LabelPresent(false)

    51 , m_Label(tools)

    52 , m_PrimaryNamePresent(false)

    53 , m_PrimaryName(tools)

    54 , m_SecondaryNamePresent(false)

    55 , m_SecondaryName(tools)

    56 , m_iIsEnabledPresent(false)

    57 , m_iIsEnabled(false)

    58 {

    59 }

    60 

    61 //-------------------------------------------------------------------------------

    62 

    63 bool eap_certificate_entry_c::get_is_valid()

    64 {

    65 	return true;

    66 }

    67 

    68 //-------------------------------------------------------------------------------

    69 

    70 bool eap_certificate_entry_c::get_is_valid_data()

    71 {

    72 	return get_is_valid();

    73 }

    74 

    75 //-------------------------------------------------------------------------------

    76 

    77 eap_certificate_entry_c * eap_certificate_entry_c::copy()

    78 {

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

    80 

    81 	eap_automatic_variable_c<eap_certificate_entry_c> automatic_new_entry(

    82 		m_am_tools,

    83 		new_entry);

    84 

    85 	if (new_entry == 0

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

    87 	{

    88 		(void) EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

    89 		return 0;

    90 	}

    91 

    92 	eap_status_e status(eap_status_ok);

    93 

    94 	new_entry->m_CertType = m_CertType;

    95 

    96 	new_entry->m_SubjectNamePresent = m_SubjectNamePresent;

    97 	if (m_SubjectNamePresent == true)

    98 	{

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

   100 		if (status != eap_status_ok)

   101 		{

   102 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   103 			return 0;

   104 		}

   105 	}

   106 

   107 	new_entry->m_IssuerNamePresent = m_IssuerNamePresent;

   108 	if (m_IssuerNamePresent == true)

   109 	{

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

   111 		if (status != eap_status_ok)

   112 		{

   113 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   114 			return 0;

   115 		}

   116 	}

   117 

   118 	new_entry->m_SerialNumberPresent = m_SerialNumberPresent;

   119 	if (m_SerialNumberPresent == true)

   120 	{

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

   122 		if (status != eap_status_ok)

   123 		{

   124 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   125 			return 0;

   126 		}

   127 	}

   128 

   129 	new_entry->m_SubjectKeyIDPresent = m_SubjectKeyIDPresent;

   130 	if (m_SubjectKeyIDPresent == true)

   131 	{

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

   133 		if (status != eap_status_ok)

   134 		{

   135 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   136 			return 0;

   137 		}

   138 	}

   139 

   140 	new_entry->m_ThumbprintPresent = m_ThumbprintPresent;

   141 	if (m_ThumbprintPresent == true)

   142 	{

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

   144 		if (status != eap_status_ok)

   145 		{

   146 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   147 			return 0;

   148 		}

   149 	}

   150 

   151 	new_entry->m_LabelPresent = m_LabelPresent;

   152 	if (m_LabelPresent == true)

   153 	{

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

   155 		if (status != eap_status_ok)

   156 		{

   157 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   158 			return 0;

   159 		}

   160 	}

   161 

   162 	new_entry->m_PrimaryNamePresent = m_PrimaryNamePresent;

   163 	if (m_PrimaryNamePresent == true)

   164 	{

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

   166 		if (status != eap_status_ok)

   167 		{

   168 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   169 			return 0;

   170 		}

   171 	}

   172 

   173 	new_entry->m_SecondaryNamePresent = m_SecondaryNamePresent;

   174 	if (m_SecondaryNamePresent == true)

   175 	{

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

   177 		if (status != eap_status_ok)

   178 		{

   179 			(void) EAP_STATUS_RETURN(m_am_tools, status);

   180 			return 0;

   181 		}

   182 	}

   183 

   184 	new_entry->m_iIsEnabledPresent = m_iIsEnabledPresent;

   185 	new_entry->m_iIsEnabled = m_iIsEnabled;

   186 

   187 	automatic_new_entry.do_not_free_variable();

   188 

   189 	return new_entry;

   190 }

   191 

   192 //-------------------------------------------------------------------------------

   193 

   194 void eap_certificate_entry_c::trace() const

   195 {

   196 	EAP_TRACE_DEBUG(

   197 		m_am_tools,

   198 		TRACE_FLAGS_DEFAULT,

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

   200 		m_CertType));

   201 

   202 	EAP_TRACE_DEBUG(

   203 		m_am_tools,

   204 		TRACE_FLAGS_DEFAULT,

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

   206 		m_SubjectNamePresent));

   207 	if (m_SubjectNamePresent == true)

   208 	{

   209 		EAP_TRACE_DATA_DEBUG(

   210 			m_am_tools, 

   211 			TRACE_FLAGS_DEFAULT, 

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

   213 			m_SubjectName.get_data(),

   214 			m_SubjectName.get_data_length()));

   215 	}

   216 

   217 	EAP_TRACE_DEBUG(

   218 		m_am_tools,

   219 		TRACE_FLAGS_DEFAULT,

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

   221 		m_IssuerNamePresent));

   222 	if (m_IssuerNamePresent == true)

   223 	{

   224 		EAP_TRACE_DATA_DEBUG(

   225 			m_am_tools, 

   226 			TRACE_FLAGS_DEFAULT, 

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

   228 			m_IssuerName.get_data(),

   229 			m_IssuerName.get_data_length()));

   230 	}

   231 

   232 	EAP_TRACE_DEBUG(

   233 		m_am_tools,

   234 		TRACE_FLAGS_DEFAULT,

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

   236 		m_SerialNumberPresent));

   237 	if (m_SerialNumberPresent == true)

   238 	{

   239 		EAP_TRACE_DATA_DEBUG(

   240 			m_am_tools, 

   241 			TRACE_FLAGS_DEFAULT, 

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

   243 			m_SerialNumber.get_data(),

   244 			m_SerialNumber.get_data_length()));

   245 	}

   246 

   247 	EAP_TRACE_DEBUG(

   248 		m_am_tools,

   249 		TRACE_FLAGS_DEFAULT,

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

   251 		m_SubjectKeyIDPresent));

   252 	if (m_SubjectKeyIDPresent == true)

   253 	{

   254 		EAP_TRACE_DATA_DEBUG(

   255 			m_am_tools, 

   256 			TRACE_FLAGS_DEFAULT, 

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

   258 			m_SubjectKeyID.get_data(),

   259 			m_SubjectKeyID.get_data_length()));

   260 	}

   261 

   262 	EAP_TRACE_DEBUG(

   263 		m_am_tools,

   264 		TRACE_FLAGS_DEFAULT,

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

   266 		m_ThumbprintPresent));

   267 	if (m_ThumbprintPresent == true)

   268 	{

   269 		EAP_TRACE_DATA_DEBUG(

   270 			m_am_tools, 

   271 			TRACE_FLAGS_DEFAULT, 

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

   273 			m_Thumbprint.get_data(),

   274 			m_Thumbprint.get_data_length()));

   275 	}

   276 

   277 	EAP_TRACE_DEBUG(

   278 		m_am_tools,

   279 		TRACE_FLAGS_DEFAULT,

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

   281 		m_LabelPresent));

   282 	if (m_LabelPresent == true)

   283 	{

   284 		EAP_TRACE_DATA_DEBUG(

   285 			m_am_tools, 

   286 			TRACE_FLAGS_DEFAULT, 

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

   288 			m_Label.get_data(),

   289 			m_Label.get_data_length()));

   290 	}

   291 

   292 	EAP_TRACE_DEBUG(

   293 		m_am_tools,

   294 		TRACE_FLAGS_DEFAULT,

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

   296 		m_PrimaryNamePresent));

   297 	if (m_PrimaryNamePresent == true)

   298 	{

   299 		EAP_TRACE_DATA_DEBUG(

   300 			m_am_tools, 

   301 			TRACE_FLAGS_DEFAULT, 

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

   303 			m_PrimaryName.get_data(),

   304 			m_PrimaryName.get_data_length()));

   305 	}

   306 

   307 	EAP_TRACE_DEBUG(

   308 		m_am_tools,

   309 		TRACE_FLAGS_DEFAULT,

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

   311 		m_SecondaryNamePresent));

   312 	if (m_SecondaryNamePresent == true)

   313 	{

   314 		EAP_TRACE_DATA_DEBUG(

   315 			m_am_tools, 

   316 			TRACE_FLAGS_DEFAULT, 

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

   318 			m_SecondaryName.get_data(),

   319 			m_SecondaryName.get_data_length()));

   320 	}

   321 

   322 	EAP_TRACE_DEBUG(

   323 		m_am_tools,

   324 		TRACE_FLAGS_DEFAULT,

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

   326 		m_iIsEnabledPresent));

   327 	if (m_iIsEnabledPresent == true)

   328 	{

   329 		EAP_TRACE_DEBUG(

   330 			m_am_tools,

   331 			TRACE_FLAGS_DEFAULT,

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

   333 			m_iIsEnabled));

   334 	}

   335 }

   336 

   337 //-------------------------------------------------------------------------------

   338 //-------------------------------------------------------------------------------

   339 //-------------------------------------------------------------------------------

   340 

   341 eap_method_values_c::~eap_method_values_c()

   342 {

   343 }

   344 

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

   346 

   347 eap_method_values_c::eap_method_values_c(

   348 	abs_eap_am_tools_c * const tools)

   349 : m_am_tools(tools)

   350 , m_is_valid(false)

   351 , m_completion_status(eap_status_process_general_error)

   352 , m_EAPType(eap_type_none)

   353 , m_IndexType(0ul)

   354 , m_Index(0ul)

   355 , m_UseAutomaticCACertificatePresent(false)

   356 , m_UseAutomaticCACertificate(false)

   357 , m_UseAutomaticUsernamePresent(false)

   358 , m_UseAutomaticUsername(false)

   359 , m_UseAutomaticRealmPresent(false)

   360 , m_UseAutomaticRealm(false)

   361 , m_UsernamePresent(false)

   362 , m_Username_fix(tools)

   363 , m_PasswordExistPresent(false)

   364 , m_PasswordPresent(false)

   365 , m_Password(tools)

   366 , m_RealmPresent(false)

   367 , m_Realm(tools)

   368 , m_UsePseudonymsPresent(false)

   369 , m_UsePseudonyms(false)

   370 , m_VerifyServerRealmPresent(false)

   371 , m_VerifyServerRealm(false)

   372 , m_RequireClientAuthenticationPresent(false)

   373 , m_RequireClientAuthentication(false)

   374 , m_SessionValidityTimePresent(false)

   375 , m_SessionValidityTime(0ul)

   376 , m_CipherSuitesPresent(false)

   377 , m_CipherSuites(tools)

   378 , m_PEAPVersionsPresent(false)

   379 , m_PEAPv0Allowed(false)

   380 , m_PEAPv1Allowed(false)

   381 , m_PEAPv2Allowed(false)

   382 , m_CertificatesPresent(false)

   383 , m_Certificates(tools)

   384 , m_EnabledEncapsulatedEAPTypesPresent(false)

   385 , m_EnabledEncapsulatedEAPTypes(tools)

   386 , m_DisabledEncapsulatedEAPTypesPresent(false)

   387 , m_DisabledEncapsulatedEAPTypes(tools)

   388 , m_AuthProvModeAllowedPresent(false)

   389 , m_AuthProvModeAllowed(false)

   390 , m_UnauthProvModeAllowedPresent(false)

   391 , m_UnauthProvModeAllowed(false)

   392 , m_PACGroupReferencePresent(false)

   393 , m_PACGroupReference(tools)

   394 , m_WarnADHPNoPACPresent(false)

   395 , m_WarnADHPNoPAC(false)

   396 , m_WarnADHPNoMatchingPACPresent(false)

   397 , m_WarnADHPNoMatchingPAC(false)

   398 , m_WarnNotDefaultServerPresent(false)

   399 , m_WarnNotDefaultServer(false)

   400 , m_SelectedEAPTypesPresent(false)

   401 , m_active_eap_methods(tools)

   402 , m_disabled_eap_methods(tools)

   403 , m_TunnelingTypePresent(false)

   404 , m_TunnelingType(eap_type_none)

   405 , m_DestinationIndexAndTypePresent(false)

   406 , m_DestinationIndexType(0ul)

   407 , m_DestinationIndex(0ul)

   408 , m_MethodInfoPresent(false)

   409 , m_KReleaseDate(tools)

   410 , m_KEapTypeVersion(tools)

   411 , m_KManufacturer(tools)

   412 , m_ButtonIdPresent(false)

   413 , m_ButtonId(0)

   414 , m_ShowPassWordPromptPresent(false)

   415 , m_ShowPassWordPrompt(false)

   416 , m_UseIdentityPrivacyPresent(false)

   417 , m_UseIdentityPrivacy(false)

   418 {

   419 }

   420 

   421 //-------------------------------------------------------------------------------

   422 

   423 abs_eap_am_tools_c * eap_method_values_c::get_am_tools() const

   424 {

   425 	return m_am_tools;

   426 }

   427 

   428 

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

   430 //-------------------------------------------------------------------------------

   431 //-------------------------------------------------------------------------------

   432 

   433 eap_method_settings_c::~eap_method_settings_c()

   434 {

   435 }

   436 

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

   438 

   439 eap_method_settings_c::eap_method_settings_c(

   440 	abs_eap_am_tools_c * const tools)

   441 	: eap_method_values_c(tools)

   442 {

   443 	m_is_valid = true;

   444 }

   445 

   446 //-------------------------------------------------------------------------------

   447 

   448 eap_method_settings_c::eap_method_settings_c(

   449 	abs_eap_am_tools_c * const tools,

   450 	const eap_method_settings_c * const init)

   451 	: eap_method_values_c(tools)

   452 {

   453 	eap_status_e status(eap_status_ok);

   454 

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

   456 	m_completion_status = eap_status_allocation_error;

   457 

   458 	m_EAPType = init->m_EAPType;

   459 

   460 	m_IndexType = init->m_IndexType;

   461 

   462 	m_Index = init->m_Index;

   463 

   464 	m_UseAutomaticCACertificatePresent = init->m_UseAutomaticCACertificatePresent;

   465 	m_UseAutomaticCACertificate = init->m_UseAutomaticCACertificate;

   466 

   467 	m_UseAutomaticUsernamePresent = init->m_UseAutomaticUsernamePresent;

   468 	m_UseAutomaticUsername = init->m_UseAutomaticUsername;

   469 

   470 	m_UseAutomaticRealmPresent = init->m_UseAutomaticRealmPresent;

   471 	m_UseAutomaticRealm = init->m_UseAutomaticRealm;

   472 

   473 	m_UsernamePresent = init->m_UsernamePresent;

   474 	if (m_UsernamePresent == true)

   475 	{

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

   477 		if (status != eap_status_ok)

   478 		{

   479 			return;

   480 		}

   481 	}

   482 

   483 	m_PasswordExistPresent = init->m_PasswordExistPresent;

   484 	m_PasswordExist = init->m_PasswordExist;

   485 

   486 	m_PasswordPresent = init->m_PasswordPresent;

   487 	if (m_PasswordPresent == true)

   488 	{

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

   490 		if (status != eap_status_ok)

   491 		{

   492 			return;

   493 		}

   494 	}

   495 

   496 	m_RealmPresent = init->m_RealmPresent;

   497 	if (m_RealmPresent == true)

   498 	{

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

   500 		if (status != eap_status_ok)

   501 		{

   502 			return;

   503 		}

   504 	}

   505 

   506 	m_UsePseudonymsPresent = init->m_UsePseudonymsPresent;

   507 	m_UsePseudonyms = init->m_UsePseudonyms;

   508 

   509 	m_VerifyServerRealmPresent = init->m_VerifyServerRealmPresent;

   510 	m_VerifyServerRealm = init->m_VerifyServerRealm;

   511 

   512 	m_RequireClientAuthenticationPresent = init->m_RequireClientAuthenticationPresent;

   513 	m_RequireClientAuthentication = init->m_RequireClientAuthentication;

   514 

   515 	m_SessionValidityTimePresent = init->m_SessionValidityTimePresent;

   516 	m_SessionValidityTime = init->m_SessionValidityTime;

   517 

   518 	m_CipherSuitesPresent = init->m_CipherSuitesPresent;

   519 	if (m_CipherSuitesPresent == true)

   520 	{

   521 		status = copy_simple<u16_t>(

   522 			&(init->m_CipherSuites),

   523 			&m_CipherSuites,

   524 			tools,

   525 			false);

   526 		if (status != eap_status_ok)

   527 		{

   528 			return;

   529 		}

   530 	}

   531 

   532 	m_PEAPVersionsPresent = init->m_PEAPVersionsPresent;

   533 	m_PEAPv0Allowed = init->m_PEAPv0Allowed;

   534 	m_PEAPv1Allowed = init->m_PEAPv1Allowed;

   535 	m_PEAPv2Allowed = init->m_PEAPv2Allowed;

   536 

   537 	m_CertificatesPresent = init->m_CertificatesPresent;

   538 	if (m_CertificatesPresent == true)

   539 	{

   540 		status = copy<eap_certificate_entry_c>(

   541 			&(init->m_Certificates),

   542 			&m_Certificates,

   543 			tools,

   544 			false);

   545 		if (status != eap_status_ok)

   546 		{

   547 			return;

   548 		}

   549 	}

   550 

   551 	m_EnabledEncapsulatedEAPTypesPresent = init->m_EnabledEncapsulatedEAPTypesPresent;

   552 	if (m_EnabledEncapsulatedEAPTypesPresent == true)

   553 	{

   554 		status = copy<eap_type_value_e>(

   555 			&(init->m_EnabledEncapsulatedEAPTypes),

   556 			&m_EnabledEncapsulatedEAPTypes,

   557 			tools,

   558 			false);

   559 		if (status != eap_status_ok)

   560 		{

   561 			return;

   562 		}

   563 	}

   564 

   565 	m_DisabledEncapsulatedEAPTypesPresent = init->m_DisabledEncapsulatedEAPTypesPresent;

   566 	if (m_DisabledEncapsulatedEAPTypesPresent == true)

   567 	{

   568 		status = copy<eap_type_value_e>(

   569 			&(init->m_DisabledEncapsulatedEAPTypes),

   570 			&m_DisabledEncapsulatedEAPTypes,

   571 			tools,

   572 			false);

   573 		if (status != eap_status_ok)

   574 		{

   575 			return;

   576 		}

   577 	}

   578 

   579 	m_AuthProvModeAllowedPresent = init->m_AuthProvModeAllowedPresent;

   580 	m_AuthProvModeAllowed = init->m_AuthProvModeAllowed;

   581 

   582 	m_UnauthProvModeAllowedPresent = init->m_UnauthProvModeAllowedPresent;

   583 	m_UnauthProvModeAllowed = init->m_UnauthProvModeAllowed;

   584 

   585 	m_PACGroupReferencePresent = init->m_PACGroupReferencePresent;

   586 	if (m_PACGroupReferencePresent == true)

   587 	{

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

   589 		if (status != eap_status_ok)

   590 		{

   591 			return;

   592 		}

   593 	}

   594 

   595 	m_WarnADHPNoPACPresent = init->m_WarnADHPNoPACPresent;

   596 	m_WarnADHPNoPAC = init->m_WarnADHPNoPAC;

   597 

   598 	m_WarnADHPNoMatchingPACPresent = init->m_WarnADHPNoMatchingPACPresent;

   599 	m_WarnADHPNoMatchingPAC = init->m_WarnADHPNoMatchingPAC;

   600 

   601 	m_WarnNotDefaultServerPresent = init->m_WarnNotDefaultServerPresent;

   602 	m_WarnNotDefaultServer = init->m_WarnNotDefaultServer;

   603 

   604 	m_SelectedEAPTypesPresent = init->m_SelectedEAPTypesPresent;

   605 	if (m_SelectedEAPTypesPresent == true)

   606 	{

   607 		status = copy<eap_type_value_e>(

   608 			&(init->m_active_eap_methods),

   609 			&m_active_eap_methods,

   610 			tools,

   611 			false);

   612 		if (status != eap_status_ok)

   613 		{

   614 			return;

   615 		}

   616 

   617 		status = copy<eap_type_value_e>(

   618 			&(init->m_disabled_eap_methods),

   619 			&m_disabled_eap_methods,

   620 			tools,

   621 			false);

   622 		if (status != eap_status_ok)

   623 		{

   624 			return;

   625 		}

   626 	}

   627 

   628 	m_TunnelingTypePresent = init->m_TunnelingTypePresent;

   629 	m_TunnelingType = init->m_TunnelingType;

   630 

   631 	m_DestinationIndexAndTypePresent = init->m_DestinationIndexAndTypePresent;

   632 	m_DestinationIndexType = init->m_DestinationIndexType;

   633 	m_DestinationIndex = init->m_DestinationIndex;

   634 

   635 	m_MethodInfoPresent = init->m_MethodInfoPresent;

   636 	if (m_MethodInfoPresent == true)

   637 	{

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

   639 		if (status != eap_status_ok)

   640 		{

   641 			return;

   642 		}

   643 

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

   645 		if (status != eap_status_ok)

   646 		{

   647 			return;

   648 		}

   649 

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

   651 		if (status != eap_status_ok)

   652 		{

   653 			return;

   654 		}

   655 	}

   656 

   657 	m_ButtonIdPresent = init->m_ButtonIdPresent;

   658 	m_ButtonId = init->m_ButtonId;

   659 

   660 	m_ShowPassWordPromptPresent = init->m_ShowPassWordPromptPresent;

   661 	m_ShowPassWordPrompt = init->m_ShowPassWordPrompt;

   662 

   663 	m_UseIdentityPrivacyPresent = init->m_UseIdentityPrivacyPresent;

   664 	m_UseIdentityPrivacy = init->m_UseIdentityPrivacy;

   665 

   666 	m_completion_status = init->m_completion_status;

   667 

   668 	m_is_valid = true;

   669 }

   670 

   671 //-------------------------------------------------------------------------------

   672 

   673 void eap_method_settings_c::trace() const

   674 {

   675 	u32_t ind = 0ul;

   676 

   677 	EAP_TRACE_DEBUG(

   678 		get_am_tools(),

   679 		TRACE_FLAGS_DEFAULT,

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

   681 		m_is_valid));

   682 

   683 	EAP_TRACE_DEBUG(

   684 		get_am_tools(),

   685 		TRACE_FLAGS_DEFAULT,

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

   687 		m_completion_status));

   688 

   689 	EAP_TRACE_DEBUG(

   690 		get_am_tools(),

   691 		TRACE_FLAGS_DEFAULT,

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

   693 		m_EAPType.get_vendor_id(),

   694 		m_EAPType.get_vendor_type()));

   695 

   696 	EAP_TRACE_DEBUG(

   697 		get_am_tools(),

   698 		TRACE_FLAGS_DEFAULT,

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

   700 		m_IndexType));

   701 

   702 	EAP_TRACE_DEBUG(

   703 		get_am_tools(),

   704 		TRACE_FLAGS_DEFAULT,

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

   706 		m_Index));

   707 

   708 	EAP_TRACE_DEBUG(

   709 		get_am_tools(),

   710 		TRACE_FLAGS_DEFAULT,

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

   712 		m_UseAutomaticCACertificatePresent));

   713 	if (m_UseAutomaticCACertificatePresent == true)

   714 	{

   715 		EAP_TRACE_DEBUG(

   716 			get_am_tools(),

   717 			TRACE_FLAGS_DEFAULT,

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

   719 			m_UseAutomaticCACertificate));

   720 	}

   721 

   722 	EAP_TRACE_DEBUG(

   723 		get_am_tools(),

   724 		TRACE_FLAGS_DEFAULT,

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

   726 		m_UseAutomaticUsernamePresent));

   727 	if (m_UseAutomaticUsernamePresent == true)

   728 	{

   729 		EAP_TRACE_DEBUG(

   730 			get_am_tools(),

   731 			TRACE_FLAGS_DEFAULT,

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

   733 			m_UseAutomaticUsername));

   734 	}

   735 

   736 	EAP_TRACE_DEBUG(

   737 		get_am_tools(),

   738 		TRACE_FLAGS_DEFAULT,

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

   740 		m_UseAutomaticRealmPresent));

   741 	if (m_UseAutomaticRealmPresent == true)

   742 	{

   743 		EAP_TRACE_DEBUG(

   744 			get_am_tools(),

   745 			TRACE_FLAGS_DEFAULT,

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

   747 			m_UseAutomaticRealm));

   748 	}

   749 

   750 	EAP_TRACE_DEBUG(

   751 		get_am_tools(),

   752 		TRACE_FLAGS_DEFAULT,

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

   754 		m_UsernamePresent));

   755 	if (m_UsernamePresent == true)

   756 	{

   757 		EAP_TRACE_DATA_DEBUG(

   758 			get_am_tools(), 

   759 			TRACE_FLAGS_DEFAULT, 

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

   761 			m_Username_fix.get_data(),

   762 			m_Username_fix.get_data_length()));

   763 	}

   764 

   765 	EAP_TRACE_DEBUG(

   766 		get_am_tools(),

   767 		TRACE_FLAGS_DEFAULT,

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

   769 		m_PasswordExistPresent));

   770 	if (m_PasswordExistPresent == true)

   771 	{

   772 		EAP_TRACE_DEBUG(

   773 			get_am_tools(),

   774 			TRACE_FLAGS_DEFAULT,

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

   776 			m_PasswordExist));

   777 	}

   778 

   779 

   780 	EAP_TRACE_DEBUG(

   781 		get_am_tools(),

   782 		TRACE_FLAGS_DEFAULT,

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

   784 		m_PasswordPresent));

   785 	if (m_PasswordPresent == true)

   786 	{

   787 		EAP_TRACE_DATA_DEBUG(

   788 			get_am_tools(), 

   789 			TRACE_FLAGS_DEFAULT, 

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

   791 			m_Password.get_data(),

   792 			m_Password.get_data_length()));

   793 	}

   794 

   795 	EAP_TRACE_DEBUG(

   796 		get_am_tools(),

   797 		TRACE_FLAGS_DEFAULT,

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

   799 		m_RealmPresent));

   800 	if (m_RealmPresent == true)

   801 	{

   802 		EAP_TRACE_DATA_DEBUG(

   803 			get_am_tools(), 

   804 			TRACE_FLAGS_DEFAULT, 

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

   806 			m_Realm.get_data(),

   807 			m_Realm.get_data_length()));

   808 	}

   809 

   810 	EAP_TRACE_DEBUG(

   811 		get_am_tools(),

   812 		TRACE_FLAGS_DEFAULT,

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

   814 		m_UsePseudonymsPresent));

   815 	if (m_UsePseudonymsPresent == true)

   816 	{

   817 		EAP_TRACE_DEBUG(

   818 			get_am_tools(),

   819 			TRACE_FLAGS_DEFAULT,

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

   821 			m_UsePseudonyms));

   822 	}

   823 

   824 	EAP_TRACE_DEBUG(

   825 		get_am_tools(),

   826 		TRACE_FLAGS_DEFAULT,

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

   828 		m_VerifyServerRealmPresent));

   829 	if (m_VerifyServerRealmPresent == true)

   830 	{

   831 		EAP_TRACE_DEBUG(

   832 			get_am_tools(),

   833 			TRACE_FLAGS_DEFAULT,

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

   835 			m_VerifyServerRealm));

   836 	}

   837 

   838 	EAP_TRACE_DEBUG(

   839 		get_am_tools(),

   840 		TRACE_FLAGS_DEFAULT,

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

   842 		m_RequireClientAuthenticationPresent));

   843 	if (m_RequireClientAuthenticationPresent == true)

   844 	{

   845 		EAP_TRACE_DEBUG(

   846 			get_am_tools(),

   847 			TRACE_FLAGS_DEFAULT,

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

   849 			m_RequireClientAuthentication));

   850 	}

   851 

   852 	EAP_TRACE_DEBUG(

   853 		get_am_tools(),

   854 		TRACE_FLAGS_DEFAULT,

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

   856 		m_SessionValidityTimePresent));

   857 	if (m_SessionValidityTimePresent == true)

   858 	{

   859 		EAP_TRACE_DEBUG(

   860 			get_am_tools(),

   861 			TRACE_FLAGS_DEFAULT,

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

   863 			m_SessionValidityTime));

   864 	}

   865 

   866 	EAP_TRACE_DEBUG(

   867 		get_am_tools(),

   868 		TRACE_FLAGS_DEFAULT,

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

   870 		m_CipherSuitesPresent));

   871 	if (m_CipherSuitesPresent == true)

   872 	{

   873 		EAP_TRACE_DEBUG(

   874 			get_am_tools(),

   875 			TRACE_FLAGS_DEFAULT,

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

   877 			m_CipherSuites.get_object_count()));

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

   879 		{

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

   881 			if (cipher_suite != 0)

   882 			{

   883 				EAP_TRACE_DEBUG(

   884 					get_am_tools(),

   885 					TRACE_FLAGS_DEFAULT,

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

   887 					*cipher_suite));

   888 			}

   889 		}

   890 	}

   891 

   892 	EAP_TRACE_DEBUG(

   893 		get_am_tools(),

   894 		TRACE_FLAGS_DEFAULT,

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

   896 		m_PEAPVersionsPresent));

   897 	if (m_PEAPVersionsPresent == true)

   898 	{

   899 		EAP_TRACE_DEBUG(

   900 			get_am_tools(),

   901 			TRACE_FLAGS_DEFAULT,

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

   903 			m_PEAPv0Allowed));

   904 		EAP_TRACE_DEBUG(

   905 			get_am_tools(),

   906 			TRACE_FLAGS_DEFAULT,

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

   908 			m_PEAPv1Allowed));

   909 		EAP_TRACE_DEBUG(

   910 			get_am_tools(),

   911 			TRACE_FLAGS_DEFAULT,

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

   913 			m_PEAPv2Allowed));

   914 	}

   915 

   916 	EAP_TRACE_DEBUG(

   917 		get_am_tools(),

   918 		TRACE_FLAGS_DEFAULT,

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

   920 		m_CertificatesPresent));

   921 	if (m_CertificatesPresent == true)

   922 	{

   923 		EAP_TRACE_DEBUG(

   924 			get_am_tools(),

   925 			TRACE_FLAGS_DEFAULT,

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

   927 			m_Certificates.get_object_count()));

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

   929 		{

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

   931 			if (entry != 0)

   932 			{

   933 				entry->trace();

   934 			}

   935 		}

   936 	}

   937 

   938 	EAP_TRACE_DEBUG(

   939 		get_am_tools(),

   940 		TRACE_FLAGS_DEFAULT,

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

   942 		m_EnabledEncapsulatedEAPTypesPresent));

   943 	if (m_EnabledEncapsulatedEAPTypesPresent == true)

   944 	{

   945 		EAP_TRACE_DEBUG(

   946 			get_am_tools(),

   947 			TRACE_FLAGS_DEFAULT,

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

   949 			m_EnabledEncapsulatedEAPTypes.get_object_count()));

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

   951 		{

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

   953 			if (type != 0)

   954 			{

   955 				EAP_TRACE_DEBUG(

   956 					get_am_tools(),

   957 					TRACE_FLAGS_DEFAULT,

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

   959 					type->get_vendor_id(),

   960 					type->get_vendor_type()));

   961 			}

   962 		}

   963 	}

   964 

   965 	EAP_TRACE_DEBUG(

   966 		get_am_tools(),

   967 		TRACE_FLAGS_DEFAULT,

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

   969 		m_DisabledEncapsulatedEAPTypesPresent));

   970 	if (m_DisabledEncapsulatedEAPTypesPresent == true)

   971 	{

   972 		EAP_TRACE_DEBUG(

   973 			get_am_tools(),

   974 			TRACE_FLAGS_DEFAULT,

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

   976 			m_DisabledEncapsulatedEAPTypes.get_object_count()));

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

   978 		{

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

   980 			if (type != 0)

   981 			{

   982 				EAP_TRACE_DEBUG(

   983 					get_am_tools(),

   984 					TRACE_FLAGS_DEFAULT,

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

   986 					type->get_vendor_id(),

   987 					type->get_vendor_type()));

   988 			}

   989 		}

   990 	}

   991 

   992 	EAP_TRACE_DEBUG(

   993 		get_am_tools(),

   994 		TRACE_FLAGS_DEFAULT,

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

   996 		m_AuthProvModeAllowedPresent));

   997 	if (m_AuthProvModeAllowedPresent == true)

   998 	{

   999 		EAP_TRACE_DEBUG(

  1000 			get_am_tools(),

  1001 			TRACE_FLAGS_DEFAULT,

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

  1003 			m_AuthProvModeAllowed));

  1004 	}

  1005 

  1006 	EAP_TRACE_DEBUG(

  1007 		get_am_tools(),

  1008 		TRACE_FLAGS_DEFAULT,

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

  1010 		m_UnauthProvModeAllowedPresent));

  1011 	if (m_UnauthProvModeAllowedPresent == true)

  1012 	{

  1013 		EAP_TRACE_DEBUG(

  1014 			get_am_tools(),

  1015 			TRACE_FLAGS_DEFAULT,

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

  1017 			m_UnauthProvModeAllowed));

  1018 	}

  1019 

  1020 	EAP_TRACE_DEBUG(

  1021 		get_am_tools(),

  1022 		TRACE_FLAGS_DEFAULT,

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

  1024 		m_PACGroupReferencePresent));

  1025 	if (m_PACGroupReferencePresent == true)

  1026 	{

  1027 		EAP_TRACE_DATA_DEBUG(

  1028 			get_am_tools(), 

  1029 			TRACE_FLAGS_DEFAULT, 

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

  1031 			m_PACGroupReference.get_data(),

  1032 			m_PACGroupReference.get_data_length()));

  1033 	}

  1034 

  1035 	EAP_TRACE_DEBUG(

  1036 		get_am_tools(),

  1037 		TRACE_FLAGS_DEFAULT,

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

  1039 		m_WarnADHPNoPACPresent));

  1040 	if (m_WarnADHPNoPACPresent == true)

  1041 	{

  1042 		EAP_TRACE_DEBUG(

  1043 			get_am_tools(),

  1044 			TRACE_FLAGS_DEFAULT,

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

  1046 			m_WarnADHPNoPAC));

  1047 	}

  1048 

  1049 	EAP_TRACE_DEBUG(

  1050 		get_am_tools(),

  1051 		TRACE_FLAGS_DEFAULT,

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

  1053 		m_WarnADHPNoMatchingPACPresent));

  1054 	if (m_WarnADHPNoMatchingPACPresent == true)

  1055 	{

  1056 		EAP_TRACE_DEBUG(

  1057 			get_am_tools(),

  1058 			TRACE_FLAGS_DEFAULT,

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

  1060 			m_WarnADHPNoMatchingPAC));

  1061 	}

  1062 

  1063 	EAP_TRACE_DEBUG(

  1064 		get_am_tools(),

  1065 		TRACE_FLAGS_DEFAULT,

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

  1067 		m_WarnNotDefaultServerPresent));

  1068 	if (m_WarnNotDefaultServerPresent == true)

  1069 	{

  1070 		EAP_TRACE_DEBUG(

  1071 			get_am_tools(),

  1072 			TRACE_FLAGS_DEFAULT,

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

  1074 			m_WarnNotDefaultServer));

  1075 	}

  1076 

  1077 	EAP_TRACE_DEBUG(

  1078 		get_am_tools(),

  1079 		TRACE_FLAGS_DEFAULT,

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

  1081 		m_SelectedEAPTypesPresent));

  1082 	if (m_SelectedEAPTypesPresent == true)

  1083 	{

  1084 		EAP_TRACE_DEBUG(

  1085 			get_am_tools(),

  1086 			TRACE_FLAGS_DEFAULT,

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

  1088 			m_active_eap_methods.get_object_count()));

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

  1090 		{

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

  1092 			if (type != 0)

  1093 			{

  1094 				EAP_TRACE_DEBUG(

  1095 					get_am_tools(),

  1096 					TRACE_FLAGS_DEFAULT,

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

  1098 					type->get_vendor_id(),

  1099 					type->get_vendor_type()));

  1100 			}

  1101 		}

  1102 		EAP_TRACE_DEBUG(

  1103 			get_am_tools(),

  1104 			TRACE_FLAGS_DEFAULT,

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

  1106 			m_disabled_eap_methods.get_object_count()));

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

  1108 		{

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

  1110 			if (type != 0)

  1111 			{

  1112 				EAP_TRACE_DEBUG(

  1113 					get_am_tools(),

  1114 					TRACE_FLAGS_DEFAULT,

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

  1116 					type->get_vendor_id(),

  1117 					type->get_vendor_type()));

  1118 			}

  1119 		}

  1120 	}

  1121 

  1122 	EAP_TRACE_DEBUG(

  1123 		get_am_tools(),

  1124 		TRACE_FLAGS_DEFAULT,

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

  1126 		m_TunnelingTypePresent));

  1127 	if (m_TunnelingTypePresent == true)

  1128 	{

  1129 		EAP_TRACE_DEBUG(

  1130 			get_am_tools(),

  1131 			TRACE_FLAGS_DEFAULT,

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

  1133 			m_TunnelingType.get_vendor_id(),

  1134 			m_TunnelingType.get_vendor_type()));