1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  EAP and WLAN authentication protocols.

    15 *

    16 */

    17 

    18 /*

    19 * %version: 42 %

    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 40

    26 	#undef EAP_FILE_NUMBER_DATE

    27 	#define EAP_FILE_NUMBER_DATE 1127594498

    28 #endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

    29 

    30 

    31 #include "eap_am_memory.h"

    32 #include "eap_automatic_variable.h"

    33 #include "eap_process_tlv_message_data.h"

    34 #include "eap_variable_data.h"

    35 #include "eap_am_network_id.h"

    36 #include "eap_buffer.h"

    37 #include "eapol_session_key.h"

    38 #include "abs_eap_state_notification.h"

    39 #include "eap_state_notification.h"

    40 

    41 

    42 /** @file */

    43 

    44 

    45 //--------------------------------------------------

    46 

    47 EAP_FUNC_EXPORT eap_process_tlv_message_data_c::~eap_process_tlv_message_data_c()

    48 {

    49 }

    50 

    51 //--------------------------------------------------

    52 

    53 EAP_FUNC_EXPORT eap_process_tlv_message_data_c::eap_process_tlv_message_data_c(

    54 	abs_eap_am_tools_c * const tools)

    55 	: eap_tlv_message_data_c(tools)

    56 	, m_am_tools(tools)

    57 	, m_is_valid(true)

    58 {

    59 }

    60 

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

    62 

    63 /**

    64  * This function should increase reference count.

    65  */

    66 EAP_FUNC_EXPORT void eap_process_tlv_message_data_c::object_increase_reference_count()

    67 {

    68 }

    69 

    70 //-------------------------------------------------------------------

    71 

    72 /**

    73  * This function should first decrease reference count

    74  * and second return the remaining reference count.

    75  * Reference count must not be decreased when it is zero.

    76  */

    77 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::object_decrease_reference_count()

    78 {

    79 	return 0;

    80 }

    81 

    82 //--------------------------------------------------

    83 

    84 EAP_FUNC_EXPORT bool eap_process_tlv_message_data_c::get_is_valid()

    85 {

    86 	return m_is_valid && eap_tlv_message_data_c::get_is_valid();

    87 }

    88 

    89 //--------------------------------------------------

    90 

    91 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

    92 	const eap_variable_data_c * const data) const

    93 {

    94 	return

    95 		(eap_tlv_header_c::get_header_length() // Each attribute have their own header.

    96 		+ data->get_data_length());

    97 }

    98 

    99 //--------------------------------------------------

   100 

   101 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   102 	const eap_am_network_id_c * const network_id) const

   103 {

   104 	if (network_id == 0

   105 		|| network_id->get_is_valid_data() == false)

   106 	{

   107 		return 0ul;

   108 	}

   109 

   110 	return

   111 		(3ul * eap_tlv_header_c::get_header_length() // Each attribute have their own header.

   112 		+ network_id->get_source_id()->get_data_length()

   113 		+ network_id->get_destination_id()->get_data_length()

   114 		+ sizeof(network_id->get_type()));

   115 }

   116 

   117 //--------------------------------------------------

   118 

   119 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   120 	const abs_eap_state_notification_c * const state) const

   121 {

   122 	return

   123 		(7ul * eap_tlv_header_c::get_header_length()) // Each attribute have their own header.

   124 		+ (get_payload_size(state->get_send_network_id())

   125 		+ sizeof(u32_t) // eap_protocol_layer_e

   126 		+ sizeof(state->get_protocol())

   127 		+ eap_expanded_type_c::get_eap_expanded_type_size()

   128 		+ sizeof(state->get_current_state())

   129 		+ sizeof(u32_t) // bool is_client

   130 		+ sizeof(u32_t) // eap_status_e authentication error

   131 		);

   132 }

   133 

   134 //--------------------------------------------------

   135 

   136 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   137 	const eapol_session_key_c * const session_key) const

   138 {

   139 	return

   140 		((5ul * eap_tlv_header_c::get_header_length()) // Each attribute have their own header.

   141 		+ session_key->get_key()->get_data_length()

   142 		+ session_key->get_sequence_number()->get_data_length()

   143 		+ sizeof(u32_t) // const eapol_key_type_e m_key_type

   144 		+ sizeof(session_key->get_key_index())

   145 		+ sizeof(u32_t) // const bool m_key_tx_bit

   146 		);

   147 }

   148 

   149 //--------------------------------------------------

   150 

   151 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   152 	EAP_TEMPLATE_CONST eap_array_c<u16_t> * const ushort_array) const

   153 {

   154 	u32_t size(0ul);

   155 

   156 	for (u32_t ind = 0ul; ind < ushort_array->get_object_count(); ind++)

   157 	{

   158 		u16_t * const value = ushort_array->get_object(ind);

   159 		if (value != 0)

   160 		{

   161 			size += eap_tlv_header_c::get_header_length() // TLV-header of u16_t.

   162 				+ sizeof(u16_t); // Size of u16_t

   163 		}

   164 	} // for ()

   165 

   166 	return (size);

   167 }

   168 

   169 //--------------------------------------------------

   170 

   171 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   172 	const eap_certificate_entry_c * const cert) const

   173 {

   174 	u32_t size =

   175 		(10ul * eap_tlv_header_c::get_header_length() // Each attribute have their own header.

   176 		+ sizeof(u32_t) // eap_certificate_type_e m_CertType

   177 		+ sizeof(u32_t) // bool m_SubjectNamePresent

   178 		+ sizeof(u32_t) // bool m_IssuerNamePresent

   179 		+ sizeof(u32_t) // bool m_SerialNumberPresent

   180 		+ sizeof(u32_t) // bool m_SubjectKeyIDPresent

   181 		+ sizeof(u32_t) // bool m_ThumbprintPresent

   182 		+ sizeof(u32_t) // bool m_LabelPresent

   183 		+ sizeof(u32_t) // bool m_PrimaryNamePresent

   184 		+ sizeof(u32_t) // bool m_SecondaryNamePresent

   185 		+ sizeof(u32_t) // bool m_iIsEnabledPresent

   186 		);

   187 

   188 	if (cert->m_SubjectNamePresent == true)

   189 	{

   190 		size += get_payload_size(&(cert->m_SubjectName));

   191 	}

   192 

   193 	if (cert->m_IssuerNamePresent == true)

   194 	{

   195 		size += get_payload_size(&(cert->m_IssuerName));

   196 	}

   197 

   198 	if (cert->m_SerialNumberPresent == true)

   199 	{

   200 		size += get_payload_size(&(cert->m_SerialNumber));

   201 	}

   202 

   203 	if (cert->m_SubjectKeyIDPresent == true)

   204 	{

   205 		size += get_payload_size(&(cert->m_SubjectKeyID));

   206 	}

   207 

   208 	if (cert->m_ThumbprintPresent == true)

   209 	{

   210 		size += get_payload_size(&(cert->m_Thumbprint));

   211 	}

   212 

   213 	if (cert->m_LabelPresent == true)

   214 	{

   215 		size += get_payload_size(&(cert->m_Label));

   216 	}

   217 

   218 	if (cert->m_PrimaryNamePresent == true)

   219 	{

   220 		size += get_payload_size(&(cert->m_PrimaryName));

   221 	}

   222 

   223 	if (cert->m_SecondaryNamePresent == true)

   224 	{

   225 		size += get_payload_size(&(cert->m_SecondaryName));

   226 	}

   227 

   228 	if (cert->m_iIsEnabledPresent == true)

   229 	{

   230 		size += eap_tlv_header_c::get_header_length();

   231 		size += sizeof(u32_t); // bool m_iIsEnabled

   232 	}

   233 

   234 	return size;

   235 }

   236 

   237 //--------------------------------------------------

   238 

   239 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   240 	const eap_method_settings_c * const internal_settings) const

   241 {

   242 	u32_t size =

   243 		(4ul * eap_tlv_header_c::get_header_length() // Each attribute have their own header.

   244 		+ sizeof(u32_t) // eap_status_e m_completion_status

   245 		+ eap_expanded_type_c::get_eap_expanded_type_size() // eap_type_value_e m_EAPType

   246 		+ sizeof(u32_t) // u32_t m_IndexType

   247 		+ sizeof(u32_t) // u32_t m_Index

   248 		);

   249 

   250 	size += eap_tlv_header_c::get_header_length();

   251 	size += sizeof(u32_t); // bool m_UseAutomaticCACertificatePresent

   252 	if (internal_settings->m_UseAutomaticCACertificatePresent == true)

   253 	{

   254 		size += eap_tlv_header_c::get_header_length();

   255 		size += sizeof(u32_t); // bool m_UseAutomaticCACertificate

   256 	}

   257 

   258 	size += eap_tlv_header_c::get_header_length();

   259 	size += sizeof(u32_t); // bool m_UseAutomaticUsernamePresent

   260 	if (internal_settings->m_UseAutomaticUsernamePresent == true)

   261 	{

   262 		size += eap_tlv_header_c::get_header_length();

   263 		size += sizeof(u32_t); // bool m_UseAutomaticUsername

   264 	}

   265 

   266 	size += eap_tlv_header_c::get_header_length();

   267 	size += sizeof(u32_t); // bool m_UseAutomaticRealmPresent

   268 	if (internal_settings->m_UseAutomaticRealmPresent == true)

   269 	{

   270 		size += eap_tlv_header_c::get_header_length();

   271 		size += sizeof(u32_t); // bool m_UseAutomaticRealm

   272 	}

   273 

   274 	size += eap_tlv_header_c::get_header_length();

   275 	size += sizeof(u32_t); // bool m_UsernamePresent

   276 	if (internal_settings->m_UsernamePresent == true)

   277 	{

   278 		size += get_payload_size(&(internal_settings->m_Username_fix));

   279 	}

   280 

   281 	size += eap_tlv_header_c::get_header_length();

   282 	size += sizeof(u32_t); // bool m_PasswordExistPresent

   283 	if (internal_settings->m_PasswordExistPresent == true)

   284 	{

   285 		size += eap_tlv_header_c::get_header_length();

   286 		size += sizeof(u32_t); // bool m_PasswordExist

   287 	}

   288 

   289 	size += eap_tlv_header_c::get_header_length();

   290 	size += sizeof(u32_t); // bool m_PasswordPresent

   291 	if (internal_settings->m_PasswordPresent == true)

   292 	{

   293 		size += get_payload_size(&(internal_settings->m_Password));

   294 	}

   295 

   296 	size += eap_tlv_header_c::get_header_length();

   297 	size += sizeof(u32_t); // bool m_RealmPresent

   298 	if (internal_settings->m_RealmPresent == true)

   299 	{

   300 		size += get_payload_size(&(internal_settings->m_Realm));

   301 	}

   302 

   303 	size += eap_tlv_header_c::get_header_length();

   304 	size += sizeof(u32_t); // bool m_UsePseudonymsPresent

   305 	if (internal_settings->m_UsePseudonymsPresent == true)

   306 	{

   307 		size += eap_tlv_header_c::get_header_length();

   308 		size += sizeof(u32_t); // bool m_UsePseudonyms

   309 	}

   310 

   311 	size += eap_tlv_header_c::get_header_length();

   312 	size += sizeof(u32_t); // bool m_VerifyServerRealmPresent

   313 	if (internal_settings->m_VerifyServerRealmPresent == true)

   314 	{

   315 		size += eap_tlv_header_c::get_header_length();

   316 		size += sizeof(u32_t); // bool m_VerifyServerRealm

   317 	}

   318 

   319 	size += eap_tlv_header_c::get_header_length();

   320 	size += sizeof(u32_t); // bool m_RequireClientAuthenticationPresent

   321 	if (internal_settings->m_RequireClientAuthenticationPresent == true)

   322 	{

   323 		size += eap_tlv_header_c::get_header_length();

   324 		size += sizeof(u32_t); // bool m_RequireClientAuthentication

   325 	}

   326 

   327 	size += eap_tlv_header_c::get_header_length();

   328 	size += sizeof(u32_t); // bool m_SessionValidityTimePresent

   329 	if (internal_settings->m_SessionValidityTimePresent == true)

   330 	{

   331 		size += eap_tlv_header_c::get_header_length();

   332 		size += sizeof(u32_t); // u32_t m_SessionValidityTime

   333 	}

   334 

   335 	size += eap_tlv_header_c::get_header_length();

   336 	size += sizeof(u32_t); // bool m_CipherSuitesPresent

   337 	if (internal_settings->m_CipherSuitesPresent == true)

   338 	{

   339 		// Array header.

   340 		size += eap_tlv_header_c::get_header_length();

   341 		size += get_payload_size(&(internal_settings->m_CipherSuites));

   342 	}

   343 

   344 	size += eap_tlv_header_c::get_header_length();

   345 	size += sizeof(u32_t); // bool m_PEAPVersionsPresent

   346 	if (internal_settings->m_PEAPVersionsPresent == true)

   347 	{

   348 		size += (3ul * eap_tlv_header_c::get_header_length());

   349 		size += sizeof(u32_t); // bool m_PEAPv0Allowed

   350 		size += sizeof(u32_t); // bool m_PEAPv1Allowed

   351 		size += sizeof(u32_t); // bool m_PEAPv2Allowed

   352 	}

   353 

   354 	size += eap_tlv_header_c::get_header_length();

   355 	size += sizeof(u32_t); // bool m_CertificatesPresent

   356 	if (internal_settings->m_CertificatesPresent == true)

   357 	{

   358 		// Array header.

   359 		size += eap_tlv_header_c::get_header_length();

   360 		size += get_payload_size(&(internal_settings->m_Certificates));

   361 	}

   362 

   363 	size += eap_tlv_header_c::get_header_length();

   364 	size += sizeof(u32_t); // bool m_EnabledEncapsulatedEAPTypesPresent

   365 	if (internal_settings->m_EnabledEncapsulatedEAPTypesPresent == true)

   366 	{

   367 		// Array header.

   368 		size += eap_tlv_header_c::get_header_length();

   369 		size += get_payload_size(&(internal_settings->m_EnabledEncapsulatedEAPTypes));

   370 	}

   371 

   372 	size += eap_tlv_header_c::get_header_length();

   373 	size += sizeof(u32_t); // bool m_DisabledEncapsulatedEAPTypesPresent

   374 	if (internal_settings->m_DisabledEncapsulatedEAPTypesPresent == true)

   375 	{

   376 		// Array header.

   377 		size += eap_tlv_header_c::get_header_length();

   378 		size += get_payload_size(&(internal_settings->m_DisabledEncapsulatedEAPTypes));

   379 	}

   380 

   381 	size += eap_tlv_header_c::get_header_length();

   382 	size += sizeof(u32_t); // bool m_AuthProvModeAllowedPresent

   383 	if (internal_settings->m_AuthProvModeAllowedPresent == true)

   384 	{

   385 		size += eap_tlv_header_c::get_header_length();

   386 		size += sizeof(u32_t); // bool m_AuthProvModeAllowed

   387 	}

   388 

   389 	size += eap_tlv_header_c::get_header_length();

   390 	size += sizeof(u32_t); // bool m_UnauthProvModeAllowedPresent

   391 	if (internal_settings->m_UnauthProvModeAllowedPresent == true)

   392 	{

   393 		size += eap_tlv_header_c::get_header_length();

   394 		size += sizeof(u32_t); // bool m_UnauthProvModeAllowed

   395 	}

   396 

   397 	size += eap_tlv_header_c::get_header_length();

   398 	size += sizeof(u32_t); // bool m_PACGroupReferencePresent

   399 	if (internal_settings->m_PACGroupReferencePresent == true)

   400 	{

   401 		size += get_payload_size(&(internal_settings->m_PACGroupReference));

   402 	}

   403 

   404 	size += eap_tlv_header_c::get_header_length();

   405 	size += sizeof(u32_t); // bool m_WarnADHPNoPACPresent

   406 	if (internal_settings->m_WarnADHPNoPACPresent == true)

   407 	{

   408 		size += eap_tlv_header_c::get_header_length();

   409 		size += sizeof(u32_t); // bool m_WarnADHPNoPAC

   410 	}

   411 

   412 	size += eap_tlv_header_c::get_header_length();

   413 	size += sizeof(u32_t); // bool m_WarnADHPNoMatchingPACPresent

   414 	if (internal_settings->m_WarnADHPNoMatchingPACPresent == true)

   415 	{

   416 		size += eap_tlv_header_c::get_header_length();

   417 		size += sizeof(u32_t); // bool m_WarnADHPNoMatchingPAC

   418 	}

   419 

   420 	size += eap_tlv_header_c::get_header_length();

   421 	size += sizeof(u32_t); // bool m_WarnNotDefaultServerPresent

   422 	if (internal_settings->m_WarnNotDefaultServerPresent == true)

   423 	{

   424 		size += eap_tlv_header_c::get_header_length();

   425 		size += sizeof(u32_t); // bool m_WarnNotDefaultServer

   426 	}

   427 

   428 	size += eap_tlv_header_c::get_header_length();

   429 	size += sizeof(u32_t); // bool m_SelectedEAPTypesPresent

   430 	if (internal_settings->m_SelectedEAPTypesPresent == true)

   431 	{

   432 		// Array header.

   433 		size += eap_tlv_header_c::get_header_length();

   434 		size += get_payload_size(&(internal_settings->m_active_eap_methods));

   435 

   436 		// Array header.

   437 		size += eap_tlv_header_c::get_header_length();

   438 		size += get_payload_size(&(internal_settings->m_disabled_eap_methods));

   439 	}

   440 

   441 	size += eap_tlv_header_c::get_header_length();

   442 	size += sizeof(u32_t); // bool m_TunnelingTypePresent

   443 	if (internal_settings->m_TunnelingTypePresent == true)

   444 	{

   445 		size += eap_tlv_header_c::get_header_length();

   446 		size += eap_expanded_type_c::get_eap_expanded_type_size(); // eap_type_value_e m_TunnelingType

   447 	}

   448 

   449 	size += eap_tlv_header_c::get_header_length();

   450 	size += sizeof(u32_t); // bool m_DestinationIndexAndTypePresent

   451 	if (internal_settings->m_DestinationIndexAndTypePresent == true)

   452 	{

   453 		size += (2ul * eap_tlv_header_c::get_header_length());

   454 		size += sizeof(u32_t); // u32_t m_DestinationIndexType

   455 		size += sizeof(u32_t); // u32_t m_DestinationIndex

   456 	}

   457 

   458 	size += eap_tlv_header_c::get_header_length();

   459 	size += sizeof(u32_t); // bool m_MethodInfoPresent

   460 	if (internal_settings->m_MethodInfoPresent == true)

   461 	{

   462 		size += get_payload_size(&(internal_settings->m_KReleaseDate));

   463 		size += get_payload_size(&(internal_settings->m_KEapTypeVersion));

   464 		size += get_payload_size(&(internal_settings->m_KManufacturer));

   465 	}

   466 

   467 	size += eap_tlv_header_c::get_header_length();

   468 	size += sizeof(u32_t); // bool m_ButtonIdPresent

   469 	if (internal_settings->m_ButtonIdPresent == true)

   470 	{

   471 		size += eap_tlv_header_c::get_header_length();

   472 		size += sizeof(u32_t); // i32_t m_ButtonId

   473 	}

   474 

   475 	size += eap_tlv_header_c::get_header_length();

   476 	size += sizeof(u32_t); // bool m_ShowPassWordPromptPresent

   477 	if (internal_settings->m_ShowPassWordPromptPresent == true)

   478 	{

   479 		size += eap_tlv_header_c::get_header_length();

   480 		size += sizeof(u32_t); // bool m_ShowPassWordPrompt));

   481 	}

   482 

   483 	size += eap_tlv_header_c::get_header_length();

   484 	size += sizeof(u32_t); // bool m_UseIdentityPrivacyPresent

   485 	if (internal_settings->m_UseIdentityPrivacyPresent == true)

   486 	{

   487 		size += eap_tlv_header_c::get_header_length();

   488 		size += sizeof(u32_t); // bool m_UseIdentityPrivacy));

   489 	}

   490 

   491 	return size;

   492 }

   493 

   494 //--------------------------------------------------

   495 

   496 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   497 	EAP_TEMPLATE_CONST eap_array_c<eap_certificate_entry_c> * const cert_array) const

   498 {

   499 	u32_t size(0ul);

   500 

   501 	for (u32_t ind = 0ul; ind < cert_array->get_object_count(); ind++)

   502 	{

   503 		eap_certificate_entry_c * const value = cert_array->get_object(ind);

   504 		if (value != 0)

   505 		{

   506 			// Structure header.

   507 			size += eap_tlv_header_c::get_header_length();

   508 

   509 			size += get_payload_size(value);

   510 		}

   511 	} // for ()

   512 

   513 	return (size);

   514 }

   515 

   516 //--------------------------------------------------

   517 

   518 #if defined(USE_EAP_SIMPLE_CONFIG)

   519 

   520 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   521 	const network_key_and_index_c * const key) const

   522 {

   523 	u32_t size(0ul);

   524 

   525 	if (key != 0)

   526 	{

   527 		size += eap_tlv_header_c::get_header_length()

   528 			+ sizeof(key->get_network_key_index()) // Size of Network Key Index

   529 			+ eap_tlv_header_c::get_header_length()

   530 			+ key->get_network_key_const()->get_data_length() // Size of Network Key

   531 			;

   532 	}

   533 

   534 	return (size);

   535 }

   536 

   537 #endif // #if defined(USE_EAP_SIMPLE_CONFIG)

   538 

   539 //--------------------------------------------------

   540 

   541 #if defined(USE_EAP_SIMPLE_CONFIG)

   542 

   543 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   544 	const eap_array_c<network_key_and_index_c> * const network_keys) const

   545 {

   546 	u32_t size(0ul);

   547 

   548 	for (u32_t ind_network_key = 0ul; ind_network_key < network_keys->get_object_count(); ind_network_key++)

   549 	{

   550 		network_key_and_index_c * const key = network_keys->get_object(ind_network_key);

   551 		if (key != 0)

   552 		{

   553 			size += eap_tlv_header_c::get_header_length() // Size of structure header

   554 				+ get_payload_size(key); // Size of Network Key

   555 		}

   556 	} // for ()

   557 

   558 	return (size);

   559 }

   560 

   561 #endif // #if defined(USE_EAP_SIMPLE_CONFIG)

   562 

   563 //--------------------------------------------------

   564 

   565 #if defined(USE_EAP_SIMPLE_CONFIG)

   566 

   567 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   568 	const simple_config_credential_c * const credential) const

   569 {

   570 	u32_t size(0ul);

   571 

   572 	if (credential != 0)

   573 	{

   574 		size += eap_tlv_header_c::get_header_length()

   575 			+ sizeof(credential->get_network_index()) // Size of Network Index

   576 			+ eap_tlv_header_c::get_header_length()

   577 			+ credential->get_SSID_const()->get_data_length() // Size of SSID

   578 			+ eap_tlv_header_c::get_header_length()

   579 			+ sizeof(u16_t) // Size of Authentiction type

   580 			+ eap_tlv_header_c::get_header_length()

   581 			+ sizeof(u16_t) // Size of Encryption type

   582 			;

   583 

   584 		size += eap_tlv_header_c::get_header_length() // Size of header of Array

   585 			+ get_payload_size(credential->get_network_keys_const());

   586 

   587 		size += eap_tlv_header_c::get_header_length()

   588 			+ credential->get_MAC_address_const()->get_data_length() // Size of MAC Address

   589 			;

   590 	}

   591 

   592 	return (size);

   593 }

   594 

   595 #endif // #if defined(USE_EAP_SIMPLE_CONFIG)

   596 

   597 //--------------------------------------------------

   598 

   599 #if defined(USE_EAP_SIMPLE_CONFIG)

   600 

   601 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   602 	EAP_TEMPLATE_CONST eap_array_c<simple_config_credential_c> * const credential_array) const

   603 {

   604 	u32_t size(0ul);

   605 

   606 	for (u32_t ind_credential = 0ul; ind_credential < credential_array->get_object_count(); ind_credential++)

   607 	{

   608 		simple_config_credential_c * const credential = credential_array->get_object(ind_credential);

   609 		if (credential != 0)

   610 		{

   611 			size += eap_tlv_header_c::get_header_length() // Size of structure header

   612 				+ get_payload_size(credential);

   613 		}

   614 	} // for ()

   615 

   616 	return (size);

   617 }

   618 

   619 #endif // #if defined(USE_EAP_SIMPLE_CONFIG)

   620 

   621 //--------------------------------------------------

   622 

   623 EAP_FUNC_EXPORT u32_t eap_process_tlv_message_data_c::get_payload_size(

   624 	const eap_variable_data_c * const selector,

   625 	const eap_config_value_c * const configuration_option) const

   626 {

   627 	u32_t size_of_data(0ul);

   628 

   629 	EAP_TRACE_DEBUG(

   630 		m_am_tools,

   631 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   632 		(EAPL("eap_process_tlv_message_data_c::get_payload_size(): type=%d=%s\n"),

   633 		configuration_option->get_const_type(),

   634 		eap_configuration_field_c::get_configure_type_string(configuration_option->get_const_type())));

   635 

   636 	switch(configuration_option->get_const_type())

   637 	{

   638 	case eap_configure_type_string:

   639 	case eap_configure_type_hex_data:

   640 		size_of_data += 3ul * eap_tlv_header_c::get_header_length()

   641 			+ sizeof(u32_t) // Length of the type.

   642 			+ selector->get_data_length() // Length of the option name.

   643 			+ configuration_option->get_const_data()->get_data_length(); // Length of the option data.

   644 		break;

   645 	case eap_configure_type_u32_t:

   646 	case eap_configure_type_boolean:

   647 		size_of_data += 3ul * eap_tlv_header_c::get_header_length()

   648 			+ sizeof(u32_t) // Length of the type.

   649 			+ selector->get_data_length() // Length of the option name.

   650 			+ sizeof(u32_t); // Length of the option data.

   651 		break;

   652 	case eap_configure_type_u32array:

   653 		{

   654 			const u32_t count_of_values = configuration_option->get_const_data()->get_data_length() / sizeof(u32_t);

   655 			size_of_data += 3ul * eap_tlv_header_c::get_header_length()

   656 				+ sizeof(u32_t) // Length of the type.

   657 				+ selector->get_data_length() // Length of the option name.

   658 				+ count_of_values*(eap_tlv_header_c::get_header_length()+sizeof(u32_t)); // Length of the option data.

   659 		}

   660 		break;

   661 	case eap_configure_type_subsection:

   662 		// No size.

   663 		break;

   664 	default:

   665 		EAP_TRACE_DEBUG(

   666 			m_am_tools,

   667 			EAP_TRACE_FLAGS_MESSAGE_DATA,

   668 			(EAPL("ERROR: eap_process_tlv_message_data_c::get_payload_size(): Unknown type=%d=%s\n"),

   669 			configuration_option->get_const_type(),

   670 			eap_configuration_field_c::get_configure_type_string(configuration_option->get_const_type())));

   671 		break;

   672 	};

   673 

   674 	return (size_of_data);

   675 }

   676 

   677 //--------------------------------------------------

   678 

   679 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_structured_parameter_header(

   680 	const eap_tlv_message_type_e type,

   681 	const u32_t length)

   682 {

   683 	EAP_TRACE_DEBUG(

   684 		m_am_tools,

   685 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   686 		(EAPL("eap_process_tlv_message_data_c::add_structured_parameter_header(): type=%d=%s\n"),

   687 		type,

   688 		 get_type_string(type)));

   689 

   690 	return add_message_header(

   691 		type,

   692 		length);

   693 }

   694 

   695 //--------------------------------------------------

   696 

   697 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   698 	const eap_tlv_message_type_e type,

   699 	const u32_t integer)

   700 {

   701 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   702 

   703 	EAP_TRACE_DEBUG(

   704 		m_am_tools,

   705 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   706 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   707 		type,

   708 		 get_type_string(type)));

   709 

   710 	const u32_t network_order_integer(eap_htonl(integer));

   711 

   712 	eap_status_e status = add_message_data(

   713 		type,

   714 		sizeof(network_order_integer),

   715 		&network_order_integer);

   716 

   717 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   718 	return EAP_STATUS_RETURN(m_am_tools, status);

   719 }

   720 

   721 //--------------------------------------------------

   722 

   723 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   724 	const u64_t long_integer)

   725 {

   726 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   727 

   728 	EAP_TRACE_DEBUG(

   729 		m_am_tools,

   730 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   731 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   732 		eap_tlv_message_type_u64_t,

   733 		 get_type_string(eap_tlv_message_type_u64_t)));

   734 

   735 	const u64_t network_order_long_integer(eap_htonll(long_integer));

   736 

   737 	eap_status_e status = add_message_data(

   738 		eap_tlv_message_type_u64_t,

   739 		sizeof(network_order_long_integer),

   740 		&network_order_long_integer);

   741 

   742 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   743 	return EAP_STATUS_RETURN(m_am_tools, status);

   744 }

   745 

   746 //--------------------------------------------------

   747 

   748 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   749 	const u32_t integer)

   750 {

   751 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   752 

   753 	EAP_TRACE_DEBUG(

   754 		m_am_tools,

   755 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   756 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   757 		eap_tlv_message_type_u32_t,

   758 		 get_type_string(eap_tlv_message_type_u32_t)));

   759 

   760 	const u32_t network_order_integer(eap_htonl(integer));

   761 

   762 	eap_status_e status = add_message_data(

   763 		eap_tlv_message_type_u32_t,

   764 		sizeof(network_order_integer),

   765 		&network_order_integer);

   766 

   767 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   768 	return EAP_STATUS_RETURN(m_am_tools, status);

   769 }

   770 

   771 //--------------------------------------------------

   772 

   773 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   774 	const u16_t short_integer)

   775 {

   776 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   777 

   778 	EAP_TRACE_DEBUG(

   779 		m_am_tools,

   780 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   781 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   782 		eap_tlv_message_type_u16_t,

   783 		 get_type_string(eap_tlv_message_type_u16_t)));

   784 

   785 	const u16_t network_order_short_integer(eap_htons(short_integer));

   786 

   787 	eap_status_e status = add_message_data(

   788 		eap_tlv_message_type_u16_t,

   789 		sizeof(network_order_short_integer),

   790 		&network_order_short_integer);

   791 

   792 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   793 	return EAP_STATUS_RETURN(m_am_tools, status);

   794 }

   795 

   796 //--------------------------------------------------

   797 

   798 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   799 	const u8_t byte_integer)

   800 {

   801 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   802 

   803 	EAP_TRACE_DEBUG(

   804 		m_am_tools,

   805 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   806 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   807 		eap_tlv_message_type_u8_t,

   808 		 get_type_string(eap_tlv_message_type_u8_t)));

   809 

   810 	eap_status_e status = add_message_data(

   811 		eap_tlv_message_type_u8_t,

   812 		sizeof(byte_integer),

   813 		&byte_integer);

   814 

   815 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   816 	return EAP_STATUS_RETURN(m_am_tools, status);

   817 }

   818 

   819 //--------------------------------------------------

   820 

   821 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   822 	const i32_t integer)

   823 {

   824 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   825 

   826 	EAP_TRACE_DEBUG(

   827 		m_am_tools,

   828 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   829 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   830 		eap_tlv_message_type_i32_t,

   831 		 get_type_string(eap_tlv_message_type_i32_t)));

   832 

   833 	const i32_t network_order_integer(eap_htonl(integer));

   834 

   835 	eap_status_e status = add_message_data(

   836 		eap_tlv_message_type_i32_t,

   837 		sizeof(network_order_integer),

   838 		&network_order_integer);

   839 

   840 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   841 	return EAP_STATUS_RETURN(m_am_tools, status);

   842 }

   843 

   844 //--------------------------------------------------

   845 

   846 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   847 	const i16_t integer)

   848 {

   849 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   850 

   851 	EAP_TRACE_DEBUG(

   852 		m_am_tools,

   853 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   854 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   855 		eap_tlv_message_type_i16_t,

   856 		 get_type_string(eap_tlv_message_type_i16_t)));

   857 

   858 	const i16_t network_order_short_integer(eap_htons(integer));

   859 

   860 	eap_status_e status = add_message_data(

   861 		eap_tlv_message_type_i16_t,

   862 		sizeof(network_order_short_integer),

   863 		&network_order_short_integer);

   864 

   865 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   866 	return EAP_STATUS_RETURN(m_am_tools, status);

   867 }

   868 

   869 //--------------------------------------------------

   870 

   871 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   872 	const i8_t byte_integer)

   873 {

   874 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   875 

   876 	EAP_TRACE_DEBUG(

   877 		m_am_tools,

   878 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   879 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   880 		eap_tlv_message_type_i8_t,

   881 		 get_type_string(eap_tlv_message_type_i8_t)));

   882 

   883 	eap_status_e status = add_message_data(

   884 		eap_tlv_message_type_i8_t,

   885 		sizeof(byte_integer),

   886 		&byte_integer);

   887 

   888 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   889 	return EAP_STATUS_RETURN(m_am_tools, status);

   890 }

   891 

   892 //--------------------------------------------------

   893 

   894 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   895 	const bool boolean)

   896 {

   897 	const u32_t value((boolean == false) ? 0u: 1u);

   898 

   899 	return add_parameter_data(

   900 		eap_tlv_message_type_boolean,

   901 		value);

   902 }

   903 

   904 //--------------------------------------------------

   905 

   906 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   907 	const eap_status_e status)

   908 {

   909 	const u32_t value(static_cast<u32_t>(status));

   910 

   911 	return add_parameter_data(

   912 		eap_tlv_message_type_eap_status,

   913 		value);

   914 }

   915 

   916 //--------------------------------------------------

   917 

   918 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   919 	const eapol_key_authentication_type_e authentication_type)

   920 {

   921 	const u32_t value(static_cast<u32_t>(authentication_type));

   922 

   923 	return add_parameter_data(

   924 		eap_tlv_message_type_eapol_key_authentication_type,

   925 		value);

   926 }

   927 

   928 //--------------------------------------------------

   929 

   930 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   931 	const eapol_key_802_11_authentication_mode_e mode)

   932 {

   933 	const u32_t value(static_cast<u32_t>(mode));

   934 

   935 	return add_parameter_data(

   936 		eap_tlv_message_type_eapol_key_802_11_authentication_mode,

   937 		value);

   938 }

   939 

   940 //--------------------------------------------------

   941 

   942 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   943 	const eap_tlv_message_type_function_e function)

   944 {

   945 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   946 

   947 	EAP_TRACE_DEBUG(

   948 		m_am_tools,

   949 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   950 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s, function=%s\n"),

   951 		eap_tlv_message_type_function,

   952 		 get_type_string(eap_tlv_message_type_function),

   953 		 get_function_string(function)));

   954 

   955 	if (function < eap_tlv_message_type_function_none

   956 		|| function >= eap_tlv_message_type_function_illegal_value)

   957 	{

   958 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   959 		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

   960 	}

   961 

   962 	const u32_t network_order_function(eap_htonl(function));

   963 

   964 	eap_status_e status = add_message_data(

   965 		eap_tlv_message_type_function,

   966 		sizeof(network_order_function),

   967 		&network_order_function);

   968 

   969 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   970 	return EAP_STATUS_RETURN(m_am_tools, status);

   971 }

   972 

   973 //--------------------------------------------------

   974 

   975 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

   976 	const eap_variable_data_c * const variable_data)

   977 {

   978 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   979 

   980 	EAP_TRACE_DEBUG(

   981 		m_am_tools,

   982 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   983 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

   984 		eap_tlv_message_type_variable_data,

   985 		 get_type_string(eap_tlv_message_type_variable_data)));

   986 

   987 	if (variable_data == 0)

   988 	{

   989 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   990 		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

   991 	}

   992 

   993 	eap_status_e status(eap_status_process_general_error);

   994 

   995 	if (variable_data->get_is_valid_data() == false)

   996 	{

   997 		// Empty variable data. Add just the header.

   998 		status = add_structured_parameter_header(

   999 			eap_tlv_message_type_variable_data,

  1000 			0ul);

  1001 	}

  1002 	else

  1003 	{

  1004 		status = add_message_data(

  1005 			eap_tlv_message_type_variable_data,

  1006 			variable_data->get_data_length(),

  1007 			variable_data->get_data());

  1008 	}

  1009 

  1010 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1011 	return EAP_STATUS_RETURN(m_am_tools, status);

  1012 }

  1013 

  1014 //--------------------------------------------------

  1015 

  1016 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

  1017 	const eap_am_network_id_c * const network_id)

  1018 {

  1019 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1020 

  1021 	EAP_TRACE_DEBUG(

  1022 		m_am_tools,

  1023 		EAP_TRACE_FLAGS_MESSAGE_DATA,

  1024 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

  1025 		eap_tlv_message_type_network_id,

  1026 		 get_type_string(eap_tlv_message_type_network_id)));

  1027 

  1028 	if (network_id == 0

  1029 		|| network_id->get_is_valid() == false)

  1030 	{

  1031 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1032 		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

  1033 	}

  1034 

  1035 	const u32_t size_of_network_id = get_payload_size(network_id);

  1036 

  1037 	eap_status_e status = add_structured_parameter_header(

  1038 		eap_tlv_message_type_network_id,

  1039 		size_of_network_id);

  1040 	if (status != eap_status_ok)

  1041 	{

  1042 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1043 		return EAP_STATUS_RETURN(m_am_tools, status);

  1044 	}

  1045 

  1046 	status = add_parameter_data(

  1047 		network_id->get_source_id());

  1048 	if (status != eap_status_ok)

  1049 	{

  1050 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1051 		return EAP_STATUS_RETURN(m_am_tools, status);

  1052 	}

  1053 

  1054 	status = add_parameter_data(

  1055 		network_id->get_destination_id());

  1056 	if (status != eap_status_ok)

  1057 	{

  1058 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1059 		return EAP_STATUS_RETURN(m_am_tools, status);

  1060 	}

  1061 

  1062 	status = add_parameter_data(

  1063 		network_id->get_type());

  1064 	if (status != eap_status_ok)

  1065 	{

  1066 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1067 		return EAP_STATUS_RETURN(m_am_tools, status);

  1068 	}

  1069 

  1070 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1071 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

  1072 }

  1073 

  1074 //--------------------------------------------------

  1075 

  1076 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

  1077 	const eap_buf_chain_wr_c * const packet_buffer)

  1078 {

  1079 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1080 

  1081 	EAP_TRACE_DEBUG(

  1082 		m_am_tools,

  1083 		EAP_TRACE_FLAGS_MESSAGE_DATA,

  1084 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

  1085 		eap_tlv_message_type_variable_data,

  1086 		 get_type_string(eap_tlv_message_type_variable_data)));

  1087 

  1088 	if (packet_buffer == 0

  1089 		|| packet_buffer->get_is_valid() == false)

  1090 	{

  1091 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1092 		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

  1093 	}

  1094 

  1095 	eap_status_e status = add_message_data(

  1096 		eap_tlv_message_type_variable_data,

  1097 		packet_buffer->get_data_length(),

  1098 		packet_buffer->get_data(packet_buffer->get_data_length()));

  1099 

  1100 

  1101 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1102 	return EAP_STATUS_RETURN(m_am_tools, status);

  1103 }

  1104 

  1105 //--------------------------------------------------

  1106 

  1107 EAP_FUNC_EXPORT eap_status_e eap_process_tlv_message_data_c::add_parameter_data(

  1108 	const eapol_session_key_c * const session_key)

  1109 {

  1110 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1111 

  1112 	EAP_TRACE_DEBUG(

  1113 		m_am_tools,

  1114 		EAP_TRACE_FLAGS_MESSAGE_DATA,

  1115 		(EAPL("eap_process_tlv_message_data_c::add_parameter_data(): type=%d=%s\n"),

  1116 		eap_tlv_message_type_session_key,

  1117 		 get_type_string(eap_tlv_message_type_session_key)));

  1118 

  1119 	if (session_key == 0

  1120 		|| session_key->get_is_valid() == false)

  1121 	{

  1122 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1123 		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

  1124 	}

  1125 

  1126 	const u32_t size_of_session_key(get_payload_size(session_key));

  1127 

  1128 	eap_status_e status = add_structured_parameter_header(

  1129 		eap_tlv_message_type_session_key,

  1130 		size_of_session_key);

  1131 	if (status != eap_status_ok)

  1132 	{

  1133 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1134 		return EAP_STATUS_RETURN(m_am_tools, status);