1 /*

     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 * Name          : CSIPRegistrationBindingBase.h

    16 * Part of       : Registration

    17 * Version       : SIP/6.0

    18 *

    19 */

    20 

    21 

    22 

    23 

    24 /**

    25  @internalComponent

    26 */

    27 

    28 #ifndef CSIPREGISTRATIONBINDINGBASE_H

    29 #define CSIPREGISTRATIONBINDINGBASE_H

    30 

    31 #include <e32base.h>

    32 #include "MTransactionUser.h"

    33 #include "MSIPSecUser.h"

    34 #include "SipStackServerDefs.h"

    35 #include "sipnatbindingobserver.h"

    36 #include "mregistrationcontext.h"

    37 #include "TSIPTransportParams.h"

    38 #include "_sipcodecdefs.h"

    39 

    40 class CSIPRegistrar;

    41 class CSIPRegistrationBindingStore;

    42 class MRegistrationOwner;

    43 class MSigComp;

    44 class CSIPSec;

    45 class MSIPTransportMgr;

    46 class CURIContainer;

    47 class CSIPURI;

    48 class CSIPResponse;

    49 class CSIPRequest;

    50 class CSIPToHeader;

    51 class CSIPFromToHeaderBase;

    52 class CSIPFromHeader;

    53 class CSIPContactHeader;

    54 class CSIPRouteHeader;

    55 class CSIPMinExpiresHeader;

    56 class CSIPRegistrationState;

    57 class CSIPRegistering;

    58 class CSIPRegistered;

    59 class CSIP423ResponseReceived;

    60 class CSIPUnregistering;

    61 class CSIPUnregistered;

    62 class CSIPRegisterUpdating;

    63 class CSIPPAssociatedURIHeader;

    64 

    65 

    66 /**

    67  * base class of registration binding.

    68  */

    69 class CSIPRegistrationBindingBase : public CBase,

    70 									public MSIPSecUser,

    71 									public MSIPNATBindingObserver,

    72 									public MRegistrationContext

    73 	{

    74 public:

    75 

    76 	virtual ~CSIPRegistrationBindingBase();

    77 

    78 

    79 public: // From MSIPSecUser

    80 

    81 	TBool PassOnlyRealmsToUser() const;

    82 	

    83     void RequestCredentialsL(const TDesC8& aRealm);

    84 	

    85     virtual void RequestCredentialsL(CSIPResponse& aResponse,

    86 	                                 TTransactionId aTransactionId,

    87 	                                 TRefreshId aRefreshId);

    88     

    89     const MSIPSecUser* TrustedUser(TRegistrationId aRegistrationId);

    90 

    91     TBool ByPassSIPSec() const;

    92     

    93 

    94 public: // From MSIPNATBindingObserver

    95 

    96     void FlowFailure(TInt aError);

    97 

    98 

    99 public: // From MRegistrationContext

   100 

   101 	virtual TRefreshId RefreshId() const;

   102 

   103 	void RegisterL(TTransactionId&  aTransactionId,

   104 		           CSIPRequest*     aRequest,

   105 				   CSIPRouteHeader* aOutboundProxy);

   106 				   

   107 	void UpdateL(TTransactionId& aTransactionId,

   108 		         CSIPRequest*    aRequest);

   109 

   110 	void UnregisterL(TTransactionId& aTransactionId,

   111 		             CSIPRequest*    aRequest);

   112 

   113 	CSIPRegistrar* Registrar();

   114 

   115     void FillToFromL(CSIPRequest& aRequest);

   116     

   117 	void SetExpiresValueL(CSIPRequest& aRequest);

   118 

   119 	CSIPRegistrationState& CurrentState();

   120 

   121 	void ChangeState(CSIPRegistrationState* aState);

   122 

   123 	const CSIPToHeader& AOR() const;

   124 	

   125 	void UpdateContactFromRequestL();

   126 

   127 	CSIPContactHeader& Contact();

   128 

   129 	CSIPRequest* Request();

   130 

   131 	const MRegistrationOwner* Owner() const;

   132 	

   133 	void SelfDetach(TBool aRefresh);

   134 

   135 	void SelfDetach(TBool aRefresh, TBool aUseRetryId);

   136 	void Received2XXResponseL(CSIPResponse& aResponse,

   137 			TTransactionId aTransactionId);

   138 

   139 

   140 	void ReceivedErrorResponseL();

   141 

   142 	void Received423ResponseL(CSIPResponse& aResponse);

   143 

   144 	TRegistrationId RegistrationId() const;

   145 

   146 	void ClearRequest();

   147 

   148 	void SetRouteHeaderFromResponseL(CSIPResponse& aResponse);

   149 	

   150 	TBool ServiceRouteOk(CSIPResponse& aResponse) const;

   151 	             

   152 		             

   153 public: // New virtual functions

   154 

   155 	virtual TBool IsRefresh() const = 0;

   156 

   157 	virtual void DoRegisterL(TTransactionId& aTransactionId,

   158 		                     CSIPRequest* aSIPRequest,

   159 						     CSIPRouteHeader* aOutboundProxy)=0;

   160 

   161 	virtual void DoUpdateL(TTransactionId& aTransactionId,

   162 		                   CSIPRequest* aSIPRequest)=0;

   163 

   164 	virtual void DoUnregisterL(TTransactionId& aTransactionId,

   165 		                       CSIPRequest* aSIPRequest)=0;

   166 		                       

   167 	virtual void SetOutboundProxyL(CSIPRouteHeader* aOutboundProxy);                       

   168 

   169 

   170 public: // New functions

   171 

   172 	void OutboundProxyFailed();

   173 

   174 	const CSIPRouteHeader* OutboundProxy();

   175 

   176 	TBool HasOutboundProxy() const;

   177 

   178 	TInt RemoveOutboundProxy();

   179 	

   180 	TBool FindContactByFromL(const CSIPFromToHeaderBase* aFromToHeader,

   181 		                     CSIPContactHeader& aContact);

   182 

   183 	TBool CompareWithRegisterRequest(const MRegistrationOwner& aOwner,

   184 								     CSIPRequest& aSIPRequest);

   185 

   186 	RPointerArray<CSIPRouteHeader>& RouteSet();

   187 

   188 	TUint32 IAPId() const;

   189 

   190     TUint32 SigCompCompartmentId() const;

   191 

   192 	// Take ownership

   193 	void SetRequest(CSIPRequest* aSIPRequest);

   194 

   195 	void SetOutboundProxy(CSIPRouteHeader* aOutboundProxy);	

   196 

   197 	TBool RegisterPending() const;

   198 

   199 	void DetachFromStore();

   200 

   201     const CSIPPAssociatedURIHeader* PAssociatedURIHeader() const;

   202 

   203     TSIPTransportParams FillTransportParams();

   204     

   205     TBool HasTransaction(const TTransactionId& aTransactionId) const;

   206     

   207     TBool IsCacheOutboundProxyIPEnabled();

   208     

   209     CSIPRouteHeader& OutboundProxyIPL();

   210 

   211 protected:

   212 

   213 	void ConstructL(CSIPRequest* aSIPRequest, 

   214 	                CURIContainer& aRemoteTarget);

   215 

   216 	CSIPRegistrationBindingBase(MTransactionUser& aTransactionUser,

   217 	                            MSigComp& aSigComp,

   218 	                            CSIPSec& aSIPSec,

   219 	                            CSIPRegistrationBindingStore& aBindingStore,

   220 	                            MRegistrationOwner* aRegistrationOwner,

   221 	                            MSIPSecUser& aSIPSecUser,

   222 	                            MSIPTransportMgr& aTransportMgr,

   223 	                            TBool aSendWithExpires,

   224 	                            TBool aCacheOutboundProxyIP);

   225 

   226 protected:

   227 

   228     void CreateProxyTransportResourcesL(CSIPRouteHeader& aOutboundProxy);

   229 	static void DetachOutboundProxy(TAny* aBinding);

   230 	TInt RemoveBinding();

   231 

   232 private:

   233 

   234 	void InitializeStatesL();

   235 	void UpdateBindingFromResponseL(CSIPResponse& aResponse);

   236 	void SetMinExpiresToRequestL (CSIPResponse& aResponse);

   237 	void SetToHeaderL(CSIPRequest& aSIPRequest);

   238 	void SetFromHeaderL(CSIPRequest& aSIPRequest);

   239 	void SetContactHeaderL(CSIPRequest& aSIPRequest);

   240 	void SetPAssociatedURIFromResponseL(CSIPResponse& aResponse);

   241 	void FreeProxyTransportResources();

   242 	TBool HasSigCompParameter(const CSIPURI& aSipUri) const;	

   243 	TInt SetOutboundProxyIPL(const TTransactionId& aTransactionId);

   244 	HBufC8* ConvertInetAddrToTextL(const TInetAddr& aAddr);

   245 	

   246 protected: // Data	

   247 

   248     MTransactionUser&              iTransactionUser;

   249 	MRegistrationOwner*            iOwner;

   250 	TRegistrationId                iRegistrationId;

   251 	TTransactionId                 iTransactionId;

   252 	TTransactionId                 iRetryTransactionId;

   253 	TUint32                        iSigCompCompartmentId;

   254 	TUint32                        iTransportId;

   255 	CSIPRegistrar*                 iRegistrar;

   256 	CURIContainer*                 iRemoteTarget;

   257     CSIPContactHeader*             iContact;

   258 	RPointerArray<CSIPRouteHeader> iRouteSet;

   259 	MSIPSecUser&                   iSIPSecUser;

   260 	

   261 	// States

   262 	CSIPRegistrationState*         iCurrentState;

   263 	CSIPRegistering*               iRegistering;

   264 	CSIPRegistered*                iRegistered;

   265 	CSIP423ResponseReceived*       iResponse423Received;

   266 	CSIPRegisterUpdating*          iUpdating;

   267 	CSIPUnregistering*             iUnregistering;

   268 	CSIPUnregistered*              iUnregistered; 

   269 	

   270 private: // Data

   271 

   272 	MSigComp&                      iSigComp;

   273 	CSIPSec&                       iSIPSec;

   274 	CSIPRegistrationBindingStore&  iBindingStore;

   275 	MSIPTransportMgr&              iTransportMgr;

   276 	CSIPToHeader*                  iTo;

   277 	CSIPFromHeader*                iFrom;

   278 	CSIPRouteHeader*               iOutboundProxy;

   279 	CSIPPAssociatedURIHeader*      iPAssociatedURIHeader;

   280 	CSIPRequest*                   iRequest;

   281 	TBool						   iSendWithExpires;

   282 	CSIPRouteHeader*			   iOutboundProxyIP;

   283 	TBool						   iCacheOutboundProxyIP;

   284 

   285 private: // For testing purposes

   286 

   287 	UNIT_TEST(CSIPRegistrationMgrTest)

   288     UNIT_TEST(CSIPRegistrationBindingStoreTest)

   289 	UNIT_TEST(CSIPRegistrationBindingTest)

   290 	};

   291 

   292 #endif // CSIPREGISTRATIONBINDINGBASE_H

   293 

   294 // End of File