diff -r 000000000000 -r af10295192d8 linklayerprotocols/pppnif/SPPP/PppUmts.inl --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/linklayerprotocols/pppnif/SPPP/PppUmts.inl Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,273 @@ +// 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 + +/****************/ +/* 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 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