diff -r 000000000000 -r 1bce908db942 natfw/natfwconnectionmultiplexer/inc/cncmconnectionmultiplexer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/natfw/natfwconnectionmultiplexer/inc/cncmconnectionmultiplexer.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,753 @@ +/* +* Copyright (c) 2006-2008 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 multiplexer is responsible for handling network +* connections, sending and receiving data from the +* network and allows client to start media flow between +* connection multiplexer and socket media connection wrapper. +* +*/ + + + + +#ifndef C_CNCMCONNECTIONMULTIPLEXER_H +#define C_CNCMCONNECTIONMULTIPLEXER_H + +#include + +#include "natfwconnectivityapidefs.h" +#include "mncmmultiplexerconnectionobserver.h" +#include "mncmsessionobserver.h" +#include "mncmconnectionmultiplexer.h" +#include "mncmmediasourceobserver.h" + +class TInetAddr; +class MNcmConnectionMultiplexerObserver; +class MNcmMultiplexerConnectionObserver; +class MNcmIncomingConnectionObserver; +class MNcmOutgoingConnectionObserver; +class MNATFWMediaWrapper; +class CNcmPortStore; +class CNcmConnectionObserverHandler; +class RSocket; +class RConnection; +class RSocketServ; +class CNcmSession; +class CNcmStream; +class MNATFWMediaWrapper; +class MNcmSenderObserver; +class CNcmCallBackExecuter; + +/** + * Connection multiplexer is responsible for handling network + * connections, send and receive data from the network. It allows client + * to start data flow between connection multiplexer and socket media + * connection wrapper. + * + * Connection Multiplexer have one session per IAP and in session can be + * multiple streams and in streams can be multiple connections. + * + * @lib connectionmux.lib + * @since S60 v3.2 + */ +class CNcmConnectionMultiplexer : public CBase, + public MNcmConnectionMultiplexer, + public MNcmMultiplexerConnectionObserver, + public MNcmSessionObserver, + public MNcmMediaSourceObserver + { + + friend class UT_CNcmConnectionMultiplexer; + +public: + + /** + * Two-phased constructor + * + * @param aObserver Observer for Connection Multiplexer + */ + IMPORT_C static CNcmConnectionMultiplexer* NewL( + MNcmConnectionMultiplexerObserver& aObserver ); + + /** + * Destructor + */ + virtual ~CNcmConnectionMultiplexer(); + + /** + * Creates a new session. On return the client received identifier for + * the session. The session is ready to be used when the client receives + * MNcmConnectionMultiplexerObserver::Notify callback with event code + * ESessionCreated. + * + * @since S60 v3.2 + * @param aIapId The IAP used for a conection + * @param aPortRangeStart Port range start for session + * @param aPortRangeStop Port range stop for session + * @return The ID for the created session. + */ + IMPORT_C TUint CreateSessionL( TUint32 aIapId, TUint aPortRangeStart, + TUint aPortRangeStop ); + + /** + * Creates a new stream. + * + * This is done synchronously. + * + * @since S60 v3.2 + * @param aSessionId The ID identifying session + * @param aQos The desired quality of service + * @param aProtocol The protocol to be used, + * KProtocolInetUdp / KProtocolInetTcp + * @return The ID for the created stream. + */ + IMPORT_C TUint CreateStreamL( TUint aSessionId, TInt aQos, + TUint aProtocol ); + + /** + * Removes session and all its streams and streams connections + * + * This is done synchronously. + * + * @since S60 v3.2 + * @param aSessionId The ID identifying session + * @return void + */ + IMPORT_C void RemoveSessionL( TUint aSessionId ); + + /** + * Removes stream and all its connections. + * + * This is done synchronously. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @return void + */ + IMPORT_C void RemoveStreamL( TUint aStreamId ); + + /** + * Registers a media wrapper into stream. Ownership of wrapper is + * also transferred to Connection Multiplexer. + * + * @since S60 v3.2 + * @param aMediaWrapper Pointer to Socket Media Connection Wrapper + * @return void + */ + IMPORT_C void RegisterMediaWrapperL( MNATFWMediaWrapper* aMediaWrapper ); + + /** + * Receives port store associated to session + * + * @since S60 v3.2 + * @param aSessionId The ID identifying session + * @return Port store used on session + */ + IMPORT_C CNcmPortStore& PortStoreL( TUint aSessionId ); + + /** + * Gets the socket server handle and the unique name of + * the RConnection used by the connection multiplexer session. + * + * @since S60 v3.2 + * @param aSessionId The ID identifying session + * @param aConnectionName The unique name of the RConnection + * @return handle to socket server + */ + IMPORT_C RSocketServ* GetSessionInfoL( TUint aSessionId, + TName& aConnectionName ); + + /** + * Enables/disables media flow from Connection Multiplexer to + * Socket Media Connection Wrapper for the specified connection. + * + * The receiving is enabled/disabled when the client receives + * MNcmConnectionMultiplexerObserver::Notify callback with event code + * EReceivingActivated/EReceivingDeactivated. + * While incoming data from network is passed to Socket Media Connection + * Wrapper if receiving for media is activated. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aState The receiving state + * @return void + */ + IMPORT_C void SetReceivingStateForMediaL( TUint aStreamId, + TUint aConnectionId, TNATFWStreamingState aState ); + + /** + * Enables/disables media flow from Socket Media Connection Wrapper to + * Connection Multiplexer for the specified connection. + * + * The sending is enabled/disabled when the client receives + * MNcmConnectionMultiplexerObserver::Notify callback with event code + * ESendingActivated/ESendingDeactivated. While incoming data from + * Socket Media Connection Wrapper is delivered to specified connection + * which is used to send media to network if sending for media is + * activated. + * + * @since S60 3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aState The sending state + * @return void + */ + IMPORT_C void SetSendingStateForMediaL( TUint aStreamId, + TUint aConnectionId, TNATFWStreamingState aState ); + + /** + * Resolves the destination IP address from FQDN. + * ( Address and port ) + + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aAddress The Destination FQDN + * @param aPort The Destination port + * @param aResult On return contains the resolved IP address + * @return void + */ + IMPORT_C void ResolveDestinationAddressL( TUint aStreamId, + const TDesC8& aAddress, TUint aPort, TInetAddr& aResult ); + +// from base class MNcmConnectionMultiplexer + + /** + * Creates a new connection for stream. Will use same protocol as + * used in stream. Address family specifies address family + * which is used to choose whether IPv4 or IPv6 connection will be made. + * + * This is done synchronously. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aAddrFamily The address family(KAfInet/KAfInet6) + * KAfInet, IPv4 local address is used + * KAfInet6, IPv6 local address is used + * @return The ID for the created connection + * @leave KErrNotSupported If specified local address hasn't found + */ + IMPORT_C TUint CreateConnectionL( TUint aStreamId, TUint aAddrFamily ); + + /** + * Overloaded CreateConnectionL + * Creates a new connection for stream. Will use same protocol as + * used in stream. Connection is made by using specified local address. + * + * This is done synchronously. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aLocalAddr The specified local address. + * @return The ID for the created connection + */ + IMPORT_C TUint CreateConnectionL( TUint aStreamId, + const TInetAddr& aLocalAddr ); + + /** + * Removes the specified connection. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionnId The ID identifying connection + * @return void + */ + IMPORT_C void RemoveConnectionL( TUint aStreamId, TUint aConnectionnId ); + + /** + * Fetches stream specific information which is formerly stored, while + * stream was created + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aIapId IAP Id for session + * @param aQos The quality of service + * @param aProtocol KProtocolInetUdp / KProtocolInetTcp + * @return void + */ + IMPORT_C void GetStreamInfoL( TUint aStreamId, TUint32& aIapId, + TInt& aQos, TUint& aProtocol ); + + /** + * Returns the local IP address and port of specified connection. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @return Local IP address + */ + IMPORT_C TInetAddr& LocalIPAddressL( TUint aStreamId, + TUint aConnectionId ); + + /** + * Establishes TCP connection. Connection will be established in specified + * direction using given connection setup. + * + * MNcmConnectionObserver::ConnectionNotify is called with event code + * ETcpSetupCompleted when connection setup is completed. + * + * SetReceivingStateL/SetSendingStateL can be called normally after + * successfull connection initialization. + * + * @since S60 3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aConfig TCP connection setup configuration + * @param aDestAddr The destination address for active connection + * @return void + */ + IMPORT_C void OpenTcpConnectionL( TUint aStreamId, TUint aConnectionId, + TNATFWTcpConnectionSetup aConfig, const TInetAddr& aDestAddr ); + + /** + * Closes TCP connection or cancels in-progress connection process. + * + * If TCP connection establishment is in-progress + * MNcmConnectionObserver::Notify is called with event code + * ETcpConnSetupCompleted and error code KErrCancel. + * + * After successful connection closing SetupTcpConnectionL can be + * called again with different destination address. + * + * @since S60 3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @return void + */ + IMPORT_C void CloseTcpConnection( TUint aStreamId, TUint aConnectionId ); + + /** + * Registers an observer for observing incoming messages in + * specific stream. This method won't register observer again if + * client have allready registered. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aObserver Observer to be registered + * @return void + */ + IMPORT_C void RegisterIncomingConnectionObserverL( TUint aStreamId, + MNcmIncomingConnectionObserver& aObserver ); + + /** + * Registers an observer for outgoing messages in specific + * stream. This method won't register observer again if + * client have allready registered. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aObserver Observer to be registered + * @return void + */ + IMPORT_C void RegisterOutgoingConnectionObserverL( TUint aStreamId, + MNcmOutgoingConnectionObserver& aObserver ); + + /** + * Unregisters specified observer. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aObserver Observer to be unregistered + * @return void + */ + IMPORT_C void UnregisterIncomingConnectionObserverL( TUint aStreamId, + MNcmIncomingConnectionObserver& aObserver ); + + /** + * Unregisters specified observer. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aObserver Observer to be unregistered + * @return void + */ + IMPORT_C void UnregisterOutgoingConnectionObserverL( TUint aStreamId, + MNcmOutgoingConnectionObserver& aObserver ); + + /** + * Registers an observer for connection notifies. + * This method won't register observer again if + * client have allready registered. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aObserver Observer to be registered + * @return void + */ + IMPORT_C void RegisterConnectionObserverL( TUint aStreamId, + MNcmConnectionObserver& aObserver ); + + /** + * Unregisters specified observer. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aObserver Observer to be unregistered + * @return void + */ + IMPORT_C void UnregisterConnectionObserverL( TUint aStreamId, + MNcmConnectionObserver& aObserver ); + + /** + * Registers an observer for receive incoming and outgoing message + * notifications. All notifications are offered first to this observer. + * There can be only one registered observer at a time. + * Message observer is allowed to make modifications to offered + * messages. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aObserver Observer to be registered + * @return void + */ + IMPORT_C void RegisterMessageObserverL( TUint aStreamId, + MNcmMessageObserver& aObserver ); + + /** + * Unregisters an observer for receiving incoming and outgoing message + * notifications. + * + * @since S60 v3.2 + * @param aStreamId A stream ID + * @param aObserver to be unregistered + * @return void + */ + IMPORT_C void UnregisterMessageObserverL( TUint aStreamId, + MNcmMessageObserver& aObserver ); + + /** + * Sends a message from specified connection to network. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aMessage A message to be copied and + * then sent asynchronously. + * @param aSenderObserver Observer for this send. + * @return void + */ + IMPORT_C void SendL( TUint aStreamId, TUint aConnectionId, + const TDesC8& aMessage, MNcmSenderObserver* aSenderObserver = NULL ); + + /** + * Overloaded SendL + * Sends a message from specified connection to network. + * Destination address parameter tells + * the destination address for the message. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying conenction + * @param aMessage A message to be copied and + * then sent asynchronously. + * @param aDestinationAddress Destination address + * @param aSenderObserver Observer for this send. + * @return void + */ + IMPORT_C void SendL( TUint aStreamId, TUint aConnectionId, + const TDesC8& aMessage, const TInetAddr& aDestinationAddress, + MNcmSenderObserver* aSenderObserver = NULL ); + + /** + * Overloaded SendL + * Sends a message from connection which is found by next hop address. + * Destination address parameter tells the destination address for + * the message. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aMessage A message + * @param aNextHopAddress Specifies the IP address of the next + * hop in the route + * will be used to find connection which + * will be used for sending. + * @param aDestinationAddress Destination address. + * @return void + */ + IMPORT_C void SendL( TUint aStreamId, const TDesC8& aMessage, + const TInetAddr& aNextHopAddress, + const TInetAddr& aDestinationAddress ); + + /** + * Overloaded SendL + * Sends a message directly from connection. Will not offer this + * message to any registered observers if aSendDirectly is set to + * ETrue + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying conenction + * @param aMessage A message + * @param aSendDirectly if ETrue sends a message directly. + * Will not offer this message to any + * registered observers. + * normally and will be offered registered + * observers. + * @param aSenderObserver Observer for this send. + * @return void + */ + IMPORT_C void SendL( TUint aStreamId, TUint aConnectionId, + const TDesC8& aMessage, TBool aSendDirectly, + MNcmSenderObserver* aSenderObserver = NULL ); + + /** + * Cancels sender observer's message send processes. + * + * Client MUST call its destructor on this method and cancel all send + * processes which it is observing( Client have used SendL with + * sender observer param ), otherwise there can be panic. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aSenderObserver Observer which observing + * message send processes + * @return void + */ + IMPORT_C void CancelMessageSend( TUint aStreamId, TUint aConnectionId, + const MNcmSenderObserver* aSenderObserver ); + + + /** + * Enables/disables data receiving for the specified connection. + * + * MNcmConnectionObserver::ConnectionNotify is called with event code + * EReceivingActivated/EReceivingDeactivated when status change + * has completed. While incoming data is received from network. + * + * Connection receives can be use for sending + * after successful sending activation. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aState The receiving state + * @return void + */ + IMPORT_C void SetReceivingStateL( TUint aStreamId, TUint aConnectionId, + TNATFWStreamingState aState ); + + /** + * Enables/disables data sending for the specified connection. + * Function can be called again with new destination address while + * sending is in activated state. + * + * MNcmConnectionObserver::ConnectionNotify is called with event code + * ESendingActivated/ESendingDeactivated when status change + * has completed. + * + * Connection can be use for sending after successful sending activation. + * + * Destination address for TCP-connection is given in + * active TCP-connection setup. + * + * @since S60 3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aDestAddr The destination address where + * the client wants to connect to + * @param aState The sending state + * @return void + */ + IMPORT_C void SetSendingStateL( TUint aStreamId, TUint aConnectionId, + const TInetAddr& aDestAddr, TNATFWStreamingState aState ); + + /** + * Sets address from which incoming data is accepted from this moment + * onwards. Binds connection to the specified remote address. Unbinding + * can be done by setting unspecified address. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aAddress The remote address + */ + IMPORT_C void SetAcceptedFromAddressL( TUint aStreamId, + TUint aConnectionId, const TInetAddr& aAddress ); + + /** + * Static handler function for callbacks. + * + * @since S60 3.2 + * @param aObject The object reference + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aType The notify type + * @param aError The error code + * @return void + */ + static void HandleCallBack( CBase& aObject, TUint aStreamId, + TUint aConnectionId, TMultiplexerConnectionNotifyType aType, + TInt aError ); + +// from base class MNcmMultiplexerConnectionObserver + + /** + * From MNcmMultiplexerConnectionObserver + * + * Called by connection when transfer error occurs on it + * + * @since S60 v3.2 + * @param aSessionId The ID identifying session + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aNotifyType Type of notify + * @param aError The error code + * @return void + */ + void ConnectionError( TUint aSessionId, TUint aStreamId, + TUint aConnectionId, + TMultiplexerConnectionNotifyType aNotifyType, TInt aError ); + + /** + * From MNcmMultiplexerConnectionObserver + * + * Called by socket destination object when action completes + * (or error is reached) + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aType Type of notify + * @param aError Error code + * @return void + */ + void ConnectionNotify( TUint aStreamId, TUint aConnectionId, + TMultiplexerConnectionNotifyType aType, + TInt aError ); + + /** + * From MNcmMultiplexerConnectionObserver + * + * Called by socket destination object when current + * local port is already in use. + * Gets new free port. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aConnectionId The ID identifying connection + * @param aPort New free port + * @return void + */ + void GetNewFreePort( TUint aStreamId, TUint aConnectionId, TUint& aPort ); + +// from base class MNcmMediaSourceObserver + + /** + * From MNcmMediaSourceObserver + * + * Called by Media Source after wrapper has had sending error + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aError The error code + * @return void + */ + void WrapperSenderError( TUint aStreamId, TInt aError ); + + /** + * From MNcmMediaSourceObserver + * + * Called by Media Source if current local port is already in use. + * Gets new free port. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @param aPort New free port + * @return void + */ + void GetFreePort( TUint aStreamId, TUint& aPort ); + + /** + * From MNcmMediaSourceObserver + * + * Notifies that the first media packet is sent to + * the remote address. + * + * @since S60 v3.2 + * @param aStreamId The ID identifying stream + * @return void + */ + void FirstMediaPacketSent( TUint aStreamId ); + +// from base class MNcmSessionObserver + + /** + * From MNcmSessionObserver + * + * Notifies that session creation is failed. + * + * @since S60 v3.2 + * @param aSessionId The ID identifying session + * @return void + */ + void SessionCreationFailed( TUint aSessionId ); + +private: + + void ConstructL(); + + CNcmConnectionMultiplexer( + MNcmConnectionMultiplexerObserver& aObserver ); + + CNcmSession* SessionByIdL( TUint aSessionId ); + + CNcmStream* StreamByIdL( TUint aStreamId ); + + CNcmStream* StreamById( TUint aStreamId ); + + CNcmSession* SessionByStreamIdL( TUint aStreamId ); + + void ConnectionNotifyL( TUint aStreamId, TUint aConnectionId, + TMultiplexerConnectionNotifyType aType, TInt aError ); + + void GetNewFreePortL( TUint aStreamId, TUint aConnectionId, + TUint& aPort ); + + void HandleCallBackL( TUint aStreamId, TUint aConnectionId, + TMultiplexerConnectionNotifyType aType, TInt aError ); + + void CloseTcpConnectionL( TUint aStreamId, TUint aConnectionId ); + + void CancelMessageSendL( TUint aStreamId, TUint aConnectionId, + const MNcmSenderObserver* aSenderObserver ); + +private: // data + + /** + * Observer for this connection multiplexer + * Not own. + */ + MNcmConnectionMultiplexerObserver& iObserver; + + /** + * Next unused session ÍD + */ + TUint iNextSessionId; + + /** + * Created sessions. + * Own. + */ + RPointerArray iSessions; + + /** + * Async callback executer + * Own. + */ + CNcmCallBackExecuter* iAsyncCallback; + }; + + +#endif // C_CNCMCONNECTIONMULTIPLEXER_H