1 /*

     2 * ============================================================================

     3 *  Name        : ./accesssec/eapol/eapol_framework/wapi_common/src/wapi_session_core.cpp

     4 *  Part of     : WAPI / WAPI       *** Info from the SWAD

     5 *  Description : WAPI authentication

     6 *  Version     : %version: 16.1.1 % << Don't touch! Updated by Synergy at check-out.

     7 *

     8 *  Copyright © 2001-2009 Nokia.  All rights reserved.

     9 *  This material, including documentation and any related computer

    10 *  programs, is protected by copyright controlled by Nokia.  All

    11 *  rights are reserved.  Copying, including reproducing, storing,

    12 *  adapting or translating, any or all of this material requires the

    13 *  prior written consent of Nokia.  This material also contains

    14 *  confidential information which may not be disclosed to others

    15 *  without the prior written consent of Nokia.

    16 * ============================================================================

    17 * Template version: 4.1.1

    18 */

    19 

    20 // This is enumeration of WAPI source code.

    21 #if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

    22 	#undef EAP_FILE_NUMBER_ENUM

    23 	#define EAP_FILE_NUMBER_ENUM 20004

    24 	#undef EAP_FILE_NUMBER_DATE 

    25 	#define EAP_FILE_NUMBER_DATE 1127594498 

    26 #endif //#if defined(USE_EAP_MINIMUM_RELEASE_TRACES)

    27 

    28 

    29 

    30 #include "eap_am_memory.h"

    31 #include "eap_tools.h"

    32 #include "wapi_session_core.h"

    33 #include "eap_state_notification.h"

    34 #include "eap_network_id_selector.h"

    35 #include "abs_eap_am_mutex.h"

    36 #include "eap_config.h"

    37 #include "wapi_core.h"

    38 #include "eap_buffer.h"

    39 #include "eap_automatic_variable.h"

    40 #include "wai_protocol_packet_header.h"

    41 #include "wapi_strings.h"

    42 #include "eapol_session_key.h"

    43 

    44 

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

    46 

    47 // 

    48 EAP_FUNC_EXPORT wapi_session_core_c::~wapi_session_core_c()

    49 {

    50 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

    51 

    52 	EAP_TRACE_DEBUG(

    53 		m_am_tools, 

    54 		TRACE_FLAGS_DEFAULT, 

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

    56 		this,

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

    58 

    59 	EAP_ASSERT(m_shutdown_was_called == true);

    60 

    61 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

    62 }

    63 

    64 //--------------------------------------------------

    65 

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

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

    68 #endif

    69 

    70 // 

    71 EAP_FUNC_EXPORT wapi_session_core_c::wapi_session_core_c(

    72 	abs_eap_am_tools_c * const tools,

    73 	abs_wapi_core_c * const partner,

    74 	const bool is_client_when_true)

    75 : m_partner(partner)

    76 , m_am_tools(tools)

    77 , m_session_map(tools, this)

    78 , m_remove_session_timeout(WAPI_SESSION_CORE_REMOVE_SESSION_TIMEOUT)

    79 , m_is_client(is_client_when_true)

    80 , m_is_valid(false)

    81 , m_use_wapi_session_core_reset_session(true)

    82 , m_shutdown_was_called(false)

    83 {

    84 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

    85 

    86 	EAP_TRACE_DEBUG(

    87 		m_am_tools, 

    88 		TRACE_FLAGS_DEFAULT, 

    89 		(EAPL("wapi_session_core_c::wapi_session_core_c(): this = 0x%08x => 0x%08x.\n"),

    90 		this,

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

    92 

    93 	set_is_valid();

    94 

    95 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

    96 }

    97 

    98 //--------------------------------------------------

    99 

   100 //

   101 EAP_FUNC_EXPORT abs_wapi_core_c * wapi_session_core_c::get_partner()

   102 {

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

   104 

   105 	return m_partner;

   106 }

   107 

   108 //--------------------------------------------------

   109 

   110 //

   111 EAP_FUNC_EXPORT void wapi_session_core_c::set_is_valid()

   112 {

   113 	m_is_valid = true;

   114 }

   115 

   116 //--------------------------------------------------

   117 

   118 //

   119 EAP_FUNC_EXPORT bool wapi_session_core_c::get_is_valid()

   120 {

   121 	return m_is_valid;

   122 }

   123 

   124 //--------------------------------------------------

   125 

   126 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::reset()

   127 {

   128 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   129 

   130 	EAP_TRACE_DEBUG(

   131 		m_am_tools, 

   132 		TRACE_FLAGS_DEFAULT, 

   133 		(EAPL("wapi_session_core_c::reset(): this = 0x%08x => 0x%08x.\n"),

   134 		this,

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

   136 

   137 	eap_status_e status = m_session_map.for_each(shutdown_operation, true);

   138 	(void)EAP_STATUS_RETURN(m_am_tools, status);

   139 

   140 	status = m_session_map.reset();

   141 	(void)EAP_STATUS_RETURN(m_am_tools, status);

   142 

   143 	m_partner->cancel_timer(this, WAPI_SESSION_CORE_REMOVE_SESSION_ID);

   144 

   145 	EAP_TRACE_DEBUG(

   146 		m_am_tools, 

   147 		TRACE_FLAGS_DEFAULT, 

   148 		(EAPL("TIMER: WAPI_SESSION_CORE_REMOVE_SESSION_ID cancelled, %s.\n"),

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

   150 

   151 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   152 	return EAP_STATUS_RETURN(m_am_tools, status);

   153 }

   154 

   155 //--------------------------------------------------

   156 

   157 //

   158 EAP_FUNC_EXPORT wapi_core_c * wapi_session_core_c::create_new_session(

   159 	const eap_am_network_id_c * const receive_network_id)

   160 {

   161 	eap_status_e status = eap_status_process_general_error;

   162 

   163 	// Create a new session.

   164 	wapi_core_c * const session = new wapi_core_c(

   165 		m_am_tools,

   166 		this,

   167 		m_is_client,

   168 		receive_network_id);

   169 

   170 	if (session == 0)

   171 	{

   172 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   173 		(void)EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   174 		return 0;

   175 	}

   176 

   177 	if (session->get_is_valid() == false)

   178 	{

   179 		session->shutdown();

   180 		delete session;

   181 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   182 		(void)EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   183 		return 0;

   184 	}

   185 

   186 	status = session->configure();

   187 	if (status != eap_status_ok)

   188 	{

   189 		session->shutdown();

   190 		delete session;

   191 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   192 		(void)EAP_STATUS_RETURN(m_am_tools, status);

   193 		return 0;

   194 	}

   195 

   196 	// Here we swap the addresses.

   197 	eap_am_network_id_c send_network_id(m_am_tools,

   198 		receive_network_id->get_destination_id(),

   199 		receive_network_id->get_source_id(),

   200 		receive_network_id->get_type());

   201 	if (send_network_id.get_is_valid_data() == false)

   202 	{

   203 		session->shutdown();

   204 		delete session;

   205 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   206 		(void)EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   207 		return 0;

   208 	}

   209 

   210 	eap_network_id_selector_c selector(

   211 		m_am_tools,

   212 		&send_network_id);

   213 	if (selector.get_is_valid() == false)

   214 	{

   215 		session->shutdown();

   216 		delete session;

   217 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   218 		(void)EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   219 		return 0;

   220 	}

   221 

   222 	EAP_TRACE_DATA_DEBUG(

   223 		m_am_tools,

   224 		TRACE_FLAGS_DEFAULT,

   225 		(EAPL("create_new_session() WAPI session"),

   226 		 selector.get_data(selector.get_data_length()),

   227 		 selector.get_data_length()));

   228 

   229 	status = m_session_map.add_handler(&selector, session);

   230 	if (status != eap_status_ok)

   231 	{

   232 		session->shutdown();

   233 		delete session;

   234 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   235 		(void)EAP_STATUS_RETURN(m_am_tools, status);

   236 		return 0;

   237 	}

   238 

   239 	return session;

   240 }

   241 

   242 //--------------------------------------------------

   243 

   244 //

   245 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::reset_or_remove_session(

   246 	wapi_core_c ** const session,

   247 	const eap_network_id_selector_c * const selector,

   248 	const bool reset_immediately)

   249 {

   250 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   251 

   252 	eap_status_e status(eap_status_process_general_error);

   253 

   254 	if (session == 0

   255 		|| *session == 0

   256 		|| selector == 0)

   257 	{

   258 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   259 		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

   260 	}

   261 

   262 

   263 	if (m_use_wapi_session_core_reset_session == true)

   264 	{

   265 		// This will reuse session.

   266 		EAP_TRACE_DEBUG(

   267 			m_am_tools, 

   268 			TRACE_FLAGS_DEFAULT, 

   269 			(EAPL("wapi_session_core_c::reset_or_remove_session(): resets session, session 0x%08x.\n"),

   270 			(*session)));

   271 

   272 		// NOTE, this delayed reset of session is used bacause the device is so slow in some cases

   273 		// (e.g. it cannot respond to WPA 4-Way Handshake message fast enough)

   274 

   275 		if (reset_immediately == true)

   276 		{

   277 			(*session)->unset_marked_removed();

   278 

   279 			status = (*session)->reset();

   280 		}

   281 		else

   282 		{

   283 			// This will delay reset to wapi_core_c::packet_process().

   284 			status = eap_status_ok;

   285 		}

   286 	}

   287 	else

   288 	{

   289 		//  This will cause shutdown of the session.

   290 		status = eap_status_process_general_error;

   291 	}

   292 

   293 	if (status != eap_status_ok)

   294 	{

   295 		// We cannot reuse the session.

   296 

   297 		EAP_TRACE_DEBUG(

   298 			m_am_tools, 

   299 			TRACE_FLAGS_DEFAULT, 

   300 			(EAPL("wapi_session_core_c::reset_or_remove_session(): shutdown session, session 0x%08x.\n"),

   301 			(*session)));

   302 

   303 		(*session)->shutdown();

   304 		(*session) = 0;

   305 

   306 		status = m_session_map.remove_handler(selector, true);

   307 		if (status != eap_status_ok)

   308 		{

   309 			EAP_TRACE_DEBUG(

   310 				m_am_tools, 

   311 				TRACE_FLAGS_DEFAULT, 

   312 				(EAPL("ERROR: wapi_session_core_c::reset_or_remove_session(): m_session_map.remove_type(), eap_status_e %d\n"),

   313 				status));

   314 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   315 			return EAP_STATUS_RETURN(m_am_tools, status);

   316 		}

   317 

   318 		EAP_TRACE_DEBUG(

   319 			m_am_tools, 

   320 			TRACE_FLAGS_DEFAULT, 

   321 			(EAPL("wapi_session_core_c::reset_or_remove_session(): session NOT reused.\n")));

   322 	}

   323 	else

   324 	{

   325 		EAP_TRACE_DEBUG(

   326 			m_am_tools, 

   327 			TRACE_FLAGS_DEFAULT, 

   328 			(EAPL("wapi_session_core_c::reset_or_remove_session(): session reused, session 0x%08x.\n"),

   329 			(*session)));

   330 	}

   331 

   332 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   333 	return EAP_STATUS_RETURN(m_am_tools, status);

   334 }

   335 

   336 //--------------------------------------------------

   337 

   338 //

   339 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::packet_process(

   340 	const eap_am_network_id_c * const receive_network_id,

   341 	eap_general_header_base_c * const packet_data,

   342 	const u32_t packet_length)

   343 {

   344 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   345 

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

   347 

   348 	eap_status_e status = eap_status_process_general_error;

   349 

   350 	// Each WAPI authentication session includes its own wapi_core_c object.

   351 	// WAPI authentication sessions are separated by eap_am_network_id_c object.

   352 

   353 	if (packet_data == 0

   354 		|| packet_length < eap_header_base_c::get_header_length())

   355 	{

   356 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   357 		return EAP_STATUS_RETURN(m_am_tools, eap_status_process_illegal_packet_error);

   358 	}

   359 

   360 	if (receive_network_id == 0

   361 		|| receive_network_id->get_is_valid_data() == false)

   362 	{

   363 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   364 		return EAP_STATUS_RETURN(m_am_tools, eap_status_illegal_parameter);

   365 	}

   366 

   367 	wai_protocol_packet_header_c wai(

   368 		m_am_tools,

   369 		packet_data->get_header_buffer(packet_length),

   370 		packet_length);

   371 

   372 	if (wai.get_is_valid() == false)

   373 	{

   374 		EAP_TRACE_ERROR(

   375 			m_am_tools, 

   376 			TRACE_FLAGS_DEFAULT, 

   377 			(EAPL("wapi_session_core_c::packet_process(): %s, packet buffer corrupted.\n"),

   378 			 (m_is_client == true) ? "client": "server"

   379 			 ));

   380 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   381 		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);

   382 	}

   383 

   384 	EAP_TRACE_DATA_DEBUG(

   385 		m_am_tools, 

   386 		EAP_TRACE_FLAGS_MESSAGE_DATA|TRACE_TEST_VECTORS, 

   387 		(EAPL("WAI-packet"),

   388 		 wai.get_header_buffer(packet_length),

   389 		 packet_length));

   390 

   391 	WAI_PROTOCOL_PACKET_TRACE_HEADER("->", &wai, m_is_client);

   392 

   393 	status = wai.check_header();

   394 	if (status != eap_status_ok)

   395 	{

   396 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   397 		return EAP_STATUS_RETURN(m_am_tools, status);

   398 	}

   399 

   400 	// Here we swap the addresses.

   401 	eap_am_network_id_c send_network_id(m_am_tools,

   402 		receive_network_id->get_destination_id(),

   403 		receive_network_id->get_source_id(),

   404 		receive_network_id->get_type());

   405 	if (send_network_id.get_is_valid_data() == false)

   406 	{

   407 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   408 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   409 	}

   410 

   411 	eap_network_id_selector_c selector(

   412 		m_am_tools,

   413 		&send_network_id);

   414 	if (selector.get_is_valid() == false)

   415 	{

   416 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   417 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   418 	}

   419 

   420 	EAP_TRACE_DATA_DEBUG(

   421 		m_am_tools,

   422 		TRACE_FLAGS_DEFAULT,

   423 		(EAPL("packet_process() WAPI-session"),

   424 		 selector.get_data(selector.get_data_length()),

   425 		 selector.get_data_length()));

   426 

   427 	wapi_core_c *session = m_session_map.get_handler(&selector);

   428 

   429 	if (session == 0)

   430 	{

   431 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   432 		return EAP_STATUS_RETURN(m_am_tools, eap_status_handler_does_not_exists_error);

   433 	}

   434 

   435 	if (session != 0)

   436 	{

   437 		status = session->packet_process(

   438 			receive_network_id,

   439 			&wai,

   440 			packet_length);

   441 	}

   442 	else

   443 	{

   444 		status = eap_status_illegal_eap_type;

   445 	}

   446 

   447 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   448 	return EAP_STATUS_RETURN(m_am_tools, status);

   449 }

   450 

   451 //--------------------------------------------------

   452 

   453 //

   454 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::packet_send(

   455 	const eap_am_network_id_c * const send_network_id,

   456 	eap_buf_chain_wr_c * const sent_packet,

   457 	const u32_t header_offset,

   458 	const u32_t data_length,

   459 	const u32_t buffer_length)

   460 {

   461 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   462 

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

   464 

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

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

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

   468 

   469 	wai_protocol_packet_header_c wai(

   470 		m_am_tools,

   471 		sent_packet->get_data_offset(header_offset, data_length),

   472 		data_length);

   473 

   474 	if (wai.get_is_valid() == false)

   475 	{

   476 		EAP_TRACE_ERROR(

   477 			m_am_tools, 

   478 			TRACE_FLAGS_DEFAULT, 

   479 			(EAPL("wapi_session_core_c::packet_process(): %s, packet buffer corrupted.\n"),

   480 			 (m_is_client == true) ? "client": "server"

   481 			 ));

   482 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   483 		return EAP_STATUS_RETURN(m_am_tools, eap_status_header_corrupted);

   484 	}

   485 

   486 	EAP_TRACE_DATA_DEBUG(

   487 		m_am_tools, 

   488 		EAP_TRACE_FLAGS_MESSAGE_DATA|TRACE_TEST_VECTORS, 

   489 		(EAPL("WAI-packet"),

   490 		 wai.get_header_buffer(data_length),

   491 		 data_length));

   492 

   493 	WAI_PROTOCOL_PACKET_TRACE_HEADER("<-", &wai, m_is_client);

   494 

   495 	eap_status_e status = m_partner->packet_send(

   496 		send_network_id, sent_packet, header_offset, data_length, buffer_length);

   497 

   498 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   499 	return EAP_STATUS_RETURN(m_am_tools, status);

   500 }

   501 

   502 //--------------------------------------------------

   503 

   504 //

   505 EAP_FUNC_EXPORT u32_t wapi_session_core_c::get_header_offset(

   506 	u32_t * const MTU,

   507 	u32_t * const trailer_length)

   508 {

   509 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   510 

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

   512 

   513 	const u32_t offset = m_partner->get_header_offset(MTU, trailer_length);

   514 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   515 	return offset;

   516 }

   517 

   518 //--------------------------------------------------

   519 

   520 //

   521 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::configure()

   522 {

   523 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   524 

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

   526 

   527 

   528 	{

   529 		// This is optional.

   530 		eap_variable_data_c data(m_am_tools);

   531 

   532 		eap_status_e status = m_partner->read_configure(

   533 			cf_str_EAP_SESSION_use_reset_session.get_field(),

   534 			&data);

   535 		if (status == eap_status_ok

   536 			&& data.get_data_length() == sizeof(u32_t)

   537 			&& data.get_data(data.get_data_length()) != 0)

   538 		{

   539 			u32_t *flag = reinterpret_cast<u32_t *>(data.get_data(data.get_data_length()));

   540 

   541 			if (flag != 0)

   542 			{

   543 				if ((*flag) != 0ul)

   544 				{

   545 					m_use_wapi_session_core_reset_session = true;

   546 				}

   547 				else

   548 				{

   549 					m_use_wapi_session_core_reset_session = false;

   550 				}

   551 			}

   552 		}

   553 	}

   554 

   555 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   556 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   557 }

   558 

   559 //--------------------------------------------------

   560 

   561 //

   562 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::shutdown_operation(

   563 	wapi_core_c * const core,

   564 	abs_eap_am_tools_c * const m_am_tools)

   565 {

   566 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   567 

   568 	EAP_UNREFERENCED_PARAMETER(m_am_tools);

   569 

   570 	eap_status_e status = core->shutdown();

   571 

   572 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   573 	return EAP_STATUS_RETURN(m_am_tools, status);

   574 }

   575 

   576 //--------------------------------------------------

   577 

   578 //

   579 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::shutdown()

   580 {

   581 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   582 

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

   584 

   585 	EAP_TRACE_DEBUG(

   586 		m_am_tools, 

   587 		TRACE_FLAGS_DEFAULT, 

   588 		(EAPL("wapi_session_core_c::shutdown(): this = 0x%08x => 0x%08x.\n"),

   589 		this,

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

   591 

   592 	if (m_shutdown_was_called == true)

   593 	{

   594 		// Shutdown function was called already.

   595 		return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   596 	}

   597 	m_shutdown_was_called = true;

   598 

   599 	eap_status_e status = reset();

   600 

   601 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   602 	return EAP_STATUS_RETURN(m_am_tools, status);

   603 }

   604 

   605 //--------------------------------------------------

   606 

   607 //

   608 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::restart_authentication(

   609 	const eap_am_network_id_c * const send_network_id,

   610 	const bool is_client_when_true)

   611 {

   612 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   613 

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

   615 	EAP_ASSERT(is_client_when_true == m_is_client);

   616 

   617 	eap_status_e status = eap_status_process_general_error;

   618 

   619 	eap_network_id_selector_c selector(

   620 		m_am_tools,

   621 		send_network_id);

   622 	if (selector.get_is_valid() == false)

   623 	{

   624 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   625 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   626 	}

   627 

   628 	EAP_TRACE_DATA_DEBUG(

   629 		m_am_tools,

   630 		TRACE_FLAGS_DEFAULT,

   631 		(EAPL("restart_authentication() WAPI session"),

   632 		 selector.get_data(selector.get_data_length()),

   633 		 selector.get_data_length()));

   634 

   635 	wapi_core_c *session = m_session_map.get_handler(&selector);

   636 

   637 	if (session != 0)

   638 	{

   639 		status = session->restart_authentication(

   640 			send_network_id,

   641 			is_client_when_true);

   642 	}

   643 

   644 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   645 	return EAP_STATUS_RETURN(m_am_tools, status);

   646 }

   647 

   648 //--------------------------------------------------

   649 

   650 //

   651 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::restart_authentication(

   652 	const eap_am_network_id_c * const receive_network_id,

   653 	const bool is_client_when_true,

   654 	const bool force_clean_restart,

   655 	const bool from_timer)

   656 {

   657 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   658 

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

   660 	EAP_ASSERT(is_client_when_true == m_is_client);

   661 

   662 	eap_status_e status = eap_status_process_general_error;

   663 

   664 	// Here we swap the addresses.

   665 	eap_am_network_id_c send_network_id(m_am_tools,

   666 		receive_network_id->get_destination_id(),

   667 		receive_network_id->get_source_id(),

   668 		receive_network_id->get_type());

   669 	if (send_network_id.get_is_valid_data() == false)

   670 	{

   671 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   672 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   673 	}

   674 

   675 	eap_network_id_selector_c selector(

   676 		m_am_tools,

   677 		&send_network_id);

   678 	if (selector.get_is_valid() == false)

   679 	{

   680 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   681 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   682 	}

   683 

   684 	EAP_TRACE_DATA_DEBUG(

   685 		m_am_tools,

   686 		TRACE_FLAGS_DEFAULT,

   687 		(EAPL("restart_authentication() WAPI session"),

   688 		 selector.get_data(selector.get_data_length()),

   689 		 selector.get_data_length()));

   690 

   691 	wapi_core_c *session = m_session_map.get_handler(&selector);

   692 

   693 	if (session == 0)

   694 	{

   695 		// Create a new session.

   696 		session = create_new_session(receive_network_id);

   697 	}

   698 

   699 	if (session != 0)

   700 	{

   701 		status = session->restart_authentication(

   702 			receive_network_id,

   703 			is_client_when_true);

   704 	}

   705 

   706 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   707 	return EAP_STATUS_RETURN(m_am_tools, status);

   708 }

   709 

   710 //--------------------------------------------------

   711 

   712 //

   713 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::packet_data_session_key(

   714 	const eap_am_network_id_c * const send_network_id,

   715 	const eapol_session_key_c * const key)

   716 {

   717 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   718 

   719 	EAP_TRACE_DEBUG(

   720 		m_am_tools,

   721 		TRACE_FLAGS_DEFAULT,

   722 		(EAPL("%s: wapi_session_core_c::packet_data_session_key()\n"),

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

   724 

   725 	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: wapi_session_core_c::packet_data_session_key()");

   726 

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

   728 

   729 	eap_status_e status = eap_status_process_general_error;

   730 

   731 	if (key->get_is_valid() == true)

   732 	{

   733 		EAP_TRACE_DEBUG(

   734 			m_am_tools,

   735 			TRACE_FLAGS_DEFAULT,

   736 			(EAPL("eapol session key: type 0x%02x, index 0x%02x, tx %d\n"),

   737 			 key->get_key_type(),

   738 			 key->get_key_index(),

   739 			 key->get_key_tx_bit()));

   740 

   741 		EAP_TRACE_DATA_DEBUG(

   742 			m_am_tools,

   743 			TRACE_FLAGS_DEFAULT,

   744 			(EAPL("eapol session key"),

   745 			 key->get_key()->get_data(key->get_key()->get_data_length()),

   746 			 key->get_key()->get_data_length()));

   747 	}

   748 

   749 	// Forward the keys to lower layers

   750 	status = m_partner->packet_data_session_key(

   751 			send_network_id,

   752 			key);

   753 

   754 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   755 	return EAP_STATUS_RETURN(m_am_tools, status);

   756 }

   757 

   758 //--------------------------------------------------

   759 

   760 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::read_configure(

   761 	const eap_configuration_field_c * const field,

   762 	eap_variable_data_c * const data)

   763 {

   764 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   765 

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

   767 

   768 	const eap_status_e status = m_partner->read_configure(field, data);

   769 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   770 	return EAP_STATUS_RETURN(m_am_tools, status);

   771 }

   772 

   773 //--------------------------------------------------

   774 

   775 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::write_configure(

   776 	const eap_configuration_field_c * const field,

   777 	eap_variable_data_c * const data)

   778 {

   779 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   780 

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

   782 

   783 	const eap_status_e status = m_partner->write_configure(field, data);

   784 

   785 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   786 	return EAP_STATUS_RETURN(m_am_tools, status);

   787 }

   788 

   789 //--------------------------------------------------

   790 

   791 //

   792 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::timer_expired(

   793 	const u32_t id, void *data)

   794 {

   795 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   796 

   797 	EAP_TRACE_DEBUG(

   798 		m_am_tools, 

   799 		TRACE_FLAGS_DEFAULT, 

   800 		(EAPL("TIMER: [0x%08x]->wapi_session_core_c::")

   801 		 EAPL("timer_expired(id 0x%02x, data 0x%08x), %s.\n"),

   802 		 this,

   803 		 id,

   804 		 data,

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

   806 

   807 	if (id == WAPI_SESSION_CORE_REMOVE_SESSION_ID)

   808 	{

   809 		EAP_TRACE_DEBUG(

   810 			m_am_tools, 

   811 			TRACE_FLAGS_DEFAULT, 

   812 			(EAPL("TIMER: WAPI_SESSION_CORE_REMOVE_SESSION_ID elapsed, %s.\n"),

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

   814 

   815 		const eap_network_id_selector_c * const selector 

   816 			= reinterpret_cast<const eap_network_id_selector_c *>(data);

   817 		if (selector == 0

   818 			|| selector->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 		EAP_TRACE_DATA_DEBUG(

   825 			m_am_tools,

   826 			TRACE_FLAGS_DEFAULT,

   827 			(EAPL("timer_expired() WAPI-session"),

   828 			 selector->get_data(selector->get_data_length()),

   829 			 selector->get_data_length()));

   830 

   831 		wapi_core_c *session = m_session_map.get_handler(selector);

   832 

   833 		if (session != 0

   834 			&& session->get_marked_removed() == true)

   835 		{

   836 			EAP_TRACE_DEBUG(

   837 				m_am_tools, 

   838 				TRACE_FLAGS_DEFAULT, 

   839 				(EAPL("TIMER: unused session found, it is deleted, session 0x%08x.\n"),

   840 				session));

   841 

   842 			// Session must be deleted here.

   843 			session->shutdown();

   844 			session = 0;

   845 

   846 			// This will delete session.

   847 			eap_status_e status = m_session_map.remove_handler(selector, true);

   848 			if (status != eap_status_ok)

   849 			{

   850 				EAP_TRACE_DEBUG(

   851 					m_am_tools, 

   852 					TRACE_FLAGS_DEFAULT, 

   853 					(EAPL("ERROR: m_session_map.remove_type(), eap_status_e %d\n"),

   854 					 status));

   855 				EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   856 				return EAP_STATUS_RETURN(m_am_tools, status);

   857 			}

   858 		}

   859 		else if (session != 0

   860 			&& session->get_marked_removed() == false)

   861 		{

   862 			EAP_TRACE_DEBUG(

   863 				m_am_tools, 

   864 				TRACE_FLAGS_DEFAULT, 

   865 				(EAPL("TIMER: session found, it is in use, session 0x%08x.\n"),

   866 				session));

   867 		}

   868 		else

   869 		{

   870 			// Not found, no need to remove.

   871 			EAP_TRACE_DEBUG(

   872 				m_am_tools, 

   873 				TRACE_FLAGS_DEFAULT, 

   874 				(EAPL("TIMER: session not found.\n")));

   875 		}

   876 	}

   877 

   878 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   879 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   880 }

   881 

   882 //--------------------------------------------------

   883 

   884 //

   885 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::timer_delete_data(

   886 	const u32_t id, void *data)

   887 {

   888 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   889 

   890 	EAP_TRACE_DEBUG(

   891 		m_am_tools, 

   892 		TRACE_FLAGS_DEFAULT, 

   893 		(EAPL("TIMER: [0x%08x]->wapi_session_core_c::")

   894 		 EAPL("timer_delete_data(id 0x%02x, data 0x%08x).\n"),

   895 		this, id, data));

   896 

   897 	if (id == WAPI_SESSION_CORE_REMOVE_SESSION_ID)

   898 

   899 	{

   900 		const eap_network_id_selector_c * const selector 

   901 			= reinterpret_cast<const eap_network_id_selector_c *>(data);

   902 		delete selector;

   903 	}

   904 

   905 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   906 	return EAP_STATUS_RETURN(m_am_tools, eap_status_ok);

   907 }

   908 

   909 //--------------------------------------------------

   910 

   911 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::synchronous_cancel_all_wapi_sessions()

   912 {

   913 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   914 

   915 	EAP_TRACE_DEBUG(

   916 		m_am_tools, 

   917 		TRACE_FLAGS_DEFAULT, 

   918 		(EAPL("wapi_session_core_c::synchronous_cancel_all_wapi_sessions(): this = 0x%08x => 0x%08x.\n"),

   919 		this,

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

   921 

   922 	eap_status_e status = reset();

   923 

   924 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   925 	return EAP_STATUS_RETURN(m_am_tools, status);

   926 }

   927 

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

   929 

   930 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::synchronous_create_wapi_session(

   931 	const eap_am_network_id_c * const receive_network_id)

   932 {

   933 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   934 

   935 	EAP_TRACE_DEBUG(

   936 		m_am_tools, 

   937 		TRACE_FLAGS_DEFAULT, 

   938 		(EAPL("wapi_session_core_c::synchronous_create_wapi_session(): this = 0x%08x => 0x%08x.\n"),

   939 		this,

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

   941 

   942 	eap_status_e status = eap_status_process_general_error;

   943 

   944 	// Here we swap the addresses.

   945 	eap_am_network_id_c send_network_id(

   946 		m_am_tools,

   947 		receive_network_id->get_destination_id(),

   948 		receive_network_id->get_source_id(),

   949 		receive_network_id->get_type());

   950 	if (send_network_id.get_is_valid_data() == false)

   951 	{

   952 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   953 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   954 	}

   955 

   956 	eap_network_id_selector_c selector(

   957 		m_am_tools,

   958 		&send_network_id);

   959 	if (selector.get_is_valid() == false)

   960 	{

   961 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   962 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   963 	}

   964 

   965 	EAP_TRACE_DATA_DEBUG(

   966 		m_am_tools,

   967 		TRACE_FLAGS_DEFAULT,

   968 		(EAPL("synchronous_create_eap_session() WAPI-session"),

   969 		 selector.get_data(selector.get_data_length()),

   970 		 selector.get_data_length()));

   971 

   972 	wapi_core_c *session = m_session_map.get_handler(&selector);

   973 

   974 	if (session == 0)

   975 	{

   976 		session = create_new_session(receive_network_id);

   977 

   978 		if (session == 0)

   979 		{

   980 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   981 			return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

   982 		}

   983 		else

   984 		{

   985 			status = eap_status_ok;

   986 		}

   987 	}

   988 	else

   989 	{

   990 		status = eap_status_ok;

   991 	}

   992 

   993 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   994 	return EAP_STATUS_RETURN(m_am_tools, status);

   995 }

   996 

   997 //--------------------------------------------------

   998 

   999 EAP_FUNC_EXPORT eap_status_e wapi_session_core_c::synchronous_remove_wapi_session(

  1000 	const eap_am_network_id_c * const receive_network_id)

  1001 {

  1002 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1003 

  1004 	EAP_TRACE_DEBUG(

  1005 		m_am_tools, 

  1006 		TRACE_FLAGS_DEFAULT, 

  1007 		(EAPL("wapi_session_core_c::synchronous_remove_eap_session(): this = 0x%08x => 0x%08x.\n"),

  1008 		this,

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

  1010 

  1011 	eap_status_e status = eap_status_process_general_error;

  1012 

  1013 	// Here we swap the addresses.

  1014 	eap_am_network_id_c send_network_id(

  1015 		m_am_tools,

  1016 		receive_network_id->get_destination_id(),

  1017 		receive_network_id->get_source_id(),

  1018 		receive_network_id->get_type());

  1019 	if (send_network_id.get_is_valid_data() == false)

  1020 	{

  1021 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1022 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

  1023 	}

  1024 

  1025 	eap_network_id_selector_c selector(

  1026 		m_am_tools,

  1027 		&send_network_id);

  1028 	if (selector.get_is_valid() == false)

  1029 	{

  1030 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1031 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

  1032 	}

  1033 

  1034 	EAP_TRACE_DATA_DEBUG(

  1035 		m_am_tools,

  1036 		TRACE_FLAGS_DEFAULT,

  1037 		(EAPL("synchronous_remove_eap_session() WAPI-session"),

  1038 		 selector.get_data(selector.get_data_length()),

  1039 		 selector.get_data_length()));

  1040 

  1041 	wapi_core_c *session = m_session_map.get_handler(&selector);

  1042 

  1043 	if (session != 0)

  1044 	{

  1045 		// This reset is immediaete.

  1046 		status = reset_or_remove_session(

  1047 			&session,

  1048 			&selector,

  1049 			true);

  1050 		if (status != eap_status_ok)

  1051 		{

  1052 			EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1053 			return EAP_STATUS_RETURN(m_am_tools, status);

  1054 		}

  1055 	}

  1056 	else

  1057 	{

  1058 		// Not found, no need to remove.

  1059 		status = eap_status_ok;

  1060 	}

  1061 

  1062 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1063 	return EAP_STATUS_RETURN(m_am_tools, status);

  1064 }

  1065 

  1066 //--------------------------------------------------

  1067 

  1068 //

  1069 eap_status_e wapi_session_core_c::asynchronous_init_remove_wapi_session(

  1070 	const eap_am_network_id_c * const send_network_id)

  1071 {

  1072 	EAP_TRACE_DEBUG(

  1073 		m_am_tools, 

  1074 		TRACE_FLAGS_DEFAULT, 

  1075 		(EAPL("wapi_session_core_c::asynchronous_init_remove_wapi_session(): %s.\n"),

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

  1077 

  1078 	eap_network_id_selector_c state_selector(

  1079 		m_am_tools,

  1080 		send_network_id);

  1081 	if (state_selector.get_is_valid() == false)

  1082 	{

  1083 		EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1084 		return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);

  1085 	}

  1086 

  1087 	EAP_TRACE_DATA_DEBUG(

  1088 		m_am_tools,

  1089 		TRACE_FLAGS_DEFAULT,

  1090 		(EAPL("asynchronous_init_remove_wapi_session() WAPI session"),

  1091 		 state_selector.get_data(state_selector.get_data_length()),

  1092 		 state_selector.get_data_length()));

  1093 

  1094 	eap_status_e status = asynchronous_init_remove_wapi_session(

  1095 		&state_selector);

  1096 

  1097 	return EAP_STATUS_RETURN(m_am_tools, status);

  1098 }

  1099 

  1100 //--------------------------------------------------

  1101 

  1102 //

  1103 eap_status_e wapi_session_core_c::asynchronous_init_remove_wapi_session(

  1104 	const eap_network_id_selector_c * const state_selector)

  1105 {

  1106 	EAP_TRACE_DEBUG(

  1107 		m_am_tools, 

  1108 		TRACE_FLAGS_DEFAULT, 

  1109 		(EAPL("wapi_session_core_c::asynchronous_init_remove_wapi_session(): %s.\n"),

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

  1111 

  1112 	// NOTE: we cannot call directly synchronous_remove_wapi_session(), because we will

  1113 	// return from here to removed object.

  1114 

  1115 	eap_status_e status = eap_status_process_general_error;

  1116 

  1117 	EAP_TRACE_DATA_DEBUG(

  1118 		m_am_tools,

  1119 		TRACE_FLAGS_DEFAULT,

  1120 		(EAPL("asynchronous_init_remove_wapi_session() WAPI session"),

  1121 		 state_selector->get_data(state_selector->get_data_length()),

  1122 		 state_selector->get_data_length()));

  1123 

  1124 	wapi_core_c *session = m_session_map.get_handler(state_selector);

  1125 

  1126 	if (session != 0)

  1127 	{

  1128 		session->set_marked_removed();

  1129 

  1130 		// So we initiate a timer to remove session identified by state_selector.

  1131 		eap_network_id_selector_c * const copy_selector = state_selector->copy();

  1132 		if (copy_selector == 0

  1133 			|| copy_selector->get_is_valid() == false)

  1134 		{