// 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:
// Contains definition of CTestStepSocket which is the base class 
// for all the Socket Test Step classes (p.s. very dummy class) 
// 
//

// EPOC includes
#include <e32base.h>
#include <es_sock.h>
#include <test/es_dummy.h>

// Test system includes
#include "TestStepSocket.h"


// static consts
const TUint CTestStepSocket::KNumTestSockets = 10;
const TInt CTestStepSocket::KNumExhaustiveSockets = 100;
const TInt CTestStepSocket::KNumStretchOpens = 16;

_LIT(KProtocolName, "Dummy Protocol 1");          // Name of test protocol to use in these tests
_LIT8(KSendStringTest, "Bad descriptor"); // Sample testdata to send in these tests

const TInt segmentlengthtest = 1;
const TInt txlengthtest = 42; // Length of KSEndStringTest Its useful to be const

// constructor
CTestStepSocket::CTestStepSocket() : iErrText()
	{
	}

// destructor
CTestStepSocket::~CTestStepSocket()
	{
	}


enum TVerdict CTestStepSocket::doTestStepL()
	{
	
	TRAPD(trapRet,
		Logger().ShareAuto();
	enum TVerdict stepRet = InternalDoTestStepL();
	if (stepRet !=EPass)
		{
		SetTestStepResult(stepRet);
		}
		)
		
		if (trapRet != KErrNone)
			{
			SetTestStepResult(EFail);
			return EFail;
			}
		return EPass;
	};


// extra logging methods
const TPtrC& CTestStepSocket::EpocErrorToText(const TInt aErrCode)
/**
Convert a Error code to text.

  @param aError error code to display as text.
  @return Text describing the error.
  */
	{
	//	TPtr errText;
	switch (aErrCode)
		{
		case KErrNone:
			iErrText.Set(_L("KErrNone"));
			break;
		case KErrNotFound:
			iErrText.Set(_L("KErrNotFound"));
			break;
		case KErrGeneral:
			iErrText.Set(_L("KErrGeneral"));
			break;
		case KErrCancel:
			iErrText.Set(_L("KErrCancel"));
			break;
		case KErrNoMemory:
			iErrText.Set(_L("KErrNoMemory"));
			break;
		case KErrNotSupported:
			iErrText.Set(_L("KErrNotSupported"));
			break;
		case KErrArgument:
			iErrText.Set(_L("KErrArgument"));
			break;
		case KErrTotalLossOfPrecision:
			iErrText.Set(_L("KErrTotalLossOfPrecision"));
			break;
		case KErrBadHandle:
			iErrText.Set(_L("KErrBadHandle"));
			break;
		case KErrOverflow:
			iErrText.Set(_L("KErrOverflow"));
			break;
		case KErrUnderflow:
			iErrText.Set(_L("KErrUnderflow"));
			break;
		case KErrAlreadyExists:
			iErrText.Set(_L("KErrAlreadyExists"));
			break;
		case KErrPathNotFound:
			iErrText.Set(_L("KErrPathNotFound"));
			break;
		case KErrDied:
			iErrText.Set(_L("KErrDied"));
			break;
		case KErrInUse:
			iErrText.Set(_L("KErrInUse"));
			break;
		case KErrServerTerminated:
			iErrText.Set(_L("KErrServerTerminated"));
			break;
		case KErrServerBusy:
			iErrText.Set(_L("KErrServerBusy"));
			break;
		case KErrCompletion:
			iErrText.Set(_L("KErrCompletion"));
			break;
		case KErrNotReady:
			iErrText.Set(_L("KErrNotReady"));
			break;
		case KErrUnknown:
			iErrText.Set(_L("KErrUnknown"));
			break;
		case KErrCorrupt:
			iErrText.Set(_L("KErrCorrupt"));
			break;
		case KErrAccessDenied:
			iErrText.Set(_L("KErrAccessDenied"));
			break;
		case KErrLocked:
			iErrText.Set(_L("KErrLocked"));
			break;
		case KErrWrite:
			iErrText.Set(_L("KErrWrite"));
			break;
		case KErrDisMounted:
			iErrText.Set(_L("KErrDisMounted"));
			break;
		case KErrEof:
			iErrText.Set(_L("KErrEof"));
			break;
		case KErrDiskFull:
			iErrText.Set(_L("KErrDiskFull"));
			break;
		case KErrBadDriver:
			iErrText.Set(_L("KErrBadDriver"));
			break;
		case KErrBadName:
			iErrText.Set(_L("KErrBadName"));
			break;
		case KErrCommsLineFail:
			iErrText.Set(_L("KErrCommsLineFail"));
			break;
		case KErrCommsFrame:
			iErrText.Set(_L("KErrCommsFrame"));
			break;
		case KErrCommsOverrun:
			iErrText.Set(_L("KErrCommsOverrun"));
			break;
		case KErrCommsParity:
			iErrText.Set(_L("KErrCommsParity"));
			break;
		case KErrTimedOut:
			iErrText.Set(_L("KErrTimedOut"));
			break;
		case KErrCouldNotConnect:
			iErrText.Set(_L("KErrCouldNotConnect"));
			break;
		case KErrCouldNotDisconnect:
			iErrText.Set(_L("KErrCouldNotDisconnect"));
			break;
		case KErrDisconnected:
			iErrText.Set(_L("KErrDisconnected"));
			break;
		case KErrBadLibraryEntryPoint:
			iErrText.Set(_L("KErrBadLibraryEntryPoint"));
			break;
		case KErrBadDescriptor:
			iErrText.Set(_L("KErrBadDescriptor"));
			break;
		case KErrAbort:
			iErrText.Set(_L("KErrAbort"));
			break;
		case KErrTooBig:
			iErrText.Set(_L("KErrTooBig"));
			break;
		case KErrCannotFindProtocol:
			iErrText.Set(_L("KErrCannotFindProtocol"));
			break;
		case KErrPermissionDenied:
			iErrText.Set(_L("KErrPermissionDenied"));
			break;	
		default:
			iErrBuf.Format(_L(" %d"),aErrCode);
			iErrText.Set(iErrBuf.Ptr());
			break;
		}
		return iErrText;
	}	
	
// static threads

void CTestStepSocket::DoCreateSubsessionsL(CTestStepSocket *aTestStep, TInt aNumSubsess)
	{
	aTestStep->Logger().WriteFormat(_L("SocketThread : eSock client test sub thread - creating sockets and resolvers"));
	
	aTestStep->Logger().WriteFormat(_L("Attempting to connect to socket server"));
	RSocketServ ss;
	TInt ret = ss.Connect();
	if (KErrNone != ret)
		{
		aTestStep->Logger().WriteFormat(_L("SocketThread : Connect returned %d"), ret);
		User::Leave(ret);
		}
	
	TProtocolDesc protoInfo;
	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
	if (KErrNone != ret)
		{
		aTestStep->Logger().WriteFormat(_L("SocketThread : FindProtocol returned %d"), ret);
		User::Leave(ret);
		}
	
	aTestStep->Logger().WriteFormat(_L("SocketThread : Making %d sockets, host resolvers, service resolvers, net databases"), aNumSubsess);
	
	RSocket* sock = new(ELeave) RSocket[aNumSubsess];
	RHostResolver* hostR = new(ELeave) RHostResolver[aNumSubsess];
	RServiceResolver* servR = new(ELeave) RServiceResolver[aNumSubsess];
	RNetDatabase* netDb = new(ELeave) RNetDatabase[aNumSubsess];
	
	for (TInt i=0;i<aNumSubsess;i++)
		{
		ret = sock[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
		if (KErrNone != ret)
			{
			aTestStep->Logger().WriteFormat(_L("SocketThread : Socket Open returned %d"), ret);
			User::Leave(ret);
			}
		ret = hostR[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol);
		if (KErrNone != ret)
			{
			aTestStep->Logger().WriteFormat(_L("SocketThread : Host Resolver Open returned %d"), ret);
			User::Leave(ret);
			}
		ret = servR[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
		if (KErrNone != ret)
			{
			aTestStep->Logger().WriteFormat(_L("SocketThread : Service Resolver Open returned %d"), ret);
			User::Leave(ret);
			}
		
		ret = netDb[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol);
		if (KErrNone != ret)
			{
			aTestStep->Logger().WriteFormat(_L("SocketThread : Net Database Open returned %d"), ret);
			User::Leave(ret);
			}
		}
	}

TInt CTestStepSocket::SocketThread(TAny * anArg)
	{
	
	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
	CTestStepSocket *h = tArg->iHandle;
	
	TInt trapRet;
	CTrapCleanup *cleanup = CTrapCleanup::New(); //Creates and then installs the cleanup stack
	if (cleanup)
		{
		TRAP(trapRet, DoCreateSubsessionsL(h, tArg->iNumSockets));
		}
	else
		{
		trapRet = KErrNoMemory;
		}

	delete cleanup;
	RSemaphore *s = tArg->iSem;
	s->Signal();
	User::WaitForAnyRequest();

	return trapRet;
	}

	
	
TInt CTestStepSocket::ConnectThread(TAny * anArg)
	{
	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
	CTestStepSocket *h = tArg->iHandle;
	
	CTrapCleanup *cleanup = CTrapCleanup::New();
	if (!cleanup)
		{
		tArg->iSem->Signal();
		return KErrNoMemory;
		}
	
	TInt trapRet;
	TRAP(trapRet,
		h->Logger().WriteFormat(_L("ConnectThread : eSock client test sub thread - connect and disconnect"));
	
	h->Logger().WriteFormat(_L("Attempting to connect to socket server"));
	RSocketServ ss;
	TInt ret = ss.Connect();
	if (KErrNone != ret)
		{
		h->Logger().WriteFormat(_L("ConnectThread : Connect returned %d"), ret);
		delete cleanup;
		tArg->iSem->Signal();
		return ret;
		}
	ss.Close();
	
	)
		
		delete cleanup;
	
	tArg->iSem->Signal();
	
	return trapRet;
	}


TInt CTestStepSocket::BadHandleThread(TAny* anArg)
	{
	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
	CTestStepSocket *h = tArg->iHandle;
	
	CTrapCleanup *cleanup = CTrapCleanup::New();
	if (!cleanup)
		{
		return KErrNoMemory;
		}
	
	TInt trapRet;
	TRAP(trapRet,
		h->Logger().WriteFormat(_L("BadHandleThread : eSock client test sub thread - use bad handle"));
	RSocketServ ss;
	TInt ret = ss.Connect();
	if (KErrNone != ret)
		{
		h->Logger().WriteFormat(_L("SocketThread : Connect returned %d"), ret);
		delete cleanup;
		return ret;
		}
	
	// Give socket a bad handle
	RSocket socket;
	*(RSessionBase*)(&socket)=ss;
	*(((TInt*)&socket)+(sizeof(RSessionBase)/sizeof(TInt))) = 4;
	
	// attempt to use it - should panic
	TSockAddr addr;
	socket.LocalName(addr);
	
	)
		// Shouldn't get there (panic before ;-)
		delete cleanup; //really a waste of time because will not get here. Just here for neatness
	
	return trapRet;
	}

TInt CTestStepSocket::ReadTwiceThread(TAny* anArg)
	{
	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
	CTestStepSocket *h = tArg->iHandle;
	
	CTrapCleanup *cleanup = CTrapCleanup::New();
	if (!cleanup)
		{
		return KErrNoMemory;
		}
	
	TInt trapRet;
	
	TRAP(trapRet,
		
		h->Logger().WriteFormat(_L("ReadTwiceThread : eSock client test sub thread - read twice"));
	
	h->Logger().WriteFormat(_L("Attempting to connect to socket server"));
	RSocketServ ss;
	TInt ret = ss.Connect();
	if (KErrNone != ret)
		{
		h->Logger().WriteFormat(_L("ReadTwiceThread : Connect returned %d"), ret);
		delete cleanup;
		return ret;
		}
	
	RSocket socket;
	h->Logger().WriteFormat(_L("ReadTwiceThread : Opening socket on dummy protocol 1"));
	ret = socket.Open(ss, _L("Dummy Protocol 1"));
	h->Logger().WriteFormat(_L("ReadTwiceThread : Open returned %d"), ret);
	if (KErrNone != ret)
		{
		delete cleanup;
		return ret;
		}
	
	h->Logger().WriteFormat(_L("ReadTwiceThread : Attempting Reads - should panic"));
	TRequestStatus stat(KRequestPending);
	TBuf8<100> buf;
	socket.Read(buf, stat);
	socket.Read(buf, stat);
	
	//Make sure ESock has time to PANIC us before we exit.
	// We expect ESock will PANIC us immediately upon receiving the
	// IPC message for the second read.
	User::After(5000000); 
	
	)
		// Shouldn't get there (panic before ;-)
		delete cleanup;
	return trapRet;
	}

TInt CTestStepSocket::BadDescriptorThread(TAny* anArg)
	{
	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
	CTestStepSocket *h = tArg->iHandle;
	RSocketServ server;
	CTrapCleanup *cleanup = CTrapCleanup::New();
	if (!cleanup)
		{
		return KErrNoMemory;
		}
	
	TInt trapRet;
	TRAP(trapRet,
		
		h->Logger().WriteFormat(_L("Connecting to Socket server"));
	TInt ret = server.Connect();
	
	RSocket socket;
	h->Logger().WriteFormat(_L("Openning socket"));
	ret = socket.Open(server,KProtocolName);
	
	TRequestStatus status;
	TSockAddr addr;
	h->Logger().WriteFormat(_L("Connecting to socket"));
	socket.Connect(addr,status);
	User::WaitForRequest(status);
	
	h->Logger().WriteFormat(_L("Attempt is made to pass a negative descriptor."));
	h->Logger().WriteFormat(_L("Esock panics when a Negative Descriptor is passed"));
	
	TBuf8<txlengthtest> logstr;
	logstr.Copy(KSendStringTest);
	TInt* plength=(TInt*)&logstr;
	*plength=-42;
	
	// Send
	TSockXfrLength length;
	socket.Send(logstr, 0, status, length);
	User::WaitForRequest(status);
	
	// Receive setup
	TSockXfrLength rxlength;
	TBuf8<segmentlengthtest> rxbuf;
	
	//Receive 0 octets
	socket.Recv(rxbuf, 0, status, rxlength);
	User::WaitForRequest(status);
	
	)
		
		delete cleanup;
	
	return trapRet;
	
	}

TInt CTestStepSocket::OptimalConnect(RSocketServ& aSrv)
	{
    TSessionPref pref;
    pref.iAddrFamily = KDummyAddrFamily;
    pref.iProtocol = KDummyThree;
	return aSrv.Connect(pref);
	}

TBool CSocketTestStep_OOMCapable::CheckForHeapFailNext()
	{
	if(iOOMSess.Handle() != KNullHandle)
		{
		// If ESOCK heaps are still in FailNext mode then we try to flag the termination
		// of the loop to TEF by setting the local heap to fail. Because this might get
		// "eaten" inside TEF before it checks we walk a failure point here too
		return iOOMSess.__DbgCheckFailNext();
		}
	return ETrue;
	}