diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/TransactionUser/src/SIPMessageUtility.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/TransactionUser/src/SIPMessageUtility.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,425 @@ +/* +* Copyright (c) 2006-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 : SIPMessageUtility.h +* Part of : TransactionUser +* Version : SIP/5.0 +* +*/ + + + + +/** + @internalComponent +*/ + +#ifndef SIPMESSAGEUTILITY_H +#define SIPMESSAGEUTILITY_H + +// INCLUDES +#include +#include "SipStackServerDefs.h" +#include "SipLogs.h" //USE_SIP_LOGS is defined here +#include "TransactionBase.h" + +// FORWARD DECLARATIONS +class RStringF; +class TInetAddr; +class CURIContainer; +class CSIPMessage; +class CSIPResponse; +class CSIPHeaderBase; +class CSIPFromToHeaderBase; +class CSIPViaHeader; + +class CUserAgent; + +// CONSTANTS + +// CLASS DECLARATION +/* + * Miscellaneous SIP message related functions + */ +class CSIPMessageUtility : public CBase + { +public: // Constructor and destructor + + CSIPMessageUtility(); + + ~CSIPMessageUtility(); + +public: // New functions + + /** + * Compares two TInetAddr objects. + * + * @pre aAddr2 has port filled + * @param aAddr TInetAddr to compare + * @param aTransportProtocol Transport protocol of aAddr + * @param aAddr2 Another TInetAddr to compare + * @return value ETrue if ip-addresses and ports match, EFalse otherwise + */ + static TBool CompareTInetAddr(const TInetAddr& aAddr, + RStringF aTransportProtocol, + const TInetAddr& aAddr2); + + /** + * Adds random characters to the given descriptor. + * + * @pre aBuf must have space for at least aLength additional characters + * + * @param aBuf Descriptor into which the random characters are added + * @param aLength Amount of characters added to aBuf + * @param aCaseSensitive ETrue if both upper and lowercase characters are + * allowed to be added into aBuf. EFalse if only lowercase characters are + * to be used. + * @param aMsg SIP message, contains useful input for generating random + * data. Can be NULL. Ownership isn't transferred. + * @param aTransactionId Id of the associated transaction + * @param aUserAgent Address of the associated UserAgent object, can be + * NULL. Ownership isn't transferred. + */ + void AddRandomStringL(TDes8& aBuf, + TInt aLength, + TBool aCaseSensitive, + CSIPMessage* aMsg, + TTransactionId aTransactionId, + const CUserAgent* aUserAgent); + + /** + * Computes a checksum over the data pointed by aPtr, and adds the result + * into aBuf. + * + * @param aBuf Buffer to which the result is appended + * @param aPtr Pointer to data for which the checksum is calculated + * @param aLength Length of the data to be checksummed + */ + static void ComputeChecksum(TDes8& aBuf, const TAny* aPtr, TInt aLength); + + /** + * Returns a reference to the method of the SIP message. In case of request + * this is the request method, and in case of response, it is the method in + * CSeq header. + * + * @param aMsg SIP message + * @return value Reference to method + */ + static RStringF MessageMethod(CSIPMessage& aMsg); + + /** + * Returns the transaction type. + * + * @param aMsg SIP message + * @param aIncomingMsg + * ETrue if the message was received from remote endpoint + * EFalse if the message is sent by the local endpoint + * @return Transaction type + */ + static CTransactionBase::TTransactionType + TransactionType(CSIPMessage& aMsg, TBool aIncomingMsg); + + /** + * Checks whether the top Via header has a branch beginning with the magic + * cookie. + * + * @param aMsg SIP message + * @return value ETrue if top via has branch beginning with the magic + * cookie + */ + static TBool HasViaMagicCookie(CSIPMessage& aMsg); + + /** + * Checks whether aTransport has an allowed value. + * + * @param aTransport Transport protocol + * @return value ETrue if aTransport is valid, EFalse otherwise + */ + static TBool CheckTransport(RStringF aTransport); + + /** + * Reads transport protocol from the top Via header of aMsg, and fills the + * value into aTransport. + * + * @param aMsg IN: SIP message + * @param aTransport OUT: transport protocol from aMsg + * @return ETrue: Transport was found and set, EFalse: Transport not found, + * or has unknown value + */ + static TBool TransportProtocol(CSIPMessage& aMsg, RStringF& aTransport); + + /** + * Updates the top via header's transport parameter to match the value of + * aTransport. + * + * @pre CheckTransport(aTransport) == ETrue + * aMsg has Via header + * + * @param aMsg SIP message + * @param aTransport Transport protocol + */ + static void UpdateViaTransportL(CSIPMessage& aMsg, RStringF aTransport); + + /** + * Compares tags of two To (or From) headers. + * + * @param aHeader To (or From) header + * @param aHeader2 To (or From) header + * @return value ETrue if the tags are equal, EFalse otherwise + */ + static TBool CompareTags(const CSIPFromToHeaderBase& aHeader, + const CSIPFromToHeaderBase& aHeader2); + + /** + * Copies the specified headers from aSrc into aDest, maintaining the + * order. + * + * @param aSrc SIP message from where the headers are copied + * @param aDest SIP message to which the headers are copied. If aDest + * contains same headers before copying, the old headers are removed. + * @param aHeaderName Identifies the headers + */ + static void CopyHeadersL(CSIPMessage& aSrc, + CSIPMessage& aDest, + RStringF aHeaderName); + + /** + * Copies the Authorization and Proxy-Authorization headers from aSrc into + * aDest. If aSrc is NULL, nothing is done. + * + * @param aSrc SIP message from where the headers are copied, can be NULL. + * Ownership is not transferred. + * @param aDest SIP message to which the headers are copied. If aDest + * contains same headers before copying, the old headers are removed. + */ + static void CopyAuthorizationHeadersL(CSIPMessage* aSrc, + CSIPMessage& aDest); + + /** + * Makes a copy of the specified header, and returns a pointer to it. + * This function only copies one header, and if there are multiple headers + * in aMsg, only the first is copied. + * + * @param aMsg SIP message from where the header is copied + * @param aHeaderName Identifies the header + * @return Copy of the header, or NULL if header wasn't present in aMsg. + * Ownership is transferred. + */ + static CSIPHeaderBase* CopyHeaderFromMsgL(CSIPMessage& aMsg, + RStringF aHeaderName); + + /** + * Fills the CSeq header into aMsg. If aMsg already contains a CSeq header, + * it isn't changed. + * + * @param aMsg IN/OUT: SIP message + * @param aSeq CSeq sequence number + * @param aMethod CSeq method + */ + static void FillCSeqL(CSIPMessage& aMsg, + TUint aSeq, + RStringF aMethod); + + /** + * Checks whether the SIP message is an ACK request + * + * @param aMsg SIP message + * @return ETrue aMsg is ACK, EFalse otherwise + */ + static TBool IsAck(const CSIPMessage& aMsg); + + /** + * Checks whether the SIP response is a final response. + * + * @param aResp SIP response + * @return ETrue aResp is a final response (2xx-6xx), + * EFalse Otherwise + */ + static TBool IsFinalResponse(const CSIPResponse& aResp); + + /** + * Checks whether the URI has a parameter comp=sigcomp + * + * @param aUri URI + * @return ETrue If aUri has a parameter comp=sigcomp, EFalse otherwise + */ + static TBool HasSigCompParam(const CURIContainer& aUri); + + /** + * Checks whether the SIP message is a 2xx class response + * + * @param aMsg SIP message + * @return ETrue aMsg is a 2xx response, EFalse otherwise + */ + static TBool Is2xxResponse(const CSIPMessage& aMsg); + + /** + * Returns the topmost Via header of SIP message. + * + * @param aMsg SIP message + * @return Via header, or NULL if no Via header exists in aMsg. Ownership + * is not transferred. + */ + static CSIPViaHeader* TopVia(CSIPMessage& aMsg); + + static const TDesC8& BranchMagicCookie(); + + static const TDesC8& UriDescriptor(const CURIContainer& aUri); + + /** + * Determines if the local address is in the IPv4 private address space. + * + * @param aTransportMgr TransportMgr + * @param aIapId IAP-id + * @return ETrue Local address is a private address + * EFalse Otherwise + */ + static TBool IsPrivateAddressL(MSIPTransportMgr& aTransportMgr, + TUint32 aIapId); + +private: + + static HBufC* ConvertUtf8LC(const TDesC8& aUtf8); + + /** + * Returns the SIP port of aAddr. + * + * @param aAddr Address + * @param aTransportProtocol Transport protocol + * @return value Port number + */ + static TUint SIPPort(const TInetAddr& aAddr, RStringF aTransportProtocol); + + /** + * Builds a buffer containing random data. + * + * @param aLength Amount of bytes the buffer will contain + * @param aMsg SIP message, contains useful input for generating random + * data. Can be NULL. Ownership isn't transferred. + * @param aTransactionId Id of the associated transaction + * @param aUserAgent Address of the associated UserAgent object, can be + * NULL. Ownership isn't transferred. + * @return value Buffer containing random data. Ownership is transferred. + */ + HBufC8* BuildInputDataL(TUint aLength, + CSIPMessage* aMsg, + TTransactionId aTransactionId, + const CUserAgent* aUserAgent); + + /** + * Checks if there is space left for aSize amount of bytes in the aBuf. + * + * @param aBuf Descriptor + * @param aSize Amount of bytes + * @return value ETrue if aBuf has free space for at least aSize bytes, + * EFalse otherwise. + */ + static TBool FitsInBuf(const TDes8& aBuf, TInt aSize); + + /** + * Returns aBits long sequence of bits from the aBuf. + * + * @param aBuf Descriptor from where the bits are read + * @param aBits How many bits are read + * @param aCounter Offset into the descriptor aBuf, indicating the position + * from where the bits are read. Zero means the bits are read from the + * beginning of aBuf. + * @return value Bit sequence containing aBits bits + */ + static TUint8 GetNextBits(const TDesC8& aBuf, + TInt aBits, + TUint& aCounter); + + /** + * Adds random data into the aBuf. The random data is generated using the + * SIP message (aMsg) as input. + * + * @param aMsg SIP message, can be NULL. Ownership isn't transferred + * @param aBuf Random data is appended to this buffer + */ + void AddCheckSumOfSipMessageL(CSIPMessage* aMsg, TDes8& aBuf); + + /** + * Adds random data into the aBuf. The random data is generated using + * aHeader and iCounter as inputs and by combining the user, host and tag + * into a single descriptor, and calculating a checksum over the data. + * + * @param aHeader To or From header + * @param aBuf Random data is appended to this buffer + */ + void AddCheckSumOfFromToHeaderL(CSIPFromToHeaderBase& aHeader, + TDes8& aBuf); + + /** + * Adds random data into the aBuf. The random data is generated using the + * CSeq sequence number of the aMsg as input. + * + * @param aMsg SIP message + * @param aBuf Random data is appended to this buffer + */ + static void AddCheckSumOfCSeq(CSIPMessage& aMsg, TDes8& aBuf); + + /** + * Adds random data into the aBuf. The random data is generated using the + * iCounter and current time as inputs. + * + * @param aBuf Random data is appended to this buffer + */ + void AddCheckSumOfClock(TDes8& aBuf) const; + + /** + * Adds random data into the aBuf. The random data is generated using the + * iCounter and aTransactionId as inputs. + * + * @param aTransactionId Id of the associated transaction + * @param aBuf Random data is appended to this buffer + */ + void AddCheckSumOfTaIdL(TTransactionId aTransactionId, TDes8& aBuf); + + /** + * Adds random data into the aBuf. The random data is generated using the + * request method and Request URI of the aMsg as inputs. If aMsg is a + * response, nothing is added to aBuf. + * + * @param aMsg SIP message + * @param aBuf Random data is appended to this buffer + */ + static void AddCheckSumOfRequestLineL(CSIPMessage& aMsg, TDes8& aBuf); + + /** + * Adds random data into the aBuf. The random data is generated using the + * clock, amount of free and used memory and the inactivity time. + * + * @param aBuf Random data is appended to this buffer + */ + void AddSystemInfo(TDes8& aBuf) const; + +private: // Data + + //Seed value for Math::Rand() + TInt64 iSeed; + + //Counter value used for generating random values + TInt32 iCounter; + +private: // For testing purposes + +#ifdef CPPUNIT_TEST + friend class CSIPMessageUtility_Test; +#endif + }; + +#endif // end of SIPMESSAGEUTILITY_H + +// End of File