/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  handler to EAPOL callbacks.

*

*/

#include "core_eapol_handler.h"

#include "core_server.h"

#include "core_tools.h"

#include "core_tools_parser.h"

#include "abs_core_protected_setup_handler.h"

#include "am_debug.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_eapol_handler_c::core_eapol_handler_c(

    core_server_c* server,

    abs_core_driverif_c* drivers,

    abs_core_server_callback_c* adaptation ) :

    abs_wlan_eapol_callback_interface_c(),

    server_m( server ),

    drivers_m( drivers ),

    adaptation_m( adaptation ),

    handler_m( NULL ),

    protected_setup_handler_m( NULL )

    {

    DEBUG( "core_eapol_handler_c::core_eapol_handler_c()" );

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_eapol_handler_c::~core_eapol_handler_c()

    {

    DEBUG( "core_eapol_handler_c::~core_eapol_handler_c()" );

    server_m = NULL;

    drivers_m = NULL;

    adaptation_m = NULL;

    handler_m = NULL;

    protected_setup_handler_m = NULL;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

abs_wlan_eapol_callback_interface_c* core_eapol_handler_c::eapol_handler()

    {

    return handler_m;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void core_eapol_handler_c::set_eapol_handler(

    abs_wlan_eapol_callback_interface_c* handler )

    {

    handler_m = handler;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

void core_eapol_handler_c::set_protected_setup_handler(

    abs_core_protected_setup_handler_c* handler )

    {

    protected_setup_handler_m = handler;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_error_e core_eapol_handler_c::packet_send(

    network_id_c * send_network_id,

    u8_t * packet_data,

    u32_t packet_data_length,

    bool_t send_unencrypted )

    {

    DEBUG( "core_eapol_handler_c::packet_send()" );

    ASSERT ( server_m != NULL );

    if ( !server_m->get_core_settings().is_connected() )

        {

        DEBUG( "core_eapol_handler_c::packet_send() - not connected or attempting connection, ignoring" );

        return core_error_ok;

        }

    if ( handler_m )

        {

        return handler_m->packet_send(

            send_network_id,

            packet_data,

            packet_data_length,

            send_unencrypted );

        }

    server_m->send_data_frame(

        *server_m->get_connection_data()->current_ap_data(),

        core_frame_type_ethernet,

        static_cast<u16_t>( packet_data_length ),

        packet_data,

        core_access_class_voice,

        send_network_id->destination(),

        send_unencrypted );

    return core_error_ok;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_error_e core_eapol_handler_c::associate(

    wlan_eapol_if_eapol_key_authentication_mode_e authentication_mode )

    {

    DEBUG( "core_eapol_handler_c::associate()" );

    ASSERT ( handler_m );

    if ( handler_m )

        {

        return handler_m->associate(

                authentication_mode );

        }

    return core_error_ok;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_error_e core_eapol_handler_c::disassociate(

    network_id_c * receive_network_id,

    const bool_t self_disassociation )

    {

    DEBUG( "core_eapol_handler_c::disassociate()" );

    ASSERT ( handler_m );

    if ( handler_m )

        {

        return handler_m->disassociate(

                receive_network_id,

                self_disassociation );

        }

    return core_error_ok;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//	    

core_error_e core_eapol_handler_c::packet_data_session_key(

    network_id_c * send_network_id,

    session_key_c * key )

    {

    DEBUG( "core_eapol_handler_c::packet_data_session_key()" );

    ASSERT( key != NULL);

    ASSERT( send_network_id != NULL);

    if ( !handler_m )

        {

        ASSERT ( server_m != NULL );

        core_cipher_key_type_e type =

            core_tools_c::cipher_key_type(

                key->eapol_key_type,

                server_m->get_connection_data()->current_ap_data()->best_pairwise_cipher(),

                server_m->get_connection_data()->current_ap_data()->best_group_cipher() );

        core_mac_address_s mac( BROADCAST_MAC_ADDR );

        if ( key->eapol_key_type == wlan_eapol_if_eapol_key_type_unicast )

            {

            mac = send_network_id->destination();

            }

        ASSERT ( drivers_m != NULL );

        drivers_m->add_cipher_key(

            type,

            static_cast<u8_t>( key->key_index ),

            static_cast<u16_t>( key->key_length ),

            key->key,

            mac,

            true_t );

        return core_error_ok;

        }

    return handler_m->packet_data_session_key(

        send_network_id,

        key );

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//	    

void core_eapol_handler_c::state_notification(

    state_notification_c * state )

    {

    DEBUG( "core_eapol_handler_c::state_notification()" );

    const u32_t eap_type_vendor_id_ietf = 0;

    const u32_t eap_type_vendor_id_WFA = 0x00372A;

    ASSERT ( server_m != NULL );

    if ( !server_m->get_core_settings().is_connected() )

        {

        DEBUG( "core_eapol_handler_c::state_notification() - not connected or attempting connection, ignoring" );

        return;

        }

    ASSERT ( state != NULL );

    if ( state->protocol_layer == wlan_eapol_if_eap_protocol_layer_wlan_authentication ||

         state->protocol_layer == wlan_eapol_if_eap_protocol_layer_wapi )

        {

        if ( state->current_state == wlan_eapol_if_eapol_wlan_authentication_state_authentication_cancelled )

        	{

        	if ( server_m->get_connection_data()->last_failed_eap_type() == EAP_TYPE_NONE )

	            {

	            // We know that vendor_type values (in ietf and WFA) are not overlapping 

	            // and thus there is no need for storing vendor_id's.

	            if ( state->eap_type_vendor_id == eap_type_vendor_id_ietf 

	                    || state->eap_type_vendor_id == eap_type_vendor_id_WFA )

	                {

	                server_m->get_connection_data()->set_last_failed_eap_type(

	                    state->eap_type_vendor_type );

	                server_m->get_connection_data()->set_last_eap_error(

	                    state->authentication_error );

	                }

	            else

	                {

	                DEBUG1( "core_eapol_handler_c::state_notification() - Unknown vendor_id %i in EAP-type. Type not stored.",

	                    state->eap_type_vendor_id );

	                }

	            }

        	}

        handle_wlan_authentication_state(

            state->current_state,

            state->network_id.destination() );

        }

    else

    	{

    	if ( state->protocol_layer == wlan_eapol_if_eap_protocol_layer_general &&

        state->current_state == wlan_eapol_if_eap_state_general_authentication_error )

	        {

	        DEBUG( "core_eapol_handler_c::state_notification() - EAP-specific authentication error:" );

	        }

        else if ( state->protocol_layer == wlan_eapol_if_eap_protocol_layer_eap &&

                state->current_state == wlan_eapol_if_eap_state_authentication_terminated_unsuccessfully )

            {

            DEBUG( "core_eapol_handler_c::state_notification() - EAP-layer error:" );

            }

    	if (  ( state->protocol_layer == wlan_eapol_if_eap_protocol_layer_general &&

    	        state->current_state == wlan_eapol_if_eap_state_general_authentication_error ) ||

		        ( state->protocol_layer == wlan_eapol_if_eap_protocol_layer_eap &&

		          state->current_state == wlan_eapol_if_eap_state_authentication_terminated_unsuccessfully ) )

    		{

		        DEBUG2( "core_eapol_handler_c::state_notification() - type: vendor_id: %u, vendor_type: %u",

			            state->eap_type_vendor_id,

			            state->eap_type_vendor_type );

			        DEBUG1( "core_eapol_handler_c::state_notification() - error: %u",

			            state->authentication_error );

			        DEBUG1( "core_eapol_handler_c::state_notification() - previous type: %u",

			            server_m->get_connection_data()->last_failed_eap_type() );

			        DEBUG1( "core_eapol_handler_c::state_notification() - previous error: %u",

			            server_m->get_connection_data()->last_eap_error() );

	        if ( server_m->get_connection_data()->last_failed_eap_type() == EAP_TYPE_NONE )

	            {

	            // We know that vendor_type values (in ietf and WFA) are not overlapping 

	            // and thus there is no need for storing vendor_id's.

	            if ( state->eap_type_vendor_id == eap_type_vendor_id_ietf 

	                    || state->eap_type_vendor_id == eap_type_vendor_id_WFA )

	                {

	                server_m->get_connection_data()->set_last_failed_eap_type(

	                    state->eap_type_vendor_type );

	                server_m->get_connection_data()->set_last_eap_error(

	                    state->authentication_error );

	                }

	            else

	                {

	                DEBUG1( "core_eapol_handler_c::state_notification() - Unknown vendor_id %i in EAP-type. Type not stored.",

	                    state->eap_type_vendor_id );

	                }

	            }

    		}

        }

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

core_error_e core_eapol_handler_c::reassociate(

    network_id_c * send_network_id,

    const wlan_eapol_if_eapol_key_authentication_type_e authentication_type,

    u8_t * PMKID,

    u32_t PMKID_length )

    {

    DEBUG( "core_eapol_handler_c::reassociate()" );

    ASSERT ( handler_m );

    if ( handler_m )

        {

        return handler_m->reassociate(

                send_network_id,

                authentication_type,

                PMKID,

                PMKID_length );

        }

    return core_error_ok;

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

u32_t core_eapol_handler_c::convert_core_error_to_if_status(

    core_error_e core_error )

    {

    DEBUG1( "core_eapol_handler_c::convert_core_error_to_if_status( %i )", core_error );

    switch ( core_error )

        {

        case core_error_ok:

            return wlan_eapol_if_error_ok;

        case core_error_request_pending:

            return wlan_eapol_if_error_pending_request;

        case core_error_no_memory:

            return wlan_eapol_if_error_allocation_error;

        case core_error_illegal_argument:

            return wlan_eapol_if_error_illegal_parameter;

        case core_error_general:

            return wlan_eapol_if_error_process_general_error;

        default:

            DEBUG( "core_eapol_handler_c::convert_core_error_to_if_status - Error: No special conversion to given status" );

            return wlan_eapol_if_error_process_general_error;

        }

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

//

u32_t core_eapol_handler_c::send_data(

    const void * const data, 

    const u32_t length )

    {

    DEBUG2( "core_eapol_handler_c::send_data(data=0x%08X, length=%i)", data, length );

    if ( !data || length == 0 )

        {

        DEBUG( "core_eapol_handler_c::send_data() - Parameters not valid. Ignoring." );

        core_wlan_eapol_if_function_c function;

        if ( function.generate_error( wlan_eapol_if_error_illegal_parameter, wlan_eapol_if_message_type_function_none )

            == core_error_ok )

            {

            adaptation_m->process_data( function.get_data(), function.size() );

            }

        return wlan_eapol_if_error_illegal_parameter;

        }

    core_wlan_eapol_if_function_c function( static_cast<u8_t *>( const_cast<void *>( data ) ), length );

    function.debug_print();

    core_error_e error( core_error_ok );

    // 1. Get function

    // 2. Parse it's parameters

    // 3. Call actual function

    // Check error case here.

    wlan_eapol_if_message_type_e type = function.get_type();

    if ( type == wlan_eapol_if_message_type_error )

        {

        DEBUG( "core_eapol_handler_c::send_data() - Error received." );

        wlan_eapol_if_error_e parsed_errorcode;

        wlan_eapol_if_message_type_function_e parsed_function;

        error = function.parse_error( &parsed_errorcode, &parsed_function );

        if ( error != core_error_ok )

            {

            DEBUG1( "core_eapol_handler_c::send_data() - Could not parse error message (parsing error=%i)", error );

            // Do not send Error message when error message parsing fails...

            }

        else

            {

            handle_error( parsed_errorcode, parsed_function );

            }

        return wlan_eapol_if_error_ok;

        }

    else if ( type != wlan_eapol_if_message_type_function )

        {

        DEBUG( "core_eapol_handler_c::send_data() - Type parameter is not valid. Ignoring." );

        if ( function.generate_error( wlan_eapol_if_error_illegal_parameter, wlan_eapol_if_message_type_function_none )

            == core_error_ok )

            {

            adaptation_m->process_data( function.get_data(), function.size() );

            }

        return wlan_eapol_if_error_illegal_parameter;

        }

    wlan_eapol_if_message_type_function_e func = function.get_function();

    switch ( func )

        {

        // These functions are used only from WLAN Engine to EAPOL. So, no need to parse and handle...

        case wlan_eapol_if_message_type_function_check_pmksa_cache:

        case wlan_eapol_if_message_type_function_start_authentication:

        case wlan_eapol_if_message_type_function_complete_association:

        case wlan_eapol_if_message_type_function_disassociation:

        case wlan_eapol_if_message_type_function_start_preauthentication:

        case wlan_eapol_if_message_type_function_start_reassociation:

        case wlan_eapol_if_message_type_function_complete_reassociation:

        case wlan_eapol_if_message_type_function_start_wpx_fast_roam_reassociation:

        case wlan_eapol_if_message_type_function_complete_wpx_fast_roam_reassociation:

        case wlan_eapol_if_message_type_function_packet_process:

        case wlan_eapol_if_message_type_function_tkip_mic_failure:

        case wlan_eapol_if_message_type_function_eap_acknowledge:

        case wlan_eapol_if_message_type_function_update_header_offset:

        case wlan_eapol_if_message_type_function_update_wlan_database_reference_values:

            DEBUG1( "core_eapol_handler_c::send_data() - Error: Message %i coming to from EAPOL to Engine (wrong direction...)", func );

            return wlan_eapol_if_error_illegal_parameter;

        // These functions are handled in WLAN Engine.

        case wlan_eapol_if_message_type_function_complete_check_pmksa_cache:

            {

            core_type_list_c<network_id_c> network_id_list;

            error = function.parse_complete_check_pmksa_cache(

                network_id_list );

            if ( error == core_error_ok )

                {

                error = complete_check_pmksa_cache( network_id_list );

                }

            break;

            }

        case wlan_eapol_if_message_type_function_packet_send:

            {

            network_id_c network_id( NULL, 0, NULL, 0, 0 );

            u8_t * packet( NULL );

            u32_t packet_length( 0 );

            wlan_eapol_if_eapol_key_authentication_type_e type(

                server_m->get_eapol_instance().authentication_type() );

            bool_t send_unecrypted( false_t );

            if( type == wlan_eapol_if_eapol_key_authentication_type_wapi ||

                type == wlan_eapol_if_eapol_key_authentication_type_wapi_psk )

                {

                send_unecrypted = true_t;

                }

            error = function.parse_packet_send(

                &network_id,

                &packet, &packet_length );

            if ( error == core_error_ok )

                {               

                error = packet_send( &network_id, packet, packet_length, send_unecrypted );

                }

            break;

            }

        case wlan_eapol_if_message_type_function_associate:

            {

            wlan_eapol_if_eapol_key_authentication_mode_e auth_mode( wlan_eapol_if_eapol_key_authentication_mode_none );

            error = function.parse_associate(

                &auth_mode );

            if ( error == core_error_ok )

                {

                error = associate( auth_mode );

                }

            break;

            }

        case wlan_eapol_if_message_type_function_disassociate:

            {

            network_id_c network_id( NULL, 0, NULL, 0, 0 );

            bool_t self_disassociation( false_t );

            error = function.parse_disassociate(

                &network_id,

                &self_disassociation );

            if ( error == core_error_ok )

                {

                error = disassociate( &network_id, self_disassociation );

                }

            break;

            }

        case wlan_eapol_if_message_type_function_packet_data_session_key:

            {

            network_id_c network_id( NULL, 0, NULL, 0, 0 );

            session_key_c session_key( NULL, 0, NULL, 0, wlan_eapol_if_eapol_key_type_broadcast, 0, false_t );

            error = function.parse_packet_data_session_key(

                &network_id,

                &session_key );

            if ( error == core_error_ok )

                {

                error = packet_data_session_key( &network_id, &session_key );

                }

            break;

            }

        case wlan_eapol_if_message_type_function_state_notification:

            {

            network_id_c network_id( NULL, 0, NULL, 0, 0 );

            state_notification_c state_notif( &network_id, wlan_eapol_if_eap_protocol_layer_none, 0, 0, 0, 0, false_t, wlan_eapol_if_eap_status_none );

            error = function.parse_state_notification(

                &state_notif );

            if ( error == core_error_ok )

                {

                state_notification( &state_notif );

                }