// Copyright (c) 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:
// e32test\entropysources\d_entropysources.cpp
// 
//
/**
 @file
 @internalComponent
 @test
*/
#include <dfcs.h>
#include <kernel/kernel.h>
#include <kernel/kern_priv.h>
#include "kern_test.h"
#include "d_entropysources.h"

//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID				KBASE-entropysources-2703
//! @SYMTestType				UT
//! @SYMTestCaseDesc			Verifies that entropy is contributed to the Secure RNG
//! @SYMPREQ					PREQ211
//! @SYMTestPriority			High
//! @SYMTestActions				
//! 	1. 	TestReseed: tests that the interval between RNG reseeds is less than KMaxReseedTime, unless the platform is 
//!         known not to have a viable entropy source.
//! 		
//! 
//! @SYMTestExpectedResults
//! 	1.	Properties checked:
//! 		1) checks that there is a valid entropy source contrbuting entropy data.
//!         2) checks that the entropy collection framework is functioning correctly..
//! 	
//---------------------------------------------------------------------------------------------------------------------

class DEntropySourcesFactory : public DLogicalDevice
    {
public:
    DEntropySourcesFactory();
    virtual TInt Install();    
    virtual void GetCaps(TDes8 &aDes) const;
    virtual TInt Create(DLogicalChannelBase*& aChannel); 
    };

class DEntropySources : public DLogicalChannelBase
    {
public:
 	DEntropySources();
   ~DEntropySources();    
    void ReseedHook();
    
protected:    
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);

private:
    DThread*        iClient;
    TClientRequest* iRequest;    
    };

// Function to be called from the kernel side code.
void ReseedHook(TAny* aPtr)
    {
	((DEntropySources*)aPtr)->ReseedHook();
    }

DECLARE_STANDARD_LDD()
    {
     return new DEntropySourcesFactory;
    }

//
// DEntropySourcesFactory
//

DEntropySourcesFactory::DEntropySourcesFactory()
    {
    // Set version number for this device
    iVersion = TVersion(0,1,1);

    // Indicate we don't support units or a PDD
    iParseMask = 0;
    }

TInt DEntropySourcesFactory::Install()
    {
    return(SetName(&KEntropySourcesName));
    }

void DEntropySourcesFactory::GetCaps(TDes8& aDes) const
    {
    // Create a capabilities object
    TCapsEntropySources caps;
    caps.iVersion = iVersion;

    // Write it back to user memory
    Kern::InfoCopy(aDes,(TUint8*)&caps,sizeof(caps));
    }

TInt DEntropySourcesFactory::Create(DLogicalChannelBase*& aChannel)
    {
    aChannel = new DEntropySources;
    if(!aChannel)
        return KErrNoMemory;
    return KErrNone;
    }

//
// DEntropySources
//

DEntropySources::DEntropySources()
	{
    iClient = &Kern::CurrentThread();
    iClient->Open();
	}

DEntropySources::~DEntropySources()
    {
	KernTest::Test(KernTest::ERNGReseedHook, NULL, NULL);
    Kern::SafeClose((DObject*&)iClient, NULL);
	Kern::DestroyClientRequest(iRequest);
    }

TInt DEntropySources::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
	{
	return Kern::CreateClientRequest(iRequest);
	}

TInt DEntropySources::Request(TInt aReqNo, TAny* a1, TAny* a2)
    {
    (void)a2;
    TInt r = KErrNotSupported;
    switch(aReqNo)
        {
        case ~REntropySources::EReseedTest:
            r = iRequest->SetStatus((TRequestStatus*)a1);
			if (r!=KErrNone)
				return r;
            KernTest::Test(KernTest::ERNGReseedHook, (TAny*)&::ReseedHook, this);            
            break;
        }
    return r;
    }

void DEntropySources::ReseedHook()
    {
	KernTest::Test(KernTest::ERNGReseedHook, NULL, NULL);
    Kern::QueueRequestComplete(iClient, iRequest, KErrNone);
    }