/*
* 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;  
            		                    
    }