// Copyright (c) 2004-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 "esocktestutils.h"
#include <es_sock.h>
#include <es_enum.h>
#include <f32file.h>






EXPORT_C TInt ESockTestUtils::StopAllInterfaces(TDes& aErrDesc)
/**
Close all interfaces that are currently open by attaching to each in turn and then using the Stop() method.

@param None
*/
	{
	// this code is based on the implementation of the same method in TS_RConnection
	// there are no methods used here which are allowed to leave and so the cleanup stack is not used
	TInt err = KErrNone;
	
	// all operations here require a socket server
	RSocketServ ss;	
	err = ss.Connect();

	TDes16IgnoreOverflow overflow;
	aErrDesc.Zero();
	
	// how many open interfaces are there?
	RConnection enumerator;
	if(err == KErrNone)
		{
		err = enumerator.Open(ss);
		}
	TUint noOfConnectionsBefore = 0;
	TUint noOfConnectionsAfter = 0;	
	if(err == KErrNone)
		{
		err = enumerator.EnumerateConnections(noOfConnectionsBefore);
		}	
	if (KErrNone != err)
		{
		aErrDesc.AppendFormat(_L("Up to initial EnumerateConnections failed"), &overflow);
		return err;
		}
	aErrDesc.AppendFormat(_L("Started with %d connections\n"), &overflow, noOfConnectionsBefore);
	// for each interface attach to it and then stop it.
	TPckgBuf<TConnectionInfo> connectionInfo;
	while (noOfConnectionsBefore && err == KErrNone)
		{
		err = enumerator.GetConnectionInfo(1, connectionInfo);
		if (KErrNone != err)
			{
			aErrDesc.AppendFormat(_L("GetConnectionInfo(1) failed"), &overflow);
			break;
			}
		aErrDesc.AppendFormat(_L("Conn#1 IAP=%d, NID=%d\n"), &overflow, connectionInfo().iIapId, connectionInfo().iNetId);
		
		RConnection real;
		err = real.Open(ss);
		if (KErrNone != err)
			{
			aErrDesc.AppendFormat(_L("RConnection::Open() failed"), &overflow);
			break;
			}
		
		//Attach can fail, and it may be acceptible for it to fail
		//if the connection is no longer there.
		err = real.Attach(connectionInfo, RConnection::EAttachTypeNormal);
		if (KErrNone == err)
			{
    		err = real.Stop();
			if(KErrNone != err)
				{
				aErrDesc.Format(_L("RConnection::Stop failed"), &overflow);
				}
			}
		aErrDesc.Format(_L("RConnection::Attach failed with %d - continuing"), &overflow, err);
  		real.Close();
  		
  		//Here we check the ultimate objective of the iteration, i.e.:
  		//at least one connection less. 
		TInt errEnum = enumerator.EnumerateConnections(noOfConnectionsAfter);
		if(errEnum != KErrNone)
			{
			aErrDesc.Format(_L("RConnection::Enumerate failed with %d - continuing"), &overflow, errEnum);
			}
		if (noOfConnectionsAfter < noOfConnectionsBefore)
    		{
    		//Iteration successful. If error attaching, clear it.
    		err = KErrNone;
    		noOfConnectionsBefore = noOfConnectionsAfter;
    		}
    	else if (err == KErrNone)
        	{
            //very strange - no error recorded, though no connection stopped.
            err = KErrGeneral;
        	}
		}
	
	// clean up
	enumerator.Close();
	ss.Close();
	return err;
	}


EXPORT_C void ESockTestUtils::DefaultToConfig1L()
	{
	// If no PDUMMY1 or PDUMMY2 config files are present then run "te_esock_test_copy_config_1.script". This allows elementary tests such as TE_SOCKET
	// to "work out of the box" on a freshly booted ROM, so reducing support costs.
	// This trivial thing is only implemented as a test step because our test scripting language has no conditional support.
	_LIT(KConfiguratorPrivateDir, "\\private\\101F7988\\");
	_LIT(KPDummyCmiMask, "pdummy*.cmi");
	_LIT(KCodealerCmiMask, "esock_codealer*.cmi");

	RFs fs;
	User::LeaveIfError(fs.Connect());

	TFindFile ff(fs);
	CDir* dummyList = NULL;
	TInt ret = ff.FindWildByDir(KPDummyCmiMask, KConfiguratorPrivateDir, dummyList);
	if(ret != KErrNone)
		{
		delete dummyList;
		ret = ff.FindWildByDir(KCodealerCmiMask, KConfiguratorPrivateDir, dummyList);
		if(ret != KErrNone)
			{
			// Run the config script. Very horribly it seems to have to be like this with ScheduleTest, as running
			// TestExecute from a TestExecute test step produces KErrAlreadyExists followed by a garbled log file for the
			// parent. 
			_LIT(KScheduleTestExe, "ScheduleTest");
			_LIT(KCopyConfig1Script, "z:\\testdata\\scripts\\te_esock_test_copy_config_1.script");
			RProcess testExec;
			ret = testExec.Create(KScheduleTestExe, KCopyConfig1Script);
			if(ret == KErrNone)
				{
				TRequestStatus completedStatus;
				testExec.Logon(completedStatus);
				testExec.Resume();
				User::WaitForRequest(completedStatus);
				}
			testExec.Close();
			}
		}
	delete dummyList;
	}





//from deprecated genconn library
//modified to fit in with TE_ methodology
EXPORT_C TBool ESockTestUtils::IsNetworkActiveL()
{

	TBool result = true;
	TInt err = KErrNone;

	RSocketServ ss;
	err = ss.Connect();
	User::LeaveIfError(err);

	RConnection conn;
	err = conn.Open(ss);
	User::LeaveIfError(err);

	TUint count(0);
	err = conn.EnumerateConnections(count);
	User::LeaveIfError(err);


	conn.Close();
	ss.Close();

	//KErrNone - no connections, need to think about return status if there
	//are connections taking place
	if (count==0)
		result= false;
	else
		result= true;

	return result;
}


//from deprecated genconn library
//modified to fit in with TE_ methodology as per esocktestsection9.cp-waitfor
EXPORT_C TInt ESockTestUtils::Delay(TInt aGuardTimerValue)
{
	//Note this function step would have been called from the iTest scripts
	//to delay for a certain amount of milliseconds before checking to see
	//if the socket/network/connection has changed to the desired state.
	//The delay tries to ensure the socket/network/connection
	//status has change before we go to the next step where we would check 
	//this status

	// wait for either test thread or timer to end
	TInt err = KErrNone;
	RTimer GuardTimer;
	GuardTimer.CreateLocal();			// create for this thread
	TRequestStatus TimerStatus;

	//aGuardTimerValue is in milliseconds
	GuardTimer.After(TimerStatus,aGuardTimerValue * 1000); 


	User::WaitForRequest(TimerStatus);
	if( TimerStatus == KRequestPending )
		{
		// This is lifted from SockBench to solve some apparently
		// strange behaviour with the timer.
		
		// Since we are still waiting for this timer, cancel it and
		// wait for the request to be flagged.  I believe this is
		// needed since the kernel may have setup a semaphore on the
		// 'TimerStatus' Request Status.  The Cancel() will flag the
		// status change (or maybe the timer will expire anyway) and
		// if we don't clear it, we may crash later when we return
		// to the Active Scheduler (since the TRequestStatus and
		// RTimer won't exist).
		//
		GuardTimer.Cancel();
		User::WaitForRequest( TimerStatus );
		}
	GuardTimer.Cancel();
	if (TimerStatus == KErrNone)
		err= KErrNone;
	else
		err= KErrGeneral;

	return err;
}