// Copyright (c) 1997-2009 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:

//

/**

 @file ND_DLGSV.CPP

*/

#include <c32comm.h>

#include <e32svr.h>

#include <commsdattypesv1_1.h>

using namespace CommsDat;

#include <comms-infras/dbaccess.h>

#include "ND_DLGSL.H"

#include "ND_DLGSV.H"

#include <rsshared.h>

#include <c32root.h>

#include <es_sock.h>

/**

@internalComponent

*/

//

// CNetDialDialogServerChannelHandler

//

/*static*/ CNetDialDialogServerChannelHandler* CNetDialDialogServerChannelHandler::NewL(

		CommsFW::RCFChannel::TMsgQueues aRxQueues, CommsFW::RCFChannel::TMsgQueues aTxQueues, 

			CNetDialDialogServer& aServer)

	{

	CNetDialDialogServerChannelHandler* pHandler = new (ELeave) CNetDialDialogServerChannelHandler(aServer);

	CleanupStack::PushL(pHandler);

	pHandler->ConstructL(aRxQueues, aTxQueues);

	CleanupStack::Pop(pHandler);

	return pHandler;

	}

CNetDialDialogServerChannelHandler::CNetDialDialogServerChannelHandler(CNetDialDialogServer& aServer):

			CCFModuleChannelHandler(CActive::EPriorityStandard),iServer(aServer)

	{

	}

void CNetDialDialogServerChannelHandler::CFMessageShutdown(const CommsFW::TCFShutdownMsg& /*aMessage*/)

	{

	iServer.Shutdown();

	}

//

// CNetDialDialogServer

//

CNetDialDialogServer::CNetDialDialogServer(TInt aPriority)

	: CServer2(aPriority)

	{

	__FLOG_OPEN(KDlgSvrLogSubsys, KDlgSvrLogComponent);

    }

CNetDialDialogServer::~CNetDialDialogServer()

	{

	delete iChannel;

	__FLOG_CLOSE;

	}

CNetDialDialogServer* CNetDialDialogServer::NewL(CommsFW::RCFChannel::TMsgQueues aRxQueues, CommsFW::RCFChannel::TMsgQueues aTxQueues)

/**

Create and start a new count server.

*/

	{

	CNetDialDialogServer* pS=new(ELeave) CNetDialDialogServer(EPrioritySupervisor);

	CleanupStack::PushL(pS);

	pS->ConstructL(aRxQueues, aTxQueues);

	CleanupStack::Pop();

	return pS;

	}

void CNetDialDialogServer::ConstructL(CommsFW::RCFChannel::TMsgQueues aRxQueues, CommsFW::RCFChannel::TMsgQueues aTxQueues)

	{

	__FLOG(_L("CNetDialDialogServer::ConstructL"));

	iChannel = CNetDialDialogServerChannelHandler::NewL(aRxQueues, aTxQueues, *this);

	StartL(KCommsDialogServerName);

	}

void CNetDialDialogServer::Shutdown()

	{

	if(!Message().IsNull())

		{

		__FLOG(_L("CNetDialDialogServer::Shutdown: Completing message pending in the server."));

		Message().Complete(KErrServerTerminated);

		}

	CNetDialDialogSession* pSession;

	iSessionIter.SetToFirst();

	while((pSession=reinterpret_cast<CNetDialDialogSession*>(iSessionIter++))!=NULL)

		{

		delete pSession;

		iSessionIter.SetToFirst();

		__FLOG(_L("CNetDialDialogServer::Shutdown: Found session. Deleted."));

		}

	__FLOG(_L("CNetDialDialogServer::Shutdown: Stopping active scheduler."));

	CActiveScheduler::Stop();

	}

CSession2* CNetDialDialogServer::NewSessionL(const TVersion &aVersion, const RMessage2& /*aMessage*/) const

/**

 Create a new server session

*/

	{

	// check we're the right version

	TVersion v(KDialogServMajorVersionNumber,KDialogServMinorVersionNumber,KDialogServBuildVersionNumber);

	if (!User::QueryVersionSupported(v,aVersion))

		User::Leave(KErrNotSupported);

	return CNetDialDialogSession::NewL((CNetDialDialogServer*)this);

	}

//

// CNetDialDialogSession

//

CNetDialDialogSession* CNetDialDialogSession::NewL(CNetDialDialogServer* aServer)

/**

CNetDialDialogSession

*/

{

	CNetDialDialogSession* r=new(ELeave) CNetDialDialogSession(aServer);

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop();

	return r;

	}

CNetDialDialogSession::CNetDialDialogSession(CNetDialDialogServer* aServer)

	: CSession2(),

	iNetDialDialogSvr(aServer),

	iBufPtr(NULL,0),

	iPctWriteBuffer(NULL,0)

/**

Constructor.

*/

	{

	__FLOG_OPEN(KDlgSvrLogSubsys, KDlgSvrLogComponent);

	}

void CNetDialDialogSession::ConstructL()

/**

Completes construction of the CNetDialDialogSession object.

*/

	{

	iDb=CMDBSession::NewL(KCDVersion1_2);

	iBuffer=HBufC::NewL(EMaxWriteBufferSize);

	TPtr temp=iBuffer->Des();

	iBufPtr.Set(temp);

	iPctWriteBuffer.Set(temp);

	}

CNetDialDialogSession::~CNetDialDialogSession()

/**

Destructor.

*/

	{

	delete iBuffer;

	delete iDb;

	CancelEverything();

	// Just in case the cancel fails, delete the objects.

	// This is safe as the pointers are nulled after successful 

	// completition to client.

	delete iIAPSelection;

	delete iAccessPointSelection;

	delete iModemAndLocationSelection;

	delete iIAPWarning;

	delete iLogin;

	delete iAuthenticate;

	delete iReconnect;

	delete iPct;

	delete iQoSWarning;

	__FLOG_CLOSE;

	}

void CNetDialDialogSession::ServiceL(const RMessage2& aMessage)

/**

Services the specified transaction.

@param aMessage A Reference to RMessage class.

*/

	{

	TRAPD(err,DispatchMessageL(aMessage));

	if(err!=KErrNone)

		aMessage.Complete(err);

	}

void CNetDialDialogSession::DispatchMessageL(const RMessage2& aMessage)

/**

Dispatch the Message.

@param aMessage A Reference to RMessage class.

*/

	{

	switch (aMessage.Function())

        {

		case EGetIAP:

			CheckBusyL();

			iMessage=aMessage;

			iState=EGetIAP;

			GetIAPL();

			break;

		case EGetAccessPoint:

			CheckBusyL();

			iMessage=aMessage;

			iState=EGetAccessPointState;

			GetAccessPointL();

			break;

		case EGetAccessPointAP:

			CheckBusyL();

			iMessage=aMessage;

			iState=EGetAccessPointState;

			GetAccessPointAPL();

			break;

		case EGetModemAndLocation:

			CheckBusyL();

			iMessage=aMessage;

			iState=EGetModemAndLocation;

			GetModemAndLocationL();

			break;

		case EWarnNewIAP:

			CheckBusyL();

			iMessage=aMessage;

			iState=EWarnIAP;

			WarnIAPL();

			break;

		case EGetLogin:

			CheckBusyL();

			iMessage=aMessage;

			iState=ELogin;

			GetLoginL();

			break;

		case EGetAuthentication:

			CheckBusyL();

			iMessage=aMessage;

			iState=EAuthentication;

			GetAuthenticationL();

			break;

		case EGetReconnectReq:

			CheckBusyL();

			iMessage=aMessage;

			iState=EReconnectReq;

			ReconnectReqL();

			break;

		case EOpenPct:

			CheckBusyL();

			CheckPctL(aMessage);

			iMessage=aMessage;

			iState=EPct;

			OpenPctL();

			break;

		case EWritePct:

			CheckPctL(aMessage);

			iMessage=aMessage;

			iState=EPct;

			WritePct();

			break;

		case EReadPct:

			CheckPctL(aMessage);

			iReadPctMessage=aMessage;

			iState=EPct;

			ReadPctL();

			break;

		case EDestroyPctNotification:

			CheckPctL(aMessage);

			iDestroyNotificationMessage=aMessage;

			iState=EPct;

			DestroyPctNotificationL();

			break;

		case EClosePct:

			CheckPctL(aMessage);

			iMessage=aMessage;

			iState=EPct;

			ClosePct();

			break;

		case EWarnQoS:

			CheckBusyL();

			iMessage=aMessage;

			iState=EWarnQoSState;

			WarnQoSL();

			break;

		case ECancelGetIAP:

		case ECancelGetAccessPoint:

		case ECancelGetModemAndLocation:

		case ECancelWarnIAP:

		case ECancelLogin:

		case ECancelAuthenticate:

		case ECancelReconnect:

		case ECancelReadPct:

		case ECancelDestroyPctNotification:

		case ECancelWarnQoS:

			Cancel((TDialogServRqst)aMessage.Function());

			aMessage.Complete(KErrNone);

			if(!iMessage.IsNull())

				iMessage.Complete(KErrCancel);

			break;

		default:

			PanicClient(EClientBadRequest);

			break;

	        }

	}

void CNetDialDialogSession::CheckBusyL()

/**

Check whether the request is Busy.

*/

	{

	if(iBusy)

		{

		User::Leave(KErrInUse);

		}

	iBusy=ETrue;

	}

TInt CNetDialDialogSession::GeneralCallBackL(TAny* aSession)

	{

	__ASSERT_ALWAYS(aSession,PanicServer(ESvrGeneralCallBackNoSession));

	CNetDialDialogSession* self = STATIC_CAST(CNetDialDialogSession*,aSession);

	switch (self->iState)

        {

		case EGetIAP:

			self->GetIAPCompleteL(self->iIAPSelection->Status());

			break;

		case EGetModemAndLocation:

			self->GetModemAndLocationCompleteL(self->iModemAndLocationSelection->Status());

			break;

		case EWarnIAP:

			self->WarnIAPCompleteL(self->iIAPWarning->Status());

			break;

		case ELogin:

			self->CompleteLoginL(self->iLogin->Status());

			break;

		case EAuthentication:

			self->CompleteAuthentication(self->iAuthenticate->Status());

			break;

		case EReconnectReq:

			self->CompleteReconnectReq(self->iReconnect->Status());

			break;

		case EWarnQoSState:

			self->WarnQoSCompleteL(self->iQoSWarning->Status());

			break;

		case EGetAccessPointState:

			self->GetAccessPointCompleteL(self->iAccessPointSelection->Status());

			break;

		default:

			PanicServer(ESvrGeneralCallBackError);

			break;

        }

	if (self->iDb)

		{

		delete self->iDb;

		self->iDb = NULL;

		}

	return KErrNone;

	}

void CNetDialDialogSession::GetModemAndLocationL()

/**

Shows a dialog to enable the user to choose which modem and location to use for data transactions

*/

	{

	iModemAndLocationSelection = CModemAndLocationSelection::NewL(iDb,this);

	TCallBack callBack(GeneralCallBackL,this);

	iModemAndLocationSelection->GetModemAndLocationL(iModemId(),iLocationId(),callBack);

	}

void CNetDialDialogSession::GetModemAndLocationCompleteL(TInt aStatus)

/**

Shows a dialog to indicate whether data transcations is completed.

@param aStatus whether sucess or failure.

*/

	{

	if (aStatus == KErrNone)

		{

		iMessage.WriteL(0,iModemId);

		iMessage.WriteL(1,iLocationId);

		}

	delete iModemAndLocationSelection;

	iModemAndLocationSelection = NULL;

	iBusy=EFalse;

	iMessage.Complete(aStatus);

	}

void CNetDialDialogSession::GetIAPL()

/**

Get IAP

*/

	{

	iMessage.ReadL(1,iPrefs);

	const TInt lastError = iMessage.Int2();

	iIAPSelection=CIAPSelection::NewL(iDb,this);

	TCallBack callBack(GeneralCallBackL,this);

	iIAPSelection->GetIAPL(iIAP(),iPrefs(),lastError,callBack);

	}

void CNetDialDialogSession::GetIAPCompleteL(TInt aStatus)

	{

	__FLOG_1(_L("CNetDialDialogSession::GetIAPCompleteL - Returned %d"),aStatus);

	if (aStatus == KErrNone)

		{

		iMessage.WriteL(0,iIAP);

		}

	delete iIAPSelection;

	iIAPSelection = NULL;

	iBusy=EFalse;

	iMessage.Complete(aStatus);

	}

void CNetDialDialogSession::WarnIAPL()

/**

Warn IAP

*/

	{

	iMessage.ReadL(0,iPrefs);

	const TInt lastError = iMessage.Int1();

	iMessage.ReadL(2,iNewIAPName);

	iIAPWarning = CIAPWarning::NewL(this);

	TCallBack callBack(GeneralCallBackL,this);

	iIAPWarning->WarnIAPL(iPrefs(),lastError,iNewIAPName,iBool(),callBack);

	}

void CNetDialDialogSession::WarnIAPCompleteL(TInt aStatus)

	{

	if (aStatus == KErrNone)

		{

		iMessage.WriteL(3,iBool);

		}

	delete iIAPWarning;

	iIAPWarning = NULL;

	iBusy = EFalse;

	iMessage.Complete(aStatus);

	}

void CNetDialDialogSession::GetAccessPointL()

/**

Get AccessPoint

*/

	{

	// licensees specific implementation, this is only a reference

	ASSERT(iAccessPointSelection==NULL);

	const TInt tierId = iMessage.Int1();

	iAccessPointSelection=CAccessPointSelection::NewL(iDb,this);

	TCallBack callBack(GeneralCallBackL,this);

	iAccessPointSelection->GetAccessPointL(iAccessPoint(),tierId,callBack);

    }

void CNetDialDialogSession::GetAccessPointAPL()

/**

Get AccessPoint filtered on bearer-related info

*/

	{

    // licensees specific implementation, this is only a reference

	ASSERT(iAccessPointSelection==NULL);

	const TInt tierId = iMessage.Int1();

	iAccessPointSelection=CAccessPointSelection::NewL(iDb,this);

	TCallBack callBack(GeneralCallBackL,this);

	iAccessPointSelection->GetAccessPointL(iAccessPoint(),tierId,callBack);

	}

void CNetDialDialogSession::GetAccessPointCompleteL(TInt aStatus)

	{

	__FLOG_1(_L("CNetDialDialogSession::GetAccessPointCompleteL - Returned %d"),aStatus);

	if (aStatus == KErrNone)

		{

		iMessage.WriteL(0,iAccessPoint);

		}

	delete iAccessPointSelection;

	iAccessPointSelection = NULL;

	iBusy=EFalse;

	iMessage.Complete(aStatus);

	}

void CNetDialDialogSession::GetLoginL()

/**

Login Dialog

*/

	{

	iLogin=CLogin::NewL(this);

	iMessage.ReadL(0,iUsername);

	iMessage.ReadL(1,iPassword);

	TCallBack callBack(GeneralCallBackL,this);

	iLogin->GetUserPassL(iUsername,iPassword,callBack);

	}

void CNetDialDialogSession::CompleteLoginL(TInt aStatus)

/**

Shows the dialog to indicate the Login Complete.

*/

	{

	if(aStatus==KErrNone)

		{

		iMessage.WriteL(0,iUsername);