/*
* Copyright (c) 2006 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:   Implementation of DevandTruSrvCertStoreConduit
*
*/



#include "DevandTruSrvCertStoreConduit.h"
#include "DevandTruSrvCertStoreServer.h"
#include "DevTokenMarshaller.h"
#include "DevTokenUtil.h"
#include "DevTokenDataTypes.h"


// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::NewL()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreConduit* CDevandTruSrvCertStoreConduit::NewL(CDevandTruSrvCertStoreServer& aServer)
    {
    return new (ELeave) CDevandTruSrvCertStoreConduit(aServer);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::CDevandTruSrvCertStoreConduit()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreConduit::CDevandTruSrvCertStoreConduit(CDevandTruSrvCertStoreServer& aServer) :
  iServer(aServer)
    {
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::~CDevandTruSrvCertStoreConduit()
// ---------------------------------------------------------------------------
//
CDevandTruSrvCertStoreConduit::~CDevandTruSrvCertStoreConduit()
    {
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::AllocResponseBufferLC()
// Allocate a buffer for the externalised response - this is then copied into
// the client's buffer.
//
// This also checks that the client's buffer is big enough (this is assumed to
// be in message slot 3).  If the client buffer isn't big enough, the required
// length is passed back in the first word of the buffer and the method leaves
// with KErrOverflow.
// ---------------------------------------------------------------------------
// 
HBufC8* CDevandTruSrvCertStoreConduit::AllocResponseBufferLC(TInt aSize, const RMessage2& aMessage)
    {
    TInt writeBufLen = aMessage.GetDesLengthL(3);

    if (aSize > writeBufLen)
        {
        TPckg<TInt> theRequiredLength(aSize);
        aMessage.WriteL(3, theRequiredLength);
        User::Leave(KErrOverflow);
        }

    HBufC8* result = HBufC8::NewMaxLC(aSize);
    TPtr8 ptr = result->Des();
    ptr.FillZ();

    return result;
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::ServiceCertStoreRequestL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::ServiceCertStoreRequestL(const RMessage2& aMessage)
    {
    TDevTokenMessages request = (TDevTokenMessages) aMessage.Function();
    TInt result = KErrNone;

    switch (request)
        {
        case EListCerts:
            ListCertsL(aMessage);   
            break;

        case EGetCert:
            GetCertL(aMessage);     
            break;

        case EApplications:
            ApplicationsL(aMessage);  
            break;

        case EIsApplicable:
            result = IsApplicableL(aMessage); 
            break;

        case ETrusted:
            result = TrustedL(aMessage);      
            break;

        case ERetrieve:
            RetrieveL(aMessage);    
            break;

        case EAddCert:
            AddCertL(aMessage);     
            break;

        case ERemoveCert:
            RemoveCertL(aMessage);    
            break;

        case ESetApplicability:
            SetApplicabilityL(aMessage);
            break;

        case ESetTrust:
            SetTrustL(aMessage);
            break;

        default:
            // Client made an illegal request
            PanicClient(aMessage, EPanicInvalidRequest);
            return;
        }

    aMessage.Complete(result);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::ListCertsL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::ListCertsL(const RMessage2& aMessage)
    {
    // p[1] has filter as set by the client

    TInt bufLength = aMessage.GetDesLengthL(1);
    HBufC8* certFilterBuf = HBufC8::NewMaxLC(bufLength);
    TPtr8 ptr(certFilterBuf->Des());  
    aMessage.ReadL(1, ptr);
    CCertAttributeFilter* certFilter = NULL;
    DevTokenDataMarshaller::ReadL(*certFilterBuf, certFilter);
    CleanupStack::PopAndDestroy(certFilterBuf);
    CleanupStack::PushL(certFilter);

    RPointerArray<CDevTokenCertInfo> certs;
    CleanupClosePushL(certs);
    iServer.ListL(*certFilter, certs, aMessage, EFalse );

    HBufC8* clientBuffer = AllocResponseBufferLC(DevTokenDataMarshaller::Size(certs), aMessage);  
    TPtr8 theData(clientBuffer->Des());
    DevTokenDataMarshaller::Write(certs, theData);
    aMessage.WriteL(3, theData);
    CleanupStack::PopAndDestroy(3, certFilter);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::GetCertL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::GetCertL(const RMessage2& aMessage)
    {
    // p[0] is the cert handle

    const CDevTokenCertInfo& certInfo = iServer.GetCertL(aMessage.Int0());

    HBufC8* clientBuffer = AllocResponseBufferLC(DevTokenDataMarshaller::Size(certInfo), aMessage); 
    TPtr8 ptr(clientBuffer->Des());
    DevTokenDataMarshaller::Write(certInfo, ptr);
    aMessage.WriteL(3, ptr);
    CleanupStack::PopAndDestroy(clientBuffer);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::ApplicationsL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::ApplicationsL(const RMessage2& aMessage)
    {
    // p[0] is the cert handle

    const RArray<TUid>& apps = iServer.ApplicationsL(aMessage.Int0());

    HBufC8* clientBuffer = AllocResponseBufferLC(DevTokenDataMarshaller::Size(apps), aMessage); 
    TPtr8 outPtr(clientBuffer->Des());
    DevTokenDataMarshaller::Write(apps, outPtr);
    aMessage.WriteL(3, outPtr);
    CleanupStack::PopAndDestroy(clientBuffer);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::IsApplicableL()
// ---------------------------------------------------------------------------
//
TInt CDevandTruSrvCertStoreConduit::IsApplicableL(const RMessage2& aMessage)
    {
    // p[0] is the cert handle
    // p[2] is the UID
    // p[3] to return the applicability bool

        TUid uid = { aMessage.Int2() };
    TBool result = iServer.IsApplicableL(aMessage.Int0(), uid);
    return result ? 1 : 0;  // Convert TBool to TInt
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::TrustedL()
// ---------------------------------------------------------------------------
//
TInt CDevandTruSrvCertStoreConduit::TrustedL(const RMessage2& aMessage)
    {
    //  p[1] has CCertInfo in question, p[2] to return the trusted bool

    TBool result = iServer.TrustedL(aMessage.Int0()); 
    return result ? 1 : 0;  // Convert TBool to TInt
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::RetrieveL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::RetrieveL(const RMessage2& aMessage)
    {
    // p[0] is the cert handle
    // p[3] the buffer to return the retrieved certificate

    HBufC8* certData = iServer.RetrieveLC(aMessage.Int0(), aMessage, EFalse );

    TInt maxSize = aMessage.GetDesLengthL(3);
    if (maxSize < certData->Size())
        {
        //  Client has passed in a descriptor which is too short
        User::Leave(KErrOverflow);
        }

    aMessage.WriteL(3, *certData);
    CleanupStack::PopAndDestroy(certData);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::AddCertL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::AddCertL(const RMessage2& aMessage)
    {
    //  p[1] has TDevTokenAddCertDataStruct, p[3] has certificate data
    TPckgBuf<TDevTokenAddCertDataStruct> data;
    aMessage.ReadL(1, data);

    TInt maxSize = aMessage.GetDesLengthL(3);
    HBufC8* certData = HBufC8::NewMaxLC(maxSize);
    TPtr8 ptr(certData->Des());
    ptr.FillZ();
    aMessage.ReadL(3, ptr);

    iServer.AddL(data(), *certData, aMessage, EFalse );

    CleanupStack::PopAndDestroy(certData);
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::RemoveCertL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::RemoveCertL(const RMessage2& aMessage)
    {
    // p[0] is the cert handle

    iServer.RemoveL(aMessage.Int0(), aMessage, EFalse );
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::SetApplicabilityL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::SetApplicabilityL(const RMessage2& aMessage)
    {
    // p[0] is the cert handle
    // p[2] the array of UIDs

    TInt bufLen = aMessage.GetDesLengthL(2);
    HBufC8* buf = HBufC8::NewLC(bufLen);
    TPtr8 bufPtr(buf->Des());
    aMessage.ReadL(2, bufPtr);

    RArray<TUid> apps;
    CleanupClosePushL(apps);
    DevTokenDataMarshaller::ReadL(*buf, apps);

    iServer.SetApplicabilityL(aMessage.Int0(), apps, aMessage);
    CleanupStack::PopAndDestroy(2, buf);  
    }


// ---------------------------------------------------------------------------
// CDevandTruSrvCertStoreConduit::SetTrustL()
// ---------------------------------------------------------------------------
//
void CDevandTruSrvCertStoreConduit::SetTrustL(const RMessage2& aMessage)
    {
    // p[0] is the cert handle
    // p[2] the trust setting

    TBool trusted = !!aMessage.Int2();    
    iServer.SetTrustL(aMessage.Int0(), trusted, aMessage);
    }

//EOF