/*

* Copyright (c) 2005 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:   Implementation of the class CProcessorWlan

*

*/

// INCLUDE FILES

#include "cdcprocessorwlan.h"

#include "cdclogger.h"

#include "cdcerrors.h"

#include <cmpluginwlandef.h>

#include <cmpluginbaseeng.h>

#include <cmconnectionmethoddef.h>

#include <cmmanagerext.h>

#include <datamobilitycommsdattypes.h>

#include <commsdattypesv1_1.h>

#include <WlanCdbCols.h>

#include <commsdattypesv1_1.h>

#include <wlancontainer.h>

using namespace CMManager;

// CONSTANTS

// network modes.

_LIT16( KStrAd_hoc,         "Ad-hoc" );

_LIT16( KStrInfrastructure, "Infrastructure" ); // Default value.

// security modes.

_LIT16( KStrWEP,            "WEP" );

_LIT16( KStr802_1x,         "802.1x" );

_LIT16( KStrWPA,            "WPA" );          // WPA/WPA2 mixed mode

_LIT16( KStrWPA2,           "WPA2" );         // WPA2-only mode

_LIT16( KStrOpen,           "Open" );         // Default value.

// default WLAN channel Id value

const TInt KDefaultChannelId = 0;

const TInt KMaximumChannelId = 11;

// default port number

const TUint32 KDefaultPortNum = 0;

// ratio between sizes of ascii and unicode characters

const TUint KAsciiUnicodeRatio = 2;

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

CEapTypeElement::~CEapTypeElement()

    {

    delete iEapSettings;

    delete iName;

    }

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

// CProcessorWlan::NewL

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

//

CProcessorWlan* CProcessorWlan::NewL( CReaderBase* aFileReader,

                                      RCmManagerExt& aCmManager,

                                      RPointerArray< RCmConnectionMethodExt >& aPluginArray,

                                      RPointerArray< HBufC >& aPluginNames,

                                      RPointerArray< HBufC >& aSecurityInfo,

									  RPointerArray< CEapTypeElement >& aEapSettings )

    {

    CProcessorWlan* self = new ( ELeave ) CProcessorWlan( aFileReader,

                                                          aCmManager,

                                                          aPluginArray,

                                                          aPluginNames,

                                                          aSecurityInfo,

														  aEapSettings );

    CleanupStack::PushL( self );

    // From base class

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CProcessorWlan::ConstructL

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

//

void CProcessorWlan::ConstructL()

    {

    iEmptyTag = KStrEmpty.operator const TDesC16&().Alloc();

    Reset(); // iWepData, iWpaData

    }

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

// CProcessorWlan::CProcessorWlan

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

//

CProcessorWlan::CProcessorWlan( CReaderBase* aFileReader,

                                RCmManagerExt& aCmManager,

                                RPointerArray< RCmConnectionMethodExt >& aPluginArray,

                                RPointerArray< HBufC >& aPluginNames,

                                RPointerArray< HBufC >& aSecurityInfo,

								RPointerArray< CEapTypeElement >& aEapSettings ) :

             CProcessorBase( aFileReader,

                             aCmManager,

                             aPluginArray,

                             aPluginNames ),

             iSecurityMode( ESecurityModeOpen ),

             iEapSettings( aEapSettings ),

             iIsEasyWlan( ETrue )                     

    {

    iBearerType = KUidWlanBearerType;

    iSecurityInfo = &aSecurityInfo;

    iDataStart = 0;

    }

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

// CProcessorWlan::~CProcessorWlan

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

//

CProcessorWlan::~CProcessorWlan()

    {

    delete iEmptyTag;

    }

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

// CProcessorWlan::ProcessSpecialFieldsL

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

//

void CProcessorWlan::ProcessSpecialFieldsL( TInt aField, HBufC* aPtrTag, TInt /*aDx*/ )

    {

        switch( aField )

            {

            // TDesC16

            case EWlanSSID:

                {

                if ( aPtrTag->CompareF( KStrEmpty ) != 0 )

                    {

                    iPlugin.SetStringAttributeL( aField, *aPtrTag );

                    iIsEasyWlan = EFalse;

                    }

                else

                    {

                    // Access point is Easy WLAN 

                    iIsEasyWlan = ETrue;

                    }

                break;

                }

            case EWlanIpAddr:

                {

                if ( aPtrTag->CompareF( KStrEmpty ) != 0 )

                    {

                    iPlugin.SetStringAttributeL( aField, *aPtrTag );

                    }

                break;

                }

            // TDesC16

            case EWlanIpGateway:             //fall through

            case EWlanIpNetMask:             //fall through

                {

                iPlugin.SetStringAttributeL( aField, *aPtrTag );

                break;

                }

            case EWlanIpNameServer1:         //fall through

            case EWlanIpNameServer2:         //fall through

            case EWlanIp6NameServer1:        //fall through

            case EWlanIp6NameServer2:        //fall through

                {

                iPlugin.SetStringAttributeL( aField, *aPtrTag );

                SetAddressFromServerL( EWlanIpNameServer1,

                                      EWlanIpNameServer2,

                                      EWlanIpDNSAddrFromServer,

                                      EWlanIp6NameServer1,

                                      EWlanIp6NameServer2,

                                      EWlanIp6DNSAddrFromServer );    

                break;

                }

            // TUint32

            case EWlanSecurityMode:

                {

                if ( aPtrTag->CompareF( KStrWEP ) == 0 )

                    {

                    // WEP

                    iPlugin.SetIntAttributeL( aField, EWlanSecModeWep );

                    iSecurityMode = ESecurityModeWEP;

                    }

                else if ( aPtrTag->CompareF( KStr802_1x ) == 0 )

                    {

                    // 802.1x

                    iPlugin.SetIntAttributeL( aField, EWlanSecMode802_1x );

                    iSecurityMode = ESecurityMode802;

                    }

                else if ( aPtrTag->CompareF( KStrWPA ) == 0 )

                    {

                    // WPA/WPA2 mixed mode

                    iPlugin.SetIntAttributeL( aField, EWlanSecModeWpa );

                    iSecurityMode = ESecurityModeWPA;

                    }

                else if ( aPtrTag->CompareF( KStrWPA2 ) == 0 )

                    {

                    // WPA2

                    iPlugin.SetIntAttributeL( aField, EWlanSecModeWpa2 );

                    iSecurityMode = ESecurityModeWPA2;

                    }

                else if ( aPtrTag->CompareF( KStrOpen ) == 0 )

                    {

                    // Open network (default)

                    iPlugin.SetIntAttributeL( aField, EWlanSecModeOpen );

                    iSecurityMode = ESecurityModeOpen;

                    }

                else 

                    {

                    iPlugin.SetIntAttributeL( aField, EWlanSecModeOpen );

                    iSecurityMode = ESecurityModeOpen;

                    CLOG_WRITE( "! Error : Invalid Security Mode. Default:Open" )

                    }

                break;

                }

            // TUint32

            case EWlanConnectionMode:

                {

                if ( !aPtrTag->CompareF( KStrAd_hoc ) )

                    {

                    // Ad-hoc

                    iPlugin.SetIntAttributeL( aField, EAdhoc );

                    }

                else if ( !aPtrTag->CompareF( KStrInfrastructure ) )

                    {

                    // Infrastructure

                    iPlugin.SetIntAttributeL( aField, EInfra );

                    }

                else

                    {

                    iPlugin.SetIntAttributeL( aField, EInfra );

                    CLOG_WRITE( "! Error : Invalid Network Mode. Default:Infrastructure" )

                    }

                break;

                }

            // TUint32

            case ECmProxyPortNumber:

                {

                // First set proxy usage to enabled

                if( !iProxyEnabled )

                    {

                    iPlugin.SetBoolAttributeL( ECmProxyUsageEnabled, ETrue );

                    iProxyEnabled = ETrue;

                    }

                TLex16 lex( *aPtrTag );

                TUint32 tmp( 0 );

                if ( lex.Val( tmp, EDecimal ) == KErrNone )

                    {

                    iPlugin.SetIntAttributeL( aField, tmp );

                    }

                else

                    {

                    //no valid data is given

                    iPlugin.SetIntAttributeL( aField, KDefaultPortNum );

                    CLOG_WRITE( "! Error : Invalid port number. Default:0" );

                    }

                break;

                }

            // Long text.

            case ECmStartPage:

                {

                if ( aPtrTag->CompareF( KStrEmpty ) != 0 )

                    {

                    iPlugin.SetStringAttributeL( aField, *aPtrTag );

                    }

                break;

                }

	        case ECmProxyProtocolName:

	        	{

	        	// Do not enable proxy in this case yet

	        	iPlugin.SetStringAttributeL( aField, *aPtrTag );

	        	break;

	        	}

            // Long text.

            case ECmProxyServerName:            

                {

                // First set proxy usage to enabled

                if( !iProxyEnabled )

                    {

                    iPlugin.SetBoolAttributeL( ECmProxyUsageEnabled, ETrue );

                    iProxyEnabled = ETrue;

                    }

                iPlugin.SetStringAttributeL( aField, *aPtrTag );

                break;

                }

            // Bool

            case EWlanScanSSID:

                {

                if ( !aPtrTag->CompareF( KStrYes ) )

                    {

                    iPlugin.SetBoolAttributeL( aField, ETrue );

                    }

                else if ( !aPtrTag->CompareF( KStrNo ) )

                    {

                    iPlugin.SetBoolAttributeL( aField, EFalse );

                    }

                else 

                    {

                    iPlugin.SetBoolAttributeL( aField, EFalse );

                    CLOG_WRITE( "! Error : Invalid Scan SSID. Default:No" )

                    }

                break;

                }

            // TUint32

            case EWlanChannelID:

                {

                TLex16 lex( *aPtrTag );

                TUint32 tmp( 0 );

                lex.Val( tmp, EDecimal );

                if( tmp <= KMaximumChannelId )

                    {

                    iPlugin.SetIntAttributeL( aField, tmp );

                    }

                else

                    {

                    // Default value

                    iPlugin.SetIntAttributeL( aField, KDefaultChannelId );

                    CLOG_WRITE( "! Error : Invalid Chanel Id. Default:0" )

                    }

                break;

                }

            //WEP

            case EWEPKeyInUse:

            case EWEPAuthType:

            case EWEPKey1Length:

            case EWEPKey1Format:

            case EWEPKey1Data:

            case EWEPKey2Length:

            case EWEPKey2Format:

            case EWEPKey2Data:

            case EWEPKey3Length:

            case EWEPKey3Format:

            case EWEPKey3Data:

            case EWEPKey4Length:

            case EWEPKey4Format:

            case EWEPKey4Data:

                {

                if( iSecurityMode == ESecurityModeWEP )

                    {

                    AddSecurityDataL( aField, aPtrTag, ETrue );

                    }

                }

                break;

            //WPA

            case EWPAPresharedKey:

            case EWPAKeyLength:

            case EWPAEapMethod:

            case EWPAUseOfPresharedKey:

                {

                if( iSecurityMode != ESecurityModeWEP && iSecurityMode != ESecurityModeOpen )

                    {

                    AddSecurityDataL( aField, aPtrTag, EFalse );

                    }

                }

                break;

            default:

            	// Check if this is EAP setting

            	if ( EAPSetting( aField ) )

            		{

            		AddEAPSettingL( aField, aPtrTag );

            		}

            	else

            		{            		

            		CLOG_WRITE_FORMAT( "! Warning: Unhandled setting for WLAN: %d", aField );

            		}

                break;

            }//switch

    }

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

// CProcessorWlan::ProcessAPL

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

//

void CProcessorWlan::ProcessAPL()

    {

    RCmConnectionMethodExt& iPlugin = GetLastPluginL();

    if( iIsProtected )

        {

        iPlugin.SetBoolAttributeL( ECmProtected, ETrue );

        }

    // Ensure that Easy WLAN is always an open network

    if( iIsEasyWlan )

        {

        iSecurityMode = ESecurityModeOpen;

        }

    FillSecurityInfoL();        

    // Writes into the log file.

    DoLogL();

    Reset(); // iWepData, iWpaData

    }

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

// CProcessorWlan::ProcessAPL

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

//

void CProcessorWlan::FillSecurityInfoL()

    {

    //Set Security mode settings

    switch ( iSecurityMode )

        {

        case ESecurityModeWEP:

            if ( WEPFieldValidate() )

                {

                FillSecurityInfoL( ETrue ); //WEP

                }

            else

                {

                CLOG_WRITE( "! Error : WEP settings are not valid." )

                }

            break;  

        case ESecurityMode802:

        case ESecurityModeWPA:

        case ESecurityModeWPA2:

            {

            FillSecurityInfoL( EFalse ); //WPA

            break;

            }

        default:

            {

            }

            break;

        }

    }    

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

// CProcessorWlan::ProcessAPL

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

//

void CProcessorWlan::FillSecurityInfoL( TBool aIsWep )

    {

    // iName has been deleted by Base. Name is retrieved from name array.

    TInt lastPos = iPluginArray->Count() - 1;

    HBufC* name = (*iPluginName)[ lastPos ];

    // Name appended to the array

    iSecurityInfo->Append( name->AllocL() );

    CLOG_WRITE_FORMAT( "FillSecurityInfoL %S", name );

    CLOG_WRITE_FORMAT( "FillSecurityInfoL start %d", iSecurityInfo->Count() );

    if( aIsWep )

        {

        // Security type appended to the array

        iSecurityInfo->Append( KStrWEP.operator const TDesC16&().Alloc() );

        for( TInt i( 0 ); i < KWEPKeyNumOfFields; i++ )

            {

            if( iWepData[i] != NULL )

                {

                CLOG_WRITE_FORMAT( "wep info %S", iWepData[i] );

                }

            else

                {

                CLOG_WRITE( "wep info NULL" );

                }

            iSecurityInfo->Append( iWepData[i] );

            }

        }

    else

        {

        // Security type appended to the array

        switch ( iSecurityMode )

            {

            case ESecurityMode802:

                iSecurityInfo->Append( KStr802_1x.operator const TDesC16&().Alloc() );

            break;            

            case ESecurityModeWPA2:

                iSecurityInfo->Append( KStrWPA2.operator const TDesC16&().Alloc() );

            break;            

            default:

                iSecurityInfo->Append( KStrWPA.operator const TDesC16&().Alloc() );

            break;            

            }

        for( TInt i( 0 ); i < KWPAKeyNumOfFields; i++ )

            {

            if( iWpaData[i] != NULL )

                {

                CLOG_WRITE_FORMAT( "wpa info %S", iWpaData[i] );

                }

            else

                {

                CLOG_WRITE( "wep info NULL" );

                }

            iSecurityInfo->Append( iWpaData[ i ] );

            }

        }

    CLOG_WRITE_FORMAT( "FillSecurityInfoL end %d", iSecurityInfo->Count() );

    }