// 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);    
    }