vpnengine/pkiservice/src/pkisession.cpp
changeset 1 c9c2ad51f972
parent 0 33413c0669b9
child 22 9f4e37332ce5
equal deleted inserted replaced
0:33413c0669b9 1:c9c2ad51f972
    92 
    92 
    93     switch(aMessage.Function())
    93     switch(aMessage.Function())
    94         {                            
    94         {                            
    95         case PkiService::ECancelPendingOperation:
    95         case PkiService::ECancelPendingOperation:
    96             iWrapper->CancelPendingOperation();
    96             iWrapper->CancelPendingOperation();
    97             aMessage.Complete(Status);
    97             aMessage.Complete(KErrNone);
    98             break;
    98             break;
    99         
    99         
   100         case PkiService::EGetRequiredBufferSize:
   100         case PkiService::EGetRequiredBufferSize:
   101             if (iRequiredBufferSize == KBufferSizeNotDefined)
   101             if (iRequiredBufferSize == KBufferSizeNotDefined)
   102                 {                
   102                 {                
   109                 aMessage.Complete(KErrNone);
   109                 aMessage.Complete(KErrNone);
   110                 }
   110                 }
   111             break;
   111             break;
   112 
   112 
   113         case PkiService::ECertCount:        
   113         case PkiService::ECertCount:        
   114             count = iMapper.CertCount();
   114             count = iMapper.CertCount(iWrapper->Informational());
   115             aMessage.Complete(count);          // Status <==> count
   115             aMessage.Complete(count);
   116             break;
   116             break;
   117             
   117             
   118         case PkiService::EApplicableCertCount:
   118         case PkiService::EApplicableCertCount:
   119     		{
   119     		{
   120     		TInt aC = 0;
   120     		TInt aC = 0;
   139     				}
   139     				}
   140     			}
   140     			}
   141     		CleanupStack::PopAndDestroy(1);     // list
   141     		CleanupStack::PopAndDestroy(1);     // list
   142     		
   142     		
   143     		TInt matchCount = iMapper.ApplicableCertCount(iUidArray);
   143     		TInt matchCount = iMapper.ApplicableCertCount(iUidArray);
   144     		aMessage.Complete(matchCount);          // Status <==> count
   144     		aMessage.Complete(matchCount); 
   145     		}
   145     		}
   146     		break;
   146     		break;
   147        case PkiService::EGetCertDetails:
   147        case PkiService::EGetCertDetails:
   148 		    Status = iMapper.GetCertListL(aMessage, iWrapper->CertStoreType(), ETrue);
   148             {
       
   149             TPckgBuf<TSecurityObjectDescriptor> secDescPtr;
       
   150             aMessage.ReadL(1, secDescPtr);
       
   151             TCertificateListEntry* resultCertInfo = new (ELeave) TCertificateListEntry;
       
   152             CleanupStack::PushL(resultCertInfo);            
       
   153             Status = iMapper.GetCertDetailsL(secDescPtr(), 
       
   154                                              iWrapper->CertStoreType(), 
       
   155                                              iWrapper->Informational(),
       
   156                                              *resultCertInfo);
       
   157 		    if (Status == KErrNone)
       
   158 		        {
       
   159 		        TPckg<TCertificateListEntry> certDetailsPtr(*resultCertInfo);
       
   160 	            aMessage.WriteL(0, certDetailsPtr);
       
   161 		        }
   149 		    aMessage.Complete(Status);
   162 		    aMessage.Complete(Status);
       
   163 		    CleanupStack::PopAndDestroy(resultCertInfo);            
       
   164             }
   150 		    break;
   165 		    break;
   151         case PkiService::EGetCertList:
   166         case PkiService::EGetCertList:
   152 		    iMapper.GetCertListL(aMessage, iWrapper->CertStoreType());
   167 		    iMapper.GetCertListL(aMessage, iWrapper->Informational());
   153 		    aMessage.Complete(KErrNone);
   168 		    aMessage.Complete(KErrNone);
   154 		    break;
   169 		    break;
   155 
   170 
   156         case PkiService::EGetApplicableCertList:		
   171         case PkiService::EGetApplicableCertList:		
   157 		    iMapper.GetApplicableCertListL(aMessage, iUidArray);
   172 		    iMapper.GetApplicableCertListL(aMessage, iUidArray);
   183         	}
   198         	}
   184             break;
   199             break;
   185     		
   200     		
   186         case PkiService::ECertReqCount:                    
   201         case PkiService::ECertReqCount:                    
   187             count = iServer.CertificateRequestStore().CertReqCountL();
   202             count = iServer.CertificateRequestStore().CertReqCountL();
   188             aMessage.Complete(count);          // Status <==> count
   203             aMessage.Complete(count); 
   189             break;    		
   204             break;    		
   190     		
   205     		
   191         case PkiService::EGetCertReqList:
   206         case PkiService::EGetCertReqList:
   192             {
   207             {
   193             CArrayFixFlat<TCertificateRequestListEntry>* certReqList =
   208             CArrayFixFlat<TCertificateRequestListEntry>* certReqList =
   329             iWrapper->SetInformational(aMessage.Int0());
   344             iWrapper->SetInformational(aMessage.Int0());
   330             aMessage.Complete(KErrNone);
   345             aMessage.Complete(KErrNone);
   331             }
   346             }
   332             break;
   347             break;
   333             
   348             
   334         case PkiService::EInitialize://falls through    		
   349         case PkiService::EInitialize://falls through
   335         case PkiService::EKeyCount: //falls through    		                
   350         case PkiService::EKeyCount: //falls through    		                
   336         case PkiService::EGetKeyDetails: //falls through    		
   351         case PkiService::EGetKeyDetails: //falls through    		
   337         case PkiService::EDecrypt: //falls through    		
   352         case PkiService::EDecrypt: //falls through    		
   338         case PkiService::ESignWithKeyId: //falls through    		
   353         case PkiService::ESignWithKeyId: //falls through    		
   339         case PkiService::ESignWithCert: //falls through    		
   354         case PkiService::ESignWithCert: //falls through    		
   347             iKeyOperationQueue.AddOperationL(*this, aMessage,
   362             iKeyOperationQueue.AddOperationL(*this, aMessage,
   348                                              iUsedKeyStore, iWrapper->CertStoreType());
   363                                              iUsedKeyStore, iWrapper->CertStoreType());
   349             break;  
   364             break;  
   350         default:      
   365         default:      
   351             iRequiredBufferSize = KBufferSizeNotDefined;
   366             iRequiredBufferSize = KBufferSizeNotDefined;
   352             Status = iWrapper->InitOperation(aMessage);
   367             iWrapper->InitOperation(aMessage);
   353             break;
   368             break;
   354         }
   369         }
   355     }
   370     }
   356 
   371 
   357 
   372