diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmcesrv/mmceserver/inc/mcesip.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/mmcesrv/mmceserver/inc/mcesip.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,683 @@ +/* +* Copyright (c) 2005 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: +* +*/ + + + + +#ifndef MCESIP_H +#define MCESIP_H + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "mceserial.h" +#include "mcesipextensions.h" + +// FORWARD DECLARATION + +class CSdpDocument; +class CSIPDialog; +class CSIPContactHeader; + +// CLASS DECLARATION + + +enum TMceSipResponseType + { + E1XX, + E2XX, + E3XX, + E4XX, + E5XX, + E6XX + }; + +//E1XX, +const TUint KMceSipTrying = 100; +const TUint KMceSipRinging = 180; +const TUint KMceSipCallIsBeingForwarded = 181; +const TUint KMceSipQueued = 182; +const TUint KMceSipSessionProgress = 183; + +//E2XX, +const TUint KMceSipOK = 200; +const TUint KMceSipAccepted = 202; + +//E3XX, +const TUint KMceSipMultipleChoices = 300; +const TUint KMceSipMovedPermanently = 301; +const TUint KMceSipMovedTemporarily = 302; +const TUint KMceSipUseProxy = 305; +const TUint KMceSipAlternativeService = 380; + +//E4XX, +const TInt KMceSipBadRequest = 400; +const TUint KMceSipUnauthorized = 401; +const TUint KMceSipPaymentRequired = 402; +const TUint KMceSipForbidden = 403; +const TUint KMceSipNotFound = 404; +const TUint KMceSipMethodNotAllowed = 405; +const TUint KMceSip4XXNotAcceptable = 406; +const TUint KMceSipProxyAuthenticationRequired = 407; +const TUint KMceSipRequestTimeout = 408; +const TUint KMceSipGone = 410; +const TUint KMceSipequestEntityTooLarge = 413; +const TUint KMceSipRequestURITooLong = 414; +const TUint KMceSipUnsupportedMediaType = 415; +const TUint KMceSipUnsupportedURIScheme = 416; +const TUint KMceSipBadExtension = 420; +const TUint KMceSipExtensionRequired = 421; +const TUint KMceSipSessionIntervalTooSmall = 422; +const TUint KMceSipIntervalTooBrief = 423; +const TUint KMceSipTemporarilyUnavailable = 480; +const TUint KMceSipCallOrTransactionDoesNotExist = 481; +const TUint KMceSipLoopDetected = 482; +const TUint KMceSipTooManyHops = 483; +const TUint KMceSipAddressIncomplete = 484; +const TUint KMceSipAmbiguous = 485; +const TUint KMceSipBusyHere = 486; +const TUint KMceSipRequestTerminated = 487; +const TUint KMceSipNotAcceptableHere = 488; +const TUint KMceSipBadEvent = 489; +const TUint KMceSipRequestPending = 491; +const TUint KMceSipUndecipherable = 493; + +const TUint KMceSipRefreshInterval = 60; + + +//E5XX, +const TUint KMceSipServerInternalError = 500; +const TUint KMceSipNotImplemented = 501; +const TUint KMceSipBadGateway = 502; +const TUint KMceSipServiceUnavailable = 503; +const TUint KMceSipServerTimeOut = 504; +const TUint KMceSipVersionNotSupported = 505; +const TUint KMceSipMessageTooLarge = 513; +//580 Precondition Failure: +const TInt KMceSipPreconditionFailure = 580; + +//E6XX, +const TUint KMceSipBusyEverywhere = 600; +const TUint KMceSipDecline = 603; +const TUint KMceSipDoesNotExistAnywhere = 604; +const TUint KMceSip6XXNotAcceptable = 606; + + + +typedef TUint TMceSipWarningCode; + +//300 Incompatible network protocol: One or more network protocols +//contained in the session description are not available. +const TMceSipWarningCode KMceSipWarnIncompatibleNetworkProtocol = 300; + +//301 Incompatible network address formats: One or more network +//address formats contained in the session description are not +//available. +const TMceSipWarningCode KMceSipWarnIncompatibleNetworkAddressFormat = 301; + +//302 Incompatible transport protocol: One or more transport +//protocols described in the session description are not available. +const TMceSipWarningCode KMceSipWarnIncompatibleTransportProtocol = 302; + +//303 Incompatible bandwidth units: One or more bandwidth +//measurement units contained in the session description were not understood. +const TMceSipWarningCode KMceSipWarnIncompatibleBandwidthUnits = 303; + +//304 Media type not available: One or more media types +//contained in the session description are not available. +const TMceSipWarningCode KMceSipWarnMediaTypeNotAvailable = 304; + +//305 Incompatible media format: One or more media +//formats contained in the session description are not available. +const TMceSipWarningCode KMceSipWarnIncompatibleMediaFormat = 305; + +//306 Attribute not understood: One or more of the media +//attributes in the session description are not supported. +const TMceSipWarningCode KMceSipWarnAttributeNotUnderstood = 306; + +//307 Session description parameter not understood: A parameter +//other than those listed above was not understood. +const TMceSipWarningCode KMceSipWarnSessionDescriptionParameterNotUnderstood = 307; + +//330 Multicast not available: The site where the user is located +//does not support multicast. +const TMceSipWarningCode KMceSipWarnMulticastNotAvailable = 330; + +//331 Unicast not available: The site where the user is located does +//not support unicast communication (usually due to the presence of a firewall). +const TMceSipWarningCode KMceSipWarnUnicastNotAvailable = 331; + +//370 Insufficient bandwidth: The bandwidth specified in the session +//description or defined by the media exceeds that known to be available. +const TMceSipWarningCode KMceSipWarnInsufficientBandwidth = 370; + +//399 Miscellaneous warning: The warning text can include arbitrary +//information to be presented to a human user or logged. A system receiving +//this warning MUST NOT take any automated action. +const TMceSipWarningCode KMceSipWarnMiscellaneous = 399; + +const TChar KMceSipSeparator = ':'; +const TChar KMceSipHeaderSeparator = ';'; +const TChar KMceSipEqualsTo = '='; +const TChar KMceSipAt = '@'; +const TChar KMceSipBlank = ' '; +const TChar KMceSipDash = '-'; + +_LIT8( KMceSipNullAddress, "0.0.0.0" ); +_LIT8( KMceSipNullAddressA, "c=IN IP4 0.0.0.0\n" ); +_LIT8( KMceSipPhraseRequestPending, "Request Pending"); +_LIT8( KMceSipPhraseAccepted, "Accepted" ); + +_LIT8( KMceSipWarnPhrase300, "Incompatible network protocol"); +_LIT8( KMceSipWarnPhrase301, "Incompatible network address formats"); +_LIT8( KMceSipWarnPhrase302, "Incompatible transport protocol"); +_LIT8( KMceSipWarnPhrase303, "Incompatible bandwidth units"); +_LIT8( KMceSipWarnPhrase304, "Media type not available"); +_LIT8( KMceSipWarnPhrase305, "Incompatible media format"); +_LIT8( KMceSipWarnPhrase306, "Attribute not understood"); +_LIT8( KMceSipWarnPhrase307, "Session description parameter not understood"); +_LIT8( KMceSipWarnPhrase330, "Multicast not available"); +_LIT8( KMceSipWarnPhrase331, "Unicast not available"); +_LIT8( KMceSipWarnPhrase370, "Insufficient bandwidth"); +_LIT8( KMceSipWarnPhrase399, "Miscellaneous warning"); +_LIT8( KMceSipErrPhrase580, "Precondition Failure"); + +_LIT8( KMceSipWarningPattern, "%d %S %S"); +_LIT8( KMceSipContentTypePattern, "%S/%S"); +_LIT8( KMceSipContactURIPattern, "sip:%S@localhost" ); +_LIT8( KMceSipSdpSegPrecCurrentStatusPattern, "qos %S %S" ); +_LIT8( KMceSipSdpSegPrecDesiredStatusPattern, "qos %S %S %S" ); + + +_LIT8( KMceSipSdpSecPrecCurrentStatusPattern, "sec %S %S" ); +_LIT8( KMceSipSdpSecPrecDesiredStatusPattern, "sec %S %S %S" ); + + +_LIT8( KMceSipWarning, "Warning" ); +_LIT8( KMceSipTimer, "timer" ); +_LIT8( KMceSipRefresher, "refresher" ); +_LIT8( KMceSipRefresherUAC, "uac" ); +_LIT8( KMceSipRefresherUAS, "uas" ); +_LIT8( KMceSipSdpQos, "qos" ); +_LIT8( KMceSipSdpSec, "sec" ); +_LIT8( KMceSipSdpPreconditionCurr, "curr" ); +_LIT8( KMceSipSdpPreconditionDes, "des" ); +_LIT8( KMceSipSdpQosNone, "none" ); +_LIT8( KMceSipEventPackageRefer, "refer" ); +_LIT8( KMceSipStateActive, "active" ); +_LIT8( KMceSipStatePending, "pending" ); +_LIT8( KMceSipStateTerminated, "terminated" ); +_LIT8( KMceSipReferEventName, "refer" ); +_LIT8( KMceSipReferAcceptType, "message" ); +_LIT8( KMceSipReferAcceptSubtype, "sipfrag" ); +_LIT8( KMceSipVersion, "version" ); +_LIT8( KMceSipNotifyContent, "SIP/2.0 100 Trying\r\n" ); +_LIT8( KMceSipValueNoReferSub, "norefersub"); +_LIT8( KMceSipValueMultipleRefer,"multiple-refer" ); +_LIT8( KMceSipValueFalse, "false" ); +_LIT8( KMceSipHeaderReferSub, "Refer-Sub" ); +_LIT8( KMceSipHeaderSessionExpires, "Session-Expires" ); +_LIT8( KMceSipHeaderCompactFormOfSessionExpires, "x" ); +_LIT8( KMceSipHeaderMinSE, "Min-SE" ); +_LIT8( KMceSipMediaTypeApplication, "application" ); +_LIT8( KMceSipMediaSubTypeSDP, "sdp" ); +_LIT8( KMceSipMPartMediaTypeMultipart, "multipart" ); +_LIT8( KMceSipMPartMediaSubTypeMixed, "mixed" ); +_LIT8( KMceSipMPartBoundary, "boundary" ); +_LIT8( KMceSipMPartMessageBoundary, "MessageBoundary" ); +_LIT8( KMceSipMPartMessagePattern, +"--MessageBoundary\r\n\ +Content-Type: application/sdp\r\n\r\n\ +%S\r\n\ +--MessageBoundary\r\n\ +Content-Type: %S\r\n\r\n\ +%S\ +--MessageBoundary--\r\n"); + +_LIT8( KMceSipSubscriptionStateHeader, "Subscription-State" ); +_LIT8( KMceSipTransportTLS, "transport=tls"); +_LIT8( KMceSipUriSchemeSIPs, "sips"); +_LIT8( KMceSdpAttrRtcp, "rtcp" ); +_LIT8( KMceSdpSpace, " " ); + +// Extensions +_LIT8( KMceSip100Rel,"100rel" ); +_LIT8( KMceSipPrecondition, "precondition" ); + +const TInt KMceRandMaxRetryValue = 10; +const TInt KMceRandMinRetryValue = 1; +const TInt KMceRandDividerOne = 1000000; +const TInt KMceRandDividerTwo = 1000; + +const TBool KMceUseRetryAfter = ETrue; +const TBool KMceNoRetryAfter = EFalse; + +// Time Conversion. +const TUint KConversionMilliToMicro = 1000; +const TUint KMceOneSecondAsMicros( 1000000 ); +_LIT8( KMceSdpAttributeLineMarker, "a=" ); +_LIT8( KMceSdpBandwidthLineMarker, "b=" ); + +/** +* Static library providing basic helper methods +* to handle SIP API related issues +* +* @lib +* @since +*/ +class MceSip + { + +public://transaction related + + /** + * Returns method of server transaction (request) + * @param aRequest the server transaction + * @return method of server transaction + */ + static RStringF Method( CSIPServerTransaction& aRequest ); + + /** + * Returns response code of client transaction (response) + * @param aResponse the client transaction + * @return response code (1XX-6XX) + */ + static TUint ResponseCode( CSIPClientTransaction& aResponse ); + + /** + * Returns response type + * @param aResponse the client transaction + * @return response type (1XX-6XX) + */ + static TMceSipResponseType ResponseType( + CSIPClientTransaction& aResponse ); + /** + * Returns response type + * @param aCode the response type + * @return response type (1XX-6XX) + */ + static TMceSipResponseType ResponseType( TUint aCode ); + + /** + * Checks if client transction is response to method + * @param aResponse the client transaction + * @param aMethod the method + * @return ETrue, if client transctions is response to method + */ + static TBool IsResponseTo( CSIPClientTransaction& aResponse, + RStringF aMethod ); + + /** + * Returns transaction's state + * @param aTransaction the transaction + * @return transaction's state + */ + static CSIPTransactionBase::TState TrxState( + CSIPTransactionBase& aTransaction ); + + /** + * Returns ETrue, if transaction is completed + * @param aTransaction the transaction + * @return ETrue, if transaction is completed + */ + static TBool TrxCompleted( CSIPTransactionBase& aTransaction ); + + /** + * Returns transaction's type as an index to string pool + * @param aTransaction the transaction + * @return transaction's type as an index to string pool + */ + static TInt TrxType( CSIPTransactionBase& aTransaction ); + + + /** + * Returns SIP message elements from transaction + * @param aTransaction the transaction + * @return SIP message elements + */ + static const CSIPMessageElements* ToMessageElements( + CSIPTransactionBase& aTransaction ); + + /** + * Checks the content of transaction + * @param aTransaction the transaction + * @return ETrue, if there is a content + */ + static TBool HasContent( CSIPTransactionBase& aTransaction ); + + + /** + * Checks whether the message contains the certain header with + * certain value. + * @param aMessage message that header where to be found from. + * @param aHeaderName headername as string pool index + * @param aHeaderValue the value to be searched + * @return ETrue, if given header with given value is present. + */ + static TBool HasHeaderValueL( const CSIPMessageElements& aMessage, + TInt aHeaderName, + const TDesC8& aHeaderValue ); + + /** + * Checks whether the user headers contains the certain header with + * certain value. + * @param aHeaders user header that specific header where to be found from. + * @param aHeaderName headername as string pool index + * @param aHeaderValue the value to be searched + * @return ETrue, if given header with given value is present. + */ + static TBool HasHeaderValueL( const RPointerArray& aHeaders, + TInt aHeaderName, + const TDesC8& aHeaderValue ); + /** + * Finds Specific Headers + * @param aMessage message that header where to be found from. + * @param aHeaderName headername which want to be found in the message. + * @param aHeaders array for which the found headers are added. + * ownership of the objects is not transfered, + */ + static void FindHeadersL( const CSIPMessageElements& aMessage, + RStringF aHeaderName, + RPointerArray& aHeaders ); + + /** + * Compare remote uri with EUriScheme, EUriUserinfo and EUriHost. + * @param aRemoteUriOne, a remoteUri to be compared. + * @param aRemoteUriTwo, a remoteUri to be compared. + * @return An integer value of zero if the components are the same, + * any other value if the components are not the same. + */ + static TInt CompareUri( const CUri8& aRemoteUriOne, const CUri8& aRemoteUriTwo ); + +public://SIP string pool related + + /** + * Returns reson phrase based on status (reponse) code + * @param aStatusCode status code + * @return reson phrase. Ownership is transferred + */ + static RStringF ReasonPhraseL( TUint aStatusCode ); + + /** + * Returns warning phrase based on warning code + * @param aWarnCode warning code + * @return warning phrase. Ownership is transferred + */ + static RStringF WarningPhraseL( TUint aWarnCode ); + + /** + * Returns index of SIP string pool if given string is + * found from the pool + * @param aSIPString a string + * @return index of SIP string pool, KErrNotFound is + * returned if string is not found + */ + static TInt SIPStringIndex( const TDesC8& aSIPString ); + + +public://header manipulation + + /** + * Finds Specific Header + * @param aMessage message that header where to be found from. + * @param aHeaderName headername which want to be found in the message. + * @return pointer to the created request message. The + * ownership is not transferred. + */ + static CSIPHeaderBase* FindHeader( const CSIPMessageElements& aMessage, + RStringF aHeaderName ); + + /** + * Finds Specific Header + * @param aHeaders headers that specific header where to be found from. + * @param aHeaderName headername which want to be found in the message. + * @return pointer to the created request message. The + * ownership is not transferred. + */ + static CSIPHeaderBase* FindHeader( const RPointerArray& aHeaders , + RStringF aHeaderName ); + /** + * Converts SIP address to text + * @param aToAddr SIP Address + * @return SIP address as text + * ownership is transferred. + */ + static HBufC8* AddressToTextL( const CSIPAddress& aToAddr ); + + /** + * Converts SIP address to text + * @param aToAddr SIP Address + * @return SIP address as text + * ownership is transferred. + */ + static CDesC8Array* UserHeadersToTextArrayL( + CSIPTransactionBase& aTransaction, + const CSIPDialog& aDialog ); + + /** + * Converts SIP from address to from header + * @param aAddress SIP Address as text + * @return SIP address as SIP from header + * ownership is transferred. + */ + static CSIPFromHeader* ToFromHeaderL( const TDesC8& aAddress ); + + /** + * Converts header string array to SIP header arrays + * @param aSIPHeaders SIP header array to fill + * @param aHeaders string array + */ + static void ToSIPExtensionHeadersL( + RPointerArray& aSIPHeaders, + const MDesC8Array& aHeaders ); + + /** + * Converts content type to SIP content type header + * @param aContentType enum type to define if content type is predefined + * such as application/sdp or user defined + * @param aUserDefinedContentType if user defined content type, content type + * as text + * @return SIP content type header + */ + static CSIPContentTypeHeader* ToContentTypeHeaderL( + TMceContentType aContentType, + const HBufC8* aUserDefinedContentType = NULL ); + + /** + * Creates a Supported header for given extension and adds it + * to the header array. + * @param aSIPHeaders SIP header array + * @param aExtension the extension to be supported. + */ + + static void AddSupportedHeaderL( RPointerArray& aSIPHeaders, + const TDesC8& aExtension ); + + /** + * Creates a Require header for given extension and adds it + * to the header array. + * @param aSIPHeaders SIP header array + * @param aExtension the extension to be required. + */ + + static void AddRequireHeaderL( RPointerArray& aSIPHeaders, + const TDesC8& aExtension ); + + /** + * Creates an Allow header for given method and adds it + * to the header array. + * @param aSIPHeaders SIP header array + * @param aMethod the method to be allowed. + */ + static void AddAllowHeaderL( RPointerArray& aSIPHeaders, + TInt aMethod ); + + /** + * Creates a RAck header for given client transaction and adds it + * to the header array. + * @param aSIPHeaders SIP header array + * @param aMethod the method. + */ + static void AddRAckHeaderL( RPointerArray& aSIPHeaders, + const CSIPResponseElements& aResponse ); + + /** + * Converts "Contact"-header including the whole value of the header + * except for the header's name ("Contact:") to SIP contact header + * @param aContact value for contact header + * @return SIP contect header + * ownership is transferred. + */ + static CSIPContactHeader* ToContactHeaderL( const TDesC8& aContact ); + + /** + * Add sip methods to array for allow header + * @param aArray array that thoses methods are added to + * @return void + */ + static void BasicAllowMethodsL( RArray& aArray ); + + /** + * Find If "Contact"-header including SIPs URI in user headers + * @param aMessage message response element including contact header + * @return True if contact headers has SIPs URI, false otherwise + */ + static TBool HasSipsUriInContactL( const CSIPMessageElements& aMessage ); + + /** + * Find If "Contact"-header including SIPs URI in user headers + * @param aMessage message response element including contact header + * @return True if contact headers has SIPs URI, false otherwise + */ + static TBool HasTlsInContactL( const CSIPMessageElements& aMessage ); + + +public://error situation handling + + /** + * Returns response code and reason phrase based on given + * error. + * @param aError error + * @param aSIPResponseCode reference of response code + * @param aReasonPhrase reference of reason phrase pool index + */ + static void ErrorResponse( TInt aError, + TUint& aSIPResponseCode, + TInt& aReasonPhrase ); + + /** + * Returns ETrue, if error is SDP related error + * @param aError error code + * @return ETrue, if error is SDP related error + */ + static TBool IsSDPError( TInt aError ); + + /** + * Returns ETrue, if error is SIP API related error + * @param aError error code + * @return ETrue, if error is SIP API related error + */ + static TBool IsSIPStackError( TInt aError ); + + + /** + * Discards request by sending response, which is resolved based + * on given error. If error is greater it is interpreted as + * response code, which will be sent as response. By default + * 500 is sent as response. + * @param aRequest discarded request. Ownership is transferred + * @param aError error + * @param aRetryIndication if ETrue, Retry-After header is included + * in response + * @return status of operation + */ + static TInt DiscardRequest( CSIPServerTransaction* aRequest, + TInt aError = KErrNone, + TBool aRetryIndication = EFalse ); + + /** + * Discards request by sending response, which is resolved based + * on given error. If error is greater it is interpreted as + * response code, which will be sent as response. By default + * 500 is sent as response. + * @param aRequest discarded request. + * @param aError error + * @param aRetryIndication if ETrue, Retry-After header is included + * in response + * @return status of operation + */ + static TInt DiscardRequest( CSIPServerTransaction& aRequest, + TInt aError = KErrNone, + TBool aRetryIndication = EFalse ); + +public://misc + + /** + * Gives random value between two values + * @param aMinValue min value of random value + * @param aMaxValue max value of random value + * @return random value + */ + static TUint Random( TUint aMinValue, TUint aMaxValue ); + + + /** + * Returns first integer value from header + * @param aHeader SIP header as text + * @return integer value + */ + static TUint HeaderValueL( TPtr8 aHeader ); + + +public: // mics functions + + /** + * Returns RSeq value from the ResponseElements + * @param aResponseElements SIP Respomse Elements. + * @return integer value + */ + + static TInt RSeq( const CSIPResponseElements& aResponseElements ); + + +private: + + static void DoDiscardRequestL( CSIPServerTransaction& aRequest, + TInt aError, + TBool aRetryIndication ); + + }; + + +#endif + +// End of File +