/*

* Copyright (c) 2002-2008 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 DmAdStore

*

*/

#include "DmAdStore.h"

#include "DmAdRtNodeData.h"

#include "dmadutil.h"

#include "vpnlogger.h"

#include "pkcs12vpn.h"

CDmAdStore* CDmAdStore::NewL(MDmAdCallBack* aDmAdCallBack)

    {

    TRACE("CDmAdStore::NewL");

    CDmAdStore *self = new (ELeave) CDmAdStore();

    CleanupStack::PushL(self);

    self->ConstructL(aDmAdCallBack);

    CleanupStack::Pop(self);

    return self;

    }

void CDmAdStore::ConstructL(MDmAdCallBack* aDmAdCallBack)

    {

    TRACE("CDmAdStore::ConstructL");

    TInt status = iPkiServiceApi.Connect();

    DEBUG_LOG1(_L("Connect status: %d"), status);

    User::LeaveIfError(status);    

    iCert = CDmAdCert::NewL(iPkiServiceApi);

    iCertReq = CDmAdCertReq::NewL(iPkiServiceApi, aDmAdCallBack);

    iPrivKey = CDmAdPrivKey::NewL(iPkiServiceApi);    

    iPKCS12Obj = CDmAdPKCS12::NewL(iPkiServiceApi);

    }

CDmAdStore::CDmAdStore()

    {

    TRACE("CDmAdStore::CDmAdStore");

    }

CDmAdStore::~CDmAdStore()

    {

    TRACE("CDmAdStore::~CDmAdStore");

    iPkiServiceApi.Close();

    delete iCert;

    delete iCertReq;

    delete iPrivKey;

    delete iPKCS12Obj;

    }

TBool CDmAdStore::FindRtNodeL(const TDesC8& aLuid, const TDesC8& aUri)

    {

    TRACE("CDmAdStore::FindRtNodeL");

    TDmAdUriType uriType = CDmAdRtNodeData::UriTypeL(aUri);

    switch (uriType)

        {

        case EDmAdUriTypeCert:

            return CertFindRtNodeL(aLuid, aUri);

        case EDmAdUriTypeCertReq:

            return CertReqFindRtNodeL(aLuid, aUri);

        case EDmAdUriTypePrivKey:

            return PrivKeyFindRtNodeL(aLuid, aUri);

        case EDmAdUriTypePKCS12:

            // For PKCS#12, a special case

            return EFalse;

        default:

            DEBUG_LOG(_L("Unexcepted URI type"));

            User::Leave(KErrGeneral);

            return EFalse;

        }

    }

void CDmAdStore::LuidListL(const TDesC8& aUri, const TDesC8& aLuid, RPointerArray<HBufC8>& aLuidList)

    {

    TRACE("CDmAdStore::LuidListL");

    TDmAdUriType uriType = CDmAdRtNodeData::UriTypeL(aUri);

    switch (uriType)

        {

        case EDmAdUriTypeCert:

            CertLuidListL(aUri, aLuid, aLuidList);

            break;

        case EDmAdUriTypeCertReq:

            CertReqLuidListL(aUri, aLuid, aLuidList);

            break;

        case EDmAdUriTypePrivKey:

            PrivKeyLuidListL(aUri, aLuid, aLuidList);

            break;

        case EDmAdUriTypePKCS12:

            // For PKCS#12, a special case

            break;

        default:

            DEBUG_LOG(_L("CDmAdStore::LuidListLC: Unexcepted URI type"));

            User::Leave(KErrGeneral);

            break;

        }    

    }

void CDmAdStore::FetchRtNodeL(CDmAdRtNode& aRtNode)

    {

    TRACE("CDmAdStore::FetchRtNodeL");

    TDmAdUriType uriType = aRtNode.Data()->UriType();

    switch (uriType)

        {

        case EDmAdUriTypeCert:

            CertFetchRtNodeL(aRtNode);

            break;

        case EDmAdUriTypeCertReq:

            CertReqFetchRtNodeL(aRtNode);

            break;

        case EDmAdUriTypePrivKey:

            PrivKeyFetchRtNodeL(aRtNode);

            break;

        case EDmAdUriTypePKCS12:

            // For PKCS#12, a special case

            break;

        default:

            DEBUG_LOG(_L("Unexcepted URI type"));

            User::Leave(KErrGeneral);

            break;

        }

    }

void CDmAdStore::SaveTopLevelRtNodeL(CDmAdRtNode& aRtNode, CArrayPtr<CDmAdRtNode>& aChildRtNodes)

    {

    TRACE("CDmAdStore::SaveTopLevelRtNodeL");

    TDmAdUriType uriType = aRtNode.Data()->UriType();

    switch (uriType)

        {

        case EDmAdUriTypeCert:

            CertSaveTopLevelRtNodeL(aRtNode, aChildRtNodes);

            break;

        case EDmAdUriTypeCertReq:

            CertReqSaveTopLevelRtNodeL(aRtNode, aChildRtNodes);

            break;

        case EDmAdUriTypePKCS12:

            PKCS12SaveTopLevelRtNodeL(aRtNode, aChildRtNodes);

            break;

        default:

            DEBUG_LOG(_L("Unexcepted URI type"));

            User::Leave(KErrGeneral);

            break;

        }

    }

void CDmAdStore::SaveChildLevelRtNodeL(CDmAdRtNode& aRtNode)

    {

    TRACE("CDmAdStore::SaveChildLevelRtNodeL");

    TDmAdUriType uriType = aRtNode.Data()->UriType();

    switch (uriType)

        {

        case EDmAdUriTypeCert:

            CertSaveChildLevelRtNodeL(aRtNode);

            break;

        case EDmAdUriTypeCertReq:

            CertReqSaveChildLevelRtNodeL(aRtNode);

            break;

        case EDmAdUriTypePKCS12:

            // For PKCS#12, a special case

            break;

        default:

            DEBUG_LOG(_L("Unexcepted URI type"));

            User::Leave(KErrGeneral);

            break;

        }

    }

void CDmAdStore::DeleteRtNodeL(const TDesC8& aLuid, const TDesC8& aUri)

    {

    TRACE("CDmAdStore::DeleteRtNodeL");

    TDmAdUriType uriType = CDmAdRtNodeData::UriTypeL(aUri);

    switch (uriType)

        {

        case EDmAdUriTypeCert:

            CertDeleteRtNodeL(aLuid, aUri);

            break;

        case EDmAdUriTypeCertReq:

            CertReqDeleteRtNodeL(aLuid, aUri);

            break;

        case EDmAdUriTypePrivKey:

            PrivKeyDeleteRtNodeL(aLuid, aUri);

            break;

        case EDmAdUriTypePKCS12:

            // For PKCS#12, a special case

            break;

        default:

            DEBUG_LOG(_L("Unexcepted URI type"));

            User::Leave(KErrGeneral);

            break;

        }

    }

//=========================================================================

//=========================================================================

TBool CDmAdStore::CertFindRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

    {

    TRACE("CDmAdStore::CertFindRtNodeL");

    TBool ret = EFalse;

    if (aLuid.Length() > 0)

        {

        if (iCert->FindL(aLuid))

            {

            ret = ETrue;

            }

        }

    return ret;

    }

void CDmAdStore::CertLuidListL(const TDesC8& /*aUri*/, const TDesC8& /*aLuid*/, RPointerArray<HBufC8>& aLuidList)

    {

    TRACE("CDmAdStore::CertLuidListL");

    iCert->ListL(aLuidList);

    }

void CDmAdStore::CertFetchRtNodeL(CDmAdRtNode& aRtNode)

    {

    TRACE("CDmAdStore::CertFetchRtNodeL");

    TPtrC8 luid(aRtNode.Luid());

    if (luid.Length() == 0)

        {

        DEBUG_LOG(_L("Zero length luid"));

        User::Leave(KErrNotFound);

        }

    CDmAdCertData* data = aRtNode.Data()->CertData();

    CDmAdCertParms* certParms = CDmAdCertParms::NewL();

    CleanupStack::PushL(certParms);

    iCert->FetchL(luid, *certParms);

    data->RestoreL(*certParms);

    CleanupStack::PopAndDestroy(certParms);

    }

void CDmAdStore::CertSaveTopLevelRtNodeL(CDmAdRtNode& aRtNode, CArrayPtr<CDmAdRtNode>& aChildRtNodes)

    {

    TRACE("CDmAdStore::CertSaveTopLevelRtNodeL");

    if (aChildRtNodes.Count() > 0)

        {

        DEBUG_LOG(_L("ChildRtNode count > 0"));        

        User::Leave(KErrGeneral);

        }

    if (aRtNode.IsJustFetched())

        {

        return;

        }

    CDmAdCertData* data = aRtNode.Data()->CertData();

    CDmAdCertParms* certParms = CDmAdCertParms::NewL();

    CleanupStack::PushL(certParms);

    data->ToStoreL(*certParms);

    if (aRtNode.IsSomeLeafAddedToRtNode())

        {

        HBufC8* luid = iCert->AddL(*certParms);

        CleanupStack::PushL(luid);

        aRtNode.SetLuidL(*luid);

        CleanupStack::PopAndDestroy(luid); 

        }

    else

        {

        iCert->UpdateL(aRtNode.Luid(), *certParms);

        }

    CleanupStack::PopAndDestroy(certParms);

    }

void CDmAdStore::CertSaveChildLevelRtNodeL(CDmAdRtNode& /*aRtNode*/)

    {

    TRACE("CDmAdStore::CertSaveChildLevelRtNodeL");

    DEBUG_LOG(_L("Method not implemented"));

    User::Leave(KErrGeneral);

    }

void CDmAdStore::CertDeleteRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

    {

    TRACE("CDmAdStore::CertDeleteRtNodeL");

    if (aLuid.Length() == 0)

        {

        DEBUG_LOG(_L("aLuid length is 0"));

        User::Leave(KErrNotFound);

        }

    iCert->DeleteL(aLuid);

    }

//=========================================================================

//=========================================================================

TBool CDmAdStore::CertReqFindRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

    {

    TRACE("CDmAdStore::CertReqFindRtNodeL");

    TBool ret = EFalse;

    if (aLuid.Length() > 0)

        {

        if (iCertReq->FindL(aLuid))

            {

            ret = ETrue;

            }

        }

    return ret;

    }

void CDmAdStore::CertReqLuidListL(const TDesC8& /*aUri*/, const TDesC8& /*aLuid*/,RPointerArray<HBufC8>& aLuidList)

    {

    TRACE("CDmAdStore::CertReqLuidListL");

    iCertReq->ListL(aLuidList);

    }

void CDmAdStore::CertReqFetchRtNodeL(CDmAdRtNode& aRtNode)

    {

    TRACE("CDmAdStore::CertReqFetchRtNodeL");

    TPtrC8 luid(aRtNode.Luid());

    if (luid.Length() == 0)

        {

        DEBUG_LOG(_L("luid length is 0"));

        User::Leave(KErrNotFound);

        }

    CDmAdCertReqData* data = aRtNode.Data()->CertReqData();

    CDmAdCertReqParms* CertReqParms = CDmAdCertReqParms::NewL();

    CleanupStack::PushL(CertReqParms);

    iCertReq->FetchL(luid, *CertReqParms);

    data->RestoreL(*CertReqParms);

    CleanupStack::PopAndDestroy(CertReqParms);

    }

void CDmAdStore::CertReqSaveTopLevelRtNodeL(CDmAdRtNode& aRtNode, CArrayPtr<CDmAdRtNode>& aChildRtNodes)

    {

    TRACE("CDmAdStore::CertReqSaveTopLevelRtNodeL");

    if (aChildRtNodes.Count() > 0)

        {

        DEBUG_LOG(_L("aChildRtNodes count > 0"));

        User::Leave(KErrGeneral);

        }

    if (aRtNode.IsJustFetched())

        {

        return;

        }

    CDmAdCertReqData* data = aRtNode.Data()->CertReqData();

    CDmAdCertReqParms* CertReqParms = CDmAdCertReqParms::NewL();

    CleanupStack::PushL(CertReqParms);

    data->ToStoreL(*CertReqParms);

    if (aRtNode.IsSomeLeafAddedToRtNode())

        {

        HBufC8* luid = iCertReq->AddL(*CertReqParms);

        CleanupStack::PushL(luid);

        aRtNode.SetLuidL(*luid);

        CleanupStack::PopAndDestroy(luid);

        }

    else

        {

        DEBUG_LOG(_L("aRtNode.IsSomeLeafAddedToRtNode() returned false"));

        User::Leave(KErrGeneral);

        /*

        //iCertReq->UpdateL(aRtNode.Luid(), *CertReqParms);

        CertReqDeleteRtNodeL(aRtNode.Luid(), aRtNode.Uri());

        HBufC8* luid = iCertReq->AddL(*CertReqParms);

        CleanupStack::PushL(luid);

        aRtNode.SetLuidL(*luid);

        iCallBack->SetMappingL(aRtNode.Uri(), aRtNode.Luid());

        CleanupStack::PopAndDestroy(); //luid

        */

        }

    CleanupStack::PopAndDestroy(CertReqParms);

    }

void CDmAdStore::CertReqSaveChildLevelRtNodeL(CDmAdRtNode& /*aRtNode*/)

    {

    TRACE("CDmAdStore::CertReqSaveChildLevelRtNodeL");

    DEBUG_LOG(_L("Method not implemented"));

    User::Leave(KErrGeneral);

    }

void CDmAdStore::CertReqDeleteRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

    {

    TRACE("CDmAdStore::CertReqDeleteRtNodeL");

    if (aLuid.Length() == 0)

        {

        DEBUG_LOG(_L("aLuid length is 0"));        

        User::Leave(KErrNotFound);

        }

    iCertReq->DeleteL(aLuid);

    }

//=========================================================================

//=========================================================================

TBool CDmAdStore::PrivKeyFindRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

    {

    TRACE("CDmAdStore::PrivKeyFindRtNodeL");

    TBool ret = EFalse;

    if (aLuid.Length() > 0)

        {

        if (iPrivKey->FindL(aLuid))

            {

            ret = ETrue;

            }

        }

    return ret;

    }

void CDmAdStore::PrivKeyLuidListL(const TDesC8& /*aUri*/, const TDesC8& /*aLuid*/, RPointerArray<HBufC8>& aLuidList)

    {

    TRACE("CDmAdStore::PrivKeyLuidListL");

    iPrivKey->ListL(aLuidList);

    }

void CDmAdStore::PrivKeyFetchRtNodeL(CDmAdRtNode& aRtNode)

    {

    TRACE("CDmAdStore::PrivKeyFetchRtNodeL");

    TPtrC8 luid(aRtNode.Luid());

    if (luid.Length() == 0)

        {

        DEBUG_LOG(_L("aLuid length is 0"));        

        User::Leave(KErrNotFound);

        }

    CDmAdPrivKeyData* data = aRtNode.Data()->PrivKeyData();

    CDmAdPrivKeyParms* PrivKeyParms = CDmAdPrivKeyParms::NewL();

    CleanupStack::PushL(PrivKeyParms);

    iPrivKey->FetchL(luid, *PrivKeyParms);

    data->RestoreL(*PrivKeyParms);

    CleanupStack::PopAndDestroy(PrivKeyParms);

    }

void CDmAdStore::PrivKeyDeleteRtNodeL(const TDesC8& aLuid, const TDesC8& /*aUri*/)

    {

    TRACE("CDmAdStore::PrivKeyDeleteRtNodeL");

    if (aLuid.Length() == 0)

        {

        DEBUG_LOG(_L("aLuid length is 0"));        

        User::Leave(KErrNotFound);

        }

    iPrivKey->DeleteL(aLuid);

    }

//=========================================================================

//=========================================================================

// PKCS#12 handling

void CDmAdStore::PKCS12SaveTopLevelRtNodeL(CDmAdRtNode& aRtNode,

                               CArrayPtr<CDmAdRtNode>& aChildRtNodes) 

    {

    TRACE("CDmAdStore::PKCS12SaveTopLevelRtNodeL");

    if (aChildRtNodes.Count() > 0)

        {

        DEBUG_LOG(_L("ChildRtNode count > 0"));        

        User::Leave(KErrGeneral);

        }

    CDmAdPKCS12Data* data = aRtNode.Data()->PKCS12Data();

    CDmAdPKCS12Parms* pkcs12Parms = CDmAdPKCS12Parms::NewL();

    CleanupStack::PushL(pkcs12Parms);

    // Extract parameters from data

    data->ToStoreL(*pkcs12Parms);

    // Store PKCS#12 object contents to PKI

    iPKCS12Obj->AddL(*pkcs12Parms);

    TPtrC8 uri = aRtNode.Uri();

    DEBUG_LOG1(_L8(" Setting LUID to '%S'"), &uri);

    aRtNode.SetLuidL(uri);

    CleanupStack::PopAndDestroy(pkcs12Parms);

    }

//=========================================================================

//=========================================================================

void CDmAdStore::PkiLogonL()

    {

    TRACE("CDmAdStore::PkiLogonL");

    TRequestStatus requestStatus;

    iPkiServiceApi.Logon(requestStatus);

    User::WaitForRequest(requestStatus);