// Copyright (c) 2006-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:
// server side exmaple of how to use the abstract server framework
// 
//

#include <e32debug.h>
#include "lbsdevloggermacros.h"

#include "lbsnrhprivacycontrollerserver.h"
#include "lbsnrhx3pserver.h"
#include "opensessionparams.h"
#include "lbsnrhserverdata.h"
#include "lbsnrhmessageenums.h"

const TInt KLbsLogQueueSize = 30;

//
// Security policy data structures
//

const TUint myRangeCount = 7;

const TInt myRanges[myRangeCount] = 
    {
    0, //range is 0-1 inclusive
    ESecureSubSessionBaseClose, //range is 2 to (ENrhPrivacyControllerSubSessionFirstMessageId - 1)
    ENrhPrivacyControllerRegister, // Register a MLbsPrivacyObserver for callbacks
    ENrhPrivacyControllerResponse, // All other CLbsPrivacyController functions
    ENrhPrivacyControllerSubSessionLastMessageId,  // Range between last privacy handler message
    											   // and first X3P message.
    EX3pSubSessionFirstMessageId,	// All X3P messages
    EX3pSubSessionLastMessageId	// Remaining messages.
    };
const TUint8 myElementsIndex[myRangeCount] = 
    {
    CPolicyServer::ECustomCheck,
    CPolicyServer::ENotSupported,
    0,
    1,
    CPolicyServer::ENotSupported,
    2,
    CPolicyServer::ENotSupported
    };
    
const CPolicyServer::TPolicyElement myElements[] = 
    {
    {_INIT_SECURITY_POLICY_C2(ECapabilityLocation, ECapabilityReadDeviceData), CPolicyServer::EFailClient},
    {_INIT_SECURITY_POLICY_C2(ECapabilityLocation, ECapabilityWriteDeviceData), CPolicyServer::EFailClient},
    {_INIT_SECURITY_POLICY_C2(ECapabilityLocation, ECapabilityNetworkServices), CPolicyServer::EFailClient}
    };
    
const CPolicyServer::TPolicy myPolicy =
    {
    CPolicyServer::EAlwaysPass, //specifies all connect attempts should pass
    myRangeCount,                   
    myRanges,
    myElementsIndex,
    myElements,
    };

//
// Server Framework Function Implementations
//

MCreateServerImpl* CSecureASBase::GetImplLC()
	{
	CNrhServerImpl* impl = new(ELeave) CNrhServerImpl();
	CleanupStack::PushL(impl);
	return impl;
	}

void CNrhServerImpl::CreateServerLC(TServerStartParams& aParams)
	{
	CNrhServer* s = new(ELeave) CNrhServer(CActive::EPriorityStandard, myPolicy);
	CleanupStack::PushL(s);
	s->ConstructL(aParams.GetServerName());
	// leave the server object on the CS
	}
	
//
// CNrhServer
//

RLbsLogger CNrhServer::iLogger;

CNrhServer::CNrhServer(TInt aPriority, const CPolicyServer::TPolicy& aSecurityPolicy) 
:	CSecureServerBase(aPriority, aSecurityPolicy),
	iVersion(KNrhServerMajorVersionNumber,
			 KNrhServerMinorVersionNumber,
			 KNrhServerBuildVersionNumber)
	{		
	}
	
CNrhServer::~CNrhServer()
	{
	iLogger.Close();
	
	iX3pObserver = NULL;
	iPrivacyObserver = NULL;

	delete iNetworkRequestHandler;
	delete iCloseDownRequestDetector;
	}
	
void CNrhServer::ConstructL(const TDesC& aServerName)
	{			
	StartL(aServerName);
	BaseConstructL(EFalse); // MUST BE CALLED. No shutdown timer. Makes the NRH a perm. server	
	
    // Create the monitor which detects a closedown signal from
    // the LBS Root Process.
    iCloseDownRequestDetector = CLbsCloseDownRequestDetector::NewL(
    								this, 
									KLbsNetRequestHandlerUid);

	iNetworkRequestHandler = CLbsNetworkRequestHandler::NewL(this);	
	
	iLogger.Open(KLbsLogQueueSize);
	}
	
CSession2* CNrhServer::DoNewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const
	{
	return new (ELeave) CNrhServerSession(); // version number already checked at this point
	}
	
	
TVersion CNrhServer::GetServerVersion() const
	{
	return iVersion;
	}

/**
Security policies used for custom security check below:
*/
static _LIT_SECURITY_POLICY_C1(KLocationPolicy, ECapabilityLocation);
static _LIT_SECURITY_POLICY_C1(KReadDeviceDataPolicy, ECapabilityReadDeviceData);
static _LIT_SECURITY_POLICY_C1(KNetworkServicesPolicy, ECapabilityNetworkServices);


/**
Perform a custom security check.

A custom security check is only needed for the sub-session connect
message. The reason is that the two type of sub-sessions the NRH supports
(X3P and privacy controller) have different PlatSec capabilities to
create them.

@param aMsg The message to check.
@param aAction A reference to the action to take if the security check fails.
@param aMissing A reference to the list of security attributes missing from the checked process.

@return Enum specifying the result of the security check.
*/
CPolicyServer::TCustomResult CNrhServer::CustomSecurityCheckL(const RMessage2 &aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)
	{
	LBSLOG(ELogP1, "CNrhServer::CustomSecurityCheckL() Begin\n");

	TNrhSubSessionType subSessType;
	TPckg<TNrhSubSessionType> subSessTypeBuf(subSessType);
	MessageUtils::Read(aMsg, 0, subSessTypeBuf); // data is always in slot zero
		
	// Capabilities to check depend on the type of sub-session
	CPolicyServer::TCustomResult result(EFail);
	switch (subSessType)
		{
		case ENrhSubSessionPrivacyController:
			{
			if (KLocationPolicy().CheckPolicy(aMsg) 
				&& KReadDeviceDataPolicy.CheckPolicy(aMsg))
				{
				LBSLOG(ELogP1, "CNrhServer::CustomSecurityCheckL() End (PASS)\n");
				result = EPass;
				}
			break;
			}
		case ENrhSubSessionX3P:
			{
			if (KLocationPolicy().CheckPolicy(aMsg) 
				&& KNetworkServicesPolicy().CheckPolicy(aMsg))
				{
				LBSLOG(ELogP1, "CNrhServer::CustomSecurityCheckL() End (PASS)\n");
				result = EPass;
				}
			break;
			}
		case ENrhSubSessionUnknown:
		default:
			{
			LBSLOG(ELogP1, "CNrhServer::CustomSecurityCheckL() End (FAIL)\n");
			result = EFail;
			break;
			}
		}

	return result;
	}

/* Called when LbsRoot has requested that the NRH should 
   closedown.
*/
void CNrhServer::OnProcessCloseDown()
    {
    CActiveScheduler::Stop();
    }
    
MX3pHandlerNotifier* CNrhServer::X3pObserver() const
	{
	return(iX3pObserver);
	}

void CNrhServer::SetPrivacyServerObserver(MPrivacyHandlerObserver* aObserver)
	{
	iPrivacyObserver = aObserver;
	}

MPrivacyHandlerObserver* CNrhServer::PrivacyObserver() const
	{
	return(iPrivacyObserver);
	}

CLbsAdmin* CNrhServer::Admin() const
	{
	return iNetworkRequestHandler->Admin();
	}

RLbsNetworkRegistrationStatus& CNrhServer::NetworkRegistrationStatus()
	{
	return iNetworkRequestHandler->NetworkRegistrationStatus();
	}

void CNrhServer::SetX3pServerObserver(MX3pHandlerNotifier* aObserver)
	{
	iX3pObserver = aObserver;
	}

CNrhServerSession::~CNrhServerSession()
	{
	}
	
// called by the CServer2 code to complete construction of the session 
void CNrhServerSession::CreateL()
	{
	CSecureSessionSubSessionBase::CreateL(); // MUST do this
	}
	
void CNrhServerSession::ServiceMessageL(const RMessage2& /*aMessage*/)
	{
	// Got a message from the client
	}
	
void CNrhServerSession::ServiceMessageError(const RMessage2& /*aMessage*/, const TInt /*aError*/)
	{
	// service leaves from the above in here
	}
	
	
//------------------------------------------------------------------	

MSubSessionImpl* CSubSessionBase::GetImplL(const RMessage2& aMessage)
	{	
	// Read in the subsession type
	TNrhSubSessionType subSessType;
	TPckg<TNrhSubSessionType> subSessTypeBuf(subSessType);
	MessageUtils::Read(aMessage, 0, subSessTypeBuf); // data is always in slot zero
		
	// Create the subsession, depending on the type requested
	MSubSessionImpl* subSession(NULL);
	switch (subSessType)
		{
		case ENrhSubSessionPrivacyController:
			{
			subSession = CNrhPrivacyServerSubsession::NewL();
			break;
			}
		case ENrhSubSessionX3P:
			{
			subSession = CNrhX3pServerSubsession::NewL(CNrhServer::iLogger);
			break;
			}
		case ENrhSubSessionUnknown:
		default:
			{
			_LIT(KPanicNrhServer, "Unknown SubSession Type");
			MessageUtils::PanicClient(aMessage, KPanicNrhServer, 0);
			break;
			}
		}
		
	return subSession;
	}