diff -r 000000000000 -r 33413c0669b9 vpnengine/pkiservice/src/pkiservicesigner.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/pkiservice/src/pkiservicesigner.cpp	Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,267 @@
+/*
+* Copyright (c) 2008 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: A class that provides a signing operation.
+*
+*/
+
+
+
+#include <unifiedkeystore.h>
+#include <asymmetric.h>
+
+#include "pkiservicesigner.h"
+#include "logonservices.h"
+#include "pkidefs.h"
+#include "pkiserviceconstants.h"
+#include "pkiserviceassert.h"
+
+CPkiServiceSigner* CPkiServiceSigner::NewL(CLogonServices& aLogonServices)
+    {
+    CPkiServiceSigner* self = new (ELeave) CPkiServiceSigner(aLogonServices);
+    return self;
+    }
+
+
+CPkiServiceSigner::CPkiServiceSigner(CLogonServices& aLogonServices)
+:CActive(EPriorityStandard), iLogonServices(aLogonServices)
+    {
+    CActiveScheduler::Add(this);
+    }
+
+
+CPkiServiceSigner::~CPkiServiceSigner()
+    {
+    Cancel();   
+    }
+
+
+void CPkiServiceSigner::Sign(const TPKIKeyIdentifier& aKeyId,
+                             const TDesC8& aDataToBeSigned,
+                             HBufC8*& aSignature,
+                             CUnifiedKeyStore& aUnifiedKeyStore,
+                             TInt aUsedKeyStore,
+                             TRequestStatus& aStatus)
+    {
+    PKISERVICE_ASSERT(iState == ESignerIdle);
+    PKISERVICE_ASSERT(iClientStatus == NULL);
+    PKISERVICE_ASSERT(iKeyStore == NULL);
+    PKISERVICE_ASSERT(iOutputBuffer == NULL);
+    PKISERVICE_ASSERT(iRsaSigner == NULL);
+    PKISERVICE_ASSERT(iDsaSigner == NULL);
+    PKISERVICE_ASSERT(iRsaSignature == NULL);
+    PKISERVICE_ASSERT(iDsaSignature == NULL);
+    PKISERVICE_ASSERT(iKeysList.Count() == 0);
+    
+    
+    iState = ESignerGettingKey;
+            
+    
+    iInput.Set(aDataToBeSigned);
+    
+    iOutputBuffer = &aSignature;
+    iKeyStore = &aUnifiedKeyStore;
+    iUsedKeyStore = aUsedKeyStore;
+    aStatus = KRequestPending;
+    iClientStatus = &aStatus;
+    
+        
+    TCTKeyAttributeFilter filter;
+    filter.iKeyId = aKeyId;
+    
+    iKeyStore->List(iKeysList, filter, iStatus);
+    SetActive();    
+    }
+
+
+void CPkiServiceSigner::DoCancel()
+    {
+    switch(iState)
+        {
+        case ESignerGettingKey:
+            iKeyStore->CancelList();
+            break;
+        case ESignerOpeningSigner:
+            iKeyStore->CancelOpen();
+            break;
+        case ESignerSigning:
+            if (iRsaSigner != NULL)
+                {         
+                PKISERVICE_ASSERT(iDsaSigner == NULL);        
+                iRsaSigner->CancelSign();          
+                }
+            else
+                {
+                PKISERVICE_ASSERT(iDsaSigner != NULL);
+                PKISERVICE_ASSERT(iRsaSigner == NULL );
+                iDsaSigner->CancelSign();
+                }
+            Cleanup();       
+            break;
+        default:
+            PKISERVICE_INVARIANT();
+            break;        
+        }
+    iState = ESignerIdle;
+    Cleanup();
+    User::RequestComplete(iClientStatus, KErrCancel);
+    }
+
+
+void CPkiServiceSigner::RunL()
+    {
+    if (iStatus.Int() == KErrNone)
+        {        
+        switch(iState)
+            {
+            case ESignerGettingKey:
+                iState = ESignerIdle;
+                
+                TInt keyIndex;
+                for (keyIndex = 0; keyIndex < iKeysList.Count(); keyIndex++)
+                    {
+                    if (iUsedKeyStore == STORETYPE_ANY_KEY_ID ||
+                        iUsedKeyStore == iKeysList[keyIndex]->Token().TokenType().Type().iUid)
+                        {
+                        break;
+                        }
+                    }
+                
+                if (keyIndex < iKeysList.Count())
+                    {
+                    iUsedKeyInfo = iKeysList[keyIndex];
+                    TCTTokenObjectHandle tokenHandle = iUsedKeyInfo->Handle();                                            
+                    switch(iUsedKeyInfo->Algorithm())
+                        {
+                        case CKeyInfoBase::ERSA:
+                            iState = ESignerOpeningSigner;
+                            iKeyStore->Open(tokenHandle, iRsaSigner, iStatus);
+                            SetActive();
+                            break;
+                        case CKeyInfoBase::EDSA:            
+                            iState = ESignerOpeningSigner;  
+                            iKeyStore->Open(tokenHandle, iDsaSigner, iStatus);
+                            SetActive();                            
+                            break;
+                        default:
+                            Cleanup();                         
+                            User::RequestComplete(iClientStatus, KPKIErrNotSupported);
+                            break;                            
+                        }                    
+                    }
+                else
+                    {
+                    Cleanup();
+                    User::RequestComplete(iClientStatus, KPKIErrNotFound);                    
+                    }                
+            
+                break;            
+            case ESignerOpeningSigner:
+                iState = ESignerSigning;            
+                if (iRsaSigner != NULL)
+                    {         
+                    PKISERVICE_ASSERT(iDsaSigner == NULL);        
+                    iRsaSigner->Sign(iInput, iRsaSignature, iStatus);
+                    SetActive();                
+                    }
+                else
+                    {
+                    PKISERVICE_ASSERT(iDsaSigner != NULL);                    
+                    iDsaSigner->Sign(iInput, iDsaSignature, iStatus);
+                    SetActive();   
+                    }
+                break;
+            case ESignerSigning:
+                iState = ESignerIdle;
+                                                                
+                if (iUsedKeyInfo->Protector() != NULL)
+                    {
+                    //authObject is NULL for device store
+                    iLogonServices.SetAuthenticationObject(iUsedKeyInfo->Protector());
+                    }
+
+                
+                TRAPD(err,                                 
+                    if (iRsaSignature != NULL)
+                        {
+                        PKISERVICE_ASSERT(iDsaSignature == NULL);
+                        
+                        const TInteger& integer = iRsaSignature->S();                    
+                        *iOutputBuffer = integer.BufferLC();
+                        CleanupStack::Pop(*iOutputBuffer);  
+                        }
+                    else
+                        {
+                        PKISERVICE_ASSERT(iDsaSignature != NULL);
+                        
+                        const TInteger& integerR = iDsaSignature->R();
+                        HBufC8* rBuf = integerR.BufferLC();                        
+                                                                        
+                        const TInteger& integerS = iDsaSignature->S();
+                        HBufC8* sBuf = integerS.BufferLC();
+                        
+                        (*iOutputBuffer) = HBufC8::NewL(rBuf->Length() + sBuf->Length());
+                        TPtr8 outputBufferPtr = (*iOutputBuffer)->Des();
+                        outputBufferPtr.Append(*rBuf);
+                        outputBufferPtr.Append(*sBuf);
+                        
+                        CleanupStack::PopAndDestroy(sBuf);
+                        CleanupStack::PopAndDestroy(rBuf);                        
+                        }                    
+                    );
+                Cleanup();                  
+                User::RequestComplete(iClientStatus, err);
+                break; 
+            default:
+                PKISERVICE_INVARIANT();
+                break;                       
+            }    
+        }
+    else
+        {
+        iState = ESignerIdle;
+        Cleanup();
+        User::RequestComplete(iClientStatus, iStatus.Int());
+        }
+    }
+
+
+void CPkiServiceSigner::Cleanup()
+    {
+    iUsedKeyInfo = NULL;
+    
+    delete iRsaSignature;
+    iRsaSignature = NULL;
+    
+    delete iDsaSignature;    
+    iDsaSignature = NULL;
+
+    
+    if (iRsaSigner != NULL)
+        {
+        iRsaSigner->Release();
+        iRsaSigner = NULL;
+        }
+    
+    if (iDsaSigner != NULL)
+        {
+        iDsaSigner->Release();
+        iDsaSigner = NULL;
+        }    
+        
+    iKeysList.Close();  
+    
+    iOutputBuffer = NULL;
+    iKeyStore = NULL;  
+            		                    
+    }