// Copyright (c) 2004-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:
// in_bind.cpp - inet protocol base
//

#include "in_bind.h"

//
//  CProtocolInet6Base
//
//


EXPORT_C TInt CProtocolInet6Binder::DoBindTo(CProtocolBase *aProtocol)
	/**
	* Performs the BindToL processing for the IP binding.
	*
	* This method exists for derived classes that override the default
	* CProtocolInet6Binder::BindToL for their own processing. They can first
	* call DoBindTo to handle the network bind, and then handle other binds.
	* If the bound protocol is a network, the CProtocolInet6Binder::iNetwork
	* is initialized and this protocol is bound to the network using
	* the BindL(this, id) function, where id is the value of the
	* TServerProtocolDesc::iProtocol field from this protocol. This must
	* be in range [1..255] and it maps directly the to protocol field
	* (next header in IPv6) of the IP header (TInet6HeaderIP and
	* TInet6HeaderIP4).
	*
	* Only one network bind is accepted. If protocol is bound
	* to multiple protocols which have either #KProtocolInet6Ip
	* or #KProtocolInetIp as their TServerProtocolDesc::iProtocol,
	* then the first one used in DoBindTo is the effective one,
	* the remaining ones are returned as if bind wast to some
	* other protocol.
	*
	* @param aProtocol
	*	This protocol is recognized as a "network", if the
	*	TServerProtocolDesc::iProtocol field contains the
	*	special value KProtocolInet6Ip (or KProtocolInetIp).
	*
	* @return
	* @li	= 0 (= KErrNone),
	*	It was the network bind, iNetwork
	*	has a non-NULL value and network layer can be accessed.
	* @li	> 0 (= protocol id value from aProtocol's
	*	TServerProtocolDesc::iProtocol).
	*	aProtocol was not the network (or network was already
	*	attached). It is up to the caller to decide what to do
	*	with this protocol.
	* @li	< 0 (= error code)
	*	An error detected.
	*
	* @note
	*	Because the return value is used for both error indication
	*	(= negative return), and for unprocessed protocol number, the
	*	implementation prevents use of protocol numbers that would
	*	be negative numbers when treated as signed integers. If such
	*	is required, the derived class must handle them by other
	*	means.
	*
	* Example, assuming your ESK contains
@verbatim
[upper]
filename= upper.prt
index= 1
bindto= ip6,other
@endverbatim
	* the socket server will call your BindToL twice, once for
	* 'ip6' and once for 'other'. If your 'upper' protocol does
	* not override the BindToL function, then the default implementation
	* of CProtocolInet6Binder handles the 'ip6' case, but leaves
	* with 'other'. To handle the above case, your overriding
	* BindToL could look as follows:
@code
CProtocolUpper::BindToL(CProtocolBase *aProtocol)
	{
	TInt id = DoBindTo(aProtocol);
	if (id == your_other_protocol_id)
		{
		// handle your bind to other, for example
		iOther = aProtocol;
		iOther->Open();
		iOther->BindL(this, your_id_or_something_else);
		}
	else if (id != KErrNone)
		{
		// Not ip6 or 'other
		User::Leave(KErrNotSupported);
		}
	}

CProtocolUpper::~CProtocolUpper
	{
	if (iOther)
		{
		// iOther->Unbind(this); // maybe needed, depends on 'other'
		iOther->Close();
		iOther = NULL;
		}
	}
@endcode
	*/
	{
	ASSERT(this != aProtocol);

	TServerProtocolDesc info;
	aProtocol->Identify(&info);
	// here bind_id is declared as TInt (because it is used as
	// return value). However, in info they are TUint.
	// A confusion may result if someone speficies "negative" protocol
	// ids -- msa
	TInt bind_id = (TInt)info.iProtocol;
	if (bind_id < 0)
		return KErrNotSupported;

	if (iNetwork == NULL &&
		(bind_id == (TInt)KProtocolInetIp || bind_id == (TInt)KProtocolInet6Ip))
		{
		//
		// The first network bind detected
		//
		iNetwork = ((CProtocolInet6Binder *)aProtocol)->NetworkService();
		aProtocol->Open();
		// If anything after this fails, the matching Unbind/Close()
		// will happen in the destructor... (Unbind is safe to call,
		// even if there is no matching succesful BindL).
		Identify(&info);
		TRAP(bind_id, aProtocol->BindL(this, info.iProtocol));
		}
	return bind_id;
	}

EXPORT_C void CProtocolInet6Binder::BindToL(CProtocolBase *aProtocol)
	/**
	* Bind to another protocol.
	*
	* This default implementation only handles the network bind. The
	* implementation is just a call to CProtocolInet6Binder::DoBindTo
	* and a leave with KErrNotSupported, if the protocol was not
	* the network (= IPv6) instance.
	*
	* If this handling is not sufficient, the derived class must
	* override this method and call first the CProtocolInet6Binder::DoBindTo
	* for network bind, and then handle the other allowed bindings.
	*
	* @param aProtocol
	*	Protocol to bind (see CProtocolInet6Binder::DoBindTo)
	*/
	{
	TInt err = DoBindTo(aProtocol);
	if (err == KErrNone)
		return;
	if (err > 0)
		err = KErrNotSupported;
	User::Leave(err);
	}

EXPORT_C CProtocolInet6Binder::~CProtocolInet6Binder()
	/**
	* Destructor.
	*
	* This handles unbinding from the network (iNetwork), if
	* it has been bound.
	*/
	{
	if (iNetwork != NULL)
		{
		CProtocolInet6Binder *const prt = iNetwork->Protocol();
		iNetwork = NULL;
		prt->Unbind(this);
		prt->Close();
		}
	}

//
// Provide default for the name services through the MNetworkService
//

EXPORT_C CHostResolvProvdBase* CProtocolInet6Binder::NewHostResolverL()
	/**
	* Gets the default name services provider from the network layer.
	* @return Default name services provider
	*/
	{
	if (iNetwork == NULL)
		User::Leave(KErrNotSupported);
	return iNetwork->NewHostResolverL();
	}

EXPORT_C CServiceResolvProvdBase* CProtocolInet6Binder::NewServiceResolverL()
	/**
	* Gets the default service resolver provider from the network layer.
	* @return Default service resolver provider
	*/
	{
	if (iNetwork == NULL)
		User::Leave(KErrNotSupported);
	return iNetwork->NewServiceResolverL();
	}


EXPORT_C CNetDBProvdBase* CProtocolInet6Binder::NewNetDatabaseL()
	/**
	* Gets the default net database provider from the network layer.
	* @return Default net database provider
	*/
	{
	if (iNetwork == NULL)
		User::Leave(KErrNotSupported);
	return iNetwork->NewNetDatabaseL();
	}