/*
* Copyright (c) 2007-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: 
* software hash base class implementation
* software hash base class implementation
*
*/


/**
 @file
*/

#include "softwarehashbase.h"

#include <cryptospi/hashplugin.h>
#include "pluginconfig.h"
#include "keys.h"
#include "md2impl.h"
#include "md5impl.h"
#include "md4impl.h"
#include "sha1impl.h"
#include "sha2impl.h"
#include "hmacimpl.h"

using namespace SoftwareCrypto;

CSoftwareHash* CSoftwareHash::NewL(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey)
	{
	CSoftwareHash* self=NewLC(aAlgorithm, aOperationMode, aKey);
	CleanupStack::Pop();
	return self;
	}

CSoftwareHash* CSoftwareHash::NewL(TUid aAlgorithm)
	{
	CSoftwareHash* self=NewLC(aAlgorithm, CryptoSpi::KHashModeUid, NULL);
	CleanupStack::Pop();
	return self;
	}

CSoftwareHash* CSoftwareHash::NewLC(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey)
	{
	CSoftwareHash* self=new (ELeave) CSoftwareHash();
	CleanupStack::PushL(self);
	self->ConstructL(aAlgorithm, aOperationMode, aKey);
	return self;
	}

CSoftwareHash::CSoftwareHash()
	{		
	}

CSoftwareHash::~CSoftwareHash()
	{
	if (iHashImpl)
		{
		iHashImpl->Close();			
		}

	if (iHmacImpl)
		{
		iHmacImpl->Close();
		}
	delete iKey;
	}

void CSoftwareHash::ConstructL(TUid aAlgorithm, TUid aOperationMode, const CKey* aKey)
	{
	//
	// Only Hash and Hmac mode are supported.
	//
	if (aOperationMode!=KHmacModeUid && aOperationMode!=KHashModeUid)
		{
		User::Leave(KErrNotSupported);			
		}
		
	//Set the key if there is one
	if (aKey)
		{
		SetKeyL(*aKey);
		}
	
	switch (aAlgorithm.iUid)
		{
	case KCryptoPluginMd2:
		{
		iHashImpl=CMD2Impl::NewL();
		}
		break;
		
	case KCryptoPluginMd5:
		{
		iHashImpl=CMD5Impl::NewL();
		}
		break;
		
	case KCryptoPluginMd4:
		{
		iHashImpl=CMD4Impl::NewL();
		}
		break;

	case KCryptoPluginSha1:
		{
		iHashImpl=CSHA1Impl::NewL();
		}
		break;
		
	case KCryptoPluginSha224:
	case KCryptoPluginSha256:
	case KCryptoPluginSha384:
	case KCryptoPluginSha512:
		{
		iHashImpl=CSHA2Impl::NewL(aAlgorithm.iUid);
		}
		break;
		
	default:
		User::Leave(KErrNotSupported);
		}
		
	SetOperationModeL(aOperationMode);
	}

void CSoftwareHash::SetOperationModeL(TUid aOperationMode)
	{
	switch (aOperationMode.iUid)
		{
	case KHmacMode:
		{
		//
		//Only create hmac implementation if there isn't one
		//
		if (!iHmacImpl)
			{
			if (iKey)
				{
				iHmacImpl=CHMacImpl::NewL(*iKey, iHashImpl);	
				}
			else
				{
				iHmacImpl=CHMacImpl::NewL(iHashImpl);
				}							
			}
		}
		break;
		
	case KHashMode:
		{
		Reset();	
		}
		break;
		
	default:
		User::Leave(KErrNotSupported);
		}
		
	//
	// Set the operation mode.
	//
	iOperationMode=aOperationMode;
	}

MSoftwareHash* CSoftwareHash::Impl()
	{
	MSoftwareHash* impl=NULL;
	if (iOperationMode==KHashModeUid)
		{
		impl=iHashImpl;
		}
	else if (iOperationMode==KHmacModeUid && iKey)
			{
			impl=iHmacImpl;
			}
	return impl;
	}
	
void CSoftwareHash::SetKeyL(const CKey& aKey)
	{
	Reset();
	delete iKey;
	iKey=CKey::NewL(aKey);
	if (iHmacImpl)
		{
		iHmacImpl->SetKeyL(aKey);
		}
	}
	
void CSoftwareHash::Reset()
	{
	if (iHashImpl)
		{
		iHashImpl->Reset();			
		}
		
	if (iHmacImpl)
		{
		iHmacImpl->Reset();			
		}
	}
	
void CSoftwareHash::Close()
	{
	delete this;
	}
	
void CSoftwareHash::GetCharacteristicsL(const TCharacteristics*& aPluginCharacteristics)
	{
	MSoftwareHash* impl=Impl();
	if (impl)
		{
		impl->GetCharacteristicsL(aPluginCharacteristics);			
		}
	else
		{
		User::Leave(KErrNotReady);
		}		
	}
	
const CExtendedCharacteristics* CSoftwareHash::GetExtendedCharacteristicsL()
	{
	MSoftwareHash* impl=Impl();
	if (!impl)
		{
		User::Leave(KErrNotReady);	
		}
	return impl->GetExtendedCharacteristicsL();
	}
	
TAny* CSoftwareHash::GetExtension(TUid aExtensionId)
	{
	MSoftwareHash* impl=Impl();
	if (impl)
		{
		return impl->GetExtension(aExtensionId);			
		}
	else
		{
		return NULL;	
		}
	}

TPtrC8 CSoftwareHash::Hash(const TDesC8& aMessage)
	{
	MSoftwareHash* impl=Impl();
	if (impl)
		{
		return impl->Hash(aMessage);			
		}
	else
		{
		return KNullDesC8();
		}
	}
	
void CSoftwareHash::Update(const TDesC8& aMessage)
	{
	MSoftwareHash* impl=Impl();
	if (impl)
		{
		return impl->Update(aMessage);
		}
	}
	
TPtrC8 CSoftwareHash::Final(const TDesC8& aMessage)
	{
	MSoftwareHash* impl=Impl();
	if (impl)
		{
		return impl->Final(aMessage);
		}
	else
		{
		return KNullDesC8();
		}
	}
	
MHash* CSoftwareHash::ReplicateL()
	{
	CSoftwareHash* that=new(ELeave)CSoftwareHash();
	CleanupStack::PushL(that);
	if (this->iKey)
		{
		that->iKey=CKey::NewL(*this->iKey);			
		}
	that->iOperationMode=this->iOperationMode;
	that->iHashImpl=static_cast<MSoftwareHash*>(this->iHashImpl->ReplicateL());
	if (this->iHmacImpl)
		{
		that->iHmacImpl=static_cast<MSoftwareHash*>(this->iHmacImpl->ReplicateL());			
		}
	CleanupStack::Pop();
	return that;
	}
	
MHash* CSoftwareHash::CopyL()
	{
	CSoftwareHash* that=new(ELeave)CSoftwareHash();
	CleanupStack::PushL(that);
	if (this->iKey)
		{
		that->iKey=CKey::NewL(*this->iKey);			
		}
	that->iOperationMode=this->iOperationMode;
	that->iHashImpl=static_cast<MSoftwareHash*>(this->iHashImpl->CopyL());
	if (this->iHmacImpl)
		{
		that->iHmacImpl=static_cast<MSoftwareHash*>(this->iHmacImpl->CopyL());
		}
	CleanupStack::Pop();
	return that;
	}