/*

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

*

*/

#include <x509cert.h>

#include "TrustedSitesStore.h"

#include "DevandTruSrvCertStore.h"

#include "DevTokenType.h"

#include "DevToken.h"

#include "DevTokenUtils.h"

#include "DevTokenImplementationUID.hrh"

const TInt KSHA1Length = 20;

// Define the default size. If overflow, the function 

// SendSyncRequestAndHandleOverflowL() will handle.

const TInt KDefaultBufferSize = 256;

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

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

// CTrustSitesStore::NewL()

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

//

EXPORT_C CTrustSitesStore* CTrustSitesStore::NewL()

    {

    CTrustSitesStore* me = new (ELeave) CTrustSitesStore();

    CleanupStack::PushL(me);

    me->ConstructL();

    CleanupStack::Pop(me);

    return (me);

    }

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

// CTrustSitesStore::CTrustSitesStore()

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

//

CTrustSitesStore::CTrustSitesStore() :

  iRequestPtr(NULL, 0, 0) 

    {

    }

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

// CTrustSitesStore::~CTrustSitesStore()

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

//

EXPORT_C CTrustSitesStore::~CTrustSitesStore()

    {

    FreeRequestBuffer();  

    if ( iClientSession )

        {

        iClientSession->Close();

        delete iClientSession;

        }

    }

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

// CTrustSitesStore::ConstructL()

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

//

void CTrustSitesStore::ConstructL()

    { 

    iClientSession = RDevTokenClientSession::ClientSessionL();

    User::LeaveIfError(iClientSession->Connect(ETruSitesStore));

    }

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

// CTrustSitesStore::AddL()

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

//

EXPORT_C TInt CTrustSitesStore::AddL( const TDesC8& aCertificate, const TDesC& aTrustedSite )

    {

    if( !(aCertificate.Length() > KSHA1Length) || !( aTrustedSite.Length() > 0) )

        {

        User::LeaveIfError(KErrArgument);

        }

    CX509Certificate* cert = CX509Certificate::NewL(aCertificate);

    TBuf8<KSHA1Length> certHash;

    certHash.Copy(cert->Fingerprint());

    delete cert;

    TIpcArgs args(&certHash, &aTrustedSite, NULL, NULL);

    TInt r = iClientSession->SendRequest(EAddTrustSite, args);  

    return r; 

    }

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

// CTrustSitesStore::AddForgivenSiteL()

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

//

EXPORT_C TInt CTrustSitesStore::AddForgivenSiteL( const TDesC& aSite, const TBool& aIsOutOfDateAllowed )

    {

    if( !( aSite.Length() > 0) )

        {

        User::LeaveIfError(KErrArgument);

        }

    TIpcArgs args( &aSite, aIsOutOfDateAllowed );

    TInt r = iClientSession->SendRequest(EAddForgivenSite, args);  

    return r; 	

    }

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

// CTrustSitesStore::RemoveForgivenSiteL()

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

//

EXPORT_C TInt CTrustSitesStore::RemoveForgivenSiteL( const TDesC& aSite )

	{

	TIpcArgs args( &aSite );

	TInt r = iClientSession->SendRequest(ERemoveForgivenSite, args);  

	return r;

	}

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

// CTrustSitesStore::IsOutOfDateAllowedL()

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

//

EXPORT_C TBool CTrustSitesStore::IsOutOfDateAllowedL( const TDesC8& aCertificate, const TDesC& aTrustedSite )

    {

    if( !(aCertificate.Length() > 0) || !( aTrustedSite.Length() > 0) )

        {

        User::LeaveIfError(KErrArgument);

        }

    CX509Certificate* cert = CX509Certificate::NewL(aCertificate);

    TBuf8<KSHA1Length> certHash;

    certHash.Copy(cert->Fingerprint());

    delete cert;

    cert = NULL;

    TIpcArgs args(&certHash, &aTrustedSite );

    TInt r = iClientSession->SendRequest(EIsOutOfDateAllowed, args); 

    if( r > 0 )

        {

        return ETrue;

        }

    else

        {

        return EFalse;  

        } 	

   }

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

// CTrustSitesStore::IsTrustedSiteL()

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

//

EXPORT_C TBool CTrustSitesStore::IsTrustedSiteL( const TDesC8& aCertificate, const TDesC& aTrustedSite )

    {

    if( !(aCertificate.Length() > 0) || !( aTrustedSite.Length() > 0) )

        {

        User::LeaveIfError(KErrArgument);

        }

    CX509Certificate* cert = CX509Certificate::NewL(aCertificate);

    TBuf8<KSHA1Length> certHash;

    certHash.Copy(cert->Fingerprint());

    delete cert;

    cert = NULL;

    TIpcArgs args(&certHash, &aTrustedSite, &aCertificate );

    TInt r = iClientSession->SendRequest(EIsTrustedSite, args); 

    if( r > 0 )

        {

        return ETrue;

        }

    else

        {

        return EFalse;  

        } 

    }

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

// CTrustSitesStore::GetTrustedSitesL()

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

//

EXPORT_C TInt CTrustSitesStore::GetTrustedSitesL( const TDesC8& aCertificate, RPointerArray<HBufC>& aListOfSites )       

    {

    if( !(aCertificate.Length() > 0 ) ) 

        {

        User::LeaveIfError(KErrArgument);

        }

    CX509Certificate* cert = CX509Certificate::NewL(aCertificate);

    TBuf8<KSHA1Length> certHash;

    certHash.Copy(cert->Fingerprint()); 

    delete cert;

    cert = NULL;

    TIpcArgs args( &certHash, &iRequestPtr, NULL, NULL );

    TRAPD(err, SendSyncRequestAndHandleOverflowL(KDefaultBufferSize, args));

    if(err!=KErrNone)

        {

        return err;

        }

    TRAP(err, DevTokenDataMarshaller::ReadL( iRequestPtr, aListOfSites ));

    if( err!= KErrNone )

        {

        return err;

        }

    return KErrNone;    

    }

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

// CTrustSitesStore::RemoveL()

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

//

/*EXPORT_C TInt CTrustSitesStore::RemoveL( const TDesC8& aCertificate )

    {

    if( !(aCertificate.Length() > 0 ) )

        {

        User::LeaveIfError(KErrArgument);

        }

    CX509Certificate* cert = CX509Certificate::NewL(aCertificate);

    TBuf8<KSHA1Length> certHash;

    certHash.Copy(cert->Fingerprint()); 

    TIpcArgs args( &certHash, NULL, NULL, NULL );

    TInt r = iClientSession->SendRequest(ERemove, args);  

    return r; 

    }*/

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

// CTrustSitesStore::FreeRequestBuffer()

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

//

void CTrustSitesStore::FreeRequestBuffer() 

    {

    delete iRequestDataBuf; 

    iRequestDataBuf = NULL;

    iRequestPtr.Set(NULL, 0, 0);

    }

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

// CTrustSitesStore::AllocRequestBuffer()

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

//

TInt CTrustSitesStore::AllocRequestBuffer(TInt aReqdSize) 

    {

    ASSERT(aReqdSize > 0);

    TInt result = KErrNoMemory;

    FreeRequestBuffer();

    iRequestDataBuf = HBufC8::NewMax(aReqdSize);

    if (iRequestDataBuf)

        {

        iRequestPtr.Set(iRequestDataBuf->Des());

        iRequestPtr.FillZ();

        result = KErrNone;

        }

    return result;

    }

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

// CTrustSitesStore::SendSyncRequestAndHandleOverflowL()

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

//

void CTrustSitesStore::SendSyncRequestAndHandleOverflowL(TInt aInitialBufSize,

                          const TIpcArgs& aArgs) 

    {

    TDevTokenMessages message;

    message = EGetTrustedSites; 

    User::LeaveIfError(AllocRequestBuffer(aInitialBufSize));

    TInt err = iClientSession->SendRequest(message, aArgs);

    if (err == KErrOverflow)

        {

        TInt sizeReqd = 0;

        TPckg<TInt> theSize(sizeReqd);

        theSize.Copy(iRequestPtr);

        User::LeaveIfError(AllocRequestBuffer(sizeReqd));     

        err = iClientSession->SendRequest(message, aArgs);

        }

    User::LeaveIfError(err);

    }

//EOF