// 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>

#if defined(_UNICODE)

#if !defined(UNICODE)

#define UNICODE

#endif

#endif

#define WIN32_LEAN_AND_MEAN

#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union

#include <windows.h>

#include <winbase.h>

#include <TCHAR.H>

#pragma warning( default : 4201 ) // nonstandard extension used : nameless struct/union

#include "ESTW32SV.H"

#ifndef EKA2

GLDEF_C TInt E32Dll(TDllReason)

	{

	return KErrNone;

	}

#endif

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

EXPORT_C void RWin32Stream::StartServer()

//

// Static function which spawns the three servers

//

	{

	CWin32Stream::StartServer(Kstdin);

	CWin32Stream::StartServer(Kstdout);

	CWin32Stream::StartServer(Kstderr);

	}

EXPORT_C TInt RWin32Stream::Open(TInt aStream)

	{

	TBuf<8> stream;

	if (CWin32Stream::StreamName(aStream,stream)!=KErrNone)

		return KErrArgument;

	TVersion version(1,0,0);

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

	}

TInt RWin32Stream::CheckEOF(TRequestStatus& aStatus)

	{

	if (Handle()!=0)

		return KErrNone;

	TRequestStatus* aStatusPtr=&aStatus;

	User::RequestComplete(aStatusPtr,KErrEof);

	return KErrEof;

	}

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

	{

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

	}

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

	{

	if (CheckEOF(aStatus))

		return;

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

	}

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

	{

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

	}

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

//

// Write aLength bytes

//

	{

	if (CheckEOF(aStatus))

		return;

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

	}

EXPORT_C void RWin32Stream::Flush(TRequestStatus& aStatus)

//

// Flush output

//

	{

	if (CheckEOF(aStatus))

		return;

	SendReceive(EWin32Flush,aStatus);

	}

// -------------- SERVER IMPLEMENTATION -----------------------------

//

// This is only relevant to WINS, so we know that in truth it's all a single address space

// and we can just operate on the descriptors directly.

//#define ESTW32_LOGGING	// log the stream output into a file

TInt CWin32Stream::StreamName(TInt aStream, TDes& aBuf)

	{

	switch (aStream)

		{

	case Kstdin:

		aBuf=_L("stdin"); break;

	case Kstdout:

		aBuf=_L("stdout"); break;

	case Kstderr:

		aBuf=_L("stderr"); break;

	default:

		return KErrArgument;

		}

	return KErrNone;

	}

struct rendezvous 

	{

	TRequestStatus*	iStatus;

	TInt	iStream;

	RThread iCaller;

	TBuf<8> iStreamName;

	};

void CWin32Stream::StartServer(TInt aStream)

//

// Static function which spawns a server thread

//

	{

	TRequestStatus status(KRequestPending);

	struct rendezvous rv;

	rv.iStatus=&status;

	rv.iStream=aStream;

	TInt err=StreamName(aStream,rv.iStreamName);

	if (err!=KErrNone)

		return;

	err=rv.iCaller.Duplicate(RThread(),EOwnerProcess);

	if (err!=KErrNone)

		return;

	RThread server;

	err=server.Create(rv.iStreamName,ThreadFunction,2048,4096,65536,(TAny*)&rv,EOwnerProcess);

	if (err==KErrNone) 

		{

		server.Resume();

		User::WaitForRequest(status);

		server.Close();

		}

	rv.iCaller.Close();

	}

TInt CWin32Stream::ThreadFunction(TAny* aPtr)

	{

	struct rendezvous* rvp=(struct rendezvous*)aPtr;

	TInt err=KErrNoMemory;

	CWin32Stream* stream = new CWin32Stream();

	if (stream!=0)

		err=stream->Init(rvp->iStream, rvp->iStreamName);

	rvp->iCaller.RequestComplete(rvp->iStatus,err);	// let the caller continue

	if (err==KErrNone)

		{

		FOREVER

			stream->HandleMessage();

		}

	else

		{

		delete stream;

		}

	return err;

	}

TInt CWin32Stream::Init(TInt aStream, const TDesC& aStreamName)

	{

	iHandle = GetStdHandle((STD_INPUT_HANDLE)-(int)aStream);

	if (iHandle==INVALID_HANDLE_VALUE)

		return KErrNotFound;

#ifdef ESTW32_LOGGING

	static char* logs[3]={ "x:\\stdin.log", "x:\\stdout.log", "x:\\stderr.log"};

	iLogHandle=CreateFile(logs[aStream], GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);

#else

	iLogHandle=INVALID_HANDLE_VALUE;

#endif

	return iServer.CreateGlobal(aStreamName);

	}

void CWin32Stream::HandleMessage()

	{

	iServer.Receive(iMessage);

	TInt err=KErrNone;

	TInt f=iMessage.Function();

	switch (f)

		{

	case RMessage2::EConnect:

	case RMessage2::EDisConnect:

		// RServer2 connection management - nothing interesting to be done

		break;

	case EWin32Read:

		err=ReadStream(iMessage);

		break;

	case EWin32Write:

		err=WriteStream(iMessage);

		break;

	case EWin32Flush:

		FlushStream();

		break;

	default:

		err=KErrNotSupported;

		break;

		}

	iMessage.Complete(err);

	}

TInt CWin32Stream::ReadStream(RMessage2& aMessage)

	{

	TDes8* bufDes = (TDes8*)(aMessage.Ptr0());

	int length = aMessage.Int1();

	unsigned long nbytes;

	if (ReadFile(iHandle, (TAny*)(bufDes->Ptr()), length, &nbytes, 0) && nbytes>0)

		{

		bufDes->SetLength(nbytes);

		return KErrNone;

		}

	return MapWin32Error(KErrEof);

	}

TInt CWin32Stream::WriteStream(RMessage2& aMessage)

	{

	TDesC8* bufDes = (TDesC8*)(aMessage.Ptr0());

	int length = aMessage.Int1();

	int offset = 0;

	unsigned long nbytes;

#ifdef ESTW32_LOGGING

	WriteFile(iLogHandle, bufDes->Ptr(), length, &nbytes, 0);

	FlushFileBuffers(iLogHandle);

#endif

	while (length>offset)

		{

		if (!WriteFile(iHandle, bufDes->Ptr()+offset, length-offset, &nbytes, 0))

			return MapWin32Error(KErrEof);

		offset+=nbytes;

		}

	return KErrNone;

	}

void CWin32Stream::FlushStream()

	{

	FlushFileBuffers(iHandle);	// don't care if it works or not

	}

#include <winerror.h>

TInt CWin32Stream::MapWin32Error(TInt aDefault)

	{

	switch (GetLastError())

		{

	case ERROR_INVALID_HANDLE:

		return KErrBadHandle;

	case ERROR_HANDLE_EOF:

		return KErrEof;

		}

	return aDefault;

	}