/*
* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:       Defines rtsecmgr common client server message types
 *
*/







#include "rtsecmgrmsg.h"

CRTSecMgrRegisterScriptMsg::CRTSecMgrRegisterScriptMsg(TPolicyID aPolicyID) :
	iPolicyID(aPolicyID)
	{
	// No implementation required
	}

EXPORT_C CRTSecMgrRegisterScriptMsg::~CRTSecMgrRegisterScriptMsg()
	{
	if ( iHashMarker)
		{
		delete iHashMarker;
		}
	}

EXPORT_C CRTSecMgrRegisterScriptMsg* CRTSecMgrRegisterScriptMsg::NewLC(
		TPolicyID aPolicyID, const TDesC& aHashValue)
	{
	CRTSecMgrRegisterScriptMsg* self = new (ELeave)CRTSecMgrRegisterScriptMsg(aPolicyID);
	CleanupStack::PushL (self);
	self->ConstructL (aHashValue);
	return self;
	}

EXPORT_C CRTSecMgrRegisterScriptMsg* CRTSecMgrRegisterScriptMsg::NewL(
		TPolicyID aPolicyID, const TDesC& aHashValue)
	{
	CRTSecMgrRegisterScriptMsg* self=CRTSecMgrRegisterScriptMsg::NewLC (
			aPolicyID, aHashValue);
	CleanupStack::Pop (self); // self;
	return self;
	}

// Creates a CRTSecMgrRegisterScriptMsg initialized with the contents of the
// descriptor parameter
EXPORT_C CRTSecMgrRegisterScriptMsg* CRTSecMgrRegisterScriptMsg::NewLC(const TDesC8& aStreamData)
	{
	// Reads descriptor data from a stream
	// and creates a new CRTSecMgrRegisterScriptMsg object
	CRTSecMgrRegisterScriptMsg* self = new (ELeave) CRTSecMgrRegisterScriptMsg();
	CleanupStack::PushL (self);
	
	// Open a read stream for the descriptor
	RDesReadStream stream(aStreamData);
	CleanupClosePushL (stream);
	self->InternalizeL (stream);
	CleanupStack::PopAndDestroy (&stream); // finished with the stream
	return (self);
	}

void CRTSecMgrRegisterScriptMsg::ConstructL(const TDesC& aHashValue)
	{
	if ( iHashMarker)
		{
		delete iHashMarker;
		iHashMarker = NULL;
		}

	iHashMarker = aHashValue.AllocL ();
	}

// Creates and returns a heap descriptor which holds contents of ’this’
EXPORT_C HBufC8* CRTSecMgrRegisterScriptMsg::PackMsgL() const
	{
	// Dynamic data buffer
	CBufFlat* buf = CBufFlat::NewL(KMaxMsgLength);
	CleanupStack::PushL(buf);
	RBufWriteStream stream(*buf); // Stream over the buffer
	CleanupClosePushL(stream);
	ExternalizeL(stream);
	CleanupStack::PopAndDestroy(&stream);
	// Create a heap descriptor from the buffer
	HBufC8* des = HBufC8::NewL(buf->Size());
	TPtr8 ptr(des->Des());
	buf->Read(0, ptr, buf->Size());
	CleanupStack::PopAndDestroy(buf); // Finished with the buffer
	return (des);
	}

// Writes ’this’ to aStream
void CRTSecMgrRegisterScriptMsg::ExternalizeL(RWriteStream& aStream) const
	{
	if ( iHashMarker)
		aStream << *iHashMarker;
	else
		aStream << KNullDesC8;
	
	aStream.WriteInt32L (iPolicyID); // Write iPolicyID to the stream
	}

// Initializes ’this’ with the contents of aStream
void CRTSecMgrRegisterScriptMsg::InternalizeL(RReadStream& aStream)
	{
	iHashMarker = HBufC::NewL (aStream, KMaxHashValueDesLen);
	iPolicyID = aStream.ReadInt32L (); // Read iPolicyID
	}

EXPORT_C CRTPermGrantMessage::~CRTPermGrantMessage()
    {
    iAllowedProviders.Close();
    iDeniedProviders.Close();
    }

EXPORT_C CRTPermGrantMessage* CRTPermGrantMessage::NewL()
    {
    CRTPermGrantMessage* self = CRTPermGrantMessage::NewLC();
    CleanupStack::Pop(self);
    return self;
    }

EXPORT_C CRTPermGrantMessage* CRTPermGrantMessage::NewLC()
    {
    CRTPermGrantMessage* self = new(ELeave) CRTPermGrantMessage();
    CleanupStack::PushL(self);
    return self;
    }

EXPORT_C CRTPermGrantMessage* CRTPermGrantMessage::NewL(const TDesC8& aBuf)
    {
    CRTPermGrantMessage* self = CRTPermGrantMessage::NewLC(aBuf);
    CleanupStack::Pop(self);
    return self;
    }

EXPORT_C CRTPermGrantMessage* CRTPermGrantMessage::NewLC(const TDesC8& aBuf)
    {
    CRTPermGrantMessage* self = new(ELeave) CRTPermGrantMessage();
    CleanupStack::PushL(self);
    self->ConstructL(aBuf);
    return self;
    }

EXPORT_C CRTPermGrantMessage* CRTPermGrantMessage::NewL(RProviderArray aAllowedProviders, RProviderArray aDeniedProviders,TExecutableID aScriptId)
    {
    CRTPermGrantMessage* self = CRTPermGrantMessage::NewLC(aAllowedProviders,aDeniedProviders,aScriptId);
    CleanupStack::Pop(self);
    return self;
    }

EXPORT_C CRTPermGrantMessage* CRTPermGrantMessage::NewLC(RProviderArray aAllowedProviders, RProviderArray aDeniedProviders,TExecutableID aScriptId)
    {
    CRTPermGrantMessage* self = new(ELeave) CRTPermGrantMessage(aAllowedProviders,aDeniedProviders,aScriptId);
    CleanupStack::PushL(self);
    return self;
    }

CRTPermGrantMessage::CRTPermGrantMessage()
    {
    
    }

CRTPermGrantMessage::CRTPermGrantMessage(RProviderArray aAllowedProviders,RProviderArray aDeniedProviders,TExecutableID aScriptId)
    {
    iAllowedProviders.Reset();
    for(TInt i(0); i < aAllowedProviders.Count(); i++)
        iAllowedProviders.Append(aAllowedProviders[i]);
    iDeniedProviders.Reset();
    for(TInt i(0); i < aDeniedProviders.Count(); i++)
        iDeniedProviders.Append(aDeniedProviders[i]);
    iScriptId = aScriptId;
    }

void CRTPermGrantMessage::ConstructL(const TDesC8& aBuf)
    {
    RDesReadStream stream(aBuf);
    CleanupClosePushL (stream);
    InternalizeL (stream);
    CleanupStack::PopAndDestroy (&stream);
    }

EXPORT_C void CRTPermGrantMessage::AllowedProviders(RProviderArray& aAllowedProviders)
    {
    aAllowedProviders.Reset();
    for(TInt i(0); i < iAllowedProviders.Count(); i++)
        aAllowedProviders.Append(iAllowedProviders[i]);
    }

EXPORT_C void CRTPermGrantMessage::DeniedProviders(RProviderArray& aDeniedProviders)
    {
    aDeniedProviders.Reset();
    for(TInt i(0); i < iDeniedProviders.Count(); i++)
        aDeniedProviders.Append(iDeniedProviders[i]);
    }

EXPORT_C TExecutableID CRTPermGrantMessage::ScriptID()
    {
    return iScriptId;
    }

EXPORT_C void CRTPermGrantMessage::setAllowedProviders(RProviderArray aAllowedProviders)
    {
    iAllowedProviders.Reset();
    for(TInt i(0); i < aAllowedProviders.Count(); i++)
            iAllowedProviders.Append(aAllowedProviders[i]);
    }

EXPORT_C void CRTPermGrantMessage::setDeniedProviders(RProviderArray aDeniedProviders)
    {
    iDeniedProviders.Reset();
    for(TInt i(0); i < aDeniedProviders.Count(); i++)
            iDeniedProviders.Append(aDeniedProviders[i]);
    }

EXPORT_C void CRTPermGrantMessage::setScriptID(TExecutableID aScriptId)
    {
    iScriptId = aScriptId;
    }

void CRTPermGrantMessage::InternalizeL(RReadStream& aSource)
    {
    iScriptId = aSource.ReadInt32L();
    TInt allowCnt = aSource.ReadInt32L();
    iAllowedProviders.Reset();
    for(TInt i(0); i < allowCnt; i++)
        {
        TInt uid = aSource.ReadInt32L();
        TUid allowPid = TUid::Uid(uid);
        iAllowedProviders.Append(allowPid);
        }
    TInt denyCnt = aSource.ReadInt32L();
    iDeniedProviders.Reset();
    for(TInt i(0); i < denyCnt; i++)
        {
        TInt uid = aSource.ReadInt32L();
        TUid denyPid = TUid::Uid(uid);
        iDeniedProviders.Append(denyPid);
        }
    }

void CRTPermGrantMessage::ExternalizeL(RWriteStream& aSink)
    {
    aSink.WriteInt32L(iScriptId);
    TInt cnt = iAllowedProviders.Count();
    aSink.WriteInt32L(cnt);
    for(TInt i(0); i < iAllowedProviders.Count(); i++)
        aSink.WriteInt32L(iAllowedProviders[i].iUid);
    cnt = iDeniedProviders.Count();
    aSink.WriteInt32L(cnt);
    for(TInt i(0); i < iDeniedProviders.Count(); i++)
        aSink.WriteInt32L(iDeniedProviders[i].iUid);
    }

EXPORT_C HBufC8* CRTPermGrantMessage::PackMessageL()
    {
    // Dynamic data buffer
    CBufFlat* buf = CBufFlat::NewL(KMaxMsgLength);
    CleanupStack::PushL(buf);
    RBufWriteStream stream(*buf); // Stream over the buffer
    CleanupClosePushL(stream);
    ExternalizeL(stream);
    CleanupStack::PopAndDestroy(&stream);
    // Create a heap descriptor from the buffer
    HBufC8* des = HBufC8::NewL(buf->Size());
    TPtr8 ptr(des->Des());
    buf->Read(0, ptr, buf->Size());
    CleanupStack::PopAndDestroy(buf); // Finished with the buffer
    return (des);
    }