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

    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 716 

    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 "dummy_eap_core.h"

    35 #include "eap_core_nak_info.h"

    36 #include "eap_state_notification.h"

    37 #include "eap_network_id_selector.h"

    38 #include "eap_buffer.h"

    39 #include "eap_header_string.h"

    40 #include "eap_automatic_variable.h"

    41 

    42 

    43 //--------------------------------------------------

    44 

    45 // 

    46 EAP_FUNC_EXPORT dummy_eap_core_c::~dummy_eap_core_c()

    47 {

    48 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

    49 

    50 	EAP_TRACE_DEBUG(

    51 		m_am_tools,

    52 		TRACE_FLAGS_DEFAULT,

    53 		(EAPL("dummy_eap_core_c::~dummy_eap_core_c: ")

    54 		 EAPL("this = 0x%08x\n"),

    55 		 this));

    56 

    57 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

    58 }

    59 

    60 //--------------------------------------------------

    61 

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

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

    64 #endif

    65 

    66 // 

    67 EAP_FUNC_EXPORT dummy_eap_core_c::dummy_eap_core_c(

    68 	abs_eap_am_tools_c * const tools,

    69 	abs_eap_core_c * const partner,

    70 	const bool is_client_when_true,

    71 	const eap_am_network_id_c * const /* receive_network_id */,

    72 	const bool is_tunneled_eap)

    73 	: m_partner(partner)

    74 	, m_am_tools(tools)

    75 	, m_type_map(tools, this)

    76 	, m_current_eap_type(eap_type_none)

    77 	, m_default_eap_type(eap_type_none)

    78 	, m_eap_identity(tools)

    79 	, m_eap_header_offset(0u)

    80 	, m_MTU(0u)

    81 	, m_trailer_length(0u)

    82 	, m_receive_network_id(tools)

    83 	, m_retransmission(0)

    84 	, m_retransmission_time(EAP_CORE_RETRANSMISSION_TIME)

    85 	, m_retransmission_counter(EAP_CORE_RETRANSMISSION_COUNTER)

    86 	, m_session_timeout(EAP_CORE_SESSION_TIMEOUT)

    87 	, m_eap_core_failure_received_timeout(EAP_CORE_FAILURE_RECEIVED_TIMEOUT)

    88 	, m_remove_session_timeout(EAP_CORE_REMOVE_SESSION_TIMEOUT)

    89 #if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

    90 	, m_wait_eap_request_type_timeout(EAP_CORE_WAIT_EAP_REQUEST_TYPE_TIMEOUT)

    91 	, m_wait_eap_request_type_timeout_set(false)

    92 #endif //#if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

    93 	, m_eap_identity_request_identifier_client(0)

    94 	, m_is_client(is_client_when_true)

    95 	, m_is_client_role(is_client_when_true)

    96 	, m_is_valid(false)

    97 	, m_client_restart_authentication_initiated(false)

    98 	, m_marked_removed(false)

    99 	, m_eap_identity_response_accepted(false)

   100 	, m_shutdown_was_called(false)

   101 	, m_eap_type_response_sent(false)

   102 	, m_is_tunneled_eap(is_tunneled_eap)

   103 #if defined(USE_EAP_CORE_SERVER)

   104 	, m_process_eap_nak_immediately(EAP_CORE_PROCESS_EAP_NAK_IMMEDIATELY)

   105 	, m_nak_process_timer_active(false)

   106 	, m_eap_identity_request_send(false)

   107 	, m_eap_identity_response_received(false)

   108 	, m_eap_failure_sent(false)

   109 	, m_send_eap_success_after_notification(false)

   110 #if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

   111 	, m_skip_eap_request_identity(false)

   112 #endif //#if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

   113 #endif //#if defined(USE_EAP_CORE_SERVER)

   114 	, m_use_eap_expanded_type(false)

   115 	, m_ignore_eap_failure(false)

   116 	, m_ignore_notifications(false)

   117 {

   118 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   119 

   120 	EAP_TRACE_DEBUG(

   121 		m_am_tools,

   122 		TRACE_FLAGS_DEFAULT,

   123 		(EAPL("ummy_eap_core_c::dummy_eap_core_c: ")

   124 		 EAPL("this = 0x%08x\n"),

   125 		 this));

   126 

   127 	set_is_valid();

   128 

   129 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   130 }

   131 

   132 //--------------------------------------------------

   133 

   134 //

   135 EAP_FUNC_EXPORT abs_eap_core_c * dummy_eap_core_c::get_partner()

   136 {

   137 

   138 	return m_partner;

   139 }

   140 

   141 //--------------------------------------------------

   142 

   143 //

   144 EAP_FUNC_EXPORT void dummy_eap_core_c::set_partner(abs_eap_core_c * const partner)

   145 {

   146 

   147 	m_partner = partner;

   148 }

   149 

   150 //--------------------------------------------------

   151 

   152 //

   153 EAP_FUNC_EXPORT void dummy_eap_core_c::set_is_valid()

   154 {

   155 	m_is_valid = true;

   156 }

   157 

   158 //--------------------------------------------------

   159 

   160 //

   161 EAP_FUNC_EXPORT bool dummy_eap_core_c::get_is_valid()

   162 {

   163 	return m_is_valid;

   164 }

   165 

   166 //--------------------------------------------------

   167 

   168 //

   169 EAP_FUNC_EXPORT void dummy_eap_core_c::object_increase_reference_count()

   170 {

   171 }

   172 

   173 //--------------------------------------------------

   174 

   175 //

   176 EAP_FUNC_EXPORT u32_t dummy_eap_core_c::object_decrease_reference_count()

   177 {

   178 	return 0u;

   179 }

   180 

   181 //--------------------------------------------------

   182 

   183 //

   184 EAP_FUNC_EXPORT bool dummy_eap_core_c::get_marked_removed()

   185 {

   186 	return false;

   187 }

   188 

   189 //--------------------------------------------------

   190 

   191 //

   192 EAP_FUNC_EXPORT void dummy_eap_core_c::set_marked_removed()

   193 {

   194 }

   195 

   196 //--------------------------------------------------

   197 

   198 //

   199 EAP_FUNC_EXPORT void dummy_eap_core_c::unset_marked_removed()

   200 {

   201 }

   202 

   203 

   204 //--------------------------------------------------

   205 

   206 //

   207 EAP_FUNC_EXPORT void dummy_eap_core_c::ignore_notifications()

   208 {

   209 }

   210 

   211 //--------------------------------------------------

   212 

   213 //

   214 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::initialize_asynchronous_init_remove_eap_session(

   215 	const u32_t /* remove_session_timeout */)

   216 {

   217 	EAP_TRACE_DEBUG(

   218 		m_am_tools, 

   219 		TRACE_FLAGS_DEFAULT, 

   220 		(EAPL("dummy_eap_core_c::initialize_asynchronous_init_remove_eap_session(): %s.\n"),

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

   222 

   223 	eap_status_e status = eap_status_process_general_error;

   224 

   225 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   226 	return EAP_STATUS_RETURN(m_am_tools, status);

   227 }

   228 

   229 //--------------------------------------------------

   230 

   231 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::cancel_asynchronous_init_remove_eap_session()

   232 {

   233 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   234 

   235 		eap_status_e status = eap_status_process_general_error;

   236 

   237 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   238 	return EAP_STATUS_RETURN(m_am_tools, status);

   239 }

   240 

   241 //--------------------------------------------------

   242 

   243 //

   244 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::asynchronous_init_remove_eap_session()

   245 {

   246 	EAP_TRACE_DEBUG(

   247 		m_am_tools, 

   248 		TRACE_FLAGS_DEFAULT, 

   249 		(EAPL("dummy_eap_core_c::asynchronous_init_remove_eap_session(): %s.\n"),

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

   251 

   252 		eap_status_e status = eap_status_process_general_error;

   253 

   254 	return EAP_STATUS_RETURN(m_am_tools, status);

   255 }

   256 

   257 //--------------------------------------------------

   258 

   259 //

   260 eap_status_e dummy_eap_core_c::init_end_of_session(

   261 	const abs_eap_state_notification_c * const /* state */)

   262 {

   263 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   264 

   265 	EAP_TRACE_DEBUG(

   266 		m_am_tools, 

   267 		TRACE_FLAGS_DEFAULT, 

   268 		(EAPL("dummy_eap_core_c::init_end_of_session(): %s.\n"),

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

   270 

   271 	eap_status_e status(eap_status_process_general_error);

   272 

   273 

   274 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   275 	return EAP_STATUS_RETURN(m_am_tools, status);

   276 }

   277 

   278 //--------------------------------------------------

   279 

   280 EAP_FUNC_EXPORT void dummy_eap_core_c::state_notification(

   281 	const abs_eap_state_notification_c * const /* state */)

   282 {

   283 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   284 

   285 

   286 

   287 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   288 }

   289 

   290 //--------------------------------------------------

   291 

   292 //

   293 EAP_FUNC_EXPORT eap_base_type_c * dummy_eap_core_c::load_type(

   294 	const eap_type_value_e /* type */,

   295 	const eap_type_value_e /* tunneling_type */,

   296 	const eap_am_network_id_c * /* const receive_network_id */)

   297 {

   298 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   299 

   300 	eap_base_type_c *handler = 0;

   301 

   302 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   303 	return handler;

   304 }

   305 

   306 //--------------------------------------------------

   307 

   308 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::check_is_valid_eap_type(const eap_type_value_e /* eap_type */)

   309 {

   310 		eap_status_e status = eap_status_process_general_error;

   311 

   312 	return EAP_STATUS_RETURN(m_am_tools, status);

   313 }

   314 

   315 //--------------------------------------------------

   316 

   317 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::get_eap_type_list(

   318 	eap_array_c<eap_type_value_e> * const /* eap_type_list */)

   319 {

   320 		eap_status_e status = eap_status_process_general_error;

   321 

   322 	return EAP_STATUS_RETURN(m_am_tools, status);

   323 }

   324 

   325 //--------------------------------------------------

   326 

   327 //

   328 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::initialize_session_timeout(const u32_t /* session_timeout_ms */)

   329 {

   330 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   331 

   332 		eap_status_e status = eap_status_process_general_error;

   333 

   334 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   335 	return EAP_STATUS_RETURN(m_am_tools, status);

   336 }

   337 

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

   339 

   340 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::cancel_session_timeout()

   341 {

   342 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   343 

   344 		eap_status_e status = eap_status_process_general_error;

   345 

   346 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   347 	return EAP_STATUS_RETURN(m_am_tools, status);

   348 }

   349 

   350 //--------------------------------------------------

   351 

   352 EAP_FUNC_EXPORT void dummy_eap_core_c::trace_eap_packet(

   353 	eap_const_string /* prefix */,

   354 	const eap_header_wr_c * /* const eap_header */)

   355 {

   356 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   357 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   358 

   359 }

   360 

   361 

   362 //--------------------------------------------------

   363 

   364 #if defined(USE_EAP_CORE_SERVER)

   365 

   366 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::restart_with_new_type(

   367 	const eap_type_value_e /* used_eap_type */,

   368 	const eap_am_network_id_c * /* const receive_network_id */,

   369 	const u8_t /* eap_identifier */)

   370 {

   371 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   372 

   373 		eap_status_e status = eap_status_process_general_error;

   374 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   375 	return EAP_STATUS_RETURN(m_am_tools, status);

   376 }

   377 

   378 #endif //#if defined(USE_EAP_CORE_SERVER)

   379 

   380 //--------------------------------------------------

   381 

   382 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::client_proposes_eap_types(

   383 	const eap_am_network_id_c * const /* receive_network_id */,

   384 	const u8_t /* eap_identifier */)

   385 {

   386 

   387 	/**

   388 	 * @{ 2005-04-19 complete Expanded Nak Type to client_proposes_eap_types(). }

   389 	 */

   390 		eap_status_e status = eap_status_process_general_error;

   391 

   392 

   393 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   394 	return EAP_STATUS_RETURN(m_am_tools, status);

   395 }

   396 

   397 //--------------------------------------------------

   398 

   399 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::packet_process_type(

   400 	const eap_type_value_e /* used_eap_type */,

   401 	const eap_am_network_id_c * /* const receive_network_id */,

   402 	eap_general_header_base_c * /* const packet_data */,

   403 	const u32_t /* packet_length */)

   404 {

   405 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   406 

   407 	EAP_TRACE_DEBUG(

   408 		m_am_tools, 

   409 		TRACE_FLAGS_DEFAULT, 

   410 		(EAPL("dummy_eap_core_c::packet_process_type(): %s\n"),

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

   412 

   413 

   414 	eap_status_e status = eap_status_process_general_error;

   415 

   416 

   417 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   418 	return EAP_STATUS_RETURN(m_am_tools, status);

   419 }

   420 

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

   422 

   423 /**

   424  * @{ 2003-10-01 draft-ietf-eap-rfc2284bis-06.txt chapter 2.1 Support for sequences:

   425  * An EAP conversation MAY utilize a sequence of methods.  A common

   426  * example of this is an Identity request followed by a single EAP

   427  * authentication method such as an MD5-Challenge.  However the peer and

   428  * authenticator MUST utilize only one authentication method (Type 4 or

   429  * greater) within an EAP conversation, after which the authenticator

   430  * MUST send a Success or Failure packet.

   431  * Once a peer has sent a Response of the same Type as the initial

   432  * Request, an authenticator MUST NOT send a Request of a different Type

   433  * prior to completion of the final round of a given method (with the

   434  * exception of a Notification-Request) and MUST NOT send a Request for

   435  * an additional method of any Type after completion of the initial

   436  * authentication method; a peer receiving such Requests MUST treat them

   437  * as invalid, and silently discard them. As a result, Identity Requery

   438  * is not supported.

   439  * A peer MUST NOT send a Nak (legacy or expanded) in reply to a

   440  * Request, after an initial non-Nak Response has been sent.  Since

   441  * spoofed EAP Request packets may be sent by an attacker, an

   442  * authenticator receiving an unexpected Nak SHOULD discard it and log

   443  * the event.

   444  * Multiple authentication methods within an EAP conversation are not

   445  * supported due to their vulnerability to man-in-the-middle attacks

   446  * (see Section 7.4) and incompatibility with existing implementations.

   447  * }

   448  */

   449 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::packet_process(

   450 	const eap_am_network_id_c * /* const receive_network_id */,

   451 	eap_general_header_base_c * /* const packet_data */,

   452 	const u32_t /* packet_length */)

   453 {

   454 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   455 

   456 	EAP_TRACE_DEBUG(

   457 		m_am_tools, 

   458 		TRACE_FLAGS_DEFAULT, 

   459 		(EAPL("dummy_eap_core_c::packet_process(): %s\n"),

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

   461 

   462 	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: dummy_eap_core_c::packet_process()");

   463 

   464 	eap_status_e status = eap_status_process_general_error;

   465 

   466 

   467 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   468 	return EAP_STATUS_RETURN(m_am_tools, status);

   469 }

   470 

   471 //--------------------------------------------------

   472 

   473 //

   474 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::packet_send(

   475 	const eap_am_network_id_c * const /* send_network_id */,

   476 	eap_buf_chain_wr_c * const /* sent_packet */,

   477 	const u32_t /* header_offset */,

   478 	const u32_t /* data_length */,

   479 	const u32_t /* buffer_length */)

   480 {

   481 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   482 

   483 	eap_status_e status = eap_status_process_general_error;

   484 

   485 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   486 	return EAP_STATUS_RETURN(m_am_tools, status);

   487 }

   488 

   489 //--------------------------------------------------

   490 

   491 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::resend_packet(

   492 	const eap_am_network_id_c * const /* send_network_id */,

   493 	eap_buf_chain_wr_c * const /* sent_packet */,

   494 	const u32_t /* header_offset */,

   495 	const u32_t /* data_length */,

   496 	const u32_t /* buffer_length */,

   497 	const u32_t /* retransmission_counter */)

   498 {

   499 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   500 

   501 	eap_status_e status = eap_status_process_general_error;

   502 

   503 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   504 	return EAP_STATUS_RETURN(m_am_tools, status);

   505 }

   506 

   507 //--------------------------------------------------

   508 

   509 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::cancel_retransmission()

   510 {

   511 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   512 

   513 	eap_status_e status = eap_status_process_general_error;

   514 

   515 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   516 	return EAP_STATUS_RETURN(m_am_tools, status);

   517 }

   518 

   519 //--------------------------------------------------

   520 

   521 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::init_retransmission(

   522 	const eap_am_network_id_c * const /* send_network_id */,

   523 	eap_buf_chain_wr_c * const /* sent_packet */,

   524 	const u32_t /* header_offset */,

   525 	const u32_t /* data_length */,

   526 	const eap_code_value_e /* eap_code */,

   527 	const u8_t /* eap_identifier */,

   528 	const eap_type_value_e /* eap_type */

   529 	)

   530 {

   531 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   532 	eap_status_e status = eap_status_process_general_error;

   533 

   534 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   535 	return EAP_STATUS_RETURN(m_am_tools, status);

   536 

   537 }

   538 

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

   540 

   541 //

   542 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::set_eap_failure_timeout()

   543 {

   544 	eap_status_e status = eap_status_process_general_error;

   545 

   546 	return EAP_STATUS_RETURN(m_am_tools, status);

   547 }

   548 

   549 //--------------------------------------------------

   550 

   551 //

   552 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::cancel_eap_failure_timeout()

   553 {

   554 	eap_status_e status = eap_status_process_general_error;

   555 

   556 	return EAP_STATUS_RETURN(m_am_tools, status);

   557 

   558 }

   559 

   560 //--------------------------------------------------

   561 

   562 #if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

   563 

   564 //

   565 eap_status_e dummy_eap_core_c::set_wait_eap_request_type_timeout()

   566 {

   567 

   568 	eap_status_e status = eap_status_process_general_error;

   569 

   570 	return EAP_STATUS_RETURN(m_am_tools, status);

   571 }

   572 

   573 #endif //#if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

   574 

   575 //--------------------------------------------------

   576 

   577 #if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

   578 

   579 //

   580 eap_status_e dummy_eap_core_c::cancel_wait_eap_request_type_timeout()

   581 {

   582 	eap_status_e status = eap_status_process_general_error;

   583 

   584 	return EAP_STATUS_RETURN(m_am_tools, status);

   585 

   586 }

   587 

   588 #endif //#if defined(USE_EAP_CORE_WAIT_REQUEST_TYPE_TIMER)

   589 

   590 //--------------------------------------------------

   591 

   592 //

   593 EAP_FUNC_EXPORT u32_t dummy_eap_core_c::get_header_offset(

   594 	u32_t * const MTU,

   595 	u32_t * const trailer_length)

   596 {

   597 	EAP_UNREFERENCED_PARAMETER(MTU);

   598 	EAP_UNREFERENCED_PARAMETER(trailer_length);

   599 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   600 

   601 	const u32_t offset = 0;

   602 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   603 

   604 	EAP_TRACE_DEBUG(

   605 		m_am_tools,

   606 		TRACE_FLAGS_DEFAULT,

   607 		(EAPL("dummy_eap_core_c::get_header_offset(): offset=%d, MTU=%d, trailer_length=%d\n"),

   608 		offset,

   609 		*MTU,

   610 		*trailer_length));

   611 

   612 	return offset;

   613 }

   614 

   615 //--------------------------------------------------

   616 

   617 //

   618 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::load_module(

   619 	const eap_type_value_e /* type */,

   620 	const eap_type_value_e /* tunneling_type */,

   621 	abs_eap_base_type_c * /* const partner */,

   622 	eap_base_type_c ** const /* handler */,

   623 	const bool /* is_client_when_true */,

   624 	const eap_am_network_id_c * const /* receive_network_id */)

   625 {

   626 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   627 

   628 	eap_status_e status = eap_status_process_general_error;

   629 

   630 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   631 	return EAP_STATUS_RETURN(m_am_tools, status);

   632 }

   633 

   634 //--------------------------------------------------

   635 

   636 //

   637 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::configure()

   638 	{

   639 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   640 

   641 #if !defined(USE_EAP_DEBUG_TRACE)

   642 	EAP_TRACE_ALWAYS(

   643 		m_am_tools, 

   644 		TRACE_FLAGS_DEFAULT, 

   645 		(EAPL("dummy_eap_core_c::configure(): %s: %s.\n"),

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

   647 		 (m_is_tunneled_eap == true) ? "tunneled": "outer most"));

   648 #else

   649 	EAP_TRACE_ALWAYS(

   650 		m_am_tools, 

   651 		TRACE_FLAGS_DEFAULT, 

   652 		(EAPL("dummy_eap_core_c::configure(): %s: %s, this = 0x%08x => 0x%08x.\n"),

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

   654 		 (m_is_tunneled_eap == true) ? "tunneled": "outer most",

   655 		 this,

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

   657 #endif

   658 

   659 	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: dummy_eap_core_c::configure()");

   660 

   661 	eap_status_e status(eap_status_process_general_error);

   662 

   663 

   664 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   665 	return EAP_STATUS_RETURN(m_am_tools, status);

   666 	}

   667 

   668 //--------------------------------------------------

   669 

   670 //

   671 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::shutdown_operation(

   672 	eap_base_type_c * const handler,

   673 	abs_eap_am_tools_c * const m_am_tools)

   674 {

   675 	EAP_UNREFERENCED_PARAMETER(handler);

   676 

   677 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   678 

   679 	EAP_UNREFERENCED_PARAMETER(m_am_tools);

   680 

   681 	EAP_TRACE_ALWAYS(

   682 		m_am_tools, 

   683 		TRACE_FLAGS_DEFAULT, 

   684 		(EAPL("dummy_eap_core_c::shutdown_operation(): handler=0x%08x.\n"),

   685 		 handler));

   686 

   687 	eap_status_e status(eap_status_process_general_error);

   688 

   689 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   690 	return EAP_STATUS_RETURN(m_am_tools, status);

   691 }

   692 

   693 //--------------------------------------------------

   694 

   695 //

   696 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::shutdown()

   697 {

   698 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   699 	

   700 	eap_status_e status(eap_status_ok);

   701 

   702 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   703 	return EAP_STATUS_RETURN(m_am_tools, status);

   704 }

   705 

   706 //--------------------------------------------------

   707 

   708 //

   709 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::unload_module(const eap_type_value_e /* type */)

   710 {

   711 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   712 

   713 	eap_status_e status(eap_status_process_general_error);

   714 

   715 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   716 	return EAP_STATUS_RETURN(m_am_tools, status);

   717 }

   718 

   719 //--------------------------------------------------

   720 

   721 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::eap_acknowledge(

   722 	const eap_am_network_id_c * const /* receive_network_id */)

   723 {

   724 	// Any Network Protocol packet is accepted as a success indication.

   725 	// This is described in RFC 2284 "PPP Extensible Authentication Protocol (EAP)".

   726 

   727 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   728 

   729 	eap_status_e status(eap_status_process_general_error);

   730 

   731 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   732 	return EAP_STATUS_RETURN(m_am_tools, status);

   733 }

   734 

   735 //--------------------------------------------------

   736 

   737 //

   738 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::restart_authentication(

   739 	const eap_am_network_id_c * const /* send_network_id */,

   740 	const bool /* is_client_when_true */)

   741 {

   742 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   743 

   744 	eap_status_e status = eap_status_process_general_error;

   745 

   746 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   747 	return EAP_STATUS_RETURN(m_am_tools, status);

   748 }

   749 

   750 //--------------------------------------------------

   751 

   752 #if defined(USE_EAP_CORE_SERVER)

   753 

   754 //

   755 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::send_eap_identity_request(

   756 	const eap_am_network_id_c * const /* receive_network_id */)

   757 {

   758 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   759 

   760 	eap_status_e status = eap_status_process_general_error;

   761 

   762 	EAP_TRACE_DEBUG(

   763 		m_am_tools, 

   764 		TRACE_FLAGS_DEFAULT, 

   765 		(EAPL("dummy_eap_core_c::send_eap_identity_request(): %s, %s\n"),

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

   767 		 (m_is_tunneled_eap == true) ? "tunneled": "outer most"

   768 		 ));

   769 

   770 	EAP_TRACE_RETURN_STRING(m_am_tools, "returns: dummy_eap_core_c::send_eap_identity_request()");

   771 

   772 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   773 	return EAP_STATUS_RETURN(m_am_tools, status);

   774 }

   775 

   776 #endif //#if defined(USE_EAP_CORE_SERVER)

   777 

   778 //--------------------------------------------------

   779 

   780 //

   781 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::send_eap_nak_response(

   782 	const eap_am_network_id_c * const /* receive_network_id */,

   783 	const u8_t /* eap_identifier */,

   784 	const eap_array_c<eap_type_value_e> * const /* eap_type_list */)

   785 {

   786 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   787 

   788 	eap_status_e status = eap_status_process_general_error;

   789 

   790 	EAP_TRACE_DEBUG(

   791 		m_am_tools, 

   792 		TRACE_FLAGS_DEFAULT, 

   793 		(EAPL("dummy_eap_core_c::send_eap_nak_response(): %s, %s\n"),

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

   795 		 (m_is_tunneled_eap == true) ? "tunneled": "outer most"

   796 		 ));

   797 

   798 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   799 	return EAP_STATUS_RETURN(m_am_tools, status);

   800 }

   801 

   802 //--------------------------------------------------

   803 

   804 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::packet_data_crypto_keys(

   805 	const eap_am_network_id_c * const /* send_network_id */,

   806 	const eap_master_session_key_c * const /* master_session_key */

   807 	)

   808 {

   809 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   810 

   811 	eap_status_e status = eap_status_process_general_error;

   812 

   813 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   814 	return EAP_STATUS_RETURN(m_am_tools, status);

   815 }

   816 

   817 //--------------------------------------------------

   818 

   819 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::read_configure(

   820 	const eap_configuration_field_c * const /* field */,

   821 	eap_variable_data_c * const /* data */)

   822 {

   823 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   824 

   825 	eap_status_e status = eap_status_process_general_error;

   826 

   827 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   828 	return EAP_STATUS_RETURN(m_am_tools, status);

   829 }

   830 

   831 //--------------------------------------------------

   832 

   833 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::write_configure(

   834 	const eap_configuration_field_c * const /* field */,

   835 	eap_variable_data_c * const /* data */)

   836 {

   837 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   838 

   839 	eap_status_e status = eap_status_process_general_error;

   840 

   841 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   842 	return EAP_STATUS_RETURN(m_am_tools, status);

   843 }

   844 

   845 //--------------------------------------------------

   846 

   847 //

   848 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::timer_expired(

   849 	const u32_t /* id */, void * /* data */)

   850 {

   851 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   852 

   853 	eap_status_e status = eap_status_process_general_error;

   854 

   855 

   856 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   857 	return EAP_STATUS_RETURN(m_am_tools, status);

   858 }

   859 

   860 //--------------------------------------------------

   861 

   862 //

   863 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::timer_delete_data(

   864 	const u32_t /* id */, void * /* data */)

   865 {

   866 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   867 

   868 	eap_status_e status = eap_status_process_general_error;

   869 

   870 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   871 	return EAP_STATUS_RETURN(m_am_tools, status);

   872 }

   873 

   874 //--------------------------------------------------

   875 

   876 //

   877 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::reset_operation(

   878 	eap_base_type_c * const handler,

   879 	abs_eap_am_tools_c * const m_am_tools)

   880 {

   881 	EAP_UNREFERENCED_PARAMETER(handler);

   882 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   883 

   884 	EAP_UNREFERENCED_PARAMETER(m_am_tools);

   885 

   886 	EAP_TRACE_ALWAYS(

   887 		m_am_tools, 

   888 		TRACE_FLAGS_DEFAULT, 

   889 		(EAPL("dummy_eap_core_c::reset_operation(): handler=0x%08x.\n"),

   890 		 handler));

   891 

   892 	eap_status_e status = eap_status_process_general_error;

   893 

   894 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   895 	return EAP_STATUS_RETURN(m_am_tools, status);

   896 }

   897 

   898 //--------------------------------------------------

   899 

   900 //

   901 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::reset()

   902 {

   903 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   904 

   905 #if !defined(USE_EAP_DEBUG_TRACE)

   906 	EAP_TRACE_ALWAYS(

   907 		m_am_tools, 

   908 		TRACE_FLAGS_DEFAULT, 

   909 		(EAPL("dummy_eap_core_c::reset(): %s: %s.\n"),

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

   911 		 (m_is_tunneled_eap == true) ? "tunneled": "outer most"));

   912 #else

   913 	EAP_TRACE_ALWAYS(

   914 		m_am_tools, 

   915 		TRACE_FLAGS_DEFAULT, 

   916 		(EAPL("dummy_eap_core_c::reset(): %s: %s, this = 0x%08x => 0x%08x.\n"),

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

   918 		 (m_is_tunneled_eap == true) ? "tunneled": "outer most",

   919 		 this,

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

   921 #endif

   922 

   923 	eap_status_e status = eap_status_process_general_error;

   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 dummy_eap_core_c::handle_eap_identity_request(

   933 	const eap_type_value_e /* used_eap_type */,

   934 	const u8_t /* eap_identifier */,

   935 	const eap_am_network_id_c * const /* receive_network_id */)

   936 {

   937 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   938 

   939 	eap_status_e status = eap_status_process_general_error;

   940 

   941 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   942 	return EAP_STATUS_RETURN(m_am_tools, status);

   943 }

   944 

   945 //--------------------------------------------------

   946 

   947 #if defined(USE_EAP_CORE_SERVER)

   948 

   949 // 

   950 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::handle_eap_identity_response(

   951 	eap_base_type_c * const /* handler */,

   952 	const eap_type_value_e used_eap_type,

   953 	const eap_am_network_id_c * const /* receive_network_id */,

   954 	eap_header_wr_c * const /* eap */,

   955 	const u32_t /* packet_length */)

   956 {

   957 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   958 	EAP_UNREFERENCED_PARAMETER(used_eap_type); 

   959 

   960 	eap_status_e status = eap_status_process_general_error;

   961 

   962 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   963 	return EAP_STATUS_RETURN(m_am_tools, status);

   964 }

   965 

   966 #endif //#if defined(USE_EAP_CORE_SERVER)

   967 

   968 //--------------------------------------------------

   969 

   970 #if defined(USE_EAP_CORE_SERVER)

   971 

   972 //

   973 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::send_eap_success(

   974 	const eap_am_network_id_c * const /* send_network_id */,

   975 	const u8_t /* eap_identifier */)

   976 {

   977 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   978 

   979 	eap_status_e status = eap_status_process_general_error;

   980 

   981 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

   982 	return EAP_STATUS_RETURN(m_am_tools, status);

   983 }

   984 

   985 #endif //#if defined(USE_EAP_CORE_SERVER)

   986 

   987 //--------------------------------------------------

   988 

   989 #if defined(USE_EAP_CORE_SERVER)

   990 

   991 //

   992 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::send_eap_failure(

   993 	const eap_am_network_id_c * const /* send_network_id */,

   994 	const u8_t /* eap_identifier */)

   995 {

   996 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

   997 

   998 	eap_status_e status = eap_status_process_general_error;

   999 

  1000 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1001 	return EAP_STATUS_RETURN(m_am_tools, status);

  1002 }

  1003 

  1004 #endif //#if defined(USE_EAP_CORE_SERVER)

  1005 

  1006 //--------------------------------------------------

  1007 

  1008 //

  1009 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::send_eap_notification_response(

  1010 	const eap_am_network_id_c * const /* send_network_id */,

  1011 	const u8_t /* eap_identifier */)

  1012 {

  1013 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1014 

  1015 	eap_status_e status = eap_status_process_general_error;

  1016 

  1017 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1018 	return EAP_STATUS_RETURN(m_am_tools, status);

  1019 }

  1020 

  1021 

  1022 //--------------------------------------------------

  1023 

  1024 //

  1025 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::create_eap_identity_response(

  1026 	eap_buf_chain_wr_c * const /* response_packet */,

  1027 	const eap_variable_data_c * const /* identity */,

  1028 	const u8_t /* eap_identifier */

  1029 	)

  1030 {

  1031 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1032 

  1033 	eap_status_e status = eap_status_process_general_error;

  1034 

  1035 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1036 	return EAP_STATUS_RETURN(m_am_tools, status);

  1037 }

  1038 

  1039 //--------------------------------------------------

  1040 

  1041 //

  1042 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::send_eap_identity_response(

  1043 	const eap_am_network_id_c * const /* send_network_id */,

  1044 	const eap_variable_data_c * const /* identity */,

  1045 	const u8_t /* eap_identifier */

  1046 	)

  1047 {

  1048 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1049 

  1050 	eap_status_e status = eap_status_process_general_error;

  1051 

  1052 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1053 	return EAP_STATUS_RETURN(m_am_tools, status);

  1054 }

  1055 

  1056 //--------------------------------------------------

  1057 

  1058 //

  1059 eap_status_e dummy_eap_core_c::set_eap_identity_routing_info_and_nai_decoration(

  1060 	eap_variable_data_c * const /* identity */)

  1061 {

  1062 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1063 

  1064 	eap_status_e status = eap_status_process_general_error;

  1065 

  1066 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1067 	return EAP_STATUS_RETURN(m_am_tools, status);

  1068 

  1069 }

  1070 

  1071 //--------------------------------------------------

  1072 

  1073 //

  1074 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::complete_eap_identity_query(

  1075 	const eap_am_network_id_c * const /* send_network_id */,

  1076 	const eap_variable_data_c * const /* identity */,

  1077 	const u8_t /*eap_identifier*/) // Remove eap_identifier parameter.

  1078 {

  1079 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1080 		eap_status_e status = eap_status_process_general_error;

  1081 

  1082 	return EAP_STATUS_RETURN(m_am_tools, status);

  1083 }

  1084 

  1085 //--------------------------------------------------

  1086 

  1087 //

  1088 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::get_saved_eap_identity(

  1089 	eap_variable_data_c * const /* identity */)

  1090 {

  1091 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1092 

  1093 	eap_status_e status = eap_status_process_general_error;

  1094 

  1095 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1096 	return EAP_STATUS_RETURN_WARNING(m_am_tools, status);

  1097 }

  1098 

  1099 //--------------------------------------------------

  1100 

  1101 //

  1102 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::set_session_timeout(

  1103 	const u32_t /* session_timeout_ms */)

  1104 {

  1105 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1106 

  1107 	eap_status_e status = eap_status_process_general_error;

  1108 

  1109 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1110 	return EAP_STATUS_RETURN(m_am_tools, status);

  1111 }

  1112 

  1113 //--------------------------------------------------

  1114 

  1115 //

  1116 EAP_FUNC_EXPORT eap_status_e dummy_eap_core_c::set_timer(

  1117 	abs_eap_base_timer_c * const p_initializer, 

  1118 	const u32_t p_id, 

  1119 	void * const p_data,

  1120 	const u32_t p_time_ms)

  1121 {

  1122 	EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);

  1123 

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

  1125 

  1126 	const eap_status_e status = m_am_tools->am_set_timer(

  1127 		p_initializer, 

  1128 		p_id, 

  1129 		p_data,

  1130 		p_time_ms);

  1131 

  1132 	EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);

  1133 	return EAP_STATUS_RETURN(m_am_tools, status);

  1134 }