/*
* Copyright (c) 2007-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:
* Name          : CSIPRegistrationBindingBase.h
* Part of       : Registration
* Version       : SIP/6.0
*
*/




/**
 @internalComponent
*/

#ifndef CSIPREGISTRATIONBINDINGBASE_H
#define CSIPREGISTRATIONBINDINGBASE_H

#include <e32base.h>
#include "MTransactionUser.h"
#include "MSIPSecUser.h"
#include "SipStackServerDefs.h"
#include "sipnatbindingobserver.h"
#include "mregistrationcontext.h"
#include "TSIPTransportParams.h"
#include "_sipcodecdefs.h"

class CSIPRegistrar;
class CSIPRegistrationBindingStore;
class MRegistrationOwner;
class MSigComp;
class CSIPSec;
class MSIPTransportMgr;
class CURIContainer;
class CSIPURI;
class CSIPResponse;
class CSIPRequest;
class CSIPToHeader;
class CSIPFromToHeaderBase;
class CSIPFromHeader;
class CSIPContactHeader;
class CSIPRouteHeader;
class CSIPMinExpiresHeader;
class CSIPRegistrationState;
class CSIPRegistering;
class CSIPRegistered;
class CSIP423ResponseReceived;
class CSIPUnregistering;
class CSIPUnregistered;
class CSIPRegisterUpdating;
class CSIPPAssociatedURIHeader;


/**
 * base class of registration binding.
 */
class CSIPRegistrationBindingBase : public CBase,
									public MSIPSecUser,
									public MSIPNATBindingObserver,
									public MRegistrationContext
	{
public:

	virtual ~CSIPRegistrationBindingBase();


public: // From MSIPSecUser

	TBool PassOnlyRealmsToUser() const;
	
    void RequestCredentialsL(const TDesC8& aRealm);
	
    virtual void RequestCredentialsL(CSIPResponse& aResponse,
	                                 TTransactionId aTransactionId,
	                                 TRefreshId aRefreshId);
    
    const MSIPSecUser* TrustedUser(TRegistrationId aRegistrationId);

    TBool ByPassSIPSec() const;
    

public: // From MSIPNATBindingObserver

    void FlowFailure(TInt aError);


public: // From MRegistrationContext

	virtual TRefreshId RefreshId() const;

	void RegisterL(TTransactionId&  aTransactionId,
		           CSIPRequest*     aRequest,
				   CSIPRouteHeader* aOutboundProxy);
				   
	void UpdateL(TTransactionId& aTransactionId,
		         CSIPRequest*    aRequest);

	void UnregisterL(TTransactionId& aTransactionId,
		             CSIPRequest*    aRequest);

	CSIPRegistrar* Registrar();

    void FillToFromL(CSIPRequest& aRequest);
    
	void SetExpiresValueL(CSIPRequest& aRequest);

	CSIPRegistrationState& CurrentState();

	void ChangeState(CSIPRegistrationState* aState);

	const CSIPToHeader& AOR() const;
	
	void UpdateContactFromRequestL();

	CSIPContactHeader& Contact();

	CSIPRequest* Request();

	const MRegistrationOwner* Owner() const;
	
	void SelfDetach(TBool aRefresh);

	void SelfDetach(TBool aRefresh, TBool aUseRetryId);
	void Received2XXResponseL(CSIPResponse& aResponse,
			TTransactionId aTransactionId);


	void ReceivedErrorResponseL();

	void Received423ResponseL(CSIPResponse& aResponse);

	TRegistrationId RegistrationId() const;

	void ClearRequest();

	void SetRouteHeaderFromResponseL(CSIPResponse& aResponse);
	
	TBool ServiceRouteOk(CSIPResponse& aResponse) const;
	             
		             
public: // New virtual functions

	virtual TBool IsRefresh() const = 0;

	virtual void DoRegisterL(TTransactionId& aTransactionId,
		                     CSIPRequest* aSIPRequest,
						     CSIPRouteHeader* aOutboundProxy)=0;

	virtual void DoUpdateL(TTransactionId& aTransactionId,
		                   CSIPRequest* aSIPRequest)=0;

	virtual void DoUnregisterL(TTransactionId& aTransactionId,
		                       CSIPRequest* aSIPRequest)=0;
		                       
	virtual void SetOutboundProxyL(CSIPRouteHeader* aOutboundProxy);                       


public: // New functions

	void OutboundProxyFailed();

	const CSIPRouteHeader* OutboundProxy();

	TBool HasOutboundProxy() const;

	TInt RemoveOutboundProxy();
	
	TBool FindContactByFromL(const CSIPFromToHeaderBase* aFromToHeader,
		                     CSIPContactHeader& aContact);

	TBool CompareWithRegisterRequest(const MRegistrationOwner& aOwner,
								     CSIPRequest& aSIPRequest);

	RPointerArray<CSIPRouteHeader>& RouteSet();

	TUint32 IAPId() const;

    TUint32 SigCompCompartmentId() const;

	// Take ownership
	void SetRequest(CSIPRequest* aSIPRequest);

	void SetOutboundProxy(CSIPRouteHeader* aOutboundProxy);	

	TBool RegisterPending() const;

	void DetachFromStore();

    const CSIPPAssociatedURIHeader* PAssociatedURIHeader() const;

    TSIPTransportParams FillTransportParams();
    
    TBool HasTransaction(const TTransactionId& aTransactionId) const;
    
    TBool IsCacheOutboundProxyIPEnabled();
    
    CSIPRouteHeader& OutboundProxyIPL();

protected:

	void ConstructL(CSIPRequest* aSIPRequest, 
	                CURIContainer& aRemoteTarget);

	CSIPRegistrationBindingBase(MTransactionUser& aTransactionUser,
	                            MSigComp& aSigComp,
	                            CSIPSec& aSIPSec,
	                            CSIPRegistrationBindingStore& aBindingStore,
	                            MRegistrationOwner* aRegistrationOwner,
	                            MSIPSecUser& aSIPSecUser,
	                            MSIPTransportMgr& aTransportMgr,
	                            TBool aSendWithExpires,
	                            TBool aCacheOutboundProxyIP);

protected:

    void CreateProxyTransportResourcesL(CSIPRouteHeader& aOutboundProxy);
	static void DetachOutboundProxy(TAny* aBinding);
	TInt RemoveBinding();

private:

	void InitializeStatesL();
	void UpdateBindingFromResponseL(CSIPResponse& aResponse);
	void SetMinExpiresToRequestL (CSIPResponse& aResponse);
	void SetToHeaderL(CSIPRequest& aSIPRequest);
	void SetFromHeaderL(CSIPRequest& aSIPRequest);
	void SetContactHeaderL(CSIPRequest& aSIPRequest);
	void SetPAssociatedURIFromResponseL(CSIPResponse& aResponse);
	void FreeProxyTransportResources();
	TBool HasSigCompParameter(const CSIPURI& aSipUri) const;	
	TInt SetOutboundProxyIPL(const TTransactionId& aTransactionId);
	HBufC8* ConvertInetAddrToTextL(const TInetAddr& aAddr);
	
protected: // Data	

    MTransactionUser&              iTransactionUser;
	MRegistrationOwner*            iOwner;
	TRegistrationId                iRegistrationId;
	TTransactionId                 iTransactionId;
	TTransactionId                 iRetryTransactionId;
	TUint32                        iSigCompCompartmentId;
	TUint32                        iTransportId;
	CSIPRegistrar*                 iRegistrar;
	CURIContainer*                 iRemoteTarget;
    CSIPContactHeader*             iContact;
	RPointerArray<CSIPRouteHeader> iRouteSet;
	MSIPSecUser&                   iSIPSecUser;
	
	// States
	CSIPRegistrationState*         iCurrentState;
	CSIPRegistering*               iRegistering;
	CSIPRegistered*                iRegistered;
	CSIP423ResponseReceived*       iResponse423Received;
	CSIPRegisterUpdating*          iUpdating;
	CSIPUnregistering*             iUnregistering;
	CSIPUnregistered*              iUnregistered; 
	
private: // Data

	MSigComp&                      iSigComp;
	CSIPSec&                       iSIPSec;
	CSIPRegistrationBindingStore&  iBindingStore;
	MSIPTransportMgr&              iTransportMgr;
	CSIPToHeader*                  iTo;
	CSIPFromHeader*                iFrom;
	CSIPRouteHeader*               iOutboundProxy;
	CSIPPAssociatedURIHeader*      iPAssociatedURIHeader;
	CSIPRequest*                   iRequest;
	TBool						   iSendWithExpires;
	CSIPRouteHeader*			   iOutboundProxyIP;
	TBool						   iCacheOutboundProxyIP;

private: // For testing purposes

	UNIT_TEST(CSIPRegistrationMgrTest)
    UNIT_TEST(CSIPRegistrationBindingStoreTest)
	UNIT_TEST(CSIPRegistrationBindingTest)
	};

#endif // CSIPREGISTRATIONBINDINGBASE_H

// End of File