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

//

#include <e32std.h>

#include <redircli.h>

#include <redircliinternal.h>

#ifndef EKA2

GLDEF_C TInt E32Dll(TDllReason)

	{

	return KErrNone;

	}

#endif

// server name

_LIT(KRedirServerName,"RedirServer");

enum TRedirStream 

	{

	ERedirRead,

	ERedirWrite,

	ERedirFlush

	};

// A version must be specified when creating a session with the server

const TUint KRedirServMajorVersionNumber=1;

const TUint KRedirServMinorVersionNumber=0;

const TUint KRedirServBuildVersionNumber=0;

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

// CRedirSession

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

// This class represents a session in the server.

// Functions are provided to respond appropriately to client messages.

NONSHARABLE_CLASS(CRedirSession) : public CSession2

	{

public:

	static CRedirSession* NewL(CStreamBase2* aStream);

	//service request

	virtual void ServiceL(const RMessage2 &aMessage);

private :

	// construct/destruct

	CRedirSession(CStreamBase2* aStream);

	~CRedirSession();

	//services available to handle read/write requests

	TInt WriteStreamL(const RMessage2& aMessage);

private:

	CStreamBase2* iStream;

	};

// ------------------- CRedirServer2 implementation --------------------------

/**

Constructs and allocates memory for a new CRedirServer2 object.

@return RedirServer

@param aStreamFactory Stream factory.

*/ 

EXPORT_C CRedirServer2* CRedirServer2::NewL(CStreamFactoryBase2* aStreamFactory)

	{

	CRedirServer2* r=new(ELeave) CRedirServer2(aStreamFactory);

	CleanupStack::PushL(r);

	r->StartL(KRedirServerName);

	CleanupStack::Pop();

	return r;

	}

/**

Default constructor

@param aStreamFactory Stream factory.

*/ 

CRedirServer2::CRedirServer2(CStreamFactoryBase2* aStreamFactory)

	: CServer2(EPriority)

	{

	iStreamFactory = aStreamFactory;

	}

/**

Virtual destructor

*/ 	

CRedirServer2::~CRedirServer2()

	{

	}

/**

Create a new server session. 

Checks if the aVersion is the right version and make a new session.

@leave KErrNotSupported

@return Sharable Session for all threads within a single process.

@param aVersion Contains version information.

A version is defined by a set of three numbers:major,minor,build version number

*/

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

	{

	TVersion v(KRedirServMajorVersionNumber,KRedirServMinorVersionNumber,

		KRedirServBuildVersionNumber);

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

		User::Leave(KErrNotSupported);

	// get a stream object from the current stream factory

	CStreamBase2* stream = iStreamFactory->GetStream();

	return CRedirSession::NewL(stream);

	}

/**

Sets the stream factory

@param aStreamFactory a factory to be set

*/

EXPORT_C void CRedirServer2::SetStreamFactory(CStreamFactoryBase2* aStreamFactory) 

	{

	// set the stream factory

	iStreamFactory = aStreamFactory;

	}

// ------------------- CRedirSession2 implementation --------------------------

CRedirSession* CRedirSession::NewL(CStreamBase2* aStream)

	{

	return new(ELeave) CRedirSession(aStream);

	}

CRedirSession::CRedirSession(CStreamBase2* aStream)

	: iStream(aStream)

	{}

CRedirSession::~CRedirSession()

	{

	// The stream returned by GetStream() is effectively a singleton as 

	// implemented in the current redirector, so we leave deletion to

	// the factory

	}

void CRedirSession::ServiceL(const RMessage2& aMessage)

	{

	TInt ret = KErrNone;

	switch (aMessage.Function())

		{

	case ERedirRead:

		// call the Stream to do the read for us

		iStream->Read(aMessage);

		break;

	case ERedirWrite:

		TRAP(ret,WriteStreamL(aMessage));

		aMessage.Complete(ret);

		break;

	case ERedirFlush:

		// TO DO: ignore flushing?

		aMessage.Complete(ret);

		break;

	default:

		aMessage.Complete(KErrNotSupported);

		break;

		}

	return;

	}

TInt CRedirSession::WriteStreamL(const RMessage2& aMessage)

	{

	const TInt KMaxTransfer=256;

	//

	// retrieve the length of the buffer the client wants to write

	TInt length = aMessage.Int1();

	// retrieve the descriptor to be written

	TBuf8<KMaxTransfer> bufDes;

	for (TInt offset=0;offset<length;offset+=KMaxTransfer)

		{

		aMessage.ReadL(0, bufDes, offset);

		// send descriptor to stream for printing

		iStream->Write(bufDes);

		}

	return KErrNone;

	}

// -------------- CLIENT IMPLEMENTATION -----------------------------

EXPORT_C TInt RRedirSession2::Connect()

	{

	TVersion version(KRedirServMajorVersionNumber,KRedirServMinorVersionNumber,

		KRedirServBuildVersionNumber);

	return CreateSession(KRedirServerName,version,1);	// only one message allowed - no concurrency

	}

TInt RRedirSession2::CheckEOF(TRequestStatus& aStatus)

	{

	if (Handle()!=0)

		return KErrNone;

	TRequestStatus* aStatusPtr=&aStatus;

	User::RequestComplete(aStatusPtr,KErrEof);

	return KErrEof;

	}

EXPORT_C void RRedirSession2::Read(TRequestStatus& aStatus, TDes8& aDes)

	{

	Read(aStatus, aDes, aDes.MaxLength());

	}

EXPORT_C void RRedirSession2::Read(TRequestStatus& aStatus, TDes8& aDes, TInt aLength)

	{

	if (CheckEOF(aStatus))

		return;

	SendReceive(ERedirRead,TIpcArgs(&aDes,aLength),aStatus);

	}

EXPORT_C void RRedirSession2::Write(TRequestStatus& aStatus, const TDesC8& aDes)

	{

	Write(aStatus, aDes, aDes.Length());

	}

EXPORT_C void RRedirSession2::Write(TRequestStatus& aStatus, const TDesC8& aDes, TInt aLength)

//

// Write aLength bytes

//

	{

	if (CheckEOF(aStatus))

		return;

	SendReceive(ERedirWrite,TIpcArgs(&aDes,aLength),aStatus);

	}

EXPORT_C void RRedirSession2::Flush(TRequestStatus& aStatus)

//

// Flush output

//

	{

	if (CheckEOF(aStatus))

		return;

	SendReceive(ERedirFlush,aStatus);

	}