// Copyright (c) 2002-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:
// This module contains the code for the PPP "proxy" class which communicates with the lower Nif.
// 
//

#ifndef __PPPUMTS_INL__
#define __PPPUMTS_INL__

#include "PppUmts.h"
#include <e32std.h>

/****************/
/* CProtocolPpp */
/****************/

//
// The following functions are called by the NCP layer of lower Nif
//
inline void CProtocolPpp::Process(RMBufChain &aPacket,CProtocolBase* aSourceProtocol)
/**
 * Called by lower Nif to communicate received data to PPP.
 */
	{
	iPppUmtsLink->Process(aPacket, aSourceProtocol);
	}

inline void CProtocolPpp::Process(TDes8& aPDU,TSockAddr *from,TSockAddr *to,CProtocolBase* aSourceProtocol)
/**
 * Called by lower Nif to communicate received data to PPP (not used).
 */
	{
	iPppUmtsLink->Process(aPDU,from,to,aSourceProtocol);
	}

inline void CProtocolPpp::StartSending(CProtocolBase* /*aProtocol*/)
/**
 * Called by lower Nif to unblock flow control.
 */
	{
	iPppUmtsLink->StartSending(this);
	}

void CProtocolPpp::Identify(TServerProtocolDesc* /*aProtocolDesc*/) const
	{}

/****************/
/* CPppUmtsLink */
/****************/

inline void CPppUmtsLink::Process(RMBufChain &aPacket,CProtocolBase* /*aSourceProtocol*/)
/**
 * Called from CProtocolPpp when it receives data from lower Nif.  Pass data to LCP.
 *
 * @param aPacket MBuf chain containing received packet.
 */
	{
	DeliverToLcp(aPacket);
	}

inline void CPppUmtsLink::Process(TDes8& /*aPDU*/,TSockAddr * /*from*/,TSockAddr * /*to*/,CProtocolBase* /*aSourceProtocol*/)	// Up
	{
	PppPanic(EPppPanic_PPPNotSupported);
	}

inline void CPppUmtsLink::StartSending(CProtocolBase* /*aProtocol*/)
/**
 * Called from CProtocolPpp when it receives a request to unblock flow control from lower Nif.  Pass request to LCP.
 */
	{
	iPppLcp->LinkFlowOn();
	}

// CPppLinkBase API to PPP Nif

inline TInt CPppUmtsLink::Send(RMBufChain& aPacket, TUint aPppId/*=KPppIdAsIs*/)
/**
 * Called from PPP to send data to lower Nif.
 *
 * @param aPacket MBuf chain containing packet to transmit.
 * @returns 0 if Nif requested flow control block, else 1.
 */
	{
	return iUmtsNifPppBinder->Send(aPacket,(TAny *)aPppId);
	}

inline void CPppUmtsLink::OpenL()
	{
	}

inline void CPppUmtsLink::Close()
	{
	// Required only for the ts_dummyoveralltest
	// If LinkLayerDown must be called to let LCP know that physical layer has disconnected
	// Otherwise, PPP never terminates.
	iPppLcp->LinkLayerDown(KErrNone);
	}

inline void CPppUmtsLink::StartL()
/**
 * Called when Nifman calls Start() on PPP.  Call Start() on the lower Nif.
 */
	{
	iUmtsNif->Start();
	}

inline void CPppUmtsLink::GetSendRecvSize(TInt& aMaxRecvSize, TInt& aMaxSendSize)
	{
	aMaxRecvSize = 0;	// Dont Care
	aMaxSendSize = 0;	// Dont Care
	}

inline void CPppUmtsLink::GetDataTransfer(RPacketContext::TDataVolume& aData)
	{
	TPckg<RPacketContext::TDataVolume> info(aData);
	iUmtsNif->Notification(EAgentToNifEventTypeGetDataTransfer, &info);
	}

//
// Following functions implement the MNifIfNotify API to lower Nif.
//

inline void CPppUmtsLink::LinkLayerDown(TInt aReason, TAction /*aAction*/)
/**
 * Called from lower Nif to indicate that link layer has gone down.
 */
	{
	NotifyLinkDown(aReason);
	}

inline void CPppUmtsLink::LinkLayerUp()
/**
 * Called from lower Nif to indicate that link layer has come up (after a Start() call).
 */
	{
	NotifyLinkUp();
	}

inline void CPppUmtsLink::NegotiationFailed(CNifIfBase* aIf, TInt aReason)
	{iPppLcp->Notify()->NegotiationFailed(aIf, aReason);}

inline TInt CPppUmtsLink::Authenticate(TDes& aUsername, TDes& aPassword)
	{return iPppLcp->Notify()->Authenticate(aUsername, aPassword);}

inline void CPppUmtsLink::CancelAuthenticate()
	{iPppLcp->Notify()->CancelAuthenticate();}

inline TInt CPppUmtsLink::GetExcessData(TDes8& aBuffer)
	{return iPppLcp->Notify()->GetExcessData(aBuffer);}

/**
 * Called by lower Nif to read a CommDb field
 *
 * @param aField Name of CommDb field
 * @param aValue Receives the value of the field.
 * @param aMessage Message containing security capabilities to validate
 * @returns A system wide error code.
 */
inline TInt CPppUmtsLink::DoReadInt(const TDesC& aField, TUint32& aValue,const RMessagePtr2* aMessage)
	{ return iPppLcp->Notify()->ReadInt(aField,aValue,aMessage); }

/**
 * Called by lower Nif to write a CommDb field
 *
 * @param aField Name of CommDb field
 * @param aValue Value to write.
 * @param aMessage Message containing security capabilities to validate
 * @returns A system wide error code.
 */
inline TInt CPppUmtsLink::DoWriteInt(const TDesC& aField, TUint32 aValue,const RMessagePtr2* aMessage)
	{ return iPppLcp->Notify()->WriteInt(aField,aValue,aMessage); }

inline TInt CPppUmtsLink::DoReadDes(const TDesC& aField, TDes8& aValue,const RMessagePtr2* aMessage)
	{return iPppLcp->Notify()->ReadDes(aField, aValue,aMessage);}

inline TInt CPppUmtsLink::DoReadDes(const TDesC& aField, TDes16& aValue,const RMessagePtr2* aMessage)
	{return iPppLcp->Notify()->ReadDes(aField, aValue,aMessage);}

inline TInt CPppUmtsLink::DoWriteDes(const TDesC& aField, const TDesC8& aValue,const RMessagePtr2* aMessage)
	{return iPppLcp->Notify()->WriteDes(aField,aValue,aMessage);}

inline TInt CPppUmtsLink::DoWriteDes(const TDesC& aField, const TDesC16& aValue,const RMessagePtr2* aMessage)
	{return iPppLcp->Notify()->WriteDes(aField,aValue,aMessage);}

inline TInt CPppUmtsLink::DoReadBool(const TDesC& aField, TBool& aValue,const RMessagePtr2* aMessage)
	{return iPppLcp->Notify()->ReadBool(aField, aValue,aMessage);}

inline TInt CPppUmtsLink::DoWriteBool(const TDesC& aField, TBool aValue,const RMessagePtr2* aMessage)
	{return iPppLcp->Notify()->WriteBool(aField, aValue,aMessage);}

inline void CPppUmtsLink::IfProgress(TInt /*aStage*/, TInt /*aError*/)
/**
 * Called by lower Nif when signalling progress.  This does not need to be conveyed to Nifman.
 */
	{ }

inline void CPppUmtsLink::OpenRoute()
	{ iPppLcp->Notify()->OpenRoute(); }

inline void CPppUmtsLink::CloseRoute()
	{ iPppLcp->Notify()->CloseRoute(); }

inline TInt CPppUmtsLink::PacketActivity(TDataTransferDirection /*aDirection*/, TUint /*aBytes*/, TBool /*aResetTimer*/)
	{ return KErrNone; }

inline void CPppUmtsLink::IfProgress(TSubConnectionUniqueId aSubConnectionUniqueId, TInt aStage, TInt aError)
/**
 * Upcall from lower level nif to report progress on a subconnection
 * @param aSubConnectionUniqueId The id of the subconnection to which this notification refers
 * @param aStage The progress stage that has been reached
 * @param aError Any error relating to that progress stage
 * @note When PPP is running over another nif, only one subconnection is supported.
 * @note Since PPP.nif governs the state of the connection, the only progress that should be passed up is "suspended" from GPRS nifs
 */
	{
	if(aStage==KPsdSuspended)
		{
		iPppLcp->Notify()->IfProgress(aSubConnectionUniqueId, aStage, aError);
		}
	}

inline void CPppUmtsLink::NotifyDataSent(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aUplinkVolume)
/**
 * Upcall from lower level nif to report data sent on a subconnection
 * @param aSubConnectionUniqueId The id of the subconnection to which this notification refers
 * @param aUplinkVolume The total volume of data sent on the subconnection
 */
	{
	iPppLcp->Notify()->NotifyDataSent(aSubConnectionUniqueId, aUplinkVolume);
	}

inline void CPppUmtsLink::NotifyDataReceived(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aDownlinkVolume)
/**
 * Upcall from lower level nif to report data received on a subconnection
 * @param aSubConnectionUniqueId The id of the subconnection to which this notification refers
 * @param aUplinkVolume The total volume of data received on the subconnection
 */
	{
	iPppLcp->Notify()->NotifyDataReceived(aSubConnectionUniqueId, aDownlinkVolume);
	}


inline void CPppUmtsLink::NifEvent(TNetworkAdaptorEventType aEventType, TUint aEvent, const TDesC8& aEventData, TAny* aSource)
/**
 * Upcall from the nif to report an event
 * @param aSubConnectionUniqueId The id of the subconnection to which this event refers
 * @param aEvent The event from the nif
 * @todo Alter this when nifman is defined correctly
 * @see MNifIfNotify::NifEvent
 */
	{
	iPppLcp->Notify()->NifEvent(aEventType, aEvent, aEventData, aSource);
	}


inline TInt CPppUmtsLink::Notification(TNifToAgentEventType aEvent, void * aInfo)
/**
 * Called by lower Nif for passing notifications to the Agent.
 */
	{ return iPppLcp->Notify()->Notification(aEvent, aInfo); }

#endif