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

// Name        : SIPProfileCSServer.cpp

// Part of     : SIP Profile Server

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include "SipProfileActiveScheduler.h"

#include "SipProfileCSServer.h"

#include "SipProfileCSSession.h"

#include "SipProfileCSServer.pan"

#include "SipProfileCSServerCloseTimer.h"

#include "SipProfileSecurityPolicy.h"

#include "SipProfileLog.h"

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

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

// CSIPProfileCSServer::NewL

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

//

CSIPProfileCSServer*

CSIPProfileCSServer::NewL(CSIPProfileServerCore& aServerCore)

	{

    CSIPProfileCSServer* self = CSIPProfileCSServer::NewLC(aServerCore);

    CleanupStack::Pop(self);

    return self;

	}

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

// CSIPProfileCSServer::NewLC

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

//

CSIPProfileCSServer*

CSIPProfileCSServer::NewLC(CSIPProfileServerCore& aServerCore)

	{

	CSIPProfileCSServer* self =

	    new (ELeave) CSIPProfileCSServer(aServerCore,EPriorityHigh);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

	}

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

// CSIPProfileCSServer::ConstructL

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

//

void CSIPProfileCSServer::ConstructL()

	{

	const TUint	KSIPProfileServerTimerValue = 5;

    StartL(KSipProfileServerName);	

	if (iServerCore.CanServerStop()) 

		{

		PROFILE_DEBUG1("ProfileServer shutdown timer started")

		iCloseTimer = CSipProfileCSServerCloseTimer::NewL();

		iCloseTimer->StopActiveSchedulerAfter(KSIPProfileServerTimerValue);

		}

	}

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

// CSIPProfileCSServer::CSIPProfileCSServer

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

//

CSIPProfileCSServer::CSIPProfileCSServer(

    CSIPProfileServerCore& aServerCore,

    TInt aPriority)

 : CPolicyServer(aPriority, TSipProfilePlatSecPolicy),

   iServerCore(aServerCore)

	{

	}

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

// CSIPProfileCSServer::~CSIPProfileCSServer

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

//

CSIPProfileCSServer::~CSIPProfileCSServer()

	{

	delete iCloseTimer;

	}

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

// CSIPProfileCSServer::NewSessionL

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

//

CSession2* CSIPProfileCSServer::NewSessionL(const TVersion &aVersion,

                                            const RMessage2& /*aMessage*/) const

	{

	PROFILE_DEBUG1("CSIPProfileCSServer::NewSessionL")

	// Check we're the right version

	if (!User::QueryVersionSupported(

		TVersion(KSipProfileServerMajorVersionNumber,

                 KSipProfileServerMinorVersionNumber,

                 KSipProfileServerBuildVersionNumber),

                 aVersion))

		{

		User::Leave(KErrNotSupported);

		}

	if (iServerCore.BackupInProgress())

		{

		User::Leave(KErrLocked);

		}

	PROFILE_DEBUG1("CSIPProfileCSServer::NewSessionL, exit")

    return CSIPProfileCSSession::NewL(*const_cast<CSIPProfileCSServer*>(this),

                                      iServerCore);

	}

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

// CSIPProfileCSServer::IncrementSessions

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

//

void CSIPProfileCSServer::IncrementSessions()

	{

    iSessionCount++;

	if (iCloseTimer)

		{

		PROFILE_DEBUG1("ProfileServer shutdown timer stopped")

		delete iCloseTimer;

		iCloseTimer = NULL;

		}

	}

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

// CSIPProfileCSServer::DecrementSessions

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

//

void CSIPProfileCSServer::DecrementSessions()

	{

    iSessionCount--;

	if (iSessionCount == 0 && iServerCore.CanServerStop())

		{

	    CActiveScheduler::Stop();

		}

	}

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

// CSIPProfileCSServer::ServerCanStop

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

//

void CSIPProfileCSServer::ServerCanStop()

	{

	if (iSessionCount == 0)

		{

		CActiveScheduler::Stop();

		}	

	}

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

// CSIPProfileCSSession::ShutdownL

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

//

void CSIPProfileCSServer::ShutdownL()

	{

	}

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

// CSIPProfileCSSession::CleanShutdownL

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

//

void CSIPProfileCSServer::CleanShutdownL()

	{

	}

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

// CSIPProfileCSServer::RunError

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

//

TInt CSIPProfileCSServer::RunError(TInt aError)

	{

    Message().Complete(aError);

	// The leave will result in an early return from CServer::RunL(), skipping

	// the call to request another message. So do that now in order to keep the

	// server running.

	ReStart();

	return KErrNone; // handled the error fully

	}

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

// CSIPProfileCSServer::PanicClient

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

//

void CSIPProfileCSServer::PanicClient(const RMessage2& aMessage,

                                      TSIPProfileCSPanic aPanic)

	{

    aMessage.Panic(KSipProfileCSServerPanic, aPanic);

	}

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

// CSIPProfileCSServer::PanicServer

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

//

void CSIPProfileCSServer::PanicServer(TSIPProfileCSPanic aPanic)

	{

    User::Panic(KSipProfileCSServerPanic, aPanic);

	}

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

// CSIPProfileCSServer::ThreadFunctionL

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

//

void CSIPProfileCSServer::ThreadFunctionL(RMutex& aMutex)

	{

	// Give a name to this thread

	User::LeaveIfError(User::RenameThread(KSipProfileServerName));

    // Construct our server

    CActiveScheduler* activeScheduler = new (ELeave) CSIPProfileActiveScheduler;

    CActiveScheduler::Install(activeScheduler);

    CleanupStack::PushL(activeScheduler);

    CSIPProfileServerCore::NewLC();

	if (SignalClientSemaphore() == KErrNone)

		{

		// Semaphore signalled ok

		PROFILE_DEBUG1("Start initiated by client")

		}

	else

		{

		PROFILE_DEBUG1("Start initiated by non-client")

		// Server started by non-client. No need to signal.

		}	

	aMutex.Signal();

    aMutex.Close();

	// Start handling requests

	CActiveScheduler::Start();

    // This will be executed after the active scheduler has been stopped:

    CleanupStack::PopAndDestroy(2); // server, activeScheduler

	}

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

// CSIPProfileCSServer::ThreadFunction

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

//

TInt CSIPProfileCSServer::ThreadFunction(TAny* /*aNone*/)

	{

	_LIT(KSipProfileServerMutexName, "SipProfileServerMutex");

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if (!cleanupStack) 

	    {

	    PanicServer(ECreateTrapCleanup);

	    }

	// Protect server starting code with a mutex.

	RMutex mutex;

	TInt err = mutex.CreateGlobal(KSipProfileServerMutexName);

    if (err != KErrNone)

        {

        err = mutex.OpenGlobal(KSipProfileServerMutexName);

        if (err != KErrNone)

            {

            delete cleanupStack;

            PanicServer(ESrvCreateServer);

            return err; // silence warnings

            }

        }

    mutex.Wait(); // Wait here until nobody else executes the code below.

    TFindServer findServer(KSipProfileServerName);

    TFullName name;

	if (findServer.Next(name) == KErrNone) 

        {

        // Server already running.

        SignalClientSemaphore();

        mutex.Signal();

        mutex.Close();

        }

    else

        {

        // Server not running. Try to start it.

        TRAP(err, ThreadFunctionL(mutex));

        if (err != KErrNone)

            {

            SignalClientSemaphore();

	        mutex.Signal();

	        mutex.Close();	

            } 

        }

    delete cleanupStack;

    return err;

	}

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

// CSIPProfileCSServer::SignalClientSemaphore

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

//

TInt CSIPProfileCSServer::SignalClientSemaphore()

    {

    RSemaphore semaphore;

	TInt err = semaphore.OpenGlobal(KSipProfileServerSemaphoreName);

	if (err == KErrNone)

	    {

		semaphore.Signal();

		semaphore.Close();

		}

	return err; 

    }

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

// E32Main

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

//

TInt E32Main() 

    { 

	PROFILE_DEBUG1("Process created")

    return CSIPProfileCSServer::ThreadFunction(NULL);

    }