/*

* Copyright (c) 2002-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:  Simple utility functions for core

*

*/

#include "core_tools.h"

#include "core_frame_beacon.h"

#include "genscanoffsets.h"

#include "am_debug.h"

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

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

// core_tools_c::compare

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

//

int_t core_tools_c::compare(

    const u8_t* pl,

    int_t ll, 

    const u8_t* pr, 

    int_t rl )

    {

    if ( ll != rl )

        {

        return ll - rl;

        }        

    if ( pl == pr )

        {

        return 0;

        }        

    for ( int_t i( 0 ); i < ll; ++i )

        {

        if ( *(pl+i) != *(pr+i) )

            {

            return *(pl+i) - *(pr+i);

            }

        }

    return 0;

    }

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

// core_tools_c::copy

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

//

u8_t* core_tools_c::copy(

    void* trg,

    const void* src,

    int_t len )

    {

    if ( len <= 0 )

        {

        return reinterpret_cast<u8_t*>( trg );

        }

    if ( trg == src )

        {

        return reinterpret_cast<u8_t*>( trg ) + len;

        }

    // ensure areas do not overlap

    if ( trg > src )

        {

        ASSERT( reinterpret_cast<u8_t*>( trg ) >= ( reinterpret_cast<const u8_t*>( src ) + len ) );

        }

    else

        {

        ASSERT( reinterpret_cast<const u8_t*>( src ) >= ( reinterpret_cast<u8_t*>( trg ) + len ) );

        }

    for ( i32_t i( 0 ); i < len; ++i )

        {

        *( reinterpret_cast<u8_t*>( trg ) + i ) = *( reinterpret_cast<const u8_t*>( src ) + i );

        }

    return reinterpret_cast<u8_t*>( trg ) + len;

    }

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

// core_tools_c::fillz

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

//

void core_tools_c::fillz(

    void* trg,

    int_t len )

    {

    if ( len <= 0 )

        {

        return;

        }        

    for ( int_t i( 0 ); i < len; ++i )

        {

        *( reinterpret_cast<u8_t*>( trg ) + i ) = 0;

        }

    }

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

// core_tools_c::convert_host_to_big_endian

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

//

u16_t core_tools_c::convert_host_to_big_endian(

    u16_t src )

    {

    return( static_cast<u16_t>( ( src >> 8 ) | ( src << 8 ) ) );

    }

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

// core_tools_c::convert_host_to_big_endian

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

//           

u32_t core_tools_c::convert_host_to_big_endian(

    u32_t src )

    {

    return( static_cast<u32_t>( ( ( src & 0xFF ) << 24 ) | 

                                ( ( src & 0xFF00 ) << 8 ) |

                                ( ( src & 0xFF0000 ) >> 8 ) | 

                                ( ( src & 0xFF000000 ) >> 24 ) ) );      

    }

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

// core_tools_c::convert_big_endian_to_host

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

//

u16_t core_tools_c::convert_big_endian_to_host(

    u16_t src )

    {

    return( static_cast<u16_t>( ( src >> 8 ) | ( src << 8 ) ) ); 

    }

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

// core_tools_c::convert_big_endian_to_host

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

//

u32_t core_tools_c::convert_big_endian_to_host(

    u32_t src )

    {

    return( static_cast<u32_t>( ( ( src & 0xFF ) << 24 ) | 

                                ( ( src & 0xFF00 ) << 8 ) |

                                ( ( src & 0xFF0000 ) >> 8 ) | 

                                ( ( src & 0xFF000000 ) >> 24 ) ) );     

    }

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

// core_tools_c::get_u16_big_endian

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

//

u16_t core_tools_c::get_u16_big_endian(

    const u8_t* data,

    u16_t index )

    {

    return core_tools_c::convert_big_endian_to_host(

        get_u16( data, index ) );

    }

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

// core_tools_c::get_u16

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

//

u16_t core_tools_c::get_u16(

    const u8_t* data,

    u16_t index )

    {

    u16_t temp16( 0 );

    core_tools_c::copy( reinterpret_cast<u8_t*>( &temp16 ),

        data + index,

        sizeof( temp16 ) );

    return temp16;

    }

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

// core_tools_c::get_u32_big_endian

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

//

u32_t core_tools_c::get_u32_big_endian(

    const u8_t* data,

    u16_t index )

    {

    return core_tools_c::convert_big_endian_to_host(

        get_u32( data, index ) );

    }

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

// core_tools_c::get_u32

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

//

u32_t core_tools_c::get_u32(

    const u8_t* data,

    u16_t index )

    {

    u32_t temp32( 0 );

    core_tools_c::copy( reinterpret_cast<u8_t*>( &temp32 ),

        data + index,

        sizeof( temp32 ) );

    return temp32;       

    }

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

// core_tools_c::get_u64

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

//

u64_t core_tools_c::get_u64(

    const u8_t* data,

    u16_t index )

    {

    u64_t temp64( 0 );

    core_tools_c::copy( reinterpret_cast<u8_t*>( &temp64 ),

        data + index,

        sizeof( temp64 ) );

    return temp64;       

    }

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

// core_tools_c::insert_u16_big_endian

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

//

void core_tools_c::insert_u16_big_endian(

    u8_t* data,

    u16_t index,

    u16_t value )

    {

    u16_t temp16(

        convert_host_to_big_endian( value ) );

    core_tools_c::copy(

        &data[index],

        reinterpret_cast<u8_t*>( &temp16 ),

        sizeof( temp16 ) );

    }

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

// core_tools_c::insert_u16

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

//

void core_tools_c::insert_u16(

    u8_t* data,

    u16_t index,

    u16_t value )

    {

    u16_t temp16( value );

    core_tools_c::copy(

        &data[index],

        reinterpret_cast<u8_t*>( &temp16 ),

        sizeof( temp16 ) );    

    }

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

// core_tools_c::insert_u32_big_endian

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

//

void core_tools_c::insert_u32_big_endian(

    u8_t* data,

    u16_t index,

    u32_t value )

    {

    u32_t temp32(

        convert_host_to_big_endian( value ) );

    core_tools_c::copy(

        &data[index],

        reinterpret_cast<u8_t*>( &temp32 ),

        sizeof( temp32 ) );

    }

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

// core_tools_c::insert_u32

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

//

void core_tools_c::insert_u32(

    u8_t* data,

    u16_t index,

    u32_t value )

    {

    u32_t temp32( value );

    core_tools_c::copy(

        &data[index],

        reinterpret_cast<u8_t*>( &temp32 ),

        sizeof( temp32 ) );    

    }

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

// core_tools_c::append_u16_big_endian

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

//    

void core_tools_c::append_u16_big_endian(

    u8_t* data,

    u16_t& data_length,

    u16_t value )

    {

    insert_u16_big_endian(

        data,

        data_length,

        value );

    data_length += sizeof( value );

    }

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

// core_tools_c::append_u16

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

//

void core_tools_c::append_u16(

    u8_t* data,

    u16_t& data_length,

    u16_t value )

    {

    insert_u16(

        data,

        data_length,

        value );

    data_length += sizeof( value );    

    }

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

// core_tools_c::append_u32_big_endian

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

//    

void core_tools_c::append_u32_big_endian(

    u8_t* data,

    u16_t& data_length,

    u32_t value )

    {

    insert_u32_big_endian(

        data,

        data_length,

        value );

    data_length += sizeof( value );

    }

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

// core_tools_c::append_u32

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

//

void core_tools_c::append_u32(

    u8_t* data,

    u16_t& data_length,

    u32_t value )

    {

    insert_u32(

        data,

        data_length,

        value );

    data_length += sizeof( value );    

    }

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

// core_tools_c::cipher_key_type

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

//

core_cipher_key_type_e core_tools_c::cipher_key_type(

    core_cipher_suite_e cipher )

    {

    switch( cipher )

        {

        case core_cipher_suite_wep40:

            /** Falls through on purpose. */

        case core_cipher_suite_wep104:

            return core_cipher_key_type_wep;

        case core_cipher_suite_tkip:

            return core_cipher_key_type_tkip;

        case core_cipher_suite_ccmp:

            return core_cipher_key_type_ccmp;

        case core_cipher_suite_wpi:

            return core_cipher_key_type_wpi;

        default:

            return core_cipher_key_type_none;            

        }

    }

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

// core_tools_c::cipher_key_type

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

//

core_cipher_key_type_e core_tools_c::cipher_key_type(

    wlan_eapol_if_eapol_key_type_e type,

    core_cipher_suite_e pairwise_cipher,

    core_cipher_suite_e group_cipher )

    {

    core_cipher_key_type_e return_type( core_cipher_key_type_ccmp );

    switch( type )

        {

        case wlan_eapol_if_eapol_key_type_unicast:

            {

            if( pairwise_cipher == core_cipher_suite_ccmp )

                {

                DEBUG( "core_tools_c::cipher_key_type() - pairwise CCMP key" );

                return_type = core_cipher_key_type_ccmp;

                }

            else if( pairwise_cipher == core_cipher_suite_tkip )

                {

                DEBUG( "core_tools_c::cipher_key_type() - pairwise TKIP key" );

                return_type = core_cipher_key_type_tkip;

                }

            else if( pairwise_cipher == core_cipher_suite_wpi )

                {

                DEBUG( "core_tools_c::cipher_key_type() - pairwise WPI key" );

                return_type = core_cipher_key_type_wpi;                

                }

            else

                {

                DEBUG( "core_tools_c::cipher_key_type() - pairwise WEP key" );

                return_type = core_cipher_key_type_wep;

                }

            break;            

            }           

        case wlan_eapol_if_eapol_key_type_broadcast:

            {            

            if( group_cipher == core_cipher_suite_ccmp )

                {

                DEBUG( "core_tools_c::cipher_key_type() - group CCMP key" );

                return_type = core_cipher_key_type_ccmp;

                }

            else if( group_cipher == core_cipher_suite_tkip )

                {

                DEBUG( "core_tools_c::cipher_key_type() - group TKIP key" );

                return_type = core_cipher_key_type_tkip;

                }

            else if( pairwise_cipher == core_cipher_suite_wpi )

                {

                DEBUG( "core_tools_c::cipher_key_type() - group WPI key" );

                return_type = core_cipher_key_type_wpi;                

                }

            else

                {

                DEBUG( "core_tools_c::cipher_key_type() - group WEP key" );

                return_type = core_cipher_key_type_wep;

                }

            break;

            }            

        case wlan_eapol_if_eapol_key_type_pmkid:

            {

            DEBUG( "core_tools_c::cipher_key_type() - PMKID" );

            ASSERT( false_t );

            break;

            }

        default:

            {

            DEBUG1( "core_tools_c::cipher_key_type() - unknown EAPOL key type %u",

                type );

            ASSERT( false_t );

            }

        }

    return return_type;

    }

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

// core_tools_c::cipher_key_type

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

//

wlan_eapol_if_eapol_key_authentication_type_e core_tools_c::eap_authentication_type(

    const core_iap_data_c& iap_data,

    const core_ap_data_c& ap_data )

    {

    core_security_mode_e mode =

        iap_data.security_mode();

    bool_t is_psk_required =

        iap_data.is_psk_used();

    if( mode == core_security_mode_802dot1x &&

         !ap_data.is_rsn_ie_present() &&

         !ap_data.is_wpa_ie_present() )

        {

        DEBUG( "core_tools_c::eap_authentication_type() - wlan_eapol_if_eapol_key_authentication_type_802_1x" );

        return wlan_eapol_if_eapol_key_authentication_type_802_1x;

        }

        {

        DEBUG( "core_tools_c::eap_authentication_type() - wlan_eapol_if_eapol_key_authentication_type_wpx_fast_roam" );

        return wlan_eapol_if_eapol_key_authentication_type_wpx_fast_roam;

        }

    if( mode == core_security_mode_protected_setup )

        {

        DEBUG( "core_tools_c::eap_authentication_type() - wlan_eapol_if_eapol_key_authentication_type_wfa_sc" );

        return wlan_eapol_if_eapol_key_authentication_type_wfa_sc;

        }

    else if( iap_data.is_eap_used() )

        {

        if( ap_data.is_rsn_ie_present() )

            {

            if( !is_psk_required &&

                ap_data.key_management_suites() & core_key_management_eap )

                {

                DEBUG( "core_tools_c::eap_authentication_type() - wlan_eapol_if_eapol_key_authentication_type_rsna_eap" );

                return wlan_eapol_if_eapol_key_authentication_type_rsna_eap;

                }

            else if( is_psk_required &&

                     ap_data.key_management_suites() & core_key_management_preshared )

                {

                DEBUG( "core_tools_c::eap_authentication_type() - wlan_eapol_if_eapol_key_authentication_type_rsna_psk" );

                return wlan_eapol_if_eapol_key_authentication_type_rsna_psk;