/*

 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "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: 

 *   WLAN Wizard Utilities

 *

 */

// System includes

#include <QString>

#include <QDebug>

#include <QVariant>

// User includes

#include "wlanwizardutils.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "wlanwizardutilsTraces.h"

#endif

/*!

    \class WlanWizardUtils wlanwizardutils.cpp

    \brief Utilities for WLAN key validations.

*/

/*!

    \enum WlanWizardUtils::KeyStatus

    This enum defines the validation results.

    \var WlanWizardUtils::KeyStatusOk

    Key is valid.

    \var WlanWizardUtils::KeyStatusIllegalCharacters

    Key contains illegal characters.

    \var WlanWizardUtils::KeyStatusWpaTooShort

    WPA key is too short. Minimum allowed length is 8. See 

    WlanWizardUtils::validateWpaKey().

    \var WlanWizardUtils::KeyStatusWpaTooLong

    WPA key is too long. Minimum allowed length is 64 for hex key and 63 for 

    ascii key. See WlanWizardUtils::validateWpaKey().

    \var WlanWizardUtils::KeyStatusWepInvalidLength

    WEP key length is not valid. Valid keys are 

    - hex: 10 or 26 characters

    - ascii: 5 or 13 characters. See WlanWizardUtils::validateWpaKey().

    \var WlanWizardUtils::SsidMinLength

    Minumum acceptable length for SSID.

    \var WlanWizardUtils::SsidMaxLength

    Maximum acceptable length for SSID.

    \var WlanWizardUtils::WpaMinLength

    Minumum acceptable length for WPA key.

    \var WlanWizardUtils::WpaMaxLength

    Maximum acceptable length for WPA key.

    \var WlanWizardUtils::WepHex64BitMaxLength

    Length of WEP key: format hex 64-bits.

    \var WlanWizardUtils::WepHex128BitMaxLength

    Length of WEP key: format hex 128-bits.

    \var WlanWizardUtils::WepAscii64BitMaxLength

    Length of WEP key: format ascii 64-bits.

    \var WlanWizardUtils::WepAscii128BitMaxLength

    Length of WEP key: format ascii 128-bits.

*/

// External function prototypes

// Local constants

// ======== LOCAL FUNCTIONS ========

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

/*! 

   Process WPA key validation. A passphrase can contain from 8 to 63 ASCII

   characters where each character MUST have a decimal encoding in the range of

   32 to 126, inclusive.

   A preshared key is stored as 64 character hex string.

   @param [in] key PSK to be validated

   @return Following values are possible

   - KeyStatusOk

   - KeyStatusIllegalCharacters

   - KeyStatusWpaTooShort

   - KeyStatusWpaTooLong

 */

WlanWizardUtils::KeyStatus WlanWizardUtils::validateWpaKey(const QString &key)

{

    OstTraceFunctionEntry0( WLANWIZARDUTILS_VALIDATEWPAKEY_ENTRY );

#ifdef OST_TRACE_COMPILER_IN_USE

    TPtrC tmp(key.utf16(),key.length() );

    OstTraceExt1( TRACE_NORMAL, WLANWIZARDUTILS_VALIDATEWPAKEY, 

        "WlanWizardUtils::validateWpaKey;key=%S", tmp );

#endif

    int length = key.length();

    KeyStatus ret = KeyStatusOk;

    if (length < WpaMinLength) {

        ret = KeyStatusWpaTooShort;

    } else if (length > WpaMaxLength) {

        ret = KeyStatusWpaTooLong;

    } else if (length == WpaMaxLength) {

        ret = isHex(key);

    } else {

        ret = isAscii(key);

    }

    OstTrace1( 

        TRACE_NORMAL, WLANWIZARDUTILS_VALIDATEWPAKEY_RETURN, 

        "WlanWizardUtils::validateWpaKey - Return;ret=%{KeyStatus}", ret );

    OstTraceFunctionExit0( WLANWIZARDUTILS_VALIDATEWPAKEY_EXIT );

    return ret;

}

/*!

   Process WEP key validation. Following keys are allowed:

   HEX: 

   - 64 bit: allowed key length = 10

   - 128 bit: allowed key length = 26

   ASCII:

   - 64 bit: allowed key length = 5   

   - 128 bit: allowed key length = 13

   @param [in] key WEP Key to be validated

   @return Following values are possible

   - KeyStatusOk

   - KeyStatusIllegalCharacters

   - KeyStatusWepInvalidLength

 */

WlanWizardUtils::KeyStatus WlanWizardUtils::validateWepKey(const QString &key)

{

    OstTraceFunctionEntry0( WLANWIZARDUTILS_VALIDATEWEPKEY_ENTRY );

#ifdef OST_TRACE_COMPILER_IN_USE

    TPtrC tmp(key.utf16(),key.length() );

    OstTraceExt1( TRACE_NORMAL, WLANWIZARDUTILS_VALIDATEWEPKEY, 

        "WlanWizardUtils::validateWepKey;key=%S", tmp );

#endif

    int length = key.length();

    KeyStatus ret = KeyStatusOk;

    if (length == WepHex64BitMaxLength || length == WepHex128BitMaxLength) {

        ret = isHex(key);

    } else if (length == WepAscii64BitMaxLength || length == WepAscii128BitMaxLength) {

        ret = isAscii(key);

    } else {

        ret = KeyStatusWepInvalidLength;

    }

    OstTrace1( 

        TRACE_NORMAL, WLANWIZARDUTILS_VALIDATEWEPKEY_RETURN, 

        "WlanWizardUtils::validateWepKey - Return;ret=%{KeyStatus}", ret );

    OstTraceFunctionExit0( WLANWIZARDUTILS_VALIDATEWEPKEY_EXIT );

    return ret;

}

/*!

   Process Ascii validation. Allowed characters are from 32 to 126.

   @param [in] key to be validated.

   @return Following values are possible

   - KeyStatusOk

   - KeyStatusIllegalCharacters

 */

WlanWizardUtils::KeyStatus WlanWizardUtils::isAscii(const QString &key)

{

    OstTraceFunctionEntry0( WLANWIZARDUTILS_ISASCII_ENTRY );

    static const QChar ch32(32);   // First visible ascii character

    static const QChar ch126(126); // Last visible ascii character

    const QChar *data = key.data();

    while (!data->isNull()) {

        if ((*data) < ch32 || (*data) > ch126) {

            OstTraceFunctionExit0( WLANWIZARDUTILS_ISASCII_EXIT );

            return KeyStatusIllegalCharacters;

        }

        ++data;

    }

    OstTraceFunctionExit0( DUP1_WLANWIZARDUTILS_ISASCII_EXIT );

    return KeyStatusOk;

}

/*!

   Process Hex validation. Allowed characters are

   - from 0 to 9

   - from a to f

   - from A to F

   @param [in] key to be validated.

   @return Following values are possible

   - KeyStatusOk

   - KeyStatusIllegalCharacters

 */

WlanWizardUtils::KeyStatus WlanWizardUtils::isHex(const QString &key)

{

    OstTraceFunctionEntry0( WLANWIZARDUTILS_ISHEX_ENTRY );

    static const QChar ch_A(65); // Character: A

    static const QChar ch_F(70); // Character: F

    static const QChar ch_a(97); // Character: a

    static const QChar ch_f(102);// Character: f

    const QChar *data = key.data();

    while (!data->isNull()) {

        if (data->isDigit() ||

            (*data) >= ch_a && (*data) <= ch_f ||

            (*data) >= ch_A && (*data) <= ch_F) {

            ++data;

        } else {

            OstTraceFunctionExit0( WLANWIZARDUTILS_ISHEX_EXIT );

            return KeyStatusIllegalCharacters;

        }

    }

    OstTraceFunctionExit0( DUP1_WLANWIZARDUTILS_ISHEX_EXIT );

    return KeyStatusOk;

}

/*!

   Process SSID validation.

   @param [in] ssid to be validated.

   @return Following values are possible

   - SsidStatusOk

   - SsidStatusInvalidLength

 */

WlanWizardUtils::SsidStatus WlanWizardUtils::validateSsid(const QString &ssid)

{

    OstTraceFunctionEntry0( WLANWIZARDUTILS_VALIDATESSID_ENTRY );

    TPtrC tmp(ssid.utf16(), ssid.length() );

    OstTraceExt1( TRACE_NORMAL, WLANWIZARDUTILS_VALIDATESSID, 

        "WlanWizardUtils::validateSsid;ssid=%S", tmp );

    SsidStatus ret = SsidStatusOk;

    int len = ssid.length();

    if (len < SsidMinLength || len > SsidMaxLength) {

        ret = SsidStatusInvalidLength;

    }

    OstTrace1( 

        TRACE_NORMAL, WLANWIZARDUTILS_VALIDATESSID_RETURN, 

        "WlanWizardUtils::validateSsid - Return;ret=%{SsidStatus}", ret );

    OstTraceFunctionExit0( WLANWIZARDUTILS_VALIDATESSID_EXIT );

    return ret;

}