/*

* Copyright (c) 2005-2010 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:  State machine for connecting to a WPA network

*

*/

/*

*/

#include "core_sub_operation_wpa_connect.h"

#include "core_sub_operation_connect.h"

#include "core_server.h"

#include "core_tools.h"

#include "core_tools_parser.h"

#include "core_ap_data.h"

#include "core_frame_rsn_ie.h"

#include "core_frame_wpa_ie.h"

#include "core_frame_wapi_ie.h"

#include "am_debug.h"

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

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

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

//

core_sub_operation_wpa_connect_c::core_sub_operation_wpa_connect_c(

    u32_t request_id,

    core_server_c* server,

    abs_core_driverif_c* drivers,

    abs_core_server_callback_c* adaptation,

    bool_t& is_connected,

    core_management_status_e& connect_status,

    const core_ssid_s& ssid,

    core_ap_data_c& ap_data,

    bool_t& is_cached_sa_used,

    core_type_list_c<core_frame_dot11_ie_c>& assoc_ie_list,

    core_frame_assoc_resp_c** assoc_resp ) :

    core_operation_base_c( core_operation_unspecified, request_id, server, drivers, adaptation,

        core_base_flag_drivers_needed ),

    abs_wlan_eapol_callback_interface_c(),

    is_connected_m( is_connected ),

    is_cached_sa_used_m( is_cached_sa_used ),

    connect_status_m( connect_status ),

    ssid_m( ssid ),

    ap_data_m( ap_data ),

    current_bssid_m( ZERO_MAC_ADDR ),

    pmkid_length_m( 0 ),

    sent_ie_m( NULL ),

    auth_algorithm_m( core_authentication_mode_open ),

    eapol_auth_type_m( wlan_eapol_if_eapol_key_authentication_type_none ),

    assoc_ie_list_m( assoc_ie_list ),

    assoc_resp_m( assoc_resp ),

    is_key_caching_used_m( false_t ),

    pairwise_key_m( CIPHER_KEY_NOT_DEFINED )

    {

    DEBUG( "core_sub_operation_wpa_connect_c::core_sub_operation_wpa_connect_c()" );

    }

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

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

//

core_sub_operation_wpa_connect_c::~core_sub_operation_wpa_connect_c()

    {

    DEBUG( "core_sub_operation_wpa_connect_c::~core_sub_operation_wpa_connect_c()" );

    /**

     * Ownership of sent_ie_m has been transferred to assoc_ie_list_m,

     * no need delete it.

     */

    sent_ie_m = NULL;

    server_m->set_eapol_handler( NULL );

    server_m->unregister_event_handler( this );

    assoc_resp_m = NULL;

    }

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

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

//

core_error_e core_sub_operation_wpa_connect_c::next_state()

    {

    DEBUG( "core_sub_operation_wpa_connect_c::next_state()" );

    switch ( operation_state_m )

        {

        case core_state_init:

            {

            DEBUG( "core_sub_operation_wpa_connect_c::next_state() - marking is_eapol_authentication_started as true" );

            server_m->get_connection_data()->set_eapol_authentication_started(

                true_t );

            server_m->get_connection_data()->set_eapol_auth_bssid(

                ZERO_MAC_ADDR );

            eapol_auth_type_m = core_tools_c::eap_authentication_type(

                server_m->get_connection_data()->iap_data(),

                ap_data_m );

            current_bssid_m = ap_data_m.bssid();

            server_m->set_eapol_handler( this );

            server_m->get_eapol_instance().clear_stored_frame();

            /**

             * If roaming to a WPA2-EAP AP without a cached PMKSA, attempt

             * to use proactive key caching if not previously done so.

             */

            if( !is_key_caching_used_m &&

                !is_cached_sa_used_m &&              

                server_m->get_connection_data()->current_ap_data() &&

                eapol_auth_type_m == wlan_eapol_if_eapol_key_authentication_type_rsna_eap )

                {

                DEBUG( "core_sub_operation_wpa_connect_c::next_state() - attempting to use proactive key caching" );

                is_cached_sa_used_m = true_t;

                is_key_caching_used_m = true_t;

                }

            else if( is_key_caching_used_m )

                {

                is_cached_sa_used_m = false_t;

                is_key_caching_used_m = false_t;                

                }

            // update_wlan_database_reference_values must be sent before start_authentication and start_reassociation.

            u32_t reference[2] = {

                3, // ELan

                server_m->get_connection_data()->iap_data().id() };

            core_error_e ret = server_m->get_eapol_instance().update_wlan_database_reference_values(

                reinterpret_cast<u8_t*>( reference ), 2*sizeof( u32_t ) );

            if( is_cached_sa_used_m )

                {

                if( eapol_auth_type_m == wlan_eapol_if_eapol_key_authentication_type_wpx_fast_roam )

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - starting a WPX fast-roam reassociation" );

                    core_error_e ret = server_m->get_wpx_adaptation_instance().handle_fast_roam_start_reassociation(

                        ap_data_m,

                        assoc_ie_list_m );

                    DEBUG1( "core_sub_operation_wpa_connect_c::next_state() - handle_fast_roam_start_reassociation returned with %u",

                        ret );

                    /*

                     *  State machine will move forward from here by:

                     * - complete_start_wpx_fast_roam_reassociation() 

                     *     -> core_state_do_connect

                     * - Error message (start_wpx_fast_roam_reassociation) 

                     *     -> core_state_init (with is_cached_sa_used_m = false_t)

                     */

                    }

                else

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - starting a reassociation" );

                    operation_state_m = core_state_do_connect;

                    core_mac_address_s previous_bssid( ZERO_MAC_ADDR );

                    if( server_m->get_connection_data()->current_ap_data() )

                        {

                        previous_bssid = server_m->get_connection_data()->current_ap_data()->bssid();

                        }

                    network_id_c previous_ap(

                        &previous_bssid.addr[0],

                        MAC_ADDR_LEN,

                        &server_m->own_mac_addr().addr[0],

                        MAC_ADDR_LEN,

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

                    network_id_c new_ap(

                        &current_bssid_m.addr[0],

                        MAC_ADDR_LEN,

                        &server_m->own_mac_addr().addr[0],

                        MAC_ADDR_LEN,

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

                    ret = server_m->get_eapol_instance().start_reassociation(

                        &previous_ap, &new_ap, eapol_auth_type_m );

                    DEBUG1( "core_sub_operation_wpa_connect_c::next_state() - start_reassociation returned with %u",

                        ret );

                    /*

                     *  State machine will move forward from here by:

                     * - reassociate(), when reassociation is possible 

                     *     -> core_state_do_connect

                     * - Error message (start_reassociation), when start_reassociation is not possible 

                     *     -> core_state_start_authentication_needed

                     */

                    }

                }

            else

                {

                // Full authentication is needed.

                operation_state_m = core_state_start_authentication_needed;

                return next_state();

                }

            break;

            }

        case core_state_start_authentication_needed:

            {

            DEBUG( "core_sub_operation_wpa_connect_c::next_state() - starting a full authentication" );

            operation_state_m = core_state_do_connect;

            network_id_c network_id(

                &current_bssid_m.addr[0],

                MAC_ADDR_LEN,

                &server_m->own_mac_addr().addr[0],

                MAC_ADDR_LEN,

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

            core_error_e ret = server_m->get_eapol_instance().start_authentication(

                const_cast<u8_t*>( &ssid_m.ssid[0] ), ssid_m.length,

                eapol_auth_type_m,

                const_cast<u8_t*>( &server_m->get_connection_data()->iap_data().psk_key().key_data[0] ),

                server_m->get_connection_data()->iap_data().psk_key().key_length,

                server_m->get_connection_data()->iap_data().is_psk_overridden(),

                &network_id );

            DEBUG1( "core_sub_operation_wpa_connect_c::next_state() - start_authentication returned with %u",

                ret );

            break;

            }

        case core_state_do_connect:

            {

            core_key_management_e key_management( core_key_management_eap );

            core_encryption_mode_e encryption_mode( core_encryption_mode_wpa );

            bool_t is_pairwise_key_invalidated( true_t );

            switch ( eapol_auth_type_m )

                {

                case wlan_eapol_if_eapol_key_authentication_type_rsna_eap:

                    /** Falls through on purpose. */

                case wlan_eapol_if_eapol_key_authentication_type_wpa_eap:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using key management core_key_management_eap" );

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_encryption_mode_wpa" );

                    key_management = core_key_management_eap;

                    encryption_mode = core_encryption_mode_wpa;                    

                    break;

                    }

                case wlan_eapol_if_eapol_key_authentication_type_wfa_sc:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using key management core_key_management_eap" );

                    key_management = core_key_management_eap;

                    if ( ap_data_m.is_privacy_enabled() )

                        {

                        DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_encryption_mode_wpa" );

                        encryption_mode = core_encryption_mode_wpa;

                        }

                    else

                        {

                        DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_encryption_mode_disabled" );

                        encryption_mode = core_encryption_mode_disabled;

                        }

                    break;

                    }

                case wlan_eapol_if_eapol_key_authentication_type_rsna_psk:

                    /** Falls through on purpose. */

                case wlan_eapol_if_eapol_key_authentication_type_wpa_psk:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using key management core_key_management_preshared" );

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_encryption_mode_wpa" );

                    key_management = core_key_management_preshared;

                    encryption_mode = core_encryption_mode_wpa;

                    break;

                    }

                case wlan_eapol_if_eapol_key_authentication_type_802_1x:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using key management core_key_management_eap" );

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_encryption_mode_802dot1x" );

                    key_management = core_key_management_eap;

                    encryption_mode = core_encryption_mode_802dot1x;

                    break;

                    }

                case wlan_eapol_if_eapol_key_authentication_type_wpx_fast_roam:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using key management wlan_eapol_if_eapol_key_authentication_type_wpx_fast_roam" );

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_encryption_mode_802dot1x" );

                    key_management = core_key_management_wpx_fast_roam;

                    encryption_mode = core_encryption_mode_802dot1x;

                    if( is_cached_sa_used_m )

                        {

                        is_pairwise_key_invalidated = false_t;

                        }

                    break;

                    }

                case wlan_eapol_if_eapol_key_authentication_type_wapi:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using key management core_key_management_wapi_certificate" );

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_security_mode_wapi" );

                    key_management = core_key_management_wapi_certificate;

                    encryption_mode = core_encryption_mode_wpi;

                    break;                    

                    }

                case wlan_eapol_if_eapol_key_authentication_type_wapi_psk:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using key management core_key_management_wapi_psk" );

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - using encryption mode core_security_mode_wapi" );

                    key_management = core_key_management_wapi_psk;

                    encryption_mode = core_encryption_mode_wpi;

                    break;                    

                    }

                default:

                    {

                    DEBUG( "core_sub_operation_wpa_connect_c::next_state() - unknown authentication type" );

                    ASSERT( false_t );

                    }

                }

            operation_state_m = core_state_req_connect;

            if( ap_data_m.is_rsn_ie_present() )

                {

                DEBUG( "core_sub_operation_wpa_connect_c::next_state() - generating RSN IE" );

                sent_ie_m = core_frame_rsn_ie_c::instance(

                    server_m->get_wpx_adaptation_instance(),

                    ap_data_m.best_group_cipher(),

                    ap_data_m.best_pairwise_cipher(),

                    key_management,

                    pmkid_length_m,

                    &pmkid_data_m[0] );

                }

            else if( ap_data_m.is_wpa_ie_present() )

                {

                DEBUG( "core_sub_operation_wpa_connect_c::next_state() - generating WPA IE" );

                sent_ie_m = core_frame_wpa_ie_c::instance(

                    server_m->get_wpx_adaptation_instance(),

                    ap_data_m.best_group_cipher(),

                    ap_data_m.best_pairwise_cipher(),

                    key_management );

                }

            else if( ap_data_m.is_wapi_ie_present() )

                {

                DEBUG( "core_sub_operation_wpa_connect_c::next_state() - generating WAPI IE" );

                sent_ie_m = core_frame_wapi_ie_c::instance(

                    ap_data_m.best_group_cipher(),

                    ap_data_m.best_pairwise_cipher(),

                    key_management,

                    0,

                    pmkid_length_m,

                    &pmkid_data_m[0] );

                }

            if( sent_ie_m &&

                eapol_auth_type_m != wlan_eapol_if_eapol_key_authentication_type_wfa_sc )

                {

                assoc_ie_list_m.append(

                    sent_ie_m,

                    sent_ie_m->element_id() );

                }

            DEBUG( "core_sub_operation_wpa_connect_c::next_state() - marking is_eapol_connecting as true" );

            server_m->get_connection_data()->set_eapol_connecting(

                true_t );

            core_operation_base_c* operation = new core_sub_operation_connect_c(

                request_id_m,

                server_m,

                drivers_m,

                adaptation_m,

                is_connected_m,

                connect_status_m,

                ssid_m,

                ap_data_m,

                auth_algorithm_m,

                server_m->get_wpx_adaptation_instance().encryption_mode(

                    ap_data_m, encryption_mode ),

                core_tools_c::cipher_key_type(

                    ap_data_m.best_pairwise_cipher() ),

                assoc_ie_list_m,

                assoc_resp_m,

                is_pairwise_key_invalidated,

                true_t,

                pairwise_key_m.key_length ? &pairwise_key_m : NULL );

            return run_sub_operation( operation );

            }

        case core_state_req_connect:

            {

            DEBUG( "core_sub_operation_wpa_connect_c::next_state() - connection success" );

            operation_state_m = core_state_req_state_notification;

            network_id_c network(

                &current_bssid_m.addr[0],

                MAC_ADDR_LEN,

                &server_m->own_mac_addr().addr[0],

                MAC_ADDR_LEN,

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

            const core_frame_dot11_ie_c* ie = NULL;

            if( ap_data_m.is_rsn_ie_present() )

                {

                ie = ap_data_m.rsn_ie();

                }

            else if( ap_data_m.is_wpa_ie_present() )

                {

                ie = ap_data_m.wpa_ie();

                }

            else if( ap_data_m.is_wapi_ie_present() )

                {

                ie = ap_data_m.wapi_ie();

                }

            core_frame_dot11_ie_c * recv_ie = NULL;

            core_frame_dot11_ie_c * sent_ie = NULL;

            if ( sent_ie_m )

                {

                sent_ie = sent_ie_m;

                DEBUG( "core_sub_operation_wpa_connect_c::next_state() - sent IE: " );

                DEBUG_BUFFER( sent_ie_m->data_length(), sent_ie_m->data() );

                }

            if ( ie )

                {

                recv_ie = core_frame_dot11_ie_c::instance( ie->data_length(), ie->data() );

                DEBUG( "core_sub_operation_wpa_connect_c::next_state() - received IE: " );

                DEBUG_BUFFER( ie->data_length(), ie->data() );

                }

            DEBUG( "core_sub_operation_wpa_connect_c::next_state() - marking is_eapol_connecting as false" );

            server_m->get_connection_data()->set_eapol_connecting(

                false_t );

            server_m->get_connection_data()->set_eapol_auth_bssid(

                current_bssid_m );

            /**

             * WPX fast-roam reassociation is handled differently, EAPOL indication will

             * move the state machine forward.

             */

            if ( is_cached_sa_used_m &&

                 eapol_auth_type_m == wlan_eapol_if_eapol_key_authentication_type_wpx_fast_roam )

                {

                server_m->get_wpx_adaptation_instance().handle_fast_roam_reassoc_resp(

                    assoc_resp_m ? *assoc_resp_m : NULL );

                delete recv_ie;

                recv_ie = NULL;

                delete ie;

                ie = NULL;

                return core_error_request_pending;

                }

            u8_t * temp_recv_ie( NULL );

            u32_t temp_recv_ie_length( 0 );

            u8_t * temp_sent_ie( NULL );

            u32_t temp_sent_ie_length( 0 );

            if ( recv_ie )

                {

                temp_recv_ie = const_cast<u8_t*>( recv_ie->data() );

                temp_recv_ie_length = recv_ie->data_length();

                }

            if ( sent_ie_m )

                {

                temp_sent_ie = const_cast<u8_t*>( sent_ie->data() );

                temp_sent_ie_length = sent_ie->data_length();

                }

            if ( is_cached_sa_used_m )                 

                {

                server_m->get_eapol_instance().complete_reassociation(

                    wlan_eapol_if_eapol_wlan_authentication_state_association_ok,

                    &network,

                    temp_recv_ie, temp_recv_ie_length,

                    temp_sent_ie, temp_sent_ie_length,

                    core_tools_c::eapol_cipher( ap_data_m.best_pairwise_cipher() ),

                    core_tools_c::eapol_cipher( ap_data_m.best_group_cipher() ) );

                }

            else

                {

                server_m->get_eapol_instance().complete_association(                

                    wlan_eapol_if_eapol_wlan_authentication_state_association_ok,

                    &network,

                    temp_recv_ie, temp_recv_ie_length,

                    temp_sent_ie, temp_sent_ie_length,

                    core_tools_c::eapol_cipher( ap_data_m.best_pairwise_cipher() ),

                    core_tools_c::eapol_cipher( ap_data_m.best_group_cipher() ) );

                }

            delete recv_ie;

            recv_ie = NULL;

            delete ie;

            ie = NULL;

            // Send EAPOL frame after timer. This will allow new EAPOL frames to come from queue.

            return asynch_goto( core_state_process_eapol_frame, CORE_TIMER_IMMEDIATELY );

            }

        case core_state_process_eapol_frame:

            {

            operation_state_m = core_state_req_state_notification;

            server_m->get_eapol_instance().process_stored_frame();

            server_m->register_event_handler( this );

            break;

            }

        case core_state_req_state_notification:

            {

            server_m->unregister_event_handler( this );

            DEBUG( "core_sub_operation_wpa_connect_c::next_state() - authentication success" );

            return core_error_ok;

            }

        case core_state_req_connect_failed:

            {

            DEBUG( "core_sub_operation_wpa_connect_c::next_state() - connection failed" );