// 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:
// Name          : CSipCRServer.cpp
// Part of       : SIP Client Resolver
// Version       : 1.0
//



// INCLUDES
#include "sipCRclientserver.h"
#include "CSipCRServer.h"
#include "CSipCRServerSession.h"
#include "CSIPCRITCUtility.h"
#include "CSIPCRRoutingTable.h"
#include "CSIPCRServerCloseTimer.h"
#include "CSIPClientResolver.h"
#include "sipresolvedclient.h"
#include "sipresolvedclient2.h"
#include "sipstrings.h"
#include "SIPHeaderLookup.h"
#include "TSipCRPlatSecPolicy.h"

// CONSTANTS
const TUint KServerCloseWaitTime = 500; // milliseconds

// -----------------------------------------------------------------------------
// CSIPCRServer::NewL
// -----------------------------------------------------------------------------
//
CSIPCRServer* CSIPCRServer::NewL ()
	{
    CSIPCRServer* self = CSIPCRServer::NewLC();
    CleanupStack::Pop(self);
    return self;
	}

// -----------------------------------------------------------------------------
// CSIPCRServer::NewLC
// -----------------------------------------------------------------------------
//
CSIPCRServer* CSIPCRServer::NewLC ()
	{
	CSIPCRServer* self = new(ELeave)CSIPCRServer(EPriorityHigh);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
	}

// -----------------------------------------------------------------------------
// CSIPCRServer::CSipCRServer
// -----------------------------------------------------------------------------
//
CSIPCRServer::CSIPCRServer (TInt aPriority)
 : CPolicyServer(aPriority, TSIPCRPlatSecPolicy)
	{
	}

// -----------------------------------------------------------------------------
// CSIPCRServer::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPCRServer::ConstructL ()
	{
	SIPStrings::OpenL();
	SIPHeaderLookup::OpenL();
	SIPHeaderLookup::SetConvertToSIPURI();
	
    iActiveScheduler = new (ELeave) CActiveScheduler ();
    CActiveScheduler::Install (iActiveScheduler);

    iItcUtility = CSIPCRITCUtility::NewL();
    iCloseTimer = CSIPCRServerCloseTimer::NewL();
    iRoutingTable = CSIPCRRoutingTable::NewL();
    iClientResolver = CSIPClientResolver::NewL();
    
    StartL(KSipClientResolverServerName);
	}

// -----------------------------------------------------------------------------
// CSIPCRServer::~CSIPCRServer
// -----------------------------------------------------------------------------
//
CSIPCRServer::~CSIPCRServer ()
	{
	delete iClientResolver;
	delete iRoutingTable;
	delete iCloseTimer;
	delete iItcUtility;
	delete iActiveScheduler;
	CActiveScheduler::Install (NULL);
	SIPHeaderLookup::Close();
	SIPStrings::Close();
	REComSession::FinalClose();
	
#ifdef _BullseyeCoverage
    // Store coverage measurement
    cov_write();
#endif
	}

// -----------------------------------------------------------------------------
// CSIPCRServer::IncrementSessions
// -----------------------------------------------------------------------------
//
void CSIPCRServer::IncrementSessions ()
	{
	if (iCloseTimer->IsActive())
        {
        iCloseTimer->Cancel();
        }
    iSessionCount++;
	}

// -----------------------------------------------------------------------------
// CSIPCRServer::DecrementSessions
// -----------------------------------------------------------------------------
//
void CSIPCRServer::DecrementSessions ()
	{
    iSessionCount--;
	if (iSessionCount == 0)
		{
		iCloseTimer->StopActiveSchedulerAfter(KServerCloseWaitTime);
		}
	}

// -----------------------------------------------------------------------------
// CSIPCRServer::ITCUtility
// -----------------------------------------------------------------------------
//
CSIPCRITCUtility& CSIPCRServer::ITCUtility ()
    {
    return *iItcUtility;
    }
    
// -----------------------------------------------------------------------------
// CSIPCRServer::RoutingTable
// -----------------------------------------------------------------------------
//
CSIPCRRoutingTable& CSIPCRServer::RoutingTable ()
    {
    return *iRoutingTable;
    }
    
// -----------------------------------------------------------------------------
// CSIPCRServer::ClientResolver
// -----------------------------------------------------------------------------
//
CSIPClientResolver& CSIPCRServer::ClientResolver ()
    {
    return *iClientResolver;
    }
    
// ----------------------------------------------------------------------------
// CSIPCRServer::LoadPlugin1LC
// ----------------------------------------------------------------------------
//    
CSIPResolvedClient* CSIPCRServer::LoadPlugin1LC( 
    const TUid& aClientUid,
    const TUid& aResolverUid )
    {
    const TInt KUidWidth = 8;
    TBuf8<KUidWidth> clientUidBuf;
    clientUidBuf.AppendNumFixedWidthUC( aClientUid.iUid, EHex, KUidWidth );
    TEComResolverParams resolverParams;
    resolverParams.SetDataType( clientUidBuf );
    CSIPResolvedClient* resolvedClient = NULL;
    
    if (aResolverUid == TUid::Null())
        {
        resolvedClient = reinterpret_cast< CSIPResolvedClient* >(
            REComSession::CreateImplementationL( KSIPResolvedClientIFUid,
                _FOFF( CSIPResolvedClient, iInstanceKey ),
                resolverParams ) );
        }
    else
        {
        resolvedClient = reinterpret_cast< CSIPResolvedClient* >(
            REComSession::CreateImplementationL( KSIPResolvedClientIFUid,
                _FOFF( CSIPResolvedClient, iInstanceKey ),
                resolverParams, aResolverUid ) );        
        }
        
    CleanupStack::PushL(resolvedClient);
    return resolvedClient;    
    }
    
// ----------------------------------------------------------------------------
// CSIPCRServer::LoadPlugin2LC
// ----------------------------------------------------------------------------
//    
CSIPResolvedClient2* CSIPCRServer::LoadPlugin2LC(
    const TUid& aImplementationUid )
    {
    CSIPResolvedClient2* resolvedClient = 
        reinterpret_cast< CSIPResolvedClient2* >(
            REComSession::CreateImplementationL( 
                aImplementationUid,
                _FOFF( CSIPResolvedClient2, iInstanceKey ) ) );
    CleanupStack::PushL(resolvedClient);
    return resolvedClient;    
    }
   
// ----------------------------------------------------------------------------
// CSIPCRServer::RoutingEntryAddedL
// ----------------------------------------------------------------------------
//    
void CSIPCRServer::RoutingEntryAddedL(const TUid& aUid)
    {
	// Inform all the sessions
	iSessionIter.SetToFirst();
    CSIPCRServerSession* session = NULL;
	for (CSession2* s=iSessionIter; s!=0; s=iSessionIter++)
		{
		session = static_cast<CSIPCRServerSession*>(s);
		session->RoutingEntryAddedL(aUid);
		}
    }    
    
// -----------------------------------------------------------------------------
// CSIPCRServer::RunError
// -----------------------------------------------------------------------------
//
TInt CSIPCRServer::RunError(TInt aError)
	{
	if (aError == KErrBadDescriptor)
		{
        // A bad descriptor error implies a badly programmed client, 
        // so panic it; otherwise report the error to the client
		Message().Panic(KSipCRServerPanic, EBadDescriptor);
		}
	else
		{
		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
	}
	
// -----------------------------------------------------------------------------
// CSIPCRServer::NewSessionL
// -----------------------------------------------------------------------------
//
CSession2* CSIPCRServer::NewSessionL(const TVersion &aVersion,
                                     const RMessage2& /*aMessage*/) const
	{
	// check we're the right version
	if (!User::QueryVersionSupported(TVersion(KSipCRServerMajorVersionNumber,
                                              KSipCRServerMinorVersionNumber,
                                              KSipCRServerBuildVersionNumber),
                                              aVersion))
		{
		User::Leave(KErrNotSupported);
		}
	// make new session
    return CSIPCRServerSession::NewL(const_cast<CSIPCRServer&>(*this));
  	}

//  End of File