--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/realtimenetprots/sipfw/SIP/Server/src/CSIPCSSerializer.cpp Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,393 @@
+// Copyright (c) 2004-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 : CSIPCSSerializer.cpp
+// Part of : SIPServerCore
+// Version : SIP/4.0
+//
+
+
+
+
+#include "CSIPCSSerializer.h"
+#include "sipmessage.h"
+#include "siprequest.h"
+#include "sipresponse.h"
+#include "sipheaderbase.h"
+#include "sipfromheader.h"
+#include "siptoheader.h"
+#include "siprouteheader.h"
+#include "uricontainer.h"
+#include "siphostport.h"
+#include "SIPHeaderLookup.h"
+#include "TSIPRemoteTargetAndProxy.h"
+#include "sipstrings.h"
+
+
+const TInt KBufExpandSize=100;
+// The maximum value for RHeap Alloc operations is KMaxTInt/2-1
+const TInt KMaxLength=(KMaxTInt/2)-1;
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::NewL
+// -----------------------------------------------------------------------------
+//
+CSIPCSSerializer* CSIPCSSerializer::NewL()
+ {
+ CSIPCSSerializer* self = CSIPCSSerializer::NewLC();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::NewLC
+// -----------------------------------------------------------------------------
+//
+CSIPCSSerializer* CSIPCSSerializer::NewLC ()
+ {
+ CSIPCSSerializer* self = new (ELeave) CSIPCSSerializer;
+ CleanupStack::PushL (self);
+ self->ConstructL();
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::CSIPCSSerializer
+// -----------------------------------------------------------------------------
+//
+CSIPCSSerializer::CSIPCSSerializer()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CSIPCSSerializer::ConstructL()
+ {
+ SIPHeaderLookup::OpenL();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::~CSIPCSSerializer
+// -----------------------------------------------------------------------------
+//
+CSIPCSSerializer::~CSIPCSSerializer()
+ {
+ SIPHeaderLookup::Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::InternalizeCredentialsL
+// -----------------------------------------------------------------------------
+//
+CDesC8Array* CSIPCSSerializer::InternalizeCredentialsL(const TDesC8& aDes) const
+ {
+ CDesC8ArraySeg* settings = new(ELeave)CDesC8ArraySeg(1);
+ CleanupStack::PushL(settings);
+ RDesReadStream readStream(aDes);
+ readStream.PushL();
+ TUint32 settingLength = readStream.ReadUint32L();
+ while (settingLength > 0)
+ {
+ if (settingLength > KMaxLength)
+ {
+ User::Leave(KErrOverflow);
+ }
+ HBufC8* setting = HBufC8::NewLC (settingLength);
+ TPtr8 settingPtr(setting->Des());
+ readStream.ReadL (settingPtr,settingLength);
+ settings->AppendL(settingPtr);
+ CleanupStack::PopAndDestroy(setting);
+ settingLength = readStream.ReadUint32L();
+ }
+ readStream.Pop();
+ readStream.Close();
+ CleanupStack::Pop(settings);
+ return settings;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ExternalizeLC
+// -----------------------------------------------------------------------------
+//
+CBufFlat* CSIPCSSerializer::ExternalizeLC(
+ const MDesC8Array& aSecurityMechanisms) const
+ {
+ CBufFlat* buf = CBufFlat::NewL(KBufExpandSize);
+ CleanupStack::PushL(buf);
+ RBufWriteStream writeStream(*buf,0);
+ writeStream.PushL();
+ for (TInt i=0; i < aSecurityMechanisms.MdcaCount(); i++)
+ {
+ TPtrC8 mechanism(aSecurityMechanisms.MdcaPoint(i));
+ writeStream.WriteUint32L(mechanism.Length());
+ writeStream.WriteL(mechanism);
+ }
+ writeStream.WriteUint32L(0); // no more mechanisms in the stream
+ writeStream.Pop();
+ writeStream.Close();
+ return buf;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ExternalizeValueLC
+// -----------------------------------------------------------------------------
+//
+CBufFlat* CSIPCSSerializer::ExternalizeValueLC(
+ const CSIPHeaderBase& aHeader) const
+ {
+ CBufFlat* buf = CBufFlat::NewL(KBufExpandSize);
+ CleanupStack::PushL(buf);
+ RBufWriteStream writeStream(*buf,0);
+ writeStream.PushL();
+ aHeader.ExternalizeL(writeStream,EFalse);
+ writeStream.Pop();
+ writeStream.Close();
+ return buf;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ExternalizeLC
+// -----------------------------------------------------------------------------
+//
+CBufFlat* CSIPCSSerializer::ExternalizeLC (CSIPMessage& aMessage) const
+ {
+ CBufFlat* buf = CBufFlat::NewL(KBufExpandSize);
+ CleanupStack::PushL(buf);
+ RBufWriteStream writeStream(*buf,0);
+ writeStream.PushL();
+ if (aMessage.IsRequest())
+ {
+ writeStream.WriteUint8L(1); // request flag
+ CSIPRequest& request = static_cast<CSIPRequest&>(aMessage);
+ ExternalizeL(request,writeStream);
+ }
+ else
+ {
+ writeStream.WriteUint8L(0); // response flag
+ CSIPResponse& response = static_cast<CSIPResponse&>(aMessage);
+ ExternalizeL(response,writeStream);
+ }
+ writeStream.Pop();
+ writeStream.Close();
+ return buf;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ExternalizeL
+// -----------------------------------------------------------------------------
+//
+void CSIPCSSerializer::ExternalizeL (CSIPRequest& aRequest,
+ RWriteStream& aWriteStream) const
+ {
+ ExternalizeL(aRequest.Method(),aWriteStream);
+ if (aRequest.RequestURI())
+ {
+ aWriteStream.WriteUint8L(1);
+ aRequest.RequestURI()->ExternalizeL(aWriteStream);
+ }
+ else
+ {
+ aWriteStream.WriteUint8L(0);
+ }
+ aRequest.ExternalizeHeadersL(aWriteStream);
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ExternalizeL
+// -----------------------------------------------------------------------------
+//
+void CSIPCSSerializer::ExternalizeL (CSIPResponse& aResponse,
+ RWriteStream& aWriteStream) const
+ {
+ aWriteStream.WriteUint16L(aResponse.ResponseCode());
+ ExternalizeL(aResponse.ReasonPhrase(),aWriteStream);
+ aResponse.ExternalizeHeadersL(aWriteStream);
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::InternalizeL
+// -----------------------------------------------------------------------------
+//
+void CSIPCSSerializer::InternalizeL (const TDesC8& aDes,
+ CSIPRequest& aRequest,
+ TBool aMethodExpected) const
+ {
+ RDesReadStream readStream(aDes);
+ CleanupClosePushL (readStream);
+ if (aMethodExpected)
+ {
+ InternalizeMethodL (aRequest,readStream);
+ }
+ aRequest.InternalizeHeadersL(readStream);
+ readStream.Pop();
+ readStream.Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::InternalizeL
+// -----------------------------------------------------------------------------
+//
+void CSIPCSSerializer::InternalizeL (const TDesC8& aDes,
+ CSIPRequest& aRequest,
+ TSIPRemoteTargetAndProxy& aRemoteTargetAndProxy,
+ TBool aMethodExpected,
+ TBool aProxyExpected) const
+ {
+ RDesReadStream readStream(aDes);
+ CleanupClosePushL(readStream);
+ if (aMethodExpected)
+ {
+ InternalizeMethodL(aRequest,readStream);
+ }
+ CURIContainer* remoteTarget = NULL;
+ if (readStream.ReadUint8L()) // remote target present
+ {
+ remoteTarget = CURIContainer::InternalizeL(readStream);
+ CleanupStack::PushL(remoteTarget);
+ }
+ CSIPRouteHeader* proxy = NULL;
+ if (aProxyExpected)
+ {
+ proxy = static_cast<CSIPRouteHeader*>(
+ CSIPRouteHeader::InternalizeValueL(readStream));
+ CleanupStack::PushL(proxy);
+ }
+ aRequest.InternalizeHeadersL(readStream);
+ if (proxy)
+ {
+ CleanupStack::Pop(proxy);
+ }
+ if (remoteTarget)
+ {
+ CleanupStack::Pop(remoteTarget);
+ }
+ readStream.Pop();
+ readStream.Close();
+ aRemoteTargetAndProxy.iProxy = proxy;
+ aRemoteTargetAndProxy.iRemoteTarget = remoteTarget;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::InternalizeL
+// -----------------------------------------------------------------------------
+//
+CSIPResponse* CSIPCSSerializer::InternalizeL (const TDesC8& aDes) const
+ {
+ RDesReadStream readStream(aDes);
+ readStream.PushL();
+ TUint statusCode = readStream.ReadUint16L();
+ RStringF reasonPhrase = ReadFromStreamL(readStream);
+ CleanupClosePushL(reasonPhrase);
+ CSIPResponse* response = CSIPResponse::NewL(statusCode,reasonPhrase);
+ CleanupStack::PopAndDestroy(); // reasonPhrase
+ CleanupStack::PushL(response);
+ response->InternalizeHeadersL(readStream);
+ CleanupStack::Pop(response);
+ readStream.Pop();
+ readStream.Close();
+ return response;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::InternalizeHeadersL
+// -----------------------------------------------------------------------------
+//
+RPointerArray<CSIPHeaderBase> CSIPCSSerializer::InternalizeHeadersL(
+ const TDesC8& aDes) const
+ {
+ RPointerArray<CSIPHeaderBase> headers;
+ CSIPHeaderBase::PushLC(&headers);
+ RDesReadStream readStream(aDes);
+ CleanupClosePushL (readStream);
+ TUint8 moreHeaders = readStream.ReadUint8L();
+ CSIPHeaderBase* header = NULL;
+ while (moreHeaders)
+ {
+ RStringF headerName = ReadFromStreamL(readStream);
+ CleanupClosePushL(headerName);
+ header = SIPHeaderLookup::InternalizeL(headerName,readStream);
+ CleanupStack::PopAndDestroy(); // headerName
+ if (header)
+ {
+ CleanupStack::PushL(header);
+ headers.AppendL(header);
+ CleanupStack::Pop(header);
+ }
+ moreHeaders = readStream.ReadUint8L();
+ }
+ readStream.Pop();
+ readStream.Close();
+ CleanupStack::Pop(); // headers
+ return headers;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::InternalizeProxyL
+// -----------------------------------------------------------------------------
+//
+CSIPRouteHeader* CSIPCSSerializer::InternalizeProxyL (const TDesC8& aDes) const
+ {
+ RDesReadStream readStream(aDes);
+ CleanupClosePushL(readStream);
+ CSIPRouteHeader* proxy =
+ static_cast<CSIPRouteHeader*>(
+ CSIPRouteHeader::InternalizeValueL(readStream));
+ readStream.Pop();
+ readStream.Close();
+ return proxy;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::InternalizeMethodL
+// -----------------------------------------------------------------------------
+//
+void CSIPCSSerializer::InternalizeMethodL (CSIPRequest& aRequest,
+ RReadStream& aReadStream) const
+ {
+ RStringF method = ReadFromStreamL(aReadStream);
+ CleanupClosePushL(method);
+ aRequest.SetMethodL(method);
+ CleanupStack::PopAndDestroy(); // method
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ReadFromStreamLC
+// -----------------------------------------------------------------------------
+//
+RStringF CSIPCSSerializer::ReadFromStreamL (RReadStream& aReadStream) const
+ {
+ TUint32 bufLength = aReadStream.ReadUint32L();
+ HBufC8* buf = HBufC8::NewLC (bufLength);
+ TPtr8 bufPtr(buf->Des());
+ if (bufLength > 0)
+ {
+ aReadStream.ReadL (bufPtr,bufLength);
+ }
+ RStringF str = SIPStrings::Pool().OpenFStringL(bufPtr);
+ CleanupStack::PopAndDestroy(buf);
+ return str;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIPCSSerializer::ExternalizeL
+// -----------------------------------------------------------------------------
+//
+void CSIPCSSerializer::ExternalizeL (RStringF aStr,
+ RWriteStream& aWriteStream) const
+ {
+ TPtrC8 des(aStr.DesC());
+ aWriteStream.WriteUint32L(des.Length());
+ aWriteStream.WriteL(des);
+ }