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

    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 48 

    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 

    32 #include "eap_am_memory.h"

    33 #include "eap_tools.h"

    34 #include "eap_core_server_message_if.h"

    35 #include "eap_crypto_api.h"

    36 #include "eap_state_notification.h"

    37 #include "eap_automatic_variable.h"

    38 #include "eap_network_id_selector.h"

    39 #include "eap_config.h"

    40 #include "eap_buffer.h"

    41 #include "eapol_session_key.h"

    42 #include "eap_master_session_key.h"

    43 #include "eap_am_stack.h"

    44 

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

    46 

    47 // 

    48 EAP_FUNC_EXPORT eap_core_server_message_if_c::~eap_core_server_message_if_c()

    49 {

    50 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

    51 

    52 	EAP_TRACE_DEBUG(

    53 		m_am_tools, 

    54 		EAP_TRACE_FLAGS_MESSAGE_DATA, 

    55 		(EAPL("eap_core_server_message_if_c::~eap_core_server_message_if_c(): this = 0x%08x\n"),

    56 		this));

    57 

    58 	EAP_ASSERT(m_shutdown_was_called == true);

    59 

    60 	delete m_eap_core;

    61 	delete m_am_stack;

    62 

    63 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

    64 }

    65 

    66 //--------------------------------------------------

    67 

    68 #if defined(_WIN32) && !defined(__GNUC__)

    69 	#pragma warning( disable : 4355 ) // 'this' : used in base member initializer list

    70 #endif

    71 

    72 // 

    73 EAP_FUNC_EXPORT eap_core_server_message_if_c::eap_core_server_message_if_c(

    74 	abs_eap_am_tools_c * const tools,

    75 	const bool is_client_when_true,

    76 	const u32_t MTU)

    77 	: m_partner(0)

    78 	, m_eap_core(eap_session_core_base_c::new_eap_session_core_c(tools, this, is_client_when_true, MTU))

    79 	, m_am_stack(new_eap_am_stack_c(tools, is_client_when_true))

    80 	, m_am_tools(tools)

    81 	, m_eap_header_offset(0u)

    82 	, m_MTU(MTU)

    83 	, m_trailer_length(0u)

    84 	, m_error_code(eap_status_ok)

    85 	, m_error_function(eap_tlv_message_type_function_none)

    86 	, m_is_client(is_client_when_true)

    87 	, m_is_valid(false)

    88 	, m_shutdown_was_called(false)

    89 {

    90 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

    91 

    92 	EAP_TRACE_DEBUG(

    93 		m_am_tools, 

    94 		EAP_TRACE_FLAGS_MESSAGE_DATA, 

    95 		(EAPL("eap_core_server_message_if_c::eap_core_server_message_if_c(): %s, this = 0x%08x => 0x%08x, compiled %s %s.\n"),

    96 		(m_is_client == true) ? "client": "server",

    97 		this,

    98 		dynamic_cast<abs_eap_base_timer_c *>(this),

    99 		__DATE__,

   100 		__TIME__));

   101 

   102 	if (m_eap_core != 0

   103 		&& m_eap_core->get_is_valid() == true

   104 		&& m_am_stack != 0

   105 		&& m_am_stack->get_is_valid() == true)

   106 	{

   107 		set_is_valid();

   108 	}

   109 

   110 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   111 }

   112 

   113 //--------------------------------------------------

   114 

   115 //

   116 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::configure(

   117 	const eap_variable_data_c * const client_configuration)

   118 {

   119 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   120 

   121 	EAP_TRACE_DEBUG(

   122 		m_am_tools,

   123 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   124 		(EAPL("%s: eap_core_server_message_if_c::configure()\n"),

   125 		(m_is_client == true) ? "client": "server"));

   126 

   127 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::configure()");

   128 

   129 	eap_status_e status(eap_status_process_general_error);

   130 

   131 	m_eap_header_offset = 0ul;

   132 	m_trailer_length = 0ul;

   133 

   134 	if (m_am_stack != 0)

   135 	{

   136 		status = m_am_stack->set_partner(

   137 			this

   138 #if defined(USE_EAP_SIMPLE_CONFIG)

   139 			, this

   140 #endif // #if defined(USE_EAP_SIMPLE_CONFIG)

   141 			);

   142 		if (status != eap_status_ok)

   143 		{

   144 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   145 			return EAP_STATUS_RETURN(m_am_tools, status);

   146 		}

   147 

   148 		status = m_am_stack->configure(client_configuration);

   149 		if (status != eap_status_ok)

   150 		{

   151 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   152 			return EAP_STATUS_RETURN(m_am_tools, status);

   153 		}

   154 	}

   155 	

   156 	if (m_eap_core != 0)

   157 	{

   158 		status = m_eap_core->configure();

   159 		if (status != eap_status_ok)

   160 		{

   161 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   162 			return EAP_STATUS_RETURN(m_am_tools, status);

   163 		}

   164 	}

   165 

   166 	return EAP_STATUS_RETURN(m_am_tools, status);

   167 }

   168 

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

   170 

   171 //

   172 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::shutdown()

   173 {

   174 	EAP_TRACE_DEBUG(

   175 		m_am_tools,

   176 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   177 		(EAPL("%s: eap_core_server_message_if_c::shutdown(), m_shutdown_was_called=%d\n"),

   178 		(m_is_client == true) ? "client": "server",

   179 		m_shutdown_was_called));

   180 

   181 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::shutdown()");

   182 

   183 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   184 

   185 	if (m_shutdown_was_called == true)

   186 	{

   187 		// Shutdown function was called already.

   188 		return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   189 	}

   190 	m_shutdown_was_called = true;

   191 

   192 	if (m_eap_core != 0)

   193 	{

   194 		(void) m_eap_core->shutdown();

   195 	}

   196 

   197 	if (m_am_stack != 0)

   198 	{

   199 		(void) m_am_stack->shutdown();

   200 	}

   201 

   202 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   203 }

   204 

   205 //--------------------------------------------------

   206 

   207 //

   208 EAP_FUNC_EXPORT void eap_core_server_message_if_c::set_partner(abs_eap_am_message_if_c * const partner)

   209 {

   210 	m_partner = partner;

   211 }

   212 

   213 //--------------------------------------------------

   214 

   215 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::send_error_message(

   216 	const eap_status_e error_code,

   217 	const eap_tlv_message_type_function_e function)

   218 {

   219 	eap_status_e status(eap_status_ok);

   220 

   221 	{

   222 		// Creates message data composed of Attribute-Value Pairs.

   223 		eap_process_tlv_message_data_c message(m_am_tools);

   224 

   225 		if (message.get_is_valid() == false)

   226 		{

   227 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   228 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   229 		}

   230 

   231 		status = message.add_parameter_data(

   232 			eap_tlv_message_type_error,

   233 			static_cast<u32_t>(error_code));

   234 		if (status != eap_status_ok)

   235 		{

   236 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   237 			return EAP_STATUS_RETURN(m_am_tools, status);

   238 		}

   239 

   240 		status = message.add_parameter_data(function);

   241 		if (status != eap_status_ok)

   242 		{

   243 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   244 			return EAP_STATUS_RETURN(m_am_tools, status);

   245 		}

   246 

   247 		status = send_message(&message);

   248 		if (status != eap_status_ok)

   249 		{

   250 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   251 			return EAP_STATUS_RETURN(m_am_tools, status);

   252 		}

   253 	}

   254 

   255 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   256 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   257 }

   258 

   259 //--------------------------------------------------

   260 

   261 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::send_message(eap_process_tlv_message_data_c * const message)

   262 {

   263 	// Sends message data composed of Attribute-Value Pairs.

   264 

   265 	EAP_TRACE_DATA_DEBUG(

   266 		m_am_tools,

   267 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   268 		(EAPL("eap_core_client_message_if_c::send_message()"),

   269 		message->get_message_data(),

   270 		message->get_message_data_length()));

   271 

   272 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_client_message_if_c::send_message()");

   273 

   274 

   275 	{

   276 		eap_status_e send_status = m_partner->send_data(

   277 			message->get_message_data(),

   278 			message->get_message_data_length());

   279 		if (send_status != eap_status_ok)

   280 		{

   281 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   282 			return EAP_STATUS_RETURN(m_am_tools, send_status);

   283 		}

   284 

   285 

   286 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   287 		return EAP_STATUS_RETURN(m_am_tools, send_status);

   288 	}

   289 

   290 }

   291 

   292 //--------------------------------------------------

   293 

   294 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::process_message_type_error(

   295 	EAP_TEMPLATE_CONST eap_array_c<eap_tlv_header_c> * const parameters)

   296 {

   297 	eap_status_e status(eap_status_ok);

   298 

   299 	eap_process_tlv_message_data_c message_data(m_am_tools);

   300 

   301 	if (message_data.get_is_valid() == false)

   302 	{

   303 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   304 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   305 	}

   306 

   307 	// Error payload is the first in this case.

   308 	status = message_data.read_parameter_data(parameters, eap_message_payload_index_function, eap_tlv_message_type_error, &m_error_code);

   309 	if (status != eap_status_ok)

   310 	{

   311 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   312 		return EAP_STATUS_RETURN(m_am_tools, status);

   313 	}

   314 

   315 	// Fuction payload is the second in this case.

   316 	status = message_data.read_parameter_data(parameters, eap_message_payload_index_first_parameter, &m_error_function);

   317 	if (status != eap_status_ok)

   318 	{

   319 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   320 		return EAP_STATUS_RETURN(m_am_tools, status);

   321 	}

   322 

   323 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   324 	return EAP_STATUS_RETURN(m_am_tools, status);

   325 }

   326 

   327 //--------------------------------------------------

   328 

   329 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::process_message(eap_process_tlv_message_data_c * const message)

   330 {

   331 	// Parses message data composed of Attribute-Value Pairs.

   332 

   333 	EAP_TRACE_DATA_DEBUG(

   334 		m_am_tools,

   335 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   336 		(EAPL("eap_core_server_message_if_c::process_message()"),

   337 		message->get_message_data(),

   338 		message->get_message_data_length()));

   339 

   340 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::process_message()");

   341 

   342 	eap_array_c<eap_tlv_header_c> parameters(m_am_tools);

   343 

   344 	eap_status_e status = message->parse_message_data(&parameters);

   345 	if (status != eap_status_ok)

   346 	{

   347 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   348 

   349 		(void) send_error_message(

   350 			status,

   351 			eap_tlv_message_type_function_none);

   352 

   353 		return EAP_STATUS_RETURN(m_am_tools, status);

   354 	}

   355 

   356 	if (parameters.get_object_count() == 0)

   357 	{

   358 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   359 

   360 		status = eap_status_illegal_parameter;

   361 

   362 		(void) send_error_message(

   363 			status,

   364 			eap_tlv_message_type_function_none);

   365 

   366 		return EAP_STATUS_RETURN(m_am_tools, status);

   367 	}

   368 

   369 	const eap_tlv_header_c * const function_header = parameters.get_object(eap_message_payload_index_function);

   370 	if (function_header == 0

   371 		|| (function_header->get_type() != eap_tlv_message_type_error

   372 			&& function_header->get_type() != eap_tlv_message_type_function))

   373 	{

   374 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   375 

   376 		status = eap_status_illegal_parameter;

   377 

   378 		(void) send_error_message(

   379 			status,

   380 			eap_tlv_message_type_function_none);

   381 

   382 		return EAP_STATUS_RETURN(m_am_tools, status);

   383 	}

   384 

   385 	if (function_header->get_type() == eap_tlv_message_type_error)

   386 	{

   387 		status = process_message_type_error(&parameters);

   388 	}

   389 	else // function_header->get_type() == eap_tlv_message_type_function

   390 	{

   391 		eap_tlv_message_type_function_e function(eap_tlv_message_type_function_none);

   392 

   393 		status = message->get_parameter_data(function_header, &function);

   394 		if (status != eap_status_ok)

   395 		{

   396 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   397 

   398 			(void) send_error_message(

   399 				status,

   400 				eap_tlv_message_type_function_none);

   401 

   402 			return EAP_STATUS_RETURN(m_am_tools, status);

   403 		}

   404 

   405 		switch(function)

   406 		{

   407 		case eap_tlv_message_type_function_create_eap_session:

   408 			status = create_eap_session(&parameters);

   409 			break;

   410 		case eap_tlv_message_type_function_remove_eap_session:

   411 			status = remove_eap_session(&parameters);

   412 			break;

   413 		case eap_tlv_message_type_function_send_eap_identity_request:

   414 			status = send_eap_identity_request(&parameters);

   415 			break;

   416 		case eap_tlv_message_type_function_packet_process:

   417 			status = packet_process(&parameters);

   418 			break;

   419 		case eap_tlv_message_type_function_eap_acknowledge:

   420 			status = eap_acknowledge(&parameters);

   421 			break;

   422 		case eap_tlv_message_type_function_set_eap_database_reference_values:

   423 			status = set_eap_database_reference_values(&parameters);

   424 			break;

   425 		case eap_tlv_message_type_function_eap_mtu:

   426 			status = eap_mtu(&parameters);

   427 			break;

   428 		case eap_tlv_message_type_function_get_802_11_authentication_mode:

   429 			status = get_802_11_authentication_mode(&parameters);

   430 			break;

   431 		default:

   432 			EAP_TRACE_ERROR(

   433 				m_am_tools,

   434 				TRACE_FLAGS_DEFAULT,

   435 				(EAPL("ERROR: process_data(): unknown function %d.\n"),

   436 				 function));

   437 

   438 			status = eap_status_illegal_parameter;

   439 

   440 			EAP_ASSERT_ANYWAY_TOOLS(m_am_tools);

   441 		};

   442 

   443 		if (status != eap_status_ok

   444 			&& status != eap_status_success

   445 			&& status != eap_status_pending_request

   446 			&& status != eap_status_completed_request

   447 			&& status != eap_status_drop_packet_quietly)

   448 		{

   449 			(void) send_error_message(

   450 				status,

   451 				function);

   452 		}

   453 	}

   454 

   455 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   456 	return EAP_STATUS_RETURN(m_am_tools, status);

   457 }

   458 

   459 //--------------------------------------------------

   460 

   461 /// Function receives the data message from lower layer.

   462 /// Data is formatted to Attribute-Value Pairs.

   463 /// Look at eap_tlv_header_c and eap_tlv_message_data_c.

   464 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::process_data(const void * const data, const u32_t length)

   465 {

   466 	eap_status_e status(eap_status_process_general_error);

   467 

   468 	{

   469 		eap_process_tlv_message_data_c message(m_am_tools);

   470 

   471 		if (message.get_is_valid() == false)

   472 		{

   473 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   474 

   475 			status = eap_status_allocation_error;

   476 

   477 			(void) send_error_message(

   478 				status,

   479 				eap_tlv_message_type_function_none);

   480 

   481 			return EAP_STATUS_RETURN(m_am_tools, status);

   482 		}

   483 

   484 		status = message.set_message_data(length, data);

   485 		if (status != eap_status_ok)

   486 		{

   487 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   488 

   489 			(void) send_error_message(

   490 				status,

   491 				eap_tlv_message_type_function_none);

   492 

   493 			return EAP_STATUS_RETURN(m_am_tools, status);

   494 		}

   495 

   496 		status = process_message(&message);

   497 	}

   498 

   499 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   500 	return EAP_STATUS_RETURN(m_am_tools, status);

   501 }

   502 

   503 //--------------------------------------------------

   504 

   505 //

   506 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::packet_send(

   507 	const eap_am_network_id_c * const send_network_id,

   508 	eap_buf_chain_wr_c * const sent_packet,

   509 	const u32_t header_offset,

   510 	const u32_t data_length,

   511 	const u32_t buffer_length)

   512 {

   513 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   514 

   515 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   516 	EAP_ASSERT(header_offset < sent_packet->get_data_length());

   517 	EAP_ASSERT(data_length <= sent_packet->get_data_length());

   518 	EAP_ASSERT(sent_packet->get_data_length() <= buffer_length);

   519 

   520 	eap_status_e status(eap_status_process_general_error);

   521 

   522 	if (sent_packet->get_do_length_checks() == true)

   523 	{

   524 		if (header_offset != 0ul)

   525 		{

   526 			EAP_TRACE_ERROR(

   527 				m_am_tools,

   528 				TRACE_FLAGS_DEFAULT,

   529 				(EAPL("ERROR: packet_send: packet buffer corrupted (header_offset != %d).\n"),

   530 				0ul));

   531 			EAP_ASSERT_ALWAYS(header_offset == 0ul);

   532 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   533 		}

   534 		else if (header_offset+data_length != sent_packet->get_data_length())

   535 		{

   536 			EAP_TRACE_ERROR(

   537 				m_am_tools,

   538 				TRACE_FLAGS_DEFAULT,

   539 				(EAPL("ERROR: packet_send: packet buffer corrupted ")

   540 				 EAPL("(data_length %d != sent_packet->get_data_length() %d).\n"),

   541 				 header_offset+data_length,

   542 				 sent_packet->get_data_length()));

   543 			EAP_ASSERT_ALWAYS(data_length == sent_packet->get_buffer_length());

   544 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   545 		}

   546 		else if (header_offset+data_length > buffer_length)

   547 		{

   548 			EAP_TRACE_ERROR(

   549 				m_am_tools,

   550 				TRACE_FLAGS_DEFAULT,

   551 				(EAPL("ERROR: packet_send: packet buffer corrupted ")

   552 				 EAPL("(header_offset+data_length %d > buffer_length %d).\n"),

   553 				 header_offset+data_length,

   554 				 buffer_length));

   555 			EAP_ASSERT_ALWAYS(header_offset+data_length <= buffer_length);

   556 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   557 		}

   558 		else if (header_offset+data_length > m_MTU)

   559 		{

   560 			EAP_TRACE_ERROR(

   561 				m_am_tools,

   562 				TRACE_FLAGS_DEFAULT,

   563 				(EAPL("ERROR: packet_send: packet buffer corrupted ")

   564 				 EAPL("(header_offset+data_length %d > m_MTU %d).\n"),

   565 				 header_offset+data_length,

   566 				 m_MTU));

   567 			EAP_ASSERT_ALWAYS(header_offset+data_length <= m_MTU);

   568 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   569 		}

   570 	}

   571 	else

   572 	{

   573 		// Always we need at least the EAP header.

   574 		if (sent_packet->get_data_length()

   575 			< eap_header_base_c::get_header_length())

   576 		{

   577 			EAP_TRACE_ERROR(

   578 				m_am_tools,

   579 				TRACE_FLAGS_DEFAULT,

   580 				(EAPL("ERROR: packet_send: packet buffer corrupted ")

   581 				 EAPL("(sent_packet->get_data_length() %d < ")

   582 				 EAPL("eap_header_base_c::get_header_length() %d).\n"),

   583 				 sent_packet->get_data_length(),

   584 				 eap_header_base_c::get_header_length()));

   585 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   586 		}

   587 	}

   588 	

   589 	{

   590 		// Creates message data composed of Attribute-Value Pairs.

   591 		eap_process_tlv_message_data_c message(m_am_tools);

   592 

   593 		if (message.get_is_valid() == false)

   594 		{

   595 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   596 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   597 		}

   598 

   599 		status = message.add_parameter_data(eap_tlv_message_type_function_packet_send);

   600 		if (status != eap_status_ok)

   601 		{

   602 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   603 			return EAP_STATUS_RETURN(m_am_tools, status);

   604 		}

   605 

   606 		status = message.add_parameter_data(send_network_id);

   607 		if (status != eap_status_ok)

   608 		{

   609 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   610 			return EAP_STATUS_RETURN(m_am_tools, status);

   611 		}

   612 

   613 		status = message.add_parameter_data(sent_packet);

   614 		if (status != eap_status_ok)

   615 		{

   616 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   617 			return EAP_STATUS_RETURN(m_am_tools, status);

   618 		}

   619 

   620 		status = send_message(&message);

   621 		if (status != eap_status_ok)

   622 		{

   623 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   624 			return EAP_STATUS_RETURN(m_am_tools, status);

   625 		}

   626 	}

   627 

   628 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   629 	return EAP_STATUS_RETURN(m_am_tools, status);

   630 }

   631 

   632 //--------------------------------------------------

   633 

   634 //

   635 EAP_FUNC_EXPORT u32_t eap_core_server_message_if_c::get_header_offset(

   636 	u32_t * const MTU,

   637 	u32_t * const trailer_length)

   638 {

   639 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   640 

   641 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   642 

   643 	const u32_t offset = 0ul;

   644 

   645 	*MTU = m_MTU;

   646 	*trailer_length = m_trailer_length;

   647 

   648 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   649 	return offset;

   650 }

   651 

   652 //--------------------------------------------------

   653 

   654 //

   655 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::load_module(

   656 	const eap_type_value_e type,

   657 	const eap_type_value_e tunneling_type,

   658 	abs_eap_base_type_c * const partner,

   659 	eap_base_type_c ** const eap_type,

   660 	const bool is_client_when_true,

   661 	const eap_am_network_id_c * const receive_network_id)

   662 {

   663 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   664 

   665 	eap_status_e status = m_am_stack->load_module(

   666 		type,

   667 		tunneling_type,

   668 		partner,

   669 		eap_type,

   670 		is_client_when_true,

   671 		receive_network_id);

   672 

   673 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   674 	return EAP_STATUS_RETURN(m_am_tools, status);

   675 }

   676 

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

   678 

   679 //

   680 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::unload_module(const eap_type_value_e type)

   681 {

   682 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   683 

   684 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   685 

   686 	eap_status_e status(eap_status_process_general_error);

   687 

   688 	EAP_ASSERT_ANYWAY_TOOLS(m_am_tools);

   689 

   690 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   691 	return EAP_STATUS_RETURN(m_am_tools, status);

   692 }

   693 

   694 //--------------------------------------------------

   695 

   696 //

   697 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::packet_data_crypto_keys(

   698 	const eap_am_network_id_c * const send_network_id,

   699 	const eap_master_session_key_c * const master_session_key

   700 	)

   701 {

   702 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   703 

   704 	EAP_TRACE_DEBUG(

   705 		m_am_tools,

   706 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   707 		(EAPL("%s: eap_core_server_message_if_c::packet_data_crypto_keys()\n"),

   708 		(m_is_client == true) ? "client": "server"));

   709 

   710 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::packet_data_crypto_keys()");

   711 

   712 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   713 

   714 	eap_status_e status(eap_status_process_general_error);

   715 

   716 	if (master_session_key == 0

   717 		|| master_session_key->get_is_valid() == false)

   718 	{

   719 		EAP_TRACE_DEBUG(

   720 			m_am_tools,

   721 			TRACE_FLAGS_DEFAULT,

   722 			(EAPL("ERROR: eap_core_server_message_if_c::packet_data_crypto_keys(), invalid key.\n")));

   723 		return EAP_STATUS_RETURN(m_am_tools, eap_status_key_error);

   724 	}

   725 	

   726 	EAP_TRACE_DATA_DEBUG(

   727 		m_am_tools,

   728 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   729 		(EAPL("eap_core_server_message_if_c::packet_data_crypto_keys(): master_session_key"), 

   730 		 master_session_key->get_data(),

   731 		 master_session_key->get_data_length()));

   732 	

   733 	{

   734 		// Creates message data composed of Attribute-Value Pairs.

   735 		eap_process_tlv_message_data_c message(m_am_tools);

   736 

   737 		if (message.get_is_valid() == false)

   738 		{

   739 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   740 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   741 		}

   742 

   743 		status = message.add_parameter_data(eap_tlv_message_type_function_packet_data_crypto_keys);

   744 		if (status != eap_status_ok)

   745 		{

   746 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   747 			return EAP_STATUS_RETURN(m_am_tools, status);

   748 		}

   749 

   750 		status = message.add_parameter_data(send_network_id);

   751 		if (status != eap_status_ok)

   752 		{

   753 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   754 			return EAP_STATUS_RETURN(m_am_tools, status);

   755 		}

   756 

   757 		// This adds only the EAP-type.

   758 		status = message.add_parameter_data(master_session_key->get_eap_type());

   759 		if (status != eap_status_ok)

   760 		{

   761 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   762 			return EAP_STATUS_RETURN(m_am_tools, status);

   763 		}

   764 

   765 		// This adds only the eap_variable_data.

   766 		status = message.add_parameter_data(master_session_key);

   767 		if (status != eap_status_ok)

   768 		{

   769 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   770 			return EAP_STATUS_RETURN(m_am_tools, status);

   771 		}

   772 

   773 		status = send_message(&message);

   774 		if (status != eap_status_ok)

   775 		{

   776 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   777 			return EAP_STATUS_RETURN(m_am_tools, status);

   778 		}

   779 	}

   780 

   781 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   782 	return EAP_STATUS_RETURN(m_am_tools, status);

   783 }

   784 

   785 //--------------------------------------------------

   786 

   787 //

   788 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::complete_get_802_11_authentication_mode(

   789 	const eap_status_e completion_status,

   790 	const eap_am_network_id_c * const receive_network_id,

   791 	const eapol_key_802_11_authentication_mode_e mode)

   792 {

   793 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   794 

   795 	EAP_TRACE_DEBUG(

   796 		m_am_tools,

   797 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   798 		(EAPL("%s: eap_core_server_message_if_c::complete_get_802_11_authentication_mode()\n"),

   799 		(m_is_client == true) ? "client": "server"));

   800 

   801 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::complete_get_802_11_authentication_mode()");

   802 

   803 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   804 

   805 	eap_status_e status(eap_status_process_general_error);

   806 

   807 	{

   808 		// Creates message data composed of Attribute-Value Pairs.

   809 		eap_process_tlv_message_data_c message(m_am_tools);

   810 

   811 		if (message.get_is_valid() == false)

   812 		{

   813 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   814 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   815 		}

   816 

   817 		status = message.add_parameter_data(eap_tlv_message_type_function_complete_get_802_11_authentication_mode);

   818 		if (status != eap_status_ok)

   819 		{

   820 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   821 			return EAP_STATUS_RETURN(m_am_tools, status);

   822 		}

   823 

   824 		status = message.add_parameter_data(completion_status);

   825 		if (status != eap_status_ok)

   826 		{

   827 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   828 			return EAP_STATUS_RETURN(m_am_tools, status);

   829 		}

   830 

   831 		status = message.add_parameter_data(receive_network_id);

   832 		if (status != eap_status_ok)

   833 		{

   834 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   835 			return EAP_STATUS_RETURN(m_am_tools, status);

   836 		}

   837 

   838 		status = message.add_parameter_data(mode);

   839 		if (status != eap_status_ok)

   840 		{

   841 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   842 			return EAP_STATUS_RETURN(m_am_tools, status);

   843 		}

   844 

   845 		status = send_message(&message);

   846 		if (status != eap_status_ok)

   847 		{

   848 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   849 			return EAP_STATUS_RETURN(m_am_tools, status);

   850 		}

   851 	}

   852 

   853 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   854 	return EAP_STATUS_RETURN(m_am_tools, status);

   855 }

   856 

   857 //--------------------------------------------------

   858 

   859 //

   860 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::complete_remove_eap_session(

   861 	const bool complete_to_lower_layer,

   862 	const eap_am_network_id_c * const receive_network_id)

   863 {

   864 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   865 

   866 	EAP_TRACE_DEBUG(

   867 		m_am_tools,

   868 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   869 		(EAPL("%s: eap_core_server_message_if_c::complete_remove_eap_session(): complete_to_lower_layer=%s\n"),

   870 		(m_is_client == true) ? "client": "server",

   871 		(complete_to_lower_layer == true) ? "true": "false"));

   872 

   873 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::complete_remove_eap_session()");

   874 

   875 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   876 

   877 	eap_status_e status(eap_status_process_general_error);

   878 

   879 	{

   880 		// Creates message data composed of Attribute-Value Pairs.

   881 		eap_process_tlv_message_data_c message(m_am_tools);

   882 

   883 		if (message.get_is_valid() == false)

   884 		{

   885 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   886 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   887 		}

   888 

   889 		status = message.add_parameter_data(eap_tlv_message_type_function_complete_remove_eap_session);

   890 		if (status != eap_status_ok)

   891 		{

   892 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   893 			return EAP_STATUS_RETURN(m_am_tools, status);

   894 		}

   895 

   896 		status = message.add_parameter_data(complete_to_lower_layer);

   897 		if (status != eap_status_ok)

   898 		{

   899 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   900 			return EAP_STATUS_RETURN(m_am_tools, status);

   901 		}

   902 

   903 		status = message.add_parameter_data(receive_network_id);

   904 		if (status != eap_status_ok)

   905 		{

   906 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   907 			return EAP_STATUS_RETURN(m_am_tools, status);

   908 		}

   909 

   910 		status = send_message(&message);

   911 		if (status != eap_status_ok)

   912 		{

   913 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   914 			return EAP_STATUS_RETURN(m_am_tools, status);

   915 		}

   916 	}

   917 

   918 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   919 	return EAP_STATUS_RETURN(m_am_tools, status);

   920 }

   921 

   922 //--------------------------------------------------

   923 

   924 //

   925 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::read_configure(

   926 	const eap_configuration_field_c * const field,

   927 	eap_variable_data_c * const data)

   928 {

   929 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   930 

   931 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   932 

   933 	eap_status_e status = m_am_stack->read_configure(

   934 		field,

   935 		data);

   936 

   937 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   938 	return EAP_STATUS_RETURN(m_am_tools, status);

   939 }

   940 

   941 //--------------------------------------------------

   942 

   943 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::write_configure(

   944 	const eap_configuration_field_c * const field,

   945 	eap_variable_data_c * const data)

   946 {

   947 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   948 

   949 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

   950 

   951 	eap_status_e status(eap_status_process_general_error);

   952 

   953 	EAP_ASSERT_ANYWAY_TOOLS(m_am_tools);

   954 

   955 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   956 	return EAP_STATUS_RETURN(m_am_tools, status);

   957 }

   958 

   959 //--------------------------------------------------

   960 

   961 //

   962 EAP_FUNC_EXPORT void eap_core_server_message_if_c::set_is_valid()

   963 {

   964 	m_is_valid = true;

   965 }

   966 

   967 //--------------------------------------------------

   968 

   969 //

   970 EAP_FUNC_EXPORT bool eap_core_server_message_if_c::get_is_valid()

   971 {

   972 	return m_is_valid;

   973 }

   974 

   975 //--------------------------------------------------

   976 

   977 //

   978 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::timer_expired(

   979 	const u32_t id, void *data)

   980 {

   981 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   982 

   983 	EAP_TRACE_DEBUG(

   984 		m_am_tools,

   985 		EAP_TRACE_FLAGS_MESSAGE_DATA,

   986 		(EAPL("TIMER: %s: [0x%08x]->eap_core_server_message_if_c::timer_expired(id 0x%02x, data 0x%08x).\n"),

   987 		 (m_is_client == true) ? "client": "server",

   988 		 this,

   989 		 id,

   990 		 data));

   991 

   992 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::timer_expired()");

   993 

   994 

   995 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   996 }

   997 

   998 //--------------------------------------------------

   999 

  1000 //

  1001 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::timer_delete_data(

  1002 	const u32_t id, void *data)

  1003 {

  1004 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1005 

  1006 	EAP_TRACE_DEBUG(

  1007 		m_am_tools,

  1008 		EAP_TRACE_FLAGS_MESSAGE_DATA,

  1009 		(EAPL("TIMER: %s: [0x%08x]->eap_core_server_message_if_c::timer_delete_data(id 0x%02x, data 0x%08x).\n"),

  1010 		(m_is_client == true) ? "client": "server",

  1011 		this, id, data));

  1012 

  1013 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::timer_delete_data()");

  1014 

  1015 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

  1016 }

  1017 

  1018 //--------------------------------------------------

  1019 

  1020 EAP_FUNC_EXPORT void eap_core_server_message_if_c::state_notification(

  1021 	const abs_eap_state_notification_c * const state)

  1022 {

  1023 	eap_status_e status(eap_status_process_general_error);

  1024 

  1025 	EAP_TRACE_DEBUG(

  1026 		m_am_tools, 

  1027 		EAP_TRACE_FLAGS_MESSAGE_DATA, 

  1028 		(EAPL("%s: eap_core_server_message_if_c::state_notification()\n"),

  1029 		 (m_is_client == true) ? "client": "server"));

  1030 

  1031 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::state_notification()");

  1032 

  1033 	{

  1034 		// Creates message data composed of Attribute-Value Pairs.

  1035 		eap_process_tlv_message_data_c message(m_am_tools);

  1036 

  1037 		if (message.get_is_valid() == false)

  1038 		{

  1039 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1040 			(void)EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

  1041 			return;

  1042 		}

  1043 

  1044 		status = message.add_parameter_data(eap_tlv_message_type_function_state_notification);

  1045 		if (status != eap_status_ok)

  1046 		{

  1047 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1048 			(void)EAP_STATUS_RETURN(m_am_tools, status);

  1049 			return;

  1050 		}

  1051 

  1052 		status = message.add_parameter_data(state);

  1053 		if (status != eap_status_ok)

  1054 		{

  1055 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1056 			(void)EAP_STATUS_RETURN(m_am_tools, status);

  1057 			return;

  1058 		}

  1059 

  1060 		status = send_message(&message);

  1061 		if (status != eap_status_ok)

  1062 		{

  1063 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1064 			(void)EAP_STATUS_RETURN(m_am_tools, status);

  1065 			return;

  1066 		}

  1067 	}

  1068 }

  1069 

  1070 //--------------------------------------------------

  1071 

  1072 //

  1073 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::asynchronous_init_remove_eap_session(

  1074 	const eap_am_network_id_c * const /* send_network_id */)

  1075 {

  1076 	// eap_core_server_message_if_c object does not support asynchronous_init_remove_eap_session().

  1077 	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);

  1078 }

  1079 

  1080 //--------------------------------------------------

  1081 

  1082 //

  1083 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::asynchronous_start_authentication(

  1084 	const eap_am_network_id_c * const /* receive_network_id */,

  1085 	const bool /* is_client_when_true */)

  1086 {

  1087 	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);

  1088 }

  1089 

  1090 //--------------------------------------------------

  1091 

  1092 //

  1093 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::restart_authentication(

  1094 	const eap_am_network_id_c * const send_network_id,

  1095 	const bool is_client_when_true,

  1096 	const bool force_clean_restart,

  1097 	const bool from_timer)

  1098 {

  1099 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1100 

  1101 	EAP_TRACE_DEBUG(

  1102 		m_am_tools,

  1103 		EAP_TRACE_FLAGS_MESSAGE_DATA,

  1104 		(EAPL("%s: eap_core_server_message_if_c::restart_authentication()\n"),

  1105 		(m_is_client == true) ? "client": "server"));

  1106 

  1107 	EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, EAP_TRACE_FLAGS_MESSAGE_DATA, "returns: eap_core_server_message_if_c::restart_authentication()");

  1108 

  1109 	EAP_ASSERT(m_am_tools->get_global_mutex()->get_is_reserved() == true);

  1110 

  1111 	eap_status_e status(eap_status_process_general_error);

  1112 

  1113 	{

  1114 		// Creates message data composed of Attribute-Value Pairs.

  1115 		eap_process_tlv_message_data_c message(m_am_tools);

  1116 

  1117 		if (message.get_is_valid() == false)

  1118 		{

  1119 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1120 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

  1121 		}

  1122 

  1123 		status = message.add_parameter_data(eap_tlv_message_type_function_restart_authentication);

  1124 		if (status != eap_status_ok)

  1125 		{

  1126 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1127 			return EAP_STATUS_RETURN(m_am_tools, status);

  1128 		}

  1129 

  1130 		status = message.add_parameter_data(send_network_id);

  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);