/*

* 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:  Statemachine for roaming

*

*/

/*

*/

#include "core_operation_roam.h"

#include "core_server.h"

#include "core_tools.h"

#include "core_tools_parser.h"

#include "core_sub_operation_connect.h"

#include "core_sub_operation_adhoc.h"

#include "core_sub_operation_wep_connect.h"

#include "core_sub_operation_wpa_connect.h"

#include "core_sub_operation_roam_update_ts.h"

#include "core_operation_update_power_mode.h"

#include "core_frame_assoc_resp.h"

#include "core_frame_dot11.h"

#include "core_frame_qbss_load_ie.h"

#include "core_scan_list.h"

#include "core_frame_nr_ie.h"

#include "core_frame_action_nr.h"

#include "core_frame_action_rm.h"

#include "core_frame_radio_measurement_action.h"

#include "am_debug.h"

const u32_t CORE_ROAMING_LIST_BONUS_PMKSA = 20;

const u32_t CORE_ROAMING_LIST_BONUS_WPX_FAST_ROAM = 20;

/** The maximum amount association/authentication failures when WAPI is used. */

const u32_t CORE_MAX_WAPI_AP_ASSOCIATION_FAILURE_COUNT = 10; 

/** Definitions for RRM Enabled Capabilities bitmask */

const u64_t RRM_CAPABILITY_BIT_MASK_NEIGHBOR_REPORT = 0x0000000002;

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

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

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

//

core_operation_roam_c::core_operation_roam_c(

    u32_t request_id,

    core_server_c* server,

    abs_core_driverif_c* drivers,

    abs_core_server_callback_c* adaptation,

    bool_t& is_connected,

    u8_t tag,        

    u8_t min_required_rcpi,

    const medium_time_s& min_medium_time,        

    const core_ssid_s& ssid,

    const core_mac_address_s& bssid ) :

    core_operation_base_c( core_operation_roam, request_id, server, drivers, adaptation, 

        core_base_flag_drivers_needed ),

    is_connected_m( is_connected ),

    tag_m( tag ),

    min_required_rcpi_m( min_required_rcpi ),

    min_medium_time_m( min_medium_time ),

    ssid_m( ssid ),

    bssid_m( bssid ),    

    roaming_list_m( ),

    management_status_m( core_management_status_success ),

    connect_status_m( core_connect_network_not_found ),

    current_ap_m( NULL ),

    current_bssid_m( ZERO_MAC_ADDR ),

    assoc_ie_list_m( false_t ),

    is_cached_sa_used_m( false_t ),

    assoc_resp_m( NULL )

    {

    DEBUG( "core_operation_roam_c::core_operation_roam_c()" );    

    }

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

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

//

core_operation_roam_c::~core_operation_roam_c()

    {

    DEBUG( "core_operation_roam_c::~core_operation_roam_c()" );

    for ( roaming_list_entry_s* iter = roaming_list_m.first(); iter; iter = roaming_list_m.next() )

        {

        delete iter->ap_data;

        }

    roaming_list_m.clear();

    assoc_ie_list_m.clear();

    delete assoc_resp_m;

    current_ap_m = NULL;

    }

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

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

//

core_error_e core_operation_roam_c::next_state()

    {

    DEBUG( "core_operation_roam_c::next_state()" );

    switch ( operation_state_m )

        {

        case core_state_init:

            {

            if( server_m->get_connection_data()->last_roam_reason() != core_roam_reason_initial_connect )

                {

                server_m->get_core_settings().roam_metrics().inc_roam_attempt_count(

                    server_m->get_connection_data()->last_roam_reason() );

                }

            if( is_connected_m )

                {

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

                DEBUG6( "core_operation_roam_c::next_state() - current BSSID: %02X:%02X:%02X:%02X:%02X:%02X",

                    current_bssid_m.addr[0], current_bssid_m.addr[1], current_bssid_m.addr[2],

                    current_bssid_m.addr[3], current_bssid_m.addr[4], current_bssid_m.addr[5] );

                }

            DEBUG6( "core_operation_roam_c::next_state() - requested BSSID: %02X:%02X:%02X:%02X:%02X:%02X",

                bssid_m.addr[0], bssid_m.addr[1], bssid_m.addr[2],

                bssid_m.addr[3], bssid_m.addr[4], bssid_m.addr[5] );           

            DEBUG1( "core_operation_roam_c::next_state() - minimum required RCPI value: %u",

                min_required_rcpi_m );

            /**

             * Set all the traffic streams as not active and reset TSPEC parameters to the

             * default values.

             */

            core_traffic_stream_list_c& ts_list(

                server_m->get_connection_data()->traffic_stream_list() );

            for( core_traffic_stream_c* iter = ts_list.first(); iter; iter = ts_list.next() )

                {

                iter->set_status( core_traffic_stream_status_undefined );

                iter->reset_to_default_values();

                }

            if ( !is_connected_m )

                {

                /**

                 * Indicate core_connection_state_searching state to adaptation.

                 */

                core_connection_state_e state = core_connection_state_searching;

                server_m->get_core_settings().set_connection_state( state );

                if ( server_m->get_connection_data()->last_connection_state() != state )

                    {

                    u8_t buf[5];

                    buf[0] = static_cast<u8_t>( state );

                    adaptation_m->notify(

                        core_notification_connection_state_changed,

                        1,

                        buf );

                    server_m->get_connection_data()->set_last_connection_state(

                        state );

                    }

                }

            server_m->get_scan_list().print_contents();

            DEBUG1( "core_operation_roam_c::next_state() - tag entry for iterator is 0x%02X",

                tag_m );

            core_scan_list_iterator_by_tag_and_ssid_and_bssid_c iter(

                server_m->get_scan_list(),

                tag_m,

                ssid_m,

                bssid_m );

            for ( core_ap_data_c* ap_data = iter.first(); ap_data; ap_data = iter.next() )

                {

                if ( process_frame( *ap_data ) )

                    {

                    DEBUG( "core_operation_roam_c::next_state() - AP added to roaming list" );

                    }                

                }               

#ifdef _DEBUG

            DEBUG( "core_operation_roam_c::next_state() - roaming list start" );

            roaming_list_entry_s* entry_iter = roaming_list_m.first();

            TUint idx( 1 );

            while ( entry_iter )

                {

                const core_mac_address_s bssid = entry_iter->ap_data->bssid();

                DEBUG8( "core_operation_roam_c::next_state() - entry #%02u %02X:%02X:%02X:%02X:%02X:%02X (RCPI %u)",

                    idx, bssid.addr[0], bssid.addr[1], bssid.addr[2], 

                    bssid.addr[3], bssid.addr[4], bssid.addr[5], entry_iter->ap_data->rcpi() );

                entry_iter = roaming_list_m.next();

                ++idx;

                }

            DEBUG( "core_operation_roam_c::next_state() - roaming list end" );

#endif // _DEBUG            

            if ( roaming_list_m.first() )

                {

                current_ap_m = roaming_list_m.first()->ap_data;

                }

            /**

             * We can proceed with the connection if there are entries in

             * the roaming list OR we are going to start our own IBSS network.

             */

            if( current_ap_m ||

                ( !is_connected_m &&

                  server_m->get_connection_data()->iap_data().operating_mode() == core_operating_mode_ibss ) )

                {

                operation_state_m = core_state_req_disable_userdata_before_connect;

                if ( !is_connected_m )

                    {

                    return next_state();

                    }

                DEBUG( "core_operation_roam_c::next_state() - disabling user data before connect" );

                server_m->get_core_settings().roam_metrics().set_roam_ts_userdata_disabled();

                drivers_m->disable_user_data(

                    request_id_m );

                }

            else

                {

                DEBUG( "core_operation_roam_c::next_state() - no suitable AP found" );

                failure_reason_m = core_error_not_found;

                if ( server_m->get_connection_data()->connect_status() == core_connect_undefined )

                    {

                    server_m->get_connection_data()->set_connect_status( connect_status_m );

                    }

                server_m->get_core_settings().roam_metrics().inc_roam_attempt_failed_count(

                    core_roam_failed_reason_no_suitable_ap );

                if ( server_m->get_connection_data()->last_roam_failed_reason() == core_roam_failed_reason_none )

                    {

                    server_m->get_connection_data()->set_last_roam_failed_reason( core_roam_failed_reason_no_suitable_ap );

                    }

                /**

                 * Set all traffic stream statuses and parameters back to the values

                 * they were before the roam attempt.

                 */

                core_traffic_stream_list_c& ts_list(

                    server_m->get_connection_data()->traffic_stream_list() );

                for( core_traffic_stream_c* iter = ts_list.first(); iter; iter = ts_list.next() )

                    {

                    iter->set_status( core_traffic_stream_status_active );

                    iter->reset_to_previous_values();

                    }

                return cancel();

                }            

            break;                

            }

        case core_state_req_disable_userdata_before_connect:

            {

            operation_state_m = core_state_req_connect;

#ifdef _DEBUG

            if( current_ap_m )

                {

                const core_mac_address_s current_bssid =

                    current_ap_m->bssid();

                DEBUG6( "core_operation_roam_c::next_state() - selecting BSSID %02X:%02X:%02X:%02X:%02X:%02X",

                    current_bssid.addr[0], current_bssid.addr[1], current_bssid.addr[2],

                    current_bssid.addr[3], current_bssid.addr[4], current_bssid.addr[5] );                

                }

            else

                {

                DEBUG("core_operation_roam_c::next_state() - establishing adhoc network");

                }

#endif // _DEBUG

            core_security_mode_e mode(

                server_m->get_connection_data()->iap_data().security_mode() );

            bool_t is_ibss_mode(

                server_m->get_connection_data()->iap_data().operating_mode() == core_operating_mode_ibss );

            /**

             * Establish Adhoc network

             */

            if( !current_ap_m &&

                is_ibss_mode )

                {

                core_operation_base_c* operation = new core_sub_operation_adhoc_c(

                    request_id_m,

                    server_m,

                    drivers_m,

                    adaptation_m,

                    &current_ap_m ); // conveying a pointer to pointer

                return run_sub_operation( operation );

                }

            /**

             * IAP with no security.

             */

            if ( mode == core_security_mode_allow_unsecure )                     

                {                                        

                core_operation_base_c* operation = new core_sub_operation_connect_c(

                    request_id_m,

                    server_m,

                    drivers_m,

                    adaptation_m,

                    is_connected_m,

                    management_status_m,

                    ssid_m,

                    *current_ap_m,

                    core_authentication_mode_open,

                    core_encryption_mode_disabled,

                    core_cipher_key_type_none,

                    assoc_ie_list_m,

                    is_ibss_mode ? NULL : &assoc_resp_m,

                    true_t,    // ignored, pairwise key not used

                return run_sub_operation( operation );

                }

            /**

             * IAP with static WEP.

             */

            if ( mode == core_security_mode_wep )

                {

                core_operation_base_c* operation = new core_sub_operation_wep_connect_c(

                    request_id_m,

                    server_m,

                    drivers_m,

                    adaptation_m,

                    is_connected_m,

                    management_status_m,

                    ssid_m,

                    *current_ap_m,

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

                    core_encryption_mode_wep,

                    assoc_ie_list_m,

                    is_ibss_mode ? NULL : &assoc_resp_m );

                return run_sub_operation( operation );

                }

            /**

             * IAP with EAP.

             */

            is_cached_sa_used_m = roaming_list_m.first()->is_cached_sa_available;

            core_operation_base_c* operation = new core_sub_operation_wpa_connect_c(

                request_id_m,

                server_m,

                drivers_m,

                adaptation_m,

                is_connected_m,

                management_status_m,

                ssid_m,

                *current_ap_m,

                is_cached_sa_used_m,

                assoc_ie_list_m,

                is_ibss_mode ? NULL : &assoc_resp_m );

            return run_sub_operation( operation );

            }

        case core_state_req_connect:

            {

            operation_state_m = core_state_req_update_ts;

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

            /**

             * Send information about the current AP to the subscribed clients.

             *

             * This has to be done before updating traffic stream statuses so

             * that NIF won't try to recreate rejected streams.

             */

            core_ap_information_s info = core_tools_parser_c::get_ap_info(

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

                *current_ap_m );

            DEBUG( "core_operation_roam_c::next_state() - notifying access point information:" );

            DEBUG1( "core_operation_roam_c::next_state() - is_ac_required_for_voice = %u",

                info.is_ac_required_for_voice );

            DEBUG1( "core_operation_roam_c::next_state() - is_ac_required_for_video = %u",

                info.is_ac_required_for_video );

            DEBUG1( "core_operation_roam_c::next_state() - is_ac_required_for_best_effort = %u",

                info.is_ac_required_for_best_effort );

            DEBUG1( "core_operation_roam_c::next_state() - is_ac_required_for_background = %u",

                info.is_ac_required_for_background );

            DEBUG1( "core_operation_roam_c::next_state() - is_wpx = %u",

                info.is_wpx );

            adaptation_m->notify(

                core_notification_ap_info_changed,

                sizeof ( info ),

                reinterpret_cast<u8_t*>( &info ) );

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

                 server_m->get_connection_data()->current_ap_data()->bssid() != current_ap_m->bssid() )

                {

                server_m->get_connection_data()->set_previous_ap_data(

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

                /**

                 * EAPOL must notified about the disassociation.

                 */

                if ( server_m->get_connection_data()->iap_data().is_eap_used() ||

                     server_m->get_connection_data()->iap_data().is_wapi_used() )

                    {

                    core_mac_address_s bssid =

                        server_m->get_connection_data()->previous_ap_data()->bssid();

                    network_id_c network(

                        &bssid.addr[0],

                        MAC_ADDR_LEN,

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

                        MAC_ADDR_LEN,

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

                    DEBUG6( "core_operation_roam_c::next_state() - EAPOL disassociation from BSSID %02X:%02X:%02X:%02X:%02X:%02X",

                        bssid.addr[0], bssid.addr[1], bssid.addr[2],

                        bssid.addr[3], bssid.addr[4], bssid.addr[5] );

                    server_m->get_eapol_instance().disassociation( &network );

                    }

                }

            server_m->get_connection_data()->set_current_ap_data(

                *current_ap_m );

            core_operation_base_c* operation = new core_sub_operation_roam_update_ts_c(

                request_id_m,

                server_m,

                drivers_m,

                adaptation_m,

                *current_ap_m );

            return run_sub_operation( operation );           

            }        

        case core_state_req_update_ts:

            {

            operation_state_m = core_state_req_enable_userdata;

            DEBUG( "core_operation_roam_c::next_state() - allowing user data" );

            drivers_m->enable_user_data(

                request_id_m );

            break;

            }

        case core_state_req_enable_userdata:

            {                        

            DEBUG( "core_operation_roam_c::next_state() - connection done" );

            server_m->get_connection_data()->set_last_rcp_class( core_rcp_normal );

            server_m->get_connection_data()->set_ssid( ssid_m );

            server_m->get_core_settings().roam_metrics().set_roam_ts_userdata_enabled();

            server_m->get_core_settings().roam_metrics().inc_roam_success_count();

            server_m->get_connection_data()->clear_ap_association_failure_count(

                current_ap_m->bssid() );

            server_m->get_connection_data()->clear_all_authentication_failure_counts();

            server_m->get_connection_data()->remove_temporary_blacklist_entries(

                core_ap_blacklist_reason_eapol_failure |

                core_ap_blacklist_reason_max_association_failure_count );

            if ( current_ap_m->bssid() != server_m->get_connection_data()->last_bssid() )

                {

                DEBUG( "core_operation_roam_c::next_state() - BSSID changed, notifying change" );

                const core_mac_address_s bssid = current_ap_m->bssid();

                adaptation_m->notify(

                    core_notification_bssid_changed,

                    sizeof ( bssid ),

                    &bssid.addr[0] );

                server_m->get_connection_data()->set_last_bssid(

                    bssid );

                }

            if ( !is_connected_m )

                {

                core_connection_state_e state = server_m->get_connection_data()->connection_state();

                server_m->get_core_settings().set_connection_state( state );

                if ( server_m->get_connection_data()->last_connection_state() != state )

                    {

                    u8_t buf[5];

                    buf[0] = static_cast<u8_t>( state );

                    adaptation_m->notify(

                        core_notification_connection_state_changed,

                        1,

                        buf );

                    server_m->get_connection_data()->set_last_connection_state(

                        state );

                    }

                }

            if ( current_ap_m->is_wpx() )

                {

                server_m->get_wpx_adaptation_instance().handle_wpx_roam_success(

                    *current_ap_m );

                }

            if( current_ap_m->rrm_capabilities() & RRM_CAPABILITY_BIT_MASK_NEIGHBOR_REPORT )

                {

                handle_neighbor_request();

                }

            /**

             * If roaming to another AP, schedule a power save update.