/*

* 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 IAP availability.

*

*/

/*

*/

#include "core_operation_get_available_iaps.h"

#include "core_server.h"

#include "core_tools.h"

#include "core_tools_parser.h"

#include "core_frame_dot11.h"

#include "core_frame_dot11_ie.h"

#include "am_debug.h"

const u32_t LONG_PASSIVE_SCAN_CHANNEL_TIME = 210;

/**

 * If the phone has at least this many IAPs marked as hidden,

 * limiting algorithm will be used for detecting available IAPs.

 */

const u8_t MIN_HIDDEN_IAPS_FOR_LIMITING_ALGORITHM = 15;

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

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

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

//

core_operation_get_available_iaps_c::core_operation_get_available_iaps_c(

    u32_t request_id,

    core_server_c* server,        

    abs_core_driverif_c* drivers,

    abs_core_server_callback_c* adaptation,

    bool_t is_active_scan_allowed,

    core_type_list_c<core_iap_data_s>& iap_data_list,

    core_type_list_c<core_ssid_entry_s>* iap_ssid_list,

    ScanList& scan_data ) :

    core_operation_base_c( core_operation_get_available_iaps, request_id, server, drivers, adaptation,

        core_base_flag_drivers_needed ),    

    is_active_scan_allowed_m( is_active_scan_allowed ),

    is_limiting_algorithm_used_m( false_t ),

    iap_data_list_m( iap_data_list ),

    iap_ssid_list_m( iap_ssid_list ),

    client_scan_data_m( scan_data ),

    active_channels_m( ),

    broadcast_channels_m( ),

    long_broadcast_count_m( 0 ),

    is_split_scan_m( false_t ),

    bss_count_m( 0 ),

    region_from_ap_m( core_wlan_region_fcc )

    {

    DEBUG( "core_operation_get_available_iaps_c::core_operation_get_available_iaps_c()" );

    }

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

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

//

core_operation_get_available_iaps_c::~core_operation_get_available_iaps_c()

    {

    DEBUG( "core_operation_get_available_iaps_c::~core_operation_get_available_iaps_c()" );

    server_m->unregister_event_handler( this );

    server_m->unregister_frame_handler( this );

    iap_ssid_list_m = NULL;

    }

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

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

//

core_error_e core_operation_get_available_iaps_c::next_state()

    {

    DEBUG( "core_operation_get_available_iaps_c::next_state()" );

    switch ( operation_state_m )

        {

        case core_state_init:

            {

            operation_state_m = core_state_long_broadcast_scan_start;

#ifdef WLAN_CORE_DEEP_DEBUG

            DEBUG( "core_operation_get_available_iaps_c::next_state() - IAP data list:" );

                {

                DEBUG1( "core_operation_get_available_iaps_c::next_state() - ID: %u",

                DEBUG1S( "core_operation_get_available_iaps_c::next_state() - SSID: ",

                }

            if ( iap_ssid_list_m )

                {

                DEBUG( "core_operation_get_available_iaps_c::next_state()" );

                DEBUG( "core_operation_get_available_iaps_c::next_state() - Secondary SSID list:" );

                core_ssid_entry_s* iter_entry = iap_ssid_list_m->first();

                while( iter_entry )

                    {

                    DEBUG1( "core_operation_get_available_iaps_c::next_state() - ID: %u",

                        iter_entry->id );

                    DEBUG1S( "core_operation_get_available_iaps_c::next_state() - SSID: ",

                        iter_entry->ssid.length, iter_entry->ssid.ssid );

                    DEBUG1S( "core_operation_get_available_iaps_c::next_state() - Used SSID: ",

                        iter_entry->used_ssid.length, iter_entry->used_ssid.ssid );

                    iter_entry = iap_ssid_list_m->next();

                    }

                DEBUG( "core_operation_get_available_iaps_c::next_state()" );

                }

#endif // WLAN_CORE_DEEP_DEBUG

            server_m->get_scan_list().remove_entries_by_age(

                server_m->get_device_settings().scan_list_expiration_time );

            server_m->get_scan_list().set_tag(

                core_scan_list_tag_scan );

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

                {

                is_split_scan_m = true_t;

                DEBUG( "core_operation_get_available_iaps_c::next_state() - using a split-scan" );

                }

            else

                {

                DEBUG( "core_operation_get_available_iaps_c::next_state() - using a regular scan" );

                }

            /**

             * Limiting algorithm is only used when there's a certain amount of IAPs

             * marked as hidden.

             */

            if ( hidden_iap_count( iap_data_list_m ) >= MIN_HIDDEN_IAPS_FOR_LIMITING_ALGORITHM )

                {

                DEBUG1( "core_operation_get_available_iaps_c::next_state() - %u hidden IAPs defined, using limiting algorithm",

                    hidden_iap_count( iap_data_list_m ) );

                is_limiting_algorithm_used_m = true_t;

                }

            /**

             * Construct a channel mask of channels that have previously contained

             * APs with long beacon intervals.

             */

            core_long_beacon_interval_channels_s& long_beacon_interval_channels(

                server_m->get_core_settings().long_beacon_interval_channels() );

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

                {

                if ( long_beacon_interval_channels.channel_scan_count[idx] )

                    {

                    long_beacon_interval_channels.channel_scan_count[idx]--;

                    const u8_t channel( idx + 1);

                    if ( server_m->get_core_settings().mcc_known() )

                    	{

                    	if ( server_m->get_core_settings().is_valid_channel(

                            SCAN_BAND_2DOT4GHZ,

                            channel ) )

                            {

                            long_broadcast_count_m++;

                            broadcast_channels_m.add(

                                SCAN_BAND_2DOT4GHZ,

                                channel );

                            }

                    	}

                    else

                    	{

                    	long_broadcast_count_m++;

                    	broadcast_channels_m.add(

                                SCAN_BAND_2DOT4GHZ,

                                channel );

                        }

                    }

                }

            /**

             * If we can active scan or the channel mask is empty, we can jump

             * directly to the main broadcast scan.             

             */

            if ( is_active_scan_allowed_m ||

                 !long_broadcast_count_m )

                {

                long_broadcast_count_m = 0;

                return goto_state( core_state_long_broadcast_scan_done );

                }

            const core_scan_channels_s channels(

                broadcast_channels_m.channels() );

            DEBUG2( "core_operation_get_available_iaps_c::next_state() - requesting long passive broadcast scan on channels 0x%02X%02X",

                channels.channels2dot4ghz[1],

                channels.channels2dot4ghz[0] );

            server_m->register_event_handler( this );

            server_m->register_frame_handler( this );

            drivers_m->scan(

                request_id_m,

                core_scan_mode_passive,

                BROADCAST_SSID,

                server_m->get_device_settings().scan_rate,

                channels,

                LONG_PASSIVE_SCAN_CHANNEL_TIME,

                LONG_PASSIVE_SCAN_CHANNEL_TIME,

                is_split_scan_m );

            break;

            }

        case core_state_long_broadcast_scan_start:

            {

            DEBUG( "core_operation_get_available_iaps_c::next_state() - long broadcast scan request completed, waiting for scan completion" );

            break;

            }

        case core_state_long_broadcast_scan_done:

            {

            operation_state_m = core_state_broadcast_scan_start;

            if ( !long_broadcast_count_m )

                {

                broadcast_channels_m.set(

                    server_m->get_core_settings().all_valid_scan_channels() );

                }

            else

                {

                broadcast_channels_m.invert_channels();

                }

            const core_scan_channels_s channels(

                server_m->get_core_settings().valid_scan_channels( broadcast_channels_m.channels() ) );

            if ( !is_active_scan_allowed_m ||

                 is_limiting_algorithm_used_m )

                {

                DEBUG2( "core_operation_get_available_iaps_c::next_state() - requesting passive broadcast scan on channels 0x%02X%02X",

                    channels.channels2dot4ghz[1],

                    channels.channels2dot4ghz[0] );

                server_m->register_event_handler( this );

                server_m->register_frame_handler( this );

                drivers_m->scan(

                    request_id_m,

                    core_scan_mode_passive,

                    BROADCAST_SSID,

                    server_m->get_device_settings().scan_rate,

                    channels,

                    server_m->get_device_settings().passive_scan_min_ch_time,

                    server_m->get_device_settings().passive_scan_max_ch_time,

                    is_split_scan_m );

                }

            else

                {

                DEBUG2( "core_operation_get_available_iaps_c::next_state() - requesting active broadcast scan on channels 0x%02X%02X",

                    channels.channels2dot4ghz[1],

                    channels.channels2dot4ghz[0] );

                u32_t min_ch_time( server_m->get_device_settings().active_broadcast_scan_min_ch_time );

                u32_t max_ch_time( server_m->get_device_settings().active_broadcast_scan_max_ch_time );

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

                    {

                    min_ch_time = server_m->get_device_settings().active_scan_min_ch_time;

                    max_ch_time = server_m->get_device_settings().active_scan_max_ch_time;

                    }

                server_m->register_event_handler( this );

                server_m->register_frame_handler( this );

                drivers_m->scan(

                    request_id_m,

                    core_scan_mode_active,

                    BROADCAST_SSID,

                    server_m->get_device_settings().scan_rate,

                    channels,

                    min_ch_time,

                    max_ch_time,

                    is_split_scan_m );

                }

            break;

            }

        case core_state_broadcast_scan_start:

            {

            DEBUG( "core_operation_get_available_iaps_c::next_state() - broadcast scan request completed, waiting for scan completion" );

            break;            

            }

        case core_state_broadcast_scan_done:

            {            

            if ( server_m->get_core_settings().mcc_known() )

            	{

            	/* When WLAN region is known, the allowed scan channels are known and 

            	 * handled already */

            	return goto_state( core_state_broadcast_scan_done_handle_result );

            	}

            operation_state_m = core_state_broadcast_scan_start_unknown_region;

            broadcast_channels_m.set(

                    server_m->get_core_settings().all_valid_scan_channels() );

            const core_scan_channels_s channels(

                    server_m->get_core_settings().invalid_scan_channels( broadcast_channels_m.channels() ) );

            server_m->register_event_handler( this );

            server_m->register_frame_handler( this );

            drivers_m->scan(

                    request_id_m,

                    core_scan_mode_passive,

                    BROADCAST_SSID,

                    server_m->get_device_settings().scan_rate,

                    channels,

                    server_m->get_device_settings().passive_scan_min_ch_time,

                    server_m->get_device_settings().passive_scan_max_ch_time,

                    is_split_scan_m );

            break;

            }

        case core_state_broadcast_scan_start_unknown_region:

        	{

            DEBUG( "core_operation_get_available_iaps_c::next_state() - broadcast scan request for channels 12 and 13 completed, waiting for scan completion" );

        	break;

        	}

        case core_state_broadcast_scan_complete_unknown_region:

        	{

            operation_state_m = core_state_store_country_info;

            /* If WLAN region was not known before the scan, then check if country information is present

             * in the scan results. APs on channels 12 and 13 must be ignored if country information indicates this. 

             */

            core_scan_list_iterator_by_tag_c iter_country_beacon(

                server_m->get_scan_list(),

                core_scan_list_tag_scan );

            core_wlan_region_e found_region = core_wlan_region_undefined;

            bool_t inconsistent_info( false_t );

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

                {

                core_country_string_s country_info = ap_data->country_info();

                core_wlan_region_e ap_region = core_wlan_region_undefined;

                if ( country_info.country[0] != 0 )                   

                    {

                    ap_region = core_tools_c::convert_country_to_region( country_info );

                    if ( found_region != core_wlan_region_undefined )

                       	{

                       	if ( ap_region != found_region )

                       		{

                       	    inconsistent_info = true_t; 

                       		}

                       	}

                    else

                       	{

                       	found_region = ap_region;

                       	}                        

                    }

                }

            if ( found_region != core_wlan_region_undefined )

               	{

               	if ( !inconsistent_info )

               		{	

               	    region_from_ap_m = found_region;

               		}

               	else

               		{

               		region_from_ap_m = core_wlan_region_etsi;

               		}

               	adaptation_m->store_ap_country_info( request_id_m, region_from_ap_m, inconsistent_info );

               	}

            else

               	{

               	return goto_state( core_state_broadcast_scan_done_handle_result );

               	}

        	break;

        	}

        case core_state_store_country_info:

          	{

            operation_state_m = core_state_broadcast_scan_done_handle_result;

            /* Set the new region information also to core settings */

            DEBUG1( "core_operation_get_available_iaps_c::next_state() - current region %u",

                region_from_ap_m );

            server_m->get_core_settings().set_regional_domain(

                region_from_ap_m );

            server_m->get_core_settings().set_mcc_known( true_t );

            return goto_state( core_state_broadcast_scan_done_handle_result );

            }

        case core_state_broadcast_scan_done_handle_result:

        	{

        	operation_state_m = core_state_direct_scan_start;

        	/* If region information is not known, channels 12 and 13 are now been scanned in passive mode in any case */

        	/* If region is FCC, then ignore and remove the APs from channels 12 and 13 */

            if ( server_m->get_core_settings().regional_domain() == core_wlan_region_fcc )

            	{

            	DEBUG( "core_operation_get_available_iaps_c::next_state() - remove APs that were found on channels 12 and 13" );

            	remove_disallowed_aps();            	

            	}

            /* If WLAN regional domain is not ETSI, we have to remove the high channels from

             * from the active channels mask to prevent direct scans on those channels.

             */

            if ( server_m->get_core_settings().regional_domain() != core_wlan_region_etsi )

            	{

                for ( u8_t idx( SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_FCC ); idx < SCAN_BAND_2DOT4GHZ_MAX_CHANNEL_EURO; ++idx )

                    {

                    const u8_t channel( idx + 1);

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

                         SCAN_BAND_2DOT4GHZ,

                         channel ) )

                        {

                        active_channels_m.remove(

                            SCAN_BAND_2DOT4GHZ,

                            channel );

                        }

                    }

            	}

            DEBUG1( "core_operation_get_available_iaps_c::next_state() - broadcast scan done, %u beacon(s)/probe(s) received",

                bss_count_m );

            /**

             * Add the results from the broadcast scan to the scan list so that

             * they can be cached in adaptation.

             */

            core_scan_list_iterator_by_tag_c iter(

                server_m->get_scan_list(),

                core_scan_list_tag_scan );

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

                {

                const core_mac_address_s bssid = ap_data->bssid();

                if ( !server_m->get_core_settings().is_mac_in_permanent_blacklist( bssid ) )

                    {

                    core_tools_c::add_beacon_to_scan_list(

                        client_scan_data_m,

                        *ap_data,

                        ap_data->rcpi() );

                    }

                }

            /**

             */

            process_scan_results(

                core_scan_list_tag_scan );

            /**

             * Direct scans are only needed if active scanning is allowed. If limiting algorithm

             * is used, channel activity based on broadcast scan is also required.

             */

            if ( ( is_active_scan_allowed_m &&

                   !is_limiting_algorithm_used_m ) ||

                 ( is_active_scan_allowed_m &&

                   is_limiting_algorithm_used_m &&

                   bss_count_m ) )

                {

                /**

                 * If limiting algorithm is used, only the current active_channels_m

                 * will be used.

                 */               

                    {

                    DEBUG( "core_operation_get_available_iaps_c::next_state() - limiting channels based on WLAN activity" );

                    }

                else

                    {

                    active_channels_m.set(

                        server_m->get_core_settings().all_valid_scan_channels() );