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

// The Rootserver executeable. Runs the Rootserver from c32rootsrv.dll.

// 

//

/**

 @file

 @internalComponent

*/

#include <rsshared.h>

#include <cflog.h>

#include <commsdattypesv1_1.h>	// for initialising CommsDat

#include "c32Exe.h"

using namespace RootServer;

#include <comms-infras/commsdebugutility.h>

__CFLOG_STMT(_LIT8(KLogSubSysRS, "RootServer");) // subsystem name

CCommsProviderModule* CC32ProviderModule::NewL(CRootServer* aRootServer, 

									const TRSStartModuleParams& aParams, 

								   	HBufC8* aIniData)

    /** Creates a new instance of a CPM.

	 @param aRootServer The root server object

	 @param aParams The data used to load the module

	 @param aIniData The initialisation data for the module

     */

    {

    CC32ProviderModule* pCPM = new (ELeave) CC32ProviderModule();

    CleanupStack::PushL(pCPM);

    pCPM->ConstructL(aRootServer, aParams, aIniData);

    CleanupStack::Pop(pCPM);

    return pCPM;

    }

TInt CC32ProviderModule::CreateModuleThread(const TDesC& aName, TThreadFunction aOtherThreadFunction,

						TInt aStackSize, RHeap* aHeap, TAny* aModuleArgs)

    {

    return iRCFThread.Create(aName, aOtherThreadFunction, aStackSize, aHeap, aModuleArgs);

    }

CRootServer* CC32RootServer::NewL(const TRootServerStartupInfo& aRootServerStartupInfo)

    /** Create new rootserver instance.

     This is the only way of instantiation

     @internalComponent

     @param aRootServerStartupInfo Information containing name of the server and priority of the server active object.

     */

    {

    CC32RootServer* pS=new (ELeave) CC32RootServer(aRootServerStartupInfo.iPriority);

    CleanupStack::PushL(pS);

	pS->iCommsProviderModuleCtorL = CC32ProviderModule::NewL;

    pS->ConstructL(aRootServerStartupInfo);

	// Now that we're guaranteed to be a singleton initialise CommsDat

	__CFLOG(KLogSubSysRS, KLogCode, _L8("RunRootServer - Initializing Commsdat"));

	CommsDat::CMDBSession* ptrCommsdatSession = NULL;

	TRAPD(result, ptrCommsdatSession = CommsDat::CMDBSession::NewL(KCDVersion1_2));

	if (result == KErrNone)

		{

		result = ptrCommsdatSession->PublishProperties();

		if(result != KErrNone)

			{

			__CFLOG_1(KLogSubSysRS, KLogCode, _L8("RunRootServer - Error %d in CMDBSession::PublishProperties"), result);

			}

		delete ptrCommsdatSession;

		}

	else

		{

		__CFLOG_1(KLogSubSysRS, KLogCode, _L8("RunRootServer - Error %d creating Commsdat object"), result);

		}

	__CFLOG(KLogSubSysRS, KLogCode, _L8("RunRootServer - Commsdat initialized"));

    CleanupStack::Pop(pS);

    return pS;

	}

CC32RootServer::~CC32RootServer()

    {

#ifdef SYMBIAN_ZERO_COPY_NETWORKING    

	iCommsBufPond.Close();

#else

	delete iMBufManager;

#endif // SYMBIAN_ZERO_COPY_NETWORKING	

    }

#ifdef _DEBUG

TInt CC32RootServer::RunError(TInt aError)

	{

	__CFLOG_1(KLogSubSysRS, KLogCode, _L8("CRootServer::RunError:%d" ), aError);

	return aError;

	}

#endif // _DEBUG

TInt CC32RootServer::AdjustMBufPool(const TRSSetMBufMnr &aMBufParamsPckg)

    /** Adjust the buffer pool size.

  	 Doesn't actually adjust the pool, can only be called when there

     is no pool instantiated. If a pool is already instantiated, returns KErrInUse.

	 @internalComponent

     @param aBufPoolSize The new size of the buffer pool in bytes.

     @return An error code

     */

    {

    const TRSSetMBufMnrContainer &mbufParams = aMBufParamsPckg();

    __CFLOG_2(KLogSubSysRS, KLogCode, _L8("CRootServer - AdjustMBufPool to %d Init and %d Max."),

     mbufParams.iInitSize, mbufParams.iMaxSize);

    // Can't do this if it is already in use

    if(CpmCount()>0)

        return KErrInUse;

#ifndef SYMBIAN_ZERO_COPY_NETWORKING  

   if(iInitMBufPoolSize == mbufParams.iInitSize && iMaxMBufPoolSize == mbufParams.iMaxSize)

      {

	  return KErrNone;

      }

	  // Finally register new size.

	  iInitMBufPoolSize = mbufParams.iInitSize;

	  iMaxMBufPoolSize = mbufParams.iMaxSize;

	  // Delete MBufManager, it will be lazy loaded with new value when needed

	  if(iMBufManager!=NULL)

	  	{

 		delete iMBufManager;

	    iMBufManager=NULL;

        }

#endif // SYMBIAN_ZERO_COPY_NETWORKING

    return KErrNone;    

    }

TInt CC32RootServer::AdjustMBufSizeAllocInfo(const TRSAddMBufAllocInfo &aMBufParamsPckg)

    /** Adjust (aka add) the mbuf size alloc info

	 @internalComponent

     @param aBufPoolSize The new size of the buffer pool in bytes.

     @return An error code

     */

    {

	const TRSAddMBufAllocInfoContainer &mBufAllocSizeInfo = aMBufParamsPckg();

	__CFLOG_4(KLogSubSysRS, KLogCode, _L8("CRootServer::AdjustMBufSizeAllocInfo() - mbufSize=%d initialAlloc=%d minGrowth=%d growthThreshold=%d"),

		mBufAllocSizeInfo.iMBufSize, mBufAllocSizeInfo.iInitialAllocation, mBufAllocSizeInfo.iMinGrowth, mBufAllocSizeInfo.iGrowthThreshold);

    // store params - they will be retrieved  set during the lazy load

	return iMBufSizeAllocInfo.Append(mBufAllocSizeInfo);

    }

void CC32RootServer::LazyLoadL()

    /** Instantiate the MBuf Manager.

     If the MBufManager is not already running, then create a new

     instance of it.

	 @internalComponent

     */

    {

#ifdef SYMBIAN_ZERO_COPY_NETWORKING    

    if(TCommsBufPondTLSOp::Get().IsNull())

        {

        __CFLOG_0(KLogSubSysRS, KLogCode, 

        	_L8("CRootServer - Lazy loading CommsBuf Pond."));

			RArray<TCommsBufPoolCreateInfo> bufPoolCreateInfoArray;

			// configure the mbuf size allocation info

			for (int i=0; i < iMBufSizeAllocInfo.Count(); i++)

				{

				TRSAddMBufAllocInfoContainer &allocInfo = iMBufSizeAllocInfo[i];

				__CFLOG_4(KLogSubSysRS, KLogCode,

					_L8("CRootServer::LazyLoadMBufManagerL(); - about to add mbuf size alloc info - mbufSize=%d initialAlloc=%d minGrowth=%d growthThreshold=%d"),

					allocInfo.iMBufSize, allocInfo.iInitialAllocation,

					allocInfo.iMinGrowth, allocInfo.iGrowthThreshold);

					TCommsBufPoolCreateInfo createInfo;

					createInfo.iBufSize = allocInfo.iMBufSize;

					createInfo.iInitialBufs = allocInfo.iInitialAllocation;

					createInfo.iGrowByBufs = allocInfo.iMinGrowth;

					createInfo.iMinFreeBufs = allocInfo.iGrowthThreshold;

					createInfo.iCeiling = allocInfo.iPoolCeiling;

					bufPoolCreateInfoArray.AppendL(createInfo);

				}

			User::LeaveIfError(iCommsBufPond.Open(bufPoolCreateInfoArray));

        }

#else

    if(iMBufManager==NULL)

	    {

	    __CFLOG_2(KLogSubSysRS, KLogCode, 

	    _L8("CRootServer - Lazy loading MBuf Manager. %d initial bytes - can grow to %d bytes."),

		iInitMBufPoolSize,iMaxMBufPoolSize);

		iMBufManager = CMBufManager::NewL(iMaxMBufPoolSize, iMBufSizeAllocator);

		if (iMBufSizeAllocator)

	        {

	        // configure the mbuf size allocation info

			for (int i=0; i < iMBufSizeAllocInfo.Count(); i++)

		        {

		        TRSAddMBufAllocInfoContainer &allocInfo = iMBufSizeAllocInfo[i];

		        __CFLOG_4(KLogSubSysRS, KLogCode,

	            _L8("CRootServer::LazyLoadMBufManagerL(); - about to add mbuf size alloc info - mbufSize=%d initialAlloc=%d minGrowth=%d growthThreshold=%d"),

				allocInfo.iMBufSize, allocInfo.iInitialAllocation,

		        allocInfo.iMinGrowth, allocInfo.iGrowthThreshold);

	            iMBufSizeAllocator->AddL(allocInfo.iMBufSize, allocInfo.iInitialAllocation,

	            allocInfo.iMinGrowth, allocInfo.iGrowthThreshold);

				}

			iMBufSizeAllocator->Commit();

		    }

			iMBufSizeAllocInfo.Close();

		}

#endif // SYMBIAN_ZERO_COPY_NETWORKING        

    }

TBool CC32RootServer::IsCallerConfigurator(const CRootServerSession* aSession, const RMessage2& aMessage)

	/** If The Configurator has been determined then any other session asking isn't. Otherwise the 

	first configurator process to ask becomes The Configurator. Note that this would fail if The

	Configurator opened a second session, but it doesn't (and it's internalTech)

	*/

	{

	if(!iTheConfiguratorSession)

		{

		RThread client;

		TInt err = aMessage.Client(client);

		if(err == KErrNone)

			{

			static _LIT_SECURITY_POLICY_S1(configuratorPolicy, KUidC32StartProcess, ECapabilityProtServ);

			if(configuratorPolicy.CheckPolicy(client))

				{

				iTheConfiguratorSession = aSession;

				}

			client.Close();

			}

		}

	return iTheConfiguratorSession == aSession;

	}

void CC32RootServer::DisconnectSession(const CRootServerSession* aSession)

	{

	if(iTheConfiguratorSession == aSession)

		{

		iTheConfiguratorSession = NULL;

		}

	}    

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

    /** Create new session object.

     @internalComponent

     */

    {

    __CFLOG(KLogSubSysRS, KLogCode,_L8("CC32RootServer - NewSession"));

    TVersion v(TVersion(KRS32MajorVersionNumber,KRS32MinorVersionNumber,KRS32BuildVersionNumber));

    TBool r = User::QueryVersionSupported(v, aVersion);

    if (r==EFalse)

        User::Leave(KErrNotSupported);

    CC32RootServerSession* p = new(ELeave) CC32RootServerSession(this);

    return p;

    }

CC32RootServerSession::CC32RootServerSession(const CRootServer* aRootServer):CRootServerSession(aRootServer)

	{

	}

CC32RootServerSession::~CC32RootServerSession()

	{

	}

void CC32RootServerSession::ServiceL(const RMessage2& aMessage)

	{

    TInt result = KErrGeneral;

    TBool completeNow = ETrue;

    switch ((aMessage.Function()))

		{

		case RSSetMBufPoolSize:

			result = SetMBufPoolSize(aMessage);

			break;

		case RSAddMBufAllocInfo:

			result = AddMBufAllocInfo(aMessage);

			break;

		case RSIsCallerConfigurator:

			result = IsCallerConfigurator(aMessage);

			break;			

		case RSDbgFailNextMbuf:

		case RSDbgSetMbufPoolLimit:

		case RSDbgCheckMbuf:

		case RSDbgMbufFreeSpace:

		case RSDbgMbufTotalSpace:

			result = KErrNotSupported;

			break;

		default:

			CRootServerSession::ServiceL(aMessage);

			completeNow = EFalse;

			break;

		}

    if(completeNow)

            {

            aMessage.Complete(result);

            }

	}

TInt CC32RootServerSession::IsCallerConfigurator(const RMessage2& aMessage)

	{

	return (TInt) iRootServer->IsCallerConfigurator(this, aMessage);

	}

TInt CC32RootServerSession::SetMBufPoolSize(const RMessage2& aMessage)

    {

    // Do the dirty business and return the result

    TInt ret;

    TRSSetMBufMnr params;

    ret = aMessage.Read(0,params);

    if (ret != KErrNone)

    	{

    	return ret;

    	}

    return (static_cast <CC32RootServer*> (iRootServer))->AdjustMBufPool(params);

    }

// set the mbuf size allocation information

TInt CC32RootServerSession::AddMBufAllocInfo(const RMessage2& aMessage)

    {

    TRSAddMBufAllocInfo params;

    TInt ret = aMessage.Read(0, params);

    if (ret != KErrNone)

    	{

    	return ret;

    	}

    return (static_cast <CC32RootServer*> (iRootServer))->AdjustMBufSizeAllocInfo(params);

    }

TInt E32Main()

/** Life starts here. ONly purpose is to run RunRootServer() from c32rootsrv.dll

*/

    {

	__FLOG_DECLARATION_VARIABLE;

	__FLOG_STMT( _LIT8( KRSLogSubSys, "RootServer" ) );

	__FLOG_STMT( _LIT8( KRSLogComp, "event" ) );

	__FLOG_OPEN( KRSLogSubSys, KRSLogComp );  

	__FLOG( _L8("C32exe.exe - E32Main calling RunRootServer in DLL") );

	__FLOG_CLOSE;

 	TRootServerStartupInfo info;

 	info.iPriority = CActive::EPriorityStandard;

 	info.iServerName = KRootServerName;

 	info.iRootServerCtor = CC32RootServer::NewL;

 	info.iDeathKey = KUidC32RootModuleDeathKey;

	info.iLeakKey.iUid = KUidCommsModuleLeakCounter;

	info.iProcessKey = KUidCommsProcess;

	return RunRootServer(info); // Load Root Server. Blocks by starting the active scheduler

    }