/*

* Copyright (c) 2006-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          : CSIPRegistrationMgr.h

* Part of       : Registration

* Version       : SIP/5.0 

*

*/

/**

 @internalComponent

*/

#ifndef CSIPREGISTRATIONMGR_H

#define CSIPREGISTRATIONMGR_H

#include <e32base.h>

#include <in_sock.h>

#include "MSipRegistrations.h"

#include "MSipRegistrationContact.h"

#include "MConnectionStateObserver.h"

#include "SipStackServerDefs.h"

#include "_sipcodecdefs.h"

class CSIPRegistrationBindingStore;

class CSIPRegistrarStore;

class CSIPRouteHeader;

class CSIPFromHeader;

class CSIPRequest;

class CSIPContactHeader;

class CURIContainer;

class CSIPURI;

class MTransactionUser;

class MSipRefreshMgr;

class MTimerManager;

class CSIPSec;

class MSIPSecUser;

class MSigComp;

class MSIPTransportMgr;

class MRegistrationOwner;

class TSIPTransportParams;

class MTransactionOwner;

/**

 * This class implements interface functions of Sip Registration subsystem.

 */

class CSIPRegistrationMgr : public CBase,

						    public MSipRegistrations,

							public MSipRegistrationContact,

							public MConnectionStateObserver

	{

public: // Constructors and destructor

	static CSIPRegistrationMgr* NewL(MTransactionUser& aTU, 

									 MSipRefreshMgr& aRefreshMgr,

									 MTimerManager& aTimerManager,

									 CSIPSec& aSIPSec,

									 MSigComp& aSigComp,

									 MSIPTransportMgr& aTransportMgr);

	~CSIPRegistrationMgr();

public: // From MSipRegistrations

	TBool CheckRequestURI(CURIContainer& aRequestUri);

	const CSIPRouteHeader* OutboundProxy(TRegistrationId aRegistrationId);

	TBool HasOutboundProxy(TRegistrationId aRegistrationId) const;

    TBool IsOutboundProxy(const CURIContainer& aUri);

    void URIFailed(CURIContainer& aUri);

    TBool IsCacheOutboundProxyIPEanbled(

    	TRegistrationId aRegistrationId) const;

    CSIPRouteHeader& OutboundProxyIPL(

    	TRegistrationId aRegistrationId) const;

public: // From MSipRegistrationContact

	void ContactL(TUint32                     aIapId,

	              TRegistrationId             aRegistrationId,

		          const CSIPFromToHeaderBase* aFromToHeader,

	              CSIPContactHeader&          aContact);

public: // From MConnectionStateObserver		

	void ConnectionStateChangedL (TUint32                aIapId,

                                  CSIPConnection::TState aState);

public: // New functions

	/** 

	 * Function sends a Register request to registration subsystem.  

	 *

	 * @pre aRequest!=0

	 * @pre aRegistrationOwner!=0

	 *

	 * @param  aTransactionId; On return contains the id 

	 *         of the created transaction.

	 * @param  aRegistrationId; On return contains the id 

	 *         of the created registration binding object.

	 * @param  aRequest; a sip request. the ownership is transferred.

     * @param  aRemoteTarget; a remote target to be copied to the

     *         registrar if it the registrar does not already exist.

     *         The ownership is NOT transferred.

	 * @param  aOwner; the ownership is NOT transferred.

	 * @param  aSIPSecUser a user for SIPSec	

	 * @param  aOutboundProxy; an outbound proxy to be used with the

	 *         binding to be created. The ownership is transferred.

	 *         If 0 no outbound proxy will be used.

	 * @param aSendWithExpires when set to EFalse REGISTER message is sent

	 *        without expires value

	 * @param aCacheOutboundProxyIP when set to ETrue outbiund proxy IP

	 *        of REGISTER message is cached in registration context

	 * @param  aRefresh; If ETrue, the request will be refreshed.

	 */

    void RegisterL(TTransactionId& aTransactionId,

                   TRegistrationId& aRegistrationId,

                   CSIPRequest* aRequest,

                   CURIContainer& aRemoteTarget,

                   MRegistrationOwner* aOwner,

                   MSIPSecUser& aSIPSecUser,

                   CSIPRouteHeader* aOutboundProxy=0,

                   TBool aRefresh=EFalse,

                   TBool aSendWithExpires=ETrue,

                   TBool aCacheOutboundProxyIP=EFalse);

	/** 

	 * Function sends an update request.

	 * Registration fills To, From, Call-ID and CSeq.

	 * Also Contact will be filled if not present.

	 * If a different CSIPAddress is provided in Contact, leaves

	 * with KErrArgument. Leaves with KErrSIPInvalidRegistrationState

	 * if no registration binding was found.

	 *

	 * @pre aRequest!=0

	 * @param  aRegistrationId; the id of the registration binding to be

	 *         updated.

	 * @param  aTransactionId;  an empty transaction id that will 

	 *         be filled by TU.

	 * @param  aRequest; a sip request. The ownership is transferred.

	 * @param  aOwner the owner that must match to the original owner

	 */

    void UpdateRegistrationL(const TRegistrationId& aRegistrationId,

                             TTransactionId& aTransactionId,

                             CSIPRequest* aRequest,

                             const MRegistrationOwner* aOwner);

	/** 

	 * Function sends an unregister request.

	 * Registration fills To, From, Contact, Call-ID, CSeq.

	 * Contact-header's expire-parameter is updated to 0 by

	 * registration before added to the request.

	 * Leaves with CSIPClient::ENonExistingRegistrationId if 

	 * no registration binding was found.

	 *

	 * @pre aRequest!=0

	 * @param  aRegistrationId; the id of the registration binding to be

	 *         removed by unregistering.

	 * @param  aTransactionId;  an empty transaction id that will be 

	 *         filled by TU.

	 * @param  aRequest; a sip request. The ownership is transferred.

	 *         No Contact is allowed to be present. Panics if there is.

	 * @param  aOwner the owner that must match to the original owner

	 */

    void UnRegisterL(const TRegistrationId& aRegistrationId,

                     TTransactionId& aTransactionId,

                     CSIPRequest* aRequest,

                     const MRegistrationOwner* aOwner);

	/** 

	 * Function sets an outbound proxy for a registration binding.

	 * Leaves if the binding was not found. 

	 *

	 * @pre aOutboundProxy != 0

	 * @param  aRegistrationId; the id of the registration binding

	 *         for which the outbound proxy should be set.

	 * @param  aOutboundProxy; an outbound proxy to be used with the

	 *         binding to be created. The ownership is transferred.

	 * @param  aOwner the owner that must match to the original owner        

	 */	

    void SetOutboundProxyL(const TRegistrationId& aRegistrationId,

                           CSIPRouteHeader* aOutboundProxy,

                           const MRegistrationOwner* aOwner);

	/** 

	 * Function removes an outbound proxy for a specified registration

	 * binding.

	 *

	 * @param  aRegistrationId; the id of the registration binding

	 *         from where the outbound proxy should be removed.

	 *

	 * @param  aOwner the owner that must match to the original owner

	 *

	 * @return KErrNotFound if the binding

	 *         with a given id was not found, otherwise KErrNone.          

	 */

    TInt RemoveOutboundProxy(const TRegistrationId& aRegistrationId,

                             const MRegistrationOwner* aOwner);

	/** 

	 * Fetch all the registrations. Leaves on failure.

	 *

     * @pre aRequest!=0

	 * @pre !aRequest.HasHeader(KContactHeaderFullName)

     * @pre aRemoteTarget!=0

     * @pre aTransactionOwner!=0

     *

     * @param  aTransportParams transport parameters to be used by TU

	 * @param  aTransactionId; an empty transaction id that is filled by TU.

	 * @param  aRequest; a sip request. the ownership is transferred.

     * @param  aRemoteTarget; The remote target to be used.

     * @param  aTransactionOwner; To be passed as such to TU.

     *         The ownership is NOT transferred.

	 *

	 */

    void FetchRegistrationsL(const TSIPTransportParams& aTransportParams,

                             TTransactionId& aTransactionId,

                             CSIPRequest* aRequest,

                             CURIContainer& aRemoteTarget,

                             MTransactionOwner* aTransactionOwner);

	/** 

	 * Copies the POINTERS of the Route-set objects for 

     * the given registration-id to the givena array.

     * If a Route-set was not found, the function silently returns

     * without filling anything.

	 *

	 * @param  aRegistrationId; the id of the registration

	 *         for which the Route-set should be filled.

     * @param  aRouteSet. IN: empty array, OUT: array filled with pointers

     *         to the stored Route-headers.

     * @param  aAddOutboundProxy

     *         If ETrue, add pointer to the outbound proxy as the FIRST entry. 

     *         If ETrue and there is no Service-Route but an outbound proxy,

     *         do NOT add anything.

     *         If EFalse ignore outbound proxy, but add Service-Route if any. 

     *

	 */

    void GetRouteL(const TRegistrationId& aRegistrationId,

                   RPointerArray<CSIPRouteHeader>& aRouteSet,

                   TBool aAddOutboundProxy=EFalse);

    /**

     * Creates a from header by giving registration Id.

     *

     * @param aRegistrationId; a registrationId of existing registration,

     *

     * @returns a new From-header instance. The ownership is transferred.

     */

    CSIPFromHeader* CreateFromLC(const TRegistrationId& aRegistrationId);

	/** 

	 * Delete all the registration bindings related to the registration 

	 * owner passed as parameter. Does NOT delete the registration owner.

	 *

	 * @param  aOwner; a owner

	 *

	 * @return KErrNone if the owner was found and all related bindings 

	 *         were detached.

	 */

    TInt ClearRegistrationOwner(const MRegistrationOwner* aOwner);		   

    /* Terminates a registration with a given registration id abnormally. 

	 * Deletes the binding immediately.

     *

	 * @param aRegistrationId; a registration Id of an existing registration. 

     *

     * @param  aOwner the owner that must match to the original owner

     *

	 * @returns KErrNotFound if no registration

	 *          with the given id was found, otherwise KErrNone.

     */

    TInt TerminateRegistration (const TRegistrationId& aRegistrationId,

                                const MRegistrationOwner* aOwner);

    /**

     * Gets a pointer to the contact header related 

     * to the registration binding having the given ID

     *

     * @param aRegistrationId a ID of a registration binding

     *

     * @returns a pointer to a Contact-header if the binding was found.

     *          NULL if the binding was not found

     *          The ownership is not transferred.

     */    

    const CSIPContactHeader* Contact(const TRegistrationId& aRegistrationId);

    /**

     * Gets the transport parameters used for a registration binding.

     *

     * @param aRegistrationId a ID of a registration binding

     * @param aTransportParams on return contains the 

     *        transport parameters if found

     *

     * @returns ETrue if the registration binding was found and 

     *          the transport parameters were filled, otherwise EFalse.

     */    

    TBool FillTransportParams(

        const TRegistrationId& aRegistrationId,

        TSIPTransportParams& aTransportParams);

	/**

	 * Gets the MSIPSecUser related to the given registration id.

     *

     * @param aRegistrationId the registration id

     *

     * @returns the user related to the given registration id if found,

     *          otherwise NULL.

	 */    

    const MSIPSecUser* SIPSecUser(const TRegistrationId& aRegistrationId);         

	/**

	 * Gets a MSIPSecUser related to a transaction.

     *

     * @param aTransactionId the transaction id

     *

     * @return MSIPSecUser related to the given transaction id, if found,

     *         otherwise NULL.

	 */    

    const MSIPSecUser* SIPSecUserForTransaction(

        const TTransactionId& aTransactionId);

private: // New functions

	CSIPRegistrationMgr(MTransactionUser& aTU, 

						MSipRefreshMgr&   aRefreshMgr,

						MTimerManager&    aTimerManager,

						CSIPSec&          aSIPSec,

						MSigComp&         aSigComp,

						MSIPTransportMgr& aTransportMgr);

	void ConstructL();

    void FillHostWithLocalIPL (TUint32 aIapId, CSIPURI& aSipUri);    

	static void DetachBinding(TAny* aBinding);

private: // Data

	MTransactionUser&             iTU;

	MSipRefreshMgr&               iRefreshMgr;

	MTimerManager&                iTimerMgr;

	CSIPSec&                      iSIPSec;

	MSigComp&                     iSigComp;

	MSIPTransportMgr&             iTransportMgr;

	CSIPRegistrationBindingStore* iBindingStore;

	CSIPRegistrarStore*           iRegistrarStore;

private: // For testing purposes

	UNIT_TEST(CSIPRegistrationMgrTest)

	};

#endif // CSIPREGISTRATIONMGR_H

// End of File