// Copyright (c) 1998-2009 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:

 //

 #include "UE_STD.H"

 #include <pbe.h>

 #define UNUSED_VAR(a) a = a

 TSecureFilter::TSecureFilter()

 	{}

 void TSecureFilter::Set(MStreamBuf* aHost,TInt aMode)

 //

 // Set this filter up for encryption.

 //

 	{

 	TStreamFilter::Set(aHost,aMode);

 	iIn.Zero();

 //	Make sure any header added by the en/de-cryption goes

 //	straight into the output buffer 

     TPtr8 buf(iBuf,sizeof(iBuf));

     TRAPD(r, CryptL(buf,iIn));

     UNUSED_VAR(r);

     iOut.Set(buf);

 	}

 EXPORT_C TInt TSecureFilter::Capacity(TInt aMaxLength)

 //

 // Return the maximum guaranteed input used for aMaxLength output.

 // If we can fulfil the request from the output buffer, consume nothing,

 // otherwise return the space left in the input buffer

 //

 	{

 	return aMaxLength<=iOut.Length() ? 0 : KEncryptionFilterBufSize-iIn.Length();

 	}

 LOCAL_C TInt transfer(TDes8& aTarg,TPtrC8& aSrc)

 	{

 	TInt avail=aTarg.MaxLength()-aTarg.Length();

 	TInt len=Min(aSrc.Length(),avail);

 	if (len)

 		{

 		aTarg.Append(aSrc.Left(len));

 		aSrc.Set(aSrc.Mid(len));

 		}

 	return avail-len;

 	}

 EXPORT_C TInt TSecureFilter::FilterL(TAny* aPtr,TInt aMaxLength,const TUint8*& aFrom,const TUint8* anEnd)

 //

 // Encrypt the input buffer.

 //

 // This must consume all its input - when called during reading, it's asserted

 // that aFrom == anEnd after calling this

 //

 	{

 	TPtr8 dest((TUint8*)aPtr,aMaxLength);

 	TPtrC8 src(aFrom,anEnd-aFrom);

     // Copy as much as possible from the output buffer to the destination

 	TInt req=transfer(dest,iOut);

     // If there's input in src, copy as much as possible to the input buffer

     // iIn.  If the input buffer is full, the output buffer is empty, and there

     // is space in the destination buffer, process data

 	if ((src.Length()==0 || transfer(iIn,src)==0) && req)

 		{	// process input buffer to generate more output

 		do

 			{

             TPtr8 buf(iBuf,sizeof(iBuf));

 			CryptL(buf,iIn);

 			iOut.Set(buf);

             iIn.Zero();

             // Copy as much data as possible from the output buffer to the final

             // destination (updating iOut to point to the remainder), and as

             // much as possible from the source to the input buffer.  If we have

             // completely emptied the output buffer and filled the input buffer,

             // and there is space in the destination buffer, go round again.

 			} while (transfer(dest,iOut) && transfer(iIn,src)==0);

 		}

     // Update client's src pointer to reflect what we've consumed

 	aFrom=src.Ptr();

     // Return the number of bytes output

 	return dest.Length();	

 }

 TInt TSecureFilter::EmitL(const TDesC8& aDes)

 	{

 	TInt len=aDes.Length();

 	if (len)

 		TStreamFilter::EmitL(aDes.Ptr(),len);

 	return len;

 	}

 EXPORT_C void TSecureFilter::DoSynchL()

 //

 // Pad out remaining input if necessary, encrypt and emit.

 //

 	{

 	if (IsCommitted())

 		return;

 //

 	EmitL(iOut);

 	iOut.Set(NULL,0);

 	TPtr8 buf(iBuf,sizeof(iBuf));

 	CompleteL(buf,iIn);

 	TStreamFilter::DoSynchL();

 	Committed();

 	}

 EXPORT_C TEncryptFilter::TEncryptFilter():

 	iKey(NULL)

 /** Constructs an empty encrypting filter object.

 The encrypting filter must be set up before use.

 @see Set() */

 	{}

 EXPORT_C void TEncryptFilter::SetL(MStreamBuf* aHost,CPBEncryptor* aKey,TInt aMode)

 /*

 Set this filter up for encryption using a Password Based Encryption object.

 @publishedPartner

 @leave KErrNoMemory. If a leave occurs, ownership of aKey is retained by the caller, 

 which should thus keep aKey on the cleanup stack when calling this function.

 @param aHost The stream buffer that is the target for encrypted data.

 @param aKey A Password Based Encryption handling object. 

 Ownership is transferred from the caller to this object as long as no allocation leave occurs.

 @param aMode The mode in which the stream buffer is to be used. 

 By default, this is write mode as represented by EWrite.

 */

 	{

     __ASSERT_ALWAYS(aKey!=NULL,Panic(ECryptNoKey));

     iKey=aKey;

 	TSecureFilter::Set(aHost,aMode);

 	}

 EXPORT_C TInt TEncryptFilter::CryptL(TDes8& aTarget,const TDesC8& aSource)

 	{

     iKey->Process(aSource,aTarget);

     return aSource.Length();

 	}

 EXPORT_C void TEncryptFilter::CompleteL(TDes8& aTarget,const TDesC8& aSource)

 	{

 // Encrypt and send remaining input buffer

     if (aSource.Length() > 0)

         {

         CryptL(aTarget, aSource);

         EmitL(aTarget);

         aTarget.Zero();

         }

 	TPtrC8 ptr;

 	ptr.Set(NULL,0);

     iKey->ProcessFinalL(ptr, aTarget);

 	EmitL(aTarget);	

 }

 EXPORT_C void TEncryptFilter::DoRelease()

 	{

 	delete iKey;

 	iKey=NULL;

 	TSecureFilter::DoRelease();

 	}

 EXPORT_C TDecryptFilter::TDecryptFilter():

 	iKey(NULL)

 /** Constructs an empty decrypting filter object.

 The decrypting filter must be set up before use.

 @see Set() */

 	{}

 EXPORT_C void TDecryptFilter::SetL(MStreamBuf* aHost,CPBDecryptor* aKey,TInt aMode)

 /*

 Set this filter up for decryption using a Password Based Encryption object.

 @publishedPartner

 @leave KErrNoMemory. If a leave occurs, ownership of aKey is retained by the caller, 

 which should thus keep aKey on the cleanup stack when calling this function.

 @param aHost The stream buffer that is the source of encrypted data.

 @param aKey A Password Based Encryption decryption object. 

 Ownership is transferred from the caller to this object as long as no allocation leave occurs.

 @param aMode The mode in which the stream buffer is to be used. 

 By default, this is write mode as represented by ERead.

 */

 	{

 	__ASSERT_ALWAYS(aKey!=NULL,Panic(ECryptNoKey));

 	iKey=aKey;

 	TSecureFilter::Set(aHost,aMode);

 	}

 EXPORT_C TInt TDecryptFilter::CryptL(TDes8& aTarget,const TDesC8& aSource)

 	{

     iKey->Process(aSource,aTarget);

     return aSource.Length();

 	}

 EXPORT_C void TDecryptFilter::CompleteL(TDes8& /*aTarget*/,const TDesC8& aSource)

 	{

 	if (aSource.Length()!=0)

 		User::Leave(KErrCorrupt);

 	}

 EXPORT_C void TDecryptFilter::DoRelease()

 	{

 	delete iKey;

 	iKey=NULL;

 	TSecureFilter::DoRelease();

 	}

 void HEncryptFilter::DoRelease()

 //

 // Finished with this filter.

 //

 	{

 	delete this;

 	}

 void HDecryptFilter::DoRelease()

 //

 // Finished with this filter.

 //

 	{

 	delete this;

 	}