/*
* Copyright (c) 2002 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 CDmAdCert.
*
*/


#include "dmadutil.h"
#include "dmadstorecert.h"
#include "vpnlogger.h"
#include "dmadcertxmldefs.h"
#include "XppImpl.h"
#include "XwImpl.h"
#include <vpnlogmessages.rsg>

CDmAdCert* CDmAdCert::NewL(RPKIServiceAPI& aPkiServiceApi)
    {
    TRACE("CDmAdCert::NewL");
    
    CDmAdCert* self = NewLC(aPkiServiceApi);
    CleanupStack::Pop(self);
    return self;
    }

CDmAdCert* CDmAdCert::NewLC(RPKIServiceAPI& aPkiServiceApi)
    {
    CDmAdCert* self = new (ELeave) CDmAdCert(aPkiServiceApi);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

void CDmAdCert::ConstructL()
    {
    TRACE("CDmAdCert::ConstructL");
    iCertLuidMapping = new (ELeave) CArrayPtrFlat<CDmAdCertLuidMappingElem>(4);
    BuildCertLuidMappingTableL();
    }
    
CDmAdCert::CDmAdCert(RPKIServiceAPI& aPkiServiceApi) : iPkiServiceApi(&aPkiServiceApi)
    {
    }
    
CDmAdCert::~CDmAdCert()
    {
    TRACE("CDmAdCert::~CDmAdCert");
    CDmAdCertLuidMappingElem::CleanupOperationDeleteCArrayPtr(iCertLuidMapping);    
    }
    
TBool CDmAdCert::FindL(const TDesC8& aLuid)
    {
    TRACE("CDmAdCert::FindL");
    if (!FindCertLuidMappingElemL(aLuid))
        {
        return EFalse;
        }
    else
        {
        return ETrue;
        }
    }
    
HBufC8* CDmAdCert::AddL(const CDmAdCertParms& aParms)
    {    
    TRACE("CDmAdCert::AddL");
    
    TPKICertificateOwnerType ownerType = aParms.Type();

    HBufC8* certRef = BuildCertRefL(aParms.Content(), EFalse);
    CleanupStack::PushL(certRef);
    CDmAdCertLuidMappingElem* certLuidMappingElem = FindCertLuidMappingElemL(*certRef);
    if (certLuidMappingElem)
        {
        DEBUG_LOG(_L("Element already exists"));
        User::Leave(KErrAlreadyExists);
        }
    CleanupStack::PopAndDestroy(certRef); 
    

    TInt status = KErrNone;
    if (ownerType == EPKIUserCertificate)
        {
        DEBUG_LOG(_L("Attaching user certificate"));        
        
        TKeyListEntry* keyListEntry = new (ELeave) TKeyListEntry;
        CleanupStack::PushL(keyListEntry);
        
        TPKIKeyIdentifier keyId = aParms.KeyId();
        DEBUG_LOG(_L("Key id:"));
        DEBUG_LOG_HEX(keyId);
        
        
        User::LeaveIfError(iPkiServiceApi->KeyDetails(keyId,
						   *keyListEntry));
        
        TInt keyLength = keyListEntry->iKeySize;
        
        DEBUG_LOG(_L("Key info:"));
        DEBUG_LOG1(_L("Object name: %S"), &(keyListEntry->iObjectName));
        DEBUG_LOG_HEX(keyListEntry->iSubjectKeyId);
        DEBUG_LOG1(_L("Key size: %d"), keyListEntry->iKeySize);
        DEBUG_LOG1(_L("Algorithm: %d"), keyListEntry->iKeyAlgorithm);

        
        
        CleanupStack::PopAndDestroy(); //keyListEntry
        
        status = iPkiServiceApi->AttachCertificate(keyId,
                                                   aParms.Deletable(),
                                                   keyLength,
                                                   EPKIRSA,
                                                   aParms.Content());
        }
    else
        {
        status = iPkiServiceApi->StoreCertificate(ownerType,
                                                  aParms.Deletable(),
                                                  0, //Key length is undefined
                                                  EPKIRSA,
                                                  aParms.Content());            
        }

    if (status != KErrNone)
        {
        DEBUG_LOG1(_L("Operation failed with %d"), status);       
        User::Leave(status);
        }

    certRef = BuildCertRefL(aParms.Content(), ETrue);
    CleanupStack::PushL(certRef);
    UpdateL(*certRef, aParms);
    CleanupStack::Pop(certRef);
    return certRef;
    }

void CDmAdCert::UpdateL(const TDesC8& aLuid, const CDmAdCertParms& aParms)
    {
    TRACE("CDmAdCert::UpdateL");
    HBufC8* issuerName;
    HBufC8* serialNumber;
    GetIssuerAndSerialFromCertRefLC(aLuid, issuerName, serialNumber);

    if (aParms.Type() == EPKICACertificate) // CA cert
        {
        UpdateTrustedL(*issuerName, *serialNumber, aParms);
        UpdateApplicabilityL(*issuerName, *serialNumber, aParms);
        }
    
    CleanupStack::PopAndDestroy(2); //serialNumber, issuerName
    }
    
void CDmAdCert::FetchL(const TDesC8& aLuid, CDmAdCertParms& aParms)
    {
    TRACE("CDmAdCert::FetchL");
    HBufC8* issuerName;
    HBufC8* serialNumber;
    GetIssuerAndSerialFromCertRefLC(aLuid, issuerName, serialNumber);
    
    //TInt certSize = 1024;
    TInt certSize = 4096;
    HBufC8* certBuf = NULL;
    TPtr8 certBufDesc(NULL, 0);
    TBool errBufferTooShortOccurred = EFalse;
    for (;;)
        {
        if (certBuf)
            {
            CleanupStack::PopAndDestroy(certBuf);
            }
        certBuf = HBufC8::NewLC(certSize);
        certBufDesc.Set(certBuf->Des());
    
        // Both user and device certificate stores needs to be used for
        // certificate reading. Set certificate store type to STORETYPE_ANY.
        TPkiServiceStoreType certStoreType(EPkiStoreTypeAny);
        User::LeaveIfError(iPkiServiceApi->CertStoreType(certStoreType));
        User::LeaveIfError(iPkiServiceApi->SetStoreType(STORE_CERTSTORE, EPkiStoreTypeAny));        
        TInt err = iPkiServiceApi->ReadCertificate(*issuerName,
                                                   *serialNumber,
                                                   certBufDesc);
                
        // Set previous store type back
        User::LeaveIfError(iPkiServiceApi->SetStoreType(STORE_CERTSTORE, certStoreType));                
        
        if (err == KErrNone)
            {
            break;
            }
        else if (err == KPKIErrBufferTooShort)
            {
            if (errBufferTooShortOccurred)
                {
                DEBUG_LOG(_L("Buffer too short"));                
                User::Leave(KErrGeneral);
                }
            errBufferTooShortOccurred = ETrue;
            User::LeaveIfError(iPkiServiceApi->GetRequiredBufferSize(certSize));
            }
        else
            {
            DEBUG_LOG1(_L("Fetch failed with %d"), err);            
            User::Leave(err);
            }
        }

    aParms.SetContentL(*certBuf);
    ReadCertDetailsL(*issuerName, *serialNumber, aParms);

    CleanupStack::PopAndDestroy(3); //certBuf, serialNumber, issuerName
    }
    
void CDmAdCert::DeleteL(const TDesC8& aLuid)
    {
    TRACE("CDmAdCert::DeleteL");
    HBufC8* issuerName;
    HBufC8* serialNumber;
    GetIssuerAndSerialFromCertRefLC(aLuid, issuerName, serialNumber);
    while (FindCertLuidMappingElemL(aLuid))
        {
        User::LeaveIfError(iPkiServiceApi->RemoveCertificate(*issuerName,
                                                             *serialNumber));
        
        RemoveCertLuidMappingElem(aLuid);
        }
    CleanupStack::PopAndDestroy(2); //serialNumber, issuerName
    }

void CDmAdCert::ListL(RPointerArray<HBufC8>& aLuidList)
    {
    TRACE("CDmAdCert::ListL");
    for (TInt i=0; i<iCertLuidMapping->Count(); ++i)
        {
        CDmAdCertLuidMappingElem* certLuidMappingElem = iCertLuidMapping->At(i);
                
        HBufC8* luidElem = certLuidMappingElem->Luid().AllocLC();
        aLuidList.AppendL(luidElem);
        CleanupStack::Pop(luidElem);
        }
    }
    
//------------------------------------------------------------------------

void CDmAdCert::ReadCertDetailsL(const TDesC8& aIssuerName, const TDesC8& aSerialNumber, CDmAdCertParms& aParms)
    {
    TRACE("CDmAdCert::ReadCertDetailsL");
    TCertificateListEntry* entry = new (ELeave) TCertificateListEntry();
    CleanupStack::PushL(entry);
    
    User::LeaveIfError(iPkiServiceApi->CertificateDetails(aIssuerName,
                                                          aSerialNumber,
                                                          *entry)); 
    
    aParms.SetType(entry->iOwnerType);    
    aParms.SetDeletable(entry->iIsDeletable);
       
    TBool trusted = ETrue;
    if (entry->iOwnerType == EPKICACertificate) // CA cert
        {
        User::LeaveIfError(iPkiServiceApi->Trusted(aIssuerName,
                                                   aSerialNumber,
                                                   trusted));        
        }
    aParms.SetTrusted(trusted);

    if (entry->iOwnerType == EPKICACertificate) // CA cert
        {
        RArray<TUid> applications;
        CleanupClosePushL(applications);
        
        iPkiServiceApi->ApplicationsL(aIssuerName,
                                      aSerialNumber,
                                      applications);
        aParms.SetApplicabilityL(applications);                                      
        CleanupStack::PopAndDestroy(); //applications
        }    
        
    CleanupStack::PopAndDestroy(); // entry        
    }
    
void CDmAdCert::UpdateTrustedL(const TDesC8& aIssuerName, const TDesC8& aSerialNumber, const CDmAdCertParms& aParms)
    {
    TRACE("CDmAdCert::UpdateTrustedL");
    
    User::LeaveIfError(iPkiServiceApi->SetTrust(aIssuerName,
                                                aSerialNumber,
                                                aParms.Trusted()));
    }

void CDmAdCert::UpdateApplicabilityL(const TDesC8& aIssuerName, const TDesC8& aSerialNumber, const CDmAdCertParms& aParms)
    {
    TRACE("CDmAdCert::UpdateApplicabilityL");
    
    const RArray<TUid>& applications = aParms.Applicability();   
    if (applications.Count() > 0)
        {
        iPkiServiceApi->SetApplicabilityL(aIssuerName,
                                          aSerialNumber,
                                          applications);
        }
    }

TPtrC8 CDmAdCert::AppendCertLuidMappingElemL(const TDesC8& aIssuerName, const TDesC8& aSerialNumber)
    {
    TRACE("CDmAdCert::AppendCertLuidMappingElemL");
    TPtrC8 luid(KNullDesC8);
    
    CDmAdCertLuidMappingElem* certLuidMappingElem = CDmAdCertLuidMappingElem::NewLC(aIssuerName, aSerialNumber);
    luid.Set(certLuidMappingElem->Luid());
    
    iCertLuidMapping->AppendL(certLuidMappingElem);
    CleanupStack::Pop(certLuidMappingElem);
    
    return luid;
    }

void CDmAdCert::RemoveCertLuidMappingElem(const TDesC8& aLuid)
    {
    TRACE("CDmAdCert::RemoveCertLuidMappingElem");
    for (TInt i=0; i<iCertLuidMapping->Count(); ++i)
        {
        CDmAdCertLuidMappingElem* certLuidMappingElem = iCertLuidMapping->At(i);
        if (certLuidMappingElem->Luid().Compare(aLuid) == 0)
            {
            iCertLuidMapping->Delete(i);
            i--;
            delete certLuidMappingElem;
            break;
            }
        }
    }

CDmAdCertLuidMappingElem* CDmAdCert::FindCertLuidMappingElemL(const TDesC8& aLuid)
    {
    TRACE("CDmAdCert::FindCertLuidMappingElemL");
    for (TInt i=0; i<iCertLuidMapping->Count(); ++i)
        {
        CDmAdCertLuidMappingElem* certLuidMappingElem = iCertLuidMapping->At(i);
        if (certLuidMappingElem->Luid().Compare(aLuid) == 0)
            {
            return certLuidMappingElem;
            }
        }
    return NULL;
    }

void CDmAdCert::BuildCertLuidMappingTableL()
    {
    TRACE("CDmAdCert::BuildCertLuidMappingTableL");
    CArrayFix<TCertificateListEntry>* certList;
    iPkiServiceApi->ListCertificatesL(certList);
    CleanupStack::PushL(certList);

    for (TInt i=0; i<certList->Count(); ++i)
        {
        TCertificateListEntry& entry = certList->At(i);
        AppendCertLuidMappingElemL(entry.iTrustedAuthority, entry.iSerialNumber);
        }
    
    CleanupStack::PopAndDestroy(certList); 
    }

HBufC8* CDmAdCert::BuildCertRefL(const TDesC8& aCertificateDer, TBool aAppend)
    {
    TRACE("CDmAdCert::BuildCertRefL");
    
    CX509Certificate* certCx509 = CX509Certificate::NewL(aCertificateDer);
    CleanupStack::PushL(certCx509);

    const TPtrC8 issuerName(*(certCx509->DataElementEncoding(CX509Certificate::EIssuerName)));
    const TPtrC8 serialNumber(*(certCx509->DataElementEncoding(CX509Certificate::ESerialNumber)));

    HBufC8* certRef = 0;
    if (aAppend)
        {
        TPtrC8 luid(AppendCertLuidMappingElemL(issuerName, serialNumber));
        certRef = luid.AllocL();
        }
    else
        {
        certRef = CDmAdCertLuidMappingElem::BuildLuidL(issuerName, serialNumber);
        }

    CleanupStack::PopAndDestroy(certCx509);
    return certRef;
    }

void CDmAdCert::GetIssuerAndSerialFromCertRefLC(const TDesC8&  aCertRef,
                                                HBufC8*&       aIssuerName,
                                                HBufC8*&       aSerialNumber)
    {
    CDmAdCertLuidMappingElem* certLuidMappingElem = FindCertLuidMappingElemL(aCertRef);
    if (!certLuidMappingElem)
        {
        DEBUG_LOG(_L("Mapping not found"));        
        User::Leave(KErrNotFound);
        }

    HBufC8* issuerNameHBuf = certLuidMappingElem->IssuerName().AllocLC();
    HBufC8* serialNumberHBuf = certLuidMappingElem->SerialNumber().AllocLC();
    
    aIssuerName = issuerNameHBuf;
    aSerialNumber = serialNumberHBuf;
    }

HBufC8* CDmAdCert::CertSubjectNameL(const TDesC8& aCertificateDer)
    {
    CX509Certificate* certCx509 = CX509Certificate::NewLC(aCertificateDer);
    HBufC16* subjectName16 = certCx509->SubjectName().DisplayNameL();
    CleanupStack::PushL(subjectName16);    
    HBufC8* subjectName8 = HBufC8::NewL(subjectName16->Length());
    subjectName8->Des().Copy(*subjectName16);
    CleanupStack::PopAndDestroy(2, certCx509);
    return subjectName8;
    }