--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/realtimenetprots/sipfw/SIP/sipapi/src/RegBindingImplementation.h Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,436 @@
+/*
+* Copyright (c) 2005-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 : RegBindingImplementation.h
+* Part of : SIP Client
+* Interface : SDK API, SIP Client API
+* Version : 1.0
+*
+*/
+
+
+
+
+/**
+ @internalComponent
+*/
+
+#ifndef CREGBINDINGIMPLEMENTATION_H
+#define CREGBINDINGIMPLEMENTATION_H
+
+// INCLUDES
+#include <stringpool.h>
+#include "sipregistrationcontext.h"
+#include "transactionassociation.h"
+#include "siprefreshassociation.h"
+#include "_sipcodecdefs.h"
+
+// FORWARD DECLARATIONS
+class CSIPRegistrationBinding;
+class CSIPResponseElements;
+class CSIPContactHeader;
+class CSIPRouteHeader;
+class CUri8;
+class CRegistrationState;
+class CSIPToHeader;
+class CSIPFromHeader;
+class CConnectionCallback;
+
+
+// CLASS DECLARATION
+
+/**
+* Implementation class for managing SIP registration binding.
+*/
+class CRegBindingImplementation :
+ public CBase,
+ public MSIPRegistrationContext,
+ public MTransactionAssociation,
+ public MSIPRefreshAssociation
+ {
+ public: // Constructors and destructor
+
+ /**
+ * Two-phased constructor.
+ * @pre aAor != 0 &&
+ * aContact != 0
+ * @pre "Expires" parameter in aContact must be >= KSIPMinExpirationValue
+ * @param aRegistration Registration binding who creates this
+ * CRegBindingImplementation instance.
+ * @param aConnection The SIP connection to be used
+ * @param aAor contains user's address-of-record to register;
+ * the ownership is transfered
+ * @param aContact contact(s) to be registered. The "expires" parameter
+ * indicates how long the client would like the binding to be
+ * valid.
+ * "expires" parameter value must be >= KSIPMinExpirationValue;
+ * the ownership is transfered
+ * @param aRefresh if set, created binding will be refreshed;
+ * the ownership is transfered
+ * @param aOutboundProxy an outbound proxy address;
+ * the ownership is transfered
+ * @param aRemoteUri if set, will be used in request-uri construction;
+ * the ownership is transfered
+ * @param aFrom From header, the ownership is transferred
+ * @return New object, ownership is transferred.
+ */
+ static CRegBindingImplementation*
+ NewL(CSIPRegistrationBinding& aRegistration,
+ CSIPConnection& aConnection,
+ CSIPToHeader* aAor,
+ CSIPContactHeader* aContact,
+ CSIPRefresh* aRefresh,
+ CSIPRouteHeader* aOutboundProxy,
+ CUri8* aRemoteUri,
+ CSIPFromHeader* aFrom);
+
+ /**
+ * Destructor
+ */
+ ~CRegBindingImplementation();
+
+ public: // From MSIPRegistrationContext
+
+ /**
+ * Checks if the registration context can be
+ * used for creating SIP messages/dialogs
+ * @return ETrue if the registration binding exists; EFalse
+ * otherwise
+ */
+ TBool IsContextActive() const;
+
+ /**
+ * Gets the context id
+ * @return context id
+ * For internal use only
+ */
+ TUint32 ContextId() const;
+
+ public: // From MTransactionAssociation
+
+ CSIPClientConnection& ClientConnectionL();
+
+ CSIPClientConnection* ClientConnection();
+
+ CSIPConnection& SIPConnectionL();
+
+ void AddTransactionL(CSIPTransactionBase& aTransaction);
+
+ void RemoveTransaction(const CSIPTransactionBase& aTransaction);
+
+ public: // From MSIPRefreshAssociation
+
+ CSIPClientTransaction*
+ UpdateRefreshL(CSIPRefresh& aRefresh,
+ CSIPMessageElements* aElements,
+ TBool aTerminate);
+
+ void DeletingRefresh(CSIPRefresh& aRefresh, TUint32 aRefreshId);
+
+ MTransactionAssociation& TransactionAssociation();
+
+ TInt CheckIfStandAlone();
+
+ public: // New functions
+
+ /**
+ * Creates SIP REGISTER request, sends it to the given destination.
+ * Received 2xx response will create at least one registration
+ * binding.
+ * @pre Connection().State()==EActive
+ * @param aElements contains user SIP headers and content; the ownership
+ * is taken
+ * @return SIP REGISTER transaction; the ownership is transfered
+ * @leave KErrSIPMalformedMessage if aElements contain contact or
+ * expires headers
+ */
+ CSIPClientTransaction* RegisterL(CSIPMessageElements* aElements=0);
+
+ /**
+ * Creates SIP (de)REGISTER request, sends it to the given destination.
+ * This function will remove registration binding.
+ * Any SIP response (2xx - 6xx) to this request removes the binding.
+ * Note that deregistration can be done then the 2xx is received to the
+ * initial REGISTER transaction and there is no on-going registration
+ * updates.
+ * @pre Connection().State()==EActive
+ * @param aElements contains user SIP headers and content; the ownership
+ * is transfered. If set, user SIP headers must not contain any
+ * Contact-header nor Expires-header
+ * @return SIP REGISTER transaction; the ownership is transfered
+ */
+ CSIPClientTransaction* DeregisterL(CSIPMessageElements* aElements=0);
+
+ CSIPClientTransaction*
+ UpdateL(CSIPMessageElements* aElements, TUint* aExpirationValue=0);
+
+ /**
+ * Gets the SIP connection used for the registration.
+ * @return SIP connection used for the registration, or 0-pointer if the
+ * connection has been deleted. Ownership is not transferred.
+ */
+ CSIPConnection* Connection();
+
+ /**
+ * Gets the SIP connection used for the registration.
+ * @return SIP connection used for the registration, or 0-pointer if the
+ * connection has been deleted. Ownership is not transferred.
+ */
+ const CSIPConnection* Connection() const;
+
+ /**
+ * Sets/resets outbound proxy.
+ * If a 0-pointer is given the outbound proxy will be reset.
+ * @param aOutboundProxy an outbound proxy. Ownership is transferred.
+ */
+ void SetOutboundProxyL(CSIPRouteHeader* aOutboundProxy);
+
+ /**
+ * Gets the address-of-record (AOR) used for creating binding
+ * @return address-of-record (AOR)
+ */
+ const CSIPToHeader& Aor() const;
+
+ /**
+ * Gets Contact header associated with the registration binding
+ * @return Contact header
+ */
+ const CSIPContactHeader& ContactHeader() const;
+
+ /**
+ * Gets Contact header associated with the registration binding
+ * @return Contact header
+ */
+ CSIPContactHeader& ContactHeader();
+
+ /**
+ * Gets the registered Contact-header received in the 200 OK response.
+ * @return Contact header, or NULL if IsContextActive() is EFalse.
+ * Ownership is not transferred.
+ */
+ const CSIPContactHeader* RegisteredContact() const;
+
+ /**
+ * Gets used outbound proxy
+ * @return outbound proxy or a 0-pointer if not set. Ownership is not
+ * transferred.
+ */
+ const CSIPRouteHeader* OutboundProxy() const;
+
+ /**
+ * Gets associated refresh in case the user has requested the refresh of
+ * the registration. Note that client cannot use update or terminate
+ * functions defined in the CSIPRefresh class.
+ * @return Associated refresh or a 0-pointer if the user has not
+ * requested a refresh of registration binding. Ownership is not
+ * transferred.
+ */
+ const CSIPRefresh* SIPRefresh() const;
+
+ /**
+ * Gets associated refresh in case the user has requested the refresh of
+ * the registration. Note that client cannot use update or terminate
+ * functions defined in the CSIPRefresh class.
+ * @return Associated refresh or a 0-pointer if the user has not
+ * requested a refresh of registration binding. Ownership is not
+ * transferred.
+ */
+ CSIPRefresh* SIPRefresh();
+
+ /**
+ * Compares this object to another object
+ * @param aRegistration CRegBindingImplementation object to compare
+ * @return ETrue if the objects are equal, otherwise EFalse
+ */
+ TBool operator==(const CRegBindingImplementation& aRegistration) const;
+
+ CSIPClientTransaction* DoRegisterL(CSIPMessageElements* aElements);
+
+ CSIPClientTransaction* DoDeregisterL(CSIPMessageElements* aElements);
+
+ CSIPClientTransaction* DoUpdateL(CSIPMessageElements* aElements,
+ TUint* aExpirationValue);
+
+ TBool IncomingResponseL(CSIPResponseElements* aElements,
+ TUint32 aRequestId,
+ TUint32 aRegistrationId,
+ TUint32 aRefreshId,
+ CConnectionCallback& aCallback);
+
+ TBool ErrorOccured(TInt aError,
+ TUint32 aRequestId,
+ CConnectionCallback& aCallback);
+
+ void SetRegistrationId(TUint32 aRegistrationId);
+
+ /**
+ * Searches for a transaction matching the given aRequestId.
+ *
+ * @param aRequestId Request id
+ * @return Transaction object, or NULL if not found. Ownership isn't
+ * transferred.
+ */
+ CSIPClientTransaction* FindTransaction(TUint32 aRequestId);
+
+ /**
+ * Change the registration binding state.
+ *
+ * @param aNewState State to enter, can be NULL.
+ * Ownership is not transferred.
+ */
+ void ChangeState(const CRegistrationState* aNewState);
+
+ void UpdateRefreshState(TUint aStatusCode) const;
+
+ void ConnectionLost();
+
+ CSIPClientTransaction* CreateClientTransactionL();
+
+ TBool HandleError(CConnectionCallback& aCallback,
+ TInt aError,
+ TUint32 aRequestId,
+ const CRegistrationState& aUnregistered);
+
+ /**
+ * Informs CRegBindingImplementation that the associated CSIPConnection
+ * has been deleted. After this the CSIPRegistrationBinding object can't
+ * be used any more.
+ */
+ void ConnectionDeleted();
+
+ CSIPRegistrationBinding& Binding() const;
+
+ void UpdateRegisteredContactL();
+
+ void RemoveRegisteredContact();
+
+ /**
+ * Sets/resets properties.
+ * @pre IsContextActive()==EFalse
+ * @param aProperty. Property name
+ * @param aValue. Property value
+ * @leave KErrSIPInvalidRegistrationState if IsContextActive() is ETrue
+ * @leave KErrNotFound if property is not found
+ */
+ void SetPropertyL(TUint32 aProperty,TBool aValue);
+
+ private: // Constructors, for internal use
+
+ CRegBindingImplementation(CSIPRegistrationBinding& aRegistration,
+ CSIPConnection& aConnection);
+
+ void ConstructL(CSIPToHeader* aAor,
+ CSIPContactHeader* aContacts,
+ CSIPRefresh* aRefresh,
+ CSIPRouteHeader* aOutboundProxy,
+ CUri8* aRemoteUri,
+ CSIPFromHeader* aFrom);
+
+ private: // New functions, for internal use
+
+ /**
+ * Checks that CSIPConnection is available for use (not NULL). If
+ * iConnection is NULL, it means user has deleted a resource needed by
+ * CRegBindingImplementation, and this function leaves.
+ */
+ void CheckConnectionL() const;
+
+ /**
+ * Returns the current registration state. If state handler is not
+ * available, meaning user has deleted a resource needed by
+ * CRegBindingImplementation, this function leaves.
+ */
+ const CRegistrationState& StateL() const;
+
+ /**
+ * Checks that aElements don't contain Contact or Expires headers.
+ * @param aElements Message elements
+ * @leave KErrSIPMalformedMessage If Contact or Expires header is
+ * present in aElements.
+ */
+ void CheckElementsL(const CSIPMessageElements* aElements) const;
+
+ /**
+ * Removes, does not delete, Contact headers from aElements.
+ * @pre aElements != NULL
+ * @param aElements Message elements. Ownership is not transferred.
+ */
+ static void DetachContactHeader(TAny* aElements);
+
+ /**
+ * Removes, does not delete, the headers identified by aName, from
+ * aElements.
+ * @pre aElements != NULL
+ * @param aElements Message elements. Ownership is not transferred.
+ * @param aName Header name
+ */
+ static void DetachHeaders(TAny* aElements, RStringF aName);
+
+ private: // Data
+
+ //Registration binding who owns this CRegBindingImplementation instance
+ CSIPRegistrationBinding& iRegistration;
+
+ //The used connection. CRegBindingImplementation doesn't own it.
+ //If this pointer is NULL; it means application has deleted the
+ //connection before deleting the CRegBindingImplementation, and this
+ //CRegBindingImplementation is now useless.
+ CSIPConnection* iConnection;
+
+ //Outbound proxy or NULL if no proxy is specified. Owned.
+ CSIPRouteHeader* iOutboundProxy;
+
+ CSIPToHeader* iAor; //Owned.
+ CSIPFromHeader* iFrom; //Owned, can be NULL.
+ CSIPContactHeader* iContact; //Owned
+
+ CSIPContactHeader* iRegisteredContact; //Owned, can be NULL
+
+ CUri8* iRemoteUri; //Owned, can be NULL.
+
+
+ //CRegBindingImplementation owns the CSIPRefresh object. It is not
+ //deleted even the refresh ends since user can try to register again,
+ //using the same CRegBindingImplementation (and CSIPRefresh) instance.
+ //CRegBindingImplementation can have maximum of one refresh object
+ CSIPRefresh* iRefresh;
+
+ //Id received from SIP client
+ TUint32 iRegistrationId;
+
+ //Only client transactions can be bound to registration. Transactions
+ //are not owned. Application owns them.
+ RPointerArray<CSIPClientTransaction> iTransactions;
+
+ //Current state of the registration. CRegBindingImplementation doesn't
+ //own the state object. If iState is NULL, it means the CSIP owning the
+ //registration states has been deleted.
+ const CRegistrationState* iState;
+
+ TBool iSendWithExpires;
+ TBool iCacheOutboundProxyIP;
+
+ private: // For testing purposes
+
+ UNIT_TEST(CSIP_Test)
+ UNIT_TEST(CSIPRegistrationBinding_Test)
+ UNIT_TEST(CSIPInviteDialogAssoc_Test)
+ UNIT_TEST(CSIPSubscribeDialogAssoc_Test)
+ UNIT_TEST(CSIPReferDialogAssoc_Test)
+
+ void __DbgTestInvariant() const;
+
+ };
+
+#endif