/*
* 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);
        }
    if(iAesWriteStatus)
        {
        // Finished with client descriptor, so NULL it to help detect coding errors
        iAesWriteDescriptor = NULL;
        // Complete clients request (nb following call set iAesWriteStatus to 0)
        Kern::RequestComplete(iParent.iClient,iAesWriteStatus, aResult);
        }
	}



/**
  Cancel a Aes Read request.
*/
void DLddChanAes::CancelRead()
    {
	TRACE_FUNCTION("CancelRead");
    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,KErrCancel);
        }
    }

/**
  Cancel a Aes Write request.
*/
void DLddChanAes::CancelWrite()
    {
	TRACE_FUNCTION("CancelWrite");
    if(iAesWriteStatus)
        {
        // Finished with client descriptor, so NULL it to help detect coding errors
        iAesWriteDescriptor = NULL;
        // Complete clients request (nb following call set iAesWriteStatus to 0)
        Kern::RequestComplete(iParent.iClient,iAesWriteStatus,KErrCancel);
        }
    }

// End of file