/*
* Copyright (c) 2005 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_CSTUNSHAREDSECRET_H
#define C_CSTUNSHAREDSECRET_H

// INCLUDES
#include <e32base.h>
#include "mnatfwunsaftlstransportobserver.h"
#include "cstuntimeruser.h"

// FORWARD DECLARATIONS
class RSocketServ;
class RConnection;
class TInetAddr;
class CNATFWUNSAFTlsTransport;
class CNATFWUNSAFSharedSecretRequest;
class CNATFWUNSAFAttribute;
class MSharedSecretObserver;
class CSTUNSharedSecretState;
class CSTUNSharedSecretConnecting;
class CSTUNSharedSecretWaitResponse;
class CSTUNSharedSecretWaitToRetry;
class CSTUNSharedSecretActive;
class CTransactionIDGenerator;

// CLASS DECLARATION

/**
 *  This class handles the obtaining of a shared secret.
 *
 *  @lib ?library
 *  @since S60 ?S60_version *** for example, S60 v3.0
 */
class CSTUNSharedSecret :    
    public CSTUNTimerUser,
    public MNATFWUNSAFTlsTransportObserver
    {
    	
    friend class ut_cstunsharedsecret;
    	
    public: // Constructors and destructor

        /**
        * Creates a new instance of CSTUNSharedSecret, and initiates the
        * procedures needed to obtain a shared secret.        
        * @param aSocketServer a connected socket server session        
        * @param aConnection an active connection to be used
        * @param aTimer Timer services
        * @param aAddr remote address of the TLS connection
        * @param aTransactionIDGenerator Provides unique TransactionIDs
        * @param aObserver An observer to receive callbacks
        * @param aLtUsername long term username
        * @param aLtPassword long term password
        * @return A new instance of CSTUNSharedSecret, ownership is transferred.
        */
        static CSTUNSharedSecret*
            NewL( RSocketServ& aSocketServer,
                  RConnection& aConnection,
                  CDeltaTimer& aTimer,
                  const TInetAddr& aAddr,
                  CTransactionIDGenerator& aTransactionIDGenerator,
                  MSharedSecretObserver& aObserver,
                  const TDesC8& aLtUsername,
                  const TDesC8& aLtPassword );

        ~CSTUNSharedSecret();

    public: // From CSTUNTimerUser

        void TimerExpiredL();

        void LeaveFromTimerExpired( TInt aError );
    
    public: // From MUNSAFTlsTransportObserver
    
        void TlsConnectedL();

        void IncomingMessageL( CNATFWUNSAFMessage* aMessage );

        void ErrorOccured( TInt aError );

    public: // New functions

        /**
        * Get the username.
        * @return Username, or an empty descriptor if username has not been
        *          obtained.
        */
        const TDesC8& Username() const;

        /**
        * Get the password.        
        * @return Password, or an empty descriptor if password has not been
        *          obtained.
        */
        const TDesC8& Password() const;

        /**
        * Change the object's state.        
        * @param aNewState State to enter, can be NULL.
        *                    Ownership is not transferred.        
        */
        void ChangeState( const CSTUNSharedSecretState* aNewState );

        /**
        * Terminate the state machine as an error has occurred.
        * @pre aError != KErrNone
        * @param aError Reason for the failure.
        */
        void Terminate( TInt aError );

        void SendRequestL();
        
        /**
        * Check if the received UNSAF message is correct and should be
        * processed.
        * @param aMessage UNSAF message
        * @return ETrue message is valid, EFalse otherwise
        */
        TBool CheckMessage( const CNATFWUNSAFMessage& aMessage ) const;        

        /**
        * Process a Shared Secret Response.        
        * @pre aResponse.Type() == CUNSAFMessage::ESharedSecretResponse
        * @param aResponse Shared Secret Response        
        */
        void ResponseReceivedL( const CNATFWUNSAFMessage& aResponse );
        
        /**
        * Process a Shared Secret Error Response.        
        * @pre aResponse.Type() == CUNSAFMessage::ESharedSecretErrorResponse
        * @param aResponse Shared Secret Error Response
        * @return ETrue  Wait a while, then retry
        *          EFalse Terminate immediately
        */
        TBool ErrorResponseReceivedL( const CNATFWUNSAFMessage& aResponse );

    private: // Enumerations
        
        enum TTimerDuration
            {
            // How long implementation waits for a TLS connection to be formed.
            KTlsHandshakeTimeout = 8000,

            // How long implementation waits for a Shared Secret (Error)
            // Response, after having sent a Shared Secret Request.
            KSharedSecretRequestTimeout = 10000
            };
        
        TBool IsExpectedError( TInt aError );
        
        void SaveRealmAndNonceL( const CNATFWUNSAFMessage& aResponse );

    private: // Constructors
    
        CSTUNSharedSecret( CDeltaTimer& aTimer,
                           CTransactionIDGenerator& aTransactionIDGenerator,
                           MSharedSecretObserver& aObserver );

        CSTUNSharedSecret();

        CSTUNSharedSecret( const CSTUNSharedSecret& aSharedSecret );

        void ConstructL( RSocketServ& aSocketServer,
                         RConnection& aConnection,
                         const TInetAddr& aAddr,
                         const TDesC8& aLtUsername,
                         const TDesC8& aLtPassword );        

    private: // New functions, for internal use

        void StoreValueL( CNATFWUNSAFAttribute* aAttribute, HBufC8** aDest ) const;

    private: // Data
        
        /**
         * not own.
         */
        MSharedSecretObserver& iObserver;
        
        /**
         * not own.
         */
        CTransactionIDGenerator& iTransactionIDGenerator;

        /**
         * TLS transport
         * own.
         */
        CNATFWUNSAFTlsTransport* iTlsTransport;

        /**
         * Kept until response has been received.
         * own.
         */
        CNATFWUNSAFSharedSecretRequest* iRequest;

        /**
         * Username to use in the STUN Binding Request
         * own.
         */
        HBufC8* iUsername;
        
        /**
         * Password is the shared secret
         * own.
         */
        HBufC8* iPassword;
        
        /**
         * Current state
         * not own.
         */
        const CSTUNSharedSecretState* iState;
        
        /**
         * Username to use in shared secret request authentication
         * own.
         */
        HBufC8* iLtUsername;
        
        /**
         * Password to use in shared secret request authentication
         * own.
         */
        HBufC8* iLtPassword;
        
        /**
         * Nonce value from error response
         * own.
         */
        HBufC8* iNonce;
        
        /**
         * Realm value from error response
         * own.
         */
        HBufC8* iRealm;
        
        // Indicates that first error response has arrived (401)
        TBool iAddUsernameAttr;
        
        /**
         * Keeps count of errors
         * own.
         */
        RArray<TInt> iErrorBuffer;

        //Shared secret states, owned
        CSTUNSharedSecretConnecting*     iConnecting;
        CSTUNSharedSecretWaitResponse*    iWaitResponse;
        CSTUNSharedSecretWaitToRetry*    iWaitToRetry;
        CSTUNSharedSecretActive*         iActive;
        
    private: // For testing purposes

#ifdef TEST_EUNIT
        friend class CSTUNSharedSecretTest;
        friend class STUNTestUtils;
        friend class CSTUNClientTest;
        friend class CSTUNClientImplementationTest;
#endif
        __DECLARE_TEST;
    };

#endif // C_CSTUNSHAREDSECRET_H