// client.cpp
// 
// Copyright (c) 2006 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//

#include <fshell/iocli.h>
#include "clientserver.h"
#include <e32math.h>


#ifndef EKA2

//
// TServerStart.
//

TServerStart::TServerStart(TRequestStatus& aStatus)
	: iId(RThread().Id()), iStatus(&aStatus)
	{
	aStatus = KRequestPending;
	}

TPtrC TServerStart::AsCommand() const
	{
	return TPtrC(reinterpret_cast<const TText*>(this),sizeof(TServerStart)/sizeof(TText));
	}

#endif


//
// Statics.
//

static TInt StartServer()
	{
#ifdef EKA2
	const TUidType serverUid(KNullUid, KNullUid, KServerUid3);
	RProcess server;
	TInt r = server.Create(KIoServerName, KNullDesC, serverUid);
	if (r != KErrNone)
		{
		return r;
		}
	TRequestStatus stat;
	server.Rendezvous(stat);
	if (stat != KRequestPending)
		{
		server.Kill(0);
		}
	else
		{
		server.Resume();
		}
	User::WaitForRequest(stat);		// wait for start or death
	r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();
	server.Close();
	return r;
#else
	TRequestStatus started;
	TServerStart start(started);
	const TUidType serverUid(KNullUid, KNullUid, KServerUid3);
#ifdef __WINS__
	RLibrary lib;
	TInt r = lib.Load(KIoServerName, serverUid);
	if (r != KErrNone)
		{
		return r;
		}
	TLibraryFunction ordinal1 = lib.Lookup(1);
	TThreadFunction serverFunc = reinterpret_cast<TThreadFunction>(ordinal1());
	TName name(KIoServerName);
	name.AppendNum(Math::Random(), EHex);
	RThread server;
	r=server.Create(name, serverFunc,
					KIoStackSize,
					&start, &lib, NULL,
					KIoInitHeapSize, KIoMaxHeapSize, EOwnerProcess);
	lib.Close();
#else
	RProcess server;
	TInt r=server.Create(KIoServerName, start.AsCommand(), serverUid);
#endif
	if (r != KErrNone)
		{
		return r;
		}
	TRequestStatus died;
	server.Logon(died);
	if (died != KRequestPending)
		{
		User::WaitForRequest(died);
		server.Kill(0);
		server.Close();
		return died.Int();
		}
	server.Resume();
	User::WaitForRequest(started, died);
	if (started == KRequestPending)
		{
		server.Close();
		return died.Int();
		}
	server.LogonCancel(died);
	server.Close();
	User::WaitForRequest(died);
	return KErrNone;
#endif // EKA2
	}

#ifndef EKA2
TInt E32Dll(TDllReason)
	{
	return 0;
	}
#endif


//
// RIoSession.
//

EXPORT_C TInt RIoSession::Connect()
	{
	TInt retry = 2;
	for (;;)
		{
		TInt r = CreateSession(KIoServerName, TVersion(0,0,0));
		if ((r != KErrNotFound) && (r != KErrServerTerminated))
			{
			return r;
			}
		if (--retry == 0)
			{
			return r;
			}
		r = StartServer();
		if ((r != KErrNone) && (r != KErrAlreadyExists))
			{
			return r;
			}
		}
	}
	
EXPORT_C void RIoSession::ConnectL()
	{
	User::LeaveIfError(Connect());
	}

EXPORT_C TInt RIoSession::SetObjectName(TInt aHandle, const TDesC& aName)
	{
#ifdef EKA2
	return SendReceive(EIoSetObjectName, TIpcArgs(aHandle, &aName));
#else
	TInt p[4];
	p[0] = aHandle;
	p[1] = (TInt)&aName;
	return SendReceive(EIoSetObjectName, &p[0]);
#endif
	}

EXPORT_C void RIoSession::SetObjectNameL(TInt aHandle, const TDesC& aName)
	{
	User::LeaveIfError(SetObjectName(aHandle, aName));
	}
	
EXPORT_C TInt RIoSession::FindFirstHandle(RIoHandle::TType aType, const TDesC& aMatchString, TInt& aFoundHandle, TName& aName)
	{
#ifdef EKA2
	TPckg<TInt> foundBuf(aFoundHandle);
	return SendReceive(EIoFindFirstHandle, TIpcArgs(aType, &aMatchString, &foundBuf, &aName));
#else
	TInt p[4];
	p[0] = aType;
	p[1] = &aMatchString;
	p[2] = &aFoundHandle;
	p[3] = &aName;
	return SendReceive(EIoFindFirstHandle, &p[0]);
#endif
	}
	
EXPORT_C TInt RIoSession::FindNextHandle(TInt& aFoundHandle, TName& aName)
	{
#ifdef EKA2
	TPckg<TInt> foundBuf(aFoundHandle);
	return SendReceive(EIoFindNextHandle, TIpcArgs(&foundBuf, &aName));
#else
	TInt p[4];
	p[0] = &aFoundHandle;
	p[1] = &aName;
	return SendReceive(EIoFindNextHandle, &p[0]);
#endif
	}


//
// RIoHandle.
//

EXPORT_C TInt RIoHandle::OpenFoundHandle(RIoSession& aSession, TInt aFoundHandle)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoOpenFoundHandle, TIpcArgs(aFoundHandle));
#else
	TInt p[4];
	p[0] = aFoundHandle;
	return CreateSubSession(aSession, EIoOpenFoundHandle, &p[0]);
#endif
	}
	
EXPORT_C void RIoHandle::OpenFoundHandleL(RIoSession& aSession, TInt aFoundHandle)
	{
	User::LeaveIfError(OpenFoundHandle(aSession, aFoundHandle));
	}

EXPORT_C void RIoHandle::Close()
	{
	CloseSubSession(EIoHandleClose);
	}

EXPORT_C TInt RIoHandle::IsType(TType aType) const
	{
#ifdef EKA2
	return SendReceive(EIoHandleIsType, TIpcArgs(aType));
#else
	TInt p[4];
	p[0] = (TInt)aType;
	return SendReceive(EIoHandleIsType, &p[0]);
#endif
	
	}
	
EXPORT_C TBool RIoHandle::IsTypeL(TType aType) const
	{
	return User::LeaveIfError(IsType(aType));
	}
	
EXPORT_C TInt RIoHandle::ObjectName(TDes& aName) const
	{
#ifdef EKA2
	return SendReceive(EIoHandleGetName, TIpcArgs(&aName));
#else
	TInt p[4];
	p[0] = &aName;
	return SendReceive(EIoHandleGetName, &p[0]);
#endif
	}
	
EXPORT_C void RIoHandle::ObjectNameL(TDes& aName) const
	{
	User::LeaveIfError(ObjectName(aName));
	}
	
EXPORT_C TInt RIoHandle::Equals(const RIoHandle& aNother) const
	{
#ifdef EKA2
	return SendReceive(EIoHandleEquals, TIpcArgs(aNother.SubSessionHandle()));
#else
	TInt p[4];
	p[0] = (TInt)aNother.SubSessionHandle();
	return SendReceive(EIoHandleEquals, &p[0]);
#endif
	}
	
EXPORT_C TBool RIoHandle::EqualsL(const RIoHandle& aNother) const
	{
	return User::LeaveIfError(Equals(aNother));
	}

EXPORT_C RIoSession RIoHandle::Session() const
	{
	RSessionBase session = RSubSessionBase::Session();
	return static_cast<RIoSession&>(session);
	}


//
// RIoReadWriteHandle.
//

EXPORT_C TInt RIoReadWriteHandle::SetMode(TMode aMode)
	{
#ifdef EKA2
	return SendReceive(EIoSetReadWriteMode, TIpcArgs(aMode));
#else
	TInt p[4];
	p[0] = (TInt)aMode;
	return SendReceive(EIoSetReadWriteMode, &p[0]);
#endif
	}
	
EXPORT_C void RIoReadWriteHandle::SetModeL(TMode aMode)
	{
	User::LeaveIfError(SetMode(aMode));
	}

EXPORT_C TInt RIoReadWriteHandle::SetOwner(TThreadId aOwningThread)
	{
#ifdef EKA2
	return SendReceive(EIoHandleSetOwner, TIpcArgs(aOwningThread));
#else
	TInt p[4];
	p[0] = aOwningThread;
	return SendReceive(EIoHandleSetOwner, &p[0]);
#endif
	}
	
EXPORT_C void RIoReadWriteHandle::SetOwnerL(TThreadId aOwningThread)
	{
	User::LeaveIfError(SetOwner(aOwningThread));
	}

EXPORT_C TInt RIoReadWriteHandle::SetUnderlyingConsole(RIoConsole& aConsole)
	{
#ifdef EKA2
	return SendReceive(EIoHandleSetUnderlyingConsole, TIpcArgs(aConsole.SubSessionHandle()));
#else
	TInt p[4];
	p[0] = aConsole.SubSessionHandle();
	return SendReceive(EIoHandleSetUnderlyingConsole, &p[0]);
#endif
	}
	
EXPORT_C void RIoReadWriteHandle::SetUnderlyingConsoleL(RIoConsole& aConsole)
	{
	User::LeaveIfError(SetUnderlyingConsole(aConsole));
	}

EXPORT_C TInt RIoReadWriteHandle::AttachedToConsole() const
	{
#ifdef EKA2
	return SendReceive(EIoHandleAttachedToConsole);
#else
	return SendReceive(EIoHandleAttachedToConsole, NULL);
#endif
	}
	
EXPORT_C TBool RIoReadWriteHandle::AttachedToConsoleL() const
	{
	return User::LeaveIfError(AttachedToConsole());
	}

//
// RIoReadHandle.
//

EXPORT_C TInt RIoReadHandle::Create(RIoSession& aSession)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreateReader);
#else
	return CreateSubSession(aSession, EIoCreateReader, NULL);
#endif
	}
	
EXPORT_C void RIoReadHandle::CreateL(RIoSession& aSession)
	{
	User::LeaveIfError(Create(aSession));
	}

EXPORT_C TInt RIoReadHandle::Open(RIoSession& aSession)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoOpenReaderByThreadId);
#else
	return CreateSubSession(aSession, EIoOpenReaderByThreadId, NULL);
#endif
	}
	
EXPORT_C void RIoReadHandle::OpenL(RIoSession& aSession)
	{
	User::LeaveIfError(Open(aSession));
	}

EXPORT_C TInt RIoReadHandle::Open(RIoSession& aSession, TThreadId aThreadId)
	{
	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
#ifdef EKA2
	return CreateSubSession(aSession, EIoOpenReaderByExplicitThreadId, TIpcArgs(&threadIdPckg));
#else
	TInt p[4];
	p[0] = &threadIdPckg;
	return CreateSubSession(aSession, EIoOpenReaderByExplicitThreadId, &p[0]);
#endif
	}
	
EXPORT_C void RIoReadHandle::OpenL(RIoSession& aSession, TThreadId aThreadId)
	{
	User::LeaveIfError(Open(aSession, aThreadId));
	}

EXPORT_C TInt RIoReadHandle::Duplicate(RIoReadHandle& aReadHandle)
	{
#ifdef EKA2
	return SendReceive(EIoDuplicateReader, TIpcArgs(aReadHandle.SubSessionHandle()));
#else
	TInt p[4];
	p[0] = aReadHandle.SubSessionHandle();
	return SendReceive(EIoDuplicateReader, &p[0]);
#endif
	}
	
EXPORT_C void RIoReadHandle::DuplicateL(RIoReadHandle& aReadHandle)
	{
	User::LeaveIfError(Duplicate(aReadHandle));
	}

EXPORT_C TInt RIoReadHandle::DuplicateHandleFromThread(TThreadId aThreadId)
	{
	return SendReceive(EIoDuplicateReaderHandleFromThread, TIpcArgs(TUint(aThreadId)));
	}

EXPORT_C TInt RIoReadHandle::SetReadMode(TReadMode aMode)
	{
#ifdef EKA2
	return SendReceive(EIoSetReadMode, TIpcArgs(aMode));
#else
	TInt p[4];
	p[0] = (TInt)aMode;
	return SendReceive(EIoSetReadMode, &p[0]);
#endif
	}
	
EXPORT_C void RIoReadHandle::SetReadModeL(TReadMode aMode)
	{
	User::LeaveIfError(SetReadMode(aMode));
	}

EXPORT_C TInt RIoReadHandle::SetToForeground()
	{
#ifdef EKA2
	return SendReceive(EIoSetReaderToForeground);
#else
	return SendReceive(EIoSetReaderToForeground, NULL);
#endif
	}

EXPORT_C void RIoReadHandle::SetToForegroundL()
	{
	User::LeaveIfError(SetToForeground());
	}

EXPORT_C TInt RIoReadHandle::Read(TDes& aDes)
	{
#ifdef EKA2
	return SendReceive(EIoRead, TIpcArgs(&aDes));
#else
	TInt p[4];
	p[0] = (TInt)&aDes;
	return SendReceive(EIoRead, &p[0]);
#endif
	}
	
EXPORT_C void RIoReadHandle::ReadL(TDes& aDes)
	{
	User::LeaveIfError(Read(aDes));
	}

EXPORT_C void RIoReadHandle::Read(TDes& aDes, TRequestStatus& aStatus)
	{
#ifdef EKA2
	return SendReceive(EIoRead, TIpcArgs(&aDes), aStatus);
#else
	TInt p[4];
	p[0] = (TInt)&aDes;
	SendReceive(EIoRead, &p[0], aStatus);
#endif
	}

EXPORT_C TInt RIoReadHandle::SetLineSeparator(const TDesC& aSeparator)
	{
#ifdef EKA2
	return SendReceive(EIoSetLineSeparator, TIpcArgs(&aSeparator));
#else
	TInt p[4];
	p[0] = (TInt)&aSeparator;
	return SendReceive(EIoSetLineSeparator, &p[0]);
#endif
	}

EXPORT_C void RIoReadHandle::SetLineSeparatorL(const TDesC& aSeparator)
	{
	User::LeaveIfError(SetLineSeparator(aSeparator));
	}

EXPORT_C void RIoReadHandle::ReadCancel()
	{
#ifdef EKA2
	SendReceive(EIoReadCancel);
#else
	SendReceive(EIoReadCancel, NULL);
#endif
	}

EXPORT_C TInt RIoReadHandle::IsForeground() const
	{
#ifdef EKA2
	return SendReceive(EIoIsForegroundReader);
#else
	return SendReceive(EIoIsForegroundReader, NULL);
#endif
	}

EXPORT_C TBool RIoReadHandle::IsForegroundL() const
	{
	return User::LeaveIfError(IsForeground());
	}

EXPORT_C void RIoReadHandle::NotifyChange(TPckgBuf<TUint>& aChangeType, TRequestStatus& aStatus)
	{
#ifdef EKA2
	SendReceive(EIoReadHandleNotifyChange, TIpcArgs(&aChangeType), aStatus);
#else
	TInt p[4];
	p[0] = (TInt)&aChangeType;;
	SendReceive(EIoReadHandleNotifyChange, &p[0], aStatus);
#endif
	}

EXPORT_C void RIoReadHandle::CancelNotifyChange()
	{
	SendReceive(EIoReadHandleCancelNotifyChange);
	}


//
// RIoConsoleReadHandle.
//

EXPORT_C RIoConsoleReadHandle::RIoConsoleReadHandle()
	{
	}

EXPORT_C RIoConsoleReadHandle::RIoConsoleReadHandle(RIoReadHandle& aHandle)
	{
	*(RIoReadHandle*)this = aHandle; // Take a bit-wise copy of the base class.
	}

EXPORT_C RIoConsoleReadHandle RIoConsoleReadHandle::operator=(RIoReadHandle& aHandle)
	{
	*(RIoReadHandle*)this = aHandle; // Take a bit-wise copy of the base class.
	return *this;
	}

EXPORT_C TUint RIoConsoleReadHandle::ReadKey()
	{
	TRequestStatus status;
	WaitForKey(status);
	User::WaitForRequest(status);
	if (status.Int())
		{
		return EKeyNull;
		}
	return KeyCode();
	}

EXPORT_C void RIoConsoleReadHandle::WaitForKey(TRequestStatus& aStatus)
	{
#ifdef EKA2
	return SendReceive(EIoConsoleWaitForKey, TIpcArgs(&iKeyBuf), aStatus);
#else
	TInt p[4];
	p[0] = (TInt)&iKeyBuf;
	SendReceive(EIoConsoleWaitForKey, &p[0], aStatus);
#endif
	}

EXPORT_C void RIoConsoleReadHandle::WaitForKeyCancel()
	{
#ifdef EKA2
	SendReceive(EIoConsoleWaitForKeyCancel);
#else
	SendReceive(EIoConsoleWaitForKeyCancel, NULL);
#endif
	}

EXPORT_C TUint RIoConsoleReadHandle::KeyCode() const
	{
	return iKeyBuf().iKeyCode;
	}

EXPORT_C TUint RIoConsoleReadHandle::KeyModifiers() const
	{
	return iKeyBuf().iModifiers;
	}

EXPORT_C TInt RIoConsoleReadHandle::CaptureKey(TUint aKeyCode, TUint aModifierMask, TUint aModifiers)
	{
#ifdef EKA2
	return SendReceive(EIoConsoleCaptureKey, TIpcArgs(aKeyCode, aModifierMask, aModifiers));
#else
	TInt p[4];
	p[0] = aKeyCode;
	p[1] = aModifierMask;
	p[2] = aModifiers;
	return SendReceive(EIoConsoleCaptureKey, &p[0]);
#endif
	}

EXPORT_C void RIoConsoleReadHandle::CaptureKeyL(TUint aKeyCode, TUint aModifierMask, TUint aModifiers)
	{
	User::LeaveIfError(CaptureKey(aKeyCode, aModifierMask, aModifiers));
	}

EXPORT_C TInt RIoConsoleReadHandle::CancelCaptureKey(TUint aKeyCode, TUint aModifierMask, TUint aModifiers)
	{
#ifdef EKA2
	return SendReceive(EIoConsoleCancelCaptureKey, TIpcArgs(aKeyCode, aModifierMask, aModifiers));
#else
	TInt p[4];
	p[0] = aKeyCode;
	p[1] = aModifierMask;
	p[2] = aModifiers;
	return SendReceive(EIoConsoleCancelCaptureKey, &p[0]);
#endif
	}

EXPORT_C TInt RIoConsoleReadHandle::CaptureAllKeys()
	{
#ifdef EKA2
	return SendReceive(EIoConsoleCaptureAllKeys);
#else
	return SendReceive(EIoConsoleCaptureAllKeys, NULL);
#endif
	}
	
EXPORT_C void RIoConsoleReadHandle::CaptureAllKeysL()
	{
	User::LeaveIfError(CaptureAllKeys());
	}

EXPORT_C TInt RIoConsoleReadHandle::CancelCaptureAllKeys()
	{
#ifdef EKA2
	return SendReceive(EIoConsoleCancelCaptureAllKeys);
#else
	return SendReceive(EIoConsoleCancelCaptureAllKeys, NULL);
#endif
	}


//
// RIoWriteHandle.
//

EXPORT_C TInt RIoWriteHandle::Create(RIoSession& aSession)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreateWriter);
#else
	return CreateSubSession(aSession, EIoCreateWriter, NULL);
#endif
	}
	
EXPORT_C void RIoWriteHandle::CreateL(RIoSession& aSession)
	{
	User::LeaveIfError(Create(aSession));
	}

EXPORT_C TInt RIoWriteHandle::Open(RIoSession& aSession)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoOpenWriterByThreadId);
#else
	return CreateSubSession(aSession, EIoOpenWriterByThreadId, NULL);
#endif
	}
	
EXPORT_C void RIoWriteHandle::OpenL(RIoSession& aSession)
	{
	User::LeaveIfError(Open(aSession));
	}

EXPORT_C TInt RIoWriteHandle::Open(RIoSession& aSession, TThreadId aThreadId)
	{
	TPckgBuf<TThreadId> threadIdPckg(aThreadId);
#ifdef EKA2
	return CreateSubSession(aSession, EIoOpenWriterByExplicitThreadId, TIpcArgs(&threadIdPckg));
#else
	TInt p[4];
	p[0] = &threadIdPckg;
	return CreateSubSession(aSession, EIoOpenWriterByExplicitThreadId, &p[0]);
#endif
	}

EXPORT_C void RIoWriteHandle::OpenL(RIoSession& aSession, TThreadId aThreadId)
	{
	User::LeaveIfError(Open(aSession, aThreadId));
	}

EXPORT_C TInt RIoWriteHandle::Duplicate(RIoWriteHandle& aWriteHandle)
	{
#ifdef EKA2
	return SendReceive(EIoDuplicateWriter, TIpcArgs(aWriteHandle.SubSessionHandle()));
#else
	TInt p[4];
	p[0] = aWriteHandle.SubSessionHandle();
	return SendReceive(EIoDuplicateWriter, &p[0]);
#endif
	}
	
EXPORT_C void RIoWriteHandle::DuplicateL(RIoWriteHandle& aWriteHandle)
	{
	User::LeaveIfError(Duplicate(aWriteHandle));
	}

EXPORT_C TInt RIoWriteHandle::DuplicateHandleFromThread(TThreadId aThreadId)
	{
	return SendReceive(EIoDuplicateWriterHandleFromThread, TIpcArgs(TUint(aThreadId)));
	}

EXPORT_C TInt RIoWriteHandle::Write(const TDesC& aDes)
	{
#ifdef EKA2
	return SendReceive(EIoWrite, TIpcArgs(&aDes));
#else
	TInt p[4];
	p[0] = (TInt)&aDes;
	return SendReceive(EIoWrite, &p[0]);
#endif
	}
	
EXPORT_C void RIoWriteHandle::WriteL(const TDesC& aDes)
	{
	User::LeaveIfError(Write(aDes));
	}

EXPORT_C void RIoWriteHandle::Write(const TDesC& aDes, TRequestStatus& aStatus)
	{
#ifdef EKA2
	return SendReceive(EIoWrite, TIpcArgs(&aDes), aStatus);
#else
	TInt p[4];
	p[0] = (TInt)&aDes;
	SendReceive(EIoWrite, &p[0], aStatus);
#endif
	}

EXPORT_C void RIoWriteHandle::WriteCancel()
	{
#ifdef EKA2
	SendReceive(EIoWriteCancel);
#else
	SendReceive(EIoWriteCancel, NULL);
#endif
	}


//
// RIoConsoleWriteHandle.
//

EXPORT_C RIoConsoleWriteHandle::RIoConsoleWriteHandle()
	{
	}

EXPORT_C RIoConsoleWriteHandle::RIoConsoleWriteHandle(RIoWriteHandle& aHandle)
	{
	*(RIoWriteHandle*)this = aHandle; // Take a bit-wise copy of the base class.
	}

EXPORT_C RIoConsoleWriteHandle RIoConsoleWriteHandle::operator=(RIoWriteHandle& aHandle)
	{
	*(RIoWriteHandle*)this = aHandle; // Take a bit-wise copy of the base class.
	return *this;
	}

EXPORT_C TInt RIoConsoleWriteHandle::GetCursorPos(TPoint& aPos) const
	{
	TPckg<TPoint> posPckg(aPos);
#ifdef EKA2
	TInt err = SendReceive(EIoConsoleCursorPos, TIpcArgs(&posPckg));
#else
	TInt p[4];
	p[0] = (TInt)&posPckg;
	TInt err = SendReceive(EIoConsoleCursorPos, &p[0]);
#endif
	return err;
	}
	
EXPORT_C TPoint RIoConsoleWriteHandle::GetCursorPosL() const
	{
	TPoint pos;
	User::LeaveIfError(GetCursorPos(pos));
	return pos;
	}

EXPORT_C TInt RIoConsoleWriteHandle::SetCursorPosAbs(const TPoint& aPoint)
	{
	TPckg<TPoint> posPckg(aPoint);
#ifdef EKA2
	return SendReceive(EIoConsoleSetCursorPosAbs, TIpcArgs(&posPckg));
#else
	TInt p[4];
	p[0] = (TInt)&posPckg;
	return SendReceive(EIoConsoleSetCursorPosAbs, &p[0]);
#endif
	}
	
EXPORT_C void RIoConsoleWriteHandle::SetCursorPosAbsL(const TPoint& aPos)
	{
	User::LeaveIfError(SetCursorPosAbs(aPos));
	}

EXPORT_C TInt RIoConsoleWriteHandle::SetCursorPosRel(const TPoint& aPoint)
	{
	TPckg<TPoint> posPckg(aPoint);
#ifdef EKA2
	return SendReceive(EIoConsoleSetCursorPosRel, TIpcArgs(&posPckg));
#else
	TInt p[4];
	p[0] = (TInt)&posPckg;
	return SendReceive(EIoConsoleSetCursorPosRel, &p[0]);
#endif
	}

EXPORT_C void RIoConsoleWriteHandle::SetCursorPosRelL(const TPoint& aPos)
	{
	User::LeaveIfError(SetCursorPosRel(aPos));
	}

EXPORT_C TInt RIoConsoleWriteHandle::SetCursorHeight(TInt aPercentage)
	{
#ifdef EKA2
	return SendReceive(EIoConsoleSetCursorHeight, TIpcArgs(aPercentage));
#else
	TInt p[4];
	p[0] = aPercentage;
	return SendReceive(EIoConsoleSetCursorHeight, &p[0]);
#endif
	}

EXPORT_C void RIoConsoleWriteHandle::SetCursorHeightL(TInt aPercentage)
	{
	User::LeaveIfError(SetCursorHeight(aPercentage));
	}

EXPORT_C TInt RIoConsoleWriteHandle::SetTitle(const TDesC& aTitle)
	{
#ifdef EKA2
	return SendReceive(EIoConsoleSetTitle, TIpcArgs(&aTitle));
#else
	TInt p[4];
	p[0] = (TInt)&aTitle;
	return SendReceive(EIoConsoleSetTitle, &p[0]);
#endif
	}
	
EXPORT_C void RIoConsoleWriteHandle::SetTitleL(const TDesC& aTitle)
	{
	User::LeaveIfError(SetTitle(aTitle));
	}

EXPORT_C TInt RIoConsoleWriteHandle::ClearScreen()
	{
#ifdef EKA2
	return SendReceive(EIoConsoleClearScreen);
#else
	return SendReceive(EIoConsoleClearScreen, NULL);
#endif
	}
	
EXPORT_C void RIoConsoleWriteHandle::ClearScreenL()
	{
	User::LeaveIfError(ClearScreen());
	}

EXPORT_C TInt RIoConsoleWriteHandle::ClearToEndOfLine()
	{
#ifdef EKA2
	return SendReceive(EIoConsoleClearToEndOfLine);
#else
	return SendReceive(EIoConsoleClearToEndOfLine, NULL);
#endif
	}
	
EXPORT_C void RIoConsoleWriteHandle::ClearToEndOfLineL()
	{
	User::LeaveIfError(ClearToEndOfLine());
	}

EXPORT_C TInt RIoConsoleWriteHandle::GetScreenSize(TSize& aSize) const
	{
	TPckg<TSize> sizePckg(aSize);
#ifdef EKA2
	TInt err = SendReceive(EIoConsoleScreenSize, TIpcArgs(&sizePckg));
#else
	TInt p[4];
	p[0] = (TInt)&sizePckg;
	TInt err = SendReceive(EIoConsoleScreenSize, &p[0]);
#endif
	return err;
	}
	
EXPORT_C TSize RIoConsoleWriteHandle::GetScreenSizeL() const
	{
	TSize size;
	User::LeaveIfError(GetScreenSize(size));
	return size;
	}
	
EXPORT_C TInt RIoConsoleWriteHandle::SetAttributes(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor)
	{
#ifdef EKA2
	TInt err = SendReceive(EIoConsoleSetAttributes, TIpcArgs(aAttributes, aForegroundColor, aBackgroundColor));
#else
	TInt p[4];
	p[0] = aAttributes;
	p[1] = aForegroundColor;
	p[2] = aBackgroundColor;
	TInt err = SendReceive(EIoConsoleSetAttributes, &p[0]);
#endif
	return err;
	}

EXPORT_C void RIoConsoleWriteHandle::SetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor)
	{
	User::LeaveIfError(SetAttributes(aAttributes, aForegroundColor, aBackgroundColor));
	}

EXPORT_C TInt RIoConsoleWriteHandle::SetAttributes(const ConsoleAttributes::TAttributes& aAttributes)
	{
	return SetAttributes(aAttributes.iAttributes, aAttributes.iForegroundColor, aAttributes.iBackgroundColor);
	}

EXPORT_C TInt RIoConsoleWriteHandle::SetIsStdErr(TBool aFlag)
	{
	return SendReceive(EIoSetIsStdErr, TIpcArgs(aFlag));
	}


//
// RIoEndPoint.
//

EXPORT_C TInt RIoEndPoint::Attach(RIoReadHandle& aReader, TReadMode aMode)
	{
#ifdef EKA2
	return SendReceive(EIoEndPointAttachReader, TIpcArgs(aReader.SubSessionHandle(), aMode));
#else
	TInt p[4];
	p[0] = (TInt)aReader.SubSessionHandle();
	p[1] = aMode;
	return SendReceive(EIoEndPointAttachReader, &p[0]);
#endif
	}

EXPORT_C void RIoEndPoint::AttachL(RIoReadHandle& aReader, TReadMode aMode)
	{
	User::LeaveIfError(Attach(aReader, aMode));
	}

EXPORT_C TInt RIoEndPoint::Attach(RIoWriteHandle& aWriter)
	{
#ifdef EKA2
	return SendReceive(EIoEndPointAttachWriter, TIpcArgs(aWriter.SubSessionHandle()));
#else
	TInt p[4];
	p[0] = (TInt)aWriter.SubSessionHandle();
	return SendReceive(EIoEndPointAttachWriter, &p[0]);
#endif
	}
	
EXPORT_C void RIoEndPoint::AttachL(RIoWriteHandle& aWriter)
	{
	User::LeaveIfError(Attach(aWriter));
	}

EXPORT_C TInt RIoEndPoint::SetForegroundReadHandle(RIoReadHandle& aReader)
	{
#ifdef EKA2
	return SendReceive(EIoEndPointSetForegroundReadHandle, TIpcArgs(aReader.SubSessionHandle()));
#else
	TInt p[4];
	p[0] = (TInt)aReader.SubSessionHandle();
	return SendReceive(EIoEndPointSetForegroundReadHandle, &p[0]);
#endif
	}
	
EXPORT_C void RIoEndPoint::SetForegroundReadHandleL(RIoReadHandle& aReader)
	{
	User::LeaveIfError(SetForegroundReadHandle(aReader));
	}

EXPORT_C RIoEndPoint::RIoEndPoint()
	{
	}


//
// RIoPipe.
//

EXPORT_C TInt RIoPipe::Create(RIoSession& aSession)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreatePipe);
#else
	return CreateSubSession(aSession, EIoCreatePipe, NULL);
#endif
	}

EXPORT_C void RIoPipe::CreateL(RIoSession& aSession)
	{
	User::LeaveIfError(Create(aSession));
	}

//
// RIoConsole.
//

EXPORT_C TInt RIoConsole::Create(RIoSession& aSession, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
	{
	return Create(aSession, KNullDesC, aTitle, aSize, aOptions);
	}
	
EXPORT_C void RIoConsole::CreateL(RIoSession& aSession, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
	{
	User::LeaveIfError(Create(aSession, aTitle, aSize, aOptions));
	}

EXPORT_C TInt RIoConsole::Create(RIoSession& aSession, const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
	{
	TConsoleCreateParams params;
	params.iSize = aSize;
	params.iUnderlyingConsoleHandle = KNullHandle;
	params.iOptions = aOptions;
	TPckg<TConsoleCreateParams> paramsPckg(params);
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreateConsole, TIpcArgs(&aTitle, &paramsPckg, &aImplementation));
#else
	TInt p[4];
	p[0] = (TInt)&aTitle;
	p[1] = (TInt)&paramsPckg;
	p[2] = (TInt)&aImplementation;
	return CreateSubSession(aSession, EIoCreateConsole, &p[0]);
#endif
	}

EXPORT_C TInt RIoConsole::Create(RIoSession& aSession, const TDesC& aImplementation, RIoConsole& aUnderlyingConsole, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
	{
	TConsoleCreateParams params;
	params.iSize = aSize;
	params.iUnderlyingConsoleHandle = aUnderlyingConsole.SubSessionHandle();
	params.iOptions = aOptions;
	TPckg<TConsoleCreateParams> paramsPckg(params);
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreateConsole, TIpcArgs(&aTitle, &paramsPckg, &aImplementation));
#else
	TInt p[4];
	p[0] = (TInt)&aTitle;
	p[1] = (TInt)&paramsPckg;
	p[2] = (TInt)&aImplementation;
	return CreateSubSession(aSession, EIoCreateConsole, &p[0]);
#endif
	}

EXPORT_C void RIoConsole::CreateL(RIoSession& aSession, const TDesC& aImplementation, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
	{
	User::LeaveIfError(Create(aSession, aImplementation, aTitle, aSize, aOptions));
	}

EXPORT_C void RIoConsole::CreateL(RIoSession& aSession, const TDesC& aImplementation, RIoConsole& aUnderlyingConsole, const TDesC& aTitle, const TSize& aSize, TUint aOptions)
	{
	User::LeaveIfError(Create(aSession, aImplementation, aUnderlyingConsole, aTitle, aSize, aOptions));
	}

EXPORT_C TInt RIoConsole::Open(RIoSession& aSession, RIoHandle& aHandle)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoOpenConsole, TIpcArgs(aHandle.SubSessionHandle()));
#else
	TInt p[4];
	p[0] = aHandle.SubSessionHandle();
	return CreateSubSession(aSession, EIoOpenConsole, &p[0]);
#endif
	}
	
EXPORT_C void RIoConsole::OpenL(RIoSession& aSession, RIoHandle& aHandle)
	{
	User::LeaveIfError(Open(aSession, aHandle));
	}

EXPORT_C TInt RIoConsole::Implementation(TDes& aDes) const
	{
#ifdef EKA2
	return SendReceive(EIoConsoleImplementation, TIpcArgs(&aDes));
#else
	TInt p[4];
	p[0] = (TInt)&aDes;
	return SendReceive(EIoConsoleImplementation, &p[0]);
#endif
	}
	
EXPORT_C void RIoConsole::ImplementationL(TDes& aDes) const
	{
	User::LeaveIfError(Implementation(aDes));
	}

//
// RIoPersistentConsole.
//
EXPORT_C TInt RIoPersistentConsole::Create(RIoSession& aSession, const TDesC& aName, const TDesC& aTitle)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreatePersistentConsole, TIpcArgs(&aName, &aTitle));
#else
	TInt p[4];
	p[0] = (TInt)&aName;
	p[1] = (TInt)&aTitle;
	return CreateSubSession(aSession, EIoCreatePersistentConsole, &p[0]);
#endif
	}
	
EXPORT_C void RIoPersistentConsole::CreateL(RIoSession& aSession, const TDesC& aName, const TDesC& aTitle)
	{
	User::LeaveIfError(Create(aSession, aName, aTitle));
	}
	
EXPORT_C TInt RIoPersistentConsole::OpenByName(RIoSession& aSession, const TDesC& aName)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoOpenPersistentConsoleByName, TIpcArgs(&aName));
#else
	TInt p[4];
	p[0] = (TInt)&aTitle;
	return CreateSubSession(aSession, EIoOpenPersistentConsoleByName, &p[0]);
#endif
	}
	
EXPORT_C void RIoPersistentConsole::OpenByNameL(RIoSession& aSession, const TDesC& aName)
	{
	User::LeaveIfError(OpenByName(aSession, aName));
	}

EXPORT_C TInt RIoPersistentConsole::AttachReader(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
	{
#ifdef EKA2
	return SendReceive(EIoPersistentConsoleAttachReadEndPoint, TIpcArgs(aEndPoint.SubSessionHandle(), aCloseBehaviour));
#else
	TInt p[4];
	p[0] = aEndPoint.Handle();
	p[1] = aCloseBehaviour;
	return SendReceive(EIoPersistentConsoleAttachReadEndPoint, &p[0]);
#endif
	
	}
	
EXPORT_C void RIoPersistentConsole::AttachReaderL(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
	{
	User::LeaveIfError(AttachReader(aEndPoint, aCloseBehaviour));
	}
	
EXPORT_C void RIoPersistentConsole::DetachReader()
	{
#ifdef EKA2
	SendReceive(EIoPersistentConsoleDetachReadEndPoint, TIpcArgs());
#else
	TInt p[4];
	SendReceive(EIoPersistentConsoleDetachReadEndPoint, &p[0]);
#endif
	}
	
EXPORT_C void RIoPersistentConsole::NotifyReaderDetach(TRequestStatus& aStatus)
	{
	SendReceive(EIoPersistentConsoleNotifyReadDetach, aStatus);
	}
	
EXPORT_C void RIoPersistentConsole::CancelNotifyReaderDetach(TRequestStatus& aStatus)
	{
#ifdef EKA2
	SendReceive(EIoPersistentConsoleCancelNotifyReadDetach, TIpcArgs(&aStatus));
#else
	TInt p[4];
	p[0] = (TInt)&aStatus;
	SendReceive(EIoPersistentConsoleCancelNotifyReadDetach, &p[0]);
#endif
	}

EXPORT_C TInt RIoPersistentConsole::AttachWriter(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
	{
#ifdef EKA2
	return SendReceive(EIoPersistentConsoleAttachWriteEndPoint, TIpcArgs(aEndPoint.SubSessionHandle(), aCloseBehaviour));
#else
	TInt p[4];
	p[0] = aEndPoint.Handle();
	p[1] = aCloseBehaviour;
	return SendReceive(EIoPersistentConsoleAttachWriteEndPoint, &p[0]);
#endif
	}
	
EXPORT_C void RIoPersistentConsole::AttachWriterL(RIoEndPoint& aEndPoint, TCloseBehaviour aCloseBehaviour)
	{
	User::LeaveIfError(AttachWriter(aEndPoint, aCloseBehaviour));
	}
	
EXPORT_C void RIoPersistentConsole::DetachWriter()
	{
#ifdef EKA2
	SendReceive(EIoPersistentConsoleDetachWriteEndPoint, TIpcArgs());
#else
	TInt p[4];
	SendReceive(EIoPersistentConsoleDetachWriteEndPoint, &p[0]);
#endif
	}
	
EXPORT_C void RIoPersistentConsole::NotifyWriterDetach(TRequestStatus& aStatus)
	{
	SendReceive(EIoPersistentConsoleNotifyWriteDetach, aStatus);
	}
	
EXPORT_C void RIoPersistentConsole::CancelNotifyWriterDetach(TRequestStatus& aStatus)
	{
#ifdef EKA2
	SendReceive(EIoPersistentConsoleCancelNotifyWriteDetach, TIpcArgs(&aStatus));
#else
	TInt p[4];
	p[0] = &aStatus;
	SendReceive(EIoPersistentConsoleCancelNotifyWriteDetach, &p[0]);
#endif
	}
	
EXPORT_C TInt RIoPersistentConsole::GetAttachedReaderAndWriterNames(TName& aReaderName, TName& aWriterName)
	{
#ifdef EKA2
	return SendReceive(EIoPersistentConsoleGetAttachedNames, TIpcArgs(&aReaderName, &aWriterName));
#else
	TInt p[4];
	p[0] = &aReaderName;
	p[1] = &aWriterName;
	return SendReceive(EIoPersistentConsoleGetAttachedNames, &p[0]);
#endif
	}
	
EXPORT_C void RIoPersistentConsole::GetAttachedReaderAndWriterNamesL(TName& aReaderName, TName& aWriterName)
	{
	User::LeaveIfError(GetAttachedReaderAndWriterNames(aReaderName, aWriterName));
	}

EXPORT_C TInt RIoPersistentConsole::GetCreator(TThreadId& aThreadId)
	{
	TPckg<TThreadId> theadPckg(aThreadId);
#ifdef EKA2
	return SendReceive(EIoPersistentConsoleGetCreatorThreadId, TIpcArgs(&theadPckg));
#else
	TInt p[4];
	p[0] = &theadPckg;
	return SendReceive(EIoPersistentConsoleGetCreatorThreadId, &p[0]);
#endif
	}
	
EXPORT_C TThreadId RIoPersistentConsole::GetCreatorL()
	{
	TThreadId id;
	User::LeaveIfError(GetCreator(id));
	return id;
	}

//
// RIoFile.
//

EXPORT_C TInt RIoFile::Create(RIoSession& aSession, const TDesC& aFileName, TMode aMode)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreateFile, TIpcArgs(&aFileName, (TInt)aMode));
#else
	TInt p[4];
	p[0] = (TInt)&aFileName;
	p[1] = (TInt)aMode;
	return CreateSubSession(aSession, EIoCreateFile, &p[0]);
#endif
	}
	
EXPORT_C void RIoFile::CreateL(RIoSession& aSession, const TDesC& aFileName, TMode aMode)
	{
	User::LeaveIfError(Create(aSession, aFileName,aMode));
	}


//
// RIoNull.
//

EXPORT_C TInt RIoNull::Create(RIoSession& aSession)
	{
#ifdef EKA2
	return CreateSubSession(aSession, EIoCreateNull);
#else
	return CreateSubSession(aSession, EIoCreateNull, NULL);
#endif
	}

EXPORT_C void RIoNull::CreateL(RIoSession& aSession)
	{
	User::LeaveIfError(Create(aSession));
	}

//
// TIoHandleSet
//

EXPORT_C TIoHandleSet::TIoHandleSet(RIoSession& aIoSession, RIoReadHandle& aStdin, RIoWriteHandle& aStdout, RIoWriteHandle& aStderr)
	: iIoSession(aIoSession), iStdin(aStdin), iStdout(aStdout), iStderr(aStderr), iSpare(0)
	{
	}

EXPORT_C RIoSession& TIoHandleSet::IoSession() const
	{
	return iIoSession;
	}

EXPORT_C RIoReadHandle& TIoHandleSet::Stdin() const
	{
	return iStdin;
	}

EXPORT_C RIoWriteHandle& TIoHandleSet::Stdout() const
	{
	return iStdout;
	}

EXPORT_C RIoWriteHandle& TIoHandleSet::Stderr() const
	{
	return iStderr;
	}