|
1 /* |
|
2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Implementation of CDmAdCertReq. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "dmadstorecertreq.h" |
|
20 #include "vpnlogger.h" |
|
21 #include "base64.h" |
|
22 #include "dmadutil.h" |
|
23 |
|
24 CDmAdCertReq* CDmAdCertReq::NewL(RPKIServiceAPI& aPkiServiceApi, MDmAdCallBack* aDmAdCallBack) |
|
25 { |
|
26 TRACE("CDmAdCertReq::NewL"); |
|
27 |
|
28 CDmAdCertReq* self = NewLC(aPkiServiceApi, aDmAdCallBack); |
|
29 CleanupStack::Pop(self); |
|
30 return self; |
|
31 } |
|
32 |
|
33 CDmAdCertReq* CDmAdCertReq::NewLC(RPKIServiceAPI& aPkiServiceApi, MDmAdCallBack* aDmAdCallBack) |
|
34 { |
|
35 CDmAdCertReq* self = new (ELeave) CDmAdCertReq(aPkiServiceApi, aDmAdCallBack); |
|
36 CleanupStack::PushL(self); |
|
37 return self; |
|
38 } |
|
39 |
|
40 CDmAdCertReq::CDmAdCertReq(RPKIServiceAPI& aPkiServiceApi, MDmAdCallBack* aDmAdCallBack) : |
|
41 iPkiServiceApi(&aPkiServiceApi), |
|
42 iDmAdCallBack(aDmAdCallBack) |
|
43 { |
|
44 TRACE("CDmAdCertReq::CDmAdCertReq"); |
|
45 } |
|
46 |
|
47 CDmAdCertReq::~CDmAdCertReq() |
|
48 { |
|
49 TRACE("CDmAdCertReq::~CDmAdCertReq"); |
|
50 } |
|
51 |
|
52 TBool CDmAdCertReq::FindL(const TDesC8& aLuid) |
|
53 { |
|
54 TRACE("CDmAdCertReq::FindL"); |
|
55 |
|
56 TBool found = EFalse; |
|
57 HBufC* certReqRef = LuidToCertReqRefL(aLuid); |
|
58 CleanupStack::PushL(certReqRef); |
|
59 |
|
60 const TInt KDmAdMaxCertReqSize = 4096; // ???????? |
|
61 HBufC8* certRequest = HBufC8::NewLC(KDmAdMaxCertReqSize); |
|
62 TPtr8 certRequestPtr(certRequest->Des()); |
|
63 |
|
64 |
|
65 TInt status = iPkiServiceApi->ReadCertificateRequest(*certReqRef, |
|
66 certRequestPtr); |
|
67 if (status == KErrNone) |
|
68 { |
|
69 found = ETrue; |
|
70 } |
|
71 CleanupStack::PopAndDestroy(2); //certRequest, certReqRef |
|
72 return found; |
|
73 } |
|
74 |
|
75 |
|
76 HBufC8* CDmAdCertReq::AddL(const CDmAdCertReqParms& aParms) |
|
77 { |
|
78 TRACE("CDmAdCertReq::AddL"); |
|
79 |
|
80 const TInt KDmAdMaxCertReqRefLth = KMaxFileName; |
|
81 HBufC* certReqRef = HBufC::NewLC(KDmAdMaxCertReqRefLth); |
|
82 TPtr certReqRefPtr(certReqRef->Des()); |
|
83 |
|
84 TPKIKeyIdentifier keyIdentifier(aParms.KeyIdentifierByUri()); |
|
85 if (keyIdentifier.Length() == 0) |
|
86 { |
|
87 CreateKeypairL(EPKIRSA, |
|
88 aParms.KeyLength(), |
|
89 keyIdentifier); |
|
90 } |
|
91 |
|
92 DEBUG_LOG(_L("Key ID:")); |
|
93 DEBUG_LOG_HEX(keyIdentifier); |
|
94 |
|
95 SetKeyIDMappingL(keyIdentifier); |
|
96 |
|
97 TInt certReqSize; |
|
98 iPkiServiceApi->CreateAndSaveCertificateRequestL(keyIdentifier, |
|
99 aParms.SubjectName(), //aDistinguishedName, |
|
100 aParms.Rfc822Name(), //aSubjectAltNameRfc822, |
|
101 KNullDesC8, //aChallengePassword, |
|
102 KNullDesC8, //aDnsName, |
|
103 certReqRefPtr, |
|
104 certReqSize); |
|
105 |
|
106 HBufC8* luid = CertReqRefToLuidL(*certReqRef); |
|
107 CleanupStack::PopAndDestroy(certReqRef); |
|
108 return luid; |
|
109 } |
|
110 |
|
111 void CDmAdCertReq::SetKeyIDMappingL(const TPKIKeyIdentifier& keyIdentifier) |
|
112 { |
|
113 TRACE("CDmAdCertReq::SetKeyIDMapping"); |
|
114 |
|
115 // First fetch all private key URIs |
|
116 CBufBase* uriList = CBufFlat::NewL(16); |
|
117 CleanupStack::PushL(uriList); |
|
118 _LIT8(KKeyUri, "NokiaPKI/PrivKey"); |
|
119 MSmlDmAdapter::TError status; |
|
120 iDmAdCallBack->FetchLinkL(KKeyUri, *uriList, status); |
|
121 User::LeaveIfError(status); |
|
122 |
|
123 // Find out key URI (cli<X>) for the newly created private key |
|
124 CArrayFix<TPtrC8>* uriSegList; |
|
125 TDmAdUtil::ParseUriLC(uriList->Ptr(0), uriSegList); |
|
126 // New key URI (cli<X>) is now in uriSegList->At(0) |
|
127 HBufC8* wholeUri = TDmAdUtil::BuildUriLC(KKeyUri, uriSegList->At(0)); |
|
128 |
|
129 iDmAdCallBack->SetMappingL(*wholeUri, keyIdentifier); |
|
130 |
|
131 CleanupStack::PopAndDestroy(wholeUri); |
|
132 CleanupStack::PopAndDestroy(uriSegList); |
|
133 CleanupStack::PopAndDestroy(uriList); |
|
134 } |
|
135 |
|
136 void CDmAdCertReq::UpdateL(const TDesC8& /*aLuid*/, const CDmAdCertReqParms& /*aParms*/) |
|
137 { |
|
138 TRACE("CDmAdCertReq::UpdateL"); |
|
139 DEBUG_LOG(_L("Method not implemented")); |
|
140 |
|
141 User::Leave(KErrGeneral); |
|
142 } |
|
143 |
|
144 void CDmAdCertReq::FetchL(const TDesC8& aLuid, CDmAdCertReqParms& aParms) |
|
145 { |
|
146 TRACE("CDmAdCertReq::FetchL"); |
|
147 |
|
148 HBufC* certReqRef = LuidToCertReqRefL(aLuid); |
|
149 CleanupStack::PushL(certReqRef); |
|
150 |
|
151 const TInt KDmAdMaxCertReqSize = 4096; // ???????? |
|
152 HBufC8* certRequest = HBufC8::NewLC(KDmAdMaxCertReqSize); |
|
153 TPtr8 certRequestPtr(certRequest->Des()); |
|
154 |
|
155 User::LeaveIfError(iPkiServiceApi->ReadCertificateRequest(*certReqRef, |
|
156 certRequestPtr)); |
|
157 |
|
158 TBase64Codec base64Codec; |
|
159 HBufC8* certRequestB64Decoded; |
|
160 if ((certRequestB64Decoded = base64Codec.Base64DecodeLC(*certRequest)) == NULL) |
|
161 { |
|
162 DEBUG_LOG(_L("base64Codec.Base64DecodeLC returned NULL")); |
|
163 User::Leave(KErrNoMemory); |
|
164 } |
|
165 |
|
166 aParms.SetContentL(*certRequestB64Decoded); |
|
167 //ReadCertReqDetailsL(*certReqRef, aParms); // ??????????? |
|
168 CleanupStack::PopAndDestroy(3); // certRequestB64Decoded, certRequest, certReqRef |
|
169 } |
|
170 |
|
171 |
|
172 void CDmAdCertReq::DeleteL(const TDesC8& aLuid) |
|
173 { |
|
174 TRACE("CDmAdCertReq::DeleteL"); |
|
175 |
|
176 HBufC* certReqRef = LuidToCertReqRefL(aLuid); |
|
177 CleanupStack::PushL(certReqRef); |
|
178 |
|
179 User::LeaveIfError(iPkiServiceApi->DeleteCertificateRequest(*certReqRef)); |
|
180 |
|
181 CleanupStack::PopAndDestroy(certReqRef); |
|
182 } |
|
183 |
|
184 |
|
185 void CDmAdCertReq::ListL(RPointerArray<HBufC8>& aLuidList) |
|
186 { |
|
187 TRACE("CDmAdCertReq::ListL"); |
|
188 |
|
189 CArrayFix<TCertificateRequestListEntry>* certReqList; |
|
190 iPkiServiceApi->ListCertificateRequestsL(certReqList); |
|
191 CleanupStack::PushL(certReqList); |
|
192 |
|
193 for (TInt i=0; i<certReqList->Count(); ++i) |
|
194 { |
|
195 TCertificateRequestListEntry& entry = certReqList->At(i); |
|
196 HBufC8* luid = CertReqRefToLuidL(entry.iObjectName); |
|
197 CleanupStack::PushL(luid); |
|
198 aLuidList.AppendL(luid); |
|
199 CleanupStack::Pop(luid); |
|
200 } |
|
201 |
|
202 CleanupStack::PopAndDestroy(certReqList); |
|
203 } |
|
204 |
|
205 void CDmAdCertReq::CreateKeypairL(TPKIKeyAlgorithm aKeyAlgorithm, |
|
206 TInt aKeyLength, |
|
207 TPKIKeyIdentifier& aKeyIdentifier) |
|
208 { |
|
209 TRACE("CDmAdCertReq::CreateKeypairL"); |
|
210 |
|
211 TRequestStatus requestStatus; |
|
212 iPkiServiceApi->GenerateKeypair(aKeyIdentifier, |
|
213 (TUint)aKeyLength, |
|
214 aKeyAlgorithm, |
|
215 requestStatus); |
|
216 User::WaitForRequest(requestStatus); |
|
217 TInt status = requestStatus.Int(); |
|
218 if (status != KErrNone) |
|
219 { |
|
220 DEBUG_LOG1(_L("GenerateKeypairL returned %d"), status); |
|
221 User::Leave(status); |
|
222 } |
|
223 } |
|
224 |
|
225 HBufC8* CDmAdCertReq::CertReqRefToLuidL(const TDesC& aCertReqRef) |
|
226 { |
|
227 TRACE("CDmAdCertReq::CertReqRefToLuidL"); |
|
228 |
|
229 HBufC8* luid = HBufC8::NewL(aCertReqRef.Length() * 2); |
|
230 luid->Des().Copy((const TUint8*)aCertReqRef.Ptr(), aCertReqRef.Length() * 2); |
|
231 return luid; |
|
232 } |
|
233 |
|
234 HBufC* CDmAdCertReq::LuidToCertReqRefL(const TDesC8& aLuid) |
|
235 { |
|
236 TRACE("CDmAdCertReq::LuidToCertReqRefL"); |
|
237 |
|
238 HBufC* certReqRef = HBufC::NewL(aLuid.Length() / 2); |
|
239 certReqRef->Des().Copy((const TUint16*)aLuid.Ptr(), aLuid.Length() / 2); |
|
240 return certReqRef; |
|
241 } |