/*

* Copyright (c) 2006-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:  Statemachine for handling received measurement request.

*

*/

#include "core_operation_handle_measurement_request.h"

#include "core_frame_dot11_ie.h"

#include "core_frame_mgmt_ie.h"

#include "core_frame_rm_ie.h"

#include "core_frame_rm_ie_beacon_report.h"

#include "core_frame_rm_ie_beacon_report_ie.h"

#include "core_frame_rm_ie_beacon_report_frame_body_ie.h"

#include "core_frame_rm_ie_beacon_request.h"

#include "core_frame_rm_ie_beacon_request_ie.h"

#include "core_frame_rm_ie_beacon_request_detail_ie.h"

#include "core_frame_action_rm.h"

#include "core_tools.h"

#include "core_server.h"

#include "am_debug.h"

#include "core_am_tools.h"

const u16_t PARSED_NONE                 = 0;

const u16_t MEASUREMENT_REQUEST_PARSED  = 1;

const u16_t BEACON_REQUEST_PARSED       = 2;

const u16_t SSID_IE_PARSED              = 4;

const u16_t BRI_IE_PARSED               = 8;

const u16_t BRD_IE_PARSED               = 16;

const u16_t AP_CH_REP_IE_PARSED         = 32;

const u16_t REQUEST_IE_PARSED           = 64;

const u16_t SSID_IE_PARSING_FAILED      = 128;

const u16_t BRI_IE_PARSING_FAILED       = 256;

const u16_t BRD_IE_PARSING_FAILED       = 512;

const u16_t AP_CH_REP_IE_PARSING_FAILED = 1024;

const u16_t REQUEST_IE_PARSING_FAILED   = 2048;

const u16_t CATEGORY_ERROR_IND          = 128;

const u8_t BEACON_TABLE_REPORTED_FRAME_INFORMATION      = 0xFF;

const u8_t ANTENNA_ID                                   = 0x00;

const u8_t BEACON_TABLE_REGULATORY_CLASS                = 0xFF;

const u16_t BEACON_TABLE_MEASUREMENT_DURATION           = 0x0000;

const u8_t MEASUREMENT_REPORT_MODE_OK                   = 0x00;

const u8_t MEASUREMENT_REPORT_MODE_INCAPABLE            = 0x02;

const u8_t MEASUREMENT_REPORT_MODE_REFUSED              = 0x04;

const u8_t DURATION_MANDATORY                           = 0x10;

const u8_t SCAN_ALL_CHANNELS_IN_REGULATORY_CLASS        = 0x00;

const u8_t SCAN_ALL_CHANNELS_IN_AP_CH_REPORT            = 0xFF;

const u8_t REQUEST_IE_MAX_LENGTH = 237;

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

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

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

//

core_operation_handle_measurement_request_c::core_operation_handle_measurement_request_c(

    u32_t request_id,

    core_server_c* server,

    abs_core_driverif_c* drivers,

    abs_core_server_callback_c* adaptation,

    core_frame_action_rm_c* measurement_request ) :

    core_operation_base_c( core_operation_handle_measurement_request, request_id, server, drivers, adaptation, 

        core_base_flag_none ),

    measurement_request_m( measurement_request ),

    parsed_mask_m( PARSED_NONE ),

    current_ie_m( NULL ),

    report_m ( NULL ),

    meas_req_parser_m ( NULL ),

    beacon_req_parser_m ( NULL ),

    ssid_parser_m ( NULL ),

    bri_parser_m ( NULL ),

    brd_parser_m ( NULL ),

    ap_ch_rep_parser_m ( NULL ),

    request_ie_parser_m ( NULL ),

    actual_measurement_duration_m ( 0 )

    {

    DEBUG( "core_operation_handle_measurement_request_c::core_operation_handle_measurement_request_c()" );

    }

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

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

//

core_operation_handle_measurement_request_c::~core_operation_handle_measurement_request_c()

    {

    DEBUG( "core_operation_handle_measurement_request_c::~core_operation_handle_measurement_request_c()" );

    server_m->unregister_event_handler( this );

    server_m->unregister_frame_handler( this );

    ie_list_m.clear();

    if ( measurement_request_m )

        {

        delete measurement_request_m;

        measurement_request_m = NULL;

        }

    if ( current_ie_m )

        {

        delete current_ie_m;

        current_ie_m = NULL;

        }

    if ( beacon_req_parser_m )

        {

        delete beacon_req_parser_m;

        beacon_req_parser_m = NULL;

        }

    if ( meas_req_parser_m )

        {

        delete meas_req_parser_m;

        meas_req_parser_m = NULL;

        }

    if ( ssid_parser_m )

        {

        delete ssid_parser_m;

        ssid_parser_m = NULL;

        }

    if ( bri_parser_m )

        {

        delete bri_parser_m;

        bri_parser_m = NULL;

        }

    if ( brd_parser_m )

        {

        delete brd_parser_m;

        brd_parser_m = NULL;

        }

    if ( ap_ch_rep_parser_m )

        {

        delete ap_ch_rep_parser_m;

        ap_ch_rep_parser_m = NULL;

        }

    if ( request_ie_parser_m )

        {

        delete request_ie_parser_m;

        request_ie_parser_m = NULL;

        }

    if ( report_m )

        {

        delete report_m;

        report_m = NULL;

        }

    }

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

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

//

core_error_e core_operation_handle_measurement_request_c::next_state()

    {

    DEBUG( "core_operation_handle_measurement_request_c::next_state()" );

    switch ( operation_state_m )

        {

        case core_state_init:

            {

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - core_state_init" );

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

                {

                DEBUG( "core_operation_handle_measurement_request_c::next_state() - not connected, nothing to do" );

                return core_error_general;

                }

            status_m.set_da( measurement_request_m->source() );

            status_m.set_sa( server_m->own_mac_addr() );

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - Request data layout" );

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

            DEBUG1( "core_operation_handle_measurement_request_c::next_state() - Dialog token: 0x%02X",

                    measurement_request_m->dialog_token() );

            DEBUG1( "core_operation_handle_measurement_request_c::next_state() - Number of repetitions: 0x%04X",

                    measurement_request_m->nbr_of_repetitions() );

            // validate measurement interval

            if ( !validate_measurement_interval() )

                {

                DEBUG( "core_operation_handle_measurement_request_c::next_state() - Measurement Request coming too often, refusing request" );

                status_m.set_too_short_interval( true_t );

                }

            // loop through IEs

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

                {

                DEBUG( "core_operation_handle_measurement_request_c::next_state() - Found IE:" );

                DEBUG1( "core_operation_handle_measurement_request_c::next_state() - ID: 0x%02X",

                    ie->element_id() );

                DEBUG1( "core_operation_handle_measurement_request_c::next_state() - Length: 0x%02X",

                    ie->length() );

                ie_list_m.append( ie );

                }

            if ( ie_list_m.count() == 0 )

                {

                DEBUG( "core_operation_handle_measurement_request_c::next_state() - Measurement request didn't contain any IEs -> sending frame back" );

                status_m.set_error_in_request( true_t );

                return goto_state( core_state_create_negative_response );

                }

            return goto_state( core_state_get_next_ie );

            }

        case core_state_get_next_ie:

            {

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - state core_state_get_next_ie" );

            initialise_beacon_request_data();

            if ( current_ie_m != NULL )

                {

                // deallocate IE

                delete current_ie_m;

                current_ie_m = NULL;

                }

            current_ie_m = ie_list_m.first();

            if ( current_ie_m == NULL )

                {

                DEBUG( "core_operation_handle_measurement_request_c::next_state() - All IEs processed" );

                if ( report_m != NULL )

                    {

                    // send created response

                    return goto_state( core_state_send_response );

                    }

                else

                    {

                    return goto_state( core_state_operation_finished );

                    }

                }

            // remove ie from list, it is now owned by current_ie_m

            ie_list_m.remove ( current_ie_m );

            return asynch_goto( core_state_process_current_ie );

            }

        case core_state_process_current_ie:

            {

            if ( current_ie_m->element_id() == core_frame_dot11_ie_c::core_frame_dot11_ie_element_id_measurement_req )

                {

                // parse IE

                parse( current_ie_m, parsed_mask_m );

                // deallocate IE

                delete current_ie_m;

                current_ie_m = NULL;

                if ( status_m.error_in_request() == true_t )

                    {

                    DEBUG( "core_operation_handle_measurement_request_c::next_state() - Error in request, send frame back and stop further processing." );

                    return goto_state( core_state_create_negative_response );

                    }

                if ( status_m.refuse_request() == true_t )

                    {

                    DEBUG( "core_operation_handle_measurement_request_c::next_state() - Refusing request." );                  

                    return goto_state( core_state_create_negative_response );

                    }

                if ( status_m.too_short_interval() == true_t )

                    {

                    DEBUG( "core_operation_handle_measurement_request_c::next_state() - Too short request interval, refusing request." );

                    status_m.set_refuse_request( true_t );

                    return goto_state( core_state_create_negative_response );

                    }

                DEBUG( "core_operation_handle_measurement_request_c::next_state() - Going to core_state_make_measurement." );

                return asynch_goto( core_state_make_measurement, get_random_delay() );

                }

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - Non-supported measurement request IE received, ignoring." );

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - Going to core_state_get_next_ie." );

            return goto_state( core_state_get_next_ie );

            }

        case core_state_make_measurement:

            {

            ASSERT( beacon_req_parser_m );

            core_scan_mode_e scan_mode( core_scan_mode_active );

            actual_measurement_duration_m = get_channel_time( core_frame_rm_ie_beacon_request_c::core_beacon_request_scan_mode_active );

            core_ssid_s scan_ssid = get_ssid();

            if ( ap_ch_rep_parser_m )

                {

                core_scan_channels_c scan_channels = get_channels();

                status_m.set_scan_channels( scan_channels.channels() );

                }

            switch ( beacon_req_parser_m->measurement_mode() )

                {

                case core_frame_rm_ie_beacon_request_c::core_beacon_request_scan_mode_beacon:

                    {                    

                    DEBUG( "core_operation_handle_measurement_request_c::next_state() - beacon table measurement" );

                    actual_measurement_duration_m = get_channel_time( core_frame_rm_ie_beacon_request_c::core_beacon_request_scan_mode_beacon );

                    return asynch_goto( core_state_create_response );

                    }

                case core_frame_rm_ie_beacon_request_c::core_beacon_request_scan_mode_active:

                    {

                    DEBUG( "core_operation_handle_measurement_request_c::next_state() - issuing active scan request" );

                    break;

                    }

                case core_frame_rm_ie_beacon_request_c::core_beacon_request_scan_mode_passive:

                    {

                    DEBUG( "core_operation_handle_measurement_request_c::next_state() - issuing passive scan request" );

                    scan_mode = core_scan_mode_passive;

                    actual_measurement_duration_m = get_channel_time( core_frame_rm_ie_beacon_request_c::core_beacon_request_scan_mode_passive );

                    break;

                    }

                default:

                    {

                    // by default perform active mode measurement

                    break;

                    }

                }

            u32_t ch_time( actual_measurement_duration_m );

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - issuing scan request:" );

            DEBUG1S( "core_operation_handle_measurement_request_c::next_state() - SSID: ", scan_ssid.length, &scan_ssid.ssid[0] );

#ifdef _DEBUG

            u16_t mask( 0 );

            core_tools_c::copy(

                reinterpret_cast<u8_t*>( &mask ),

                &status_m.get_scan_channels().channels2dot4ghz[0],            

                sizeof( status_m.get_scan_channels().channels2dot4ghz ) );

#endif // _DEBUG

            DEBUG1( "core_operation_handle_measurement_request_c::next_state() - channel mask: %013b", mask );

            DEBUG1( "core_operation_handle_measurement_request_c::next_state() - min ch time: %u", ch_time );

            DEBUG1( "core_operation_handle_measurement_request_c::next_state() - max ch time: %u", ch_time );

            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 );

            server_m->register_event_handler( this );

            server_m->register_frame_handler( this );

            drivers_m->scan(

                request_id_m,

                scan_mode,

                scan_ssid,

                server_m->get_device_settings().scan_rate,

                status_m.get_scan_channels(),

                ch_time,

                ch_time,

                false_t );

            operation_state_m = core_state_scan_start;

            return core_error_request_pending;

            }

        case core_state_scan_start:

            {

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

            break;

            }

        case core_state_create_response:

            {

            core_scan_list_tag_e tag( core_scan_list_tag_scan );

            if ( beacon_req_parser_m->measurement_mode() == core_frame_rm_ie_beacon_request_c::core_beacon_request_scan_mode_beacon )

                {

                tag = core_scan_list_tag_none;

                }

#ifdef _DEBUG

            server_m->get_scan_list().print_contents();      

#endif

            core_scan_list_iterator_by_tag_c iter(

                server_m->get_scan_list(),

                tag );

            bool_t no_match( true_t );

            // loop through the scan list

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

                {

                if ( !match_found( *ap_data ) )

                    {

                    // no match found, proceed to the next beacon/probe

                    continue;

                    }

                no_match = false_t;

                if ( !create_response( *ap_data ) )

                    {

                    // create_response returns false_t only in out-of-memory situation

                    return core_error_no_memory;

                    }

                }

            if ( no_match )

                {

                create_negative_response_based_on_meas_report_mode( MEASUREMENT_REPORT_MODE_OK );

                }

            // check if more IEs need to be added to the report

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - Going to core_state_get_next_ie." );

            return goto_state( core_state_get_next_ie );

            }

        case core_state_create_negative_response:

            {

            if ( !create_negative_response() )

                {

                DEBUG( "core_operation_handle_measurement_request_c::next_state() - Unable to create response to request" );

                // create_response returns false only in out-of-memory situation

                return core_error_no_memory;

                }

            return goto_state( core_state_send_response );

            }

        case core_state_send_response:

            {

            DEBUG1( "core_operation_handle_measurement_request_c::next_state() - sending frame (%u bytes): ",

                report_m->data_length() );

            DEBUG_BUFFER(

                report_m->data_length(),

                report_m->data() );

            server_m->send_management_frame(

                core_frame_type_dot11,

                report_m->data_length(),

                report_m->data(),

                status_m.da() );

            return goto_state( core_state_operation_finished );

            }

        case core_state_operation_finished:

            {

            DEBUG( "core_operation_handle_measurement_request_c::next_state() - state core_state_operation_finished" );

            return core_error_ok;

            }

        default:

            {

            ASSERT( false_t );

            }

        }

    return core_error_request_pending;

    }

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

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

//

bool_t core_operation_handle_measurement_request_c::add_to_report(

        const core_frame_rm_ie_c* ie ) 

    {

    DEBUG( "core_operation_handle_measurement_request_c::add_to_report()" );

    if ( report_m == NULL )

        {

        // instantiate response

        report_m = core_frame_action_rm_c::instance(

                                            0,                          // Duration

                                            status_m.da(),              // Destination

                                            status_m.sa(),              // Source

                                            status_m.da(),              // BSSID

                                            0,                          // Sequence Control

                                            core_frame_action_rm_c::core_dot11_action_rm_type_meas_resp, // Action Type

                                            measurement_request_m->dialog_token(),     // Dialog Token

                                            ie );                       // RM IE

        if ( report_m == NULL )

            {

            // unable to instantiate response

            return false_t;

            }

        }

    else

        {

        report_m->append_ie( ie );

        }

    return true_t;

    }

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

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

//

void core_operation_handle_measurement_request_c::parse(

        core_frame_dot11_ie_c* ie,

        u16_t& parsed_mask )

    {

    DEBUG( "core_operation_handle_measurement_request_c::parse() - * Measurement Request IE received *" );

    // refuse repetitive measurements

    if ( measurement_request_m->nbr_of_repetitions() )

        {

        DEBUG( "core_operation_handle_measurement_request_c::parse() - refusing repeated measurement" );

        status_m.set_refuse_request( true_t );

        }

    if ( meas_req_parser_m != NULL )

        {

        delete meas_req_parser_m;