/*

* 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 DevandTruSrvCertStore

*

*/

#include "DevandTruSrvCertStore.h"

#include "DevTokenType.h"

#include "DevToken.h"

#include "DevTokenUtils.h"

#include "DevTokenImplementationUID.hrh"

// This is sized for roughly five cert infos, to ensure that the overflow

// mechanism gets tested.

const TInt KDefaultBufferSize = 256;

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

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::NewWritableInterfaceL()

// -----------------------------------------------------------------------------

//

MCTTokenInterface* CDevandTruSrvCertStore::NewWritableInterfaceL(MCTToken& aToken, 

                         RDevTokenClientSession& aClient)

    {

    // Destroyed by MCTTokenInterface::DoRelease() (no refcounting)

    CDevandTruSrvCertStore* me = new (ELeave) CDevandTruSrvCertStore(KInterfaceWritableCertStore, 

                                                                     aToken, 

                                                                     aClient);

    CleanupStack::PushL(me);

    me->ConstructL();

    CleanupStack::Pop(me);

    return (me);

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::NewReadableInterfaceL()

// -----------------------------------------------------------------------------

//

MCTTokenInterface* CDevandTruSrvCertStore::NewReadableInterfaceL(MCTToken& aToken, 

                         RDevTokenClientSession& aClient)

    {

    // Destroyed by MCTTokenInterface::DoRelease() (no refcounting)

    CDevandTruSrvCertStore* me = new (ELeave) CDevandTruSrvCertStore(KInterfaceCertStore,

                                                                     aToken, 

                                                                     aClient);

    CleanupStack::PushL(me);

    me->ConstructL();

    CleanupStack::Pop(me);

    return (me);

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CDevandTruSrvCertStore()

// -----------------------------------------------------------------------------

//

CDevandTruSrvCertStore::CDevandTruSrvCertStore(TInt aUID,

                                               MCTToken& aToken, 

                                               RDevTokenClientSession& aClient) :

    CDTClient(aUID, aToken, aClient)  

    {

    iFilter = NULL;

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::~CDevandTruSrvCertStore()

// -----------------------------------------------------------------------------

//

CDevandTruSrvCertStore::~CDevandTruSrvCertStore()

    {

    if( iFilter )

        {

    	delete iFilter;

        }

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::ConstructL()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::ConstructL()

    {

    CActiveScheduler::Add(this);

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::DoRelease()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::DoRelease()

    {

    MCTTokenInterface::DoRelease();

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::Token()

// -----------------------------------------------------------------------------

//

MCTToken& CDevandTruSrvCertStore::Token()

    {

    return iToken;

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::RunL()

// -----------------------------------------------------------------------------

//  

void CDevandTruSrvCertStore::RunL()

    {

    // Never active, so should never get called

    DevTokenPanic(ENoRequestOutstanding);

    }

//MCTCertStore 

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::List()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::List(RMPointerArray<CCTCertInfo>& aCerts, 

                                  const CCertAttributeFilter& aFilter,

                                  TRequestStatus& aStatus)

    {

    CDevToken* token = static_cast<CDevToken*>( &iToken ); 

    CDevTokenType* tokenType = static_cast<CDevTokenType*>( &(token->TokenType()) );

    if ( tokenType->iUid.iUid == DEVCERTSTORE_IMPLEMENTATION_UID )

        {

        if (aFilter.iOwnerType != EUserCertificate)

            {

            if( aFilter.iOwnerTypeIsSet )

                {

                TRequestStatus* status = &aStatus;

                User::RequestComplete( status, KErrNone );

                return;	

                }

            //If the owner type is not set, we create a filter and 

            // set the type to EUserCertificate    

            else

                {

                //alway use new filter.

                if( iFilter )

                    {

                	delete iFilter;

                	iFilter = NULL;

                    }

                TRAPD( err, iFilter = CCertAttributeFilter::NewL() );	

                if ( err != KErrNone )    

                    {

                    TRequestStatus* status = &aStatus;

                    User::RequestComplete( status, err ); 

                    return;	

                	  }

                CopyFilter( iFilter, aFilter );

                //Set owner type to user certificate

                iFilter->SetOwnerType( EUserCertificate );

                TRAPD(r, DoListL(aCerts, *iFilter));

                FreeRequestBuffer();

                TRequestStatus* status = &aStatus;

                User::RequestComplete(status, r); 

                return;

                }

            }

        }

    else if ( tokenType->iUid.iUid == TRUSRVCERTSTORE_IMPLEMENTATION_UID )

        {

        if (aFilter.iOwnerType != EPeerCertificate)

            {

            if( aFilter.iOwnerTypeIsSet )

                {

                TRequestStatus* status = &aStatus;

                User::RequestComplete( status, KErrNone );

                return;	

                }

            //If the owner type is not set, we create a filter and 

            // set the type to EPeerCertificate      

            else

                {

                if( iFilter )

                    {

                	delete iFilter;

                	iFilter = NULL;

                    }

                TRAPD( er, iFilter = CCertAttributeFilter::NewL() );	

                if ( er != KErrNone )    

                    {

                    TRequestStatus* status = &aStatus;

                    User::RequestComplete( status, er ); 

                    return;	

                	  }    

                CopyFilter( iFilter, aFilter );

                iFilter->SetOwnerType( EPeerCertificate );

                TRAPD(r, DoListL(aCerts, *iFilter));

                FreeRequestBuffer();

                TRequestStatus* status = &aStatus;

                User::RequestComplete(status, r); 

                return;	

                }

            }

        }

    else

        {

        TRequestStatus* status = &aStatus;

        User::RequestComplete( status, KErrNone );  

        return; 

        }    

    TRAPD(r, DoListL(aCerts, aFilter));

    FreeRequestBuffer();

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, r); 

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CopyFilterL()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::CopyFilter( CCertAttributeFilter* aDesFilter, const CCertAttributeFilter& aSrcFilter )

    {

    if ( aSrcFilter.iLabelIsSet )

        {

    	aDesFilter->SetLabel( aSrcFilter.iLabel );

        }

	if ( aSrcFilter.iUidIsSet )

	    {

		aDesFilter->SetUid( aSrcFilter.iUid );

	    }

	if ( aSrcFilter.iFormatIsSet )

	    {

		aDesFilter->SetFormat( aSrcFilter.iFormat );

	    }

	if ( aSrcFilter.iOwnerTypeIsSet )

	    {

		aDesFilter->SetOwnerType( aSrcFilter.iOwnerType );

	    }

	if ( aSrcFilter.iSubjectKeyIdIsSet )

	   {

	   aDesFilter->SetSubjectKeyId( aSrcFilter.iSubjectKeyId );	

	   }

	if ( aSrcFilter.iIssuerKeyIdIsSet )

	    {

		aDesFilter->SetIssuerKeyId( aSrcFilter.iIssuerKeyId );

	    }

    aDesFilter->SetKeyUsage( aSrcFilter.iKeyUsage );    

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::DoListL()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::DoListL(RMPointerArray<CCTCertInfo>& aCerts, 

                 const CCertAttributeFilter& aFilter)

    {

    HBufC8* filterBuf = HBufC8::NewLC(DevTokenDataMarshaller::Size(aFilter));

    TPtr8 ptr(filterBuf->Des());

    DevTokenDataMarshaller::WriteL(aFilter, ptr);

    TIpcArgs args(0, filterBuf, 0, &iRequestPtr);

    SendSyncRequestAndHandleOverflowL(EListCerts, KDefaultBufferSize, args);

    CleanupStack::PopAndDestroy(filterBuf);

    DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aCerts);

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CancelList()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::CancelList()

    {

    // synchronous, nothing to do

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::GetCert()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::GetCert(CCTCertInfo*& aCertInfo, 

                                     const TCTTokenObjectHandle& aHandle,

                                     TRequestStatus& aStatus)

    {

    TRAPD(r, DoGetCertL(aCertInfo, aHandle));

    FreeRequestBuffer();

    TRequestStatus* stat = &aStatus;

    User::RequestComplete(stat, r); 

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::DoGetCertL()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::DoGetCertL(CCTCertInfo*& aCertInfo, 

                                        const TCTTokenObjectHandle& aHandle)

    {

    User::LeaveIfError(AllocRequestBuffer(sizeof(CCTCertInfo))); // assumes serialized size <= sizeof class

    TIpcArgs args(aHandle.iObjectId, 0, 0, &iRequestPtr);

    User::LeaveIfError(iClientSession.SendRequest(EGetCert, args));

    DevTokenDataMarshaller::ReadL(iRequestPtr, iToken, aCertInfo);

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CancelGetCert()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::CancelGetCert()

    {

    // synchronous, nothing to do

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::Applications()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::Applications(const CCTCertInfo& aCertInfo, 

                                          RArray<TUid>& aApplications,

                                          TRequestStatus& aStatus)

    {

    TRAPD(r, DoApplicationsL(aCertInfo, aApplications));

    FreeRequestBuffer();

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, r); 

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::DoApplicationsL()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::DoApplicationsL(const CCTCertInfo& aCertInfo, 

                                             RArray<TUid>& aApplications)

    {

    TIpcArgs args(aCertInfo.Handle().iObjectId, 0, 0, &iRequestPtr);

    SendSyncRequestAndHandleOverflowL(EApplications, KDefaultBufferSize, args);

    DevTokenDataMarshaller::ReadL(iRequestPtr, aApplications);        

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CancelApplications()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::CancelApplications()

    {

    // synchronous, nothing to do

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::IsApplicable()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::IsApplicable(const CCTCertInfo& aCertInfo, TUid aApplication, 

                    TBool& aIsApplicable, TRequestStatus& aStatus)

    {

    TIpcArgs args(aCertInfo.Handle().iObjectId, 0, aApplication.iUid);

    TInt r = iClientSession.SendRequest(EIsApplicable, args); 

    if (r >= 0)

        {

        aIsApplicable = !!r;  // Convert TInt to TBool

        r = KErrNone;

        }

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, r); 

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CancelIsApplicable()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::CancelIsApplicable()

    {

    // synchronous, nothing to do

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::Trusted()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::Trusted(const CCTCertInfo& aCertInfo, TBool& aTrusted, 

                 TRequestStatus& aStatus)

    {

    TIpcArgs args(aCertInfo.Handle().iObjectId);

    TInt r = iClientSession.SendRequest(ETrusted, args);  

    if (r >= 0)

        {

        aTrusted = !!r;  // Convert TInt to TBool

        r = KErrNone;

        }

    TRequestStatus* status = &aStatus;

    User::RequestComplete(status, r); 

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CancelTrusted()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::CancelTrusted()

    {

    // synchronous, nothing to do

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::Retrieve()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::Retrieve(const CCTCertInfo& aCertInfo, TDes8& aEncodedCert,

                  TRequestStatus& aStatus)

    {

    TInt err = DoRetrieve(aCertInfo, aEncodedCert);

    FreeRequestBuffer();

    TRequestStatus* stat = &aStatus;

    User::RequestComplete(stat, err);

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::DoRetrieve()

// -----------------------------------------------------------------------------

//

TInt CDevandTruSrvCertStore::DoRetrieve(const CCTCertInfo& aCertInfo, TDes8& aEncodedCert)

    {

    if (aCertInfo.Size() <= 0)

        {

        return KErrArgument;

        }

    if (aEncodedCert.MaxSize() < aCertInfo.Size())

        {

        return KErrOverflow;

        }

    TInt r = AllocRequestBuffer(aEncodedCert.MaxSize());  

    if (KErrNone!=r)

        {

        return r;

        }

    TIpcArgs args(aCertInfo.Handle().iObjectId, 0, 0, &iRequestPtr);

    r = iClientSession.SendRequest(ERetrieve, args);

    if (r == KErrNone)

        {

        aEncodedCert.Copy(iRequestPtr);

        }

    return r;

    }

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::CancelRetrieve()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::CancelRetrieve()

    {

    // synchronous, nothing to do

    }

//  MCTWritableCertStore interface

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::Add()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::Add(const TDesC& aLabel, TCertificateFormat aFormat,

               TCertificateOwnerType aCertificateOwnerType, 

               const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

               const TDesC8& aCert, TRequestStatus& aStatus)

    {

    Add(aLabel, aFormat, aCertificateOwnerType, aSubjectKeyId, aIssuerKeyId, aCert, 

    ETrue, aStatus);

    } 

// -----------------------------------------------------------------------------

// CDevandTruSrvCertStore::Add()

// -----------------------------------------------------------------------------

//

void CDevandTruSrvCertStore::Add(const TDesC& aLabel, TCertificateFormat aFormat,

               TCertificateOwnerType aCertificateOwnerType, 

               const TKeyIdentifier* aSubjectKeyId, const TKeyIdentifier* aIssuerKeyId,

               const TDesC8& aCert, const TBool aDeletable,

               TRequestStatus& aStatus)

    {