diff -r 000000000000 -r 1bce908db942 natfw/natfwturnplugin/inc/natfwturnconnectionhandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/natfw/natfwturnplugin/inc/natfwturnconnectionhandler.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,532 @@ +/* +* Copyright (c) 2006 - 2007 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: Connection handler is responsible for creating connections +* to Connection Multiplexer and TURN Client. It is responsible +* to handle data received from different observers it +* implements. Connection handler implements 3 Connection +* Multiplexer's observers and STUNClientObserver. +* +*/ + + + + +#ifndef C_NATFWTURNCONNECTIONHANDLER_H +#define C_NATFWTURNCONNECTIONHANDLER_H + + +#include +#include +#include +#include + +#include "mncmconnectionobserver.h" +#include "mncmincomingconnectionobserver.h" +#include "mncmoutgoingconnectionobserver.h" +#include "mncmmessageobserver.h" +#include "natfwstunclientobserver.h" + +#include "natfwrefreshobserver.h" +#include "natfwtimerobserver.h" + +// forward declarations +class MNATFWPluginObserver; +class MNcmConnectionMultiplexer; +class CNATFWCandidate; +class CNATFWTurnRefreshTimer; +class CSTUNRelayBinding; +class CSTUNClient; +class TStreamData; +class TConnectionData; +class CNATFWNatSettingsApi; +class MNATFWTurnSettings; +class CNATFWTurnActiveDestinationTimer; +class CTurnAsyncCallback; +class CNATFWPluginApi; +class MNATFWServerSettings; +class CTurnServerSettings; + +/** + * Connection handler for TURN Plug-in. + * + * Connection handler is responsible for creating connections to Connection + * Multiplexer and TURN Client. It creates TURN Binding and it is responsible + * to handle data received from different observers it implements. Connection + * handler implements 3 Connection Multiplexer's observers and + * STUNClientObserver. + * + * @lib turnplugin.lib + * @since S60 v3.2 + */ +class CNATFWTurnConnectionHandler : public CBase, + public MSTUNClientObserver, + public MNcmConnectionObserver, + public MNcmIncomingConnectionObserver, + public MNcmOutgoingConnectionObserver, + public MNcmMessageObserver, + public MNATFWRefreshObserver, + public MNATFWTimerObserver + { + + friend class UT_CNATFWTurnConnectionHandler; + +public: + + /** + * Two-phased constructor. + * @param aTurnPlugin The TURN plugin instance + * @param aPluginObserver Observer for callbacks to STUN plug-in's client + */ + static CNATFWTurnConnectionHandler* NewL( + const CNATFWPluginApi& aTurnPlugin, + MNATFWPluginObserver& aPluginObserver ); + + /** + * Two-phased constructor. + * @param aTurnPlugin The TURN plugin instance + * @param aPluginObserver Observer for callbacks to STUN plug-in's client + */ + static CNATFWTurnConnectionHandler* NewLC( + const CNATFWPluginApi& aTurnPlugin, + MNATFWPluginObserver& aPluginObserver ); + + + ~CNATFWTurnConnectionHandler(); + + /** + * Initializes TURN Connection Handler. + * + * @since S60 v3.2 + * @param aIapId IAP ID used in retrieving IAP settings from + * NAT FW NAT Settings + * @param aDomain Domain name used in creating instance of NATFW + * NAT Settings to get STUN server address and port. + * @param aMultiplexer Reference to the Connection Multiplexer + */ + void PluginInitializeL( TUint32 aIapId, + const TDesC8& aDomain, + MNcmConnectionMultiplexer& aMultiplexer ); + + /** + * Finds out a STUN Server and establishes a connection to it. + * + * MNATFWPluginObserver::Notify is called with event code EServerConnected + * when connecting has completed. + * + * FetchCandidateL can be called after successful connecting. + * + * This is done asynchronously. + * + * @since S60 v3.2 + * @param aSocketServ The handle to socket server session + * @param aConnectionName The unique name of the RConnection + */ + void ConnectServerL( const RSocketServ& aSocketServ, + const TName& aConnectionName ); + + /** + * Fetches available candidates for a specified stream using given + * retransmission timeout for STUN transactions. + * + * RTO value 0 indicates default retransmission timeout as specified + * in STUN specification. + * + * @since S60 v3.2 + * @param aStreamId Stream identifier + * @param aRtoValue Retransmission timeout in milliseconds + * @param aAddrFamily KAFUnspec / KAfInet / KAfInet6 + * @param aBaseAddr Address from which to create connection + */ + void FetchCandidateL( TUint aStreamId, TUint aRtoValue, TUint aAddrFamily, + const TInetAddr& aBaseAddr ); + + /** + * Gets identifier for a connection that is associated with the + * given local end point. + * + * @since S60 v3.2 + * @param aLocalCandidate The local end point for a media + * @param aStreamId The stream identifier + * @param aConnectionId Reference to found ID + */ + void GetConnectionIdL( const CNATFWCandidate& aLocalCandidate, + TUint aStreamId, TUint& aConnectionId ); + + /** + * Starts TURN Refresh timer. Sends periodically keepalive messages to + * TURN client, which will keep the bindings to TURN Server active. + * + * @since S60 v3.2 + */ + void StartTurnRefresh(); + + /** + * Creates TURN Binding and calls AllocateRequestL(). + * + * @since S60 v3.2 + * @param aStreamId Stream ID of current TURN Binding + * @param aConnectionId Connection ID of current TURN Binding + */ + void CreateTURNBindingL( TUint aStreamId, TUint aConnectionId ); + + /** + * Enables/disables media receiving for the specified local candidate. + * + * MNATFWPluginObserver::Notify is called with event code + * EReceivingActivated/EReceivingDeactivated when status change has + * completed. While activated incoming data is delivered to the media + * engine. + * + * @since S60 v3.2 + * @pre FetchCandidate(/s) and possible ICE processing have completed + * @param aLocalCandidate The local end point for a media + * @param aState The receiving state + */ + void SetReceivingStateL( const CNATFWCandidate& aLocalCandidate, + TNATFWStreamingState aState ); + + /** + * Once the client wants to primarily receive from one peer, it can send + * a SetActiveDestination request. All subsequent data received from + * the active peer is forwarded directly to the client and vice versa, + * except that it is wrapped or framed according to the protocol used + * between the STUN relay client and STUN relay server. + * The SetActiveDestination Request does not close other bindings. Data + * to and from other peers is still wrapped in Send and Data indications + * respectively. + * + * @since S60 v3.2 + * @param aLocalCandidate The local end point for a media + * @param aState The sending state + * @param aDestAddr The remote end point for a media + */ + void SetSendingStateL( const CNATFWCandidate& aLocalCandidate, + TNATFWStreamingState aState, const TInetAddr& aDestAddr ); + + /** + * Validates that is outgoing message a TURN request or Send Indication. + * + * @since S60 v3.2 + * @param aMessage Message from which will be validated if + * it is TURN request or Send Indication + * @return ETrue if the message is TURN request or Send Indication + */ + TBool IsRequestOrIndicationL( const TDesC8& aMessage ) const; + + /** + * Validates that is incoming message a TURN response. + * + * @since S60 v3.2 + * @param aMessage Message from which will be validated if + * it is TURN response + * @return ETrue if the message is TURN response + */ + TBool IsTurnResponseL( const TDesC8& aMessage ) const; + +// From base class MStunClientObserver + + /** + * Indicates that asynchronous initialization of the related + * CSTUNClient has been completed and it can be used for + * creating CSTUNRelayBinding(s). + * + * @since S60 v3.2 + * @param aClient Handle to STUN client + * @param aCompletionCode Completion code + */ + void STUNClientInitCompleted( const CSTUNClient& aClient, + TInt aCompletionCode ); + + /** + * A TURN binding related event occurred. After this callback + * the aBinding can be used again by calling its SendRequestL + * function. + * + * @since S60 v3.2 + * @param aEvent Binding event occurred + * @param aBinding Handle to CBinding + */ + void STUNBindingEventOccurredL( TSTUNBindingEvent aEvent, + const CBinding& aBinding ); + + /** + * Error occurred during IP address resolution. This callback + * will also be called if STUNBindingEventOccurredL leaves. + * + * @since S60 v3.2 + * @param aBinding Handle to CBinding + * @param aError Error code + */ + void STUNBindingErrorOccurred( const CBinding& aBinding,TInt aError ); + + // from base class MNcmConnectionObserver + + /** + * Called by Connection Multiplexer when connection connecting completes. + * + * @since S60 v3.2 + * @param aStreamId Stream of target of notify + * @param aConnectionId Target of notify + * @param aType Type of notify + * @param aError Error code + */ + void ConnectionNotify( TUint aStreamId, + TUint aConnectionId, + TConnectionNotifyType aType, + TInt aError ); + +// from base class MNcmIncomingConnectionObserver + + /** + * Called by Connection Multiplexer when incoming message is found. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aMessage Message is a reference to constant message + * @param aConsumed Flag to indicate is this message consumed + * @param aLocalAddr A stream local address. + * @param aFromAddr A remote source address. ( From socket ) + * @param aPeerRemoteAddr A peer remote address. + * @param aConsumed A reference to a boolean variable which MUST + * be set by observer: ETrue is message was + * consumed, EFalse otherwise. + */ + void IncomingMessageL( TUint aStreamId, const TDesC8& aMessage, + const TInetAddr& aLocalAddr, const TInetAddr& aFromAddr, + const TInetAddr& aPeerRemoteAddr, TBool& aConsumed ); + +// from base class MNcmOutgoingConnectionObserver + + /** + * Called by Connection Multiplexer when outgoing message is found. + * + * @since S60 v3.2 + * @param aStreamId Stream where message was found + * @param aConnectionId Connection where message was found + * @param aDestinationAddress Destination address where the packet + * is being sent to. If this is set then + * connection ID is ignored + * @param aMessage Message is a reference to constant message + * which was found + * @param aConsumed Is reference to a boolean variable which + * MUST be set by observer: ETrue is message + * was consumed, EFalse otherwise. + */ + void OutgoingMessageL( TUint aStreamId, TUint aConnectionId, + const TInetAddr& aDestinationAddress, const TDesC8& aMessage, + TBool& aConsumed ); + +// from base class MNcmMessageObserver + + /** + * Called by Connection Multiplexer when incoming message is found. + * Allows connection observer to observe and make modifications to found + * message by offering an own copy of content with modification(s). + * + * TURN Plug-in must fill the peer address, because only TURN Plug-in can + * know currently activated destination. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aMessage Message is a reference to constant message + * @param aLocalAddr A stream local address. + * @param aFromAddr A remote source address. ( From socket ) + * @param aPeerRemoteAddr A peer remote address. + * @return Pointer to a heap descriptor with new content for message, + * otherwise NULL is returned. Ownership of the heap descriptor + * is transferred to connection multiplexer ( from observer ). + */ + HBufC8* IncomingMessageNotify( TUint aStreamId, + const TDesC8& aMessage, + const TInetAddr& aLocalAddr, + const TInetAddr& aFromAddr, + TInetAddr& aPeerRemoteAddr ); + +// from base class MNcmMessageObserver + + /** + * Called by Connection Multiplexer when outgoing message is found. + * Allows connection observer to observe and make modifications to found + * message by offering an own copy of content with modification(s). + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aDestinationAddress Destination address where the packet + * is being sent to. + * @param aMessage Message is a reference to constant message + * which was found + * @return pointer to a heap descriptor with new content for message, + * otherwise NULL is returned. Ownership of the heap descriptor is + * transferred to multiplexer (from observer). + */ + HBufC8* OutgoingMessageNotify( TUint aStreamId, + TUint aConnectionId, + const TInetAddr& aDestinationAddress, + const TDesC8& aMessage ); + + // from base class MNATFWRefreshObserver + + /** + * Sends binding requests to TURN Bindings. + * + * @since S60 v3.2 + */ + void BindingRefreshL(); + +// from base class MNATFWTimerObserver + + /** + * Notifies when active destination timer has triggered. + * + * @since S60 v3.2 + * @param aStreamId To identify the binding that the + * triggering was related to + * @param aConnectionId To identify the binding that the + * triggering was related to + */ + void TimerTriggeredL( TUint aStreamId, TUint aConnectionId ); + +private: + + CNATFWTurnConnectionHandler( const CNATFWPluginApi& aTurnPlugin ); + + void ConstructL( MNATFWPluginObserver& aPluginObserver ); + + void DeleteStream( TUint aStreamInd, TBool aRemoveMuxConn ); + + HBufC8* HandleIncomingMessageL( TUint aStreamId, const TDesC8& aMessage, + const TInetAddr& aLocalAddr, const TInetAddr& aFromAddr, + TInetAddr& aPeerRemoteAddr ); + + TInt IndexByStreamId( TUint aStreamId ); + + TConnectionData* ConnectionById( TUint aStreamInd, TUint aConnectionId ); + + TConnectionData* ConnectionByIndex( TUint aStreamInd, + TUint aConnectionInd ); + + void GenerateServerListL(); + + void TryNextServerL(); + + TConnectionData* FindConnection( TUint aStreamId, + const TInetAddr& aLocalAddr ); + + TBool MatchAddresses( const TInetAddr& aAddr1, const TInetAddr& aAddr2 ); + +private: + + /** + * Flag defining whether TURN refresh has been started + */ + TBool iTurnRefreshStarted; + + /** + * Currently selected index in list of servers ( iServerList ) + */ + TInt iServerIndex; + + /** + * Handle to the socket server. + */ + RSocketServ iSocketServ; + + /** + * Handle to the connection. + * Own. + */ + RConnection iConnection; + + /** + * Pointer to domain name data. + * Own. + */ + HBufC8* iDomain; + + /** + * Array for storing data for each stream + */ + RArray iStreamArray; + + +// Instances from other C -classes + + /** + * STUN and TURN client handle. + * Own. + */ + CSTUNClient* iStunClient; + + /** + * Set up stream for client. + * Not own. + */ + MNcmConnectionMultiplexer* iConnMux; + + /** + * Sends keepalive messages periodically. + * Own. + */ + CNATFWTurnRefreshTimer* iTurnRefreshTimer; + + /** + * Timer for setting Active Destination. + * Own. + */ + CNATFWTurnActiveDestinationTimer* iActiveDestinationTimer; + + /** + * Pointer to timer for STUN Client. + * Own. + */ + CDeltaTimer* iTimerServ; + + /** + * Pointer to NAT Settings. + * Own. + */ + CNATFWNatSettingsApi* iNatSettings; + + /** + * Pointer to TURN related NAT Settings. + * Not own. + */ + MNATFWTurnSettings* iTurnSettings; + + /** + * TURN UDP Refresh interval. + */ + TUint iTurnRefreshInterval; + + /** + * TURN Plug-in + * Not own. + */ + const CNATFWPluginApi& iTurnPlugin; + + /** + * Async callback handler + * own. + */ + CTurnAsyncCallback* iAsyncCallback; + + /** + * Array of server related settings + * Own. + */ + RPointerArray iServerList; + }; + +#endif // C_NATFWTURNCONNECTIONHANDLER_H