195 User::RequestComplete(status, KErrNone); |
160 User::RequestComplete(status, KErrNone); |
196 } |
161 } |
197 SetActive(); |
162 SetActive(); |
198 } |
163 } |
199 |
164 |
200 //-------------------------------------------------- |
|
201 |
165 |
202 void CEapTlsPeapCertFetcher::DoCancel() |
166 void CEapTlsPeapCertFetcher::DoCancel() |
203 { |
167 { |
204 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::DoCancel()\n"))); |
|
205 EAP_TRACE_RETURN_STRING_SYMBIAN(_L("returns: CEapTlsPeapCertFetcher::DoCancel()\n")); |
|
206 |
|
207 } |
|
208 |
|
209 //-------------------------------------------------- |
|
210 |
|
211 void CEapTlsPeapCertFetcher::InitializeQuery() |
|
212 { |
|
213 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::InitializeQuery(): iOwnertype=%d\n"), |
|
214 iOwnertype)); |
|
215 EAP_TRACE_RETURN_STRING_SYMBIAN(_L("returns: CEapTlsPeapCertFetcher::InitializeQuery()\n")); |
|
216 |
|
217 // Delete iCertInfos |
|
218 for (TInt i = 0; i < iCertInfos.Count(); i++) |
|
219 { |
|
220 iCertInfos[i]->Release(); |
|
221 } |
|
222 iCertInfos.Reset(); |
|
223 |
|
224 delete iCertFilter; |
|
225 iCertFilter = 0; |
|
226 |
|
227 TRAPD(error, iCertFilter = CCertAttributeFilter::NewL()); |
|
228 if (error != KErrNone) |
|
229 { |
|
230 // Complete with empty lists |
|
231 EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: CEapTlsPeapCertFetcher::InitializeQuery() - Complete with empty lists Error:%d, iUserCerts.Count()=%d, iCACerts.Count()=%d\n"), |
|
232 error, |
|
233 iUserCerts.Count(), |
|
234 iCACerts.Count()) ); |
|
235 TRAP(error, iParent->CompleteReadCertificatesL(iUserCerts, iCACerts)); |
|
236 return; |
|
237 } |
|
238 iCertFilter->SetFormat(EX509Certificate); |
|
239 |
|
240 iCertFilter->SetOwnerType(iOwnertype); |
|
241 |
|
242 iCertInfoIndex = 0; |
|
243 |
|
244 iState = EGetCertificatesGetCertList; |
|
245 |
|
246 iCertStore->List( |
|
247 iCertInfos, |
|
248 *iCertFilter, |
|
249 iStatus); |
|
250 |
|
251 SetActive(); |
|
252 } |
168 } |
253 |
169 |
254 //-------------------------------------------------- |
170 //-------------------------------------------------- |
255 |
171 |
256 void CEapTlsPeapCertFetcher::RunL() |
172 void CEapTlsPeapCertFetcher::RunL() |
257 { |
173 { |
258 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL(): - iStatus.Int()=%d, iState=%d \n"), |
174 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL - iStatus.Int()=%d, iState=%d \n"), |
259 iStatus.Int() , iState)); |
175 iStatus.Int() , iState)); |
260 EAP_TRACE_RETURN_STRING_SYMBIAN(_L("returns: CEapTlsPeapCertFetcher::RunL()\n")); |
176 if( iState == EGetSymbianSubjectKeyId ) |
261 |
177 { |
262 //int i; |
178 // Only for GetSymbianSubjectKeyIdL. |
263 TInt error(KErrNone); |
179 iWait.AsyncStop(); // This is needed to continue the execution after Wait.Start() |
|
180 return; // No need to proceed further. |
|
181 } |
|
182 |
|
183 if( iState == EGetCertificatesRetrieveCert) |
|
184 { |
|
185 // This is executed when certificate details are being retrieved. |
|
186 iWait.AsyncStop(); // This is needed to continue the execution after Wait.Start() |
|
187 return; // No need to proceed further. |
|
188 } |
|
189 |
|
190 int i; |
|
191 TInt err(KErrNone); |
264 |
192 |
265 // This causes panic if leaves |
193 // This causes panic if leaves |
266 if (iStatus.Int() != KErrNone) |
194 if (iStatus.Int() != KErrNone) |
267 { |
195 { |
268 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() -- don't leave..."))); |
196 RDebug::Print(_L("CEapTlsPeapCertFetcher::RunL() -- don't leave...")); |
269 } |
197 } |
270 |
198 |
271 switch (iState) |
199 switch (iState) |
272 { |
200 { |
273 case EGetCertificatesInitStore: |
201 case EGetCertificatesInitStore: |
274 { |
202 { |
275 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL(): - EGetCertificatesInitStore\n"))); |
203 // Delete iCertInfos |
276 |
204 for (TInt i = 0; i < iCertInfos.Count(); i++) |
277 // First get the User certificates. |
205 { |
278 iOwnertype = EUserCertificate; |
206 iCertInfos[i]->Release(); |
279 InitializeQuery(); |
207 } |
|
208 iCertInfos.Reset(); |
|
209 |
|
210 delete iCertFilter; |
|
211 iCertFilter = 0; |
|
212 |
|
213 TRAP(err, iCertFilter = CCertAttributeFilter::NewL()); |
|
214 if (err != KErrNone) |
|
215 { |
|
216 // Complete with empty lists |
|
217 TInt err(KErrNone); |
|
218 TRAP(err, iParent->CompleteReadCertificatesL(iUserCerts, iCACerts)); |
|
219 break; |
|
220 } |
|
221 iCertFilter->SetFormat(EX509Certificate); |
|
222 |
|
223 iState = EGetCertificatesGetCertList; |
|
224 iCertStore->List( |
|
225 iCertInfos, |
|
226 *iCertFilter, |
|
227 iStatus); |
|
228 SetActive(); |
280 } |
229 } |
281 break; |
230 break; |
282 |
231 |
283 case EGetCertificatesRetrieveCert: |
232 case EGetCertificatesGetCertList: |
284 { |
233 { |
285 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL(): - EGetCertificatesRetrieveCert - Symbian cert store found %d certs in device\n"), |
234 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL - EGetCertificatesGetCertList - Symbian cert store found %d certs in device\n"), |
286 iCertInfos.Count())); |
235 iCertInfos.Count())); |
287 |
236 |
288 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() - iWait.Start() returned, iStatus.Int()=%d \n"),iStatus.Int() ) ); |
237 if(0 == iCertInfos.Count()) |
289 |
|
290 CCTCertInfo* CertInfo = iCertInfos[iCertInfoIndex]; |
|
291 CCertificate* cert = NULL; |
|
292 |
|
293 if ( iStatus.Int() == KErrNone ) |
|
294 { |
238 { |
295 switch ( CertInfo->CertificateFormat() ) |
239 EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR : CEapTlsPeapCertFetcher::RunL - SERIOUS PROBLEM - Symbian cert store couldn't find any certs in device\n"))); |
|
240 } |
|
241 |
|
242 for (i = 0; i < iCertInfos.Count(); i++) |
|
243 { |
|
244 CCTCertInfo* CertInfo; |
|
245 CertInfo = iCertInfos[i]; |
|
246 iEncodedCertificate->Des().SetLength(0); |
|
247 |
|
248 TRAPD(err, iEncodedCertificate = iEncodedCertificate->ReAllocL(iCertInfos[i]->Size())); |
|
249 if (err != KErrNone) |
296 { |
250 { |
297 case EX509Certificate: |
251 EAP_TRACE_DEBUG_SYMBIAN((_L("\nCEapTlsPeapCertFetcher::RunL() - EGetCertificatesGetCertList - leave from iEncodedCertificate->ReAllocL Error:%d\n"), err ) ); |
298 { |
252 } |
299 TRAPD(error, cert = CX509Certificate::NewL( iCertPtr )); |
253 iCertPtr.Set(iEncodedCertificate->Des()); |
300 if (error != KErrNone) |
254 |
301 { |
255 EAP_TRACE_DEBUG_SYMBIAN((_L("\nCEapTlsPeapCertFetcher::RunL() - EGetCertificatesGetCertList - Retreiving cert %d\n"), i ) ); |
302 EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: CEapTlsPeapCertFetcher::RunL() - EGetCertificatesGetCertList - leave from CX509Certificate::NewL Label:%S Error:%d\n"), |
256 |
303 &(CertInfo->Label()), |
257 iCertStore->Retrieve( *CertInfo, iCertPtr, iStatus); |
304 error ) ); |
258 |
305 |
259 iState = EGetCertificatesRetrieveCert; |
306 cert = NULL; |
260 |
307 } |
261 SetActive(); |
308 break; |
262 iWait.Start(); |
309 } |
263 |
310 default: |
264 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() - iWait.Start() returned, iStatus.Int()=%d \n"),iStatus.Int() ) ); |
311 { |
265 |
312 // Only X509 type of certificates are supported at the moment. |
266 CCertificate* cert = NULL; |
313 // This won't be happening ever since we have used a filter while getting the certificate list. |
267 |
314 EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: CEapTlsPeapCertFetcher::RunL() - Unsupported Certificate - Not X509\n") ) ); |
268 if ( iStatus.Int() == KErrNone ) |
315 |
269 { |
316 cert = NULL; |
270 switch ( CertInfo->CertificateFormat() ) |
317 } |
271 { |
318 } |
272 case EX509Certificate: |
319 } |
273 { |
320 else |
274 TRAPD(err, cert = CX509Certificate::NewL( iCertPtr )); |
321 { |
275 if (err != KErrNone) |
322 EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: CEapTlsPeapCertFetcher::RunL() - Error from Certificate retrieve, iStatus.Int()=%d\n"), iStatus.Int() ) ); |
276 EAP_TRACE_DEBUG_SYMBIAN((_L("\nCEapTlsPeapCertFetcher::RunL() - EGetCertificatesGetCertList - leave from CX509Certificate::NewL Label:%S Error:%d\n"),&(CertInfo->Label()), err ) ); |
323 } |
277 break; |
324 |
278 } |
325 if( cert != NULL ) |
279 default: |
326 { |
280 { |
327 HBufC* pri = NULL; |
281 // Only X509 type of certificates are supported at the moment. |
328 HBufC* sec = NULL; |
282 // This won't be happening ever since we have used a filter while getting the certificate list. |
|
283 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() - Unsupported Certificate - Not X509\n") ) ); |
|
284 |
|
285 break; |
|
286 } |
|
287 } |
|
288 } |
|
289 else |
|
290 { |
|
291 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() - Error from Certificate retrieve, iStatus.Int()=%d\n"), iStatus.Int() ) ); |
|
292 } |
|
293 |
|
294 if( cert == NULL ) |
|
295 { |
|
296 // Some problem above. Skip the below and go for the next certificate. |
|
297 continue; |
|
298 } |
329 |
299 |
330 CleanupStack::PushL(cert); |
300 HBufC* pri = NULL; |
331 |
301 HBufC* sec = NULL; |
332 X509CertNameParser::PrimaryAndSecondaryNameL( *((CX509Certificate*)cert), pri, sec, CertInfo->Label()); |
302 |
333 |
303 CleanupStack::PushL( cert ); |
334 CleanupStack::PopAndDestroy(cert); |
304 |
335 |
305 X509CertNameParser::PrimaryAndSecondaryNameL( *((CX509Certificate*)cert), pri, sec, CertInfo->Label()); |
336 CleanupStack::PushL(pri); |
306 |
337 CleanupStack::PushL(sec); |
307 CleanupStack::PopAndDestroy(); // cert |
338 |
|
339 |
308 |
340 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() - Label=%S, Pri name=%S,Length=%d, Sec name=%S,Length=%d\n"), |
309 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() - Label=%S, Pri name=%S,Length=%d, Sec name=%S,Length=%d\n"), |
341 &(CertInfo->Label()), pri, pri->Length(), sec, sec->Length() ) ); |
310 &(CertInfo->Label()), pri, pri->Length(), sec, sec->Length() ) ); |
342 |
311 |
343 EAP_TRACE_DATA_DEBUG_SYMBIAN( ( "CEapTlsPeapCertFetcher::RunL() - Sub Key Id:", (CertInfo->SubjectKeyId().Ptr()), |
312 EAP_TRACE_DATA_DEBUG_SYMBIAN( ( "CEapTlsPeapCertFetcher::RunL() - Sub Key Id:", (CertInfo->SubjectKeyId().Ptr()), |
344 (CertInfo->SubjectKeyId().Size()) ) ); |
313 (CertInfo->SubjectKeyId().Size()) ) ); |
345 |
314 |
346 EapCertificateEntry * const certEntry = new EapCertificateEntry; |
315 SCertEntry certEntry; |
347 if (certEntry == 0) |
316 |
|
317 certEntry.iLabel.Copy(iCertInfos[i]->Label()); |
|
318 certEntry.iSubjectKeyId.Copy(iCertInfos[i]->SubjectKeyId()); |
|
319 |
|
320 // Copy the new fields. Primary and secondary name. |
|
321 certEntry.iPrimaryName.Copy( pri->Des().Left(KMaxNameLength ) ); |
|
322 certEntry.iSecondaryName.Copy( sec->Des().Left(KMaxNameLength ) ); |
|
323 |
|
324 delete pri; |
|
325 delete sec; |
|
326 |
|
327 if (iCertInfos[i]->CertificateOwnerType() == ECACertificate) |
348 { |
328 { |
349 User::Leave(KErrNoMemory); |
329 iCACerts.Append(certEntry); |
350 } |
330 } |
351 CleanupStack::PushL(certEntry); |
331 else if (iCertInfos[i]->CertificateOwnerType() == EUserCertificate) |
352 |
|
353 certEntry->SetLabel(CertInfo->Label()); |
|
354 certEntry->SetSubjectKeyId(CertInfo->SubjectKeyId()); |
|
355 |
|
356 // Copy the new fields. Primary and secondary name. |
|
357 certEntry->SetPrimaryName(pri->Des().Left(KMaxCertNameLength)); |
|
358 certEntry->SetSecondaryName(sec->Des().Left(KMaxCertNameLength)); |
|
359 |
|
360 if (CertInfo->CertificateOwnerType() == ECACertificate) |
|
361 { |
332 { |
362 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL(): - CA certificate\n"))); |
333 iUserCerts.Append(certEntry); |
363 |
334 } |
364 certEntry->SetCertType(EapCertificateEntry::ECA); |
335 } |
365 error = iCACerts.Append(certEntry); |
336 delete iCertFilter; |
366 } |
337 iCertFilter = 0; |
367 else if (CertInfo->CertificateOwnerType() == EUserCertificate) |
338 |
368 { |
339 // Delete iCertInfos |
369 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL(): - User certificate\n"))); |
340 for (TInt i = 0; i < iCertInfos.Count(); i++) |
370 |
|
371 certEntry->SetCertType(EapCertificateEntry::EUser); |
|
372 error = iUserCerts.Append(certEntry); |
|
373 } |
|
374 else |
|
375 { |
|
376 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL(): - Unknown certificate\n"))); |
|
377 } |
|
378 |
|
379 if (error == KErrNone) |
|
380 { |
|
381 CleanupStack::Pop(certEntry); |
|
382 } |
|
383 else |
|
384 { |
|
385 CleanupStack::PopAndDestroy(certEntry); |
|
386 } |
|
387 |
|
388 CleanupStack::PopAndDestroy(sec); |
|
389 CleanupStack::PopAndDestroy(pri); |
|
390 |
|
391 } |
|
392 |
|
393 ++iCertInfoIndex; |
|
394 } |
|
395 |
|
396 // Here MUST NOT be break. State EGetCertificatesGetCertList is run after the state EGetCertificatesRetrieveCert. |
|
397 |
|
398 case EGetCertificatesGetCertList: |
|
399 { |
|
400 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL(): - EGetCertificatesGetCertList - Symbian cert store found %d certs in device, iCertInfoIndex=%d\n"), |
|
401 iCertInfos.Count(), |
|
402 iCertInfoIndex)); |
|
403 |
|
404 if (iCertInfoIndex < iCertInfos.Count()) |
|
405 { |
|
406 CCTCertInfo* CertInfo = iCertInfos[iCertInfoIndex]; |
|
407 |
|
408 iEncodedCertificate->Des().SetLength(0); |
|
409 |
|
410 TRAPD(error, iEncodedCertificate = iEncodedCertificate->ReAllocL(CertInfo->Size())); |
|
411 if (error != KErrNone) |
|
412 { |
|
413 EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: CEapTlsPeapCertFetcher::RunL() - EGetCertificatesGetCertList - leave from iEncodedCertificate->ReAllocL Error:%d\n"), error ) ); |
|
414 } |
|
415 iCertPtr.Set(iEncodedCertificate->Des()); |
|
416 |
|
417 EAP_TRACE_DEBUG_SYMBIAN((_L("\nCEapTlsPeapCertFetcher::RunL() - EGetCertificatesGetCertList - Retreiving cert %d\n"), iCertInfoIndex ) ); |
|
418 |
|
419 iState = EGetCertificatesRetrieveCert; |
|
420 |
|
421 iCertStore->Retrieve( *CertInfo, iCertPtr, iStatus); |
|
422 |
|
423 SetActive(); |
|
424 } |
|
425 else if (iOwnertype == EUserCertificate) |
|
426 { |
341 { |
427 // Next get the CA certificates. |
342 iCertInfos[i]->Release(); |
428 iOwnertype = ECACertificate; |
343 } |
429 InitializeQuery(); |
344 iCertInfos.Reset(); |
430 return; |
345 TRAP(err, iParent->CompleteReadCertificatesL(iUserCerts, iCACerts)); |
431 } |
346 // Ignore error on purpose. |
432 else |
|
433 { |
|
434 delete iCertFilter; |
|
435 iCertFilter = 0; |
|
436 |
|
437 // Delete iCertInfos |
|
438 for (TInt i = 0; i < iCertInfos.Count(); i++) |
|
439 { |
|
440 iCertInfos[i]->Release(); |
|
441 } |
|
442 iCertInfos.Reset(); |
|
443 |
|
444 EAP_TRACE_DEBUG_SYMBIAN((_L("CEapTlsPeapCertFetcher::RunL() - EGetCertificatesGetCertList - Complete list, iUserCerts.Count()=%d, iCACerts.Count()=%d\n"), |
|
445 iUserCerts.Count(), |
|
446 iCACerts.Count()) ); |
|
447 |
|
448 TRAP(error, iParent->CompleteReadCertificatesL(iUserCerts, iCACerts)); |
|
449 // Ignore error on purpose. |
|
450 } |
|
451 } |
347 } |
452 break; |
348 break; |
453 |
349 |
454 default: |
350 default: |
455 EAP_TRACE_DEBUG_SYMBIAN((_L("WARNING: CEapTlsPeapCertFetcher::RunL(): - default\n"))); |
|
456 break; |
351 break; |
457 } |
352 } |
458 return; |
353 return; |
459 } |
354 } |
460 |
355 |
461 //-------------------------------------------------- |
|
462 // End of file |
356 // End of file |