diff -r 000000000000 -r 33413c0669b9 vpnengine/dmadpki/src/dmadstorecertreq.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/dmadpki/src/dmadstorecertreq.cpp	Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,241 @@
+/*
+* 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 CDmAdCertReq.
+*
+*/
+
+
+#include "dmadstorecertreq.h"
+#include "vpnlogger.h"
+#include "base64.h"
+#include "dmadutil.h"
+
+CDmAdCertReq* CDmAdCertReq::NewL(RPKIServiceAPI& aPkiServiceApi, MDmAdCallBack* aDmAdCallBack)
+    {
+    TRACE("CDmAdCertReq::NewL");
+    
+    CDmAdCertReq* self = NewLC(aPkiServiceApi, aDmAdCallBack);
+    CleanupStack::Pop(self); 
+    return self;
+    }
+
+CDmAdCertReq* CDmAdCertReq::NewLC(RPKIServiceAPI& aPkiServiceApi, MDmAdCallBack* aDmAdCallBack)
+    {
+    CDmAdCertReq* self = new (ELeave) CDmAdCertReq(aPkiServiceApi, aDmAdCallBack);
+    CleanupStack::PushL(self);
+    return self;
+    }
+
+CDmAdCertReq::CDmAdCertReq(RPKIServiceAPI& aPkiServiceApi, MDmAdCallBack* aDmAdCallBack) : 
+    iPkiServiceApi(&aPkiServiceApi),
+    iDmAdCallBack(aDmAdCallBack)
+    {
+    TRACE("CDmAdCertReq::CDmAdCertReq");
+    }
+    
+CDmAdCertReq::~CDmAdCertReq()
+    {
+    TRACE("CDmAdCertReq::~CDmAdCertReq");
+    }
+    
+TBool CDmAdCertReq::FindL(const TDesC8& aLuid)
+    {
+    TRACE("CDmAdCertReq::FindL");
+    
+    TBool found = EFalse;
+    HBufC* certReqRef = LuidToCertReqRefL(aLuid);
+    CleanupStack::PushL(certReqRef);
+    
+    const TInt KDmAdMaxCertReqSize = 4096; // ????????
+    HBufC8* certRequest = HBufC8::NewLC(KDmAdMaxCertReqSize);
+    TPtr8 certRequestPtr(certRequest->Des());
+    
+
+    TInt status = iPkiServiceApi->ReadCertificateRequest(*certReqRef,
+                                                         certRequestPtr);
+    if (status == KErrNone)
+        {
+        found = ETrue;
+        }
+    CleanupStack::PopAndDestroy(2); //certRequest, certReqRef
+    return found;
+    }
+    
+    
+HBufC8* CDmAdCertReq::AddL(const CDmAdCertReqParms& aParms)
+    {
+    TRACE("CDmAdCertReq::AddL");
+    
+    const TInt KDmAdMaxCertReqRefLth = KMaxFileName;
+    HBufC* certReqRef = HBufC::NewLC(KDmAdMaxCertReqRefLth);
+    TPtr certReqRefPtr(certReqRef->Des());
+
+    TPKIKeyIdentifier keyIdentifier(aParms.KeyIdentifierByUri());
+    if (keyIdentifier.Length() == 0)
+        {        
+        CreateKeypairL(EPKIRSA,
+                       aParms.KeyLength(),
+                       keyIdentifier);        
+        }
+        
+    DEBUG_LOG(_L("Key ID:"));            
+    DEBUG_LOG_HEX(keyIdentifier);
+    
+    SetKeyIDMappingL(keyIdentifier);
+    
+    TInt certReqSize;
+    iPkiServiceApi->CreateAndSaveCertificateRequestL(keyIdentifier,
+                                                     aParms.SubjectName(), //aDistinguishedName,
+                                                     aParms.Rfc822Name(), //aSubjectAltNameRfc822,       
+                                                     KNullDesC8, //aChallengePassword,
+                                                     KNullDesC8, //aDnsName,
+                                                     certReqRefPtr,
+                                                     certReqSize);
+
+    HBufC8* luid = CertReqRefToLuidL(*certReqRef);
+    CleanupStack::PopAndDestroy(certReqRef); 
+    return luid;
+    }
+
+void CDmAdCertReq::SetKeyIDMappingL(const TPKIKeyIdentifier& keyIdentifier)
+    {
+    TRACE("CDmAdCertReq::SetKeyIDMapping");
+
+    // First fetch all private key URIs
+    CBufBase* uriList = CBufFlat::NewL(16);
+    CleanupStack::PushL(uriList);
+    _LIT8(KKeyUri, "NokiaPKI/PrivKey");
+    MSmlDmAdapter::TError status;
+    iDmAdCallBack->FetchLinkL(KKeyUri, *uriList, status);    
+    User::LeaveIfError(status);
+    
+    // Find out key URI (cli<X>) for the newly created private key
+    CArrayFix<TPtrC8>* uriSegList;
+    TDmAdUtil::ParseUriLC(uriList->Ptr(0), uriSegList);
+    // New key URI (cli<X>) is now in uriSegList->At(0)
+    HBufC8* wholeUri = TDmAdUtil::BuildUriLC(KKeyUri, uriSegList->At(0));
+    
+    iDmAdCallBack->SetMappingL(*wholeUri, keyIdentifier);
+    
+    CleanupStack::PopAndDestroy(wholeUri);
+    CleanupStack::PopAndDestroy(uriSegList);
+    CleanupStack::PopAndDestroy(uriList);
+    }
+
+void CDmAdCertReq::UpdateL(const TDesC8& /*aLuid*/, const CDmAdCertReqParms& /*aParms*/)
+    {
+    TRACE("CDmAdCertReq::UpdateL");    
+    DEBUG_LOG(_L("Method not implemented"));
+    
+    User::Leave(KErrGeneral);
+    }
+    
+void CDmAdCertReq::FetchL(const TDesC8& aLuid, CDmAdCertReqParms& aParms)
+    {
+    TRACE("CDmAdCertReq::FetchL");
+    
+    HBufC* certReqRef = LuidToCertReqRefL(aLuid);
+    CleanupStack::PushL(certReqRef);
+    
+    const TInt KDmAdMaxCertReqSize = 4096; // ????????
+    HBufC8* certRequest = HBufC8::NewLC(KDmAdMaxCertReqSize);
+    TPtr8 certRequestPtr(certRequest->Des());
+    
+    User::LeaveIfError(iPkiServiceApi->ReadCertificateRequest(*certReqRef,
+                                                              certRequestPtr));
+
+    TBase64Codec base64Codec;
+    HBufC8* certRequestB64Decoded;
+    if ((certRequestB64Decoded = base64Codec.Base64DecodeLC(*certRequest)) == NULL)
+        {
+        DEBUG_LOG(_L("base64Codec.Base64DecodeLC returned NULL"));        
+        User::Leave(KErrNoMemory);
+        }
+
+    aParms.SetContentL(*certRequestB64Decoded);
+    //ReadCertReqDetailsL(*certReqRef, aParms); // ???????????
+    CleanupStack::PopAndDestroy(3); // certRequestB64Decoded, certRequest, certReqRef
+    }
+    
+    
+void CDmAdCertReq::DeleteL(const TDesC8& aLuid)
+    {
+    TRACE("CDmAdCertReq::DeleteL");
+    
+    HBufC* certReqRef = LuidToCertReqRefL(aLuid);
+    CleanupStack::PushL(certReqRef);
+   
+    User::LeaveIfError(iPkiServiceApi->DeleteCertificateRequest(*certReqRef));
+
+    CleanupStack::PopAndDestroy(certReqRef);
+    }
+
+
+void CDmAdCertReq::ListL(RPointerArray<HBufC8>& aLuidList)
+    {
+    TRACE("CDmAdCertReq::ListL");
+    
+    CArrayFix<TCertificateRequestListEntry>* certReqList;
+    iPkiServiceApi->ListCertificateRequestsL(certReqList);
+    CleanupStack::PushL(certReqList);
+
+    for (TInt i=0; i<certReqList->Count(); ++i)
+        {
+        TCertificateRequestListEntry& entry = certReqList->At(i);
+        HBufC8* luid = CertReqRefToLuidL(entry.iObjectName);
+        CleanupStack::PushL(luid);
+        aLuidList.AppendL(luid);        
+        CleanupStack::Pop(luid);
+        }
+    
+    CleanupStack::PopAndDestroy(certReqList); 
+    }
+
+void CDmAdCertReq::CreateKeypairL(TPKIKeyAlgorithm      aKeyAlgorithm,
+                                  TInt                  aKeyLength,
+                                  TPKIKeyIdentifier&    aKeyIdentifier)
+    {
+    TRACE("CDmAdCertReq::CreateKeypairL");
+    
+    TRequestStatus requestStatus;
+    iPkiServiceApi->GenerateKeypair(aKeyIdentifier,
+                                    (TUint)aKeyLength,
+                                    aKeyAlgorithm,
+                                    requestStatus);
+    User::WaitForRequest(requestStatus);
+    TInt status = requestStatus.Int();
+    if (status != KErrNone)
+        {
+        DEBUG_LOG1(_L("GenerateKeypairL returned %d"), status);        
+        User::Leave(status);
+        }
+    }
+
+HBufC8* CDmAdCertReq::CertReqRefToLuidL(const TDesC& aCertReqRef)
+    {
+    TRACE("CDmAdCertReq::CertReqRefToLuidL");
+    
+    HBufC8* luid = HBufC8::NewL(aCertReqRef.Length() * 2);
+    luid->Des().Copy((const TUint8*)aCertReqRef.Ptr(), aCertReqRef.Length() * 2);
+    return luid;
+    }
+    
+HBufC* CDmAdCertReq::LuidToCertReqRefL(const TDesC8& aLuid)
+    {
+    TRACE("CDmAdCertReq::LuidToCertReqRefL");
+    
+    HBufC* certReqRef = HBufC::NewL(aLuid.Length() / 2);
+    certReqRef->Des().Copy((const TUint16*)aLuid.Ptr(), aLuid.Length() / 2);
+    return certReqRef;
+    }