// 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:
// CNifIfBase and CProtocolBase shim layer functionality
// 
//

/**
 @file nif.cpp
*/

#include <e32base.h>
#include <networking/qos_if.h>
#include <nifmbuf.h>
#include <es_prot_internal.h>
#include <comms-infras/ss_subconnflow.h>
#include <comms-infras/ss_protflow.h>

#include "in_sock.h"
#include "in_iface.h"
#include "in6_if.h"

#include "flow.h"
#include "nif.h"
#include "notify.h"
#include "panic.h"
#include "ItfInfoConfigExt.h"

#include "nif4.h"		// for CIPShimIfBase::NewL()
#include "nif6.h"		// for CIPShimIfBase::NewL()

#include "IPProtoDeMux.h"

#include "../addressinfohook/inc/hookaddrinfo.h"


using namespace ESock;

//
// CIPShimIfBase methods
//

CIPShimIfBase* CIPShimIfBase::NewL(const TDesC8& aProtocol, CIPShimProtocolIntf *aIntf)
	{
	CIPShimIfBase* intf = NULL;

	if (aProtocol.CompareF(KProtocolIp()) == 0)
		{
		intf = CIPShimIfBase4::NewL(aProtocol);
		}
	else
	if (aProtocol.CompareF(KProtocolIp6()) == 0)
		{
		intf = CIPShimIfBase6::NewL(aProtocol);
		}
	else
		{
		// only support "ip" and "ip6" protocol names
		User::Leave(KErrArgument);
		}
	intf->SetProtocolIntf(aIntf);
	
	return intf;
	}


CIPShimIfBase::CIPShimIfBase(const TDesC8& aProtocolName)
	: CNifIfBase(), iBinderReady(EFalse), iProtIntf(NULL)
/**
CIPShimIfBase constructor
*/
	{
	__CFLOG_2(KIPProtoTag1, KIPProtoTag2, _L8("CIPShimIfBase %08x:\tCIPShimIfBase(aProtocolName '%S')"), this, &aProtocolName);
	iProtocolName.Copy(aProtocolName);
	}

CIPShimIfBase::~CIPShimIfBase()
	{
	__CFLOG_1(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\t~CIPShimIfBase()"), this);
	delete iShimNotify;

	for (TInt i = 0; i < iProtoBinders.Count(); i++)
		{
		iProtoBinders[i]->Unbind();
		}
		
	iProtoBinders.Close();

/*	ASSERT(iProtIntf);
	iProtIntf->NifDisappearing(this);*/
	
	/*
	 * it's not legal to assume that this pointer isn't NULL. There can be
	 * OOM conditions in the constructor (which doesn't follow the official
	 * 2 way constructions [in nif4 or nif6]) which can cause not to initialize
	 * this pointer.
	 */
	if (iProtIntf)
		{
		iProtIntf->NifDisappearing(this);
		}
	}

void CIPShimIfBase::ConstructL()
	{
	iShimNotify = CIPShimNotify::NewL(this);
	// Setup the CNifIfBase::iNotify for the benefit of the TCP/IP stack to call us
	iNotify = static_cast<MNifIfNotify*>(iShimNotify);	
	}

void CIPShimIfBase::StartL()
	{
	if (iUpperProtocol)
		{
		return;
		}
		
	TBuf<KMaxProtocolNameSize> protocolName;
	protocolName.Copy(iProtocolName);
	__CFLOG_2(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\tStartL(): FindAndLoadProtocolL('%S')"), this, &protocolName);    	
	iUpperProtocol = SocketServExt::FindAndLoadProtocolL(protocolName);
	iUpperProtocol->Open();
	
	
	// Retrieve the MNifIfUser derived object from the upper protocol

	TNifIfUser ifuser;
	TInt err = iUpperProtocol->GetOption(KNifOptLevel, KNifOptGetNifIfUser, ifuser, 0);

	if (err == KErrNone)
		{
		iNifUser = ifuser();

		// Inform the upper protocol of our CNifIfBase derived interface.
		// (the second argument does not appear to be used in current SymbianOS, so pass 0).
		__CFLOG_1(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\tStartL(): IfUserNewInterfaceL()"), this);    	

		CleanupClosePushL(*iUpperProtocol);
		iNifUser->IfUserNewInterfaceL(this, 0);	// Note: increments CNifIfBase reference
		CleanupStack::Pop();

		// Cleanup Note: if you ever add a leaving function after IfUserNewInterfaceL() above,
		// then you'll need to arrange for CleanupSignalNewInterface() to be called here (it is pushed
		// onto the cleanup stack later as there are no subsequent leaving functions in this routine.

		iNifUser->IfUserOpenNetworkLayer();				// Note: increments protocol reference count
		}
	else
		{
		__CFLOG_VAR((KIPProtoTag1, KIPProtoTag2, _L8("CIPShimIfBase %08x:\tStartL(): Error %d issuing KNifOptGetNifIfUser to protocol"), this, err));
		User::Leave(err);
		}
	}

void CIPShimIfBase::BindToL(CIPProtoBinder* aIPProtoBinder)
	{
	aIPProtoBinder->BindL(this);
	iProtoBinders.AppendL(aIPProtoBinder);
	}

void CIPShimIfBase::UnbindFrom(CIPProtoBinder* aIPProtoBinder)
	{
	TInt index = iProtoBinders.Find(aIPProtoBinder);

	// shouldn't try to unbind from a binder we're not bound to
	ASSERT(index >= 0);
	iProtoBinders.Remove(index);
	aIPProtoBinder->Unbind();
	}

//-=========================================
// MUpperDataReceiver methods
//-=========================================        
void CIPShimIfBase::Process(RMBufChain& aData)
	{
	iUpperProtocol->Process(aData, reinterpret_cast<CProtocolBase*>(this));
	}

//-=========================================
// MUpperControl methods
//-=========================================        
void CIPShimIfBase::StartSending()
	{
	if (!iBinderReady)
		{
		// Get config info (for first time)
		__CFLOG_1(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\tStartSending() (first time)"), this);
		GetConfigFirstTime();
		iBinderReady = ETrue;
		}

	if (iUpperProtocol)
		{
		// Call StartSending(...) in the context of "downstream path ready for first time"
		__CFLOG_1(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\tStartSending()"), this);
		iUpperProtocol->StartSending(reinterpret_cast<CProtocolBase*>(this));
		}
	}
	
void CIPShimIfBase::Error(TInt anError)
	{
	iProtoBinders[0]->Error(anError);
	}

#ifdef _DEBUG
void CIPShimIfBase::BindL(TAny* aId)
#else
void CIPShimIfBase::BindL(TAny* /*aId*/)
#endif
/**
Called from upper protocol to pass its CProtocolBase pointer
*/
	{
	//[401TODO] RZ: Is this assumption safe?
	ASSERT(iUpperProtocol == aId);
	
	if (iBinderReady && iUpperProtocol)
		{
		__CFLOG_2(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\tBindL(%08x)"), this, aId);
		iUpperProtocol->StartSending(reinterpret_cast<CProtocolBase*>(this));
		}
	}

void CIPShimIfBase::CleanupInterface(TInt aError)
	{
	__CFLOG_2(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %x:\tCleanupInterface(%d)"), this, aError);    	
	iUpperProtocol->Close();
	iUpperProtocol = NULL;
	
	if(iInterfaceNameRecorded && iProtoBinders.Count())
		{
        XInterfaceNames* itfNames = static_cast<XInterfaceNames*>(
			const_cast<Meta::SMetaData*>(iProtoBinders[0]->Flow().AccessPointConfig().FindExtension(XInterfaceNames::TypeId())));
		itfNames->RemoveInterfaceName(this);
		}

	// IfUserInterfaceDown may delete this object, so create a stack variable for the NifIfUser
	// so CloseNetworkLayer can be called on it.
	MNifIfUser* nifUser = iNifUser; 
	nifUser->IfUserInterfaceDown(aError, this);  	// Note: decrements CNifIfBase reference
	nifUser->IfUserCloseNetworkLayer();				// Note: decrements protocol reference count
	}

void CIPShimIfBase::RemoveInterfaceName(CIPProtoBinder* aBinder)
	{
	ASSERT(aBinder);
	
	if(iInterfaceNameRecorded)
		{
        XInterfaceNames* itfNames = static_cast<XInterfaceNames*>(
			const_cast<Meta::SMetaData*>(aBinder->Flow().AccessPointConfig().FindExtension(XInterfaceNames::TypeId())));
		itfNames->RemoveInterfaceName(this);
		}
	}


void CIPShimIfBase::Release(TInt aError)
	{
	/* CleanupInterface will delete the interface when it is done if refcount is 0 (it will decrement it itself).
	   If iRefCount 0 when release is called, Start must never have been
	   called on this nif.  */
	if (iProtoBinders.Count())
		{
		return;	//can't go away if we still have binders
		}
	   
	if (iRefCount == 0)
		{
		delete this;
		}
	else
		{
		CleanupInterface(aError);
		}
	}

TInt CIPShimIfBase::State()
	{
	return EIfDown;
	}

TInt CIPShimIfBase::ServiceHwAddrControl(TDes8& aOption)
/**
Service KSoIfHardwareAddr calls from upper protocol
*/
	{
	ASSERT(aOption.Length() == sizeof(TSoIfHardwareAddr));
	if (iProtoBinders.Count())
		{
		//[401TODO] RZ: we're probably need fixed array to avoid index changing
		return iProtoBinders[0]->Control(KSOLInterface, KSoIfHardwareAddr, aOption);		
		}
	else
		{
		__CFLOG_1(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\tServiceHwAddrControl(): no binders"), this);
		return KErrNotReady;
		}
	}

TInt CIPShimIfBase::ServiceConnInfo(TDes8& aOption)
/**
Service KSoIfGetConnectionInfo calls from upper protocol
*/
	{
	ASSERT(aOption.Length() == sizeof(TSoIfConnectionInfo));
	TUint8* ptr = const_cast<TUint8*>(aOption.Ptr());
	TSoIfConnectionInfo& returnedInfo = reinterpret_cast<TSoIfConnectionInfo&>(*ptr);

	returnedInfo.iIAPId = iConnectionInfo.iIapId;
	returnedInfo.iNetworkId = iConnectionInfo.iNetId;

	return KErrNone;
	}

TInt CIPShimIfBase::Control(TUint aLevel, TUint aName, TDes8& aOption, TAny* aSource)
	{
	__CFLOG_3(KIPProtoTag1, KIPProtoTag2, _L("CIPShimIfBase %08x:\tControl(aLevel 0x%x, aName 0x%x)"), this, aLevel, aName);
	if (aLevel == KSOLInterface)
		{
		switch (aName)
			{
		case KSoIfInfo:
			/* FALLTHROUGH */
		case KSoIfInfo6:
			return ServiceInfoControl(aOption, aName);

		case KSoIfConfig:
			return ServiceConfigControl(aOption);

		case KSoIfHardwareAddr:
			return ServiceHwAddrControl(aOption);

		case KSoIfGetConnectionInfo:
			return ServiceConnInfo(aOption);			
		case 0x734:
			iHookAddressInfo = (CHookAddressInfo*)aSource;
			return KErrNone;
		default:
			break;
			}
		}
		
	if (iProtoBinders.Count())
		{
		//[401TODO] RZ: we're probably need fixed array to avoid index changing
		return iProtoBinders[0]->Control(aLevel, aName, aOption);
		}
	return KErrNotReady;	
	}

void CIPShimIfBase::Info(TNifIfInfo& aInfo) const
	{
	// Fill in the TNifIfInfo::iName field, which is used by TCP/IP
	if (iProtoBinders.Count())
		{
		//[401TODO] RZ: we're probably need fixed array to avoid index changing
		iProtoBinders[0]->GetName(aInfo.iName);

		if(!iInterfaceNameRecorded)
			{
			XInterfaceNames* itfNames = static_cast<XInterfaceNames*>(
				const_cast<Meta::SMetaData*>(iProtoBinders[0]->Flow().AccessPointConfig().FindExtension(XInterfaceNames::TypeId())));
			itfNames->AddInterfaceNameL(this, aInfo.iName);
			iInterfaceNameRecorded = ETrue;
			}
		}	

	//[401TODO] DL: get rid of magic number
	aInfo.iVersion = TVersion(78,96,12453);

	}

TInt CIPShimIfBase::Send(RMBufChain& aPdu, TAny* /*aSource*/)
/**
Called from upper protocol to send a data packet.

@param aPdu packet to send
@param aSource unused
@return 0 if upper protocol should block until receipt of StartSending(), else 1.
*/
	{
	// demultiplex packets into the approriate senders
	const RMBufPktInfo* info = RMBufPacket::PeekInfoInChain(aPdu);
	CIPProtoBinder *binder = reinterpret_cast<CIPProtoBinder*>(info->iDstAddr.Port());
	
    //[401TODO] This check is there purely because of GuQoS interoperability
    //i.e.: GuQoS colloring packets for the Flow below IPShim. Get rid of
    //this if statement along with GuQoS.
	if (iProtoBinders.Count() == 1 || binder == NULL)
    	{
    	return iProtoBinders[0]->Send(aPdu);
    	}
    else
        {
        return binder->Send(aPdu);
        }
	}

TInt CIPShimIfBase::Notification(TAgentToNifEventType /*aEvent*/, void * /*aInfo*/)
/**
*/
	{
	return KErrNotSupported;
	}

void CIPShimIfBase::SetConnectionInfo(const TConnectionInfo& aConnectionInfo)
/**
Called from the Flow to provision the connection info to us.
*/
	{
	iConnectionInfo = aConnectionInfo;
	}

const TConnectionInfo& CIPShimIfBase::ConnectionInfo()
/**
Called from the Flow to provision the connection info to us.
*/
	{
	return iConnectionInfo;
	}

const TDesC8& CIPShimIfBase::ProtocolName()
/**
Return the associated protocol name.
*/
	{
	ASSERT(iProtocolName.Length());
	return iProtocolName;
	}

	
void CIPShimIfBase::AddIpAddrInfoL(CIPProtoBinder* aBinder, CSubConIPAddressInfoParamSet::TSubConIPAddressInfo& aAddrInfo)
	{
	ASSERT(iHookAddressInfo);
	iHookAddressInfo->AddL(aBinder, aAddrInfo);
	}

void CIPShimIfBase::RemoveIpAddrInfo(CIPProtoBinder* aBinder, CSubConIPAddressInfoParamSet::TSubConIPAddressInfo& aAddrInfo)
	{
	ASSERT(iHookAddressInfo);
    iHookAddressInfo->Remove(aBinder, aAddrInfo);	    
	}

void CIPShimIfBase::RemoveIpAddrInfo(CIPProtoBinder* aBinder)
	{
	if (iHookAddressInfo)
    	{
	    iHookAddressInfo->Remove(aBinder);
    	}
	}


CIPShimSubConnectionFlow& CIPShimIfBase::Flow()
	{
	ASSERT(iProtoBinders.Count() > 0);
	return iProtoBinders[0]->Flow();
	}
	
CIPShimProtocolIntf* CIPShimIfBase::ProtcolIntf()
	{
	ASSERT(iProtIntf);
	return iProtIntf;
	}