diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Registration/inc/CSIPRegistrationMgr.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Registration/inc/CSIPRegistrationMgr.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,381 @@ +/* +* 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 +#include +#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& 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