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:  Class for parsing 802.11i (RSN) IEs.

    15 *

    16 */

    17 

    18 #include "core_frame_mgmt_ie.h"

    19 #include "core_tools.h"

    20 #include "core_tools_parser.h"

    21 #include "am_debug.h"

    22 

    23 const u8_t CORE_FRAME_MGMT_IE_SSID_MAX_LENGTH = 34;

    24 const u8_t CORE_FRAME_MGMT_IE_SSID_OFFSET = 2;

    25 

    26 const u8_t CORE_FRAME_MGMT_IE_DS_LENGTH = 3;

    27 const u8_t CORE_FRAME_MGMT_IE_DS_OFFSET = 2;

    28 

    29 const u8_t CORE_FRAME_MGMT_IE_COUNTRY_MIN_LENGTH = 8;

    30 const u8_t CORE_FRAME_MGMT_IE_COUNTRY_OFFSET = 2;

    31 const u8_t CORE_FRAME_MGMT_IE_COUNTRY_FIRST_CHANNEL_OFFSET = 5;

    32 const u8_t CORE_FRAME_MGMT_IE_COUNTRY_SET_LENGTH = 3;

    33 const u8_t CORE_FRAME_MGMT_IE_COUNTRY_SET_CH_OFFSET = 0;

    34 const u8_t CORE_FRAME_MGMT_IE_COUNTRY_SET_NR_OFFSET = 1;

    35 const u8_t CORE_FRAME_MGMT_IE_COUNTRY_SET_TX_OFFSET = 2;

    36 

    37 const u8_t CORE_FRAME_MGMT_IE_POWER_CONSTRAINT_LENGTH = 3;

    38 const u8_t CORE_FRAME_MGMT_IE_POWER_CONSTRAINT_OFFSET = 2;

    39 

    40 const u16_t CORE_FRAME_MGMT_IE_ADMISSION_CAPACITY_LENGTH = 4;

    41 const u16_t CORE_FRAME_MGMT_IE_ADMISSION_CAPACITY_BITMASK_OFFSET = 2;

    42 const u16_t CORE_FRAME_MGMT_IE_ADMISSION_CAPACITY_OFFSET = 4;

    43 

    44 const u16_t CORE_FRAME_MGMT_IE_POWER_CAPABILITY_LENGTH = 4;

    45 const u16_t CORE_FRAME_MGMT_IE_POWER_CAPABILITY_OFFSET = 2;

    46 

    47 const u16_t CORE_FRAME_MGMT_IE_RRM_CAPABILITIES_LENGTH = 7;

    48 const u16_t CORE_FRAME_MGMT_IE_RRM_CAPABILITIES_OFFSET = 2;

    49 

    50 const u8_t CORE_FRAME_MGMT_IE_REQUEST_IE_MAX_LENGTH = 237;

    51 const u8_t CORE_FRAME_MGMT_IE_REQUEST_IE_OFFSET = 2;

    52 

    53 // ---------------------------------------------------------------------------

    54 // ---------------------------------------------------------------------------

    55 //

    56 core_frame_mgmt_ie_ssid_c* core_frame_mgmt_ie_ssid_c::instance(

    57     const core_frame_dot11_ie_c& ie )

    58     {

    59     if ( ie.data_length() > CORE_FRAME_MGMT_IE_SSID_MAX_LENGTH )

    60         {

    61         DEBUG( "core_frame_mgmt_ie_ssid_c::instance() - not a valid IE, too long" );

    62 

    63         return NULL;

    64         }

    65 

    66     core_frame_mgmt_ie_ssid_c* instance = new core_frame_mgmt_ie_ssid_c(

    67         ie.data_length(),

    68         ie.data(),

    69         0 );

    70     if ( !instance )

    71         {

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

    73 

    74         return NULL;

    75         }

    76     

    77     return instance;

    78     }

    79 

    80 // ---------------------------------------------------------------------------

    81 // ---------------------------------------------------------------------------

    82 //       

    83 core_frame_mgmt_ie_ssid_c::~core_frame_mgmt_ie_ssid_c()

    84     {

    85     }

    86 

    87 // ---------------------------------------------------------------------------

    88 // ---------------------------------------------------------------------------

    89 //

    90 core_ssid_s core_frame_mgmt_ie_ssid_c::ssid() const

    91     {

    92     core_ssid_s ssid( BROADCAST_SSID );

    93 

    94     ssid.length = length();

    95     core_tools_c::copy(

    96         &ssid.ssid[0],

    97         data_m + CORE_FRAME_MGMT_IE_SSID_OFFSET,

    98         ssid.length );    

    99 

   100     return ssid;

   101     }

   102 

   103 // ---------------------------------------------------------------------------

   104 // ---------------------------------------------------------------------------

   105 //

   106 core_frame_mgmt_ie_ssid_c::core_frame_mgmt_ie_ssid_c(

   107     u16_t data_length,

   108     const u8_t* data,

   109     u16_t max_data_length ) :

   110     core_frame_dot11_ie_c( data_length, data, max_data_length )

   111     {

   112     }

   113 

   114 // ---------------------------------------------------------------------------

   115 // ---------------------------------------------------------------------------

   116 //

   117 core_frame_mgmt_ie_ds_c* core_frame_mgmt_ie_ds_c::instance(

   118     const core_frame_dot11_ie_c& ie )

   119     {

   120     if ( ie.data_length() != CORE_FRAME_MGMT_IE_DS_LENGTH )

   121         {

   122         DEBUG( "core_frame_mgmt_ie_ds_c::instance() - not a valid IE, invalid length" );

   123 

   124         return NULL;

   125         }

   126 

   127     core_frame_mgmt_ie_ds_c* instance = new core_frame_mgmt_ie_ds_c(

   128         ie.data_length(),

   129         ie.data(),

   130         0 );

   131     if ( !instance )

   132         {

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

   134 

   135         return NULL;

   136         }

   137     

   138     return instance;

   139     }

   140 

   141 // ---------------------------------------------------------------------------

   142 // ---------------------------------------------------------------------------

   143 //       

   144 core_frame_mgmt_ie_ds_c::~core_frame_mgmt_ie_ds_c()

   145     {

   146     }

   147 

   148 // ---------------------------------------------------------------------------

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

   150 //

   151 u8_t core_frame_mgmt_ie_ds_c::channel() const

   152     {

   153     return data_m[CORE_FRAME_MGMT_IE_DS_OFFSET];

   154     }

   155 

   156 // ---------------------------------------------------------------------------

   157 // ---------------------------------------------------------------------------

   158 //

   159 core_frame_mgmt_ie_ds_c::core_frame_mgmt_ie_ds_c(

   160     u16_t data_length,

   161     const u8_t* data,

   162     u16_t max_data_length ) :

   163     core_frame_dot11_ie_c( data_length, data, max_data_length )

   164     {

   165     }

   166 

   167 // ---------------------------------------------------------------------------

   168 // ---------------------------------------------------------------------------

   169 //

   170 core_frame_mgmt_ie_country_c* core_frame_mgmt_ie_country_c::instance(

   171     const core_frame_dot11_ie_c& ie )

   172     {

   173     if ( ie.data_length() < CORE_FRAME_MGMT_IE_COUNTRY_MIN_LENGTH )

   174         {

   175         DEBUG( "core_frame_mgmt_ie_country_c::instance() - not a valid IE, invalid length" );

   176 

   177         return NULL;

   178         }

   179 

   180     core_frame_mgmt_ie_country_c* instance = new core_frame_mgmt_ie_country_c(

   181         ie.data_length(),

   182         ie.data(),

   183         0 );

   184     if ( !instance )

   185         {

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

   187 

   188         return NULL;

   189         }

   190     

   191     return instance;

   192     }

   193 

   194 // ---------------------------------------------------------------------------

   195 // ---------------------------------------------------------------------------

   196 //       

   197 core_frame_mgmt_ie_country_c::~core_frame_mgmt_ie_country_c()

   198     {

   199     }

   200 

   201 // ---------------------------------------------------------------------------

   202 // ---------------------------------------------------------------------------

   203 //

   204 core_country_string_s core_frame_mgmt_ie_country_c::country() const

   205     {

   206     core_country_string_s country = { 0, 0, 0 };

   207     core_tools_c::copy(

   208         &country.country[0],

   209         &data_m[CORE_FRAME_MGMT_IE_COUNTRY_OFFSET],

   210         MAX_COUNTRY_STRING_LENGTH );

   211 

   212     return country;

   213     }

   214 

   215 // ---------------------------------------------------------------------------

   216 // ---------------------------------------------------------------------------

   217 //    

   218 u8_t core_frame_mgmt_ie_country_c::max_tx_power_level(

   219     u8_t channel ) const

   220     {

   221     for ( const u8_t* idx = data_m + CORE_FRAME_MGMT_IE_COUNTRY_FIRST_CHANNEL_OFFSET;

   222           idx + CORE_FRAME_MGMT_IE_COUNTRY_SET_LENGTH <= data_m + data_length_m;

   223           idx += CORE_FRAME_MGMT_IE_COUNTRY_SET_LENGTH )            

   224             {

   225             u8_t channel_start = idx[CORE_FRAME_MGMT_IE_COUNTRY_SET_CH_OFFSET];

   226             u8_t channel_end = channel_start + idx[CORE_FRAME_MGMT_IE_COUNTRY_SET_NR_OFFSET];

   227 

   228             if ( channel >= channel_start &&

   229                  channel < channel_end )

   230                 {

   231                 return idx[CORE_FRAME_MGMT_IE_COUNTRY_SET_TX_OFFSET];

   232                 }

   233             }

   234 

   235     return MAX_TX_POWER_LEVEL_NOT_DEFINED;

   236     }

   237 

   238 // ---------------------------------------------------------------------------

   239 // ---------------------------------------------------------------------------

   240 //

   241 core_frame_mgmt_ie_country_c::core_frame_mgmt_ie_country_c(

   242     u16_t data_length,

   243     const u8_t* data,

   244     u16_t max_data_length ) :

   245     core_frame_dot11_ie_c( data_length, data, max_data_length )

   246     {

   247     }

   248 

   249 // ---------------------------------------------------------------------------

   250 // ---------------------------------------------------------------------------

   251 //

   252 core_frame_mgmt_ie_power_constraint_c* core_frame_mgmt_ie_power_constraint_c::instance(

   253     const core_frame_dot11_ie_c& ie )

   254     {

   255     if ( ie.data_length() != CORE_FRAME_MGMT_IE_POWER_CONSTRAINT_LENGTH )

   256         {

   257         DEBUG( "core_frame_mgmt_ie_power_constraint_c::instance() - not a valid IE, invalid length" );

   258 

   259         return NULL;

   260         }

   261 

   262     core_frame_mgmt_ie_power_constraint_c* instance = new core_frame_mgmt_ie_power_constraint_c(

   263         ie.data_length(),

   264         ie.data(),

   265         0 );

   266     if ( !instance )

   267         {

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

   269 

   270         return NULL;

   271         }

   272         

   273     return instance;

   274     }

   275 

   276 // ---------------------------------------------------------------------------

   277 // ---------------------------------------------------------------------------

   278 //       

   279 core_frame_mgmt_ie_power_constraint_c::~core_frame_mgmt_ie_power_constraint_c()

   280     {

   281     }

   282 

   283 // ---------------------------------------------------------------------------

   284 // ---------------------------------------------------------------------------

   285 //

   286 u8_t core_frame_mgmt_ie_power_constraint_c::power_constraint() const

   287     {

   288     return data_m[CORE_FRAME_MGMT_IE_POWER_CONSTRAINT_OFFSET];

   289     }

   290 

   291 // ---------------------------------------------------------------------------

   292 // ---------------------------------------------------------------------------

   293 //

   294 core_frame_mgmt_ie_power_constraint_c::core_frame_mgmt_ie_power_constraint_c(

   295     u16_t data_length,

   296     const u8_t* data,

   297     u16_t max_data_length ) :

   298     core_frame_dot11_ie_c( data_length, data, max_data_length )

   299     {

   300     }

   301 

   302 // ---------------------------------------------------------------------------

   303 // ---------------------------------------------------------------------------

   304 //

   305 core_frame_mgmt_ie_ap_channel_report_c* core_frame_mgmt_ie_ap_channel_report_c::instance(

   306     const core_frame_dot11_ie_c& ie )

   307     {

   308     if ( ie.data_length() < CORE_FRAME_MGMT_IE_AP_CHANNEL_REPORT_LENGTH )

   309         {

   310         DEBUG( "core_frame_mgmt_ie_ap_channel_report_c::instance() - not a valid IE, invalid length" );

   311 

   312         return NULL;

   313         }

   314 

   315     core_frame_mgmt_ie_ap_channel_report_c* instance = new core_frame_mgmt_ie_ap_channel_report_c(

   316         ie.data_length(),

   317         ie.data(),

   318         0 );

   319     if ( !instance )

   320         {

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

   322 

   323         return NULL;

   324         }

   325 

   326     DEBUG1( "core_frame_mgmt_ie_ap_channel_report_c::instance() - AP Channel Report: 0x%02X",

   327             instance->ap_channel_report_channel( 0 ) );

   328     

   329     return instance;

   330     }

   331 

   332 // ---------------------------------------------------------------------------

   333 // ---------------------------------------------------------------------------

   334 //       

   335 core_frame_mgmt_ie_ap_channel_report_c::~core_frame_mgmt_ie_ap_channel_report_c()

   336     {

   337     }

   338 

   339 // ---------------------------------------------------------------------------

   340 // ---------------------------------------------------------------------------

   341 //

   342 u8_t core_frame_mgmt_ie_ap_channel_report_c::ap_channel_report_class() const

   343     {

   344     return data_m[CORE_FRAME_MGMT_IE_AP_CHANNEL_REPORT_CLASS_OFFSET];

   345     }

   346 

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

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

   349 //

   350 u8_t core_frame_mgmt_ie_ap_channel_report_c::ap_channel_report_channel( 

   351     u16_t channel_offset ) const

   352     {

   353     return data_m[CORE_FRAME_MGMT_IE_AP_CHANNEL_REPORT_CHANNEL_OFFSET + channel_offset];

   354     }

   355 

   356 // ---------------------------------------------------------------------------

   357 // ---------------------------------------------------------------------------

   358 //

   359 core_frame_mgmt_ie_ap_channel_report_c::core_frame_mgmt_ie_ap_channel_report_c(

   360     u16_t data_length,

   361     const u8_t* data,

   362     u16_t max_data_length ) :

   363     core_frame_dot11_ie_c( data_length, data, max_data_length )

   364     {

   365     }

   366 

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

   368 // ---------------------------------------------------------------------------

   369 //

   370 core_frame_mgmt_ie_admission_capacity_c* core_frame_mgmt_ie_admission_capacity_c::instance(

   371     const core_frame_dot11_ie_c& ie )

   372     {

   373     if ( ie.data_length() < CORE_FRAME_MGMT_IE_ADMISSION_CAPACITY_LENGTH )

   374         {

   375         DEBUG( "core_frame_mgmt_ie_admission_capacity_c::instance() - not a valid IE, invalid length" );

   376 

   377         return NULL;

   378         }

   379 

   380     core_frame_mgmt_ie_admission_capacity_c* instance = new core_frame_mgmt_ie_admission_capacity_c(

   381         ie.data_length(),

   382         ie.data(),

   383         0 );

   384     if ( !instance )

   385         {

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

   387 

   388         return NULL;

   389         }

   390 

   391     return instance;

   392     }

   393 

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

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

   396 //       

   397 core_frame_mgmt_ie_admission_capacity_c::~core_frame_mgmt_ie_admission_capacity_c()

   398     {

   399     }

   400 

   401 // ---------------------------------------------------------------------------

   402 // ---------------------------------------------------------------------------

   403 //

   404 u16_t core_frame_mgmt_ie_admission_capacity_c::admission_capacity_bitmask() const

   405     {

   406     return core_tools_c::get_u16(

   407         data_m,

   408         CORE_FRAME_MGMT_IE_ADMISSION_CAPACITY_BITMASK_OFFSET );

   409     }

   410 

   411 // ---------------------------------------------------------------------------

   412 // ---------------------------------------------------------------------------

   413 //

   414 void core_frame_mgmt_ie_admission_capacity_c::get_admission_capacity(

   415     u16_t ie_data_length,

   416     u16_t* admission_capacity_table )

   417     {

   418     for( u16_t i=0; i < (ie_data_length - CORE_FRAME_MGMT_IE_ADMISSION_CAPACITY_OFFSET ); i=i+2 )

   419         {

   420         admission_capacity_table[i/2] = core_tools_c::get_u16(

   421                                                         data_m,

   422                                                         CORE_FRAME_MGMT_IE_ADMISSION_CAPACITY_OFFSET + i );

   423         }

   424     }

   425 

   426 // ---------------------------------------------------------------------------

   427 // ---------------------------------------------------------------------------

   428 //

   429 core_frame_mgmt_ie_admission_capacity_c::core_frame_mgmt_ie_admission_capacity_c(

   430     u16_t data_length,

   431     const u8_t* data,

   432     u16_t max_data_length ) :

   433     core_frame_dot11_ie_c( data_length, data, max_data_length )

   434     {

   435     }

   436 

   437 // ---------------------------------------------------------------------------

   438 // ---------------------------------------------------------------------------

   439 //

   440 core_frame_mgmt_ie_power_capability_c* core_frame_mgmt_ie_power_capability_c::instance(

   441     const core_frame_dot11_ie_c& ie )

   442     {

   443     if ( ie.data_length() < CORE_FRAME_MGMT_IE_POWER_CAPABILITY_LENGTH )

   444         {

   445         DEBUG( "core_frame_mgmt_ie_power_capability_c::instance() - not a valid IE, invalid length" );

   446 

   447         return NULL;

   448         }

   449 

   450     core_frame_mgmt_ie_power_capability_c* instance = new core_frame_mgmt_ie_power_capability_c(

   451         ie.data_length(),

   452         ie.data(),

   453         0 );

   454     if ( !instance )

   455         {

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

   457 

   458         return NULL;

   459         }

   460 

   461     return instance;

   462     }

   463 

   464 // ---------------------------------------------------------------------------

   465 // ---------------------------------------------------------------------------

   466 //       

   467 core_frame_mgmt_ie_power_capability_c::~core_frame_mgmt_ie_power_capability_c()

   468     {

   469     }

   470 

   471 // ---------------------------------------------------------------------------

   472 // ---------------------------------------------------------------------------

   473 //

   474 u8_t core_frame_mgmt_ie_power_capability_c::power_capability() const

   475     {

   476     return data_m[CORE_FRAME_MGMT_IE_POWER_CAPABILITY_OFFSET];

   477     }

   478 

   479 // ---------------------------------------------------------------------------

   480 // ---------------------------------------------------------------------------

   481 //

   482 core_frame_mgmt_ie_power_capability_c::core_frame_mgmt_ie_power_capability_c(

   483     u16_t data_length,

   484     const u8_t* data,

   485     u16_t max_data_length ) :

   486     core_frame_dot11_ie_c( data_length, data, max_data_length )

   487     {

   488     }

   489 

   490 // ---------------------------------------------------------------------------

   491 // ---------------------------------------------------------------------------

   492 //

   493 core_frame_radio_mgmt_ie_c* core_frame_radio_mgmt_ie_c::instance(

   494     u16_t max_data_length,

   495     u8_t min_capability,

   496     u8_t max_capability )

   497     {

   498     u8_t* buffer = new u8_t[max_data_length + CORE_FRAME_DOT11_IE_HEADER_LENGTH];

   499 

   500     if ( !buffer )

   501         {

   502         DEBUG( "core_frame_radio_mgmt_ie_c::instance() - unable create the internal buffer" );

   503         return NULL;

   504         }

   505 

   506     core_frame_radio_mgmt_ie_c* instance =

   507         new core_frame_radio_mgmt_ie_c( 0, buffer, max_data_length + CORE_FRAME_DOT11_IE_HEADER_LENGTH );

   508     if ( !instance )

   509         {

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

   511         delete[] buffer;

   512         

   513         return NULL;

   514         }

   515 

   516     instance->generate(

   517         min_capability,

   518         max_capability );

   519 

   520     return instance;

   521     }

   522 

   523 // ---------------------------------------------------------------------------

   524 // ---------------------------------------------------------------------------

   525 //       

   526 core_frame_radio_mgmt_ie_c::~core_frame_radio_mgmt_ie_c()

   527     {

   528     DEBUG( "core_frame_radio_mgmt_ie_c::~core_frame_radio_mgmt_ie_c()" );   

   529     }

   530 

   531 // ---------------------------------------------------------------------------

   532 // ---------------------------------------------------------------------------

   533 //

   534 void core_frame_radio_mgmt_ie_c::generate(

   535     u8_t min_capability,

   536     u8_t max_capability )

   537     {

   538     ASSERT( !data_length_m );

   539     ASSERT( max_data_length_m );   

   540 

   541     core_frame_dot11_ie_c::generate( core_frame_dot11_ie_c::core_frame_dot11_ie_element_id_power_capability );

   542 

   543     // Minimum transmit power capability

   544     data_m[data_length_m++] = min_capability;

   545 

   546     // Maximum transmit power capability

   547     data_m[data_length_m++] = max_capability;

   548     

   549     set_length( data_length_m );

   550     }

   551 

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

   553 // ---------------------------------------------------------------------------

   554 //

   555 core_frame_radio_mgmt_ie_c::core_frame_radio_mgmt_ie_c(

   556     u16_t data_length,

   557     const u8_t* data,

   558     u16_t max_data_length ) :

   559     core_frame_dot11_ie_c( data_length, data, max_data_length )

   560     {

   561     DEBUG( "core_frame_radio_mgmt_ie_c::core_frame_radio_mgmt_ie_c()" );   

   562     }

   563 

   564 // ---------------------------------------------------------------------------

   565 // ---------------------------------------------------------------------------

   566 //

   567 core_frame_mgmt_ie_rrm_capabilities_c* core_frame_mgmt_ie_rrm_capabilities_c::instance(

   568     const core_frame_dot11_ie_c& ie )

   569     {

   570     if ( ie.data_length() < CORE_FRAME_MGMT_IE_RRM_CAPABILITIES_LENGTH )

   571         {

   572         DEBUG( "core_frame_mgmt_ie_rrm_capabilities_c::instance() - not a valid IE, invalid length" );

   573 

   574         return NULL;

   575         }

   576 

   577     core_frame_mgmt_ie_rrm_capabilities_c* instance = new core_frame_mgmt_ie_rrm_capabilities_c(

   578         ie.data_length(),

   579         ie.data(),

   580         0 );

   581     if ( !instance )

   582         {

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

   584 

   585         return NULL;

   586         }

   587 

   588     return instance;

   589     }

   590 

   591 // ---------------------------------------------------------------------------

   592 // ---------------------------------------------------------------------------

   593 //       

   594 core_frame_mgmt_ie_rrm_capabilities_c::~core_frame_mgmt_ie_rrm_capabilities_c()

   595     {

   596     }

   597 

   598 // ---------------------------------------------------------------------------

   599 // ---------------------------------------------------------------------------

   600 //

   601 u64_t core_frame_mgmt_ie_rrm_capabilities_c::rrm_capabilities() const

   602     {

   603     return core_tools_c::get_u64(

   604         data_m,

   605         CORE_FRAME_MGMT_IE_RRM_CAPABILITIES_OFFSET );

   606     }

   607 

   608 // ---------------------------------------------------------------------------

   609 // ---------------------------------------------------------------------------

   610 //

   611 core_frame_mgmt_ie_rrm_capabilities_c::core_frame_mgmt_ie_rrm_capabilities_c(

   612     u16_t data_length,

   613     const u8_t* data,

   614     u16_t max_data_length ) :

   615     core_frame_dot11_ie_c( data_length, data, max_data_length )

   616     {

   617     }

   618 

   619 // ---------------------------------------------------------------------------

   620 // ---------------------------------------------------------------------------

   621 //

   622 core_frame_rrm_mgmt_ie_c* core_frame_rrm_mgmt_ie_c::instance(

   623     const u8_t* rrm_capabilities )

   624     {

   625     u8_t* buffer = new u8_t[CORE_FRAME_RRM_MGMT_IE_LENGTH + CORE_FRAME_DOT11_IE_HEADER_LENGTH];

   626     if ( !buffer )

   627         {

   628         DEBUG( "core_frame_rrm_mgmt_ie_c::instance() - unable create the internal buffer" );

   629         return NULL;

   630         }

   631 

   632     core_frame_rrm_mgmt_ie_c* instance =

   633         new core_frame_rrm_mgmt_ie_c( 0, buffer, CORE_FRAME_RRM_MGMT_IE_LENGTH + CORE_FRAME_DOT11_IE_HEADER_LENGTH );

   634     if ( !instance )

   635         {

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

   637         delete[] buffer;

   638         

   639         return NULL;

   640         }

   641 

   642     instance->generate( rrm_capabilities );

   643 

   644     return instance;

   645     }

   646 

   647 // ---------------------------------------------------------------------------

   648 // ---------------------------------------------------------------------------

   649 //       

   650 core_frame_rrm_mgmt_ie_c::~core_frame_rrm_mgmt_ie_c()

   651     {

   652     DEBUG( "core_frame_rrm_mgmt_ie_c::~core_frame_rrm_mgmt_ie_c()" );   

   653     }

   654 

   655 // ---------------------------------------------------------------------------

   656 // ---------------------------------------------------------------------------

   657 //

   658 void core_frame_rrm_mgmt_ie_c::generate(

   659     const u8_t* rrm_capabilities )

   660     {

   661     ASSERT( !data_length_m );

   662     ASSERT( max_data_length_m );   

   663 

   664     core_frame_dot11_ie_c::generate( core_frame_dot11_ie_c::core_frame_dot11_ie_element_id_rrm_capabilities );

   665 

   666     // RRM capabilities

   667     core_tools_c::copy(

   668         &data_m[data_length_m],

   669         const_cast<u8_t*>(rrm_capabilities),

   670         CORE_FRAME_RRM_MGMT_IE_LENGTH );

   671     data_length_m += CORE_FRAME_RRM_MGMT_IE_LENGTH;

   672     

   673     set_length( data_length_m );

   674     }

   675 

   676 // ---------------------------------------------------------------------------

   677 // ---------------------------------------------------------------------------

   678 //

   679 core_frame_rrm_mgmt_ie_c::core_frame_rrm_mgmt_ie_c(

   680     u16_t data_length,

   681     const u8_t* data,

   682     u16_t max_data_length ) :

   683     core_frame_dot11_ie_c( data_length, data, max_data_length )

   684     {

   685     DEBUG( "core_frame_rrm_mgmt_ie_c::core_frame_rrm_mgmt_ie_c()" );   

   686     }

   687 

   688 // ---------------------------------------------------------------------------

   689 // ---------------------------------------------------------------------------

   690 //

   691 core_frame_mgmt_ie_request_ie_c* core_frame_mgmt_ie_request_ie_c::instance(

   692     const core_frame_dot11_ie_c& ie )

   693     {

   694     if ( ie.data_length() > CORE_FRAME_MGMT_IE_REQUEST_IE_MAX_LENGTH )

   695         {

   696         DEBUG( "core_frame_mgmt_ie_request_ie_c::instance() - not a valid IE, too long" );

   697 

   698         return NULL;

   699         }

   700 

   701     core_frame_mgmt_ie_request_ie_c* instance = new core_frame_mgmt_ie_request_ie_c(

   702         ie.data_length(),

   703         ie.data(),

   704         0 );

   705     if ( !instance )

   706         {

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

   708 

   709         return NULL;

   710         }

   711 

   712     return instance;

   713     }

   714 

   715 // ---------------------------------------------------------------------------

   716 // ---------------------------------------------------------------------------

   717 //       

   718 core_frame_mgmt_ie_request_ie_c::~core_frame_mgmt_ie_request_ie_c()

   719     {

   720     }

   721 

   722 // ---------------------------------------------------------------------------

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

   724 //

   725 u8_t core_frame_mgmt_ie_request_ie_c::element_list( u8_t* ie_id_list ) const

   726     {

   727     u8_t ie_id_list_length = data_length_m - CORE_FRAME_DOT11_IE_HEADER_LENGTH;

   728     

   729     core_tools_c::copy(

   730         ie_id_list,

   731         const_cast<u8_t*>( &data_m[CORE_FRAME_MGMT_IE_REQUEST_IE_OFFSET] ),

   732         data_length_m );

   733     

   734     return ie_id_list_length;

   735     }

   736 

   737 // ---------------------------------------------------------------------------

   738 // ---------------------------------------------------------------------------

   739 //

   740 u8_t core_frame_mgmt_ie_request_ie_c::element_data( 

   741     u16_t element_data_offset ) const

   742     {

   743     return data_m[CORE_FRAME_MGMT_IE_REQUEST_IE_OFFSET + element_data_offset];

   744     }

   745 

   746 // ---------------------------------------------------------------------------

   747 // ---------------------------------------------------------------------------

   748 //

   749 core_frame_mgmt_ie_request_ie_c::core_frame_mgmt_ie_request_ie_c(

   750     u16_t data_length,

   751     const u8_t* data,

   752     u16_t max_data_length ) :

   753     core_frame_dot11_ie_c( data_length, data, max_data_length )

   754     {

   755     }