diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/TransactionUser/src/TransactionInfo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/TransactionUser/src/TransactionInfo.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,343 @@ +/* +* 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 : TransactionInfo.h +* Part of : TransactionUser +* Version : SIP/6.0 +* +*/ + + + + +/** + @internalComponent +*/ + +#ifndef TRANSACTIONINFO_H +#define TRANSACTIONINFO_H + +// INCLUDES +#include "TransactionBase.h" +#include + +// FORWARD DECLARATIONS +class RStringF; +class CURIContainer; +class CSIPToHeader; +class CSIPFromHeader; +class CSIPViaHeader; +class CSIPMessage; +class CSIPCallIDHeader; +class CSIPRecordRouteHeader; +class CSIPContactHeader; + +class CUserAgent; +class MTransactionHeaders; + +// CLASS DECLARATION + +/** + * This class contains information identifying a transaction (=certain headers + * from the SIP request that initiated the transaction), together with the + * addresses of the CUserAgent and CTransaction objects created for handling + * that transaction. + */ +class CTransactionInfo : public CBase + { +public: // Constructor and destructor + + /** + * Creates a new object. + * @param aType Identifies the transaction type + * @param aIapId IAP-id + * @return value New CTransactionInfo object, ownership is transferred. + */ + static CTransactionInfo* NewL(CTransactionBase::TTransactionType aType, + TUint32 aIapId); + + /** + * Destructor. Deletes the owned resources, except does NOT delete UA or + * transaction. + * @see FreeContents + */ + ~CTransactionInfo(); + +public: // New functions + + /** + * Deletes the stored UA and/or transaction. + * @see ~CTransactionStore + */ + void FreeContents(); + + /** + * Checks whether all the required headers for transaction matching and + * constructing a SIP response are present. + * @return ETrue if required headers exist, EFalse otherwise + */ + TBool RequiredHeadersPresent() const; + + /** + * Compares the stored iTransactionType to aType. + * @param aType TransactionType which is compared + * @return ETrue if types are same, EFalse otherwise + */ + TBool CompareType(CTransactionBase::TTransactionType aType) const; + + /** + * Compares the aMethod to the iMethod for determining if the SIP message + * with the aMethod belongs to the same transaction. + * + * If the SIP message that created the transaction was a request, iMethod + * is the request method, otherwise it is the method from CSeq. + * @param aMethod If the SIP message is request, this is the request + * method. Otherwise, this is the method from CSeq. + * @return value ETrue if the methods can belong to same transaction + */ + TBool CompareMethod(RStringF aMethod) const; + + /** + * Compares the Request-URI and request method to the stored values. + * @see CompareMethod + * @param aReqURI Request-URI + * @param aMethod Request method + * @param aSearchCanceledUas ETrue: search is done to find an UAS to be + * canceled. EFalse: search is done to find a transaction to receive an + * incoming SIP message. + * @return value ETrue: If both aReqURI and aMethod match the stored values + * EFalse: otherwise + */ + TBool CompareRequestLine(const CURIContainer& aReqUri, + RStringF aMethod, + TBool aSearchCanceledUas) const; + + /** + * Compares the SIP headers of aReq to the stored headers, and determines + * if the transactions match. + * @param aReq SIP request + * @return ETrue if match, EFalse otherwise + */ + TBool CompareHeaders(CSIPRequest& aReq) const; + + /** + * Obtains a MTransactionReceiver that should handle events received from + * the network. Returns transaction, if it exists, or UA if transaction does + * not exist. + * @return MTransactionReceiver Pointer to the receiver interface. + * Ownership isn't transferred. + */ + MTransactionReceiver* Receiver(); + + /** + * Returns the UA. + * @return Pointer to UA instance. Can be NULL. Ownership isn't transferred. + */ + CUserAgent* UserAgent(); + + /** + * Sets the stored UA. + * @post iUserAgent == aUserAgent + * @param aUserAgent UA instance, can be NULL. Ownership is transferred. + */ + void SetUserAgent(CUserAgent* aUserAgent); + + /** + * Sets the stored transaction. + * @post iTransaction == aTransaction + * @return Pointer to transaction. Can be NULL. Ownership isn't transferred. + */ + void SetTransaction(CTransactionBase* aTransaction); + + /** + * Obtain the TransactionId + * @return TransactionId + */ + TTransactionId TransactionId() const; + + /** + * Set new value for TransactionId + * @param aTransactionId TransactionId + */ + void SetTransactionId(TTransactionId aTransactionId); + + /** + * Obtain the IAP-id. + * @return IAP-id + */ + TUint32 IapId() const; + + /** + * Returns the topmost of the stored Via headers. Caller must not modify + * the Via header. + * @pre iViaHeaders.Count() > 0 + * @return Topmost Via header + */ + CSIPViaHeader& TopVia() const; + + /** + * Copies and stores the transaction related headers from the SIP message. + * The possibly existing old headers are removed from CTransactionInfo, + * regardless whether the same header is present in the aMsg, so that + * CTransactionInfo won't contain headers from more than one different SIP + * message. + * @param aMsg SIP message from where the headers are copied, can be NULL. + * Ownership isn't transferred. If aMsg is NULL, nothing is done. + */ + void UpdateMessageHeadersL(CSIPMessage* aMsg); + + /** + * Updates the To tag. + * @pre iTo != NULL, iTo->HasTag() == EFalse + * @param aTag To tag + */ + void UpdateToTagL(RStringF aTag); + + void StoreRecordRouteHeadersL(CSIPRequest& aReq); + void FreeRecordRouteHeaders(); + + void StoreContactHeadersL(CSIPRequest& aReq); + void FreeContactHeaders(); + + /** + * Checks a request with the aFrom, aCallID, aCSeqNbr and aCSeqMethod is a + * merged request by comparing these values to CTransactionInfo's similar + * values. + * @param aUserAgent UA initiating the search + * @param aFrom From header of a received request + * @param aCallID Call-ID header of a received request + * @param aCSeqNbr CSeq sequence number of a received request + * @param aCSeqMethod CSeq method of a received request + * @return ETrue if the request is a merged request, EFalse otherwise. + */ + TBool IsMergedRequest(const CUserAgent& aUserAgent, + CSIPFromHeader& aFrom, + CSIPCallIDHeader& aCallID, + TUint aCSeqNbr, + RStringF aCSeqMethod) const; + + MTransactionHeaders* TransactionHeadersL(); + + /** + * Copies To, From, Call-ID and CSeq headers from CTransactionInfo into the + * SIP message. If some headers already exist in the aMsg, they are not + * replaced. + * @param aMsg SIP message to which the headers are copied + */ + void CopyToFromCallIDCSeqToMsgL(CSIPMessage& aMsg) const; + + /** + * Copies the stored Via headers into the SIP message. + * @param aMsg SIP message into which where the Vias are copied + */ + void CopyViaHeadersToMsgL(CSIPMessage& aMsg) const; + + void CopyRequestUriToRequestL(CSIPRequest& aReq) const; + + /** + * Creates a SIP request from the stored headers. + * @return SIP request, or NULL if there is not enough information to + * create it. Ownership is transferred. + */ + CSIPRequest* BuildRequestFromStoredInfoL() const; + + /** + * Returns the request method. + * @return Request method + */ + RStringF RequestMethod() const; + + TSglQueLink iLink; + +private: // New functions, for internal use + + /** + * Constructor + * @param aType Identifies the transaction type + * @param aIapId IAP-id + */ + CTransactionInfo(CTransactionBase::TTransactionType aType, TUint32 aIapId); + + /** + * Clears the SIP message related members + */ + void ClearMessageHeaders(); + + /** + * Checks if the method has been stored. + * @param ETrue method has been stored, EFalse otherwise + */ + TBool MethodExists() const; + + /** + * Copies and stores the Via headers from aMsg, maintaining their order. + * @param aMsg SIP message + */ + void CopyViaHeadersFromMsgL(CSIPMessage& aMsg); + +private: // Data + + TTransactionId iTransactionId; + CTransactionBase::TTransactionType iTransactionType; + + // IAP-id + TUint32 iIapId; + + // UA, owned. NULL if iTransaction has been detached from UA. + CUserAgent* iUserAgent; + + // Transaction, can be NULL. Not owned. + CTransactionBase* iTransaction; + + // Request-URI, owned. + CURIContainer* iRequestURI; + + // To header, can be NULL. Owned. + CSIPToHeader* iTo; + // From header, can be NULL. Owned. + CSIPFromHeader* iFrom; + // Call-ID header, can be NULL. Owned. + CSIPCallIDHeader* iCallID; + + // Method from Request line (=same as CSeq method), can be NULL + RStringF iMethod; + + // CSeq sequence number + TUint iCSeq; + + // All Via headers of the SIP request are copied here. + RPointerArray iViaHeaders; + + // Record-route headers, owned. + // Stored only for incoming requests outside of a dialog. + RPointerArray iRecordRoute; + + // Contact headers, owned. + // Stored only for incoming requests outside of a dialog. + RPointerArray iContact; + + +#ifdef CPPUNIT_TEST + friend class CTransactionStore_Test; + friend class CNormalUAC_ResolveAddress_Test; + friend class CNormalUAC_WaitResponse_Test; + friend class CTransactionUser_Test; + friend class CUserAgentServer_Test; + friend class CTransactionInfo_Test; +#endif + }; + +#endif // end of TRANSACTIONINFO_H + +// End of File