/*

* 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