SIP Codec API: Index

/** SIP parsing (decoding) errors */
// General errors
const TInt KErrSipCodecPreParser=-17750;
const TInt KErrSipCodecTokenizer=-17751;
const TInt KErrSipCodecNotAllowed=-17752;
const TInt KErrSipCodecHeaderName=-17753;
const TInt KErrSipCodecHeaderValue=-17754;
const TInt KErrSipCodecRequestLine=-17755;
const TInt KErrSipCodecResponseLine=-17756;
const TInt KErrSipCodecResponseCode=-17757;
const TInt KErrSipCodecSIPVersion=-17758;
const TInt KErrSipCodecSIPMethod=-17759;
const TInt KErrSipCodecReasonPhrase=-17760;
const TInt KErrSipCodecAnyParam=-17761;
const TInt KErrSipCodecAnyParamName=-17762;
const TInt KErrSipCodecAnyParamValue=-17763;
const TInt KErrSipCodecDuplicateParam=-17764;
const TInt KErrSipCodecHostPort=-17765;
const TInt KErrSipCodecHost=-17766;
const TInt KErrSipCodecPort=-17767;
// sip-address
const TInt KErrSipCodecSIPAddress=-17768;
const TInt KErrSipCodecDisplayName=-17769;
// URI
const TInt KErrSipCodecURI=-17770;
const TInt KErrSipCodecURIScheme=-17771;
const TInt KErrSipCodecURIParams=-17772;
const TInt KErrSipCodecURIHeaders=-17773;
// From and To
const TInt KErrSipCodecFromOrToAddress=-17774;
const TInt KErrSipCodecFromOrToParams=-17775;
// Contact
const TInt KErrSipCodecContactHeader=-17776;
const TInt KErrSipCodecContactSetToStar=-17777;
const TInt KErrSipCodecContactAddress=-17778;
const TInt KErrSipCodecContactParams=-17779;
// Other SIP headers
const TInt KErrSipCodecViaHeader=-17780;
const TInt KErrSipCodecCallIdHeader=-17781;
const TInt KErrSipCodecCSeqHeader=-17782;
const TInt KErrSipCodecContentLengthHeader=-17783;
const TInt KErrSipCodecExpiresHeader=-17784;
const TInt KErrSipCodecMaxForwardsHeader=-17785;
const TInt KErrSipCodecContentTypeHeader=-17786;
const TInt KErrSipCodecRouteHeader=-17787;
const TInt KErrSipCodecMinExpiresHeader=-17788;
const TInt KErrSipCodecTokenBaseHeader=-17789;
const TInt KErrSipCodecRequireHeader=-17790;
const TInt KErrSipCodecContentEncodingHeader=-17791;
const TInt KErrSipCodecProxyRequireHeader=-17792;
const TInt KErrSipCodecSupportedHeader=-17793;
const TInt KErrSipCodecUnsupportedHeader=-17794;
const TInt KErrSipCodecAllowHeader=-17795;
const TInt KErrSipCodecSecurityHeader=-17796;
const TInt KErrSipCodecContentDispositionHeader=-17797;
const TInt KErrSipCodecSubscriptionStateHeader=-17798;
const TInt KErrSipCodecAcceptHeader=-17799;
const TInt KErrSipCodecAcceptEncodingHeader=-17800;
const TInt KErrSipCodecAcceptLanguageHeader= -17801;
const TInt KErrSipCodecAcceptParams=-17802;
const TInt KErrSipCodecEventHeader=-17803;
const TInt KErrSipCodecAllowEventsHeader=-17804;
const TInt KErrSipCodecAuthenticationInfoHeader=-17805;
const TInt KErrSipCodecReferToHeader=-17806;
const TInt KErrSipCodecAuthenticationHeader=-17807;
const TInt KErrSipCodecAuthScheme=-17808;
const TInt KErrSipCodecAuthorizationHeader=-17809;
const TInt KErrSipCodecURIContainer=-17810;
const TInt KErrSipCodecRAckHeader=-17811;
const TInt KErrSipCodecRSeqHeader=-17812;
const TInt KErrSipCodecReplyToHeader=-17813;
const TInt KErrSipCodecTimestampHeader=-17814;
const TInt KErrSipCodecRetryAfterHeader=-17815;
const TInt KErrSipCodecRetryAfterParams=-17816;
const TInt KErrSipCodecAcceptContactHeader=-17817;
const TInt KErrSipCodecPAssociatedURIHeader=-17818;
const TInt KErrSipCodecPAccessNetworkInfoHeader=-17819;

/** Predefined values in SIP codec String table */
class SipStrConsts
{
public:
enum TStrings
{
// General constants
/**  */
EEmpty,
/** SIP */
ESIP,
/** sip */
ESip,
/** sips */
ESips,
/** 2.0 */
EDefaultVersionNumber,
/** SIP/2.0 */
EDefaultProtocolVersion,
/** UDP */
EUDP,
/** udp */
EUdp,
/** TCP */
ETCP,
/** tcp */
ETcp,
/** localhost */
ELocalHost,
// SIP methods
/** REGISTER */
ERegister,
/** INVITE */
EInvite,
/** CANCEL */
ECancel,
/** ACK */
EAck,
/** BYE */
EBye,
/** PRACK */
EPrack,
/** UPDATE */
EUpdate,
/** SUBSCRIBE */
ESubscribe,
/** NOTIFY */
ENotify,
/** REFER */
ERefer,
/** MESSAGE */
EMessage,
/** OPTIONS */
EOptions,
/** INFO */
EInfo,
// SIP reason phrases:
/** OK */
EPhraseOk,
/** Trying */
EPhraseTrying,
/** Ringing */
EPhraseRinging,
/** Session Progress */
EPhraseSessionProgress,
/** Bad Request */
EPhraseBadRequest,
/** Unauthorized */
EPhraseUnauthorized,
/** Forbidden */
EPhraseForbidden,
/** Not Found */
EPhraseNotFound,
/** Method Not Allowed */
EPhraseMethodNotAllowed,
/** Proxy Authentication Required */
EPhraseProxyAuthenticationRequired,
/** Request Timeout */
EPhraseRequestTimeout,
/** Unsupported Media Type */
EPhraseUnsupportedMediaType,
/** Unsupported URI Scheme */
EPhraseUnsupportedURIScheme,
/** Bad Extension */
EPhraseBadExtension,
/** Extension Required */
EPhraseExtensionRequired,
/** Interval Too Brief */
EPhraseIntervalTooBrief,
/** Temporarily Not Available */
EPhraseTemporarilyNotAvailable,
/** Call/Transaction Does Not Exist */
EPhraseCallTransactionDoesNotExist,
/** Loop Detected */
EPhraseLoopDetected,
/** Too Many Hops */
EPhraseTooManyHops,
/** Busy Here */
EPhraseBusyHere,
/** Request Terminated */
EPhraseRequestTerminated,
/** Not Acceptable Here */
EPhraseNotAcceptableHere,
/** Bad Event */
EPhraseBadEvent,
/** Security Agreement Required */
EPhraseSecurityAgreementRequired,
/** Server Internal Error */
EPhraseServerInternalError,
/** Service Unavailable */
EPhraseServiceUnavailable,
/** Version Not Supported */
EPhraseVersionNotSupported,
/** Decline */
EPhraseDecline,
// SIP parameters:
/** ttl */
ETtl,
/** maddr */
EMaddr,
/** received */
EReceived,
/** branch */
EBranch,
/** q */
EQ,
/** expires */
EExpires,
/** tag */
ETag,
/** transport */
ETransport,
/** user */
EUser,
/** method */
EMethod,
/** lr */
ELr,
/** d-alg */
EDigestAlgorithm,
/** d-qop */
EDigestQop,
/** d-ver */
EDigestVerify,
/** handling */
EHandling,
/** reason */
EReason,
/** retry-after */
ERetryAfter,
/** id */
EId,
/** nextnonce */
ENextNonce,
/** qop */
EQop,
/** rspauth */
EResponseAuth,
/** cnonce */
ECNonce,
/** nc */
ENonceCount,
/** realm */
ERealm,
/** domain */
EDomain,
/** nonce */
ENonce,
/** opaque */
EOpaque,
/** stale */
EStale,
/** algorithm */
EAlgorithm,
/** username */
EUserName,
/** uri */
EUri,
/** response */
EResponse,
/** comp */
EComp,
/** sigcomp */
ESigComp,
/** sec-agree */
ESecAgreeTag,
/** duration */
EDuration,
/** audio */
EAudio,
/** automata */
EAutomata,
/** class */
EClass,
/** duplex */
EDuplex,
/** data */
EData,
/** control */
EControl,
/** mobility */
EMobility,
/** description */
EDescription,
/** events */
EEvents,
/** priority */
EPriority,
/** methods */
EMethods,
/** schemes */
ESchemes,
/** application */
EApplication,
/** video */
EVideo,
/** language */
ELanguage,
/** type */
EType,
/** isfocus */
EIsfocus,
/** actor */
EActor,
/** text */
EText,
/** extensions */
EExtensions,
/** require */
ERequire,
/** explicit */
EExplicit,
/** cgi-3gpp */
ECgi3gpp,
/** utran-cell-id-3gpp */
EUtranCellId3gpp,
/** auts */
EAuts,
// SIP header names:
/** To */
EToHeader,
/** t */
EToHeaderCompact,
/** From */
EFromHeader,
/** f */
EFromHeaderCompact,
/** CSeq */
ECSeqHeader,
/** Call-ID */
ECallIDHeader,
/** i */
ECallIDHeaderCompact,
/** Content-Length */
EContentLengthHeader,
/** l */
EContentLengthHeaderCompact,
/** Via */
EViaHeader,
/** v */
EViaHeaderCompact,
/** Route */
ERouteHeader,
/** Record-Route */
ERecordRouteHeader,
/** Service-Route */
EServiceRouteHeader,
/** Contact */
EContactHeader,
/** m */
EContactHeaderCompact,
/** Content-Type */
EContentTypeHeader,
/** c */
EContentTypeHeaderCompact,
/** Expires */
EExpiresHeader,
/** Min-Expires */
EMinExpiresHeader,
/** Max-Forwards */
EMaxForwardsHeader,
/** Allow */
EAllowHeader,
/** Proxy-Require */
EProxyRequireHeader,
/** Require */
ERequireHeader,
/** Supported */
ESupportedHeader,
/** k */
ESupportedHeaderCompact,
/** Unsupported */
EUnsupportedHeader,
/** Content-Encoding */
EContentEncodingHeader,
/** e */
EContentEncodingHeaderCompact,
/** Refer-To  */
EReferToHeader,
/** r */
EReferToHeaderCompact,
/** Security-Client */
ESecurityClientHeader,
/** Security-Server */
ESecurityServerHeader,
/** Security-Verify */
ESecurityVerifyHeader,
/** Authentication-Info */
EAuthenticationInfoHeader,
/** Accept */
EAcceptHeader,
/** Accept-Encoding */
EAcceptEncodingHeader,
/** Accept-Language */
EAcceptLanguageHeader,
/** Content-Disposition */
EContentDispositionHeader,
/** Subscription-State */
ESubscriptionStateHeader,
/** Allow-Events */
EAllowEventsHeader,
/** u */
EAllowEventsHeaderCompact,
/** Event */
EEventHeader,
/** o */
EEventHeaderCompact,
/** Authorization */
EAuthorizationHeader,
/** Proxy-Authenticate */
EProxyAuthenticateHeader,
/** Proxy-Authorization */
EProxyAuthorizationHeader,
/** WWW-Authenticate */
EWWWAuthenticateHeader,
/** Reply-To */
EReplyToHeader,
/** RAck */
ERAckHeader,
/** RSeq */
ERSeqHeader,
/** Timestamp */
ETimestampHeader,
/** Retry-After */
ERetryAfterHeader,
/** Accept-Contact */
EAcceptContactHeader,
/** a */
EAcceptContactHeaderCompact,
/** P-Associated-URI */
EPAssociatedURIHeader,
/** P-Access-Network-Info */
EPAccessNetworkInfoHeader,
// SIP reason phrases:
/** Not Implemented */
EPhraseNotImplemented
};
static const TStringTable Table;
};

IMPORT_C static RPointerArray<CSIPAcceptContactHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPAcceptContactHeader* NewL()
IMPORT_C static CSIPAcceptContactHeader* NewLC()
IMPORT_C virtual ~CSIPAcceptContactHeader()
IMPORT_C TBool operator==(const CSIPAcceptContactHeader& aHeader) const
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPAcceptEncodingHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPAcceptEncodingHeader* NewL(const TDesC8& aCodings)
IMPORT_C static CSIPAcceptEncodingHeader* NewLC(const TDesC8& aCodings)
IMPORT_C ~CSIPAcceptEncodingHeader()
IMPORT_C const TDesC8& Codings() const
IMPORT_C void SetCodingsL(const TDesC8& aCodings)
IMPORT_C TReal QParameter() const
IMPORT_C void SetQParameterL(TReal aQValue)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPAcceptHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPAcceptHeader* NewL(const TDesC8& aMediaType,
const TDesC8& aMediaSubtype)
IMPORT_C static CSIPAcceptHeader* NewLC(const TDesC8& aMediaType,
const TDesC8& aMediaSubtype)
IMPORT_C ~CSIPAcceptHeader()
IMPORT_C TBool IsEmpty() const
IMPORT_C const TDesC8& MediaType() const
IMPORT_C void SetMediaTypeL(const TDesC8& aMediaType)
IMPORT_C const TDesC8& MediaSubtype() const
IMPORT_C void SetMediaSubtypeL(const TDesC8& aMediaSubtype)
IMPORT_C TReal QParameter() const
IMPORT_C void SetQParameterL(TReal aQValue)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPAcceptLanguageHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPAcceptLanguageHeader* NewL(const TDesC8& aLanguageRange)
IMPORT_C static CSIPAcceptLanguageHeader* NewLC(const TDesC8& aLanguageRange)
IMPORT_C ~CSIPAcceptLanguageHeader()
IMPORT_C const TDesC8& LanguageRange() const
IMPORT_C void SetLanguageRangeL(const TDesC8& aLanguageRange)
IMPORT_C TReal QParameter() const
IMPORT_C void SetQParameterL(TReal aQValue)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPAddress* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPAddress* NewL(CUri8* aUri8)
IMPORT_C static CSIPAddress* NewLC(CUri8* aUri8)
IMPORT_C static CSIPAddress* NewL(const TDesC8& aDisplayName,
CUri8* aUri8)
IMPORT_C static CSIPAddress* NewLC(const TDesC8& aDisplayName,
CUri8* aUri8)
IMPORT_C static CSIPAddress* NewL(const CSIPAddress& aSIPAddress)
IMPORT_C static CSIPAddress* NewLC(const CSIPAddress& aSIPAddress)
IMPORT_C ~CSIPAddress()
IMPORT_C TBool operator==(const CSIPAddress& aSIPAddress) const
IMPORT_C const TDesC8& DisplayName() const
IMPORT_C void SetDisplayNameL(const TDesC8& aDisplayName)
IMPORT_C const CUri8& Uri8() const
IMPORT_C void SetUri8L(CUri8* aUri8)
IMPORT_C HBufC8* ToTextLC(TBool aUseAngleBrackets=EFalse) const
IMPORT_C static CSIPAddress* InternalizeL(RReadStream& aReadStream)
IMPORT_C void ExternalizeL(RWriteStream& aWriteStream)
IMPORT_C CURIContainer& URI()
IMPORT_C const CURIContainer& URI() const

IMPORT_C virtual ~CSIPAddressHeaderBase()
IMPORT_C void SetSIPAddressL(CSIPAddress* aSIPAddress)
IMPORT_C const CSIPAddress& SIPAddress() const
IMPORT_C CSIPAddress& SIPAddress()

IMPORT_C static RPointerArray<CSIPAllowEventsHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPAllowEventsHeader* NewL(const TDesC8& aEventPackage)
IMPORT_C static CSIPAllowEventsHeader* NewLC(const TDesC8& aEventPackage)
IMPORT_C ~CSIPAllowEventsHeader()
IMPORT_C const TDesC8& EventPackage() const
IMPORT_C void SetEventPackageL(const TDesC8& aEventPackage)
IMPORT_C void SetEventTemplatesL(const MDesC8Array& aEventTemplates)
IMPORT_C const MDesC8Array& EventTemplates() const
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const
IMPORT_C HBufC8* ToTextValueL() const

IMPORT_C static RPointerArray<CSIPAllowHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPAllowHeader* NewL(RStringF aValue)
IMPORT_C static CSIPAllowHeader* NewLC(RStringF aValue)
IMPORT_C ~CSIPAllowHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPCallIDHeader* DecodeL(const TDesC8& aValue);
IMPORT_C ~CSIPCallIDHeader ();
IMPORT_C TBool operator==(const CSIPCallIDHeader& aCallIDHeader);
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream);
IMPORT_C CSIPHeaderBase* CloneL() const;
IMPORT_C RStringF Name() const;
IMPORT_C HBufC8* ToTextValueL() const;

IMPORT_C static RPointerArray<CSIPContactHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPContactHeader* NewL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPContactHeader* NewLC(CSIPAddress* aSIPAddress)
IMPORT_C ~CSIPContactHeader()
IMPORT_C TBool operator==(const CSIPContactHeader& aHeader) const
IMPORT_C TBool Star() const
IMPORT_C TInt ExpiresParameter() const
IMPORT_C void SetExpiresParameterL(TInt aExpiresParam)
IMPORT_C TReal QParameter() const
IMPORT_C void SetQParameterL(TReal aQValue)
IMPORT_C const CSIPAddress* SIPAddress() const
IMPORT_C CSIPAddress* SIPAddress()
IMPORT_C void SetSIPAddressL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPContentDispositionHeader* DecodeL (const TDesC8& aValue)
IMPORT_C static CSIPContentDispositionHeader* NewL(const TDesC8& aDispType)
IMPORT_C static CSIPContentDispositionHeader* NewLC(const TDesC8& aDispType)
IMPORT_C ~CSIPContentDispositionHeader()
IMPORT_C const TDesC8& DispType() const
IMPORT_C void SetDispTypeL(const TDesC8& aDispType)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPContentEncodingHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPContentEncodingHeader* NewL(RStringF aValue)
IMPORT_C static CSIPContentEncodingHeader* NewLC(RStringF aValue)
IMPORT_C ~CSIPContentEncodingHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPContentTypeHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPContentTypeHeader* NewL(const TDesC8& aMediaType, const TDesC8& aMediaSubtype)
IMPORT_C static CSIPContentTypeHeader* NewLC(const TDesC8& aMediaType, const TDesC8& aMediaSubtype)
IMPORT_C ~CSIPContentTypeHeader()
IMPORT_C const TDesC8& MediaType() const
IMPORT_C void SetMediaTypeL(const TDesC8& aMediaType)
IMPORT_C const TDesC8& MediaSubtype() const
IMPORT_C void SetMediaSubtypeL(const TDesC8& aMediaSubtype)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPCSeqHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPCSeqHeader* NewL(TUint aSeq, RStringF aMethod)
IMPORT_C static CSIPCSeqHeader* NewLC(TUint aSeq, RStringF aMethod)
IMPORT_C ~CSIPCSeqHeader()
IMPORT_C TUint Seq() const
IMPORT_C void SetSeq(TUint aSeq)
IMPORT_C RStringF Method() const
IMPORT_C void SetMethodL(RStringF aMethod)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const
IMPORT_C HBufC8* ToTextValueL() const

IMPORT_C static CSIPEventHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPEventHeader* NewL(const TDesC8& aEventPackage)
IMPORT_C static CSIPEventHeader* NewLC(const TDesC8& aEventPackage)
IMPORT_C ~CSIPEventHeader()
IMPORT_C TBool operator==(const CSIPEventHeader& aHeader) const
IMPORT_C const TDesC8& EventPackage() const
IMPORT_C void SetEventPackageL(const TDesC8& aEventPackage)
IMPORT_C void SetEventTemplatesL(const MDesC8Array& aEventTemplates)
IMPORT_C const MDesC8Array& EventTemplates() const
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPExpiresHeader* DecodeL(const TDesC8& aValue)
IMPORT_C CSIPExpiresHeader(TUint aValue)
IMPORT_C ~CSIPExpiresHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPExtensionHeader* NewL(const TDesC8& aName, const TDesC8& aValue)
IMPORT_C static CSIPExtensionHeader* NewLC(const TDesC8& aName, const TDesC8& aValue)
IMPORT_C ~CSIPExtensionHeader()
IMPORT_C void SetValueL(const TDesC8& aValue)
IMPORT_C const TDesC8& Value() const
IMPORT_C static CSIPExtensionHeader* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const
IMPORT_C HBufC8* ToTextValueL() const
IMPORT_C TBool ExternalizeSupported() const

IMPORT_C static CSIPFromHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPFromHeader* NewL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPFromHeader* NewLC(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPFromHeader* NewL(const CSIPFromToHeaderBase& aHeader)
IMPORT_C static CSIPFromHeader* NewLC(const CSIPFromToHeaderBase& aHeader)
IMPORT_C ~CSIPFromHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C virtual ~CSIPFromToHeaderBase()
IMPORT_C TBool operator==(const CSIPFromToHeaderBase& aHeader) const
IMPORT_C void SetSIPAddressL(CSIPAddress* aSIPAddress)
IMPORT_C const CSIPAddress& SIPAddress() const
IMPORT_C CSIPAddress& SIPAddress()

IMPORT_C virtual ~CSIPHeaderBase()
IMPORT_C virtual CSIPHeaderBase* CloneL() const = 0
IMPORT_C virtual RStringF Name() const = 0
IMPORT_C HBufC8* ToTextL() const
IMPORT_C HBufC8* ToTextLC() const
IMPORT_C virtual HBufC8* ToTextValueL() const = 0
IMPORT_C HBufC8* ToTextValueLC() const
IMPORT_C void ExternalizeL(RWriteStream& aWriteStream,TBool aAddName=ETrue) const
IMPORT_C virtual TBool ExternalizeSupported() const
IMPORT_C static void PushLC(RPointerArray<CSIPHeaderBase>* aArray)

IMPORT_C virtual ~CSIPParameterHeaderBase()
IMPORT_C TBool HasParam(RStringF aName) const
IMPORT_C RStringF ParamValue(RStringF aName) const
IMPORT_C void SetParamL(RStringF aName, RStringF aValue)
IMPORT_C void SetParamL(RStringF aName)
IMPORT_C void DeleteParam(RStringF aName)
IMPORT_C HBufC8* ToTextValueL() const

IMPORT_C static RPointerArray<CSIPPAssociatedURIHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPPAssociatedURIHeader* NewL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPPAssociatedURIHeader* NewLC(CSIPAddress* aSIPAddress)
IMPORT_C virtual ~CSIPPAssociatedURIHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPProxyRequireHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPProxyRequireHeader* NewL(RStringF aValue)
IMPORT_C static CSIPProxyRequireHeader* NewLC(RStringF aValue)
IMPORT_C ~CSIPProxyRequireHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPRAckHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPRAckHeader* NewL(TUint aSeq, TUint aCSeqNum, RStringF aMethod)
IMPORT_C static CSIPRAckHeader* NewLC(TUint aSeq, TUint aCSeqNum, RStringF aMethod)
IMPORT_C ~CSIPRAckHeader()
IMPORT_C TUint Seq() const
IMPORT_C void SetSeq(TUint aSeq)
IMPORT_C TUint CSeqNum() const
IMPORT_C void SetCSeqNum(TUint aCSeqNum)
IMPORT_C RStringF Method() const
IMPORT_C void SetMethodL(RStringF aMethod)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const
IMPORT_C HBufC8* ToTextValueL() const

IMPORT_C static CSIPReferToHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPReferToHeader* NewL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPReferToHeader* NewLC(CSIPAddress* aSIPAddress)
IMPORT_C virtual ~CSIPReferToHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPReplyToHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPReplyToHeader* NewL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPReplyToHeader* NewLC(CSIPAddress* aSIPAddress)
IMPORT_C virtual ~CSIPReplyToHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPRequireHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPRequireHeader* NewL(RStringF aValue)
IMPORT_C static CSIPRequireHeader* NewLC(RStringF aValue)
IMPORT_C ~CSIPRequireHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPRetryAfterHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPRetryAfterHeader* NewL(TUint aRetryAfter)
IMPORT_C static CSIPRetryAfterHeader* NewLC(TUint aRetryAfter)
IMPORT_C virtual ~CSIPRetryAfterHeader()
IMPORT_C void SetRetryAfter(TUint aValue)
IMPORT_C TUint RetryAfter() const
IMPORT_C const TDesC8& Comment() const
IMPORT_C TInt DurationParam() const
IMPORT_C void SetDurationParamL(TInt aDurationParam)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPRouteHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPRouteHeader* NewL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPRouteHeader* NewLC(CSIPAddress* aSIPAddress)
IMPORT_C ~CSIPRouteHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C virtual ~CSIPRouteHeaderBase()
IMPORT_C void SetSIPAddressL(CSIPAddress* aSIPAddress)
IMPORT_C const CSIPAddress& SIPAddress() const
IMPORT_C CSIPAddress& SIPAddress()

IMPORT_C static CSIPRSeqHeader* DecodeL(const TDesC8& aValue)
IMPORT_C CSIPRSeqHeader(TUint aValue)
IMPORT_C ~CSIPRSeqHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPSecurityClientHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPSecurityClientHeader* NewL(const TDesC8& aMechanism)
IMPORT_C static CSIPSecurityClientHeader* NewLC(const TDesC8& aMechanism)
IMPORT_C ~CSIPSecurityClientHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C virtual ~CSIPSecurityHeaderBase()
IMPORT_C TReal PreferenceParam() const
IMPORT_C void SetPreferenceParamL(TReal aPreferenceValue)
IMPORT_C const TDesC8& MechanismName() const
IMPORT_C void SetMechanismNameL(const TDesC8& aMechanismName)

IMPORT_C static void OpenL();
IMPORT_C static void Close();
IMPORT_C static RStringF StringF(TInt aIndex);
IMPORT_C static RStringPool Pool();
IMPORT_C static const TStringTable& Table();

IMPORT_C static CSIPSubscriptionStateHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPSubscriptionStateHeader* NewL(const TDesC8& aSubStateValue)
IMPORT_C static CSIPSubscriptionStateHeader* NewLC(const TDesC8& aSubStateValue)
IMPORT_C ~CSIPSubscriptionStateHeader()
IMPORT_C const TDesC8& SubStateValue() const
IMPORT_C void SetSubStateValueL(const TDesC8& aSubStateValue)
IMPORT_C TInt ExpiresParameter() const
IMPORT_C void SetExpiresParameterL(TInt aExpiresParam)
IMPORT_C TInt RetryAfterParameter() const
IMPORT_C void SetRetryAfterParameterL(TInt aRetryAfterParam)
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static RPointerArray<CSIPSupportedHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPSupportedHeader* NewL(RStringF aValue)
IMPORT_C static CSIPSupportedHeader* NewLC(RStringF aValue)
IMPORT_C ~CSIPSupportedHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C static CSIPTimestampHeader* DecodeL(const TDesC8& aValue)
IMPORT_C CSIPTimestampHeader(TReal aTimestamp)
IMPORT_C ~CSIPTimestampHeader ()
IMPORT_C void SetTimestamp(TReal aTimestamp)
IMPORT_C TReal Timestamp() const
IMPORT_C TBool HasDelay() const
IMPORT_C void SetDelay(TReal aDelay)
IMPORT_C TReal Delay() const
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const
IMPORT_C HBufC8* ToTextValueL() const

IMPORT_C static CSIPToHeader* DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPToHeader* NewL(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPToHeader* NewLC(CSIPAddress* aSIPAddress)
IMPORT_C static CSIPToHeader* NewL(const CSIPFromToHeaderBase& aHeader)
IMPORT_C static CSIPToHeader* NewLC(const CSIPFromToHeaderBase& aHeader)
IMPORT_C ~CSIPToHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const

IMPORT_C virtual ~CSIPTokenHeaderBase()
IMPORT_C void SetValueL(RStringF aValue)
IMPORT_C RStringF Value() const
IMPORT_C HBufC8* ToTextValueL() const

IMPORT_C ~CSIPUnsignedIntHeaderBase()
IMPORT_C void SetValue (TUint aValue)
IMPORT_C HBufC8* ToTextValueL () const
IMPORT_C TUint Value () const

IMPORT_C static RPointerArray<CSIPUnsupportedHeader> DecodeL(const TDesC8& aValue)
IMPORT_C static CSIPUnsupportedHeader* NewL (RStringF aValue)
IMPORT_C static CSIPUnsupportedHeader* NewLC(RStringF aValue)
IMPORT_C ~CSIPUnsupportedHeader()
IMPORT_C static CSIPHeaderBase* InternalizeValueL(RReadStream& aReadStream)
IMPORT_C CSIPHeaderBase* CloneL() const
IMPORT_C RStringF Name() const