/*

* Copyright (c) 2004 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:  Main class for handling provisioning Provisioning message

*

*/

// INCLUDE FILES

#include <badesca.h>

#include <commdb.h>

#include <cdbcols.h>			 // CommsDB columname defs

#include <stringresourcereader.h>

#include <barsread.h>

#include <f32file.h>

#include <bautils.h>

#include <ApUtils.h>

#include <utf.h>

#include <featmgr.h>

#include <barsc.h> 

#include <nsmldebug.h>

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <CWPEngine.h>

#include <NSmlPrivateAPI.h>

#include "NSmlDmProvisioningAdapter.h"

#include "NSmlTransportHandler.h"

#include <data_caging_path_literals.hrh>

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

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

// CNSmlDmProvisioningAdapter::CNSmlDmProvisioningAdapter

// C++ default constructor can NOT contain any code, that

// might leave.

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

CNSmlDmProvisioningAdapter::CNSmlDmProvisioningAdapter()

	:CWPAdapter(), iAuthSecretLimitIndicator(0)

	{

	}

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

// CNSmlDmProvisioningAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CNSmlDmProvisioningAdapter::ConstructL()

	{

    iLock = EFalse;

	iSession.OpenL();

	FeatureManager::InitializeLibL();

	}

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

// CNSmlDmProvisioningAdapter::NewL

// Two-phased constructor.

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

CNSmlDmProvisioningAdapter* CNSmlDmProvisioningAdapter::NewL()

	{

	_DBG_FILE("CNSmlDmProvisioningAdapter::NewL(): begin");

	CNSmlDmProvisioningAdapter* self = new(ELeave) CNSmlDmProvisioningAdapter; 

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	_DBG_FILE("CNSmlDmProvisioningAdapter::NewL(): end");

	return self;

	}

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

// Destructor

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

CNSmlDmProvisioningAdapter::~CNSmlDmProvisioningAdapter()

	{

	iProfiles.ResetAndDestroy();

	iProfiles.Close();

	delete iTitle;

	iSession.Close();

	FeatureManager::UnInitializeLib();

	}

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

// Destructor

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

CNSmlDmProfileElement::~CNSmlDmProfileElement()

	{

	iVisitParameter = 0;

	delete iServerNonce;

	delete iHostAddress;

	delete iPort;

	delete iHTTPUserName;

	delete iHTTPPassword;

	delete iDisplayName;

	delete iServerId;

	delete iUsername;

	delete iPassword;

	delete iServerPassword;

	}

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

// CNSmlDmProvisioningAdapter::CanSetAsDefault

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

TBool CNSmlDmProvisioningAdapter::CanSetAsDefault(TInt /*aItem*/) const

	{

	return EFalse;

	}

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

// CNSmlDmProvisioningAdapter::SetAsDefaultL

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

void CNSmlDmProvisioningAdapter::SetAsDefaultL(TInt /*aItem*/ )

	{

	}

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

// CNSmlDmProvisioningAdapter::ItemCount

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

TInt CNSmlDmProvisioningAdapter::ItemCount() const

	{

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

// CNSmlDmProvisioningAdapter::SummaryTitle

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

const TDesC16& CNSmlDmProvisioningAdapter::SummaryTitle(TInt /*aIndex*/) const

	{

	return *iTitle;

	}

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

// CNSmlDmProvisioningAdapter::SummaryText

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

const TDesC16& CNSmlDmProvisioningAdapter::SummaryText(TInt aIndex) const

	{

	return *iProfiles[aIndex]->iDisplayName;

	}

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

// CNSmlDmProvisioningAdapter::SaveL

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

void CNSmlDmProvisioningAdapter::SaveL(TInt aItem)

	{

		_DBG_FILE("CNSmlDmProvisioningAdapter::SaveL(): begin");

	TInt serverID = 0;

	TInt hostAddress = 0;

	TInt username = 0;

	if(iProfiles[aItem]->iServerId && iProfiles[aItem]->iHostAddress && 

	iProfiles[aItem]->iUsername)

	{

		TPtrC8 serverPtr = iProfiles[aItem]->iServerId->Des();

		TPtrC hostAddressPtr = iProfiles[aItem]->iHostAddress->Des();

		TPtrC8 usernamePtr = iProfiles[aItem]->iUsername->Des();		

		serverID = serverPtr.Compare(KNSmlDMProvisioningNoVal);

		hostAddress = hostAddressPtr.Compare(KNSmlDMProvisioningNoVal16);

		username = usernamePtr.Compare(KNSmlDMProvisioningNoVal);

	}

	else

	{

		User::Leave(KErrGeneral);

	}

	if( ( serverID == 0 ) || ( hostAddress == 0 ) || ( username == 0 ))

	{

		User::Leave(KErrGeneral);

	}

	if (iAuthSecretLimitIndicator)

	{

		iAuthSecretLimitIndicator = 0;

		User::Leave(KErrOverflow);

	}

	TPckgBuf<TUint32> uid;

	RSyncMLDevManProfile profile,ProfileToSearch;

	RArray<TSmlProfileId> arr;

  iSession.ListProfilesL( arr, ESmlDevMan );

  TBool ret = EFalse;

  TInt ProfileId = KErrNotFound;

  CleanupClosePushL(arr);   	

	for ( TInt index = 0; index < arr.Count(); index++ )

		{

	    TRAPD( error, ProfileToSearch.OpenL(iSession, arr[index], ESmlOpenRead ) );

	    if ( error == KErrNone )

	        {	            	            	        

    	        if ( ( iProfiles[aItem]->iServerId->Des()).Compare(ProfileToSearch.ServerId() ) == 0 )

    	            {

                    ret = ETrue;                    

                    ProfileId = (TInt)arr[index];

                    ProfileToSearch.Close();

                    break;

                    }	            		    

	        }

	      ProfileToSearch.Close();  

		}

    CleanupStack::PopAndDestroy( &arr );

	if( ret )

		{

		profile.OpenL(iSession, ProfileId , ESmlOpenReadWrite );	

		TInt isprofilelocked=profile.ProfileLocked(EFalse, EFalse);

		if (isprofilelocked == 1)

		 {

            profile.ProfileLocked(ETrue, EFalse);

            iLock = ETrue;	 	

		 }

		}

	else

		{

	profile.CreateL( iSession );

		}

	CleanupClosePushL( profile );

	// ui needs this to be set 0

	profile.SetCreatorId(0);

	profile.SetSanUserInteractionL( iProfiles[aItem]->iServerAlertedAction );

	if ( iProfiles[aItem]->iDisplayName )

	    {	    

	    profile.SetDisplayNameL( iProfiles[aItem]->iDisplayName->Des() );    

	    }

	if ( iProfiles[aItem]->iServerId )

	    {	    

	    profile.SetServerIdL( iProfiles[aItem]->iServerId->Des() );    

	    }

    if ( iProfiles[aItem]->iServerPassword )

	    {	    

	    profile.SetServerPasswordL( iProfiles[aItem]->iServerPassword->Des() );    

	    }

	if ( iProfiles[aItem]->iUsername )   

	    {	    

	    profile.SetUserNameL( iProfiles[aItem]->iUsername->Des() );    

	    }

	if ( iProfiles[aItem]->iPassword )

	    {	    

	    profile.SetPasswordL( iProfiles[aItem]->iPassword->Des() );    

	    }

	// creates profile -> must be done before opening the connection

	if(iLock)

	    {

      profile.ProfileLocked(ETrue, ETrue);

      iLock = EFalse;

	    }

	profile.UpdateL();

	RSyncMLConnection connection;

	connection.OpenL( profile, KUidNSmlMediumTypeInternet.iUid );

	CleanupClosePushL( connection );

	if( iProfiles[aItem]->iVisitParameter && iProfiles[aItem]->iVisitParameter->Data().Length() == uid.MaxLength() )

		{

		uid.Copy( iProfiles[aItem]->iVisitParameter->Data() );

		CCommsDatabase* commDb = CCommsDatabase::NewL();

		CleanupStack::PushL( commDb );

		CApUtils* aputils = CApUtils::NewLC( *commDb );

		TUint apId = 0;

		TRAPD( ERROR, apId = aputils->IapIdFromWapIdL( uid() ) );

		if( ERROR != KErrNone )

			{

			apId = GetDefaultIAPL();

			}

		HBufC8* iapBuf = HBufC8::NewLC( 8 );

		TPtr8 ptrBuf = iapBuf->Des();

		ptrBuf.Num( apId );

		connection.SetPropertyL( KNSmlIAPId, *iapBuf );

		CleanupStack::PopAndDestroy( 3 ); //commdb, aputils, iapBuf		

		}

	if( iProfiles[aItem]->iHostAddress )

		{

		// see if address contains also port

		TBool portFound = EFalse;

		TInt startPos(0);

		if(iProfiles[aItem]->iHostAddress->Find(KNSmlDMProvisioningHTTP)==0)

		    {

		    startPos=KNSmlDMProvisioningHTTP().Length();		    		    

		    }

		else if(iProfiles[aItem]->iHostAddress->Find(KNSmlDMProvisioningHTTPS)==0)

		    {

		    startPos=KNSmlDMProvisioningHTTPS().Length();		    		    

		    }

		TPtrC uriPtr = iProfiles[aItem]->iHostAddress->Mid(startPos);

		if(uriPtr.Locate(KNSmlDMColon)!=KErrNotFound)

		    {

			portFound = ETrue;

		    }

		if( portFound == EFalse )

			{

			HBufC *uri = 0;

			// port not found from URI -> see if it is given separately				

			if( iProfiles[aItem]->iPort )

				{

				// parse address and port into URI				

				if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),

							  iProfiles[aItem]->iPort->Des(), uri ) == KErrNone )

					{

					if(iProfiles[aItem]->iHostAddress)

					{

						delete iProfiles[aItem]->iHostAddress;

						iProfiles[aItem]->iHostAddress = NULL;

					}

					iProfiles[aItem]->iHostAddress = uri->Des().AllocL();

					}

				CleanupStack::PopAndDestroy(); // uri		  

				}

			else

				{

				// use default port

				if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),

							  KNSmlDmDefaultPort(), uri ) == KErrNone )

					{

					if(iProfiles[aItem]->iHostAddress)

					{

						delete iProfiles[aItem]->iHostAddress;

						iProfiles[aItem]->iHostAddress = NULL;

					}

					iProfiles[aItem]->iHostAddress = uri->Des().AllocL();

					}

				CleanupStack::PopAndDestroy(); // uri					

				}

			}

		connection.SetServerURIL( ConvertTo8LC( iProfiles[aItem]->iHostAddress->Des() ) );

		CleanupStack::PopAndDestroy(); // ConvertTo8LC

		}

	// set authtype, HTTPUserName, HTTPPassword

	if( iProfiles[aItem]->iHTTPUserName ||

	    iProfiles[aItem]->iHTTPPassword )

		{

		connection.SetPropertyL( KNSmlHTTPAuth, KNSmlTrueVal );

		if( iProfiles[aItem]->iHTTPUserName )

			{

			connection.SetPropertyL( KNSmlHTTPUsername, iProfiles[aItem]->iHTTPUserName->Des() );

			}

		if( iProfiles[aItem]->iHTTPPassword )

			{

			connection.SetPropertyL( KNSmlHTTPPassword, iProfiles[aItem]->iHTTPPassword->Des() );

			}

		}

	else

		{

		connection.SetPropertyL( KNSmlHTTPAuth, KNSmlFalseVal );

		}

	connection.UpdateL();

	CleanupStack::PopAndDestroy(); //connection

	profile.UpdateL();

	if( iProfiles[aItem]->iServerNonce )

		{

		RNSmlPrivateAPI privateApi;

		iProfiles[aItem]->iAuthInfo.iProfileId = profile.Identifier();		

 		iProfiles[aItem]->iAuthInfo.iServerNonce = ConvertTo8LC( iProfiles[aItem]->iServerNonce->Des() ).AllocL();

 		CleanupStack::PopAndDestroy(); //ConvertTo8LC 

 		iProfiles[aItem]->iAuthInfo.iClientNonce = KNullDesC8().AllocL();

 		privateApi.OpenL();

 		CleanupClosePushL( privateApi );

 		TInt err( KErrNone );

 		TRAP(err, privateApi.SetDMAuthInfoL( iProfiles[aItem]->iAuthInfo ));

 		CleanupStack::PopAndDestroy(); // privateApi

		}

	iProfiles[aItem]->iProfileId = profile.Identifier(); 

	if(iInitSession&(0x01<<(aItem+1)))

	    {

    	_DBG_FILE("CNSmlDmProvisioningAdapter::SaveL(): init session");

	    TInt serverIdLen = profile.ServerId().Length();

	    TInt staticPartLen = KNSmlDmStaticAlertMessagePart().Length();

	    HBufC8* alertMessage = HBufC8::NewLC(staticPartLen+3+serverIdLen);

	    TPtr8 alertPtr = alertMessage->Des();

	    TPckgBuf<TUint8> sessionIdLo(1);

	    TPckgBuf<TUint8> sessionIdHi(0);

	    TPckgBuf<TUint8> serverIdLenBuf(serverIdLen);

	    alertPtr.Append(KNSmlDmStaticAlertMessagePart);

	    alertPtr.Append(sessionIdHi);

	    alertPtr.Append(sessionIdLo);

	    alertPtr.Append(serverIdLenBuf);

	    alertPtr.Append(profile.ServerId());

		DBG_ARGS8( alertMessage->Ptr());

		RNSmlPrivateAPI privateApi;

		privateApi.OpenL();

		CleanupClosePushL(privateApi);

		if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))

		{

		privateApi.SendL( alertPtr, ESmlDevMan, ESmlVersion1_2 );	

		}

		else

		{

		privateApi.SendL( alertPtr, ESmlDevMan, ESmlVersion1_1_2 );	

		}

	    CleanupStack::PopAndDestroy(); //privateApi

	    CleanupStack::PopAndDestroy(alertMessage);	    

	    }

	CleanupStack::PopAndDestroy( &profile );

	_DBG_FILE("CNSmlDmProvisioningAdapter::SaveL(): end");

	}

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

// CNSmlDmProvisioningAdapter::Reserved_1

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

TInt CNSmlDmProvisioningAdapter::Reserved_1()

	{

	return KErrNotSupported;

	}

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

// CNSmlDmProvisioningAdapter::Reserved_2

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

TInt CNSmlDmProvisioningAdapter::Reserved_2()

	{

	return KErrNotSupported;

	}

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

// CNSmlDmProvisioningAdapter::VisitL

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

void CNSmlDmProvisioningAdapter::VisitL( CWPCharacteristic& aCharacteristic )

	{

	_DBG_FILE("CNSmlDmProvisioningAdapter::VisitL(CWPCharacteristic): begin");

	if(aCharacteristic.Type() == KWPApplication)

		{

		iState = CNSmlDmProvisioningAdapter::EStateApplication;

		}

	else if(aCharacteristic.Type() == KWPAppAuth)

		{

		iAuthLevel = CNSmlDmProvisioningAdapter::ENone;

		if(iState != CNSmlDmProvisioningAdapter::EStateDmSettings)

			{

			iState = CNSmlDmProvisioningAdapter::EStateNull;

			}

		}

	else if(aCharacteristic.Type() == KWPAppAddr || aCharacteristic.Type() == KWPResource || aCharacteristic.Type() == KWPPort)

		{

		if(iState != CNSmlDmProvisioningAdapter::EStateDmSettings)

			{

			iState = CNSmlDmProvisioningAdapter::EStateNull;

			}

		}

	else

		{

		iState = CNSmlDmProvisioningAdapter::EStateNull;

		}

	if(iState!=CNSmlDmProvisioningAdapter::EStateNull)

		{