// Copyright (c) 2005-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 <ecom/ecom.h>

#include <obex/transport/obextransportcontrollerbase.h>

#include <obex/internal/mobexnotifyextend.h>

#include <obexirtransportinfo.h>

#include <obex/internal/obexactiverw.h>

#include <obextransportinfo.h>

#include <obex/internal/obexpacket.h>

#include <obexpanics.h>

#include "ObexTransportUtil.h" 

#include "obexconnectdata.h" 

#include "logger.h"

#include "obextransportfaults.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, "OBEXCT");

#endif

//Category used for internal panics

_LIT(KPanicCat, "TransCTBase");

// The minimum allowed number of 'transport controller' implementations. If 

// NewL doesn't find at least this many, then in debug NewL panics, and in 

// release it leaves.

const TUint KMinimumNumImplementations = 1;

/**

Constructs a CObexTransportControllerBase PlugIn object.

@internalTechnology

@return	A new CObexTransportControllerBase PlugIn object	

@panic TransCTBase EInvalidNumberOfTransportImplementations if there is more than one implementation for a given interface uid and transport name (equal to the default data in the plugin resource file

*/

EXPORT_C CObexTransportControllerBase* CObexTransportControllerBase::NewL(TObexTransportInfo& aTransportInfo)

	{

	LOG_LINE

	LOG_STATIC_FUNC_ENTRY

	//Making a copy as Collapse modifies the original iTransportName

	TBuf<60> transportName = aTransportInfo.iTransportName;

	TPtrC8 params = transportName.Collapse();	

	TEComResolverParams resolverParams; 

	resolverParams.SetDataType(*reinterpret_cast<TDesC8*>(&params));

	RImplInfoPtrArray implInfoArray;

	REComSession::ListImplementationsL(TUid::Uid(KObexTransportControllerInterfaceUid), resolverParams, KRomOnlyResolverUid,  implInfoArray);

	CleanupResetAndDestroyPushL(implInfoArray);

	__ASSERT_DEBUG(implInfoArray.Count() <= KMinimumNumImplementations, PANIC(KObexTransportPanicCat, EInvalidNumberOfTransportImplementations) ); 

	if (implInfoArray.Count() <  KMinimumNumImplementations)

		{

		User::Leave(KErrNotFound);

		}

	const TUid uid = implInfoArray[KMinimumNumImplementations - 1]->ImplementationUid();

	CleanupStack::PopAndDestroy(&implInfoArray);

	CObexTransportControllerBase* ptr = reinterpret_cast<CObexTransportControllerBase*> 

		(REComSession::CreateImplementationL(uid, _FOFF(CObexTransportControllerBase, iPrivateEComUID), 

			reinterpret_cast<TAny*>(&aTransportInfo)));

	CleanupStack::PushL(ptr);

	// Do any base construction here. This may in future include allocation of 

	// iFuture1.

	ptr->BaseConstructL();

	CleanupStack::Pop(ptr);

	return ptr;

	}

/**

Constructor.

@publishedPartner

@released

*/

EXPORT_C CObexTransportControllerBase::CObexTransportControllerBase()

	{

	LOG_LINE

	LOG_FUNC

	}

/**

This function is a place holder for future use. If iFuture1 variable is used 

it will need this function for any allocation required.

This function is called from CObexTransportControllerBase::NewL. 

*/

void CObexTransportControllerBase::BaseConstructL()

	{

	LOG_LINE

	LOG_FUNC

	}

/**

Sets the owner information from the received aOwner

@internalTechnology

*/

EXPORT_C void CObexTransportControllerBase::SetOwner(MObexNotifyExtend& aOwner)

	{

	LOG_LINE

	LOG_FUNC

	__ASSERT_ALWAYS(iOwner==NULL, PANIC(KPanicCat, EOwnerAlreadySet));

	iOwner = &aOwner;

	}

/**

Destructor.

@publishedPartner

@released

*/

EXPORT_C CObexTransportControllerBase::~CObexTransportControllerBase()

	{

	LOG_LINE

	LOG_FUNC

	delete iConnector;

	DeleteTransport();

	delete iTransportInfo;

	REComSession::DestroyedImplementation(iPrivateEComUID);

	}

/**

Cancels outstanding reads or writes

@internalTechnology

*/

EXPORT_C void CObexTransportControllerBase::CancelTransfers()

	{

	LOG_LINE

	LOG_FUNC

	if (iActiveReader)

		{

		iActiveReader->Cancel();

		}

	if (iActiveWriter)

		{

		iActiveWriter->Cancel();

		}

	}

/**

Calls on the constructor to take down the transport

@internalTechnology

@return TBool ETrue if the transport was taken down

*/

EXPORT_C TBool CObexTransportControllerBase::BringTransportDown()

	{

	LOG_LINE

	LOG_FUNC

	DeleteTransport();

	return iConnector->BringTransportDown();

	}

/**

Calls ConnectL on the connector

@internalTechnology

*/	

EXPORT_C void CObexTransportControllerBase::ConnectL ()

	{

	LOG_LINE

	LOG_FUNC

	iConnector->ConnectL();

	}

/**

Ask Connector to cancel connect

@see CObexTransportControllerBase::ConnectL

@internalTechnology

*/	

EXPORT_C void CObexTransportControllerBase::CancelConnect()

	{

	LOG_LINE

	LOG_FUNC

	iConnector->CancelConnect();

	}

/**

Calls accept connection on the connector

@internalTechnology

*/

EXPORT_C void CObexTransportControllerBase::AcceptConnectionL()

	{

	LOG_LINE

	LOG_FUNC

	iConnector->AcceptL();

	}

/**

Calls Cancel Accept on he connector

@see CObexTransportControllerBase::AcceptConnectionL

@internalTechnology

*/	

EXPORT_C void CObexTransportControllerBase::CancelAccept()

	{

	LOG_LINE

	LOG_FUNC

	if ( iConnector)

		{

		iConnector->CancelAccept();

		}

	}

/**

Calls signal transport error on the connector

@internalTechnology

*/

EXPORT_C void CObexTransportControllerBase::SignalTransportError()

	{

	LOG_LINE

	LOG_FUNC

	// If this is called during construction, iConnector could be NULL

	if(iConnector)

		{

		iConnector->SignalTransportError();

		}

	}

/**

returns the send packet

@return CObexPacket the packet that will be sent

@internalTechnology

*/	

EXPORT_C CObexPacket& CObexTransportControllerBase::SendPacket ()

	{

	LOG_LINE

	LOG_FUNC

	return *iSendPacket;

	}

/**

Returns the packet received

@return CObexPacket the packet that will be sent

@internalTechnology

*/

EXPORT_C CObexPacket& CObexTransportControllerBase::ReceivePacket ()

	{

	LOG_LINE

	LOG_FUNC

	return *iReceivePacket;

	}

/**

Ask active writer to do a send

@internalTechnology

*/

EXPORT_C void CObexTransportControllerBase::Send ()

	{

	LOG_LINE

	LOG_FUNC

	LOG3(_L8("Packet Sent, Opcode 0x%2x (0x%2x with final bit cleared), Length %d"), (iSendPacket->IsFinal() ? (iSendPacket->Opcode() | KObexPacketFinalBit) : iSendPacket->Opcode()), iSendPacket->Opcode(), iSendPacket->PacketSize());

	FTRACE(iSendPacket->Dump ());

	iActiveWriter->Transfer (*iSendPacket);

	}

/**

Init the send packet wtih the received, aOpcode, set final to true,  and send the packet

@internalTechnology

*/

EXPORT_C void CObexTransportControllerBase::Send (TObexOpcode aOpcode)

	{

	LOG_LINE

	LOG_FUNC

	LOG1(_L8("\taOpcode = %d"), aOpcode);

	iSendPacket->Init (aOpcode);

	iSendPacket->SetFinal (ETrue);

	Send ();

	}

/**

Ask activer reader to do a read

@internalTechnology

*/

EXPORT_C void CObexTransportControllerBase::Receive ()

	{

	LOG_LINE

	LOG_FUNC

	iActiveReader->Transfer (*iReceivePacket);

	}

/**

Is there a write outstanding

@return TBool  return ETrue is there is a write activer otherwise EFalse

@internalTechnology

*/		

EXPORT_C TBool CObexTransportControllerBase::IsWriteActive ()  const

	{

	LOG_LINE

	LOG_FUNC

	if (iActiveWriter)

		{

		return (iActiveWriter->IsActive());

		}

	else // this has been added incase of null iActiveWriter

		{

		return EFalse;

		}

	}

/**

Insert local Connection info with the received, aVersion, aFlags and from iReceivePacket into the receive packet, aPacket

@return TInt KErrNone or a symbian error

@param aPacket the packet that is updated with local connection info

@param aVersion 

@param aFlags

@internalTechnology

*/

EXPORT_C TInt CObexTransportControllerBase::InsertLocalConnectInfo (CObexPacket &aPacket, TUint8 aVersion, TUint8 aFlags)

	{

	LOG_LINE

	LOG_FUNC

	if (iReceivePacket)

		{

		TObexConnectData localinfo;

		localinfo.iVersion = aVersion;

		localinfo.iFlags = aFlags;

		localinfo.iMaxPacketLength = iReceivePacket->DataLimit();	// maximum packet length we can receive

		return (aPacket.InsertData (localinfo));	

		}

	else

		{

		return KErrGeneral;

		}

	}

/**

Extract the local information from the received packet 

@return EFalse- failed to extract the information. ETrue- extraction succeeded.

@param aPacket The packet from which  local connection info is extracted

@param aVersion

@param aFlags

@internalTechnology

*/

EXPORT_C TBool CObexTransportControllerBase::ExtractRemoteConnectInfo(CObexPacket &aPacket, TUint8& aVersion, TUint8& aFlags)

	{

	LOG_LINE

	LOG_FUNC

	if (iSendPacket)

		{

		TObexConnectData remoteinfo;

		if (!aPacket.ExtractData (remoteinfo))

			{

			return EFalse;

			}

		aVersion = remoteinfo.iVersion;

		aFlags = remoteinfo.iFlags;

		// Set the send buffer data limit (i.e. how much OBEX can use) to match the size of the

		// remote receive buffer (the setter function ensures it's a legal size)

		(void)iSendPacket->SetLegalDataLimit (remoteinfo.iMaxPacketLength);

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/**

@internalTechnology

*/

void CObexTransportControllerBase::ConstructPacketsL() 

	{

	LOG_FUNC

	// Set actual packet sizes

	// Receive must be at least KObexPacketDefaultSize to maintain functional compatibility with previous implentations

	// (to ensure that remote ends that ignore how big we say our receive buffer is get that same grace on buffer overflow)

	__ASSERT_DEBUG(iTransportInfo, PANIC(KPanicCat, ETransportNullPointer)); 

	TUint16 receivePacketBufferSize = Max ( iTransportInfo->iReceiveMtu, KObexPacketDefaultSize );

	TUint16 sendPacketBufferSize = iTransportInfo->iTransmitMtu;

	// Set initial "software throttle" for packets (how big OBEX says they are)

	// Send packet is set to miniumum, so initial transmit cannot overflow remote end

	TUint16 receivePacketDataLimit = GetReceivePacketDataLimit();

	TUint16 sendPacketDataLimit = KObexPacketMinSize;

	LOG2(_L8("CObexTransportControllerBase::ConstructPacketsL send buffer %d send data limit %d"), sendPacketBufferSize, sendPacketDataLimit);

	LOG2(_L8("CObexTransportControllerBase::ConstructPacketsL receive buffer %d receive data limit %d"), receivePacketBufferSize, receivePacketDataLimit);

	// Create the packets

	iSendPacket = CObexPacket::NewL(sendPacketBufferSize, sendPacketDataLimit);

	iReceivePacket = CObexPacket::NewL(receivePacketBufferSize, receivePacketDataLimit);

	}

/**

Gets the socket associated with the connector and asks the socket for its  remote name. 

This can be cast to the appropriate TSockAddr-derived class TIrdaSockAddr for IrDA. 

@publishedPartner

@released

*/

EXPORT_C void CObexTransportControllerBase::RemoteAddr(TSockAddr& aAddr)

	{

	LOG_LINE

	LOG_FUNC

	DoRemoteAddr(aAddr);

	}

/**

Returns true if the derived transport can re-connect when an obex connection is re-connected

This is used to determine whether to take the transport down when an obex connection has been disconnected

@see DoIsTransportRestartable

@return TBool return ETrue if the derived transport can support re-connection when obex re-connects

@publishedPartner

@released

*/	

EXPORT_C TBool CObexTransportControllerBase::IsTransportRestartable() const	

	{

	LOG_LINE

	LOG_FUNC

	return DoIsTransportRestartable();

	}

//MObexTransport Notify Protected 

/**

Process a Packet.  Upcall to the owner

@publishedPartner

@released

*/

EXPORT_C void CObexTransportControllerBase::DoProcess(CObexPacket &aPacket)

	{

	LOG_LINE

	LOG_FUNC

	__ASSERT_DEBUG(iOwner, PANIC(KPanicCat, ETransportNullPointer)); 

	iOwner->Process(aPacket);

	}

/**

Reports and error to the owner

@publishedPartner

@released

*/

EXPORT_C void CObexTransportControllerBase::DoError(TInt aError) 

	{

	LOG_LINE

	LOG_FUNC

	LOG1(_L8("\taError = %d"), aError);

	__ASSERT_DEBUG(iOwner, PANIC(KPanicCat, ETransportNullPointer)); 

	iOwner->Error(aError);

	}

/**

Create the transport objects and reports that the transport is up to the owner

@publishedPartner

@released

*/	

EXPORT_C void CObexTransportControllerBase::DoTransportUp(TObexConnectionInfo& aInfo)

	{

	LOG_LINE

	LOG_FUNC

	DeleteTransport();

	TRAPD(err, InitialiseTransportL(aInfo));

	if(err != KErrNone)

		{

		TransportUpError(err);

		}

	else

		{

		__ASSERT_DEBUG(iOwner, PANIC(KPanicCat, ETransportNullPointer));

		iOwner->TransportUp();

		Receive();

		}

	}

void CObexTransportControllerBase::InitialiseTransportL(TObexConnectionInfo& aInfo)

	{

	NewTransportL(aInfo);

	ConstructPacketsL();

	}

void CObexTransportControllerBase::TransportUpError(TInt aError)

	{

	// At this stage the transport controller will have a connection set-up.

	// As a result if we get an error while setting up Obex we should bring

	// the transport down (the owner has alrady been informed of the error,

	// but we shouldn't expect them to have to bring the transport down).