/*

* Copyright (c) 2005-2009 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:  Class holding all connection related data

*

*/

/*

*/

#include "core_connection_data.h"

#include "core_tools.h"

#include "am_debug.h"

const u8_t CORE_FAILURE_NONE = 0;

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

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

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

//   

core_connection_data_c::core_connection_data_c(

    const core_iap_data_s& iap_data,

    const core_device_settings_s& device_settings ) :

    iap_data_m( iap_data ),

    device_settings_m( device_settings ),

    connect_status_m( core_connect_undefined ),

    previous_ap_m( NULL ),

    current_ap_m( NULL ),

    ssid_m( BROADCAST_SSID ),

    temp_blacklist_m( ),

    last_rcp_class_m( core_rcp_normal ),

    last_tx_level_m( MAX_TX_POWER_LEVEL_NOT_DEFINED ),

    last_bssid_m( ZERO_MAC_ADDR ),

    last_connection_state_m( core_connection_state_notconnected ),

    association_failure_count_m( ),

    deauthentication_count_m( ),

    last_eap_type_m( EAP_TYPE_NONE ),

    last_eap_error_code_m( EAP_ERROR_NONE ),

    adjacent_ap_channels_m( ),

    is_eapol_authentication_started_m( false_t ),

    is_eapol_authenticating_m( false_t ),

    eapol_auth_bssid_m( ZERO_MAC_ADDR ),

    traffic_stream_list_m( ),

    virtual_traffic_stream_list_m( ),

    is_eapol_connecting_m( false_t ),

    is_disconnecting_m( false_t ),

    last_roam_reason_m( core_roam_reason_none ),

    last_roam_failed_reason_m( core_roam_failed_reason_none ),

    is_eapol_require_immediate_reconnect_m( false_t ),

    is_voice_call_on_m( false_t ),

    previous_rrm_measurement_request_time_m( 0 )

    {

    DEBUG( "core_connection_data_c::core_connection_data_c()" );

    for( u8_t idx( 0 ); idx < MAX_QOS_ACCESS_CLASS; ++idx )

        {

        ac_traffic_status_m[idx] = core_access_class_traffic_status_admitted;

        ac_traffic_mode_m[idx] = core_access_class_traffic_mode_automatic;

        }

    }

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

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

//

core_connection_data_c::~core_connection_data_c()

    {

    DEBUG( "core_connection_data_c::~core_connection_data_c()" );

    delete current_ap_m;

    delete previous_ap_m;

    temp_blacklist_m.clear();

    association_failure_count_m.clear();

    deauthentication_count_m.clear();

    power_save_test_verdict_m.clear();

    }

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

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

//   

core_iap_data_c& core_connection_data_c::iap_data()

    {

    return iap_data_m;

    }

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

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

//   

core_connect_status_e core_connection_data_c::connect_status() const

    {

    return connect_status_m;

    }

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

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

//   

void core_connection_data_c::set_connect_status(

    core_connect_status_e connect_status )

    {

    connect_status_m = connect_status;

    }

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

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

//   

void core_connection_data_c::set_current_ap_data(

    const core_ap_data_c& ap_data )

    {

    DEBUG( "core_connection_data_c::set_current_ap_data()" );

    delete current_ap_m;

    current_ap_m = NULL;

    current_ap_m = core_ap_data_c::instance( ap_data );

    }

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

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

//

core_ap_data_c* core_connection_data_c::current_ap_data()

    {

    return current_ap_m;

    }

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

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

//

void core_connection_data_c::set_previous_ap_data(

    const core_ap_data_c& ap_data )

    {

    delete previous_ap_m;

    previous_ap_m = NULL;

    previous_ap_m = core_ap_data_c::instance( ap_data );

    }

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

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

//

core_ap_data_c* core_connection_data_c::previous_ap_data()

    {

    return previous_ap_m;

    }

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

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

//

const core_ssid_s& core_connection_data_c::ssid() const

    {

    return ssid_m;

    }

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

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

//

void core_connection_data_c::set_ssid(

    const core_ssid_s& ssid )

    {

    ssid_m = ssid;

    }

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

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

//

bool_t core_connection_data_c::is_mac_in_temporary_blacklist(

    const core_mac_address_s& mac )

    {

    core_ap_blacklist_entry_s* addr = temp_blacklist_m.first();    

    while ( addr )

        {

        if ( addr->bssid == mac )

            {

            return true_t;

            }

        addr = temp_blacklist_m.next();

        }        

    return false_t;

    }

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

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

//

void core_connection_data_c::add_mac_to_temporary_blacklist(

    const core_mac_address_s& mac,

    core_ap_blacklist_reason_e reason )

    {

    if ( !is_mac_in_temporary_blacklist( mac ) )

        {

        core_ap_blacklist_entry_s* entry = new core_ap_blacklist_entry_s;

        if ( entry )

            {

            entry->bssid = mac;

            entry->reason = reason;

            temp_blacklist_m.append( entry );

            }

        }

    }

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

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

//

void core_connection_data_c::remove_mac_from_temporary_blacklist(

    const core_mac_address_s& mac )

    {

    core_ap_blacklist_entry_s* addr = temp_blacklist_m.first();    

    while ( addr )

        {

        if ( addr->bssid == mac )

            {

            temp_blacklist_m.remove( addr );

            delete addr;

            addr = NULL;

            return;

            }

        addr = temp_blacklist_m.next();

        }       

    }

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

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

//

core_type_list_c<core_ap_blacklist_entry_s>& core_connection_data_c::temporary_blacklist()

    {

    return temp_blacklist_m;

    }

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

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

//

void core_connection_data_c::remove_temporary_blacklist_entries(

    u32_t reasons )

    {

    core_ap_blacklist_entry_s* addr = temp_blacklist_m.first();    

    while( addr )

        {

        if( reasons & addr->reason )

            {

            DEBUG6( "core_connection_data_c::remove_temporary_blacklist_entries() - removing entry with BSSID %02X:%02X:%02X:%02X:%02X:%02X",

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

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

            temp_blacklist_m.remove( addr );

            delete addr;

            addr = NULL;

            return;

            }

        addr = temp_blacklist_m.next();

        }

    }

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

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

//

core_rcp_class_e core_connection_data_c::last_rcp_class() const

    {

    return last_rcp_class_m;  

    }

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

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

//   

void core_connection_data_c::set_last_rcp_class(

    core_rcp_class_e type )

    {

    last_rcp_class_m = type;

    };

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

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

//   

u32_t core_connection_data_c::last_tx_level() const

    {

    return last_tx_level_m;

    }

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

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

//      

void core_connection_data_c::set_last_tx_level(

    u32_t tx_level )

    {

    last_tx_level_m = tx_level;

    }

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

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

//

const core_mac_address_s& core_connection_data_c::last_bssid() const

    {

    return last_bssid_m;

    }

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

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

//

void core_connection_data_c::set_last_bssid(

    const core_mac_address_s& bssid )

    {

    last_bssid_m = bssid;

    }

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

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

//

core_connection_state_e core_connection_data_c::connection_state() const

    {

    core_operating_mode_e mode =

        iap_data_m.operating_mode();

    if( mode == core_operating_mode_ibss )

        {

        if( iap_data_m.security_mode() == core_security_mode_allow_unsecure )

            {

            return core_connection_state_ibss;

            }

        else

            {

            return core_connection_state_secureibss;

            }

        }

    else

        {

        if( iap_data_m.security_mode() == core_security_mode_allow_unsecure )

            {

            return core_connection_state_infrastructure;

            }

        else

            {

            return core_connection_state_secureinfra;

            }

        }

    }

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

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

//

core_connection_state_e core_connection_data_c::last_connection_state() const

    {

    return last_connection_state_m;

    }

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

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

//

void core_connection_data_c::set_last_connection_state(

    core_connection_state_e state )

    {

    last_connection_state_m = state;

    }

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

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

//

u8_t core_connection_data_c::ap_association_failure_count(

    const core_mac_address_s& bssid )

    {    

    core_ap_failure_count_s* iter = association_failure_count_m.first();    

    while ( iter )

        {

        if ( iter->bssid == bssid )

            {

            return iter->count;

            }

        iter = association_failure_count_m.next();

        }

    return CORE_FAILURE_NONE;

    }

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

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

//

void core_connection_data_c::increase_ap_association_failure_count(

    const core_mac_address_s& bssid )

    {

    core_ap_failure_count_s* iter = association_failure_count_m.first();    

    while ( iter )

        {

        if ( iter->bssid == bssid )

            {

            iter->count++;

            return;

            }

        iter = association_failure_count_m.next();

        }

    iter = new core_ap_failure_count_s;

    if ( iter )

        {

        iter->bssid = bssid;

        iter->count = CORE_FAILURE_NONE + 1;

        association_failure_count_m.append( iter );

        }

    }

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

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

//

void core_connection_data_c::clear_ap_association_failure_count(

    const core_mac_address_s& bssid )

    {

    core_ap_failure_count_s* iter = association_failure_count_m.first();    

    while ( iter )

        {

        if ( iter->bssid == bssid )

            {

            DEBUG1( "core_connection_data_c::clear_ap_failure_count() - this AP had %u previous failures",

                iter->count );

            association_failure_count_m.remove( iter );

            delete iter;

            iter = NULL;

            return;

            }

        iter = association_failure_count_m.next();

        }

    DEBUG( "core_connection_data_c::clear_ap_failure_count() - this AP had no previous failures" );

    }

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

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

//

u8_t core_connection_data_c::ap_authentication_failure_count(

    const core_mac_address_s& bssid )

    {    

    core_ap_auth_failure_count_s* iter = authentication_failure_count_m.first();    

    while ( iter )

        {

        if ( iter->bssid == bssid )

            {

            return iter->count;

            }

        iter = authentication_failure_count_m.next();

        }

    return CORE_FAILURE_NONE;

    }

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

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

//

void core_connection_data_c::increase_ap_authentication_failure_count(

    const core_mac_address_s& bssid )

    {

    core_ap_auth_failure_count_s* iter = authentication_failure_count_m.first();    

    while ( iter )

        {

        if ( iter->bssid == bssid )

            {

            iter->count++;

            return;

            }

        iter = authentication_failure_count_m.next();

        }

    iter = new core_ap_auth_failure_count_s;

    if ( iter )

        {

        iter->bssid = bssid;

        iter->count = CORE_FAILURE_NONE + 1;

        authentication_failure_count_m.append( iter );

        }

    }

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

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

//

void core_connection_data_c::clear_all_authentication_failure_counts()

    {

    DEBUG( "core_connection_data_c::clear_all_authentication_failure_counts()" );

    core_ap_auth_failure_count_s* iter = authentication_failure_count_m.first();    

    while ( iter )

        {

        DEBUG1( "core_connection_data_c::clear_all_authentication_failure_counts() - this AP had %u previous failures",

            iter->count );

        authentication_failure_count_m.remove( iter );

        delete iter;

        iter = NULL;

        iter = authentication_failure_count_m.next();

        }

    }

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

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

//

u8_t core_connection_data_c::ap_deauthentication_count(

    const core_mac_address_s& bssid )

    {

    core_ap_failure_count_s* iter = deauthentication_count_m.first();    

    while ( iter )

        {

        if ( iter->bssid == bssid )

            {

            return iter->count;

            }

        iter = deauthentication_count_m.next();