/*

* Copyright (c) 2005-2010 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:  Class for WLAN EAPOL Plugin interface.

*

*/

/*

*/

#include "core_wlan_eapol_if_message.h"

#include "core_types.h"

#include "core_tools.h"

/**

 * Constructor

 */

core_wlan_eapol_if_parameter_c::core_wlan_eapol_if_parameter_c()

    : data_m( NULL )

    , buffer_length_m( 0 )

    , delete_buffer_m( false_t)

    {

    }

/**

 * Constructor

 *

 * @param data Pointer to the TLV encoded data.

 * @param data_length Length of the TLV encoded data.

 */

core_wlan_eapol_if_parameter_c::core_wlan_eapol_if_parameter_c(

    u8_t *data, u32_t data_length )

    : data_m( data )

    , buffer_length_m( data_length )

    , delete_buffer_m( false_t )

    {

    }

/** 

 * Destructor.

 */

core_wlan_eapol_if_parameter_c::~core_wlan_eapol_if_parameter_c()

    {

    if ( delete_buffer_m )

        {

        core_tools_c::fillz( data_m, buffer_length_m );

        delete[] data_m;

        data_m = NULL;

        }

    }

/**

 * Update content of parameter

 */

void core_wlan_eapol_if_parameter_c::update(

    u8_t *data, u32_t data_length )

    {

    data_m = data;

    buffer_length_m = data_length;

    delete_buffer_m = false_t;

    }

// ============================================================================

// General methods to handle parameters

u32_t core_wlan_eapol_if_parameter_c::size() const

    {

    return WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + get_parameter_length();

    }

wlan_eapol_if_message_type_e core_wlan_eapol_if_parameter_c::get_parameter_type() const

    {

    return static_cast<wlan_eapol_if_message_type_e>( core_tools_c::get_u32_big_endian(

        &data_m[0],

        WLAN_EAPOL_MESSAGE_IF_TYPE_OFFSET ));

    }

u32_t core_wlan_eapol_if_parameter_c::get_parameter_length() const

    {

    return core_tools_c::get_u32_big_endian(

        &data_m[0],

        WLAN_EAPOL_MESSAGE_IF_LENGTH_OFFSET );

    }

u8_t* core_wlan_eapol_if_parameter_c::get_data() const

    { 

    return &data_m[0];

    }

// ============================================================================

// Parameter specific methods

core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data(

    wlan_eapol_if_message_type_e type, 

    u32_t value )

    {

    DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data(type=%i, u32_t value=%i)", type, value );

    if ( type == wlan_eapol_if_message_type_u8_t )

        {

        return set_parameter_data_u8_t( type, value );

        }

    else if ( type == wlan_eapol_if_message_type_u16_t )

        {

        return set_parameter_data_u16_t( type, value );

        }

    else if ( type == wlan_eapol_if_message_type_boolean )

        {

        return set_parameter_data_boolean( type, value );

        }

    core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( value ) );

    if ( error != core_error_ok )

        {

        return error;

        }

    add_header( type, sizeof( value ) );

    add_parameter_u32_t( value );

    return core_error_ok;

    }

core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data(

    wlan_eapol_if_message_type_e type, 

    const u8_t* data, 

    u32_t length )

    { 

    DEBUG3( "core_wlan_eapol_if_parameter_c::set_parameter_data(type=%i, data=%08X, length=%i)", type, data, length );

    core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + length );

    if ( error != core_error_ok )

        {

        return error;

        }

    add_header( type, length );

    if ( data == NULL || length == 0 )

        {

        // Variable data and Array could be empty. In that case data is NULL.

        if ( type != wlan_eapol_if_message_type_array &&

             type != wlan_eapol_if_message_type_variable_data )

            {

            DEBUG( "core_wlan_eapol_if_parameter_c::set_parameter_data() - Illegal arguments" );

            ASSERT( false_t );

            return core_error_illegal_argument;

            }

        return core_error_ok;

        }

    else

        {

        core_tools_c::copy( 

            &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET],

            data, 

            length );

        }

    return core_error_ok;

    }

core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data(

    wlan_eapol_if_message_type_e type, 

    u32_t vendor_id, 

    u32_t vendor_type )

    { 

    DEBUG3( "core_wlan_eapol_if_parameter_c::set_parameter_data(type=%i, vendor_id=%06X, vendor_type=%08X)", type, vendor_id, vendor_type );

    if ( type != wlan_eapol_if_message_type_eap_type )

        {

        return core_error_illegal_argument;

        }

    u32_t length( 8 ); // Size of EAP type.

    core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + length );

    if ( error != core_error_ok )

        {

        return error;

        }

    add_header( type, length );

    const u32_t eap_type = 254; // This is constant in Extended EAP type.

    vendor_id = (vendor_id & 0x00FFFFFF) ^ (eap_type<<24);

    vendor_id = core_tools_c::convert_host_to_big_endian( vendor_id );

    core_tools_c::copy( 

        &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET], 

        &vendor_id, 

        sizeof( vendor_id ) );

    vendor_type = core_tools_c::convert_host_to_big_endian( vendor_type );

    core_tools_c::copy( 

        &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( vendor_id )], 

        &vendor_type, 

        sizeof( vendor_type ) );

    return core_error_ok;

    }

core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_boolean(

    wlan_eapol_if_message_type_e type, 

    bool_t boolean )

    { 

    DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data_boolean(type=%i, bool_t value=%i)", type, boolean );

    core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( boolean ) );

    if ( error != core_error_ok )

        {

        return error;

        }

    add_header( type, sizeof( boolean ) );

    add_parameter_u32_t( boolean );

    return core_error_ok;

    }

core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_u16_t(

    wlan_eapol_if_message_type_e type, 

    u16_t value )

    {

    DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data_u16_t(type=%i, u16_t value=%i)", type, value );

    core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( value ) );

    if ( error != core_error_ok )

        {

        return error;

        }

    add_header( type, sizeof( value ) );

    add_parameter_u16_t( value );

    return core_error_ok;

    }

core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_u8_t(

    wlan_eapol_if_message_type_e type, 

    u8_t value )

    { 

    DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data_u8_t(type=%i, u8_t value=%i)", type, value );

    core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( value ) );

    if ( error != core_error_ok )

        {

        return error;

        }

    add_header( type, sizeof( value ) );

    add_parameter_u8_t( value );

    return core_error_ok;

    }

core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_u64_t(

        u64_t data )

        {

        DEBUG( "core_wlan_eapol_if_parameter_c::set_parameter_data_u64_t()" );

        core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( data ) );

        if ( error != core_error_ok )

            {

            return error;

            }

        add_header( wlan_eapol_if_message_type_u64_t, sizeof( data ) );

        u64_t parameter_data = 

           static_cast<u64_t>( ((data & 0xFF) << 56)

                            | ((data & 0xFF00) << 40)

                            | ((data & 0xFF0000) << 24)

                            | ((data & 0xFF000000) << 8)

                            | (((data >> 32) & 0xFF) << 24)

                            | (((data >> 32) & 0xFF00) << 8)

                            | (((data >> 32) & 0xFF0000) >> 8)

                            | (((data >> 32) & 0xFF000000) >> 24) );

        core_tools_c::copy( 

            &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET], 

            &parameter_data, 

            sizeof( parameter_data ) );

        COMPILE_ASSERT( sizeof( parameter_data ) == 8 ); // Specification says this.

        return core_error_ok;

        }

// ============================================================================

// All 32 bit values

core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data(

    u32_t * value ) const

    { 

    ASSERT( value );

    wlan_eapol_if_message_type_e type = get_parameter_type();

    if ( type == wlan_eapol_if_message_type_u32_t

        || type == wlan_eapol_if_message_type_function

        || type == wlan_eapol_if_message_type_eap_protocol_layer

        || type == wlan_eapol_if_message_type_eap_status

        || type == wlan_eapol_if_message_type_eapol_key_802_11_authentication_mode

        || type == wlan_eapol_if_message_type_eapol_key_authentication_type

        || type == wlan_eapol_if_message_type_eapol_key_type

        || type == wlan_eapol_if_message_type_eapol_tkip_mic_failure_type

        || type == wlan_eapol_if_message_type_eapol_wlan_authentication_state

        || type == wlan_eapol_if_message_type_error

        || type == wlan_eapol_if_message_type_RSNA_cipher )

        {

        *value = get_parameter_u32_t();

        return core_error_ok;

        }

    *value = 0;

    DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u32_t ) - Error: parameter not found" );

    return core_error_not_found;

    }

// 

core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data(

    u64_t * value ) const

    { 

    ASSERT( value );

    if ( get_parameter_type() == wlan_eapol_if_message_type_u64_t )

        {

        *value = get_parameter_u64_t();

        return core_error_ok;

        }

    *value = 0;

    DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u64_t ) - Error: parameter not found" );

    return core_error_not_found;

    }

// 

core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data(

    bool_t * value ) const

    {

    ASSERT( value );

    if ( get_parameter_type() == wlan_eapol_if_message_type_boolean )

        {

        *value = get_parameter_u32_t();

        return core_error_ok;

        }

    *value = 0;

    DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( bool_t ) - Error: parameter not found" );

    return core_error_not_found;

    }

core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data(

    u16_t * value ) const

    {

    ASSERT( value );

    if ( get_parameter_type() == wlan_eapol_if_message_type_u16_t )

        {

        *value = get_parameter_u16_t();

        return core_error_ok;

        }

    *value = 0;

    DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u16_t ) - Error: parameter not found" );

    return core_error_not_found;

    }

core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data(

    u8_t * value ) const

    { 

    ASSERT( value );

    if ( get_parameter_type() == wlan_eapol_if_message_type_u8_t )

        {

        *value = get_parameter_u8_t();

        return core_error_ok;

        }

    *value = 0;

    DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u8_t ) - Error: parameter not found" );

    return core_error_not_found;

    }

core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data(

    u8_t ** const data, 

    u32_t * data_length ) const

    { 

    ASSERT( data );

    ASSERT( data_length );

    // All structured parameters must be mentioned here.

    if ( get_parameter_type() == wlan_eapol_if_message_type_variable_data

        || get_parameter_type() == wlan_eapol_if_message_type_network_id

        || get_parameter_type() == wlan_eapol_if_message_type_session_key

        || get_parameter_type() == wlan_eapol_if_message_type_network_key

        || get_parameter_type() == wlan_eapol_if_message_type_protected_setup_credential

        || get_parameter_type() == wlan_eapol_if_message_type_eap_state_notification

        || get_parameter_type() == wlan_eapol_if_message_type_array )

        {

        *data = &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET];

        *data_length = get_parameter_length();

        // If data length is zero, it is good to set also data pointer to NULL.

        if ( *data_length == 0 )

            {

            *data = NULL;

            }

        return core_error_ok;

        }

    *data = NULL;

    *data_length = 0;

    DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( non-basic types ) - Error: parameter not found" );

    return core_error_not_found;

    }

core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data(

    u32_t * vendor_id, 

    u32_t * vendor_type ) const

    { 

    ASSERT( vendor_id );

    ASSERT( vendor_type );

    wlan_eapol_if_message_type_e type = get_parameter_type();

    if ( type == wlan_eapol_if_message_type_eap_type )

        {

        *vendor_id = core_tools_c::get_u32_big_endian(

            &data_m[0],

            WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET );

        if( ( *vendor_id >> 24 ) == 254 )

            {

            *vendor_id &= 0x00FFFFFF; // Mask EAP-type constant (254) out

            *vendor_type = core_tools_c::get_u32_big_endian(

                &data_m[0],

                WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( vendor_id ) );

            }

        else // Not expanded EAP type, in this case EAP type is first byte of vendor_id

            {

            *vendor_type = ( *vendor_id  >> 24 );

            *vendor_id = 0;

            }

        return core_error_ok;

        }

    *vendor_id = 0;

    *vendor_type = 0;

    DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( vendor_id, vendor_type ) - Error: parameter not found" );

    return core_error_not_found;

    }

// ============================================================================

core_error_e core_wlan_eapol_if_parameter_c::reserve_buffer(

    u32_t needed_buffer_length )

    {

    if ( needed_buffer_length <= buffer_length_m )

        {

        return core_error_ok;

        }

    DEBUG2( "core_wlan_eapol_if_parameter_c::reserve_buffer - increase buffer %i->%i bytes", buffer_length_m, needed_buffer_length );

    u8_t* p = new u8_t[needed_buffer_length];

    if ( !p )

        {

        DEBUG( "core_wlan_eapol_if_parameter_c::reserve_buffer - Error: No enough memory!" );

        return core_error_no_memory;

        }

    core_tools_c::fillz( p, needed_buffer_length );

    core_tools_c::copy( 

        p,

        &data_m[0],

        buffer_length_m );

    core_tools_c::fillz( &data_m[0], buffer_length_m );

    if ( delete_buffer_m )

        {

        delete[] data_m;

        }

    delete_buffer_m = true_t;

    data_m = p;

    buffer_length_m = needed_buffer_length;

    return core_error_ok;

    }

void core_wlan_eapol_if_parameter_c::add_header(

    wlan_eapol_if_message_type_e type, 

    u32_t length ) 

    {

    // Type

    u32_t type_value( type );

    type_value = core_tools_c::convert_host_to_big_endian( type_value );

    core_tools_c::copy( 

        &data_m[0], 

        &type_value, 

        sizeof( type_value ) );

    COMPILE_ASSERT( sizeof( type_value ) == 4); // Specification says this.

    // Length

    u32_t parameter_length( length );

    parameter_length = core_tools_c::convert_host_to_big_endian( parameter_length );

    core_tools_c::copy( 

        &data_m[WLAN_EAPOL_MESSAGE_IF_LENGTH_OFFSET],

        &parameter_length, 

        sizeof( parameter_length ) );

    COMPILE_ASSERT( sizeof( parameter_length ) == 4); // Specification says this.

    }

u64_t core_wlan_eapol_if_parameter_c::get_parameter_u64_t() const

    {

    u64_t value = core_tools_c::get_u32_big_endian(

        &data_m[0],

        WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET );

    value <<= 32;

    value += core_tools_c::get_u32_big_endian(

        &data_m[0],

        WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET+4 );

    return value;

    }