/*

* 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 access point specific information

*

*/

/*

* %version: 34 %

*/

#include "core_ap_data.h"

#include "core_tools.h"

#include "core_tools_parser.h"

#include "core_frame_beacon.h"

#include "core_frame_dot11_ie.h"

#include "core_frame_mgmt_ie.h"

#include "core_frame_rsn_ie.h"

#include "core_frame_wpa_ie.h"

#include "core_frame_wmm_ie.h"

#include "core_frame_wsc_ie.h"

#include "core_frame_qbss_load_ie.h"

#include "core_frame_wapi_ie.h"

#include "am_debug.h"

/** Defining this enables IE parsing related traces. */

//#define WLAN_CORE_DEEP_DEBUG 1

const u16_t AP_CHANNEL_REPORT_CHANNEL_OFFSET = 3;

const u8_t REQUEST_IE_OFFSET = 2;

/** The maximum number of admission capacities. */

const u16_t MAX_NBR_OF_ADMISSION_CAPACITIES = 12;

const u16_t CHECKSUM_LENGTH = 4;

const u16_t REPORTED_FRAME_BODY_MAX_LENGTH = 224;

const u16_t HEADER_LENGTH = 5;

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

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

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

//   

core_ap_data_c::core_ap_data_c(

    abs_core_wpx_adaptation_c& wpx_adaptation ) :

    wpx_adaptation_m( wpx_adaptation ),

    frame_m( NULL ),

    rcpi_m( 0 ),

    pairwise_cipher_m( core_cipher_suite_none ),

    group_cipher_m( core_cipher_suite_none ),

    key_management_m( core_key_management_none ),

    wpx_version_m( 0 ),

    capabilities_bitmap_m( 0 ),

    is_ac_required_bitmap_m( 0 ),

    dtim_period_m( 0 )

    {

    DEBUG( "core_ap_data_c::core_ap_data_c()" );

    }

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

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

//

core_ap_data_c::~core_ap_data_c()

    {

    DEBUG( "core_ap_data_c::~core_ap_data_c()" ); 

    delete frame_m;

    }

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

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

//

core_mac_address_s core_ap_data_c::bssid() const

    {

    return frame_m->bssid();

    }

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

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

//

core_ssid_s core_ap_data_c::ssid()

    {

    for( core_frame_dot11_ie_c* ie = frame_m->first_ie(); ie; ie = frame_m->next_ie() )

        {

        if ( ie->element_id() == core_frame_dot11_ie_c::core_frame_dot11_ie_element_id_ssid )

            {

            core_frame_mgmt_ie_ssid_c* parser = core_frame_mgmt_ie_ssid_c::instance( *ie );

            if ( parser )

                {

                core_ssid_s ssid = parser->ssid();

                delete parser;

                parser = NULL;

                delete ie;

                ie = NULL;

                return ssid;

                }

            }

        delete ie;

        ie = NULL;

        }

    return BROADCAST_SSID;

    }

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

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

//

u16_t core_ap_data_c::capabilities() const

    {

    return frame_m->capability();

    }

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

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

//   

u8_t core_ap_data_c::max_tx_power_level() const

    {

    u8_t tx_power_level( MAX_TX_POWER_LEVEL_NOT_DEFINED );

    u8_t power_constraint( 0 );

    u8_t channel = core_ap_data_c::channel();

    for( core_frame_dot11_ie_c* ie = frame_m->first_ie(); ie; ie = frame_m->next_ie() )

        {

        if ( ie->element_id() == core_frame_dot11_ie_c::core_frame_dot11_ie_element_id_country )

            {

            core_frame_mgmt_ie_country_c* parser = core_frame_mgmt_ie_country_c::instance( *ie );

            if ( parser )

                {

                tx_power_level = parser->max_tx_power_level(

                    channel );

                delete parser;

                parser = NULL;

                }

            }

        else if ( ie->element_id() == core_frame_dot11_ie_c::core_frame_dot11_ie_element_id_power_constraint )

            {

            core_frame_mgmt_ie_power_constraint_c* parser2 = core_frame_mgmt_ie_power_constraint_c::instance( *ie );

            if ( parser2 )

                {

                power_constraint = parser2->power_constraint();

                delete parser2;

                parser2 = NULL;

                }

            }

        delete ie;

        ie = NULL;

        }

    if(tx_power_level != MAX_TX_POWER_LEVEL_NOT_DEFINED)

        {

        tx_power_level = tx_power_level - power_constraint;

        }

    u8_t temp_power_level = wpx_adaptation_m.max_tx_power_level( frame_m );

    if ( temp_power_level < tx_power_level )

        {

        tx_power_level = temp_power_level;

        }

    return tx_power_level;

    }

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

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

//   

core_country_string_s core_ap_data_c::country_info() const

    {

    core_country_string_s country_info( COUNTRY_STRING_NONE );

    for( core_frame_dot11_ie_c* ie = frame_m->first_ie(); ie; ie = frame_m->next_ie() )

        {

        if ( ie->element_id() == core_frame_dot11_ie_c::core_frame_dot11_ie_element_id_country )

            {

            core_frame_mgmt_ie_country_c* parser = core_frame_mgmt_ie_country_c::instance( *ie );

            if ( parser )

                {

                country_info = parser->country();

                delete parser;

                parser = NULL;

                delete ie;

                ie = NULL;

                return country_info;

                }

            }

        delete ie;

        ie = NULL;

        }

   	return country_info;

    }

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

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

//   

bool_t core_ap_data_c::is_privacy_enabled() const

    {

    return frame_m->capability() & CAPABILITY_BIT_MASK_PRIVACY;

    }

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

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

//

core_ap_data_c* core_ap_data_c::instance(

    const core_ap_data_c& copy )

    {

    DEBUG( "core_ap_data_c::instance()" );

    core_ap_data_c* instance = new core_ap_data_c( copy.wpx_adaptation_m );

    if ( !instance )

        {

        DEBUG( "core_ap_data_c::instance() - unable to create an instance" );

        return NULL;

        }

    *instance = copy;

    return instance;

    }

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

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

//

core_ap_data_c* core_ap_data_c::instance(

    abs_core_wpx_adaptation_c& wpx_adaptation,

    const core_frame_dot11_c* frame,

    u8_t rcpi,

    bool_t is_copied )

    {

    DEBUG( "core_ap_data_c::instance()" );

    DEBUG1( "core_ap_data_c::instance() - is_copied %u",

        is_copied );

    core_ap_data_c* instance = new core_ap_data_c( wpx_adaptation );

    if ( !instance )

        {

        DEBUG( "core_ap_data_c::instance() - unable to create core_ap_data_c instance" );

        return NULL;

        }    

    instance->rcpi_m = rcpi;

    instance->frame_m = core_frame_beacon_c::instance(

        *frame,

        is_copied );

    if ( !instance->frame_m )

        {

        DEBUG( "core_ap_data_c::instance() - unable to create core_frame_beacon_c instance" );

        delete instance;

        instance = NULL;

        return NULL;        

        }

    const core_mac_address_s bssid = instance->frame_m->bssid();

    DEBUG6( "core_ap_data_c::instance() - 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] );

    const core_tsf_value_s timestamp = instance->frame_m->timestamp();

    DEBUG8( "core_ap_data_c::instance() - TSF: 0x%02X%02X%02X%02X%02X%02X%02X%02X",

        timestamp.tsf[0], timestamp.tsf[1], timestamp.tsf[2],

        timestamp.tsf[3], timestamp.tsf[4], timestamp.tsf[5], 

        timestamp.tsf[6], timestamp.tsf[7] );

    DEBUG1( "core_ap_data_c::instance() - capability: 0x%04X",

        instance->frame_m->capability() );

    DEBUG1( "core_ap_data_c::instance() - beacon_interval: %u",

        instance->frame_m->beacon_interval() );

    DEBUG1( "core_ap_data_c::instance() - class size: %u",

        sizeof( *instance ) );

    DEBUG1( "core_ap_data_c::instance() - beacon class size: %u",

        frame->data_length() );

#ifdef WLAN_CORE_DEEP_DEBUG

    for( core_frame_dot11_ie_c* ie = instance->frame_m->first_ie(); ie; ie = instance->frame_m->next_ie() )

        {

        DEBUG1( "core_ap_data_c::instance() - IE id: 0x%02X",

            ie->element_id() );

        DEBUG1( "core_ap_data_c::instance() - IE length: %u",

            ie->length() );

        delete ie;

        ie = NULL;

        }

#endif // WLAN_CORE_DEEP_DEBUG

    const core_frame_rsn_ie_c* rsn_ie = instance->rsn_ie();

    if ( rsn_ie )

        {

        DEBUG( "core_ap_data_c::instance() - RSN IE detected" );

        instance->capabilities_bitmap_m |= core_am_ap_data_capability_rsn_ie_present;

        instance->pairwise_cipher_m |= rsn_ie->pairwise_cipher_suites();

        instance->group_cipher_m |=  rsn_ie->group_cipher_suite();

        instance->key_management_m |= rsn_ie->key_management_suites();

        delete rsn_ie;

        rsn_ie = NULL;

        }

    const core_frame_wpa_ie_c* wpa_ie = instance->wpa_ie();

    if ( wpa_ie )

        {

        DEBUG( "core_ap_data_c::instance() - WPA IE detected" );

        instance->capabilities_bitmap_m |= core_am_ap_data_capability_wpa_ie_present;

        instance->pairwise_cipher_m |= wpa_ie->pairwise_cipher_suites();

        instance->group_cipher_m |=  wpa_ie->group_cipher_suite();

        instance->key_management_m |= wpa_ie->key_management_suites();

        delete wpa_ie;

        wpa_ie = NULL;

        }

    const core_frame_wapi_ie_c* wapi_ie = instance->wapi_ie();

    if ( wapi_ie )

        {

        DEBUG( "core_ap_data_c::instance() - WAPI IE detected" );

        instance->capabilities_bitmap_m |= core_am_ap_data_capability_wapi_ie_present;

        instance->pairwise_cipher_m |= wapi_ie->pairwise_cipher_suites();

        instance->group_cipher_m |=  wapi_ie->group_cipher_suite();

        instance->key_management_m |= wapi_ie->key_management_suites();

        delete wapi_ie;

        wapi_ie = NULL;        

        }

    if ( instance->is_rsn_ie_present() ||

         instance->is_wpa_ie_present() ||

         instance->is_wapi_ie_present() )

        {

        DEBUG1( "core_ap_data_c::instance() - supported pairwise ciphers: 0x%02X",

            instance->pairwise_cipher_m );

        DEBUG1( "core_ap_data_c::instance() - supported group cipher: 0x%02X",

            instance->group_cipher_m );

        DEBUG1( "core_ap_data_c::instance() - supported key management suites: 0x%02X",

            instance->key_management_m );

        }

    DEBUG1( "core_ap_data_c::instance() - RCPI: %u",

        instance->rcpi_m );

    DEBUG1( "core_ap_data_c::instance() - channel: %u",

        instance->channel() );

    u8_t max_tx_power_level = instance->max_tx_power_level();

    if ( max_tx_power_level < MAX_TX_POWER_LEVEL_NOT_DEFINED )

        {

        DEBUG1( "core_ap_data_c::instance() - maximum tx power level: %u",

            max_tx_power_level );

        }

    else

        {

        DEBUG( "core_ap_data_c::instance() - maximum tx power level: undefined" );

        }

    core_country_string_s country_value = instance->country_info();

    if ( COUNTRY_STRING_NONE != country_value )

        {

        DEBUG2( "core_ap_data_c::instance() - country %c%c",

                country_value.country[0], country_value.country[1] );

        }

    instance->wpx_version_m = instance->wpx_adaptation_m.wpx_version(

        instance->frame_m );

    if ( instance->wpx_version_m )

        {

        DEBUG1( "core_ap_data_c::instance() - WPX: v%u",

            instance->wpx_version_m );

        }

    else

        {

        DEBUG( "core_ap_data_c::instance() - WPX: no" );

        }

    const core_frame_wmm_ie_parameter_c* wmm_ie = instance->wmm_parameter_ie();

    if ( wmm_ie )

        {        

        DEBUG( "core_ap_data_c::instance() - WMM Parameter Element IE detected" );

        instance->capabilities_bitmap_m |= core_am_ap_data_capability_wmm_ie_present;

        if ( wmm_ie->is_uapsd_supported() )

            {

            instance->capabilities_bitmap_m |= core_am_ap_data_capability_uapsd_supported;

            }

        if ( wmm_ie->is_admission_control_required( core_access_class_best_effort ) )

            {

            instance->is_ac_required_bitmap_m |= ( 1 << core_access_class_best_effort );

            }        

        if ( wmm_ie->is_admission_control_required( core_access_class_background ) )

            {

            instance->is_ac_required_bitmap_m |= ( 1 << core_access_class_background );

            }        

        if ( wmm_ie->is_admission_control_required( core_access_class_video ) )

            {

            instance->is_ac_required_bitmap_m |= ( 1 << core_access_class_video );

            }        

        if ( wmm_ie->is_admission_control_required( core_access_class_voice ) )

            {

            instance->is_ac_required_bitmap_m |= ( 1 << core_access_class_voice );

            }

        DEBUG1( "core_ap_data_c::instance() - U-APSD: %u",

            instance->is_uapsd_supported() );

        DEBUG1( "core_ap_data_c::instance() - Admission Control for Best Effort: %u",

            instance->is_admission_control_required( core_access_class_best_effort ) );

        DEBUG1( "core_ap_data_c::instance() - Admission Control for Background: %u",

            instance->is_admission_control_required( core_access_class_background ) );

        DEBUG1( "core_ap_data_c::instance() - Admission Control for Video: %u",

            instance->is_admission_control_required( core_access_class_video ) );

        DEBUG1( "core_ap_data_c::instance() - Admission Control for Voice: %u",

            instance->is_admission_control_required( core_access_class_voice ) );

        delete wmm_ie;

        wmm_ie = NULL;

        }

#ifdef _DEBUG

    const core_frame_qbss_load_ie_c* qbss_load_ie = instance->qbss_load_ie();

    if ( qbss_load_ie )

        {

        DEBUG( "core_ap_data_c::instance() - QBSS Load IE detected" );

        DEBUG1( "core_ap_data_c::instance() - Station Count: %u",

            qbss_load_ie->station_count() );

        DEBUG1( "core_ap_data_c::instance() - Channel Utilization: %u",

            qbss_load_ie->channel_utilitization() );

        DEBUG1( "core_ap_data_c::instance() - Available Admission Capacity: %u",

            qbss_load_ie->admission_capacity() );

        delete qbss_load_ie;

        qbss_load_ie = NULL;

        }

#endif // _DEBUG

    return instance;

    }

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

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

//

bool_t core_ap_data_c::is_short_preamble_allowed() const

    {

    if ( frame_m->capability() & CAPABILITY_BIT_MASK_PREAMBLE )

        {

        return true_t;

        }

    return false_t;

    }

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

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

//

bool_t core_ap_data_c::is_short_slot_time_used() const

    {

    if ( frame_m->capability() & CAPABILITY_BIT_MASK_SLOT_TIME )

        {

        return true_t;

        }

    return false_t;

    }

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

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

//

bool_t core_ap_data_c::is_infra() const

    {

    if ( frame_m->capability() & CAPABILITY_BIT_MASK_ESS )

        {

        return true_t;

        }

    return false_t;

    }

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

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

//

bool_t core_ap_data_c::is_radio_measurement_supported() const

    {

    if ( frame_m->capability() & core_frame_dot11_c::core_dot11_capability_radio_measurement )

        {

        return true_t;

        }

    return false_t;

    }

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

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

//

bool_t core_ap_data_c::is_wpa_ie_present() const

    {

    if ( capabilities_bitmap_m & core_am_ap_data_capability_wpa_ie_present )

        {

        return true_t;

        }

    return false_t;

    }

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

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

//

bool_t core_ap_data_c::is_rsn_ie_present() const

    {

    if ( capabilities_bitmap_m & core_am_ap_data_capability_rsn_ie_present )

        {

        return true_t;

        }

    return false_t;

    }

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

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

//

bool_t core_ap_data_c::is_wmm_ie_present() const