--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/realtimenetprots/sipfw/SIP/sipapi/src/SipImplementation.h Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,309 @@
+/*
+* Copyright (c) 2008-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 : SipImplementation.h
+* Part of : SIP Client
+* Version : SIP /6.0
+*
+*/
+
+
+
+
+/**
+ @internalComponent
+*/
+
+#ifndef CSIPIMPLEMENTATION_H
+#define CSIPIMPLEMENTATION_H
+
+// INCLUDES
+#include <e32base.h>
+#include "_sipcodecdefs.h"
+#include "sipclientobserver.h"
+#include "transactionassociation.h"
+
+// FORWARD DECLARATIONS
+class CDesC8Array;
+class MSIPObserver;
+class CSIPClient;
+class CSIPConnection;
+class CSIPConnectionImplementation;
+class CRegistrationState;
+class CUnregistered;
+class CRegistering;
+class CRegistered;
+class CUnregistering;
+class CDialogState;
+class CDialogTrying;
+class CDialogEarly;
+class CDialogConfirmed;
+class CDialogTerminated;
+class CSIPRequestElements;
+class CPendingTransaction;
+class CSIPClientTransaction;
+class CSIPRefresh;
+class CSIPHttpDigest;
+
+// CLASS DECLARATION
+
+/**
+* Implementation class for connecting to SIP server.
+*/
+class CSIPImplementation :
+ public CBase,
+ public MSIPClientObserver,
+ public MTransactionAssociation
+ {
+ public: //Constructors and destructor
+
+ /**
+ * Two-phased constructor.
+ * @param aUid an unique id that identifies client
+ * @param aObserver a observer for asynchronous event
+ * @return New object, ownership is transferred
+ */
+ static CSIPImplementation* NewL(const TUid& aUid,
+ MSIPObserver& aObserver);
+
+ /**
+ * Destructor.
+ */
+ ~CSIPImplementation();
+
+ public : //From MSIPClientObserver:
+ /**
+ * Request has been received from network.
+ *
+ * @param aIapId IAP-id for which the user should create a
+ * CSIPConnection
+ * @param aElements Some SIP headers of the received request. Ownership
+ * is transferred.
+ * @param aRequestId RequestId associated with the received request
+ */
+ void IncomingRequestL(TUint32 aIapId,
+ CSIPRequestElements* aElements,
+ TUint32 aRequestId);
+
+
+ /**
+ * The transcation related to the received SIP request timed out and it
+ * has been destroyed. This happens if the user fails to create a SIP
+ * connection and does not send an appropriate SIP response.
+ *
+ * @param aRequestId RequestId of the request
+ */
+ void TimeOut(TUint32 aRequestId);
+
+ void ChallengeReceivedL(
+ TUint32 aRequestId,
+ CSIPResponseElements* aResponse,
+ MSIPHttpDigestChallengeObserver2& aObserver);
+
+ void ChallengeReceivedInRefreshL(
+ TUint32 aRefreshId,
+ TUint32 aRequestId,
+ CSIPResponseElements* aResponse,
+ MSIPHttpDigestChallengeObserver2& aObserver);
+
+ public: //From MTransactionAssociation:
+
+ CSIPClientConnection& ClientConnectionL();
+
+ CSIPClientConnection* ClientConnection();
+
+ CSIPConnection& SIPConnectionL();
+
+ void AddTransactionL(CSIPTransactionBase& aTransaction);
+
+ void RemoveTransaction(const CSIPTransactionBase& aTransaction);
+
+ public: // New functions
+
+ /**
+ * Gets all supported security mechanisms
+ * @return supported SIP security mechanisms names (e.g. digest);
+ * the ownership is transferred
+ */
+ CDesC8Array* SupportedSecurityMechanismsL() const;
+
+ /**
+ * Checks if the signalling compression (SigComp) is supported.
+ * Leaves on failure with a system wide error code.
+ * @return ETrue if supported, EFalse otherwise
+ */
+ TBool IsSigCompSupportedL() const;
+
+ /**
+ * Gets negotiated security mechanism with the next hop
+ * on the signaling path.
+ * @param aHop the next hop's FQDN or numeric IP address
+ * @return negotiated security mechanism or zero-pointer in case no
+ * security mechanism was negotiated with the next hop;
+ * the ownership is transferred
+ */
+ HBufC8* NegotiatedSecurityMechanismL(const TDesC8& aHop) const;
+
+ /**
+ * Checks if the user has a connection created for given IAP-id
+ * @param aIapId IAP-id
+ * @return sip connection or 0-pointer if connection does not exist.
+ * Ownership is not transferred.
+ */
+ CSIPConnection* Connection(TUint32 aIapId) const;
+
+ /*
+ * By default the SIP built-in security mechanisms are enabled.
+ * @param aEnabled if set to EFalse the build-in SIP security handling
+ * mechanism is disabled.
+ */
+ void SetSecurityHandlingL(TBool aEnabled);
+
+ /*
+ * Tests if SIP security handling mechanism is enabled/disabled
+ * @return ETrue if built-in mechanisms are enabled, EFalse otherwise.
+ */
+ TBool IsSecurityHandlingEnabled() const;
+
+ /*
+ * Create a client transaction for handling a received challenge.
+ * @param aRequestId Request id
+ * @param aResponse Response elements, ownership is transferred
+ * @param aRefresh Refresh to which the transaction will be associated,
+ * or NULL if no refresh used.
+ * Ownership is not transferred.
+ */
+ CSIPClientTransaction*
+ CreateTransactionL(TUint32 aRequestId,
+ CSIPResponseElements* aResponse,
+ CSIPRefresh* aRefresh);
+
+ /**
+ * Ignore each challenge present in the response in the transaction.
+ * @param aTransaction Client transaction
+ * @param aDigest HTTP digest
+ */
+ void IgnoreChallenges(const CSIPClientTransaction& aTransaction,
+ CSIPHttpDigest& aDigest);
+
+ /**
+ * Obtains the used CSIPClient instance
+ *
+ * @return SIPClient
+ */
+ CSIPClient& SIPClient();
+
+ /**
+ * Adds a new connection into CSIPImplementation.
+ *
+ * @param aConnImplementation Implementation of the connection to add
+ * @param aIapId IAP-id
+ */
+ void AddConnectionL(CSIPConnectionImplementation& aConnImplementation,
+ TUint32 aIapId);
+
+ /**
+ * Detach a connection from CSIPImplementation
+ *
+ * @param aConnection Connection to remove
+ */
+ void RemoveConnection(const CSIPConnection& aConnection);
+
+ /**
+ * Attach a CSIPHttpDigest to CSIPImplementation
+ *
+ * @param aDigest CSIPHttpDigest object to attach
+ */
+ void AddDigestL(CSIPHttpDigest& aDigest);
+
+ /**
+ * Detach a CSIPHttpDigest from CSIPImplementation
+ *
+ * @param aDigest CSIPHttpDigest object to remove
+ */
+ void RemoveDigest(const CSIPHttpDigest& aDigest);
+
+ /**
+ * Obtains the initial state for CSIPRegistrations
+ *
+ * @return Initial state of registration state machine. Ownership isn't
+ * transferred.
+ */
+ CRegistrationState* InitialRegisterState();
+
+ /**
+ * Obtains the initial state for CSIPDialog
+ *
+ * @return Initial state of dialog state machine. Ownership isn't
+ * transferred.
+ */
+ CDialogState* InitialDialogState();
+
+ private: // Constructors
+ CSIPImplementation(MSIPObserver& aObserver);
+
+ void ConstructL(const TUid& aUid);
+
+ private: // Data
+ //Application's UID
+ TUid iUid;
+
+ TBool iSecurityHandlingEnabled;
+
+ //Callback to the application
+ MSIPObserver& iObserver;
+
+ //SIP client
+ CSIPClient* iSIPClient;
+
+ //Existing connections, CSIPImplementation doesn't own them.
+ RPointerArray<CSIPConnection> iConnections;
+
+ //When a request comes from network with an IAP-id for which there is
+ //no CSIPConnection instance, the created ServerTransaction is stored
+ //here. In case TimeOut occurs, CSIPImplementation can give the pointer
+ //to the associated ServerTransaction to application.
+ //When application creates a CSIPConnection, all ServerTransactions
+ //which have the same IAP-id are removed from this array.
+ RPointerArray<CPendingTransaction> iPendingServerTransactions;
+
+ //CSIPHttpDigest objects are not owned
+ RPointerArray<CSIPHttpDigest> iDigests;
+
+ //Registration states. These are owned by CSIPImplementation and are
+ //shared by all CSIPRegistrationBinding instances.
+ CUnregistered* iUnregistered;
+ CRegistering* iRegistering;
+ CRegistered* iRegistered;
+ CUnregistering* iUnregistering;
+
+ //Dialog states. These are owned by CSIPImplementation and are shared
+ //by all CSIPDialog instances. There is no proceeding state.
+ CDialogTrying* iDialogTrying;
+ CDialogEarly* iDialogEarly;
+ CDialogConfirmed* iDialogConfirmed;
+ CDialogTerminated* iDialogTerminated;
+
+ 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