/*
* 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:  
* Main log server engine.
* Process log requests from multiple clients simultaneously.
*
*/



/**
 @file server.cpp
*/
#include "server.h"
#include <unistd.h>
#include <fcntl.h>

CLogServer* CLogServer::NewL()
/**
 * @return - Instance of the log server
 */
	{
	CLogServer * server = new (ELeave) CLogServer();
	CleanupStack::PushL(server);
	server->ConstructL();
	// CServer base class call
	server->StartL(KTestExecutePIPSLogServerName);
	CleanupStack::Pop(server);
	return server;
	}

void CLogServer::ConstructL()
/**
 * Second phase construction
 */
	{
	}


CLogServer::CLogServer() : CServer2(EPriorityStandard,ESharableSessions)
/**
 * Constructor
 */
	{
	}

CLogServer::~CLogServer()
/**
 * Destructor
 */
	{
	// Close the array of control structures
	LogControl().Close();
	//Fs().Close();
	}


CSession2* CLogServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const
/**
 * @param RMessage - RMessage for the session open
 */
	{
	// Just create the session
	CLogSession* session = new (ELeave) CLogSession();
	return session;
	}

void CLogServer::ControlComplete(CLogSession& aControl)
/**
 * @param aControl - Logfile control class reference
 *
 * Checks to see if this control session can be removed 
 */
	{
	if(aControl.SessionCount())
		return;

	// There are no subsessions mapped to the logfile control class and
	// no data buffers on its write queue
	// Loop through the server's control array and remove it then delete it
	TInt i;
	for(i=0;i<LogControl().Count();i++)
		{
		if(&aControl == LogControl()[i])
			{
			// Done
			LogControl().Remove(i);
			delete &aControl;
			break;
			}
		}
	// If it's the last one then exit the server
	if(!LogControl().Count())
		CActiveScheduler::Stop();
	}


///////

CLogSession::CLogSession()
:iFileDes(-1)
/**
 * Constructor
 */
	{
	}

CLogSession::~CLogSession()
/**
 * Destructor
 */
	{
	// Check for null
	// Session close without a createlog call leaves iControl null
	// A logfile control structure can have multiple server sessions
	// decrement its server session count
	RemoveSession();
	CLogServer* p=(CLogServer*) Server();
	// Shuts Down the server if this is the last open session
	p->ControlComplete(*this);
	}

void CLogSession::ServiceL(const RMessage2& aMessage)
/**
 * @param aMessage - Function and data for the session
 */
	{
	switch(aMessage.Function())
		{
//		case RTestExecutePIPSLogServ::ECreateLog :
//			{}
		// One of the API write calls
		case RTestExecutePIPSLogServ::EWriteLog :
			{
			// Data can be any size
			// Get the length from second argument
			TInt bufferLength = aMessage.Int1();
			// Get a heap buffer of the right size
			HBufC8* buffer = HBufC8::NewLC(bufferLength);
			TPtr8 ptr(buffer->Des());
			// read the data
			aMessage.ReadL(0,ptr);			
			// Get a buffer control class contructed with the heap data
			// takes ownership
			//CLogBuffer* logBuffer = new (ELeave) CLogBuffer(*buffer);
			CleanupStack::Pop(buffer);
			//get the name of the pipe we want to dump the logs to
			TInt pipeNameLen = aMessage.Int3();
			// Get a heap buffer of the right size
			HBufC8* pipebuffer = HBufC8::NewLC(pipeNameLen);
			TPtr8 pipePtr(pipebuffer->Des());
			// read the data
			aMessage.ReadL(2,pipePtr);			
			// Get a buffer control class contructed with the heap data
			// takes ownership
			CleanupStack::Pop(pipebuffer);
			
			if((iFileDes == -1)  || (!iPipeName ) || (iPipeName->CompareF(pipePtr))  )
				{
				iPipeName = new TPtr8(pipePtr) ; 
				//iPipeName.Set(pipePtr) ;  
				
				char arr[KMaxPath];
				int var;
				for (var = 0; var < pipePtr.Length(); ++var) {
					arr[var]=pipePtr[var];
				}
				arr[var]='\0';
				
				iFileDes = open( arr, O_WRONLY);
				}
			
			const char *printsomething = (const char *)ptr.Ptr() ;
			// incases when the pipe name given was empty / incorrect
			// or unavailable for some reason, the open is expected
			// to return -1, and then we do nothing
			if(iFileDes != -1 ) 
				{
				write(iFileDes , printsomething, bufferLength) ; 
				aMessage.Complete(KErrNone);
				}
			else
				{
				aMessage.Complete(KErrNotFound);
				}
			// apparently closing the pipe is an issue with named pipes
			// so let be for now
			//close(aFileDes); 
			}
			break;

		default:
			break;
		}
	}