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

	{