/*

* Copyright (c) 2005-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:   Main class for server side sessions

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <centralrepository.h>

#include "epos_suplterminalipc.h"

#include "epos_csuplprotocolmanagerbase.h"

#include "epos_suplnetworkipc.h"

//#ifdef _DEBUG

//#include "epos_cpostrace.h"

//#endif

#include "epos_csuplserver.h"

#include "epos_csuplsubsessionregistry.h"

#include "epos_csuplglobal.h"

#include "epos_csuplipcsubsession.h"

#include "epos_csuplipcsession.h"

#include "epos_csuplnetinitiatedsession.h"

#include "epos_csuplnetinitiatedregistry.h"

#include "epos_csuplconnecttimer.h"

#include "epos_mconnecttimerobserver.h"

#include "epos_csuplsessionmanager.h"

// CONSTANTS

//#ifdef _DEBUG

_LIT(KTraceFileName, "SUPL_GW::epos_csuplipcsession.cpp");

//#endif

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

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

// might leave.

//

CSuplIPCSession::CSuplIPCSession(CSuplServer& aServer, CSuplSessionManager& aSessnMgr):

	iSuplServer(aServer),

	iSessionManager(aSessnMgr)

    {      

    }

// Destructor

CSuplIPCSession::~CSuplIPCSession()

    {

    DEBUG_TRACE("CSuplIPCSession::~CSuplIPCSession", __LINE__)

    delete iSubSessionRegistry;

	delete iConnectTimer;

    // The flag iServerShutdown prevents calling the server or its members if

    // it is already destroyed.

    if (!iServerShutdown)

        {

        if (iDecrementSessions)

            {

            iSuplServer.DecrementSessions();

            }

        }

    }

// Two-phased constructor

CSuplIPCSession* CSuplIPCSession::NewL(CSuplServer& aServer, CSuplSessionManager& aSessnMgr, TInt aIpcSessionId)

    {

    DEBUG_TRACE("CSuplIPCSession::NewL", __LINE__)

    CSuplIPCSession* self = new (ELeave)

        CSuplIPCSession(aServer, aSessnMgr);

    CleanupStack::PushL(self);

    self->ConstructL(aIpcSessionId);

    CleanupStack::Pop(self);

    return self;

    }

// EPOC default constructor

void CSuplIPCSession::ConstructL(TInt aIpcSessionId)

    {

    DEBUG_TRACE("CSuplIPCSession::ConstructL", __LINE__)

    iSubSessionRegistry = CSuplSubsessionRegistry::NewL();

	iConnectTimer = CSuplConnectTimer::NewL(this);

    // This call will also cancel any server shutdown in progress.

    iSuplServer.IncrementSessions();

    iIpcSessionId = aIpcSessionId;

    iDecrementSessions = ETrue;

    }

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

// CSuplIPCSession::ForwardMessageL

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::ForwardMessageL(const RMessage2& aMessage)

	{

	DEBUG_TRACE("CSuplIPCSession::ForwardMessageL", __LINE__)

	if (aMessage.SecureId() != KSuplWapSecureId)

	    if (!aMessage.HasCapability(ECapabilityCommDD))

	     	{

	     	DEBUG_TRACE("CSuplServer::Invalid UID", __LINE__)

	     	RequestComplete(aMessage, KErrPermissionDenied);

	     	}

    TInt dataSize = aMessage.GetDesLength(0);

    if(dataSize>0)

    	{

    	iSuplServer.HandleNewNetSessionL(iSessionManager,aMessage);  

    	}

    else

    	{

        RequestComplete(aMessage,KErrArgument);

    	}

	}

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

// CSuplIPCSession::ServiceL

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::ServiceL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("CSuplIPCSession::ServiceL", __LINE__)

    iMessage = aMessage;

	switch (aMessage.Function())

        {

        case ESuplTerminalSubssnOpen:

        	{

     	    TInt service = aMessage.Int0();

     	    switch( service )

     	    	{

     	    	case 1:

     	    		{

     	    		iSuplService = RSuplTerminalSubSession::ESUPL_1_0;	

     	    		break;

     	    		}

     	    	case 2:

     	    		{

     	    		iSuplService = RSuplTerminalSubSession::ESUPL_2_0;	

     	    		break;

     	    		}

     	    	default:

     	    		{

     	    		iSuplService = RSuplTerminalSubSession::ESUPL_1_0;	

     	    		break;

     	    		}

     	    	}

           	TBool connect=iSuplServer.GetConnectFlag(); 

           	TInt connectError=iSessionManager.GetConnectError();

            if (connect && connectError==KErrNone)

                CreateSubSessionL(aMessage, CSUPLProtocolManagerBase::ETerminal, iSuplService );

            else

                {                	

                if(connect==FALSE && connectError==KErrNone)

                	{

                	iConnectCount = 0;

                	iReqType = ETerminalConnectOpen;

                	iConnectTimer->Start(250000);

                	}

                else

                	RequestComplete(aMessage,KErrGeneral);

                }                        

            break;

        	}

	    case ESuplTerminalSubssnClose:

            {

            CloseSubsessionL(aMessage);            	

            }

		    break;

        case ESuplNetworkForwardSuplMsg:

            {

           	TBool connect=iSuplServer.GetConnectFlag(); 

           	TInt connectError=iSessionManager.GetConnectError();

            if (connect && connectError==KErrNone)

        	    ForwardMessageL(aMessage);

            else

                {                

                if(!connect && connectError==KErrNone)

                 	{

                	iConnectCount = 0;

                 	iReqType = ENetworkConnectForwardMessage;

                 	iConnectTimer->Start(250000);	

                 	}

                else

                	RequestComplete(aMessage,KErrGeneral);

                }                        

		    break;

            }

        default:

            ForwardToSubSessionL(aMessage);

		    break;

        }

    }

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

// CSuplIPCSession::NotifyServerShutdown

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::NotifyServerShutdown()

    {

    DEBUG_TRACE("CSuplIPCSession::NotifyServerShutdown", __LINE__)

    iServerShutdown = ETrue;

    TInt nrOfSubSessions = iSubSessionRegistry->Count();

    for (TInt i = 0; i < nrOfSubSessions; i++)

        {

        CSuplIPCSubSession * subSession = 

            static_cast <CSuplIPCSubSession *> 

            (iSubSessionRegistry->SubSessionFromIndex(i));

        if (subSession)

			{

			subSession->NotifyServerShutdown();

			}

        }

    }

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

// CSuplIPCSession::CloseSubsession

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::CloseSubsessionL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("CSuplIPCSession::CloseSubsessionL", __LINE__)

    TInt handle = aMessage.Int3();

	CSuplIPCSubSession* subSession =

        iSubSessionRegistry->SubSessionFromHandleL(aMessage.Int3());

	subSession->DestroySession(iSessionManager);

    iSubSessionRegistry->CloseSubSession(handle);

	RequestComplete(aMessage, KErrNone);

    DEBUG_TRACE("CSuplIPCSession::CloseSubsessionCompletes", __LINE__)

    }

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

// CSuplIPCSession::CreateSubSessionL

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::CreateSubSessionL(

                const RMessage2& aMessage,

                CSUPLProtocolManagerBase::TSuplReqType aReqType,

                RSuplTerminalSubSession::TSuplServiceType aSuplService

            )

	{

    DEBUG_TRACE("CSuplIPCSession::CreateSubSessionL", __LINE__)

    // Create SUPL session object

    CSuplIPCSubSession* subSession = CSuplIPCSubSession::NewLC(

    									iSessionManager, 

    									aReqType, 

    									iIpcSessionId,

    									aSuplService);

	if(!subSession)

		{ 

		CleanupStack::PopAndDestroy();

		RequestComplete(aMessage, KErrGeneral);

		return;

		}

    TInt subSessionHandle = iSubSessionRegistry->AddInstanceL(subSession);

    CleanupStack::Pop(subSession); // Now owned by registry

    // Set the client subsession identifier.

    TPckg<TInt> handlePackage(subSessionHandle);

    TInt err = SuplGlobal::Write(aMessage, 3, handlePackage);

    if (err)

        {

        iSubSessionRegistry->CloseSubSession(subSessionHandle);

        User::Leave(err);

        }

    RequestComplete(aMessage, KErrNone);

	}

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

// CSuplIPCSession::ForwardToSubSessionL

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::ForwardToSubSessionL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("CSuplIPCSession::ForwardtoSubSessionL", __LINE__)

    CSuplIPCSubSession* subSession =

        iSubSessionRegistry->SubSessionFromHandleL(aMessage.Int3());

    if (!subSession)

		{

        User::Leave(KErrNotSupported);

        }

    subSession->ServiceL(aMessage); 

    }

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

// CSuplIPCSession::RequestComplete

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::RequestComplete(const RMessage2& aMessage, TInt aCompleteCode)

    {

	DEBUG_TRACE("CSuplIPCSession::RequestComplete", __LINE__)

    if (!aMessage.IsNull())

        {

        aMessage.Complete(aCompleteCode);

        }

    }

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

// CSuplIPCSession::RequestComplete

//

// (other items were commented in a header).

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

//

void CSuplIPCSession::CompleteConnectTimerL()

	{

	DEBUG_TRACE("CSuplIPCSession::CompleteConnectTimerL", __LINE__)

	TBool connect=iSuplServer.GetConnectFlag();

    if (connect)

    	{

        if (iReqType == ETerminalConnectOpen)        

        	{

            CreateSubSessionL(iMessage, CSUPLProtocolManagerBase::ETerminal, iSuplService);

        	}                

        else if (iReqType == ENetworkConnectForwardMessage)

        	{

            ForwardMessageL(iMessage);

        	}                

        return;

    	} 

    TInt connectError=iSessionManager.GetConnectError();

    if(connectError!=KErrNone)

    	{

    	RequestComplete(iMessage,KErrGeneral);

    	return;

    	}

    iConnectCount++;

    if (iConnectCount == 10)

    	{

        RequestComplete(iMessage,KErrServerBusy);

    	return;	

    	}            

    iConnectTimer->Start(250000);

	}

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

// CSuplIPCSession::ProtocolHUnloaded

//

// (other items were commented in a header).

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

//   

void CSuplIPCSession::ProtocolHUnloaded() 

	{

	DEBUG_TRACE("CSuplIPCSession::ProtocolHUnloaded", __LINE__)

	TInt subSessioncount = iSubSessionRegistry->Count();

	for(TInt loop=0; loop < subSessioncount;loop++)

		{

		DEBUG_TRACE("CSuplIPCSession::ProtocolHUnloaded Iterating", __LINE__)

		CSuplIPCSubSession* subSession = iSubSessionRegistry->SubSessionFromIndex(loop);

		subSession->ProtocolHUnloaded();

		}

	}

//  End of File