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

    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_DEBUG(

   266 		m_am_tools, 

   267 		EAP_TRACE_FLAGS_MESSAGE_DATA, 

   268 		(EAPL("eap_core_server_message_if_c::send_message(): this = 0x%08x => 0x%08x.\n"),

   269 		this,

   270 		dynamic_cast<abs_eap_base_timer_c *>(this)));

   271 

   272 	EAP_TRACE_DATA_DEBUG(

   273 		m_am_tools,

   274 		EAP_TRACE_FLAGS_NEVER,

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

   276 		message->get_message_data(),

   277 		message->get_message_data_length()));

   278 

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

   280 

   281 

   282 	{

   283 		eap_status_e send_status = m_partner->send_data(

   284 			message->get_message_data(),

   285 			message->get_message_data_length());

   286 		if (send_status != eap_status_ok)

   287 		{

   288 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   289 			return EAP_STATUS_RETURN(m_am_tools, send_status);

   290 		}

   291 

   292 

   293 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   294 		return EAP_STATUS_RETURN(m_am_tools, send_status);

   295 	}

   296 

   297 }

   298 

   299 //--------------------------------------------------

   300 

   301 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::process_message_type_error(

   302 	EAP_TEMPLATE_CONST eap_array_c<eap_tlv_header_c> * const parameters)

   303 {

   304 	eap_status_e status(eap_status_ok);

   305 

   306 	eap_process_tlv_message_data_c message_data(m_am_tools);

   307 

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

   309 	{

   310 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   311 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   312 	}

   313 

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

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

   316 	if (status != eap_status_ok)

   317 	{

   318 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   319 		return EAP_STATUS_RETURN(m_am_tools, status);

   320 	}

   321 

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

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

   324 	if (status != eap_status_ok)

   325 	{

   326 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   327 		return EAP_STATUS_RETURN(m_am_tools, status);

   328 	}

   329 

   330 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   331 	return EAP_STATUS_RETURN(m_am_tools, status);

   332 }

   333 

   334 //--------------------------------------------------

   335 

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

   337 {

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

   339 

   340 	EAP_TRACE_DATA_DEBUG(

   341 		m_am_tools,

   342 		EAP_TRACE_FLAGS_MESSAGE_DATA,

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

   344 		message->get_message_data(),

   345 		message->get_message_data_length()));

   346 

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

   348 

   349 	eap_array_c<eap_tlv_header_c> parameters(m_am_tools);

   350 

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

   352 	if (status != eap_status_ok)

   353 	{

   354 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   355 

   356 		(void) send_error_message(

   357 			status,

   358 			eap_tlv_message_type_function_none);

   359 

   360 		return EAP_STATUS_RETURN(m_am_tools, status);

   361 	}

   362 

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

   364 	{

   365 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   366 

   367 		status = eap_status_illegal_parameter;

   368 

   369 		(void) send_error_message(

   370 			status,

   371 			eap_tlv_message_type_function_none);

   372 

   373 		return EAP_STATUS_RETURN(m_am_tools, status);

   374 	}

   375 

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

   377 	if (function_header == 0

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

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

   380 	{

   381 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   382 

   383 		status = eap_status_illegal_parameter;

   384 

   385 		(void) send_error_message(

   386 			status,

   387 			eap_tlv_message_type_function_none);

   388 

   389 		return EAP_STATUS_RETURN(m_am_tools, status);

   390 	}

   391 

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

   393 	{

   394 		status = process_message_type_error(&parameters);

   395 	}

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

   397 	{

   398 		eap_tlv_message_type_function_e function(eap_tlv_message_type_function_none);

   399 

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

   401 		if (status != eap_status_ok)

   402 		{

   403 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   404 

   405 			(void) send_error_message(

   406 				status,

   407 				eap_tlv_message_type_function_none);

   408 

   409 			return EAP_STATUS_RETURN(m_am_tools, status);

   410 		}

   411 

   412 		switch(function)

   413 		{

   414 		case eap_tlv_message_type_function_create_eap_session:

   415 			status = create_eap_session(&parameters);

   416 			break;

   417 		case eap_tlv_message_type_function_remove_eap_session:

   418 			status = remove_eap_session(&parameters);

   419 			break;

   420 		case eap_tlv_message_type_function_send_eap_identity_request:

   421 			status = send_eap_identity_request(&parameters);

   422 			break;

   423 		case eap_tlv_message_type_function_packet_process:

   424 			status = packet_process(&parameters);

   425 			break;

   426 		case eap_tlv_message_type_function_eap_acknowledge:

   427 			status = eap_acknowledge(&parameters);

   428 			break;

   429 		case eap_tlv_message_type_function_set_eap_database_reference_values:

   430 			status = set_eap_database_reference_values(&parameters);

   431 			break;

   432 		case eap_tlv_message_type_function_eap_mtu:

   433 			status = eap_mtu(&parameters);

   434 			break;

   435 		case eap_tlv_message_type_function_get_802_11_authentication_mode:

   436 			status = get_802_11_authentication_mode(&parameters);

   437 			break;

   438 		default:

   439 			EAP_TRACE_ERROR(

   440 				m_am_tools,

   441 				TRACE_FLAGS_DEFAULT,

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

   443 				 function));

   444 

   445 			status = eap_status_illegal_parameter;

   446 

   447 			EAP_ASSERT_ANYWAY_TOOLS(m_am_tools);

   448 		};

   449 

   450 		if (status != eap_status_ok

   451 			&& status != eap_status_success

   452 			&& status != eap_status_pending_request

   453 			&& status != eap_status_completed_request

   454 			&& status != eap_status_drop_packet_quietly)

   455 		{

   456 			(void) send_error_message(

   457 				status,

   458 				function);

   459 		}

   460 	}

   461 

   462 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   463 	return EAP_STATUS_RETURN(m_am_tools, status);

   464 }

   465 

   466 //--------------------------------------------------

   467 

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

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

   470 /// Look at eap_tlv_header_c and eap_tlv_message_data_c.

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

   472 {

   473 	eap_status_e status(eap_status_process_general_error);

   474 

   475 	{

   476 		eap_process_tlv_message_data_c message(m_am_tools);

   477 

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

   479 		{

   480 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   481 

   482 			status = eap_status_allocation_error;

   483 

   484 			(void) send_error_message(

   485 				status,

   486 				eap_tlv_message_type_function_none);

   487 

   488 			return EAP_STATUS_RETURN(m_am_tools, status);

   489 		}

   490 

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

   492 		if (status != eap_status_ok)

   493 		{

   494 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   495 

   496 			(void) send_error_message(

   497 				status,

   498 				eap_tlv_message_type_function_none);

   499 

   500 			return EAP_STATUS_RETURN(m_am_tools, status);

   501 		}

   502 

   503 		status = process_message(&message);

   504 	}

   505 

   506 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   507 	return EAP_STATUS_RETURN(m_am_tools, status);

   508 }

   509 

   510 //--------------------------------------------------

   511 

   512 //

   513 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::packet_send(

   514 	const eap_am_network_id_c * const send_network_id,

   515 	eap_buf_chain_wr_c * const sent_packet,

   516 	const u32_t header_offset,

   517 	const u32_t data_length,

   518 	const u32_t buffer_length)

   519 {

   520 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   521 

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

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

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

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

   526 

   527 	eap_status_e status(eap_status_process_general_error);

   528 

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

   530 	{

   531 		if (header_offset != 0ul)

   532 		{

   533 			EAP_TRACE_ERROR(

   534 				m_am_tools,

   535 				TRACE_FLAGS_DEFAULT,

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

   537 				0ul));

   538 			EAP_ASSERT_ALWAYS(header_offset == 0ul);

   539 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   540 		}

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

   542 		{

   543 			EAP_TRACE_ERROR(

   544 				m_am_tools,

   545 				TRACE_FLAGS_DEFAULT,

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

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

   548 				 header_offset+data_length,

   549 				 sent_packet->get_data_length()));

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

   551 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   552 		}

   553 		else if (header_offset+data_length > buffer_length)

   554 		{

   555 			EAP_TRACE_ERROR(

   556 				m_am_tools,

   557 				TRACE_FLAGS_DEFAULT,

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

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

   560 				 header_offset+data_length,

   561 				 buffer_length));

   562 			EAP_ASSERT_ALWAYS(header_offset+data_length <= buffer_length);

   563 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   564 		}

   565 		else if (header_offset+data_length > m_MTU)

   566 		{

   567 			EAP_TRACE_ERROR(

   568 				m_am_tools,

   569 				TRACE_FLAGS_DEFAULT,

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

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

   572 				 header_offset+data_length,

   573 				 m_MTU));

   574 			EAP_ASSERT_ALWAYS(header_offset+data_length <= m_MTU);

   575 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   576 		}

   577 	}

   578 	else

   579 	{

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

   581 		if (sent_packet->get_data_length()

   582 			< eap_header_base_c::get_header_length())

   583 		{

   584 			EAP_TRACE_ERROR(

   585 				m_am_tools,

   586 				TRACE_FLAGS_DEFAULT,

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

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

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

   590 				 sent_packet->get_data_length(),

   591 				 eap_header_base_c::get_header_length()));

   592 			return EAP_STATUS_RETURN(m_am_tools, eap_status_process_general_error);

   593 		}

   594 	}

   595 	

   596 	{

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

   598 		eap_process_tlv_message_data_c message(m_am_tools);

   599 

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

   601 		{

   602 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   603 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   604 		}

   605 

   606 		status = message.add_parameter_data(eap_tlv_message_type_function_packet_send);

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

   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 = message.add_parameter_data(sent_packet);

   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 		status = send_message(&message);

   628 		if (status != eap_status_ok)

   629 		{

   630 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   631 			return EAP_STATUS_RETURN(m_am_tools, status);

   632 		}

   633 	}

   634 

   635 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   636 	return EAP_STATUS_RETURN(m_am_tools, status);

   637 }

   638 

   639 //--------------------------------------------------

   640 

   641 //

   642 EAP_FUNC_EXPORT u32_t eap_core_server_message_if_c::get_header_offset(

   643 	u32_t * const MTU,

   644 	u32_t * const trailer_length)

   645 {

   646 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   647 

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

   649 

   650 	const u32_t offset = 0ul;

   651 

   652 	*MTU = m_MTU;

   653 	*trailer_length = m_trailer_length;

   654 

   655 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   656 	return offset;

   657 }

   658 

   659 //--------------------------------------------------

   660 

   661 //

   662 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::load_module(

   663 	const eap_type_value_e type,

   664 	const eap_type_value_e tunneling_type,

   665 	abs_eap_base_type_c * const partner,

   666 	eap_base_type_c ** const eap_type,

   667 	const bool is_client_when_true,

   668 	const eap_am_network_id_c * const receive_network_id)

   669 {

   670 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   671 

   672 	eap_status_e status = m_am_stack->load_module(

   673 		type,

   674 		tunneling_type,

   675 		partner,

   676 		eap_type,

   677 		is_client_when_true,

   678 		receive_network_id);

   679 

   680 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   681 	return EAP_STATUS_RETURN(m_am_tools, status);

   682 }

   683 

   684 //--------------------------------------------------

   685 

   686 //

   687 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::unload_module(const eap_type_value_e /* type*/)

   688 {

   689 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   690 

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

   692 

   693 	eap_status_e status(eap_status_process_general_error);

   694 

   695 	EAP_ASSERT_ANYWAY_TOOLS(m_am_tools);

   696 

   697 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   698 	return EAP_STATUS_RETURN(m_am_tools, status);

   699 }

   700 

   701 //--------------------------------------------------

   702 

   703 //

   704 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::packet_data_crypto_keys(

   705 	const eap_am_network_id_c * const send_network_id,

   706 	const eap_master_session_key_c * const master_session_key

   707 	)

   708 {

   709 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   710 

   711 	EAP_TRACE_DEBUG(

   712 		m_am_tools,

   713 		EAP_TRACE_FLAGS_MESSAGE_DATA,

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

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

   716 

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

   718 

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

   720 

   721 	eap_status_e status(eap_status_process_general_error);

   722 

   723 	if (master_session_key == 0

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

   725 	{

   726 		EAP_TRACE_DEBUG(

   727 			m_am_tools,

   728 			TRACE_FLAGS_DEFAULT,

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

   730 		return EAP_STATUS_RETURN(m_am_tools, eap_status_key_error);

   731 	}

   732 	

   733 	EAP_TRACE_DATA_DEBUG(

   734 		m_am_tools,

   735 		EAP_TRACE_FLAGS_MESSAGE_DATA,

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

   737 		 master_session_key->get_data(),

   738 		 master_session_key->get_data_length()));

   739 	

   740 	{

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

   742 		eap_process_tlv_message_data_c message(m_am_tools);

   743 

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

   745 		{

   746 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   747 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   748 		}

   749 

   750 		status = message.add_parameter_data(eap_tlv_message_type_function_packet_data_crypto_keys);

   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 		status = message.add_parameter_data(send_network_id);

   758 		if (status != eap_status_ok)

   759 		{

   760 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   761 			return EAP_STATUS_RETURN(m_am_tools, status);

   762 		}

   763 

   764 		// This adds only the EAP-type.

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

   766 		if (status != eap_status_ok)

   767 		{

   768 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   769 			return EAP_STATUS_RETURN(m_am_tools, status);

   770 		}

   771 

   772 		// This adds only the eap_variable_data.

   773 		status = message.add_parameter_data(master_session_key);

   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 		status = send_message(&message);

   781 		if (status != eap_status_ok)

   782 		{

   783 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   784 			return EAP_STATUS_RETURN(m_am_tools, status);

   785 		}

   786 	}

   787 

   788 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   789 	return EAP_STATUS_RETURN(m_am_tools, status);

   790 }

   791 

   792 //--------------------------------------------------

   793 

   794 //

   795 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::complete_get_802_11_authentication_mode(

   796 	const eap_status_e completion_status,

   797 	const eap_am_network_id_c * const receive_network_id,

   798 	const eapol_key_802_11_authentication_mode_e mode)

   799 {

   800 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   801 

   802 	EAP_TRACE_DEBUG(

   803 		m_am_tools,

   804 		EAP_TRACE_FLAGS_MESSAGE_DATA,

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

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

   807 

   808 	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()");

   809 

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

   811 

   812 	eap_status_e status(eap_status_process_general_error);

   813 

   814 	{

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

   816 		eap_process_tlv_message_data_c message(m_am_tools);

   817 

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

   819 		{

   820 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   821 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   822 		}

   823 

   824 		status = message.add_parameter_data(eap_tlv_message_type_function_complete_get_802_11_authentication_mode);

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

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

   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 = message.add_parameter_data(mode);

   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 		status = send_message(&message);

   853 		if (status != eap_status_ok)

   854 		{

   855 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   856 			return EAP_STATUS_RETURN(m_am_tools, status);

   857 		}

   858 	}

   859 

   860 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   861 	return EAP_STATUS_RETURN(m_am_tools, status);

   862 }

   863 

   864 //--------------------------------------------------

   865 

   866 //

   867 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::complete_remove_eap_session(

   868 	const bool complete_to_lower_layer,

   869 	const eap_am_network_id_c * const receive_network_id)

   870 {

   871 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   872 

   873 	EAP_TRACE_DEBUG(

   874 		m_am_tools,

   875 		EAP_TRACE_FLAGS_MESSAGE_DATA,

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

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

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

   879 

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

   881 

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

   883 

   884 	eap_status_e status(eap_status_process_general_error);

   885 

   886 	{

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

   888 		eap_process_tlv_message_data_c message(m_am_tools);

   889 

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

   891 		{

   892 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   893 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   894 		}

   895 

   896 		status = message.add_parameter_data(eap_tlv_message_type_function_complete_remove_eap_session);

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

   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 = message.add_parameter_data(receive_network_id);

   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 		status = send_message(&message);

   918 		if (status != eap_status_ok)

   919 		{

   920 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   921 			return EAP_STATUS_RETURN(m_am_tools, status);

   922 		}

   923 	}

   924 

   925 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   926 	return EAP_STATUS_RETURN(m_am_tools, status);

   927 }

   928 

   929 //--------------------------------------------------

   930 

   931 //

   932 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::read_configure(

   933 	const eap_configuration_field_c * const field,

   934 	eap_variable_data_c * const data)

   935 {

   936 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   937 

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

   939 

   940 	eap_status_e status = m_am_stack->read_configure(

   941 		field,

   942 		data);

   943 

   944 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   945 	return EAP_STATUS_RETURN(m_am_tools, status);

   946 }

   947 

   948 //--------------------------------------------------

   949 

   950 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::write_configure(

   951 	const eap_configuration_field_c * const /* field */,

   952 	eap_variable_data_c * const /* data */)

   953 {

   954 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   955 

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

   957 

   958 	eap_status_e status(eap_status_process_general_error);

   959 

   960 	EAP_ASSERT_ANYWAY_TOOLS(m_am_tools);

   961 

   962 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   963 	return EAP_STATUS_RETURN(m_am_tools, status);

   964 }

   965 

   966 //--------------------------------------------------

   967 

   968 //

   969 EAP_FUNC_EXPORT void eap_core_server_message_if_c::set_is_valid()

   970 {

   971 	m_is_valid = true;

   972 }

   973 

   974 //--------------------------------------------------

   975 

   976 //

   977 EAP_FUNC_EXPORT bool eap_core_server_message_if_c::get_is_valid()

   978 {

   979 	return m_is_valid;

   980 }

   981 

   982 //--------------------------------------------------

   983 

   984 //

   985 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::timer_expired(

   986 	const u32_t id, void *data)

   987 {

   988 	EAP_UNREFERENCED_PARAMETER(id);

   989 	EAP_UNREFERENCED_PARAMETER(data);

   990 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   991 

   992 	EAP_TRACE_DEBUG(

   993 		m_am_tools,

   994 		EAP_TRACE_FLAGS_MESSAGE_DATA,

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

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

   997 		 this,

   998 		 id,

   999 		 data));

  1000 

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

  1002 

  1003 

  1004 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

  1005 }

  1006 

  1007 //--------------------------------------------------

  1008 

  1009 //

  1010 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::timer_delete_data(

  1011 	const u32_t id, void *data)

  1012 {

  1013 	EAP_UNREFERENCED_PARAMETER(id);

  1014 	EAP_UNREFERENCED_PARAMETER(data);

  1015 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1016 

  1017 	EAP_TRACE_DEBUG(

  1018 		m_am_tools,

  1019 		EAP_TRACE_FLAGS_MESSAGE_DATA,

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

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

  1022 		this, id, data));

  1023 

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

  1025 

  1026 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

  1027 }

  1028 

  1029 //--------------------------------------------------

  1030 

  1031 EAP_FUNC_EXPORT void eap_core_server_message_if_c::state_notification(

  1032 	const abs_eap_state_notification_c * const state)

  1033 {

  1034 	eap_status_e status(eap_status_process_general_error);

  1035 

  1036 	EAP_TRACE_DEBUG(

  1037 		m_am_tools, 

  1038 		EAP_TRACE_FLAGS_MESSAGE_DATA, 

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

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

  1041 

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

  1043 

  1044 	{

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

  1046 		eap_process_tlv_message_data_c message(m_am_tools);

  1047 

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

  1049 		{

  1050 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1051 			(void)EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

  1052 			return;

  1053 		}

  1054 

  1055 		status = message.add_parameter_data(eap_tlv_message_type_function_state_notification);

  1056 		if (status != eap_status_ok)

  1057 		{

  1058 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1059 			(void)EAP_STATUS_RETURN(m_am_tools, status);

  1060 			return;

  1061 		}

  1062 

  1063 		status = message.add_parameter_data(state);

  1064 		if (status != eap_status_ok)

  1065 		{

  1066 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1067 			(void)EAP_STATUS_RETURN(m_am_tools, status);

  1068 			return;

  1069 		}

  1070 

  1071 		status = send_message(&message);

  1072 		if (status != eap_status_ok)

  1073 		{

  1074 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1075 			(void)EAP_STATUS_RETURN(m_am_tools, status);

  1076 			return;

  1077 		}

  1078 	}

  1079 }

  1080 

  1081 //--------------------------------------------------

  1082 

  1083 //

  1084 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::asynchronous_init_remove_eap_session(

  1085 	const eap_am_network_id_c * const /* send_network_id */)

  1086 {

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

  1088 	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);

  1089 }

  1090 

  1091 //--------------------------------------------------

  1092 

  1093 //

  1094 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::asynchronous_start_authentication(

  1095 	const eap_am_network_id_c * const /* receive_network_id */,

  1096 	const bool /* is_client_when_true */)

  1097 {

  1098 	return EAP_STATUS_RETURN(m_am_tools, eap_status_not_supported);

  1099 }

  1100 

  1101 //--------------------------------------------------

  1102 

  1103 //

  1104 EAP_FUNC_EXPORT eap_status_e eap_core_server_message_if_c::restart_authentication(

  1105 	const eap_am_network_id_c * const send_network_id,

  1106 	const bool is_client_when_true,

  1107 	const bool force_clean_restart,

  1108 	const bool from_timer)

  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("%s: eap_core_server_message_if_c::restart_authentication()\n"),

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

  1117 

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

  1119 

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

  1121 

  1122 	eap_status_e status(eap_status_process_general_error);

  1123 

  1124 	{

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

  1126 		eap_process_tlv_message_data_c message(m_am_tools);

  1127 

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

  1129 		{

  1130 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1131 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

  1132 		}

  1133 

  1134 		status = message.add_parameter_data(eap_tlv_message_type_function_restart_authentication);