/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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: 

 *

 */

 #include "dummyeccimpl.h"

 #include <e32def.h>

 #include <cryptospi/cryptospidef.h>

 #include "keys.h"

 #include <cryptospi/plugincharacteristics.h>

 #include "pluginconfig.h"

 #include "cryptospihai.h"

 using namespace DummyEccHwCrypto;

 using namespace CryptoSpiHai;

 /**

  * These are just randomly selected numbers. There is no logic behind 

  * their values.

  */ 

 const TInt KMaxOutputLength = 50;

 const TInt KMaxInputLength = 50;

 CDummyECCCipherImpl* CDummyECCCipherImpl::NewL(const CKey& aKey,

         TUid aCryptoMode, TUid aPaddingMode)

     {

     CDummyECCCipherImpl* self = CDummyECCCipherImpl::NewLC(aKey, aCryptoMode,

             aPaddingMode);

     CleanupStack::Pop(self);

     return self;

     }

 CDummyECCCipherImpl* CDummyECCCipherImpl::NewLC(const CKey& aKey,

         TUid aCryptoMode, TUid aPaddingMode)

     {

     CDummyECCCipherImpl* self = new (ELeave) CDummyECCCipherImpl(aCryptoMode,

             aPaddingMode);

     CleanupStack::PushL(self);

     self->ConstructL(aKey);

     return self;

     }

 CDummyECCCipherImpl::CDummyECCCipherImpl(TUid aCryptoMode, TUid aPaddingMode) :

     iCryptoMode(aCryptoMode), iPaddingMode(aPaddingMode)

     {

     }

 void CDummyECCCipherImpl::ConstructL(const CKey& aKey)

     {

     SetKeyL(aKey);

     }

 // MPlugin Interface Start

 void CDummyECCCipherImpl::Close()

     {

     delete this;

     }

 void CDummyECCCipherImpl::Reset()

     {

     }

 void CDummyECCCipherImpl::GetCharacteristicsL(

         const TCharacteristics*& aPluginCharacteristics)

     {

     TInt numCiphers = sizeof(KAsymmetricCipherCharacteristics)

             / sizeof(TAsymmetricCipherCharacteristics*);

     TInt32 implUid = ImplementationUid().iUid;

     for (TInt i = 0; i < numCiphers; ++i)

         {

         if (KAsymmetricCipherCharacteristics[i]->cmn.iImplementationUID

                 == implUid)

             {

             aPluginCharacteristics = KAsymmetricCipherCharacteristics[i];

             break;

             }

         }

     }

 const CExtendedCharacteristics* CDummyECCCipherImpl::GetExtendedCharacteristicsL()

     {

     // All Symbian software plug-ins have unlimited concurrency, cannot be reserved

     // for exclusive use and are not CERTIFIED to be standards compliant.

     return CExtendedCharacteristics::NewL(KMaxTInt, EFalse);

     }

 TAny* CDummyECCCipherImpl::GetExtension(TUid /* aExtensionId */)

     {

     return 0;

     }

 // End of MPlugin Interface

 // MAsymmetricCipherBase Interface

 void CDummyECCCipherImpl::SetKeyL(const CKey& aKey)

     {

     // delete any previous key and recreate the key

     delete iKey;

     iKey = NULL;

     iKey = CKey::NewL(aKey);

     }

 void CDummyECCCipherImpl::SetCryptoModeL(TUid aCryptoMode)

     {

     switch (aCryptoMode.iUid)

         {

         case KCryptoModeEncrypt:

         case KCryptoModeDecrypt:

             break;

         default:

             User::Leave(KErrNotSupported);

         }

     iCryptoMode = aCryptoMode;

     }

 void CDummyECCCipherImpl::SetPaddingModeL(TUid /* aPaddingMode */)

     {

     User::Leave(KErrNotSupported);

     }

 TInt CDummyECCCipherImpl::GetMaximumInputLengthL() const

     {

     return KMaxInputLength;

     }

 TInt CDummyECCCipherImpl::GetMaximumOutputLengthL() const

     {

     return KMaxOutputLength;

     }

 // End of MAsymmetricCipherBase Interface

 // MAsymmetricCipher Interface

 void CDummyECCCipherImpl::ProcessL(const TDesC8& aInput, TDes8& aOutput)

     {

     if (iCryptoMode.iUid == KCryptoModeEncrypt)

         {

         EncryptL(aInput, aOutput);

         }

     else

         {

         DecryptL(aInput, aOutput);

         }

     }

 TUid CDummyECCCipherImpl::ImplementationUid() const

     {

     return KCryptoPluginEccCipherUid;

     }

 CDummyECCCipherImpl::~CDummyECCCipherImpl()

     {

     delete iKey;

     }

 void CDummyECCCipherImpl::EncryptL(const TDesC8& /* aInput */, TDes8& /* aOuput */)

     {

     User::Leave(KErrNotSupported);

     }

 void CDummyECCCipherImpl::DecryptL(const TDesC8& aInput, TDes8& aOutput)

     {

     if (iKey->IsPresent(KPassedHandleToKeyUid))

         {

         const TInt& keyHandle = iKey->GetTIntL(KPassedHandleToKeyUid);

         // Invoke the Spi HAI to perform the operation

         CCryptoSpiHai::DecryptL(keyHandle, aInput, aOutput);

         }

     else

         {

         User::Leave(KErrNotSupported);

         }

     }

 // End of file