/*

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

*

*/

#include <utf.h>

#include <x509cert.h>

#include <x509keys.h>

#include <x500dn.h>

#include <x509certext.h>

#include "DmAdRtNodeData.h"

#include "dmadddf.h"

#include "dmadutil.h"

#include "vpnlogger.h"

#include "dmadstoreprivkey.h"

#include "pkidefs.h"

#include "XwImpl.h"

#include "dmadcertxmldefs.h"

#include "XppImpl.h"

#include <vpnlogmessages.rsg>

// Macro to encode key usage bits

// See method CDmAdCertData::KeyUsageLC

#define ENC_BIT(a)                         \

    if( EFalse == keyUsageExt->IsSet(a) )  \

        {                                  \

        keyUsagePtr.Append('0');           \

        }                                  \

    else                                   \

        {                                  \

        keyUsagePtr.Append('1');           \

        }

CDmAdRtNodeData* CDmAdRtNodeData::NewL(const TDesC8& aUri, MDmAdCallBack* aCallBack)

    {

    TRACE("CDmAdRtNodeData::NewL");

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

    CleanupStack::PushL(self);

    self->ConstructL(aUri, aCallBack);

    CleanupStack::Pop(self);

    return self;

    }

void CDmAdRtNodeData::ConstructL(const TDesC8& aUri, MDmAdCallBack* aCallBack)

    {

    TRACE("CDmAdRtNodeData::ConstructL");

    iUriType = UriTypeL(aUri);

    switch (iUriType)

        {

        case EDmAdUriTypeCert:

            u.iCert = CDmAdCertData::NewL(aCallBack);

            break;

        case EDmAdUriTypeCertReq:

            u.iCertReq = CDmAdCertReqData::NewL(aCallBack);

            break;

        case EDmAdUriTypePrivKey:

            u.iPrivKey = CDmAdPrivKeyData::NewL();

            break;

        case EDmAdUriTypePKCS12:

            u.iPKCS12 = CDmAdPKCS12Data::NewL();

            break;

        default:

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

            User::Leave(KErrGeneral);

            break;

        }    

    }

CDmAdRtNodeData::CDmAdRtNodeData()

    {

    }

CDmAdRtNodeData::~CDmAdRtNodeData()

    {

    TRACE("CDmAdRtNodeData::~CDmAdRtNodeData");

    switch (iUriType)

        {

        case EDmAdUriTypeCert:

            delete u.iCert;

            break;

        case EDmAdUriTypeCertReq:

            delete u.iCertReq;

            break;

        case EDmAdUriTypePrivKey:

            delete u.iPrivKey;

            break;

        case EDmAdUriTypePKCS12:

            delete u.iPKCS12;

            break;

        default:

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

            break;

        }   

    }

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

TDmAdUriType CDmAdRtNodeData::UriType() const

    {

    TRACE("CDmAdRtNodeData::UriType");

    return iUriType;

    }

TDmAdUriType CDmAdRtNodeData::UriTypeL(const TDesC8& aUri)

    {

    TRACE("CDmAdRtNodeData::UriTypeL");

    TDmAdUriType ret = EDmAdUriTypeCert;

    CArrayFix<TPtrC8>* uriSegList;

    TDmAdUtil::ParseUriLC(aUri, uriSegList);

    if (uriSegList->Count() < 2)

        {

        DEBUG_LOG(_L("uriSegList->Count() is less than 2"));        

        User::Leave(KErrGeneral);

        }

    if (uriSegList->At(0).Compare(KDmAdNodeNokiaPki) == 0)

        {

        if (uriSegList->At(1).Compare(KDmAdNodeCert) == 0)

            {

            ret = EDmAdUriTypeCert;

            }

        else if (uriSegList->At(1).Compare(KDmAdNodeCertReq) == 0)

            {

            ret = EDmAdUriTypeCertReq;

            }

        else if (uriSegList->At(1).Compare(KDmAdNodePrivKey) == 0)

            {

            ret = EDmAdUriTypePrivKey;

            }

        else if (uriSegList->At(1).Compare(KDmAdNodePKCS12) == 0)

            {

            ret = EDmAdUriTypePKCS12;

            }

        else

            {

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

            User::Leave(KErrGeneral);

            }

        }

    else

        {

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

        User::Leave(KErrGeneral);

        }

    CleanupStack::PopAndDestroy(uriSegList);

    return ret;

    }

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

void CDmAdRtNodeData::UpdateLeafDataL(const TDesC8& aUri, const TDesC8& aObject)

    {

    TRACE("CDmAdRtNodeData::UpdateLeafDataL");

    switch (iUriType)

        {

        case EDmAdUriTypeCert:

            TRAPD(err, UpdateLeafDataCertL(aUri, aObject));

            if(err != KErrNone)

                User::Leave(err);

            break;

        case EDmAdUriTypeCertReq:

            UpdateLeafDataCertReqL(aUri, aObject);

            break;

        case EDmAdUriTypePrivKey:

            UpdateLeafDataPrivKeyL(aUri, aObject);

            break;

        case EDmAdUriTypePKCS12:

            UpdateLeafDataPKCS12L(aUri, aObject);

            break;

        default:

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

            User::Leave(KErrGeneral);

            break;

        }

    }

void CDmAdRtNodeData::UpdateLeafDataCertL(const TDesC8& aUri, const TDesC8& aObject)

    {

    TRACE("CDmAdRtNodeData::UpdateLeafDataCertL");

    TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

    if (lastSeg.Compare(KDmAdLeafContent) == 0)

        {

        u.iCert->SetContentL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafType) == 0)

        {

        u.iCert->SetTypeL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafFormat) == 0)

        {

        u.iCert->SetFormatL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)

        {

        u.iCert->SetDeletableL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafTrusted) == 0)

        {

        u.iCert->SetTrustedL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)

        {

        RArray<TUid> applicability;

        CleanupClosePushL(applicability);

        ParseApplicabilityL(aObject, applicability);                                                    

        u.iCert->SetApplicabilityL(applicability);

        CleanupStack::PopAndDestroy(); //applicability

        }

    else

        {

        DEBUG_LOG(_L("No match found"));        

        User::Leave(KErrNotFound);

        }

    }

void CDmAdRtNodeData::UpdateLeafDataCertReqL(const TDesC8& aUri, const TDesC8& aObject)

    {

    TRACE("CDmAdRtNodeData::UpdateLeafDataCertReqL");

    TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

    if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)

        {

        u.iCertReq->SetSubjectNameL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafRfc822Name) == 0)

        {

        u.iCertReq->SetRfc822NameL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)

        {

        u.iCertReq->SetKeyUriL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)

        {

        u.iCertReq->SetKeyLength(aObject);

        }

    else

        {

        DEBUG_LOG(_L("No match found"));        

        User::Leave(KErrNotFound);

        }

    }

void CDmAdRtNodeData::UpdateLeafDataPrivKeyL(const TDesC8& aUri, const TDesC8& aObject)

    {

    TRACE("CDmAdRtNodeData::UpdateLeafDataPrivKeyL");

    TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

    if (lastSeg.Compare(KDmAdLeafKeyType) == 0)

        {

        u.iPrivKey->SetKeyTypeL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)

        {

        u.iPrivKey->SetKeyLength(aObject);

        }

    else

        {        

        DEBUG_LOG(_L("No match found"));        

        User::Leave(KErrNotFound);

        }

    }

void CDmAdRtNodeData::UpdateLeafDataPKCS12L(const TDesC8& aUri, const TDesC8& aObject)

    {

    TRACE("CDmAdRtNodeData::UpdateLeafDataPKCS12L");

    TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

    if (lastSeg.Compare(KDmAdLeafContent) == 0)

        {

        u.iPKCS12->SetContentL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)

        {

        u.iPKCS12->SetDeletableL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafPKCS12Password) == 0)

        {

        u.iPKCS12->SetPasswordL(aObject);

        }

    else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)

        {

        RArray<TUid> applicability;

        CleanupClosePushL(applicability);

        ParseApplicabilityL(aObject, applicability);                                                    

        u.iPKCS12->SetApplicabilityL(applicability);

        CleanupStack::PopAndDestroy(); //applicability

        }

    else

        {

        DEBUG_LOG(_L("No match found"));        

        User::Leave(KErrNotFound);

        }

    }

void CDmAdRtNodeData::FetchLeafObjectLC(const TDesC8& aUri, const TDesC8& aLuid, CBufBase*& aObject)

    {   

    switch (iUriType)

        {

        case EDmAdUriTypeCert:

            FetchLeafObjectCertLC(aUri, aLuid, aObject);

            break;

        case EDmAdUriTypeCertReq:

            FetchLeafObjectCertReqLC(aUri, aLuid, aObject);

            break;

        case EDmAdUriTypePrivKey:

            FetchLeafObjectPrivKeyLC(aUri, aLuid, aObject);

            break;

        case EDmAdUriTypePKCS12:

            // PKCS#12 special case

            break;

        default:

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

            User::Leave(KErrGeneral);

            break;

        }

    }

void CDmAdRtNodeData::FetchLeafObjectCertLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)

    {    

    CBufBase* object = CBufFlat::NewL(32);

    CleanupStack::PushL(object);

    TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

    if (lastSeg.Compare(KDmAdLeafType) == 0)

        {

        HBufC8* obj = u.iCert->TypeLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafFormat) == 0)

        {

        HBufC8* obj = u.iCert->FormatLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafDeletable) == 0)

        {

        HBufC8* obj = u.iCert->DeletableLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafTrusted) == 0)

        {

        HBufC8* obj = u.iCert->TrustedLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafApplicability) == 0)

        {

        DEBUG_LOG(_L("Fetching applicability"));

        const RArray<TUid>& applicability = u.iCert->Applicability();

        CXmlWriter* writer = CXmlWriter::NewL();

        CleanupStack::PushL(static_cast<CBase*>(writer));

        writer->AddStartTagL(KXmlElemCertApps);

        DEBUG_LOG(_L("KXmlElemCertApps Start tag added"));

        for (TInt i = 0; i < applicability.Count(); ++i)

            {

            HBufC8* idInt = TDmAdUtil::IntToDes8LC((TInt)applicability[i].iUid);

            writer->OpenStartTagL(KXmlElemApp);

            writer->AddAttributeL(KXmlAttrId, *idInt);

            writer->CloseStartTagL(ETrue);

            CleanupStack::PopAndDestroy(idInt); 

            }

        writer->AddEndTagL(KXmlElemCertApps);

        DEBUG_LOG(_L("KXmlElemCertApps end tag added"));

        TPtrC8 docDataPtr(writer->DocPart(0, writer->Length()-1));                

        object->InsertL(0, docDataPtr);

        DEBUG_LOG(_L("document inserted"));

        CleanupStack::PopAndDestroy(static_cast<CBase*>(writer));

        DEBUG_LOG(_L("writer popped"));

        }

    else if (lastSeg.Compare(KDmAdLeafContent) == 0)

        {

        TPtrC8 obj(u.iCert->Content());

        object->InsertL(0, obj);

        }

    else if (lastSeg.Compare(KDmAdLeafSerialNumber) == 0)

        {

        HBufC8* obj = u.iCert->SerialNumberLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafIssuerName) == 0)

        {

        HBufC8* obj = u.iCert->IssuerNameLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafFingerprintAlg) == 0)

        {

        HBufC8* obj = u.iCert->FingerprintAlgLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafFingerprintValue) == 0)

        {

        HBufC8* obj = u.iCert->FingerprintValueLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafValidityBegin) == 0)

        {

        HBufC8* obj = u.iCert->ValidityBeginLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafValidityEnd) == 0)

        {

        HBufC8* obj = u.iCert->ValidityEndLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)

        {

        HBufC8* obj = u.iCert->SubjectNameLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafSubjectAltName) == 0)

        {

        HBufC8* obj = u.iCert->SubjectAltNameLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)

        {

        HBufC8* obj = u.iCert->KeyUriLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyId) == 0)

        {

        HBufC8* obj = u.iCert->KeyIdLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyUsage) == 0)

        {

        HBufC8* obj = u.iCert->KeyUsageLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else

        {

        DEBUG_LOG(_L("No match found"));        

        User::Leave(KErrNotFound);

        }

    aObject = object;

    }

void CDmAdRtNodeData::FetchLeafObjectCertReqLC(const TDesC8& aUri, const TDesC8& /*aLuid*/, CBufBase*& aObject)

    {

    CBufBase* object = CBufFlat::NewL(32);

    CleanupStack::PushL(object);

    TPtrC8 lastSeg = TDmAdUtil::LastUriSeg(aUri);

    if (lastSeg.Compare(KDmAdLeafSubjectName) == 0)

        {

        TPtrC8 obj(u.iCertReq->SubjectName());

        object->InsertL(0, obj);

        }

    else if (lastSeg.Compare(KDmAdLeafRfc822Name) == 0)

        {

        TPtrC8 obj(u.iCertReq->Rfc822Name());

        object->InsertL(0, obj);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyURI) == 0)

        {

        HBufC8* obj = u.iCertReq->KeyUriL();

        CleanupStack::PushL(obj);

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(obj);

        }

    else if (lastSeg.Compare(KDmAdLeafKeyLength) == 0)

        {

        HBufC8* obj = u.iCertReq->KeyLengthLC();

        object->InsertL(0, *obj);

        CleanupStack::PopAndDestroy(); //obj

        }

    else if (lastSeg.Compare(KDmAdLeafContent) == 0)

        {

        TPtrC8 obj(u.iCertReq->Content());

        object->InsertL(0, obj);

        }