/*

* Copyright (c) 2002-2008 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:    Class stores data for one accesspoint

*

*/

// INCLUDE FILES

#include "CWPAPNapdef.h"

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <wpapadapterresource.rsg>

#include <featmgr.h>

#include <WPAdapterUtil.h>

#include "CWPAPAccesspointItem.h"

#include "WPAPAdapter.pan"

#include <WlanCdbCols.h>

#include <EapType.h>

#include <EapSettings.h>

#include "ProvisioningDebug.h"

#include <cmconnectionmethodext.h>

#include <cmpluginpacketdatadef.h>

#include <cmpluginwlandef.h>

#include <cmmanagerext.h>

#include <cmconnectionmethodext.h>

#include <commdb.h>

#include <WlanCdbCols.h>

#include <EapExpandedType.h>

#include <centralrepository.h>

#include <pdpcontextmanagerinternalcrkeys.h>

#include <EapGeneralSettings.h>

#include <EapTypeDefinitions.h>

const TUint KIapColumn        = 0x00000100;

const TUint KLingerColumn     = 0x00000200;

const TUint KColumnMask       = 0xFFFFFF00;

const TUint KRowMask          = 0x000000FF;

// Delay for comms db begintransaction retry (microseconds)

const TInt KBeginTransRetryDelay = 1000000; 

// Maximum number of retries

const  TInt KBeginTransRetryCount = 7;      

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

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

// CWPAPNapdef::NewLC

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

//

CWPAPNapdef* CWPAPNapdef::NewLC( TBool aFollowingLink,

                                 const TDesC& aDefaultName, 

                                 CWPCharacteristic& aLogicalCharacteristic,

                                 CWPCharacteristic& aLink )

	{

	CWPAPNapdef* self = new(ELeave) CWPAPNapdef( aFollowingLink,

	                                             aDefaultName,

                                                 aLogicalCharacteristic ); 

	CleanupStack::PushL( self );

	self->ConstructL();

    aLink.AcceptL( *self );

	return self;

	}

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

// Destructor

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

CWPAPNapdef::~CWPAPNapdef()

	{

	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::~CWPAPNapdef" ) );

    iEapTypeArray.ResetAndDestroy();

    iEapTypeArray.Close();

    iSecSSID.ResetAndDestroy();

	iSecSSID.Close();

    iNameServers.Close();

	}

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

// CWPAPNapdef::ValidateL

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

//

TBool CWPAPNapdef::ValidateL()

	{

	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::ValidateL" ) );

    TBool result( ETrue );

	if ( iBearer == KUidWlanBearerType )

	    {	    	

	    FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::ValidateL wlan" ) );

	    if ( iWlanSupported )

	    	{	    	

	    	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::ValidateL wlan supported" ) );

	    	return result;

	    	}

	    else

	    	{

	   		FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::ValidateL wlan NOT supported" ) );

	    	return EFalse;

	    	}

	    }

	// Received unsupported bearer

	if( iBearerUnsupported )

	    {

	    return EFalse;

	    }

	// Didn't receive a bearer value.

	if ( iBearer == 0 )

		{

    // Access point address type can also tell the bearer

		if( iAccesspointNameType )

            {

            TPtrC addrType( iAccesspointNameType->Value() );

            if( addrType == KAddrTypeAPN )

                {

                iBearer =KUidPacketDataBearerType;

                }

            }

        // If still couldn't determine the bearer, default to GPRS

        if( iBearer == 0 )

			{

			iBearer = KUidPacketDataBearerType;

			}

		}

    // "NAP-ADDRESS" (Access point name) must be defined

    if( iAccesspointName )

        {

        if( iAccesspointName->Value() == KNullDesC )

            {

            return EFalse;

            }

        }

    else

        {

        return EFalse;

        }

	/* 

	Combinations of authentication type, username and password and corressponding

	value of prompt for password field. AuthType in this table means that provisioning document

	contained authtype parameter and it was supported by the implementation.

	Provisioning document names are used in table.

	x means that value of the specified parameter is received and it was valid.

	AuthType received & supported 

	| AuthName 

	| | AuthSecret 

	| |	| "Prompt for Password"

		  no

	x     no

      x   no

	x x   yes

        x no

    x   x yes

      x x no

    x x	x no

	*/

	// Set the "prompt password"-value. See the table above. Value is set to true

	// only if we have supported authentication type and either username or password

	// is empty.

	if ( IsReceived( EWPParameterAuthentication_id ) &&

	     ( ( !iPassword && iUserName ) ||( iPassword && !iUserName ) ) )

		{

		iPromptPassword = ETrue;	

		}

    // IFNETWORKS is a list of possible protocols that a GPRS access points can be 

    // used for. 

    if( iBearer == KUidPacketDataBearerType && IsReceived( EWPParameterIfNetworks_id ) )

        {

        TLex lex( iIfNetworks->Value() );

        lex.Mark();

        do

            {

            TChar ch( lex.Get() );

            if( ( !iPdpType && !ch.IsAlphaDigit() ) || ( !iPdpType && lex.Eos() ) )

                {

				if(!lex.Eos())

					{

					lex.UnGet();

					}

                TPtrC value( lex.MarkedToken() );

				if( !lex.Eos() )

					{

					lex.Inc();

					}

                if( value == KIPv6 

                    && FeatureManager::FeatureSupported( KFeatureIdIPv6 ) )

                    {

                    //iPdpType = EIPv6;

                    // CMManager

                    iPdpType = RPacketContext::EPdpTypeIPv6;

                    result = ETrue;

                    }

                else if( value == KIPv6 

                    && !FeatureManager::FeatureSupported( KFeatureIdIPv6 ) )

                    {

                    result = EFalse;

                    }

                else if( value == KIPv4 )

                    {

                    //iPdpType = EIPv4;

                    // CMManager

                    iPdpType = RPacketContext::EPdpTypeIPv4;

                    result = ETrue;

                    }

                }

            } while( !lex.Eos() );

        }

	return result;

	}

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

// CWPAPNapdef::AddItemsL

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

//

TInt CWPAPNapdef::AddItemsL( RPointerArray<CWPAPAccesspointItem>& aItems,

                            CWPAPItemBase* aLogicalProxy,

                            CWPAPItemBase* aPhysicalProxy ) 

	{

	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddItemsL" ) );

    TInt count( 0 );

    if( ( iFollowingLink || IsReceived( EWPParameterInternet_id ) 

                         || IsReceived( EWPParameterWlan_id ) )

                         && ValidateL() )

        {

        FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddItemsL append" ) );

        CWPAPAccesspointItem* item = CWPAPAccesspointItem::NewLC(

                                                             iDefaultName,

                                                             aLogicalProxy,

                                                             aPhysicalProxy,

                                                             this,

                                                             iCharacteristic );

        User::LeaveIfError( aItems.Append( item ) );

        //Internet Parameter is received

        if (IsReceived(EWPParameterInternet_id) && !iFollowingLink)

            {

            SetInternetIndicator(aItems.Count() - 1);

            }

        count++;

        CleanupStack::Pop( item );

        FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddItemsL append done" ) );

        }

    return count;

    }

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

// CWPAPNapdef::SetInternetIndicator

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

//

void CWPAPNapdef::SetInternetIndicator(TInt aValue)

    {

    iInternetIndicator = aValue;

    }

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

// CWPAPNapdef::GetInternetIndicator

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

//

TInt CWPAPNapdef::GetInternetIndicator()

    {

    return iInternetIndicator;

    }

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

// CWPAPNapdef::AddDataL

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

//

void CWPAPNapdef::AddDataL( /*CApAccessPointItem& aAPItem*/ RCmConnectionMethodExt& aCmItem ) 

	{

	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddDataL" ) );

	TInt err( KErrNone );

    if ( iBearer == KUidWlanBearerType )    

	    {			    	

	    	if ( iWlanSupported )

        	{

        	// CMManager

        	AddWlanDataL( aCmItem);

        	}

        else

        	{

        	// WLAN is disabled (or does not exist) in the device.

        	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddDataL WLAN disabled." ) );

        	User::Leave( KErrNotSupported );

        	}

	    }

    else

        {	    

    	if ( iConnectionName )

    		{

    		// CMManager

    		aCmItem.SetStringAttributeL( CMManager::ECmName, (iConnectionName->Value().Left( KNameMaxLength ))); 

    		}

    	else // Use default name

    		{

    		// CMManager

    		aCmItem.SetStringAttributeL( CMManager::ECmName, iDefaultName );

    		}

    	if ( iAccesspointName )

    		{

    		if ( iBearer == KUidPacketDataBearerType )

    			{

    			// CMManager

    			TRAP ( err, aCmItem.SetStringAttributeL( CMManager::EPacketDataAPName, iAccesspointName->Value() ));

                FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL value: %S, err: %d"),

                                                                     &iAccesspointName->Value(), err));    			                              

    			}

    		else

    			{

    			// CMManager

    			TRAP ( err, aCmItem.SetStringAttributeL( CMManager::EDialDefaultTelNum, iAccesspointName->Value() ));

                FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::EApIspDefaultTelNumber value: %S, err: %d"),

                			      &iAccesspointName->Value(), err ) );

    			}

    		}

    	TRAP ( err, aCmItem.UpdateL() );

    	 if ( iUserName )

    		{

    		// CMManager

    		TRAP ( err, aCmItem.SetStringAttributeL( CMManager::EDialLoginName, iUserName->Value() ));

    		FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL EDialLoginName value: %S, err: %d"),

    		                    		      &iUserName->Value(), err));

    		TRAP ( err, aCmItem.SetStringAttributeL( CMManager::EDialIFAuthName, iUserName->Value() ));

    		FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL EDialIFAuthName value: %S, err: %d"),

    		                    		      &iUserName->Value(), err));

    		TRAP ( err, aCmItem.SetStringAttributeL( CMManager::ECmIFAuthName, iUserName->Value() ));

    		FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL ECmIFAuthName value: %S, err: %d"),

    		                    		      &iUserName->Value(), err));

    		}

		// CMManager

    	TRAP ( err, aCmItem.SetBoolAttributeL( CMManager::ECmIFPromptForAuth, iPromptPassword));

    	FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL ECmIFPromptForAuth value: %d, err: %d"),

    	                            	      iPromptPassword, err ));

    	if ( iPassword )

    		{

    		// CMManager 

    		TRAP ( err, aCmItem.SetStringAttributeL( CMManager::EDialLoginPassword, iPassword->Value() ));

    		FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL EDialLoginPassword value: %d, err: %d"),

    		                		      &iPassword->Value(), err ) );

    		TRAP ( err, aCmItem.SetStringAttributeL( CMManager::ECmIFAuthPass, iPassword->Value() ));

    		FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL ECmIFAuthPass value: %d, err: %d"),

    		                		      &iPassword->Value(), err ) );

    		}	

		// CMManager

    	TRAP ( err, aCmItem.SetBoolAttributeL( CMManager::ECmDisablePlainTextAuth, iSecureAuthentication ));

        FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL EApEApIspDisablePlainTextAuth value: %d, err: %d"),    	                         

                	                        iSecureAuthentication, err ) );

        // IPv6 APs always have dynamic phone address

    	//CMManager

    	if ( iPhoneIPAddress && iPdpType != RPacketContext::EPdpTypeIPv6 )

    		{

    		// CMManager IS CORRECT?

    		//err = aAPItem.WriteTextL( EApIspIPAddr, iPhoneIPAddress->Value() );

    		TRAP ( err, aCmItem.SetStringAttributeL( CMManager::ECmIPAddress, iPhoneIPAddress->Value() ));

    		FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddDataL EApIspIPAddr value: %S, err: %d"),

                        		     &iPhoneIPAddress->Value(), err ) );

    		}

		TRAP ( err, aCmItem.UpdateL() );

        for( TInt i( 0 ); i < iNameServers.Count(); i++ )

            {

            WriteDNSAddressL( aCmItem, iNameServers[i]->Value() );

            }

		TRAP ( err, aCmItem.UpdateL() );

        if( FeatureManager::FeatureSupported( KFeatureIdIPv6 )

            && iPdpType )

            {

         	// CMManager

            TRAP ( err, aCmItem.SetIntAttributeL( CMManager::EPacketDataPDPType, iPdpType ));

            }

    if ( err ) err = 0; // prevent compiler warning

        }

	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddDataL" ) );

	}

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

// CWPAPNapdef::AddWlanDataL

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

//

void CWPAPNapdef::AddWlanDataL( RCmConnectionMethodExt& aCmItem )

    {

    FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddWlanDataL" ) );

    if ( !iWlanSupported )

    	{

    		FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddWlanDataL WLAN NOT supported." ) );

    		User::Leave( KErrNotSupported);

    	}

    TInt err = KErrNone;

	if ( iConnectionName )

		{

		FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddWlanDataL iConnectionName" ) );

		//Connection name

		// CMManager

		aCmItem.SetStringAttributeL( CMManager::ECmName, iConnectionName->Value().Left( KNameMaxLength ) );

		// CMManager 

		// Network name

		aCmItem.SetStringAttributeL( CMManager::EWlanSSID, iConnectionName->Value());

        FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddWlanDataL iConnectionName err (%d) (%S)"), err, &iConnectionName->Value()));

		}

	else // Use default name

		{

		FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddWlanDataL iConnectionName default" ) );

		aCmItem.SetStringAttributeL( CMManager::EWlanSSID, iDefaultName);

		}

   	//EApWlanNetworkMode Gives network mode, TUint32

   	FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddWlanDataL EApWlanNetworkMode" ) );

	// CMManager

   	TRAP ( err, aCmItem.SetIntAttributeL( CMManager::EWlanConnectionMode, iNetMode ));

   	FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddWlanDataL EApWlanNetworkMode err (%d)"), err));

    //EApWlanSecurityMode The security mode, TUint32

    if ( iSecMode == 0 )

        {

        // This is needed if Provisioning message does not contain SECMODE parameter

        // AP does not work if secmode is not set

        iSecMode = CMManager::EWlanSecModeOpen;

        }

    FLOG( _L( "[AccesspointAdapter] CWPAPNapdef::AddWlanDataL EApWlanSecurityMode" ) );

   	// CMManager, securitymode causes error -1, this will be set manually in SaveWlanData

   	//TRAP ( err, aCmItem.SetIntAttributeL( CMManager::EWlanSecurityMode, iSecMode ));

    FTRACE(RDebug::Print(_L("[AccesspointAdapter] CWPAPNapdef::AddWlanDataL EApWlanSecurityMode err (%d)"), err));

    if (err)

        {

        err = KErrNone;

        }

    }

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

// CWPAPNapdef::WriteDNSAddressL

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

//

void CWPAPNapdef::WriteDNSAddressL( /*CApAccessPointItem& aAPItem*/ RCmConnectionMethodExt& aCmItem,

                                    const TDesC& aValue )

	{

    // GPRS access points supports IPv6 only if explicitly stated. 

    // CMManager

    TBool apSupportsIPv6( iPdpType == RPacketContext::EPdpTypeIPv6 | iBearer != KUidPacketDataBearerType );

    // If IPv6 is supported, write the DNS address as IPv6 if

    // bearer supports IPv6 and the address format is IPv6    

    if( FeatureManager::FeatureSupported( KFeatureIdIPv6 )

        && apSupportsIPv6

        && WPAdapterUtil::CheckIPv6( aValue ) )

        {

        // Two name servers per network type

        if( iNumIPv6NameServers < KTwoNameServersPerNetworkType )

            {

            // CMManager

            TRAPD (err, aCmItem.SetStringAttributeL( CMManager::TConnectionMethodCommonAttributes( 

            													( CMManager::ECmIP6NameServer1 ) + iNumIPv6NameServers ), aValue ) );

            User::LeaveIfError( err );

            iNumIPv6NameServers++;

            }

        }

     else if( CheckIPv4values( aValue) )

        {

        // Two name servers per network type

        if( iNumIPv4NameServers < KTwoNameServersPerNetworkType )

            {

            // CMManager 

            TRAPD ( err, aCmItem.SetStringAttributeL( CMManager::TConnectionMethodCommonAttributes( 

            													( CMManager::ECmIPNameServer1 ) + iNumIPv4NameServers ), aValue ) );

            User::LeaveIfError( err );

            aCmItem.SetBoolAttributeL( CMManager::ECmIPDNSAddrFromServer, EFalse);

            iNumIPv4NameServers++;

            }

        }

	}

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

// CWPAPNapdef::CheckAddressPart

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

//

TBool CWPAPNapdef:: CheckAddressPart( TLex& aLex )

    {

    TBool result( aLex.Peek().IsDigit() );

    aLex.Inc();

    if( aLex.Peek().IsDigit() )

        {