/*

* 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:  Handles type conversion between adaptation and core layers

*

*/

/*

*/

#include <in_sock.h>

#include <e32math.h>

#include <in_iface.h>

#include "wlanconversionutil.h"

#include "wlmserver.h"

#include "wlmtsparams.h"

#include "am_debug.h"

/**

 * Mappings from user priority to access class.

 */

const TWlmAccessClass KWlmUserPriorityToAccessClass[] =

    {

    EWlmAccessClassBestEffort,

    EWlmAccessClassBackground,

    EWlmAccessClassBackground,

    EWlmAccessClassBestEffort,

    EWlmAccessClassVideo,

    EWlmAccessClassVideo,

    EWlmAccessClassVoice,

    EWlmAccessClassVoice    

    };

// Compile time assert. Used to make sure that some core constants are matching with Symbian constants.

#define COMPILE_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1] //lint --e{58,92,751,761,30,452,545}

// 58  = Error -- Bad type

// 92  = Negative array dimension or bit field length (-1)

// 751 = local typedef '__C_ASSERT__' not referenced

// 761 = Redundant typedef '__C_ASSERT__' previously declared at line x

// 30  = Expected an integer constant, obtained an expression that could not be evaluated

// 452 = typedef Symbol '__C_ASSERT__' redeclared (size) conflicts with line x

// 545 = Suspicious use of &

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

// TWlanConversionUtil::ConvertSSID()

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

//

void TWlanConversionUtil::ConvertSSID(

    core_ssid_s& aCoreSSID,

    const TSSID& aSSID )

    {

    Mem::Copy( aCoreSSID.ssid, aSSID.ssid, aSSID.ssidLength );

    aCoreSSID.length = aSSID.ssidLength;

    }

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

// TWlanConversionUtil::ConvertSSID()

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

//

void TWlanConversionUtil::ConvertSSID(

    core_ssid_s& aCoreSSID,

    const TDesC& aSSID )

    {

    TBuf8<KMaxSSIDLength> ssidBuf;

    ssidBuf.Copy( aSSID );

    Mem::Copy( aCoreSSID.ssid, ssidBuf.Ptr(), ssidBuf.Length() );

    aCoreSSID.length = ssidBuf.Length();

    }

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

// TWlanConversionUtil::ConvertSSID()

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

//

void TWlanConversionUtil::ConvertSSID(

    core_ssid_s& aCoreSSID,

    const TDesC8& aSSID )

    {

    Mem::Copy( aCoreSSID.ssid, aSSID.Ptr(), aSSID.Length() );

    aCoreSSID.length = aSSID.Length();

    }

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

// TWlanConversionUtil::ConvertSSID()

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

//

void TWlanConversionUtil::ConvertSSID(

    TSSID& aAmSSID,

    const core_ssid_s& aCoreSSID )

    {

    Mem::Copy( aAmSSID.ssid, aCoreSSID.ssid, aCoreSSID.length );

    aAmSSID.ssidLength = aCoreSSID.length;

    }

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

// TWlanConversionUtil::ConvertScanRate()

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

//

TRate TWlanConversionUtil::ConvertScanRate( int_t aCoreScanRate )

    {

    return static_cast<TRate>( aCoreScanRate );

    }

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

// TWlanConversionUtil::ConvertSecurityMode()

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

//

TWlanSecurity TWlanConversionUtil::ConvertSecurityMode(

    const core_connection_security_mode_e& aCoreMode )

    {

    switch( aCoreMode )

        {

        case core_connection_security_mode_open:

            return EWlanSecurityOpen;

        case core_connection_security_mode_wep_open:

            return EWlanSecurityWepOpen;

        case core_connection_security_mode_wep_shared:

            return EWlanSecurityWepShared;

        case core_connection_security_mode_802d1x:

            return EWlanSecurity802d1x;

        case core_connection_security_mode_wpa:

            return EWlanSecurityWpa;

        case core_connection_security_mode_wpa_psk:

            return EWlanSecurityWpaPsk;

        case core_connection_security_mode_wpa2:

            return EWlanSecurityWpa2;

        case core_connection_security_mode_wpa2_psk:

            return EWlanSecurityWpa2Psk;

        case core_connection_security_mode_wapi:

            return EWlanSecurityWapi;

        case core_connection_security_mode_wapi_psk:

            return EWlanSecurityWapiPsk;

        default:

            return EWlanSecurityOpen;

        }

    }

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

// TWlanConversionUtil::ConvertEncryptionMode()

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

//

TEncryptionStatus TWlanConversionUtil::ConvertEncryptionMode(

    const core_encryption_mode_e& aCoreEncryptionMode )

    {

    switch( aCoreEncryptionMode )

        {

        case core_encryption_mode_disabled:

            return EEncryptionDisabled;

        case core_encryption_mode_wep:

            return EEncryptionWep;

        case core_encryption_mode_802dot1x:

            return EEncryption802dot1x;

        case core_encryption_mode_wep_mixed_cell:

            return EEncryptionWepMixed;

        case core_encryption_mode_802dot1x_mixed_cell:

            return EEncryption802dot1xMixed;

        case core_encryption_mode_wpi:

            return EEncryptionWAPI;

        default: // instead of case core_encryption_mode_wpa:

            return EEncryptionWpa;

        }

    }

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

// TWlanConversionUtil::ConvertConnectionState()

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

//

TWlanConnectionState TWlanConversionUtil::ConvertConnectionState(

    const core_connection_state_e& aCoreState )

    {

    switch( aCoreState )

        {

        case core_connection_state_notconnected:

            return EWlanStateNotConnected;

        case core_connection_state_infrastructure:

            return EWlanStateInfrastructure;

        case core_connection_state_searching:

            return EWlanStateSearchingAP;

        case core_connection_state_ibss: // fall through on purpose

        case core_connection_state_secureibss:

            return EWlanStateIBSS;

        case core_connection_state_secureinfra:

            return EWlanStateSecureInfra;

        default:

            return EConnectionStateUnknown;

        }

    }

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

// TWlanConversionUtil::ConvertScanMode()

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

//

core_scan_mode_e TWlanConversionUtil::ConvertScanMode(

    const TScanMode& aAmScanMode )

    {

    switch( aAmScanMode )

        {

        case EActiveScan:

            return core_scan_mode_active;

        case EPassiveScan:

            return core_scan_mode_passive;

        default:

            return core_scan_mode_passive;

        }

    }

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

// TWlanConversionUtil::ConvertScanMode()

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

//

TScanMode TWlanConversionUtil::ConvertScanMode(

    const core_scan_mode_e& aCoreScanMode )

    {

    switch( aCoreScanMode )

        {

        case core_scan_mode_active:

            return EActiveScan;

        case core_scan_mode_passive:

            return EPassiveScan;

        default:

            return EPassiveScan;

        }

    }

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

// TWlanConversionUtil::ConvertConvertCipherKeyType()

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

//

TWlanCipherSuite TWlanConversionUtil::ConvertCipherKeyType(

    const core_cipher_key_type_e& aCoreCipherKeyType )

    {

    switch( aCoreCipherKeyType )

        {

        case core_cipher_key_type_none:

            return EWlanCipherSuiteNone;

        case core_cipher_key_type_tkip:

            return EWlanCipherSuiteTkip;

        case core_cipher_key_type_ccmp:

            return EWlanCipherSuiteCcmp;

        case core_cipher_key_type_wpi:

            return EWlanCipherSuiteWapi;

        default:

            return EWlanCipherSuiteWep;

        }

    }

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

// TWlanConversionUtil::ConvertNotificationType()

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

//

TWlmNotify TWlanConversionUtil::ConvertNotificationType(

    const core_notification_e& aCoreNotificationType )

    {

    switch( aCoreNotificationType )

        {

        case core_notification_connection_state_changed:

            return EWlmNotifyConnectionStateChanged;

        case core_notification_bssid_changed:

            return EWlmNotifyBssidChanged;

        case core_notification_bss_lost:

            return EWlmNotifyBssLost;

        case core_notification_bss_regained:

            return EWlmNotifyBssRegained;

        case core_notification_tx_power_level_changed:

            return EWlmNotifyTransmitPowerChanged;

        case core_notification_rcp_changed:

            return EWlmNotifyRcpChanged;

        case core_notification_ts_status_changed:

            return EWlmNotifyTrafficStreamStatusChanged;

        case core_notification_ap_info_changed:

            return EWlmNotifyAccessPointInfoChanged;

        case core_notification_rcpi_roam_attempt_started:

            return EWlmNotifyRcpiRoamAttemptStarted;

        case core_notification_rcpi_roam_attempt_completed:

            return EWlmNotifyRcpiRoamAttemptCompleted;

        case core_notification_ac_traffic_mode_changed:

            return EWlmNotifyAcTrafficModeChanged;

        case core_notification_ac_traffic_status_changed:

            return EWlmNotifyAcTrafficStatusChanged;

        default: // this should never happen

            return EWlmNotifyNone;

        }

    }

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

// TWlanConversionUtil::ConvertConnectStatus()

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

//

TInt TWlanConversionUtil::ConvertConnectStatus(

    const core_connect_status_e& aCoreConnectStatus,

    core_security_mode_e security_mode )

    {

    switch( aCoreConnectStatus )

        {

        case core_connect_ok:

            return KErrNone;

        case core_connect_network_not_found:

        case core_connect_mode_infra_required_but_ibss_found:

        case core_connect_mode_ibss_required_but_infra_found:

        case core_connect_ap_full:

        case core_connect_ap_not_whitelisted:

        case core_connect_ap_permanently_blacklisted:

        case core_connect_ap_temporarily_blacklisted:

        case core_connect_ap_outside_defined_region:

        case core_connect_iap_open_but_ap_requires_encryption:

        case core_connect_iap_wep_but_ap_has_no_privacy:

        case core_connect_iap_wpa_but_ap_has_no_privacy:

        case core_connect_eapol_auth_start_timeout:

        case core_connect_wep_open_authentication_unsupported:

        case core_connect_wep_shared_authentication_unsupported:

            return KErrWlanNetworkNotFound;

        case core_connect_iap_wep_but_ap_has_wpa_ie:

            return KErrWlanWpaAuthRequired;

        case core_connect_wpa_ap_has_no_valid_ciphers:

        case core_connect_wpa_ie_required_but_ap_has_none:

            {

            if ( security_mode == core_security_mode_wpa2only )

                {

                return KErrWlanWpa2OnlyModeNotSupported;

                }

            return KErrWlanNetworkNotFound;

            }

        case core_connect_wep_open_echo_test_failed:

            return KErrWlanIllegalEncryptionKeys;

        case core_connect_wep_shared_authentication_failed:

            return KErrWlanSharedKeyAuthFailed;

        case core_connect_wpa_psk_required_but_ap_has_no_support:

            return KErrWlanEapModeRequired;

        case core_connect_wpa_eap_required_but_ap_has_no_support:

            return KErrWlanPskModeRequired;

        case core_connect_wpa_eap_failure:

            return KErrWlanWpaAuthFailed;

        case core_connect_wpa_psk_failure:

            return KErrWlanIllegalWpaPskKey;

        case core_connect_802_1x_failure:

        case core_connect_802_1x_authentication_algorithm_not_supported:

            return KErrWlan802dot1xAuthFailed;

        case core_connect_wpa_authentication_canceled_by_user:

        case core_connect_802_1x_authentication_canceled_by_user:

            return KErrCancel;

        case core_connect_eap_gtc_failure:

            return KErrWlanEapGtcFailed;

        case core_connect_eap_tls_failure:

            return KErrWlanEapTlsFailed;

        case core_connect_eap_tls_server_certificate_expired:

        case core_connect_eap_ttls_server_certificate_expired:

        case core_connect_eap_peap_server_certificate_expired:

            return KErrWlanServerCertificateExpired;

        case core_connect_eap_tls_server_certificate_unknown:

        case core_connect_eap_ttls_server_certificate_unknown:

        case core_connect_eap_peap_server_certificate_unknown:

            return KErrWlanCerficateVerifyFailed;

        case core_connect_eap_tls_user_certificate_expired:

        case core_connect_eap_ttls_user_certificate_expired:

        case core_connect_eap_peap_user_certificate_expired:

            return KErrWlanUserCertificateExpired;

        case core_connect_eap_tls_user_certificate_unknown:

        case core_connect_eap_ttls_user_certificate_unknown:

        case core_connect_eap_peap_user_certificate_unknown:

            return KErrWlanNoUserCertificate;

        case core_connect_eap_tls_illegal_cipher_suite:

        case core_connect_eap_ttls_illegal_cipher_suite:

        case core_connect_eap_peap_illegal_cipher_suite:

            return KErrWlanNoCipherSuite;

        case core_connect_eap_tls_user_rejected:

        case core_connect_eap_ttls_user_rejected:

        case core_connect_eap_peap_user_rejected:

            return KErrWlanUserRejected;

        case core_connect_eap_leap_failure:

            return KErrWlanLeapFailed;

        case core_connect_eap_sim_failure:

            return KErrWlanEapSimFailed;

        case core_connect_eap_sim_identity_query_failed:

        case core_connect_eap_aka_identity_query_failed:

            return KErrWlanSimNotInstalled;

        case core_connect_eap_sim_user_has_not_subscribed_to_the_requested_service:

        case core_connect_eap_aka_user_has_not_subscribed_to_the_requested_service:

            return KErrWlanNotSubscribed;

        case core_connect_eap_sim_users_calls_are_barred:

        case core_connect_eap_aka_users_calls_are_barred:

            return KErrWlanAccessBarred;

        case core_connect_eap_ttls_failure:

            return KErrWlanEapTtlsFailed;

        case core_connect_eap_aka_failure:

            return KErrWlanEapAkaFailed;

        case core_connect_eap_peap_failure:

            return KErrWlanEapPeapFailed;

        case core_connect_eap_mschapv2_failure:

            return KErrWlanEapMsChapv2;

        case core_connect_eap_mschapv2_restricted_logon_hours:

            return KErrWlanRestrictedLogonHours;

        case core_connect_eap_mschapv2_account_disabled:

            return KErrWlanAccountDisabled;

        case core_connect_eap_mschapv2_no_dialin_permission:

            return KErrWlanNoDialinPermissions;

        case core_connect_eap_mschapv2_password_expired:

            return KErrWlanPasswordExpired;

        case core_connect_eap_fast_tunnel_compromise_error:

            return KErrWlanEapFastTunnelCompromiseError;

        case core_connect_eap_fast_unexpected_tlv_exhanged:

            return KErrWlanEapFastUnexpextedTlvExhanged;

        case core_connect_eap_fast_no_pac_nor_certs_to_authenticate_with_provision_disabled:

            return KErrWlanEapFastNoPacNorCertsToAuthenticateWithProvDisabled;

        case core_connect_eap_fast_no_matching_pac_for_aid:

            return KErrWlanEapFastNoMatchingPacForAid;

        case core_connect_eap_fast_authentication_failed:

            return KErrWlanEapFastAuthFailed;

        case core_connect_eap_fast_pac_store_corrupted:

            return KErrWlanEapFastPacStoreCorrupted;

        case core_connect_wapi_ie_required_but_ap_has_none:

        case core_connect_wapi_certificate_required_but_ap_has_no_support:

        case core_connect_wapi_psk_required_but_ap_has_no_support:

        case core_connect_wapi_ap_has_no_valid_ciphers:

            return KErrWlanNetworkNotFound;

        case core_connect_wapi_psk_failure:

            return KErrWlanInternalError;

        case core_connect_wapi_certificate_failure:

            return KErrWlanInternalError;

        case core_connect_ap_unsupported_configuration:

            return KErrIfAuthenticationFailure;

        default:

            return KErrUnknown;

        }

    }

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

// TWlanConversionUtil::ConvertRegion()

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

//

core_wlan_region_e TWlanConversionUtil::ConvertRegion(

    const TWlanRegion& aAmRegion )

    {

    switch( aAmRegion )

        {

        case EETSI:

            return core_wlan_region_etsi;

        default:

            return core_wlan_region_fcc;

        }

    }

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

// TWlanConversionUtil::ConvertRegion()

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

//

TWlanRegion TWlanConversionUtil::ConvertRegion(

    const core_wlan_region_e& aCoreRegion )

    {

    switch( aCoreRegion )

        {

        case core_wlan_region_etsi:

            return EETSI;

        default:

            return EFCC;

        }

    }

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

// TWlanConversionUtil::ConvertMacAddress()

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

//

void TWlanConversionUtil::ConvertMacAddress(

    TMacAddress& aAmMacAddress,

    const core_mac_address_s& aCoreMacAddress )

    {

    // Function assumes both mac address types have the same length

    Mem::Copy( 

        aAmMacAddress.iMacAddress, 

        aCoreMacAddress.addr, 

        MAC_ADDR_LEN );

    }

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

// TWlanConversionUtil::ConvertMacAddress()

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

//

void TWlanConversionUtil::ConvertMacAddress(

    core_mac_address_s& aCoreAddress,

    const TMacAddress& aAmMacAddress )

    {

    // Function assumes both mac address types have the same length

    Mem::Copy( 

        aCoreAddress.addr, 

        aAmMacAddress.iMacAddress, 

        MAC_ADDR_LEN );

    }

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

// TWlanConversionUtil::ConvertMacAddress()

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

//

void TWlanConversionUtil::ConvertMacAddress(

    core_mac_address_s& aCoreAddress,

    const TMacAddr& aAmMacAddress )

    {

    // Function assumes both mac address types have the same length

    Mem::Copy( 

        aCoreAddress.addr, 

        aAmMacAddress.iMacAddress, 

        MAC_ADDR_LEN );

    }

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

// TWlanConversionUtil::ConvertMacAddress()

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

//

void TWlanConversionUtil::ConvertMacAddress(

    TMacAddress& aCoreAddress,

    const TMacAddr& aAmMacAddress )

    {

    // Function assumes both mac address types have the same length

    Mem::Copy( 

        aCoreAddress.iMacAddress, 

        aAmMacAddress.iMacAddress, 

        MAC_ADDR_LEN );