/*

* 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:  Main class for core server

*

*/

/*

*/

#include "core_server.h"

#include "abs_core_server_callback.h"

#include "abs_core_driverif.h"

#include "abs_core_timer.h"

#include "abs_core_frame_handler.h"

#include "abs_core_event_handler.h"

#include "core_timer_factory.h"

#include "core_operation_connect.h"

#include "core_operation_update_device_settings.h"

#include "core_operation_scan.h"

#include "core_operation_get_available_iaps.h"

#include "core_operation_release.h"

#include "core_operation_unload_drivers.h"

#include "core_operation_check_rcpi.h"

#include "core_operation_handle_frame.h"

#include "core_operation_null.h"

#include "core_operation_get_rcpi.h"

#include "core_operation_configure_multicast_group.h"

#include "core_operation_update_power_mode.h"

#include "core_operation_update_rxtx_parameters.h"

#include "core_operation_get_statistics.h"

#include "core_operation_set_uapsd_settings.h"

#include "core_operation_set_power_save_settings.h"

#include "core_operation_protected_setup.h"

#include "core_operation_create_ts.h"

#include "core_operation_delete_ts.h"

#include "core_operation_power_save_test.h"

#include "core_operation_set_arp_filter.h"

#include "core_operation_directed_roam.h"

#include "core_frame_ethernet.h"

#include "core_connection_data.h"

#include "core_eapol_handler.h"

#include "core_frame_dot11.h"

#include "core_frame_echo_test.h"

#include "am_debug.h"

#include "core_callback.h"

#include "core_tools.h"

#include "core_tools_parser.h"

#include "core_wpx_adaptation_factory.h"

#include "core_traffic_stream_list_iter.h"

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

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

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

//

core_server_c::core_server_c(

    abs_core_server_callback_c& callback,

    abs_core_driverif_c& drivers,

    const core_device_settings_s& settings,

    const core_mac_address_s& mac_address,

    u32_t features ) :

    callback_m( callback ),

    drivers_m( drivers ),

    device_settings_m( settings ),

    queue_m( ),

    queue_timer_m( NULL ),

    driver_unload_timer_m( NULL ),

    core_settings_m( features ),

    connection_data_m( NULL ),

    own_mac_addr_m( mac_address ),

    eapol_handler_m( NULL ),

    eapol_m( NULL ),

    cm_timer_m( ),

    roam_timer_m( NULL ),

    operation_timer_m( NULL ),

    driver_dhcp_timer_m( NULL ),

    frame_handler_m( NULL ),

    event_handler_m( NULL ),

    scan_list_m( ),

    wpx_adaptation_m( NULL )

    {

    DEBUG( "core_server_c::core_server_c()" );

    queue_m.clear();

    }

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

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

//

core_server_c::~core_server_c()

    {

    DEBUG( "core_server_c::~core_server_c()" );

    queue_m.clear();

    delete connection_data_m;

    if ( queue_timer_m )

        {

        queue_timer_m->stop();

        core_timer_factory_c::destroy_timer( queue_timer_m );

        queue_timer_m = NULL;

        }

    if ( driver_unload_timer_m )

        {

        driver_unload_timer_m->stop();

        core_timer_factory_c::destroy_timer( driver_unload_timer_m );

        driver_unload_timer_m = NULL;

        }

    if ( roam_timer_m )

        {

        roam_timer_m->stop();

        core_timer_factory_c::destroy_timer( roam_timer_m );

        roam_timer_m = NULL;

        }

    if ( operation_timer_m )

        {

        operation_timer_m->stop();

        core_timer_factory_c::destroy_timer( operation_timer_m );

        operation_timer_m = NULL;

        }

    if ( driver_dhcp_timer_m )

        {

        driver_dhcp_timer_m->stop();

        core_timer_factory_c::destroy_timer( driver_dhcp_timer_m );

        driver_dhcp_timer_m = NULL;

        }

    if ( eapol_m )

        {

        eapol_m->shutdown();

        delete eapol_m;

        }

    delete wpx_adaptation_m;

    delete eapol_handler_m;

    frame_handler_m = NULL;

    event_handler_m = NULL;

    }

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

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

//

core_error_e core_server_c::init()

    {

    DEBUG( "core_server_c::init()" );

    drivers_m.init( this );

    core_callback_c* queue_timer_callback = 

        new core_callback_c( &(core_server_c::queue_timer_expired), this );

    if( !queue_timer_callback )

        {

        DEBUG("ERROR creating callback object");

        return core_error_no_memory;

        }

    queue_timer_m = core_timer_factory_c::create_timer( queue_timer_callback );

    if( !queue_timer_m )

        {

        DEBUG( "ERROR creating timer" );

        delete queue_timer_callback;

        return core_error_no_memory;

        }

    core_callback_c* unload_timer_callback = 

        new core_callback_c( &(core_server_c::unload_timer_expired), this );

    if( !unload_timer_callback )

        {

        DEBUG("ERROR creating callback object");

        return core_error_no_memory;

        }

    driver_unload_timer_m = core_timer_factory_c::create_timer( unload_timer_callback );

    if( !driver_unload_timer_m )

        {

        DEBUG( "ERROR creating timer" );

        delete unload_timer_callback;

        return core_error_no_memory;

        }

    core_callback_c* roam_timer_callback = 

        new core_callback_c( &(core_server_c::roam_timer_expired), this );

    if( !roam_timer_callback )

        {

        DEBUG("ERROR creating callback object");

        return core_error_no_memory;

        }

    roam_timer_m = core_timer_factory_c::create_timer( roam_timer_callback );

    if( !roam_timer_m )

        {

        DEBUG( "ERROR creating timer" );

        delete roam_timer_callback;

        return core_error_no_memory;

        } 

    core_callback_c* operation_timer_callback = 

        new core_callback_c( &(core_server_c::operation_timer_expired), this );

    if( !operation_timer_callback )

        {

        DEBUG("ERROR creating callback object");

        return core_error_no_memory;

        }

    operation_timer_m = core_timer_factory_c::create_timer( operation_timer_callback );

    if( !operation_timer_m )

        {

        DEBUG( "ERROR creating timer" );

        delete operation_timer_callback;

        return core_error_no_memory;

        } 

    core_callback_c* dhcp_timer_callback = 

        new core_callback_c( &(core_server_c::dhcp_timer_expired), this );

    if( !dhcp_timer_callback )

        {

        DEBUG("ERROR creating callback object");

        return core_error_no_memory;

        }        

    driver_dhcp_timer_m = core_timer_factory_c::create_timer( dhcp_timer_callback );

    if( !driver_dhcp_timer_m )

        {

        DEBUG( "ERROR creating timer" );

        delete dhcp_timer_callback;

        return core_error_no_memory;

        } 

    wpx_adaptation_m = core_wpx_adaptation_factory_c::instance(

        this, &drivers_m, &callback_m );

    if ( !wpx_adaptation_m )

        {

        DEBUG("ERROR creating WPX adaptation");

        return core_error_no_memory;

        }

    eapol_handler_m = new core_eapol_handler_c(

        this, &drivers_m, &callback_m );

    if ( !eapol_handler_m )

        {

        DEBUG("ERROR creating eapol handler");

        return core_error_no_memory;

        }

    core_settings_m.set_rcpi_boundaries(

        device_settings_m.rcpi_trigger,

        device_settings_m.rcpi_trigger + device_settings_m.rcpi_difference );

    return core_error_ok;

    }

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

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

//

core_device_settings_s& core_server_c::get_device_settings()

    {

    return device_settings_m;

    }

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

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

//

core_settings_c& core_server_c::get_core_settings()

    {

    return core_settings_m;

    }

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

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

//

core_connection_data_c* core_server_c::get_connection_data()

    {

    return connection_data_m;

    }

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

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

//

core_wlan_eapol_interface_c& core_server_c::get_eapol_instance()

    {

    return *eapol_m;

    }

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

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

//

void core_server_c::set_eapol_handler(

    abs_wlan_eapol_callback_interface_c* handler )

    {

    eapol_handler_m->set_eapol_handler( handler );

    }

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

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

//

core_mac_address_s& core_server_c::own_mac_addr()

    {

    return own_mac_addr_m;

    }

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

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

//

core_error_e core_server_c::queue_int_operation(

    core_operation_base_c* operation )

    {

    DEBUG( "core_server_c::queue_int_operation()" );

    if ( !operation )

        {

        DEBUG( "core_server_c::queue_int_operation() - no operation" );

        return core_error_no_memory;

        }

    else if ( operation->is_flags( core_operation_base_c::core_base_flag_only_one_instance ) &&

        is_operation_in_queue_with_type( operation->operation_type() ) )

        {

        DEBUG( "core_server_c::queue_int_operation() - only one instance allowed in the operation queue" );

        delete operation;

        operation = NULL;

        return core_error_already_exists;

        }

    else

        {

        core_error_e ret = queue_m.append( operation );

        if ( ret != core_error_ok )

            {

            DEBUG1( "core_server_c::queue_int_operation() - unable to queue the request (%u)",

                ret );

            delete operation;

            operation = NULL;

            return ret;

            }

        }

    return core_error_ok;    

    }

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

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

//

core_error_e core_server_c::queue_int_operation_and_run_next(

    core_operation_base_c* operation )

    {

    DEBUG( "core_server_c::queue_int_operation_and_run_next()" );

    core_error_e ret = queue_int_operation( operation );

    if ( ret != core_error_ok )

        {

        return ret;

        }

    schedule_operation();

    return core_error_ok;

    }

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

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

//

core_error_e core_server_c::init_connection_data(

    const core_iap_data_s& iap_data,

    const core_device_settings_s& device_settings )

    {

    connection_data_m = new core_connection_data_c( iap_data, device_settings );

    if ( !connection_data_m )

        {

        return core_error_no_memory;

        }

    return core_error_ok;

    }

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

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

//    

void core_server_c::clear_connection_data()

    {

    DEBUG( "core_server_c::clear_connection_data()" );

    delete connection_data_m;

    connection_data_m = NULL;

    }

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

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

//

void core_server_c::schedule_roam_timer(

    u32_t delay )

    {

    DEBUG1( "core_server_c::schedule_roam_timer() - delay %u",

        delay );

    ASSERT( !roam_timer_m->is_active() );

    roam_timer_m->start(

        delay );    

    }

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

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

//

void core_server_c::cancel_roam_timer()

    {

    DEBUG( "core_server_c::cancel_roam_timer()" );

    roam_timer_m->stop();

    }

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

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

//    

void core_server_c::roam_timer_expired(

    void* this_ptr )

    {

    DEBUG("core_server_c::roam_timer_expired()");

    core_server_c* self = static_cast<core_server_c*>( this_ptr );

    // send an indication to adaptation

    self->callback_m.notify(

        core_notification_rcpi_roam_attempt_started,

        0, 

        NULL );

    core_operation_base_c* command = new core_operation_check_rcpi_c(

        REQUEST_ID_CORE_INTERNAL,

        self,

        &(self->drivers_m),

        &(self->callback_m),

        core_operation_check_rcpi_c::core_rcpi_check_reason_timer );

    self->queue_int_operation_and_run_next( command );

    }

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

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

//

void core_server_c::schedule_operation_timer(

    u32_t delay )

    {

    DEBUG1( "core_server_c::schedule_operation_timer() - delay %u",

        delay );

    ASSERT( !operation_timer_m->is_active() );

    operation_timer_m->start(

        delay );    

    }

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

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

//

void core_server_c::cancel_operation_timer()

    {

    DEBUG( "core_server_c::cancel_operation_timer()" );

    operation_timer_m->stop();

    }

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

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

//    

void core_server_c::operation_timer_expired(

    void* this_ptr )

    {

    DEBUG("core_server_c::operation_timer_expired()");

    core_server_c* self = static_cast<core_server_c*>( this_ptr );

    core_operation_base_c* command = self->queue_m.first();

    ASSERT( command );

    ASSERT( command->is_executing() );

    self->request_complete( command->request_id(), core_error_ok );

    }

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

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

//

bool_t core_server_c::is_operation_in_queue_with_flags(

    u32_t feature_flags )

    {

    core_type_list_iterator_c<core_operation_base_c> iter( queue_m );

    for( core_operation_base_c* current = iter.first(); current; current = iter.next() )

        {

        if ( current->is_flags( feature_flags ) )

            {

            return true_t;

            }

        }

    return false_t;    

    }

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

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

//

bool_t core_server_c::is_operation_in_queue_with_type(

    u32_t type )

    {

    core_type_list_iterator_c<core_operation_base_c> iter( queue_m );

    for( core_operation_base_c* current = iter.first(); current; current = iter.next() )

        {

        if ( current->operation_type() == type )

            {

            return true_t;

            }

        }

    return false_t;    

    }

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

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

//

bool_t core_server_c::is_dhcp_timer_active()

    {

    return driver_dhcp_timer_m->is_active();

    }

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

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

//