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          : CSipDialogItem.h

    16 * Part of       : SIPDialogs

    17 * Version       : SIP/6.0 

    18 *

    19 */

    20 

    21 

    22 

    23 

    24 /**

    25  @internalComponent

    26 */

    27 

    28 #ifndef CSIPDIALOGITEM_H

    29 #define CSIPDIALOGITEM_H

    30 

    31 #include <e32base.h>

    32 #include <stringpool.h>

    33 #include "SipStackServerDefs.h"

    34 #include "MTransactionOwner.h"

    35 #include "MRefreshOwner.h"

    36 #include "sip.h"

    37 #include "MDialogContext.h"

    38 #include "MSIPSecUser.h"

    39 #include "DialogStateBase.h"

    40 #include "Establishing.h"

    41 #include "Early.h"

    42 #include "Confirmed.h"

    43 #include "Terminated.h"

    44 

    45 class MSipRefreshMgr;

    46 class MTransactionUser;

    47 class CSIPSec;

    48 class MDialogOwner;

    49 class CDeleteMgr;

    50 class CDialogsStore;

    51 class CTransactionItemStore;

    52 class CSIPMessage;

    53 class CSIPRouteHeaderBase;

    54 class CSIPRouteHeader;

    55 class CSIPCallIDHeader;

    56 class CSIPContactHeader;

    57 class CURIContainer;

    58 class CSIPURI;

    59 class CSIPAddress;

    60 class CSigCompMgr;

    61 class MSigComp;

    62 

    63 

    64 class CSipDialogItem : public CBase,

    65                        public MDialogContext,

    66                        public MTransactionOwner,

    67                        public MRefreshOwner,

    68                        public MSIPSecUser

    69                        

    70     {

    71 public: // Constructors and destructor

    72 

    73     static CSipDialogItem* NewLC(

    74         CDialogsStore& aDialogStore,

    75         MDialogOwner* aDialogOwner,

    76         MSIPSecUser& aSIPSecUser,

    77         MTransactionUser& aTransactionMgr, 

    78         MSipRefreshMgr& aRefreshMgr,

    79         CSIPSec& aSIPSec,

    80         CDeleteMgr& aDeleteMgr,

    81         MSigComp& aSigComp,

    82         TRegistrationId aRegistrationId=KEmptyRegistrationId);

    83 

    84     ~CSipDialogItem();

    85     

    86     

    87 public: // From MDialogContext

    88     

    89     MDialogOwner* DialogOwner();

    90     

    91     TDialogId DialogId() const;

    92     

    93     TRegistrationId RegistrationId() const;

    94    

    95     void SelfDestruct();

    96     

    97     TTransactionId FirstTransactionId();

    98     

    99     void ChangeState(TDialogStateBase& aState);

   100     

   101     void TerminateForkedDialogs(TTransactionId aTransactionId);

   102 

   103     void SetCallId(CSIPCallIDHeader* aCallId);

   104 

   105     CSIPCallIDHeader* CallId();

   106     

   107     void SetLocalTag(RStringF aTag);

   108     

   109     RStringF LocalTag();

   110 

   111     void SetRemoteTagL(CSIPFromToHeaderBase* aFromTo);

   112     

   113     RStringF RemoteTag();

   114     

   115     TBool RemoteTagSet();

   116     

   117     void SetLocalSeqNum(TUint aNum);

   118     

   119     void SetRemoteTargetWithMsgL(CSIPMessage& aMsg);

   120 

   121     void SetRemoteSeqNum(TUint aNum);

   122 

   123     void SetRouteSetUsingRecordRouteL(CSIPMessage& aMessage,

   124                                       TBool aIsUAC,

   125                                       TInt aLeaveCode);

   126 

   127     TInt RemoveTransactionItem(TTransactionId& aTransactionId);

   128         

   129     TBool HasRouteSet() const;    

   130     

   131     void AddCallIdHeaderInDialogL(CSIPMessage& aMessage);

   132     

   133     void AddCSeqHeaderInDialogL(CSIPRequest& aRequest);

   134 

   135     

   136 public: // From MDialogContext and MRefreshOwner

   137 

   138     TSIPTransportParams TransportParams(const TRegistrationId& aRegistrationId);    

   139 

   140     

   141 public: // From MTransactionOwner

   142 

   143     void ReceiveL(TUint32 aIapId,

   144                   TTransactionId aTransaction,

   145                   CSIPRequest* aReq);

   146     

   147     void ReceiveL(TTransactionId aTransaction,

   148                   CSIPResponse* aMsg);

   149                   

   150     TInt TransactionEnded(TUint32 aIapId,

   151                           TTransactionId aTransaction,

   152                           TInt aReason);

   153                           

   154     TInt NextCSeq(TUint& aCSeq);

   155     

   156     const MSIPSecUser* SIPSecUser() const;

   157     

   158 

   159 public: // From MRefreshOwner    

   160     

   161     void RefreshReceivedL (TTransactionId aTransactionId,

   162                            TRefreshId aRefreshId,

   163                            CSIPResponse* aSIPResponse);

   164 

   165     TInt RefreshError (TRefreshId aRefreshId,

   166                        TTransactionId aTransactionId,

   167                        TInt aReason);

   168 

   169     TInt NextRefreshCSeq (TUint& aCSeq);

   170     

   171     const MSIPSecUser* SIPSecUser(const TRegistrationId& aRegistrationId);

   172     

   173     TUint RefreshDurationL();

   174 

   175 public: // From MSIPSecUser

   176 

   177 	TBool PassOnlyRealmsToUser() const;

   178 	

   179     void RequestCredentialsL(const TDesC8& aRealm);

   180 	

   181     void RequestCredentialsL(CSIPResponse& aResponse,

   182 	                         TTransactionId aTransactionId,

   183 	                         TRefreshId aRefreshId);

   184     

   185     const MSIPSecUser* TrustedUser(TRegistrationId aRegistrationId);

   186     

   187     TBool ByPassSIPSec() const;

   188     

   189 

   190 public: // New functions    

   191    

   192     TUint32 IapId();

   193    

   194     static TInt Offset();

   195  

   196     void ResetStateL();

   197  

   198     TBool IsEarly() const;

   199 

   200     CDeleteMgr& DeleteMgr();

   201     

   202     TBool Match(CSIPRequest& aRequest) const;

   203     

   204     static TBool ContactOk(const CSIPContactHeader& aContact);

   205 

   206     void SetFirstTransactionId(const TTransactionId& aTransactionId);

   207     

   208     CTransactionItemStore& TransactionItems();

   209     

   210     TBool HasTransactionItem(TTransactionId aTransactionId);

   211 

   212     TDialogStateBase& CurrentState();

   213     

   214     TUint LocalSeqNum();

   215     

   216     TUint RemoteSeqNum();

   217 

   218     void SetLocalAddressL(const CSIPAddress& aAddr);

   219 

   220     const CSIPAddress* LocalAddress();

   221 

   222     void SetRemoteAddressL(const CSIPAddress& aAddr);

   223 

   224     const CSIPAddress* RemoteAddress();

   225     

   226     void SetInitialRemoteTargetL(CURIContainer& aUri);

   227     

   228     void SetRemoteTargetL(CURIContainer& aUri);

   229     

   230     CURIContainer* RemoteTarget();

   231 

   232     void SetLocalTargetWithMsgL(CSIPMessage& aMsg,

   233                                 TBool aUpdateSigCompParam=ETrue);

   234     

   235     CSIPContactHeader* LocalTarget();

   236     

   237     void SetRouteSetUsingRouteL(CSIPMessage& aMessage);

   238     

   239     void SetRouteSetL (RPointerArray<CSIPRouteHeaderBase>& aRoute);

   240     

   241     void UpdateLocalTargetL(CSIPMessage& aMessage);

   242     

   243     void AddRouteToMessageL(CSIPMessage& aMessage);

   244     

   245     void AddRecordRouteToMessageL(CSIPMessage& aMessage);

   246     

   247     void AddToHeaderInDialogL(CSIPRequest& aRequest);

   248     

   249     void AddFromHeaderInDialogL(CSIPRequest& aRequest);    

   250     

   251     void EndTransaction(TTransactionId aTransactionId, TInt aReason);

   252 

   253 

   254 private: // New functions

   255 

   256     CSipDialogItem (CDialogsStore& aDialogStore,

   257                     MSIPSecUser& aSIPSecUser,

   258                     MTransactionUser& aTransactionMgr,

   259                     MSipRefreshMgr& aRefreshMgr,

   260                     CSIPSec& aSIPSec,

   261                     CDeleteMgr& aDeleteMgr,

   262                     MSigComp& aSigComp,

   263                     TRegistrationId aRegistrationId);

   264 

   265     void ConstructL (MDialogOwner* aDialogOwner);

   266 

   267     void UpdateSigCompL (CURIContainer& aUri);

   268     void SetLocalTargetL (CSIPContactHeader& aContact, 

   269                           TBool aUpdateSigCompParam=ETrue);

   270     void UpdateRemoteTagForRefreshesL (RStringF aRemoteTag);

   271     void SetRouteSet (RPointerArray<CSIPRouteHeader>* aRouteSet);

   272     TBool CheckResponse(CSIPResponse* aResponse);

   273     TBool CheckRequest(CSIPRequest* aRequest);

   274     TBool CheckContacts(CSIPMessage& aMessage, 

   275                         TBool aContactRequired=EFalse) const;

   276     void CheckContactsL(TTransactionId aTransactionId,

   277                         CSIPResponse& aResponse) const;

   278     CSipDialogItem* CreateForkingDialogLC();

   279 

   280     void UpdateTransportForNextHopAndLocalTargetL(

   281         CSIPContactHeader* aLocalContactInOutgoingRequest);

   282 

   283     CSIPURI& ExtractUriL(CSIPContactHeader* aContact);

   284 

   285     // Needed for cleanup of Route-set:

   286     static void CleanupRouteSet (TAny* aRouteSet);

   287 

   288 private: // Data

   289 

   290     TSglQueLink iLink;

   291     TDialogId iDialogId;

   292     TRegistrationId iRegistrationId; // Used for filling the Contact hostport

   293     TTransactionId iFirstTransactionId;

   294     CDialogsStore& iDialogStore;

   295     MTransactionUser& iTU;

   296     MSipRefreshMgr& iRefreshMgr;

   297     CSIPSec& iSIPSec;

   298     CDeleteMgr& iDeleteMgr;

   299     MSigComp& iSigComp;

   300     MDialogOwner* iDialogOwner;

   301     MSIPSecUser& iSIPSecUser;

   302     CTransactionItemStore* iTransactionItemStore;

   303     CSigCompMgr* iSigCompMgr;

   304     RStringF iTagParamName;

   305     RStringF iTransportParamName;

   306     RStringF iContactHeaderName;

   307 

   308     // States

   309     TTerminated iTerminated;

   310     TConfirmed iConfirmed;

   311     TEarly iEarly;

   312     TEstablishing iEstablishing;

   313     TDialogStateBase* iCurrentState;

   314 

   315     // Dialog state data

   316     CSIPCallIDHeader* iCallId;

   317     RStringF iLocalTag;

   318     RStringF iRemoteTag;

   319     TBool iRemoteTagSet;

   320     TUint iLocalSeqNum;

   321     TUint iRemoteSeqNum;

   322     CSIPAddress* iLocalAddress;

   323     CSIPAddress* iRemoteAddress;

   324     CURIContainer* iRemoteTarget;

   325     CSIPContactHeader* iLocalTarget;

   326     RPointerArray<CSIPRouteHeader> iRouteSet;

   327     

   328 private: // For testing purposes

   329 

   330     UNIT_TEST(CSipDialogItemTest)

   331     UNIT_TEST(CDialogStoreTest)

   332     UNIT_TEST(CSipDialogMgrTest)

   333     };

   334 

   335 #endif // CSIPDIALOGITEM_H

   336 

   337 // End of File