/*
* 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;
}