realtimenetprots/sipfw/SIP/Server/inc/CSipCSSubSession.h
changeset 0 307788aac0a8
equal deleted inserted replaced
-1:000000000000 0:307788aac0a8
       
     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          : CSipCSSubSession.h
       
    16 * Part of       : SIPServerCore
       
    17 * Version       : SIP/6.0 
       
    18 *
       
    19 */
       
    20 
       
    21 
       
    22 
       
    23 
       
    24 /**
       
    25  @internalComponent
       
    26 */
       
    27 #ifndef CSIPCSSUBSESSION_H
       
    28 #define CSIPCSSUBSESSION_H
       
    29 
       
    30 #include <e32base.h>
       
    31 #include <stringpool.h>
       
    32 #include <in_sock.h>
       
    33 #include "SipStackServerDefs.h"
       
    34 #include "sipconnection.h"
       
    35 #include "TSIPTransportParams.h"
       
    36 #include "MSIPCSReceiverOwner.h"
       
    37 #include "_sipcodecdefs.h"
       
    38 
       
    39 class CSipCSSession;
       
    40 class MSIPSecUser;
       
    41 class MTransactionOwner;
       
    42 class CSipServerCore;
       
    43 class CSipCSServerITC;
       
    44 class CSipCSReceiverBase;
       
    45 class CSipCSSubSessionReceiver;
       
    46 class CSIPFromHeader;
       
    47 class CURIContainer;
       
    48 class CSIPMessage;
       
    49 class CSIPRequest;
       
    50 class TSIPRemoteTargetAndProxy;
       
    51 
       
    52 
       
    53 class CSipCSSubSession : public CObject,
       
    54                          public MSIPCSReceiverOwner
       
    55 	{
       
    56 public: // Constructors and desctructor
       
    57     
       
    58     static CSipCSSubSession* NewLC (CSipCSSession& aSession,
       
    59                                     MSIPSecUser& aSIPSecUser,
       
    60 		                            TUint32 aIapId);
       
    61     ~CSipCSSubSession();
       
    62 
       
    63 public: // From MSIPCSReceiverOwner
       
    64 
       
    65     const TSIPTransportParams& TransportParams() const;
       
    66 
       
    67     TSIPTransportParams TransportParams(
       
    68         const TRegistrationId& aRegistrationId);
       
    69         
       
    70     const MSIPSecUser* SIPSecUser(const TRegistrationId& aRegistrationId);
       
    71 
       
    72 public: // New functions
       
    73 
       
    74     TUint32 IapId () const;
       
    75     MTransactionOwner* TransactionOwner();
       
    76     CSipCSReceiverBase& Receiver();
       
    77     void OpenIapL(const RMessage2& aMessage);
       
    78     void SetStateL(CSIPConnection::TState aState);
       
    79     void ServiceL(TSIPIds& aIds, TInt aFunction, const RMessage2& aMessage);
       
    80 
       
    81 private: // New functions
       
    82 
       
    83     CSipCSSubSession (CSipCSSession& aSession,
       
    84                       MSIPSecUser& aSIPSecUser,
       
    85 		              TUint32 aIapId);
       
    86 
       
    87     void ConstructL ();
       
    88 
       
    89     // Services
       
    90     void GetLocalAddrL(const RMessage2& aMessage);
       
    91     
       
    92     void SetSIPSockOptL(const RMessage2& aMessage, TBool aDesOpt=EFalse);
       
    93     
       
    94 	void SetOutboundProxyL (TSIPIds& aIds, const RMessage2& aMessage);    
       
    95     
       
    96 	void OutboundProxyL (TSIPIds& aIds, const RMessage2& aMessage);
       
    97 
       
    98 	void RemoveOutboundProxyL (TSIPIds& aIds);
       
    99 	
       
   100     void RegisterL (TSIPIds& aIds, const RMessage2& aMessage);
       
   101 	
       
   102     void RegisterAndSetOutboundProxyL(TSIPIds& aIds, const RMessage2& aMessage);
       
   103 	
       
   104     void UpdateRegistrationL (TSIPIds& aIds, const RMessage2& aMessage);
       
   105 	
       
   106     void UnRegisterL (TSIPIds& aIds, const RMessage2& aMessage);
       
   107 	
       
   108     void FetchRegistrationsL (const RMessage2& aMessage);
       
   109     
       
   110     void SendRequestL (TSIPIds& aIds, const RMessage2& aMessage);
       
   111 	
       
   112     void SendRequestAndUpdateRefreshL (TSIPIds& aIds,
       
   113                                        const RMessage2& aMessage);
       
   114 
       
   115     void SendRequestAndTerminateRefreshL (TSIPIds& aIds,
       
   116                                           const RMessage2& aMessage);
       
   117     
       
   118     void SendResponseL (TSIPIds& aIds, const RMessage2& aMessage);
       
   119 
       
   120     void SendResponseAndCreateDialogL (TSIPIds& aIds,
       
   121                                        const RMessage2& aMessage);
       
   122 
       
   123     void SendResponseInDialogL (TSIPIds& aIds, const RMessage2& aMessage);
       
   124 
       
   125     void SendRequestAndCreateDialogL (TSIPIds& aIds, const RMessage2& aMessage);
       
   126 
       
   127     void SendRequestInDialogL (TSIPIds& aIds, const RMessage2& aMessage);
       
   128 
       
   129     void SendRequestInDialogAndUpdateRefreshL (TSIPIds& aIds,
       
   130                                                const RMessage2& aMessage);
       
   131                                                
       
   132     void SendCancelL (TSIPIds& aIds,
       
   133                       const RMessage2& aMessage);
       
   134 
       
   135 	void TerminateDialogL (const TDialogId& aId);
       
   136 
       
   137 	void TerminateRefreshL (const TRefreshId& aId);
       
   138 
       
   139 	void TerminateDialogRefreshL (const TDialogId& aDialogId,
       
   140                                   const TRefreshId& aRefreshId);
       
   141 
       
   142 	void TerminateRegistrationL (const TRegistrationId& aId);
       
   143     
       
   144     void ReceiveSipMessageL (const RMessage2& aMessage);
       
   145 
       
   146     void ClientReadyToReceiveL (const RMessage2& aMessage);
       
   147     
       
   148     void CancelClientReceiveL ();
       
   149 
       
   150     void GetFromHeaderL (const TRegistrationId& aId,
       
   151                          const RMessage2& aMessage);
       
   152     
       
   153     void SetRefreshIntervalL (const TRefreshId& aRefreshId, 
       
   154                               const RMessage2& aMessage);
       
   155 
       
   156     void GetRefreshIntervalL (const TRefreshId& aRefreshId,
       
   157                               const RMessage2& aMessage);
       
   158                               
       
   159     void GetCallIDHeaderL (const TDialogId& aId,
       
   160                            const RMessage2& aMessage);
       
   161                            
       
   162     void GetLocalTagL (const TDialogId& aId,
       
   163                        const RMessage2& aMessage);                  
       
   164 
       
   165     void GetRegisteredContactL (const TRegistrationId& aId,
       
   166                                 const RMessage2& aMessage);
       
   167 
       
   168     void ResetDialogStateL(const TDialogId& aId);
       
   169 
       
   170     // Helper functions:
       
   171     CSipCSServerITC& ITC ();
       
   172     
       
   173     CSipServerCore& Server ();
       
   174     
       
   175     CURIContainer* FillRequestLC (const RMessage2& aMessage,
       
   176                                   CSIPRequest& aRequest,
       
   177                                   TBool aMethodExpected=EFalse);
       
   178 
       
   179     void FillRequestL (const RMessage2& aMessage,
       
   180                        CSIPRequest& aRequest,
       
   181                        TSIPRemoteTargetAndProxy& aRemoteTargetAndProxy,
       
   182                        TBool aMethodExpected=EFalse,
       
   183                        TBool aProxyExpected=EFalse);
       
   184 
       
   185 	TBool OverlappingInDialogAllowed (RStringF aMethod);
       
   186 
       
   187     void AddFromL (const TRegistrationId& aRegistrationId,
       
   188                    CSIPRequest& aRequest);
       
   189 
       
   190     void AddContactL (const TRegistrationId& aRegistrationId,
       
   191                       CSIPMessage& aMessage);
       
   192 
       
   193     void AddRouteL (const TRegistrationId& aRegistrationId,
       
   194                     CSIPRequest& aRequest);
       
   195                     
       
   196     void CheckSigCompInNextHopL (TRegistrationId aRegistrationId,
       
   197                                  CURIContainer& aRemoteTarget,
       
   198                                  CSIPRequest& aRequest); 
       
   199                     
       
   200     void FillToAndRemoteTargetL (CSIPRequest& aRequest,
       
   201                                  TSIPRemoteTargetAndProxy& aRemoteTargetAndProxy);
       
   202 
       
   203     void CheckSigCompInContactsL (CSIPMessage& aMessage);
       
   204 
       
   205     TBool HasSigCompParameter (CURIContainer& aURI) const;
       
   206     
       
   207     void RefreshConnectionL(TUint32 aIapId);
       
   208     
       
   209     void GetConnectionErrorL(TSIPIds& aIds, const RMessage2& aMessage);
       
   210 
       
   211     
       
   212 private: // Data    
       
   213     
       
   214     CSipCSSession& iSession;
       
   215     MSIPSecUser& iSIPSecUser;
       
   216     TSIPTransportParams iTransportParams;
       
   217     CSIPConnection::TState iState;
       
   218     TInt iHandle;
       
   219     CSipCSSubSessionReceiver* iReceiver;    
       
   220     TBool iIapOpened;
       
   221     TInetAddr iLocalAddr;
       
   222 
       
   223 private: // For testing purposes
       
   224 
       
   225 	UNIT_TEST(CSipCSSubSessionTest)
       
   226 	};
       
   227 
       
   228 #endif // CSIPCSSUBSESSION_H
       
   229 
       
   230 // End of File