1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Main class for core server

    15 *

    16 */

    17 

    18 /*

    19 * %version: 89 %

    20 */

    21 

    22 #include "core_server.h"

    23 #include "abs_core_server_callback.h"

    24 #include "abs_core_driverif.h"

    25 #include "abs_core_timer.h"

    26 #include "abs_core_frame_handler.h"

    27 #include "abs_core_event_handler.h"

    28 #include "core_timer_factory.h"

    29 #include "core_operation_connect.h"

    30 #include "core_operation_update_device_settings.h"

    31 #include "core_operation_scan.h"

    32 #include "core_operation_get_available_iaps.h"

    33 #include "core_operation_release.h"

    34 #include "core_operation_unload_drivers.h"

    35 #include "core_operation_check_rcpi.h"

    36 #include "core_operation_handle_frame.h"

    37 #include "core_operation_null.h"

    38 #include "core_operation_get_rcpi.h"

    39 #include "core_operation_configure_multicast_group.h"

    40 #include "core_operation_update_power_mode.h"

    41 #include "core_operation_update_rxtx_parameters.h"

    42 #include "core_operation_get_statistics.h"

    43 #include "core_operation_set_uapsd_settings.h"

    44 #include "core_operation_set_power_save_settings.h"

    45 #include "core_operation_protected_setup.h"

    46 #include "core_operation_create_ts.h"

    47 #include "core_operation_delete_ts.h"

    48 #include "core_operation_power_save_test.h"

    49 #include "core_operation_set_arp_filter.h"

    50 #include "core_operation_directed_roam.h"

    51 #include "core_frame_ethernet.h"

    52 #include "core_connection_data.h"

    53 #include "core_eapol_handler.h"

    54 #include "core_frame_dot11.h"

    55 #include "core_frame_echo_test.h"

    56 #include "am_debug.h"

    57 #include "core_callback.h"

    58 #include "core_tools.h"

    59 #include "core_tools_parser.h"

    60 #include "core_wpx_adaptation_factory.h"

    61 #include "core_traffic_stream_list_iter.h"

    62 

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

    64 

    65 // ---------------------------------------------------------------------------

    66 // ---------------------------------------------------------------------------

    67 //

    68 core_server_c::core_server_c(

    69     abs_core_server_callback_c& callback,

    70     abs_core_driverif_c& drivers,

    71     const core_device_settings_s& settings,

    72     const core_mac_address_s& mac_address,

    73     u32_t features ) :

    74     callback_m( callback ),

    75     drivers_m( drivers ),

    76     device_settings_m( settings ),

    77     queue_m( ),

    78     queue_timer_m( NULL ),

    79     driver_unload_timer_m( NULL ),

    80     core_settings_m( features ),

    81     connection_data_m( NULL ),

    82     own_mac_addr_m( mac_address ),

    83     eapol_handler_m( NULL ),

    84     eapol_m( NULL ),

    85     cm_timer_m( ),

    86     roam_timer_m( NULL ),

    87     operation_timer_m( NULL ),

    88     driver_dhcp_timer_m( NULL ),

    89     frame_handler_m( NULL ),

    90     event_handler_m( NULL ),

    91     scan_list_m( ),

    92     wpx_adaptation_m( NULL )

    93     {

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

    95     queue_m.clear();

    96     }

    97 

    98 // ---------------------------------------------------------------------------

    99 // ---------------------------------------------------------------------------

   100 //

   101 core_server_c::~core_server_c()

   102     {

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

   104 

   105     queue_m.clear();

   106     delete connection_data_m;

   107 

   108     if ( queue_timer_m )

   109         {

   110         queue_timer_m->stop();

   111         core_timer_factory_c::destroy_timer( queue_timer_m );

   112         queue_timer_m = NULL;

   113         }

   114     if ( driver_unload_timer_m )

   115         {

   116         driver_unload_timer_m->stop();

   117         core_timer_factory_c::destroy_timer( driver_unload_timer_m );

   118         driver_unload_timer_m = NULL;

   119         }

   120     if ( roam_timer_m )

   121         {

   122         roam_timer_m->stop();

   123         core_timer_factory_c::destroy_timer( roam_timer_m );

   124         roam_timer_m = NULL;

   125         }

   126     if ( operation_timer_m )

   127         {

   128         operation_timer_m->stop();

   129         core_timer_factory_c::destroy_timer( operation_timer_m );

   130         operation_timer_m = NULL;

   131         }

   132     if ( driver_dhcp_timer_m )

   133         {

   134         driver_dhcp_timer_m->stop();

   135         core_timer_factory_c::destroy_timer( driver_dhcp_timer_m );

   136         driver_dhcp_timer_m = NULL;

   137         }

   138     if ( eapol_m )

   139         {

   140         eapol_m->shutdown();

   141         delete eapol_m;

   142         }

   143     delete wpx_adaptation_m;

   144     delete eapol_handler_m;

   145     frame_handler_m = NULL;

   146     event_handler_m = NULL;

   147     }

   148 

   149 // ---------------------------------------------------------------------------

   150 // ---------------------------------------------------------------------------

   151 //

   152 core_error_e core_server_c::init()

   153     {

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

   155 

   156     drivers_m.init( this );

   157 

   158     core_callback_c* queue_timer_callback = 

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

   160     if( !queue_timer_callback )

   161         {

   162         DEBUG("ERROR creating callback object");

   163         return core_error_no_memory;

   164         }

   165     queue_timer_m = core_timer_factory_c::create_timer( queue_timer_callback );

   166     if( !queue_timer_m )

   167         {

   168         DEBUG( "ERROR creating timer" );

   169         delete queue_timer_callback;

   170         return core_error_no_memory;

   171         }

   172 

   173     core_callback_c* unload_timer_callback = 

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

   175     if( !unload_timer_callback )

   176         {

   177         DEBUG("ERROR creating callback object");

   178         return core_error_no_memory;

   179         }

   180     driver_unload_timer_m = core_timer_factory_c::create_timer( unload_timer_callback );

   181     if( !driver_unload_timer_m )

   182         {

   183         DEBUG( "ERROR creating timer" );

   184         delete unload_timer_callback;

   185         return core_error_no_memory;

   186         }

   187     

   188     core_callback_c* roam_timer_callback = 

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

   190     if( !roam_timer_callback )

   191         {

   192         DEBUG("ERROR creating callback object");

   193         return core_error_no_memory;

   194         }

   195     roam_timer_m = core_timer_factory_c::create_timer( roam_timer_callback );

   196     if( !roam_timer_m )

   197         {

   198         DEBUG( "ERROR creating timer" );

   199         delete roam_timer_callback;

   200         return core_error_no_memory;

   201         } 

   202 

   203     core_callback_c* operation_timer_callback = 

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

   205     if( !operation_timer_callback )

   206         {

   207         DEBUG("ERROR creating callback object");

   208         return core_error_no_memory;

   209         }

   210     operation_timer_m = core_timer_factory_c::create_timer( operation_timer_callback );

   211     if( !operation_timer_m )

   212         {

   213         DEBUG( "ERROR creating timer" );

   214         delete operation_timer_callback;

   215         return core_error_no_memory;

   216         } 

   217 

   218     core_callback_c* dhcp_timer_callback = 

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

   220     if( !dhcp_timer_callback )

   221         {

   222         DEBUG("ERROR creating callback object");

   223         return core_error_no_memory;

   224         }        

   225     driver_dhcp_timer_m = core_timer_factory_c::create_timer( dhcp_timer_callback );

   226     if( !driver_dhcp_timer_m )

   227         {

   228         DEBUG( "ERROR creating timer" );

   229         delete dhcp_timer_callback;

   230         return core_error_no_memory;

   231         } 

   232 

   233     wpx_adaptation_m = core_wpx_adaptation_factory_c::instance(

   234         this, &drivers_m, &callback_m );

   235     if ( !wpx_adaptation_m )

   236         {

   237         DEBUG("ERROR creating WPX adaptation");

   238         return core_error_no_memory;

   239         }

   240 

   241     eapol_handler_m = new core_eapol_handler_c(

   242         this, &drivers_m, &callback_m );

   243     if ( !eapol_handler_m )

   244         {

   245         DEBUG("ERROR creating eapol handler");

   246         return core_error_no_memory;

   247         }

   248 

   249     core_settings_m.set_rcpi_boundaries(

   250         device_settings_m.rcpi_trigger,

   251         device_settings_m.rcpi_trigger + device_settings_m.rcpi_difference );

   252 

   253     return core_error_ok;

   254     }

   255 

   256 // ---------------------------------------------------------------------------

   257 // ---------------------------------------------------------------------------

   258 //

   259 core_device_settings_s& core_server_c::get_device_settings()

   260     {

   261     return device_settings_m;

   262     }

   263 

   264 // ---------------------------------------------------------------------------

   265 // ---------------------------------------------------------------------------

   266 //

   267 core_settings_c& core_server_c::get_core_settings()

   268     {

   269     return core_settings_m;

   270     }

   271 

   272 // ---------------------------------------------------------------------------

   273 // ---------------------------------------------------------------------------

   274 //

   275 core_connection_data_c* core_server_c::get_connection_data()

   276     {

   277     return connection_data_m;

   278     }

   279 

   280 // ---------------------------------------------------------------------------

   281 // ---------------------------------------------------------------------------

   282 //

   283 core_wlan_eapol_interface_c& core_server_c::get_eapol_instance()

   284     {

   285     return *eapol_m;

   286     }

   287 

   288 // ---------------------------------------------------------------------------

   289 // ---------------------------------------------------------------------------

   290 //

   291 void core_server_c::set_eapol_handler(

   292     abs_wlan_eapol_callback_interface_c* handler )

   293     {

   294     eapol_handler_m->set_eapol_handler( handler );

   295     }

   296 

   297 // ---------------------------------------------------------------------------

   298 // ---------------------------------------------------------------------------

   299 //

   300 core_mac_address_s& core_server_c::own_mac_addr()

   301     {

   302     return own_mac_addr_m;

   303     }

   304 

   305 // ---------------------------------------------------------------------------

   306 // ---------------------------------------------------------------------------

   307 //

   308 core_error_e core_server_c::queue_int_operation(

   309     core_operation_base_c* operation )

   310     {

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

   312 

   313     if ( !operation )

   314         {

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

   316 

   317         return core_error_no_memory;

   318         }

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

   320         is_operation_in_queue_with_type( operation->operation_type() ) )

   321         {

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

   323 

   324         delete operation;

   325         operation = NULL;

   326 

   327         return core_error_already_exists;

   328         }

   329     else

   330         {

   331         core_error_e ret = queue_m.append( operation );

   332         if ( ret != core_error_ok )

   333             {

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

   335                 ret );

   336 

   337             delete operation;

   338             operation = NULL;

   339 

   340             return ret;

   341             }

   342         }

   343 

   344     return core_error_ok;    

   345     }

   346 

   347 // ---------------------------------------------------------------------------

   348 // ---------------------------------------------------------------------------

   349 //

   350 core_error_e core_server_c::queue_int_operation_and_run_next(

   351     core_operation_base_c* operation )

   352     {

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

   354 

   355     core_error_e ret = queue_int_operation( operation );

   356     if ( ret != core_error_ok )

   357         {

   358         return ret;

   359         }

   360 

   361     schedule_operation();

   362 

   363     return core_error_ok;

   364     }

   365 

   366 // ---------------------------------------------------------------------------

   367 // ---------------------------------------------------------------------------

   368 //

   369 core_error_e core_server_c::init_connection_data(

   370     const core_iap_data_s& iap_data,

   371     const core_device_settings_s& device_settings )

   372     {

   373     connection_data_m = new core_connection_data_c( iap_data, device_settings );

   374 

   375     if ( !connection_data_m )

   376         {

   377         return core_error_no_memory;

   378         }

   379 

   380     return core_error_ok;

   381     }

   382    

   383 // ---------------------------------------------------------------------------

   384 // ---------------------------------------------------------------------------

   385 //    

   386 void core_server_c::clear_connection_data()

   387     {

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

   389     

   390     delete connection_data_m;

   391     connection_data_m = NULL;

   392     }

   393 

   394 // ---------------------------------------------------------------------------

   395 // ---------------------------------------------------------------------------

   396 //

   397 void core_server_c::schedule_roam_timer(

   398     u32_t delay )

   399     {

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

   401         delay );

   402 

   403     ASSERT( !roam_timer_m->is_active() );

   404 

   405     roam_timer_m->start(

   406         delay );    

   407     }

   408 

   409 // ---------------------------------------------------------------------------

   410 // ---------------------------------------------------------------------------

   411 //

   412 void core_server_c::cancel_roam_timer()

   413     {

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

   415     

   416     roam_timer_m->stop();

   417     }

   418 

   419 // ---------------------------------------------------------------------------

   420 // ---------------------------------------------------------------------------

   421 //    

   422 void core_server_c::roam_timer_expired(

   423     void* this_ptr )

   424     {

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

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

   427 

   428     // send an indication to adaptation

   429     self->callback_m.notify(

   430         core_notification_rcpi_roam_attempt_started,

   431         0, 

   432         NULL );

   433     

   434     core_operation_base_c* command = new core_operation_check_rcpi_c(

   435         REQUEST_ID_CORE_INTERNAL,

   436         self,

   437         &(self->drivers_m),

   438         &(self->callback_m),

   439         core_operation_check_rcpi_c::core_rcpi_check_reason_timer );

   440 

   441     self->queue_int_operation_and_run_next( command );

   442     }

   443 

   444 // ---------------------------------------------------------------------------

   445 // ---------------------------------------------------------------------------

   446 //

   447 void core_server_c::schedule_operation_timer(

   448     u32_t delay )

   449     {

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

   451         delay );

   452 

   453     ASSERT( !operation_timer_m->is_active() );

   454     operation_timer_m->start(

   455         delay );    

   456     }

   457 

   458 // ---------------------------------------------------------------------------

   459 // ---------------------------------------------------------------------------

   460 //

   461 void core_server_c::cancel_operation_timer()

   462     {

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

   464     operation_timer_m->stop();

   465     }

   466 

   467 // ---------------------------------------------------------------------------

   468 // ---------------------------------------------------------------------------

   469 //    

   470 void core_server_c::operation_timer_expired(

   471     void* this_ptr )

   472     {

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

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

   475 

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

   477     ASSERT( command );

   478     ASSERT( command->is_executing() );

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

   480     }

   481 

   482 // ---------------------------------------------------------------------------

   483 // ---------------------------------------------------------------------------

   484 //

   485 bool_t core_server_c::is_operation_in_queue_with_flags(

   486     u32_t feature_flags )

   487     {

   488     core_type_list_iterator_c<core_operation_base_c> iter( queue_m );

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

   490         {

   491         if ( current->is_flags( feature_flags ) )

   492             {

   493             return true_t;

   494             }

   495         }

   496 

   497     return false_t;    

   498     }

   499 

   500 // ---------------------------------------------------------------------------

   501 // ---------------------------------------------------------------------------

   502 //

   503 bool_t core_server_c::is_operation_in_queue_with_type(

   504     u32_t type )

   505     {

   506     core_type_list_iterator_c<core_operation_base_c> iter( queue_m );

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

   508         {

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

   510             {

   511             return true_t;

   512             }

   513         }

   514 

   515     return false_t;    

   516     }

   517 

   518 // ---------------------------------------------------------------------------

   519 // ---------------------------------------------------------------------------

   520 //

   521 bool_t core_server_c::is_dhcp_timer_active()

   522     {

   523     return driver_dhcp_timer_m->is_active();

   524     }

   525 

   526 // ---------------------------------------------------------------------------

   527 // ---------------------------------------------------------------------------

   528 //

   529 void core_server_c::schedule_dhcp_timer(

   530     u32_t delay )

   531     {

   532     DEBUG1( "core_server_c::schedule_dhcp_timer() - delay %u",

   533         delay );

   534 

   535     ASSERT( !is_dhcp_timer_active() );

   536 

   537     driver_dhcp_timer_m->start(

   538         delay );    

   539     }

   540 

   541 // ---------------------------------------------------------------------------

   542 // ---------------------------------------------------------------------------

   543 //

   544 void core_server_c::cancel_dhcp_timer()

   545     {

   546     DEBUG( "core_server_c::cancel_dhcp_timer()" );

   547     

   548     driver_dhcp_timer_m->stop();

   549     }

   550 

   551 // ---------------------------------------------------------------------------

   552 // ---------------------------------------------------------------------------

   553 //

   554 void core_server_c::dhcp_timer_expired(

   555     void* this_ptr )

   556     {

   557     DEBUG( "core_server_c::dhcp_timer_expired()" );

   558 

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

   560 

   561     core_operation_base_c* command = new core_operation_power_save_test_c(

   562         REQUEST_ID_CORE_INTERNAL,

   563         self,

   564         &(self->drivers_m),

   565         &(self->callback_m) );        

   566 

   567     self->queue_int_operation_and_run_next( command );

   568     }

   569 

   570 // ---------------------------------------------------------------------------

   571 // ---------------------------------------------------------------------------

   572 //

   573 void core_server_c::schedule_unload_timer(

   574     u32_t delay )

   575     {

   576     DEBUG1( "core_server_c::schedule_unload_timer() - delay %u",

   577         delay );

   578 

   579     ASSERT( !driver_unload_timer_m->is_active() );

   580 

   581     driver_unload_timer_m->start(

   582         delay );    

   583     }

   584 

   585 // ---------------------------------------------------------------------------

   586 // ---------------------------------------------------------------------------

   587 //

   588 void core_server_c::cancel_unload_timer()

   589     {

   590     DEBUG( "core_server_c::cancel_unload_timer()" );

   591 

   592     driver_unload_timer_m->stop();

   593     }

   594 

   595 // ---------------------------------------------------------------------------

   596 // ---------------------------------------------------------------------------

   597 //

   598 void core_server_c::cancel_operations_with_flags(

   599     u32_t feature_flags )

   600     {

   601     DEBUG( "core_server_c::cancel_operations_with_flags()" );

   602     DEBUG1( "core_server_c::cancel_operations_with_flags() - feature_flags %u",

   603         feature_flags );

   604 

   605     core_operation_base_c* command = queue_m.first();

   606     while ( command )

   607         {

   608         if ( !command->is_executing() &&

   609              command->is_flags( feature_flags ) )

   610             {

   611             DEBUG2( "core_server_c::cancel_operations_with_flags() - canceling operation (id %u, type %u)",

   612                 command->request_id(), command->operation_type() );

   613             if ( command->request_id() != REQUEST_ID_CORE_INTERNAL )

   614                 {

   615                 DEBUG( "core_server_c::cancel_operations_with_flags() - adaptation request, completing it" );

   616                 callback_m.request_complete(

   617                     command->request_id(),

   618                     core_error_cancel );

   619                 }

   620 

   621             queue_m.remove( command );

   622             delete command;

   623             command = queue_m.first();

   624             }

   625         else

   626             {

   627             command = queue_m.next();

   628             }        

   629         }

   630     }

   631 

   632 // ---------------------------------------------------------------------------

   633 // ---------------------------------------------------------------------------

   634 //

   635 void core_server_c::cancel_operations_with_type(

   636     u32_t type )

   637     {

   638     DEBUG( "core_server_c::cancel_operation_with_type()" );

   639     DEBUG1( "core_server_c::cancel_operation_with_type() - type %u",

   640         type );

   641 

   642     core_operation_base_c* command = queue_m.first();

   643     while ( command )

   644         {

   645         if ( !command->is_executing() &&

   646              command->operation_type() == type )

   647             {

   648             DEBUG2( "core_server_c::cancel_operation_with_type() - canceling operation (id %u, type %u)",

   649                 command->request_id(), command->operation_type() );

   650             if ( command->request_id() != REQUEST_ID_CORE_INTERNAL )

   651                 {

   652                 DEBUG( "core_server_c::cancel_operation_with_type() - adaptation request, completing it" );

   653                 callback_m.request_complete(

   654                     command->request_id(),

   655                     core_error_cancel );

   656                 }

   657 

   658             queue_m.remove( command );

   659             delete command;

   660             command = queue_m.first();

   661             }

   662         else

   663             {

   664             command = queue_m.next();

   665             }

   666         }       

   667     }

   668 

   669 // ---------------------------------------------------------------------------

   670 // ---------------------------------------------------------------------------

   671 //

   672 void core_server_c::cancel_all_operations(

   673     bool_t is_graceful_cancel )

   674     {

   675     DEBUG( "core_server_c::cancel_all_operations()" );

   676 

   677     core_operation_base_c* command = queue_m.first();

   678     while ( command )

   679         {

   680         if ( !command->is_executing() )

   681             {

   682             DEBUG2( "core_server_c::cancel_all_operations() - canceling operation (id %u, type %u)",

   683                 command->request_id(), command->operation_type() );

   684             if ( command->request_id() != REQUEST_ID_CORE_INTERNAL )

   685                 {

   686                 DEBUG( "core_server_c::cancel_all_operations() - adaptation request, completing it" );

   687                 callback_m.request_complete(

   688                     command->request_id(),

   689                     core_error_cancel );

   690                 }

   691 

   692             queue_m.remove( command );

   693             delete command;

   694             command = queue_m.first();

   695             }

   696         else

   697             {

   698             command = queue_m.next();

   699             }

   700         }

   701 

   702     command = queue_m.first();

   703     if ( command )

   704         {

   705         if( is_graceful_cancel )

   706             {

   707             DEBUG2( "core_server_c::cancel_all_operations() - canceling currently executing operation (id %u, type %u) (graceful cancel)",

   708                 command->request_id(), command->operation_type() );

   709             }

   710         else

   711             {

   712             DEBUG2( "core_server_c::cancel_all_operations() - canceling currently executing operation (id %u, type %u) (forced cancel)",

   713                 command->request_id(), command->operation_type() );

   714             }

   715 

   716         ASSERT( command->is_executing() );

   717 

   718         // Let operation handle it's own cancelling

   719         command->user_cancel_operation( is_graceful_cancel );

   720         }   

   721     }

   722 

   723 // ---------------------------------------------------------------------------

   724 // ---------------------------------------------------------------------------

   725 //

   726 bool_t core_server_c::create_eapol_instance(

   727     core_eapol_operating_mode_e mode )

   728     {

   729     DEBUG( "core_server_c::create_eapol_instance()" );

   730 

   731     if ( eapol_m &&

   732         eapol_m->operating_mode() == mode )

   733         {

   734         DEBUG( "core_server_c::create_eapol_instance() - an instance already exists" );

   735 

   736         return true_t;

   737         }

   738 

   739     if ( eapol_m )

   740         {

   741         DEBUG( "core_server_c::create_eapol_instance() - deleting old core_wlan_eapol_interface_c instance" );

   742 

   743         eapol_m->shutdown();

   744         delete eapol_m;

   745         eapol_m = NULL;

   746         }

   747     

   748     DEBUG1( "core_server_c::create_eapol_instance() - creating core_wlan_eapol_interface_c (mode %u)",

   749         mode );

   750 

   751     eapol_m = new core_wlan_eapol_interface_c( callback_m );

   752     if ( !eapol_m )

   753         {

   754         DEBUG( "core_server_c::create_eapol_instance() - unable to create core_wlan_eapol_interface_c" );

   755         return false_t;

   756         }

   757     core_error_e error = eapol_m->load_eapol( mode, eapol_handler_m );

   758     if ( error != core_error_ok )

   759         {

   760         DEBUG1( "core_server_c::create_eapol_instance() - load_eapol failed with %i", error );

   761         delete eapol_m;

   762         eapol_m = NULL;

   763         return false_t;

   764         }

   765     error = eapol_m->configure();

   766     if ( error != core_error_ok )

   767         {

   768         DEBUG1( "core_server_c::create_eapol_instance() - configure failed with %i", error );

   769         delete eapol_m;

   770         eapol_m = NULL;

   771         return false_t;

   772         }

   773 

   774     return true_t;

   775     }

   776 

   777 // ---------------------------------------------------------------------------

   778 // ---------------------------------------------------------------------------

   779 //

   780 abs_core_frame_handler_c* core_server_c::frame_handler()

   781     {

   782     return frame_handler_m;

   783     }

   784 

   785 // ---------------------------------------------------------------------------

   786 // ---------------------------------------------------------------------------

   787 //

   788 void core_server_c::register_frame_handler(

   789     abs_core_frame_handler_c* handler )

   790     {

   791     ASSERT( handler );

   792     ASSERT( handler == frame_handler_m || !frame_handler_m );

   793 

   794     frame_handler_m = handler;

   795     }

   796 

   797 // ---------------------------------------------------------------------------

   798 // ---------------------------------------------------------------------------

   799 //

   800 void core_server_c::unregister_frame_handler(

   801     abs_core_frame_handler_c* handler )

   802     {

   803     ASSERT( handler );

   804     

   805     if ( frame_handler_m != handler )

   806         {

   807         DEBUG1( "core_server_c::unregister_frame_handler() - handler 0x%08X not registered",

   808             handler );

   809 

   810         return;

   811         }

   812 

   813     frame_handler_m = NULL;

   814     }

   815 

   816 // ---------------------------------------------------------------------------

   817 // ---------------------------------------------------------------------------

   818 //

   819 core_scan_list_c& core_server_c::get_scan_list()

   820     {

   821     return scan_list_m;

   822     }

   823 

   824 // ---------------------------------------------------------------------------

   825 // ---------------------------------------------------------------------------

   826 //

   827 abs_core_event_handler_c* core_server_c::event_handler()

   828     {

   829     return event_handler_m;

   830     }

   831 

   832 // ---------------------------------------------------------------------------

   833 // ---------------------------------------------------------------------------

   834 //

   835 void core_server_c::register_event_handler(

   836     abs_core_event_handler_c* handler )

   837     {

   838     ASSERT( handler );

   839     ASSERT( handler == event_handler_m || !event_handler_m );

   840 

   841     event_handler_m = handler;

   842     }

   843 

   844 // ---------------------------------------------------------------------------

   845 // ---------------------------------------------------------------------------

   846 //

   847 void core_server_c::unregister_event_handler(

   848     abs_core_event_handler_c* handler )

   849     {

   850     ASSERT( handler );

   851 

   852     if ( event_handler_m != handler )

   853         {

   854         DEBUG1( "core_server_c::unregister_event_handler() - handler 0x%08X not registered",

   855             handler );

   856 

   857         return;

   858         }

   859 

   860     event_handler_m = NULL;

   861     }

   862 

   863 // ---------------------------------------------------------------------------

   864 // ---------------------------------------------------------------------------

   865 //

   866 void core_server_c::schedule_roam(

   867     core_operation_handle_bss_lost_c::core_bss_lost_reason_e reason )

   868     {

   869     if ( !is_operation_in_queue_with_type( core_operation_handle_bss_lost ) )

   870         {       

   871         DEBUG( "core_server_c::schedule_roam() - scheduling a core_operation_handle_bss_lost operation" );

   872 

   873         core_operation_base_c* command = new core_operation_handle_bss_lost_c(

   874             REQUEST_ID_CORE_INTERNAL,

   875             this,

   876             &drivers_m,

   877             &callback_m,

   878             reason );

   879 

   880         queue_int_operation_and_run_next( command );

   881         }

   882     else

   883         {

   884         DEBUG( "core_server_c::schedule_roam() - core_operation_handle_bss_lost already in the queue" );

   885         }        

   886     }

   887 

   888 // ---------------------------------------------------------------------------

   889 // ---------------------------------------------------------------------------

   890 //

   891 bool_t core_server_c::send_management_frame(

   892     core_frame_type_e frame_type,

   893     const u16_t frame_length,

   894     const u8_t* const frame_data,

   895     const core_mac_address_s& destination )

   896     {

   897     /** Management frames can be sent without downgraded user priority. */

   898     drivers_m.send_frame(

   899         frame_type,

   900         frame_length,

   901         frame_data,

   902         core_tools_c::convert_ac_to_user_priority( core_access_class_voice ),

   903         destination,

   904         true_t );    

   905 

   906     return true_t;

   907     }

   908 

   909 // ---------------------------------------------------------------------------

   910 // ---------------------------------------------------------------------------

   911 //

   912 bool_t core_server_c::send_data_frame(

   913     const core_ap_data_c& ap_data,

   914     core_frame_type_e frame_type,

   915     const u16_t frame_length,

   916     const u8_t* const frame_data,

   917     core_access_class_e frame_priority,

   918     const core_mac_address_s& destination,

   919     bool_t send_unencrypted )

   920     {

   921     DEBUG( "core_server_c::send_data_frame()" );

   922     

   923     u8_t initial_priority(

   924         core_tools_c::convert_ac_to_user_priority( frame_priority ) );

   925     u8_t user_priority = initial_priority;

   926       

   927     if ( ap_data.is_wmm_ie_present() )

   928         {

   929         /**

   930          * Collect a list of active streams per user priority.

   931          */

   932         bool_t is_ts_for_user_priority[MAX_QOS_USER_PRIORITY];

   933         core_tools_c::fillz(

   934             &is_ts_for_user_priority[0],

   935             sizeof( is_ts_for_user_priority ) );

   936 

   937         core_traffic_stream_list_iter_c iter(

   938             get_connection_data()->traffic_stream_list() );

   939 

   940         core_traffic_stream_c* entry = iter.first();

   941         while( entry )

   942             {

   943             if ( entry->status() == core_traffic_stream_status_active )

   944                 {

   945                 is_ts_for_user_priority[entry->user_priority()] = true_t;

   946                 }

   947 

   948             entry = iter.next();

   949             }

   950 

   951         /**

   952          * See if downgrade should be done.

   953          */

   954         bool_t is_send_ok( false_t );        

   955 

   956         while ( user_priority <= initial_priority && !is_send_ok )

   957             {

   958             core_access_class_e ac(

   959                 core_tools_c::convert_user_priority_to_ac( user_priority ) );

   960 

   961 #if 0

   962             DEBUG1( "core_server_c::send_data_frame() - user_priority is %u",

   963                 user_priority );

   964             DEBUG1( "core_server_c::send_data_frame() - ac is %u",

   965                 ac );

   966             DEBUG1( "core_server_c::send_data_frame() - is_admission_control_required is %u",

   967                 ap_data.is_admission_control_required( ac ) );

   968             DEBUG1( "core_server_c::send_data_frame() - is_ts_for_user_priority is %u",

   969                 is_ts_for_user_priority[user_priority] );

   970 #endif // 0

   971 

   972             if ( !ap_data.is_admission_control_required( ac ) ||

   973                  is_ts_for_user_priority[user_priority] )

   974                 {

   975                 is_send_ok = true_t;

   976                 }

   977             else

   978                 {

   979                 user_priority--;

   980                 }

   981             }

   982 

   983         if ( !is_send_ok )

   984             {

   985             DEBUG( "core_server_c::send_data_frame() - unable to send the frame due to admission control settings" );

   986             return false_t;

   987             }

   988         }

   989 

   990     if ( user_priority == initial_priority )

   991         {

   992         DEBUG1( "core_server_c::send_data_frame() - no need to downgrade user priority %u",

   993             user_priority );

   994         }

   995     else

   996         {

   997         DEBUG2( "core_server_c::send_data_frame() - user priority %u downgraded to %u",

   998             initial_priority, user_priority );

   999         }

  1000 

  1001     drivers_m.send_frame(

  1002         frame_type,

  1003         frame_length,

  1004         frame_data,

  1005         user_priority,

  1006         destination,

  1007         send_unencrypted ); 

  1008 

  1009     return true_t;

  1010     }

  1011 

  1012 // ---------------------------------------------------------------------------

  1013 // ---------------------------------------------------------------------------

  1014 //

  1015 abs_core_wpx_adaptation_c& core_server_c::get_wpx_adaptation_instance()

  1016     {

  1017     return *wpx_adaptation_m;

  1018     }

  1019 

  1020 // ---------------------------------------------------------------------------

  1021 // ---------------------------------------------------------------------------

  1022 //

  1023 void core_server_c::set_protected_setup_handler(

  1024     abs_core_protected_setup_handler_c* handler )

  1025     {

  1026     eapol_handler_m->set_protected_setup_handler( handler );

  1027     }

  1028 

  1029 // ---------------------------------------------------------------------------

  1030 // ---------------------------------------------------------------------------

  1031 //

  1032 void core_server_c::connect(

  1033     u32_t request_id,

  1034     const core_iap_data_s& settings,

  1035     core_connect_status_e& connect_status,

  1036     core_type_list_c<core_ssid_entry_s>* ssid_list )

  1037     {

  1038     DEBUG( "core_server_c::connect()" );

  1039 

  1040     core_operation_base_c* command = new core_operation_connect_c(

  1041         request_id, this, &drivers_m, &callback_m, settings, ssid_list, connect_status );

  1042 

  1043     queue_ext_operation_and_run_next( command, request_id );

  1044     }

  1045 

  1046 // ---------------------------------------------------------------------------

  1047 // ---------------------------------------------------------------------------

  1048 //

  1049 void core_server_c::release(

  1050     u32_t request_id )

  1051     {

  1052     DEBUG( "core_server_c::release()" );

  1053 

  1054     /**

  1055      * Cancel all pending roaming operations.

  1056      */

  1057     cancel_operations_with_flags(

  1058         core_operation_base_c::core_base_flag_roam_operation );

  1059 

  1060     /**

  1061      * If there's an executing roam operation, let it handle

  1062      * its own cancel.

  1063      */

  1064     core_operation_base_c* operation = queue_m.first();

  1065     if( operation &&

  1066         operation->is_flags( core_operation_base_c::core_base_flag_roam_operation ) )

  1067         {

  1068         operation->user_cancel_operation( true_t ); // Using graceful cancel

  1069         }

  1070 

  1071     core_operation_base_c* command = new core_operation_release_c(

  1072         request_id, this, &drivers_m, &callback_m, core_release_reason_external_request );

  1073 

  1074     queue_ext_operation_and_run_next( command, request_id );

  1075     }

  1076     

  1077 // ---------------------------------------------------------------------------

  1078 // ---------------------------------------------------------------------------

  1079 //

  1080 void core_server_c::get_scan_result(

  1081     u32_t request_id,

  1082     core_scan_mode_e scan_mode,

  1083     const core_ssid_s& scan_ssid,    

  1084     const core_scan_channels_s& scan_channels,

  1085     u8_t scan_max_age,

  1086     ScanList& scan_data,

  1087     bool_t is_current_ap_added )

  1088     {

  1089     DEBUG( "core_server_c::get_scan_result()" );

  1090     

  1091     core_operation_base_c* command = new core_operation_scan_c(

  1092         request_id, this, &drivers_m, &callback_m,

  1093         scan_mode, scan_ssid, scan_channels, scan_max_age, scan_data, 

  1094         true_t,

  1095         is_current_ap_added );

  1096 

  1097     queue_ext_operation_and_run_next( command, request_id );    

  1098     }

  1099     

  1100 // ---------------------------------------------------------------------------

  1101 // ---------------------------------------------------------------------------

  1102 //

  1103 void core_server_c::get_available_iaps(

  1104     u32_t request_id,

  1105     bool_t is_active_scan_allowed,

  1106     core_type_list_c<core_iap_data_s>& iap_data_list,

  1107     core_type_list_c<u32_t>& iap_id_list,

  1108     core_type_list_c<core_ssid_entry_s>* iap_ssid_list,

  1109     ScanList& scan_data )

  1110     {

  1111     DEBUG( "core_server_c::get_available_iaps()" );

  1112 

  1113     core_operation_base_c* command = new core_operation_get_available_iaps_c(

  1114         request_id, 

  1115         this, 

  1116         &drivers_m, 

  1117         &callback_m, 

  1118         is_active_scan_allowed, 

  1119         iap_data_list, 

  1120         iap_id_list,

  1121         iap_ssid_list,

  1122         scan_data );

  1123 

  1124     queue_ext_operation_and_run_next( command, request_id );

  1125     }

  1126 

  1127 // ---------------------------------------------------------------------------

  1128 // ---------------------------------------------------------------------------

  1129 //

  1130 void core_server_c::get_current_rcpi(

  1131     u32_t request_id,

  1132     u32_t& rcpi )

  1133     {

  1134     DEBUG( "core_server_c::get_current_rcpi()" );