// Copyright (c) 1997-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 "IPC_MAIN.H"
#include "ES_IPC.H"

CIpcProvdBase::CIpcProvdBase(CIpcProtocolHolder* aProtocol)
	{
	__DECLARE_NAME(_S("CIpcProvdBase"));
	iProtocol=aProtocol;
	}

CIpcProvdBase::~CIpcProvdBase()
	{
	// ensure that another CIpcProvdBase doesn't end up with a dangling pointer to this CIpcProvdBase
	if (iConnection && iConnection->iConnection == this)
		{
		iConnection->iConnection = NULL;
		}
	
	iProtocol->SocketRemoved(iLocalAddr);
	}

void CIpcProvdBase::RemName(TSockAddr &anAddr)const
//
// Get the remote name we would connect to
//
	{
	anAddr.SetPort(iRemoteAddr);
	}

TInt  CIpcProvdBase::SetRemName(TSockAddr& anAddr)
//
// Set the remote name prior to connecting (or as part of a send to)
//
	{
	iRemoteAddr=anAddr.Port();
	return KErrNone;
	}

void CIpcProvdBase::LocalName(TSockAddr &anAddr)const
//
//  Get hte local name
//
	{
	anAddr.SetPort(iLocalAddr);
	}

TInt CIpcProvdBase::SetLocalName(TSockAddr &anAddr)
//
// Set the local name prior to accepting
//
	{
	TInt ret=iProtocol->CheckAndAllocatePortNumber(anAddr.Port());
	if (ret==KErrNone)
		iLocalAddr=anAddr.Port();
	return ret;
	}

void CIpcProvdBase::AutoBind( void )
//
// Automatically set the local name
//
	{
	iLocalAddr=iProtocol->GetNextFreePort();
	}

TInt CIpcProvdBase::GetOption(TUint /*level*/,TUint /*name*/,TDes8& /*anOption*/)const
//
//
//
	{
	return KErrNotSupported;
	}

TInt CIpcProvdBase::SetOption(TUint /*level*/,TUint /*name*/,const TDesC8& /*anOption*/)
//
//
//
	{
	return KErrNotSupported;
	}



void CIpcProvdBase::Ioctl(TUint /*level*/,TUint /*name*/,TDes8 * /*anOption*/)
//
//
//
	{
	iSocket->Error(KErrNotSupported,MSocketNotify::EErrorIoctl);
	}

void CIpcProvdBase::CancelIoctl(TUint /*aLevel*/,TUint /*aName*/)
	{
	}

TInt CIpcProvdBase::PassiveOpen(TUint aQue,const TDesC8 &/*aConnectionData*/)
//
//
//
	{
	return PassiveOpen(aQue);
	}

void CIpcProvdBase::Shutdown(TCloseType option,const TDesC8 &/*aDisconnectData*/)
//
// Shutdown with disconnect data
//
	{
	Shutdown(option);
	}

void CIpcProvdBase::ActiveOpen(const TDesC8 &/*aConnectionData*/)
//
// Active open with connection data - pass it on
//
	{
	ActiveOpen();
	}

void CIpcProvdBase::Start()
//
// Start the provider - do nothing
//
	{
	}


void CIpcProvdBase::ActiveOpen(void)
//
// Actively connect to a peer socket
//
	{

	CIpcProvdBase* peer=iProtocol->FindPeerForConnection(iRemoteAddr);
	CIpcProvdBase* newSocket=NULL;
	if (peer)
		newSocket=peer->GetCloneSocket();
	if (newSocket)
		{
		iConnection=newSocket;
		newSocket->iConnection=this;
		newSocket->iRemoteAddr=iLocalAddr;
		iSocket->ConnectComplete();
		peer->Connected(*newSocket);
		}
	else
		iSocket->Error(KErrCouldNotConnect);
	}

void CIpcProvdBase::Shutdown(TCloseType aType)
	{
	if (iConnection)
		iConnection->Disconnect();
	iConnection=NULL;
	if (aType!=EImmediate)
		iSocket->CanClose();
	}

void CIpcProvdBase::Disconnect()
	{

	if (iConnection)
		{
		if (iSocket)
			{
			iSocket->Disconnect();
			}
		iConnection=NULL;
		}

	iState=EDisconnected;
	}

TInt CIpcProvdBase::PassiveOpen(TUint /*aQue*/)
	{
	iState=EWaitingConnect;
	return KErrNone;
	}

void CIpcProvdBase::Connected(CIpcProvdBase& aSocket)
	{
	iSocket->ConnectComplete(aSocket);
	}

//

CIpcStreamProvd* CIpcStreamProvd::NewL(CIpcProtocolHolder* aProtocol)
	{
	CIpcStreamProvd* p=new(ELeave)CIpcStreamProvd(aProtocol);
	CleanupStack::PushL(p);
	p->iBuffer.SetLengthL(KIPCStreamDefaultBufferSize);
	CleanupStack::Pop();
	return p;
	}

CIpcStreamProvd::CIpcStreamProvd(CIpcProtocolHolder* aProtocol)
	:CIpcProvdBase(aProtocol)
	{
	__DECLARE_NAME(_S("CIpcStreamProvd"));
	}

CIpcProvdBase* CIpcStreamProvd::GetCloneSocket()
	{
	CIpcStreamProvd* newSock=NULL;
	if (iState!=EWaitingConnect)
		return newSock;

	TRAPD(ret,newSock=CIpcStreamProvd::NewL(iProtocol));
	if (ret!=KErrNone)
		{
		iSocket->Error(ret,MSocketNotify::EErrorConnect);
		return NULL;
		}

	newSock->AutoBind();
	iProtocol->Add(newSock);
	return newSock;
	}


TUint CIpcStreamProvd::Write(const TDesC8& aDesc,TUint /*options*/, TSockAddr* /*anAddr*/)
	{
	__ASSERT_DEBUG(iSocket,Panic(EBadWriteCall));
	if (!iConnection)
		{
		iSocket->Error(KErrDisconnected);
		// error occured, the only possible error for this protocol is KErrNoMemory
		return 0;
		}
	TInt len=Min(aDesc.Size(),iBuffer.Length()-iBuffer.Count());
	if (len)
		{
		iBuffer.Add(aDesc.Ptr(),len);
		iConnection->NewData(len);
		}
	else
		{
		// error occured on attempt to send data, the only possible error for 
		// this protocol is KErrNoMemory
		return 0;
		}
		
	return len;
	}

void CIpcStreamProvd::GetData(TDes8 &aDesc,TUint /*options*/,TSockAddr* /*anAddr*/)
	{
	__ASSERT_DEBUG(iConnection,Panic(EBadWriteCall));
	__ASSERT_DEBUG(iSocket,Panic(EBadWriteCall));

	CCirBuffer& buf=((CIpcStreamProvd *)iConnection)->iBuffer;

	__ASSERT_DEBUG(aDesc.Length()<=buf.Count(),Panic(EReadGetTooMuch));

	buf.Remove((TUint8 *)aDesc.Ptr(),aDesc.Length());
	iConnection->CanSend();
	}

void CIpcStreamProvd::NewData(TInt aLen)
//
// New data has arrived at our oppo.
//
	{
	iSocket->NewData(aLen);
	}

void CIpcStreamProvd::CanSend()
//
// New space has been made (in our buffer) by at our oppo.
//
	{
	iSocket->CanSend();
	}