/*

* Copyright (c) 2002 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 for the CDosServer class

*

*/

#include <e32svr.h>

#include <f32file.h>

#include "dosserver.h"

#include "doseventmanager.h"

#include "dosfactorybase.h"

#include "dossession.h"

#include "dos_debug.h"

#include <data_caging_path_literals.hrh>

/*******************************************************

*  DEFINITION OF THE DSY TO BE USED BY THIS DOS SERVER *

********************************************************/

// This file tells the name of the DSY -module to be loaded.

_LIT(KDosServerIniFile,"Z:\\private\\101f6efa\\DosServer.ini");

// The path where the DSY-module binary must recide. This is hardcoded for

// security reasons.

_LIT(KDSYBinaryLocDrive, "z:");

//

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

// CDosServer Constructor

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

//  

CDosServer::CDosServer()

    : CPolicyServer( CActive::EPriorityStandard, KDosServerPolicy )

{

	iSessionCount=0;

	iContainerIx = NULL;

	iDosFactory = NULL;

	iLibLoaded = EFalse;

	iCurrentFreeDiskSpaceRequest = NULL;

}

//

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

// CDosServer Desctructor

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

//  

CDosServer::~CDosServer()

{

	COM_TRACE_( "[DOSSERVER]\t CDosServer::~CDosServer()" );

	// Delete our own stuff

	delete iEventManager;

	//We delete here all the open Sessions

	//This is done also by ~CServer but we do it here because it must be done before

	//deleting iContainerIx since iContainerIx will try to delete the CObjects that are

	//referenced by the Session's containers

	CDosSession* session=NULL;

	iSessionIter.SetToFirst();

	while((session = (CDosSession*)(iSessionIter++)) != NULL)

	{

		delete session;

	}

	if ( iFileSystemNotifier )

        {

        COM_TRACE_( "CDosServer::~CDosServer(), deleting iFileSytemNotifier" );

        iFileSystemNotifier->Cancel();

        delete iFileSystemNotifier;

        }

	delete iDosFactory;

	delete iContainerIx;

	COM_TRACE_( "[DOSSERVER]\t CDosServer::~CDosServer() - end" );

	//Check if RLibrary::Load() has been called

	if (iLibLoaded) 

	{

		iLib.Close();

		iLibLoaded = EFalse;

	}

    if ( iSaeThread )

    {

    delete iSaeThread;

    }

}  

//

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

// CDosServer::ConstructL

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

//  

void CDosServer::ConstructL()

{

	User::RenameThread(KDosServerName);

    // set this as a system thread so if it crashes the phone will restart

	User::SetCritical(User::ESystemCritical);

	COM_TRACE_( "CDosServer::ConstructL(), creating iFileSytemNotifier" );

    iFileSystemNotifier = CSharedDataFileSystemNotifier::NewL(*this);

	iEventManager = CDosEventManager::NewL();

	LoadDsyModuleL();

	iContainerIx = CObjectConIx::NewL();

	StartL(KDosServerName);

    iSaeThread = CSaeThread::NewL();

    iSaeThread->StartThreadL();

}

//

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

// CDosServer::NewL

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

//  

CDosServer* CDosServer::NewL()

{

    CDosServer* self=new(ELeave) CDosServer;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

//

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

// CDosServer::LoadDsyModuleL

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

//  

void CDosServer::LoadDsyModuleL()

{

	COM_TRACE_( "[DOSSERVER]\t CDosServer::LoadDsyModuleL()" );

	//Finding out the name of the Dsy file.

	RFs fs;

	RFile file;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	COM_TRACE_( "[DOSSERVER]\t CDosServer::LoadDsyModuleL() - fs connected" );

	COM_TRACE_( "[DOSSERVER]\t Opening file: Z:\\system\\data\\DosServer.ini" );

	COM_TRACE_( "[DOSSERVER]\t error occurs if above file is missing from build!" );

	User::LeaveIfError(file.Open(fs,KDosServerIniFile,EFileRead));

	CleanupClosePushL(file);

	COM_TRACE_( "[DOSSERVER]\t CDosServer::LoadDsyModuleL() - file opened" );

	TBuf8<KMaxFileName> rawFileName;

	User::LeaveIfError(file.Read(rawFileName));

	CleanupStack::PopAndDestroy(2); //fs and file are closed

	COM_TRACE_( "[DOSSERVER]\t CDosServer::LoadDsyModuleL() - file readed" );

	HBufC* unicodeFileName = HBufC::NewLC(rawFileName.Length());

	TPtr fileNamePtr(unicodeFileName->Des());

	fileNamePtr.Copy(rawFileName);

	COM_TRACE_1( "[DOSSERVER]\t CDosServer::LoadDsyModuleL() - name: %S", unicodeFileName );

	//Loading of the Dsy module

	TLibraryFunction entryPoint;

	// Check for data caging support;

	// Template parameter defines the maximum length for descriptor. 

	// After copy the length is set to same as the copied descriptor.

	TBuf<128> dsyBinaryLoc(KDC_SHARED_LIB_DIR);

	dsyBinaryLoc.Insert(0, KDSYBinaryLocDrive);

#ifdef _DEBUG // Trace used binary path.

	HBufC* dsyFileName = HBufC::NewLC(dsyBinaryLoc.Length());

	TPtr fNPtr(dsyFileName->Des());

	fNPtr.Copy(dsyBinaryLoc);

	COM_TRACE_1( "[DOSSERVER]\t CDosServer::LoadDsyModuleL() - bin path: %S", dsyFileName );

	CleanupStack::PopAndDestroy(); //dsyFileName

#endif

	User::LeaveIfError(iLib.Load(fileNamePtr, dsyBinaryLoc));

	iLibLoaded = ETrue; //RLibrary::Load() has been called

	entryPoint = iLib.Lookup(1); //Polymorphic DLL only 1 entry point.

	iDosFactory = (CDosFactoryBase *)entryPoint();

	iDosFactory->iEventManager = CONST_CAST(CDosEventManager*,iEventManager);

	CleanupStack::PopAndDestroy(); //unicodeFileName

	COM_TRACE_( "[DOSSERVER]\t CDosServer::LoadDsyModuleL() completed" );

}

//

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

// CDosServer::RunError

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

//  

TInt CDosServer::RunError(TInt aError)

{

	//

	// Handles an error from CDosSession::ServiceL()

	// Report the error to the client

	//

	COM_TRACE_1( "[DOSSERVER]\t CDosServer::RunError() error: %d", aError );

	Message().Complete(aError);

	ReStart();

	return KErrNone;	// handled the error fully

}

//

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

// CDosServer::NewSessionL

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

//  

CSession2* CDosServer::NewSessionL(const TVersion&) const

{

	COM_TRACE_( "CDosServer::NewSessionL()" );

	//

	// Create a new client session.

	//

	return new(ELeave) CDosSession();

}

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

{

	return NewSessionL(aVersion);

}

//

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

// CDosServer::AddSession

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

//  

void CDosServer::AddSession()

{

	//

	// A new session is being created

	//

	++iSessionCount;

	COM_TRACE_1( "[DOSSERVER]\t ** CDosServer - Add session, count: %d", iSessionCount );

}

//

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

// CDosServer::DropSession

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

//  

void CDosServer::DropSession()

{

	//

	// A session is being destroyed

	//

    iSessionCount--;

	COM_TRACE_1( "[DOSSERVER]\t ** CDosServer - Drop session, count: %d", iSessionCount );

}

//

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

// CDosServer::ThreadStart

//

// It Starts the Server's Thread and the Server

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

//  

EXPORT_C TInt CDosServer::ThreadStart( CDosServer::TSignal& /*aSignal*/ )

{

    // Get thread that started us

	__UHEAP_MARK;

	TInt err(KErrNone);

    CTrapCleanup* cleanup = NULL;

    CActiveScheduler* scheduler = NULL;

    CDosServer* server = NULL;

	TInt srvErr=KErrNoMemory;

    cleanup = CTrapCleanup::New();

    scheduler = new CActiveScheduler;

    if ( cleanup && scheduler )

    {

        CActiveScheduler::Install( scheduler );

        TRAP(srvErr, server = CDosServer::NewL());      // adds server in scheduler

    }

    if ( !cleanup || !scheduler || srvErr!=KErrNone )

    {

        if ( scheduler ) 

		{

			delete scheduler;

			scheduler = NULL;

		}

		if ( server )

		{

			delete server;

			server = NULL;

		}

		if ( cleanup )

		{

	        delete cleanup;

			cleanup = NULL;

		}

        err = srvErr;

    }

    // signal that we've started

	COM_TRACE_( "CDosServer::ThreadStart - calling SignalClient()" );

	SignalClient();

    if ( err == KErrNone )

    {

        // start fielding requests from clients

        CActiveScheduler::Start();

        // comes here if server gets shut down

        delete scheduler;

		scheduler = NULL;

        delete server;

		server = NULL;

        delete cleanup;

		cleanup = NULL;

    }

    // thread/process exit

	__UHEAP_MARKEND;

    return err;

}

//

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

// CDosServer::SignalClient

//

// Signal client we've started.

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

//  

void CDosServer::SignalClient()

{

	COM_TRACE_( "[DOSSERVER]\t CDosServer::SignalClient() called" );

	RSemaphore startupSemaphore;

	if ( startupSemaphore.OpenGlobal( KServerStartupSemaphoreName ) == KErrNone )

	{

		//Signal the client:The server might have started up successfully or not

		startupSemaphore.Signal();

		COM_TRACE_( "[DOSSERVER]\t CDosServer::SignalClient() semaphore signalled" );

	}

	startupSemaphore.Close();

	COM_TRACE_( "[DOSSERVER]\t CDosServer::SignalClient() semaphore closed" );

	// No point to return any error; 

	// if signal client fails, startup will freeze anyway.

}

//

// RMessage::Panic() also completes the message. This is:

// (a) important for efficient cleanup within the kernel

// (b) a problem if the message is completed a second time

//

void PanicClient(const RMessage2& aMessage,TDosPanic aPanic)

{

	COM_TRACE_( "[DOSSERVER]\t CDosServer::RMessage::PanicClient() called" );

	aMessage.Panic(KDosServerName,aPanic);

}

//

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

// CDosServer::CurrentDiskFreeSpace

//

// Returns current disk space

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

//  

TInt* CDosServer::CurrentFreeDiskSpaceRequest()

{

    COM_TRACE_( "CDosServer::CurrentFreeDiskSpaceRequest()" );

    return iCurrentFreeDiskSpaceRequest;    

}

//

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

// CDosServer::SetCurrentFreeDiskSpace

//

// Sets new current disk space

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

//  

void CDosServer::SetCurrentFreeDiskSpaceRequest(TInt* diskSpace)

{

 COM_TRACE_( "CDosServer::SetCurrentFreeDiskSpaceRequest()" );

    iCurrentFreeDiskSpaceRequest = diskSpace;    

}