/*

* 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: 

*

*/

/**

 @file

 @internalComponent

 @released

*/

#include <kernel/kern_priv.h>

#include "cryptodriver.h"

#include "cryptoldd.h"

#include "keyhandle.h"

#include "kmskext.h"

DECLARE_STANDARD_LDD()

    {

    return new DCryptoLddChannelFactory;

    }

//#define HW_PERF_CHECK

_LIT(KCryptoPanicCategory,"DCrypto");

/**

  Constructor

*/

DCryptoLddChannelFactory::DCryptoLddChannelFactory()

	{

	TRACE_FUNCTION("DCryptoLddChannelFactory");

	// Set version number for this device

    iVersion=RCryptoDriver::VersionRequired();

	// Auto load a PDD

    iParseMask=KDeviceAllowPhysicalDevice;

	}

/**

  Destructor

*/

DCryptoLddChannelFactory::~DCryptoLddChannelFactory()

	{

	TRACE_FUNCTION("~DCryptoLddChannelFactory");

	TraceFunction::DumpCounts();

	}

/**

  Second stage constructor for DCryptoLddChannelFactory.

  This must at least set a name for the driver object.

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DCryptoLddChannelFactory::Install()

	{

	TRACE_FUNCTION("Install");

    return SetName(&RCryptoDriver::Name());

	}

/**

  Return the drivers capabilities.

  Called in the response to an RDevice::GetCaps() request.

  @param aDes Descriptor into which capabilities information is to be written.

*/

void DCryptoLddChannelFactory::GetCaps(TDes8& aDes) const

	{

	TRACE_FUNCTION("GetCaps");

    // Create a capabilities object

    RCryptoDriver::TCaps caps;

	caps.iVersion = iVersion;

	// We do not have a handle to the PDD, and it might not have been

	// loaded yet, so we can't ask it for its capabilities...

    // Write it back to user memory

    Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));

 	return;

	}

/**

  Called by the kernel's device driver framework to create a Logical Channel.

  This is called in the context of the user thread (client) which requested the creation

  of the Logical Channel (e.g. through a call to RBusLogicalChannel::DoCreate).

  The thread is in a critical section.

  @param aChannel Set to point to the created Logical Channel

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DCryptoLddChannelFactory::Create(DLogicalChannelBase*& aChannel)

	{

	TRACE_FUNCTION("Create");

    aChannel=new DCryptoLddChannel;

    if(!aChannel)

        return KErrNoMemory;

    return KErrNone;

	}

//

// Logical Channel

//

/**

  Constructor

*/

DCryptoLddChannel::DCryptoLddChannel()

    : iLddChanRandom(*this),

	  iLddChanAes(*this)

	{

	TRACE_FUNCTION("DCryptoLddChannel");

    // Get pointer to client thread's DThread object

    iClient=&Kern::CurrentThread();

    // Open a reference on client thread so its control block can't disappear until

    // this driver has finished with it.

    // Note, this call to Open() can't fail since it is the thread we are currently running in.

    iClient->Open();

    }

/**

  Destructor

*/

DCryptoLddChannel::~DCryptoLddChannel()

    {

	TRACE_FUNCTION("~DCryptoLddChannel");

    // Cancel all processing that we may be doing

    DoCancel(RCryptoDriver::EAllRequests);

    // Close our reference on the client thread

    Kern::SafeClose((DObject*&)iClient,NULL);

    }

/**

  Second stage constructor called by the kernel's device driver framework.

  This is called in the context of the user thread (client) which requested the creation

  of the Logical Channel (e.g. through a call to RBusLogicalChannel::DoCreate())

  The thread is in a critical section.

  @param aUnit The unit argument supplied by the client to RBusLogicalChannel::DoCreate()

  @param aInfo The info argument supplied by the client to RBusLogicalChannel::DoCreate()

  @param aVer The version argument supplied by the client to RBusLogicalChannel::DoCreate()

  @return KErrNone if successful, otherwise one of the other system wide error codes.

*/

TInt DCryptoLddChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)

    {

	TRACE_FUNCTION("DoCreate");

    // Check Platform Security capabilities of client thread (if required).

    //

    // Here we handle the simple case where:

    // 1. The device driver can only have one client thread

    // 2. The security policy is the binary all-or-nothing policy.

    // E.g. "If you have the right capability you can do anything with the driver

    // and if you don't have the capability you can't do anything"

    // 

    // If only some functionality of the driver is restricted, then the security check should

    // go elsewhere. E.g. in DoRequest/DoControl. In that case Kern::CurrentThreadHasCapability

    // shouldn't be used because the 'current thread' isn't the client.

    //

    // In this example we do a check here for ECapability_None (which always passes)...

    if(!Kern::CurrentThreadHasCapability(ECapability_None,__PLATSEC_DIAGNOSTIC_STRING("Checked by DRIVER1")))

        return KErrPermissionDenied;

    // Check version

    if (!Kern::QueryVersionSupported(RCryptoDriver::VersionRequired(),aVer))

        return KErrNotSupported;

     // Give PDD a pointer to this channel

    PddChan()->iCryptoLddChannel = this;

    // Setup LDD for receiving client messages.

    SetDfcQ(PddChan()->DfcQue());

    iMsgQ.Receive();

    // Done

    return KErrNone;

    }

/**

  Called when a user thread requests a handle to this channel.

*/

TInt DCryptoLddChannel::RequestUserHandle(DThread* aThread, TOwnerType aType)

    {

	TRACE_FUNCTION("RequestUserHandle");

    // Make sure that only our client can get a handle

    if (aType!=EOwnerThread || aThread!=iClient)

        return KErrAccessDenied;

    return KErrNone;

    }

/**

  Process a message for this logical channel.

  This function is called in the context of a DFC thread.

  @param aMessage The message to process.

     The iValue member of this distinguishes the message type:

     iValue==ECloseMsg, channel close message

     iValue==KMaxTInt, a 'DoCancel' message

     iValue>=0, a 'DoControl' message with function number equal to iValue

     iValue<0, a 'DoRequest' message with function number equal to ~iValue

*/

void DCryptoLddChannel::HandleMsg(TMessageBase* aMsg)

    {

	TRACE_FUNCTION("HandleMsg");

    TThreadMessage& m=*(TThreadMessage*)aMsg;

    // Get message type

    TInt id=m.iValue;

    // Decode the message type and dispatch it to the relevent handler function...

    if (id==(TInt)ECloseMsg)

        {

        // Channel Close

        DoCancel(RCryptoDriver::EAllRequests);

        m.Complete(KErrNone, EFalse);

        return;

        }

    if (id==KMaxTInt)

        {

        // DoCancel

        DoCancel(m.Int0());

        m.Complete(KErrNone,ETrue);

        return;

        }

    if (id<0)

        {

        // DoRequest

        TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

        TInt r=DoRequest(~id,pS,m.Ptr1(),m.Ptr2());

        if (r!=KErrNone)

            Kern::RequestComplete(iClient,pS,r);

        m.Complete(KErrNone,ETrue);

        }

    else

        {

        // DoControl

        TInt r=DoControl(id,m.Ptr0(),m.Ptr1());

        m.Complete(r,ETrue);

        }

    }

/**

  Process synchronous 'control' requests

*/

TInt DCryptoLddChannel::DoControl(TInt aFunction, TAny* a1, TAny *)

    {

	TRACE_FUNCTION("DoControl");

    TInt r;

    switch (aFunction)

        {

        case RCryptoDriver::EGetHwVersions:

            r = GetHwVersions((TDes8*)a1);

            break;

        case RCryptoDriver::EGetConfig:

            r = GetConfig((TDes8*)a1);

            break;

        case RCryptoDriver::ESetConfig:

            r = SetConfig((const TDesC8*)a1);

            break;

        case RCryptoDriver::EAesSetConfig:

            r = iLddChanAes.SetAesConfig((const TDesC8*)a1);

            break;

        default:

            r=KErrNotSupported;

            break;

        }

    return r;

    }

/**

  Process asynchronous requests

*/

TInt DCryptoLddChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

    {

	TRACE_FUNCTION("DoRequest");

    (void)a2; // a2 not used in this example

    TInt r;

    switch(aReqNo)

        {

        case RCryptoDriver::ERandom:

			r=iLddChanRandom.Random(aStatus,(TDes8*)a1);

            break;

        case RCryptoDriver::EAesWrite:

			r=iLddChanAes.AesWrite(aStatus,(TDesC8*)a1);

            break;

        case RCryptoDriver::EAesRead:

			r=iLddChanAes.AesRead(aStatus,(TDes8*)a1, (TUint32)a2);

            break;

        default:

            r=KErrNotSupported;

            break;

        }

    return r;

    }

/**

  Process cancelling of asynchronous requests

*/

void DCryptoLddChannel::DoCancel(TUint aMask)

    {

	TRACE_FUNCTION("DoCancel");

    if(aMask&(1<<RCryptoDriver::ERandom))

		{

		iLddChanRandom.RandomCancel();

		}

    if(aMask&(1<<RCryptoDriver::EAesRead))

		{

        iLddChanAes.CancelRead();

		}

    if(aMask&(1<<RCryptoDriver::EAesWrite))

		{

        iLddChanAes.CancelWrite();

		}

    }

/**

  Process a GetHwVersions control message. This writes the crypto h/w versions to a

  RCryptoDriver::THwVersionsBuf supplied by the client.

*/

TInt DCryptoLddChannel::GetHwVersions(TDes8* aHwVersionsBuf) const

    {

	TRACE_FUNCTION("GetHwVersions");

    // Create a structure giving the current configuration

    RCryptoDriver::THwVersions versions;

	PddChan()->GetHwVersions(versions);

    // Write the config to the client

    TPtrC8 ptr((const TUint8*)&versions,sizeof(versions));

    return Kern::ThreadDesWrite(iClient,aHwVersionsBuf,ptr,0,KTruncateToMaxLength,NULL);

    }

//

// Functions for processing configuration control messages

//

/**

  Process a GetConfig control message. This writes the current driver configuration to a

  RCryptoDriver::TConfigBuf supplied by the client.

*/

TInt DCryptoLddChannel::GetConfig(TDes8* aConfigBuf) const

    {

	TRACE_FUNCTION("GetConfig");

    // Create a structure giving the current configuration

    RCryptoDriver::TConfig config;

    CurrentConfig(config);

    // Write the config to the client

    TPtrC8 ptr((const TUint8*)&config,sizeof(config));

    return Kern::ThreadDesWrite(iClient,aConfigBuf,ptr,0,KTruncateToMaxLength,NULL);

    }

/**

  Process a SetConfig control message. This sets the driver configuration using a

  RCryptoDriver::TConfigBuf supplied by the client.

*/

TInt DCryptoLddChannel::SetConfig(const TDesC8* aConfigBuf)

    {

	TRACE_FUNCTION("SetConfig");

    // Don't allow configuration changes whilst we're busy

	//    if(iSendDataStatus || iReceiveDataStatus)

	//        return KErrInUse;

    // Create a config structure.

    RCryptoDriver::TConfig config;

    CurrentConfig(config);

    // Note: We have filled config with the current settings, this is to allow

    // backwards compatibility when a client gives us an old (and shorter) version

    // of the config structure.

    // Read the config structure from client

    TPtr8 ptr((TUint8*)&config,sizeof(config));

    TInt r=Kern::ThreadDesRead(iClient,aConfigBuf,ptr,0);

    if(r!=KErrNone)

        return r;

    // Use config data to setup the driver. Checking that parameters which aren't settable

    // either contain the correct values or are zero (meaning 'default')

	r=PddChan()->SetFakeDriverSetting(config.iFakeDriverSetting);

    if(r!=KErrNone)

        return r;

    return r;

    }

/**

  Fill a TConfig with the driver's current configuration.

*/

void DCryptoLddChannel::CurrentConfig(RCryptoDriver::TConfig& aConfig) const

    {

	TRACE_FUNCTION("TConfig");

    aConfig.iFakeDriverSetting = PddChan()->FakeDriverSetting();

    }

//

// Functions for processing 'Random'

//

DLddChanRandom::DLddChanRandom(DCryptoLddChannel &aParent)

	: iParent(aParent)

	{

	TRACE_FUNCTION("DLddChanRandom");

	}

/**

  Start processing a Random request.

*/

TInt DLddChanRandom::Random(TRequestStatus* aStatus,TDes8* aPtr)

    {

	TRACE_FUNCTION("Random");

    // Check that a 'Random' isn't already in progress

    if(iRandomStatus)

        {

        Kern::ThreadKill(iParent.iClient,EExitPanic,ERequestAlreadyPending,KCryptoPanicCategory);

        return KErrInUse;

        }

	// We only support a single outstanding Random request in this LDD

	// channel, but the PDD supports multiple requests.

    // Save the client request status and descriptor

    iRandomStatus = aStatus;

    iRandomDescriptor = aPtr;

	// Retrieve user request length (ie. CURRENT length of user descriptor) into iRequestLength

	TInt tmp;

	TUint8 *tmp2;

	TInt r=Kern::ThreadGetDesInfo(iParent.iClient, iRandomDescriptor, iRequestLength, tmp, tmp2, ETrue);

	if(r != KErrNone)

		{

		return r;

 		}

	// Set current offset into user descriptor

	iCurrentIndex = 0;

	iJob = iParent.PddChan()->GetJobRandom();

	// Setup PDD job

	iJob->SetDetails(&iParent.LddFactory()->iJSRandom, this, iRequestLength);

	// Register it, which will also (maybe later) call DoSlice to run it

	iParent.LddFactory()->iJSRandom.ScheduleJob(iJob);

	return KErrNone;

    }

TInt DLddChanRandom::DataRequired()

	{

	TRACE_FUNCTION("DataRequired");

	return KErrNone; // We never pass data to the h/w...

	}

TInt DLddChanRandom::DataAvailable()

	{

	TRACE_FUNCTION("DataAvailable");

	//	Kern::Printf("DLddChanRandom::DataAvailable()");

	TInt r = KErrNone;

	TUint8 *buf;

	TUint32 bufLen;

	TBool check = ETrue;

	while(check)

		{

		iJob->GetFromPddBuffer(buf, bufLen, check);

		if(bufLen)

			{

			TInt required = iRequestLength - iCurrentIndex;

			TInt toTransfer = bufLen;

			if(toTransfer > required)

				{

				toTransfer = required;

				}

			// Copy the current buffer to user land

			TPtr8 des(buf, toTransfer, toTransfer);

			r=Kern::ThreadDesWrite(iParent.iClient, iRandomDescriptor, des, iCurrentIndex);

			if(r != KErrNone)

				{

				break;

				}

			// Update our index into the user descriptor

			iCurrentIndex += toTransfer;

			// Update h/w with number of bytes actually read

			iJob->BytesReadFromPdd(toTransfer);

			if(toTransfer != bufLen)

				{

				// We did not read all the available data, so do not

				// re-query h/w

				check = EFalse;

				}

			}

		};

	return r;

	}

void DLddChanRandom::JobComplete(TInt aResult)

	{

	TRACE_FUNCTION("JobComplete");

	if(iRandomStatus)

		{

		// Finished with client descriptor, so NULL it to help detect coding errors

		iRandomDescriptor = NULL;

		// Complete client's request

		Kern::RequestComplete(iParent.iClient,iRandomStatus, aResult);

		}

	}

/**

  Cancel a Random request.

*/

void DLddChanRandom::RandomCancel()

    {

	TRACE_FUNCTION("RandomCancel");

    if(iRandomStatus)

        {

        // Tell PDD to stop processing the request

        iParent.LddFactory()->iJSRandom.DeScheduleJob(iParent.PddChan()->GetJobRandom());

        // Finished with client descriptor, so NULL it to help detect coding errors

        iRandomDescriptor = NULL;

        // Complete clients request

        Kern::RequestComplete(iParent.iClient,iRandomStatus,KErrCancel);

        }

    }

//

// Functions for processing 'Aes'

//

DLddChanAes::DLddChanAes(DCryptoLddChannel &aParent)

	: iParent(aParent)

	{

	TRACE_FUNCTION("DLddChanAes");

	}

TInt DLddChanAes::SetAesConfig(const TDesC8* aConfigBuf)

	{

	TRACE_FUNCTION("SetAesConfig");

	// Note we need to validate arguments kernel side otherwise

	// someone could easily crash the kernel...

	RCryptoDriver::TAesConfig config;

    // Read the config structure from client

    TPtr8 ptr((TUint8*)&config,sizeof(config));

    TInt r=Kern::ThreadDesRead(iParent.iClient,aConfigBuf,ptr,0);

    if(r!=KErrNone)

		{

		return r;

		}

	//	Kern::Printf("iEncrypt = 0x%x",config.iEncrypt);

	//	Kern::Printf("iMode = 0x%x",config.iMode);

	//	Kern::Printf("iKey = 0x%x",config.iKey);

	//	Kern::Printf("iIV = 0x%x",config.iIV);

	// Remember direction

	iEncrypt = config.iEncrypt;

	// Remember mode

	iMode = config.iMode;

	//

	// Handle key

	//

	// Retrieve user key length into iKeyLengthBytes

	TInt tmp;

	TUint8 *tmp2;

	r=Kern::ThreadGetDesInfo(iParent.iClient, (TAny *)config.iKey, iKeyLengthBytes, tmp, tmp2, EFalse);

    if(r!=KErrNone)

		{

		return r;

		}

	HBuf8 *embeddedKeyData = 0;

	if(iKeyLengthBytes == 4)

		{

		// Some form of embedded key so value is a 32 bit handle

		TPckgBuf<TKeyHandle> keyHandlePkg;	

		r=Kern::ThreadDesRead(iParent.iClient, (TAny *)config.iKey, keyHandlePkg, 0);

		if(r != KErrNone)

			{

			return r;

			}

		TKeyHandle &keyHandle = keyHandlePkg();

		r = HwKeyStore::ExtractKey(iParent.iClient->iOwningProcess, keyHandle, 0 /*operation*/, embeddedKeyData);

		if(r != KErrNone)

			{

			return r;

			}

		// Update key length

		iKeyLengthBytes = embeddedKeyData->Length();

		}

	switch(iKeyLengthBytes)

		{

		case 16: // 128 bits

			break;

		case 24: // 192 bits

			break;

		case 32: // 256 bits

			break;

		default: // Illegal length

			if(embeddedKeyData) delete embeddedKeyData;

			return KErrArgument;

		}

	// Make sure iJob is valid before we use it

	iJob = iParent.PddChan()->GetJobAes();

	TUint8 *keyBuffer = iJob->GetKeyBuffer();

	TPtr8 des(keyBuffer, iKeyLengthBytes);

	if(embeddedKeyData)

		{

		// Copy embedded key to PDD

		des = *embeddedKeyData;

		delete embeddedKeyData;

		embeddedKeyData = 0;

		}

	else

		{

		// Retrieve key from user

		r=Kern::ThreadDesRead(iParent.iClient, (TAny *)config.iKey, des, 0);

		if(r != KErrNone)

			{

			return r;

			}

		}

	//

	// Handle IV

	//

	// Retrieve IV length

	TInt ivLength;

	r=Kern::ThreadGetDesInfo(iParent.iClient, (TAny *)config.iIV, ivLength, tmp, tmp2, EFalse);

	//	Kern::Printf("DLddChanAes::SetAesConfig r=%d 5",r);

	if(r != KErrNone)

		{

		return r;

		}

	if((ivLength != 0) && (ivLength != 16))

		{

		return KErrArgument;

		}

	if(ivLength == 16)

		{

		TUint8 *ivBuffer = iJob->GetIVBuffer();

		TPtr8 des(ivBuffer, 16);

		r=Kern::ThreadDesRead(iParent.iClient, (TAny *)config.iIV, des, 0);

		if(r != KErrNone)

			{

			return r;

			}

		}

	// Set details

	r = iJob->SetDetails(&iParent.LddFactory()->iJSAes, this, iEncrypt, iKeyLengthBytes, iMode);

	if(r != KErrNone)

		{

		return r;

		}

	return KErrNone;

	}

/**

  Start processing a Aes request.

*/

TInt DLddChanAes::AesWrite(TRequestStatus* aStatus, TDesC8* aPtr)

    {

	TRACE_FUNCTION("AesWrite");

	//	Kern::Printf("DLddChanAes::AesWrite");

    // Check that an Aes Write isn't already in progress

    if(iAesWriteStatus)

        {

        Kern::ThreadKill(iParent.iClient,EExitPanic,ERequestAlreadyPending,KCryptoPanicCategory);

        return KErrInUse;

        }

	// We only support a single outstanding Aes Write request in this LDD

	// channel, but the PDD supports multiple requests.

    // Save the client request status and descriptor

    iAesWriteStatus = aStatus;

    iAesWriteDescriptor = aPtr;

	// Retrieve user request length (ie. current length of user descriptor) into iRequestLength

	TInt maxLen;

	TUint8 *aesWriteDescriptorBufferRaw;

	TInt r=Kern::ThreadGetDesInfo(iParent.iClient, iAesWriteDescriptor, iWriteRequestLength, maxLen, aesWriteDescriptorBufferRaw, EFalse);

	if(r != KErrNone)

		{

		iAesWriteStatus = 0;

		return r;

 		}

	// Set current offset into user descriptor

	iCurrentUserWriteIndex = 0;

	// Make sure iJob is valid before we use it

	iJob = iParent.PddChan()->GetJobAes();

#ifdef HW_PERF_CHECK

	iJob->HwPerfCheck();

#else

	// Feed some data to the PDD

	r = DataRequired(); // Fake PDD callback to get data from us.

	if(r != KErrNone)

		{

		iAesWriteStatus = 0;

		return r;

 		}

	// Make sure job is not stalled, and maybe (re)add to job list.

	iJob->Resume();

#endif

	return KErrNone;

    }

TInt DLddChanAes::AesRead(TRequestStatus* aStatus, TDes8* aPtr, TUint32 aLength)

    {

	TRACE_FUNCTION("AesRead");

	//	Kern::Printf("DLddChanAes::AesRead");

    // Check that an Aes Read isn't already in progress

    if(iAesReadStatus)

        {

        Kern::ThreadKill(iParent.iClient,EExitPanic,ERequestAlreadyPending,KCryptoPanicCategory);

        return KErrInUse;

        }

	// We only support a single outstanding Aes Read request in this LDD

	// channel, but the PDD supports multiple requests.

    // Save the client request status and descriptor

    iAesReadStatus = aStatus;

    iAesReadDescriptor = aPtr;

	iReadRequestLength = aLength;

	// Retrieve user request length (ie. current length of user descriptor) into iRequestLength

	//	TInt iOriginalUserReadDescLength;

	TUint8 *aesReadDescriptorBufferRaw;

	TInt maxLen;

	TInt r=Kern::ThreadGetDesInfo(iParent.iClient, iAesReadDescriptor, iOriginalUserReadDescLength, maxLen, aesReadDescriptorBufferRaw, ETrue);

	if(r != KErrNone)

		{

		iAesReadStatus = 0;

		return r;

 		}

	if(iReadRequestLength > (maxLen - iOriginalUserReadDescLength))

		{

		return KErrArgument;

		}

	// Set current offset into user descriptor

	iCurrentUserReadIndex = 0;

	// Tell PDD our request length so it can optimse returning the data to us.

	iJob->NotifyReadRequestLength(iReadRequestLength);

#ifndef HW_PERF_CHECK

	// Make sure iJob is valid before we use it

	iJob = iParent.PddChan()->GetJobAes();

	// Process any data already available

	r = DataAvailable(); // Fake PDD callback to read data from PDD

	if(r != KErrNone)

		{

		iAesReadStatus = 0;

		return r;

 		}

	// Make sure job is not stalled (and maybe re-add to job list) We

	// do this even if we completely satisified the read from the PDD

	// buffer because a write might be waiting for space in the

	// buffer...

	iJob->Resume();

#endif

	return KErrNone;

	}

TInt DLddChanAes::DataRequired()

	{

	TRACE_FUNCTION("DataRequired");

	//	Kern::Printf("DLddChanAes::DataRequired");

	if(!iAesWriteStatus)

		{

		return KErrNone;

		}

	TBool moreSpace = ETrue;

	TInt toWrite = (iWriteRequestLength - iCurrentUserWriteIndex);

	while(toWrite && moreSpace)

		{

		// Get details of PDD write buffer

		TUint8 *pddBuf; // always valid, though pddBufLen might be 0

		TUint32 pddBufLen; // maybe 0

		iJob->GetToPddBuffer(pddBuf, pddBufLen, moreSpace);

		if(toWrite > pddBufLen)

			{

			toWrite = pddBufLen;

			}

		// Make sure there is some data to write

		if(toWrite == 0)

			{

			break;

			}

		TPtr8 des(pddBuf, toWrite);

		TInt r=Kern::ThreadDesRead(iParent.iClient, iAesWriteDescriptor, des, iCurrentUserWriteIndex);

		//TInt r = 0;

		if(r!=KErrNone)

			return r;

		iCurrentUserWriteIndex += toWrite;

		// Tell the PDD how many bytes we wrote to it.

		// If we wrote data, and the job was not already queued, the

		// PDD will call ScheduleJob for it.

		iJob->BytesWrittenToPdd(toWrite);

		// Update count of bytes left to write

		toWrite = (iWriteRequestLength - iCurrentUserWriteIndex);

		};

	if((iWriteRequestLength - iCurrentUserWriteIndex) <= 0)

		{

		// Write request is complete

		// Finished with client descriptor, so NULL it to help detect coding errors

		iAesWriteDescriptor = NULL;

		// Complete client's request

		Kern::RequestComplete(iParent.iClient,iAesWriteStatus, KErrNone);

		return KErrNone;

		}

	return KErrNone;

	}

TInt DLddChanAes::DataAvailable()

	{

	TRACE_FUNCTION("DataAvailable");

	//	Kern::Printf("DLddChanAes::DataAvailable()");

	if(!iAesReadStatus)

		{

		return KErrNone;

		}

	TInt r = KErrNone;

	TUint8 *buf;

	TUint32 bufLen;

	TBool check = ETrue;

	while(check)

		{

		iJob->GetFromPddBuffer(buf, bufLen, check);

		if(bufLen)

			{

			TInt required = iReadRequestLength - iCurrentUserReadIndex;

			TInt toTransfer = bufLen;

			if(toTransfer > required)

				{

				toTransfer = required;

				}

			// Copy the current buffer to user land

			TPtr8 des(buf, toTransfer, toTransfer);

			r=Kern::ThreadDesWrite(iParent.iClient, iAesReadDescriptor, des, iOriginalUserReadDescLength + iCurrentUserReadIndex);

			//r  = 0;

			if(r != KErrNone)

				{

				break;

				}

			// Update our index into the user descriptor

			iCurrentUserReadIndex += toTransfer;

			// Update h/w with number of bytes actually read

			iJob->BytesReadFromPdd(toTransfer);

			if(toTransfer != bufLen)

				{

				// We did not read all the available data, so do not

				// re-query h/w

				check = EFalse;

				}

			}

		};

	if((iReadRequestLength - iCurrentUserReadIndex) <= 0)

		{

		// Read request is complete

		// Finished with client descriptor, so NULL it to help detect coding errors

		iAesReadDescriptor = NULL;

		// Complete client's request

		Kern::RequestComplete(iParent.iClient,iAesReadStatus, KErrNone);

		return KErrNone;

		}

	return KErrNone;

	}

/**

  Called by PDD from a DFC to indicate that a Aes operation has completed.

*/

void DLddChanAes::JobComplete(TInt aResult)

	{

	TRACE_FUNCTION("JobComplete");

	// Normally not used for AES, instead the job keeps running and

	// DataAvailable/DataRequired complete the AesRead/AesWrite

	// requests.

	// 

	// Will be called if xfer to/from user space fails (or if another

	// fatal error occurs).

    if(iAesReadStatus)

        {

        // Finished with client descriptor, so NULL it to help detect coding errors

        iAesReadDescriptor = NULL;

        // Complete clients request (nb following call set iAesReadStatus to 0)

        Kern::RequestComplete(iParent.iClient,iAesReadStatus, aResult);

        }