|
1 /* |
|
2 * Copyright (c) 2006-2008 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: |
|
15 * A server side session object. Owns instances of the CPKIService |
|
16 * and CPKIWrapper classes. All requests to the service objects go |
|
17 * through this object. |
|
18 * |
|
19 */ |
|
20 |
|
21 |
|
22 |
|
23 #include "pkisession.h" |
|
24 #include "pkiservice.h" |
|
25 #include "PKIMapper.h" |
|
26 #include "pkiwrapper.h" |
|
27 #include "certificaterequeststore.h" |
|
28 #include "keyoperationqueue.h" |
|
29 #include "pkiserviceconstants.h" |
|
30 |
|
31 #include "log_r6.h" |
|
32 #include "pkiserviceassert.h" |
|
33 |
|
34 static const TInt KBufferSizeNotDefined = -1; |
|
35 |
|
36 CPKISession* CPKISession::NewL(CPKIService& aServer, |
|
37 CPKIMapper& aMapper, |
|
38 CKeyOperationQueue& aKeyOperationQueue) |
|
39 { |
|
40 CPKISession* self; |
|
41 self = new (ELeave) CPKISession(aServer, aMapper, aKeyOperationQueue); |
|
42 CleanupStack::PushL( self ); |
|
43 self->ConstructL(); |
|
44 CleanupStack::Pop(); |
|
45 return self; |
|
46 } |
|
47 |
|
48 |
|
49 CPKISession::CPKISession(CPKIService& aServer, CPKIMapper& aMapper, CKeyOperationQueue& aKeyOperationQueue) |
|
50 :iServer(aServer), iMapper(aMapper), |
|
51 iKeyOperationQueue(aKeyOperationQueue), iRequiredBufferSize(KBufferSizeNotDefined) |
|
52 { |
|
53 } |
|
54 |
|
55 |
|
56 void CPKISession::ConstructL() |
|
57 { |
|
58 LOG_("-> CPKISession::ConstructL()"); |
|
59 iWrapper = CPKIWrapper::NewL(iMapper); |
|
60 LOG_("<- CPKISession::ConstructL()"); |
|
61 } |
|
62 |
|
63 /**--------------------------------------------------------- |
|
64 * |
|
65 * ~CPKISession(void) |
|
66 * |
|
67 *----------------------------------------------------------*/ |
|
68 CPKISession::~CPKISession(void) |
|
69 { |
|
70 LOG_("-> CPKISession::~CPKISession()"); |
|
71 |
|
72 delete iKeyList; |
|
73 delete iWrapper; |
|
74 iUidArray.Close(); |
|
75 |
|
76 iServer.SessionDeleted(); |
|
77 LOG_("<- CPKISession::~CPKISession()"); |
|
78 } |
|
79 |
|
80 |
|
81 /**--------------------------------------------------------- |
|
82 * |
|
83 * ServiceL(const RMessage& aMessage) |
|
84 * |
|
85 *----------------------------------------------------------*/ |
|
86 void CPKISession::ServiceL(const RMessage2& aMessage) |
|
87 { |
|
88 TInt Status = KErrNone; |
|
89 TInt count = 0; |
|
90 |
|
91 LOG_1("CPKISession::ServiceL: function = %d", aMessage.Function()); |
|
92 |
|
93 switch(aMessage.Function()) |
|
94 { |
|
95 case PkiService::ECancelPendingOperation: |
|
96 iWrapper->CancelPendingOperation(); |
|
97 aMessage.Complete(Status); |
|
98 break; |
|
99 |
|
100 case PkiService::EGetRequiredBufferSize: |
|
101 if (iRequiredBufferSize == KBufferSizeNotDefined) |
|
102 { |
|
103 Status = iWrapper->GetRequiredBufferSizeL(aMessage); |
|
104 } |
|
105 else |
|
106 { |
|
107 TPckg<TInt> pckgSize(iRequiredBufferSize); |
|
108 aMessage.WriteL(0, pckgSize); |
|
109 aMessage.Complete(KErrNone); |
|
110 } |
|
111 break; |
|
112 |
|
113 case PkiService::ECertCount: |
|
114 count = iMapper.CertCount(); |
|
115 aMessage.Complete(count); // Status <==> count |
|
116 break; |
|
117 |
|
118 case PkiService::EApplicableCertCount: |
|
119 { |
|
120 TInt aC = 0; |
|
121 TPckg<TInt> pckgApplCount(aC); |
|
122 aMessage.ReadL(0, pckgApplCount); |
|
123 |
|
124 // Read applications |
|
125 // Allocate list for applications |
|
126 CBufFlat* list = CBufFlat::NewL(sizeof(TUid)); |
|
127 CleanupStack::PushL(list); |
|
128 list->ResizeL(aC * sizeof(TUid)); |
|
129 TPtr8 ptrList = list->Ptr(0); |
|
130 aMessage.ReadL(1, ptrList); |
|
131 iUidArray.Close(); |
|
132 if(aC > 0) |
|
133 { |
|
134 TUid tempUid; |
|
135 for (TInt i = 0; i < aC; i++) |
|
136 { |
|
137 list->Read(i * sizeof(TUid), (TAny*)&tempUid, sizeof(TUid)); |
|
138 iUidArray.Append(tempUid); |
|
139 } |
|
140 } |
|
141 CleanupStack::PopAndDestroy(1); // list |
|
142 |
|
143 TInt matchCount = iMapper.ApplicableCertCount(iUidArray); |
|
144 aMessage.Complete(matchCount); // Status <==> count |
|
145 } |
|
146 break; |
|
147 case PkiService::EGetCertDetails: |
|
148 Status = iMapper.GetCertListL(aMessage, iWrapper->CertStoreType(), ETrue); |
|
149 aMessage.Complete(Status); |
|
150 break; |
|
151 case PkiService::EGetCertList: |
|
152 iMapper.GetCertListL(aMessage, iWrapper->CertStoreType()); |
|
153 aMessage.Complete(KErrNone); |
|
154 break; |
|
155 |
|
156 case PkiService::EGetApplicableCertList: |
|
157 iMapper.GetApplicableCertListL(aMessage, iUidArray); |
|
158 aMessage.Complete(KErrNone); |
|
159 break; |
|
160 |
|
161 case PkiService::EGetKeyList: |
|
162 { |
|
163 PKISERVICE_ASSERT(iKeyList != NULL); |
|
164 |
|
165 CBufFlat* list = CBufFlat::NewL(sizeof(TKeyListEntry)); |
|
166 CleanupStack::PushL(list); |
|
167 list->ResizeL(iKeyList->Count() * sizeof(TKeyListEntry)); |
|
168 |
|
169 for(TInt i = 0; i < iKeyList->Count(); i++) |
|
170 { |
|
171 const TKeyListEntry& keyInfo = (*iKeyList)[i]; |
|
172 list->Write(i * sizeof(TKeyListEntry), |
|
173 (TAny*)&keyInfo, |
|
174 sizeof(TKeyListEntry)); |
|
175 } |
|
176 TPtr8 ptrList = list->Ptr(0); |
|
177 aMessage.WriteL(0, ptrList); |
|
178 CleanupStack::PopAndDestroy(list); // list |
|
179 |
|
180 delete iKeyList; |
|
181 iKeyList = NULL; |
|
182 aMessage.Complete(KErrNone); |
|
183 } |
|
184 break; |
|
185 |
|
186 case PkiService::ECertReqCount: |
|
187 count = iServer.CertificateRequestStore().CertReqCountL(); |
|
188 aMessage.Complete(count); // Status <==> count |
|
189 break; |
|
190 |
|
191 case PkiService::EGetCertReqList: |
|
192 { |
|
193 CArrayFixFlat<TCertificateRequestListEntry>* certReqList = |
|
194 iServer.CertificateRequestStore().GetCertReqListLC(); |
|
195 |
|
196 TUint bufferGranularity = sizeof(TCertificateRequestListEntry); |
|
197 if (certReqList->Count() > 0) |
|
198 { |
|
199 bufferGranularity = bufferGranularity * certReqList->Count(); |
|
200 } |
|
201 CBufFlat* list = CBufFlat::NewL(bufferGranularity); |
|
202 CleanupStack::PushL(list); |
|
203 |
|
204 if (certReqList->Count() > 0) |
|
205 { |
|
206 list->ResizeL(sizeof(TCertificateRequestListEntry) * certReqList->Count()); |
|
207 } |
|
208 |
|
209 for (TInt i = 0; i < certReqList->Count(); ++i) |
|
210 { |
|
211 const TCertificateRequestListEntry &certReqInfo = (*certReqList)[i]; |
|
212 list->Write(i * sizeof(TCertificateRequestListEntry), |
|
213 &certReqInfo, |
|
214 sizeof(TCertificateRequestListEntry)); |
|
215 |
|
216 } |
|
217 TPtr8 ptrList = list->Ptr(0); |
|
218 aMessage.WriteL(0, ptrList); |
|
219 |
|
220 CleanupStack::PopAndDestroy(list); |
|
221 CleanupStack::PopAndDestroy(certReqList); |
|
222 |
|
223 aMessage.Complete(KErrNone); |
|
224 } |
|
225 break; |
|
226 |
|
227 case PkiService::ESaveCertificateRequest: |
|
228 { |
|
229 TInt requestSize = aMessage.GetDesLength(0); |
|
230 HBufC8* request = HBufC8::NewLC(requestSize); |
|
231 TPtr8 requestPtr = request->Des(); |
|
232 |
|
233 TKeyIdentifier keyId; |
|
234 |
|
235 aMessage.ReadL(0, requestPtr); |
|
236 aMessage.ReadL(2, keyId); //keyId is ignored. |
|
237 |
|
238 HBufC* certRequestRef = |
|
239 iServer.CertificateRequestStore().SaveCertRequestLC(*request); |
|
240 |
|
241 aMessage.WriteL(1, *certRequestRef); |
|
242 |
|
243 CleanupStack::PopAndDestroy(certRequestRef); |
|
244 CleanupStack::PopAndDestroy(request); |
|
245 |
|
246 aMessage.Complete(KErrNone); |
|
247 } |
|
248 break; |
|
249 |
|
250 case PkiService::EReadCertificateRequest: |
|
251 { |
|
252 TInt certRequestRefSize = aMessage.GetDesLength(0); |
|
253 HBufC *certRequestRef = HBufC::NewLC(certRequestRefSize); |
|
254 TPtr certRequestRefPtr = certRequestRef->Des(); |
|
255 |
|
256 aMessage.ReadL(0, certRequestRefPtr); |
|
257 |
|
258 if (certRequestRef->Length() == 0) |
|
259 { |
|
260 User::Leave(KErrNotFound); |
|
261 } |
|
262 |
|
263 HBufC8* certificateRequest = |
|
264 iServer.CertificateRequestStore().ReadCertRequestLC(*certRequestRef); |
|
265 |
|
266 if (aMessage.GetDesMaxLength(1) >= certificateRequest->Length()) |
|
267 { |
|
268 aMessage.WriteL(1, *certificateRequest); |
|
269 aMessage.Complete(KErrNone); |
|
270 } |
|
271 else |
|
272 { |
|
273 iRequiredBufferSize = certificateRequest->Length(); |
|
274 aMessage.Complete(KPKIErrBufferTooShort); |
|
275 } |
|
276 |
|
277 CleanupStack::PopAndDestroy(certificateRequest); |
|
278 CleanupStack::PopAndDestroy(certRequestRef); |
|
279 |
|
280 } |
|
281 break; |
|
282 |
|
283 case PkiService::EDeleteCertificateRequest: |
|
284 { |
|
285 TInt certRequestRefSize = aMessage.GetDesLength(0); |
|
286 HBufC *certRequestRef = HBufC::NewLC(certRequestRefSize); |
|
287 TPtr certRequestRefPtr = certRequestRef->Des(); |
|
288 |
|
289 aMessage.ReadL(0, certRequestRefPtr); |
|
290 |
|
291 iServer.CertificateRequestStore().DeleteCertRequestL(*certRequestRef); |
|
292 |
|
293 CleanupStack::PopAndDestroy(certRequestRef); |
|
294 aMessage.Complete(KErrNone); |
|
295 } |
|
296 break; |
|
297 case PkiService::ESetCertStoreType: |
|
298 iWrapper->SetCertStoreType(static_cast<TPkiServiceStoreType>(aMessage.Int0())); |
|
299 aMessage.Complete(KErrNone); |
|
300 break; |
|
301 |
|
302 case PkiService::ESetKeyStoreType: |
|
303 SetKeyStoreL(static_cast<TPkiServiceStoreType>(aMessage.Int0())); |
|
304 aMessage.Complete(KErrNone); |
|
305 break; |
|
306 |
|
307 case PkiService::ESetStoreType: |
|
308 iWrapper->SetCertStoreType(static_cast<TPkiServiceStoreType>(aMessage.Int0())); |
|
309 SetKeyStoreL(static_cast<TPkiServiceStoreType>(aMessage.Int1())); |
|
310 aMessage.Complete(KErrNone); |
|
311 break; |
|
312 |
|
313 case PkiService::EGetCertStoreType: |
|
314 { |
|
315 Status = iWrapper->CertStoreType(); |
|
316 aMessage.Complete(Status); |
|
317 break; |
|
318 } |
|
319 |
|
320 case PkiService::EGetKeyStoreType: |
|
321 { |
|
322 Status = KeyStore(); |
|
323 aMessage.Complete(Status); |
|
324 break; |
|
325 } |
|
326 |
|
327 case PkiService::ESetInformational: |
|
328 { |
|
329 iWrapper->SetInformational(aMessage.Int0()); |
|
330 aMessage.Complete(KErrNone); |
|
331 } |
|
332 break; |
|
333 |
|
334 case PkiService::EInitialize://falls through |
|
335 case PkiService::EKeyCount: //falls through |
|
336 case PkiService::EGetKeyDetails: //falls through |
|
337 case PkiService::EDecrypt: //falls through |
|
338 case PkiService::ESignWithKeyId: //falls through |
|
339 case PkiService::ESignWithCert: //falls through |
|
340 case PkiService::EReadPublicKey: //falls through |
|
341 case PkiService::ELogon: //falls through |
|
342 case PkiService::ELogoff: //falls through |
|
343 case PkiService::EChangePassword: //falls through |
|
344 case PkiService::ERemoveKeypair: //falls through |
|
345 case PkiService::EGenerateKeypair: //falls through |
|
346 case PkiService::EStoreKeypair: //falls through |
|
347 iKeyOperationQueue.AddOperationL(*this, aMessage, |
|
348 iUsedKeyStore, iWrapper->CertStoreType()); |
|
349 break; |
|
350 default: |
|
351 iRequiredBufferSize = KBufferSizeNotDefined; |
|
352 Status = iWrapper->InitOperation(aMessage); |
|
353 break; |
|
354 } |
|
355 } |
|
356 |
|
357 |
|
358 void CPKISession::SetKeyStoreL(TPkiServiceStoreType aStoreType) |
|
359 { |
|
360 switch(aStoreType) |
|
361 { |
|
362 case EPkiStoreTypeAny: |
|
363 iUsedKeyStore = STORETYPE_ANY_KEY_ID; |
|
364 break; |
|
365 case EPkiStoreTypeUser: |
|
366 iUsedKeyStore = STORETYPE_USER_KEY_ID; |
|
367 break; |
|
368 case EPkiStoreTypeDevice: |
|
369 iUsedKeyStore = STORETYPE_DEVICE_KEY_ID; |
|
370 break; |
|
371 default: |
|
372 User::Leave(KPKIErrNotSupported); |
|
373 break; |
|
374 } |
|
375 } |
|
376 |
|
377 |
|
378 TPkiServiceStoreType CPKISession::KeyStore() const |
|
379 { |
|
380 |
|
381 TPkiServiceStoreType usedStore = EPkiStoreTypeAny; |
|
382 switch(iUsedKeyStore) |
|
383 { |
|
384 case STORETYPE_USER_KEY_ID: |
|
385 usedStore = EPkiStoreTypeUser; |
|
386 break; |
|
387 case STORETYPE_DEVICE_KEY_ID: |
|
388 usedStore = EPkiStoreTypeDevice; |
|
389 break; |
|
390 case STORETYPE_ANY_KEY_ID: |
|
391 usedStore = EPkiStoreTypeAny; |
|
392 break; |
|
393 default: |
|
394 PKISERVICE_ASSERT(iUsedKeyStore == 0); |
|
395 break; |
|
396 } |
|
397 return usedStore; |
|
398 } |
|
399 |
|
400 |
|
401 void CPKISession::SetRequiredBufferSize(TInt aSize) |
|
402 { |
|
403 iRequiredBufferSize = aSize; |
|
404 } |
|
405 |
|
406 |
|
407 void CPKISession::SetKeyList(CArrayFixFlat<TKeyListEntry> *aKeyList) |
|
408 { |
|
409 iKeyList = aKeyList; |
|
410 } |
|
411 |
|
412 |
|
413 void CPKISession::InitializeWrapperL(const RMessage2& aMessage) |
|
414 { |
|
415 iWrapper->InitializeL(aMessage); |
|
416 } |