/*

* 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:    

*

*/

#ifndef C_CBINDINGIMPLEMENTATION_H

#define C_CBINDINGIMPLEMENTATION_H

// INCLUDES

#include <e32base.h>

#include <es_sock.h>

#include <in_sock.h>

#include "mstuntransactionobserver.h"

#include "cstuntimeruser.h"

#include "mstunbindingobserver.h"

#include "natfwstunclientdefs.h"

// FORWARD DECLARATIONS

class CNATFWUNSAFMessage;

class CNATFWUNSAFUnknownAttributesAttribute;

class CBinding;

class CSTUNBindingState;

class CSTUNBindingInit;

class CSTUNBindingGetSharedSecret;

class CSTUNBindingGetAddress;

class CSTUNBindingActive;

class CSTUNBindingWaitToRetry;

class CSTUNClient;

class MSTUNBindingObserver;

class CSTUNTransaction;

class CStunIndicationTransmitter;

class MNcmConnectionMultiplexer;

// CLASS DECLARATION

/**

 * Hides the implementation of bindings for the user of STUNClient.

 *

 * @lib     natfwstunclient.lib

 * @since   s60 v3.2

 */

class CBindingImplementation : public CSTUNTimerUser,

                               public MSTUNTransactionObserver

    {

public: // default constructor

    CBindingImplementation( MSTUNBindingObserver& aClient,

                            CBinding& aBinding,                                

                            RSocket& aSocket );

    // overloaded default constructor

    CBindingImplementation( MSTUNBindingObserver& aClient,

                            CBinding& aBinding,

                            TUint aStreamId,

                            TUint aConnectionId,

                            MNcmConnectionMultiplexer* aMultiplexer );

public: // From CSTUNTimerUser

    virtual void TimerExpiredL() = 0;

    virtual void LeaveFromTimerExpired( TInt aError ) = 0;

public: // From MSTUNTransactionObserver

    virtual void PublicAddressObtainedL( const TInetAddr& aAddress ) = 0;

    // for stun relay functionality

    virtual void PublicAddressObtainedL( const TInetAddr& aReflexiveAddr,

                                         const TInetAddr& aRelayAddr ) = 0;

    virtual void TransactionError( TInt aError,

                CNATFWUNSAFUnknownAttributesAttribute* aUnknownAttr ) = 0;

    virtual void TransactionEventOccurredL( 

        TSTUNCallbackInfo::TFunction aEvent ) = 0;

    virtual void NewRTTSampleMeasured( TInt64& aRTTSample,

        TBool aRetransmitted );

public: // New functions

    /**

     * Refreshes the binding causing a new Binding Request to be sent

     * to the STUN server. The public IP address is available when 

     * MSTUNClientObserver gets called.

     *

     * @since   s60 v3.2

     * @return  void

     */

    virtual void SendRequestL();

    /**

     * Overloaded version of SendRequestL().

     *

     * @since   S60 v3.2

     * @param   aDestAddr       Destination where to send request

                                (KAFUnspec=default address)

     * @param   aAddFingerprint Whether to include fingerprint attribute

                                to request

     * @param   aRtoValue       Retransmission timeout

                                (=0 if default to be used)

     * @return  void

     */

    virtual void SendRequestL( const TInetAddr& aDestAddr,

                               TBool aAddFingerprint,

                               TUint aRtoValue );    

    /**

     * Refreshes the binding causing a new Binding Request to be sent

     * to the STUN server. The public IP address is available when 

     * MSTUNClientObserver gets called.

     *

     * @since   s60 v3.2

     * @param   aRtoValue Retransmission timeout(=0 if default to be used)

     * @return  void

     */

    virtual void AllocateRequestL( TUint aRtoValue );

    /**

     * Cancels a previously issued call to SendRequestL.

     *

     * @since   s60 v3.2

     * @return  void

     */

    virtual void CancelRequest() = 0;

    /**

     * Gets the socket used for obtaining the public address.

     *

     * @since   s60 v3.2

     * @return  socket

     */

    virtual const RSocket& Socket() const = 0;

    /**

     * Checks whether the public address has a value set

     *

     * @since   s60 v3.2

     * @return  ETrue if the public address has been obtained, 

     *          otherwise EFalse. 

     */

    virtual TBool AddressResolved() const = 0;

    /**

     * Gets the public address for this binding as seen in public network.

     *

     * @since   s60 v3.2

     * @return public address

     */

    virtual const TInetAddr& PublicAddr() const = 0;

    /**

     * Returns alternate server transport address.

     *

     * @since   s60 v3.2

     * @return alternate server address

     */

    virtual const TInetAddr& AlternateServerAddr() const = 0;

    /**

     * Returns realm value from error response.

     *

     * @since   s60 v3.2

     * @return realm from error response         

     */

    virtual const HBufC8* RealmFromResponse() const = 0; 

    /**

     * The client should call this function when it has received data

     * from the socket shared with this binding and 

     * the client cannot itself handle the data.

     *

     * @since   s60 v3.2  

     * @param   aData data received

     * @param   aConsumed on return ETrue if the data was accepted,

     *          otherwise EFalse.

     * @param   aRemoteAddr remote address from remote address attribute

     * @return  Decoded data if data is indication and not consumed,

     *          otherwise NULL. Ownership is transferred.

     */

    virtual HBufC8* HandleDataL( const TDesC8& aData, 

                                 TBool& aConsumed,

                                 TInetAddr& aRemoteAddr ) = 0;

    /**

     * Returns the associated CSTUNClient instance.

     *

     * @since   s60 v3.2

     * @return CSTUNClient, or NULL if the CSTUNClient has been deleted        

     */

    virtual const CSTUNClient* STUNClient() const = 0;

    /**

     * Get a STUN server address from STUN client

     *

     * @since   s60 v3.2

     * @return  void

     */

    virtual void GetServerAddressL() = 0;

    /**

     * Get a fresh a shared secret.

     *

     * @since   s60 v3.2

     * @return  void  

     */

    virtual void GetSharedSecretL() = 0;

    /**

     * Clears the pointer to CSTUNClient.

     *

     * @since   s60 v3.2

     * @post    iClient == NULL

     * @return  void   

     */

    virtual void DetachClient() = 0;

    /**

     * Store the obtained public address and inform application.

     *

     * @since   s60 v3.2

     * @param   aPublicAddress Public address

     * @return  void

     */

    virtual void StoreAddressL( const TInetAddr& aPublicAddress ) = 0;

    /**

     * Store the obtained addresses and inform application.

     *

     * @since   s60 v3.2

     * @param   aReflexiveAddr  public IP address (server reflexive)

     * @param   aRelayAddr      public relay IP address

     * return   void

     */

    virtual void StoreAddressL( const TInetAddr& aReflexiveAddr,

                                const TInetAddr& aRelayAddr );

    /**

     * Change the object's state.

     *

     * @since   s60 v3.2

     * @param   aNewState State to enter.

     * @return  void

     */

    virtual void ChangeState( CSTUNBindingState& aNewState ) = 0;

    /**

     * Binding encountered an error and enters terminated state. The function

     * MSTUNClientObserver::BindingErrorL is used to inform application.

     *

     * @since   s60 v3.2

     * @pre     aError != KErrNone

     * @param   aError Error code

     * @return  void

     */

    virtual void Terminate( TInt aError ) = 0;

    /**

     * Checks if this binding is waiting for shared secret.

     *

     * @since   s60 v3.2

     * @return  ETrue BInding is waiting shared secret, EFalse otherwise

     */

    virtual TBool IsWaitingSharedSecret() const = 0;

    /**

     * STUN client uses this function to give the username and password, that

     * the binding requested earlier with function

     * MSTUNBindingObserver::ObtainSharedSecretL.

     *

     * @since   s60 v3.2

     * @pre     aUsername and aPassword must either both have a descriptor that

     *          is not empty, or then both must have an empty descritor.

     * @param   aUsername Username or an empty descriptor if the shared secret

     *          is not used.

     * @param   aPassword Password or an empty descriptor if the shared secret

     *          is not used.

     * @param   void

     */

    virtual void SharedSecretObtainedL( const TDesC8& aUsername,

        const TDesC8& aPassword ) = 0;

    /**

     * Creates or updates a Binding Request message, using the given username

     * and password.

     *

     * @since   s60 v3.2

     * @param   aUsername Username

     * @param   aPassword Password

     * @return  void

     */

    virtual void CreateBindingRequestL( const TDesC8& aUsername,

        const TDesC8& aPassword ) = 0;

    /**

     * Creates a transaction for sending Binding Request message

     *

     * @since   s60 v3.2

     * @pre     iRequest != NULL

     * @return  void

     */      

    virtual void SendBindingRequestL() = 0;

    /**

     * Take actions based on the reason why transaction failed. For certain

     * errors, it is possible to send the Binding Request again.

     *

     * @since   s60 v3.2

     * @pre     aError != KErrNone

     * @param   aError Error reason

     * @return  ETrue Request can be retried

     *          EFalse Binding enters Terminated-state

     */

    virtual TBool HandleTransactionError( TInt aError ) = 0;

    /**

     * Forward the ICMP error to transaction for processing.

     *

     * @since   s60 v3.2

     * @param   aAddress Address where the ICMP error occurred

     * @return  void

     */

    virtual void IcmpError( const TInetAddr& aAddress ) = 0;

    /**

     * Wait before retring to send a Binding Request

     *

     * @since   s60 v3.2

     * @return  void

     */

    virtual void WaitBeforeRetrying() = 0;

    /**

     * ICE specific attributes can be set for the request.

     *  

     * @since   s60 v3.2

     * @param   aAttributes     Contains ICE specific attributes.

     * @return  void

     */

    virtual void SetICESpecificAttributes( 

        const TICEAttributes& aAttributes ) = 0;

    /**

     * Returns the relay address allocated for this binding.

     *

     * @since   s60 v3.2

     * @return  STUN Relay public IP address

     */               

    virtual const TInetAddr& RelayAddr() const;

    /**

     * 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   aRemoteAddr Client can specify remote address

     * @since   aTimerValue Client gets timer value after response

     * @return  void

     */

    virtual void SetActiveDestinationRequestL( 

        const TInetAddr& aRemoteAddr, TUint32& aTimerValue );

    /**

     * Send indication to remote address. Indications are not

     * retransmitted and responses are not expected.

     *

     * @since   s60 v3.2

     * @param   aRemoteAddr     Address to send to (remote agent)

     * @param   aData           Data to send to remote agent. Use KNullDesC8

     *                          if there is no data available.

     * @param   aAddFingerprint Add fingerprint attribute if true

     * @return  void

     */

    virtual void SendIndicationL( const TInetAddr& aRemoteAddr, 

        const TDesC8& aData, TBool aAddFingerprint ) = 0;

    /**

     * The Connect Request is used by a client when it has obtained an

     * allocated transport address that is TCP.  The client can use the

     * Connect Request to ask the server to open a TCP connection to a

     * specified destination address included in the request.

     *

     * @since   s60 v3.2

     * @param   aRemoteAddr remote address

     * @return  void

     */

    virtual void ConnectRequestL( const TInetAddr& aRemoteAddr );

    /**

     * client can query used stream id

     *

     * @since   s60 v3.2

     * @return  stream Id

     */

    virtual TUint StreamId( ) const = 0;

    /**

     * client can query used connection id

     *

     * @since   s60 v3.2

     * @return  connection Id

     */

    virtual TUint ConnectionId( ) const = 0;

public: // New functions, for internal use

    /**

     * Release the memory of the Binding Request related data. This data is

     * only needed for sending a Binding Request and receiving a response.

     *

     * @since   s60 v3.2

     * @return  void

     */

    virtual void FreeRequestData() = 0;

    /**

     * Return STUN client handle.

     *

     * @since   s60 v3.2

     * @pre     iClient != NULL

     * @return  STUN client

     * @leave   KErrNotFound If the STUN client has been deleted

     */

    virtual MSTUNBindingObserver& ClientL() const = 0;

    /**

     * Return the current username, or an empty descriptor if username

     * does not exist.

     *

     * @since   s60 v3.2

     * @return  Username

     */

    virtual const TDesC8& Username() const = 0;

    /**

     * Checks if the STUN server has requested client to use a shared secret.

     * @return  ETrue if STUN server requires the use of a shared secret

     *          EFalse otherwise

     */

    virtual TBool IsSharedSecretRequired() const = 0;

    /**

     * Decodes a byte stream and return the decoded UNSAF message.

     * @param   aData Byte stream to decode

     * @return  Decoded message, ownership is transferred.

     *          NULL if the stream didn't contain an UNSAF message.

     */

    virtual CNATFWUNSAFMessage* DecodeMessageL( const TDesC8& aData ) const = 0;

    /**

     * Used binding

     *

     * @since   s60 v3.2

     * @return  void

     */

    virtual const CBinding& Binding() = 0;

    /**

     * Cancels retransmission process after transaction expires.

     *

     * @since   s60 v3.2

     * @return  void

     */

    virtual void CancelRetransmission();

private:

     void CalculateNewRTO( TInt64& aRTTSample );

protected: // Data

    /**

     * Associated STUN client instance

     * Not own.

     */

    MSTUNBindingObserver* iClient;

    /**

     * Associated binding interface

     */

    CBinding& iBinding;

    /**

     * The user of NAT Traversal FW provides the UDP RSocket to be used in

     * Binding Requests and responses. It is passed within CSTUNBinding::NewL

     * Each CSTUNBinding instance uses a separate RSocket.

     *

     * Not own. Must be NULLed in derived classes destructor.

     */

    RSocket* iSocket;

    /**

     * Used natfw stream id

     */

    TUint iStreamId;

    /**

     * Used natfw connection id

     */

    TUint iConnectionId;