/*

* Copyright (c) 2007-2008 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:  Implementation of CWsfServer

*

*/

//  CLASS HEADER

#include "wsfserver.h"

//  INTERNAL INCLUDES

#include "wsfengine.h"

#include "wsfsession.h"

#include "wsfservercommon.h"

#include "wsflogger.h"

//  LOCAL DEFINITIONS

/**

* Number of security ranges

*/

static const TInt KRangeCount = 1;

/**

* Security ranges

*/

static const TInt KSecurityRanges[KRangeCount] = 

	{

	0,

	};

/**

* Policy for the security ranges

*/	

static const TUint8 KSecurityRangesPolicy[KRangeCount] =

	{

	CPolicyServer::ECustomCheck

	};

/**

* The complete policy structure

*/

static const CPolicyServer::TPolicy KPolicy =

	{

	CPolicyServer::EAlwaysPass,

	KRangeCount,

	KSecurityRanges,

	KSecurityRangesPolicy,

	NULL,

	};

/**

* Secure ID of the Active Idle (ailaunch.exe)

*/

static _LIT_SECURE_ID( KSidActiveIdle, 0x102750F0 );

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

// CWsfServer::NewLC

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

//

CWsfServer* CWsfServer::NewLC()

	{

	CWsfServer* snifferServer = new (ELeave) CWsfServer( 

	                                                  CActive::EPriorityHigh );

	CleanupStack::PushL( snifferServer );

	snifferServer->ConstructL();

	snifferServer->StartL( KWlanSnifferServerName );

	return snifferServer;

	}

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

// CWsfServer::NewSessionL

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

//

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

                                    const RMessage2& /*aMessage*/) const

	{

	LOG_ENTERFN( "CWsfServer::NewSessionL" );

	// check we're the right version

	TVersion v( KWlanSnifferServerMajor, 

	            KWlanSnifferServerMinor, 

	            KWlanSnifferServerBuild );

	if ( !User::QueryVersionSupported( v, aVersion ) )

	    {

	    User::Leave( KErrNotSupported );

	    }

	// make new session

	CSession2* newSession = CWsfSession::NewL( 

	                                        const_cast<CWsfServer&>( *this ) );

	return newSession;

	}

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

// CWsfServer::CWsfServer

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

//

CWsfServer::CWsfServer( TInt aPriority ): 

    CPolicyServer( aPriority, KPolicy ),

	iClientCount( 0 )

	{

	}

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

// CWsfServer::~CWsfServer

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

//

CWsfServer::~CWsfServer()

	{

	delete iCloser;

	delete iEngine;

	}	

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

// CWsfServer::ConstructL

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

//

void CWsfServer::ConstructL()

	{

	iCloser = CWsfServerCloser::NewL();

	iEngine = CWsfEngine::NewL( *iCloser );

	// start the closing up procedure

	// so we won't be left running if no clients would appear

	iCloser->WaitForClients( EFalse );

	}

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

// CWsfServer::ClientRelease

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

//

void CWsfServer::ClientRelease()

	{

	LOG_ENTERFN( "CWsfServer::ClientRelease" );

	--iClientCount;

	// even if there are no clients, we might need to keep the server alive

	// to maintain the connection or clean up IAPs properly

	if ( !iClientCount )

		{

		// The last client is released.

        // Iap deletion must not suppress anymore. Make sure the flag is off.

        iEngine->ResetSuppressIapDeletion();

		// From this point on, the server is kept alive to wait for connection notifications if necessary. 

		// E.g. browser could be launched by sniffer and WLAN connection still exists after sniffer shut down, 

		// server waits for connection lost callback and cleans up temporary IAPs when connection is closed. 

	    // If no connections are available, make sure the the server is NOT kept alive to wait

	    // browser exit, because the server is not set to monitor those notifications directly. 

		if( !iEngine->IsConnected() )

		    {

		    iCloser->WaitForBrowserExit( EFalse );

		    }

		iCloser->WaitForClients( EFalse );

		}

	}

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

// CWsfServer::ClientAttach

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

//

void CWsfServer::ClientAttach()

	{

	LOG_ENTERFN( "CWsfServer::ClientAttach" );

	iCloser->Cancel();

	++iClientCount;

	iCloser->WaitForClients( ETrue );

	}

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

// CWsfServer::Engine

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

//

CWsfEngine* CWsfServer::Engine()

	{

	return iEngine;

	}	

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

// CWsfServer::RunServer

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

//

TInt CWsfServer::RunServer()

	{

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TInt ret = KErrNoMemory;

	if ( cleanup )

		{

		TRAP( ret, CWsfServer::RunServerL() );

		delete cleanup;

		}

	if ( ret != KErrNone )

		{

		// Signal the client that server creation failed

		RProcess::Rendezvous( ret );

		}

	return KErrNone;

	}

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

// CWsfServer::RunServerL

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

//

void CWsfServer::RunServerL()

	{

	// Create and install the active scheduler we need

	CActiveScheduler *as = new (ELeave) CActiveScheduler;

	CleanupStack::PushL( as );

	CActiveScheduler::Install( as );

	// Create server

	CWsfServer::NewLC();

	// Initialisation complete, now signal the client

	User::LeaveIfError( RThread().RenameMe( KWlanSnifferServerName ) );

	RProcess::Rendezvous( KErrNone );

	// Ready to run

	CActiveScheduler::Start();

	// Cleanup the server and scheduler

	CleanupStack::PopAndDestroy( 2, as );

	}

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

// CWsfServer::RunError

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

//

TInt CWsfServer::RunError( TInt /*aError*/ )

	{

	return KErrNone;

	}

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

// CWsfServer::E32Main

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

//

TInt E32Main()

	{

	TInt error( KErrNone );

	error = CWsfServer::RunServer();

	return error;

	}

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

// CWsfServer::CustomSecurityCheckL

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

//

CPolicyServer::TCustomResult CWsfServer::CustomSecurityCheckL( 

                                                const RMessage2& aMsg, 

                                                TInt& /*aAction*/, 

                                                TSecurityInfo& /*aMissing*/ )

	{	

	TCustomResult ret = EFail;

	switch ( aMsg.Function() )

        {

        // NULL CAPABILITIES

        case ESnifferCmdNotifyEvents:

        case ESnifferCmdCancelNotifyEvents:

        case ESnifferCmdIsScanEnabled:

        case ESnifferCmdCancelAll:

        case ESnifferCmdConnectionName:	

        case ESnifferCmdIsConnected:

        case ESnifferCmdMonitorAp:

            {

        	ret = EPass;

        	break;

            }        	

        // CAPABILITY NEEDED

        case ESnifferCmdActivateScan:

        case ESnifferCmdDisableScan:

        case ESnifferCmdWlanDataSize:

        case ESnifferCmdGetWlanInfo:

        case ESnifferCmdConnectedDetails:

        case ESnifferCmdConnect:

        case ESnifferCmdDisconnect:

        case ESnifferCmdRequestScan:

        case ESnifferCmdAbortScanning:

        case ESnifferCmdAbortConnecting:

        case ESnifferCmdSetIapPersistence:

        case ESnifferCmdControlDisconnectTimer:

            {

        	// if it is called from ailaunch.exe

        	// disgusting workaround

            if ( aMsg.SecureId() == KSidActiveIdle )

            	{

            	ret = EPass;

            	}

            else

            	{

           		ret = ( aMsg.HasCapability( ECapabilityNetworkServices ) && 

           		        aMsg.HasCapability( ECapabilityNetworkControl ) )? 

        			        EPass : EFail;

        		}

        	break;

            }

        default:

            {

        	ret = EPass;

        	break;

            }

        }

	return ret;

	}