// 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 "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:

// server class for the rtp core unit test cases

// 

//

/**

 @file

 @internalComponent

*/

#include "trtpcoreserver.h"

#include "trtpcorestep.h"

static const TInt KStartOfItemValue = 2;

static const TInt KStartOfFirstItemValue = 10;

// __EDIT_ME__ - Substitute the name of your test server 

_LIT(KServerName,"trtpsocket");

// __EDIT_ME__ - Use your own server class name

CTRtpCoreServer* CTRtpCoreServer::NewL()

/**

 * @return - Instance of the test server

 * Same code for Secure and non-secure variants

 * Called inside the MainL() function to create and start the

 * CTestServer derived server.

 */

	{

	CTRtpCoreServer* server = new (ELeave) CTRtpCoreServer();

	CleanupStack::PushL(server);

	//CServer call

	server->ConstructL(KServerName);

	CleanupStack::Pop(server);

	return server;

	}

CTRtpCoreServer::CTRtpCoreServer()

	{

	iUsingConnectedSocket = EFalse;

	}

CTRtpCoreServer::~CTRtpCoreServer()

	{

	delete iScheduler;

	//

	delete iController;

	delete iSendController;

	}

#if (!defined EKA2)

LOCAL_C void MainL()

/**

 * REQUIRES semaphore to sync with client as the Rendezvous()

 * calls are not available

 */

	{

	CActiveScheduler* sched=NULL;

	sched=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(sched);

	CActiveScheduler::Install(sched);

	CTRtpCoreServer* server = NULL;

	// Create the CTestServer derived server

	TRAPD(err,server = CTRtpCoreServer::NewL());

	if(!err)

		{

		CleanupStack::PushL(server);

		RSemaphore sem;

		// The client API will already have created the semaphore

		User::LeaveIfError(sem.OpenGlobal(KServerName));

		CleanupStack::Pop(server);

		// Sync with the client then enter the active scheduler

		sem.Signal();

		sem.Close();

		sched->Start();

		}

	CleanupStack::Pop(sched);

	delete server;

	delete sched;

	}

#else

// EKA2 much simpler

// Just an E32Main and a MainL()

LOCAL_C void MainL()

/**

 * Much simpler, uses the new Rendezvous() call to sync with the client

 */

	{

	// Leave the hooks in for platform security

#if (defined __DATA_CAGING__)

	RProcess().DataCaging(RProcess::EDataCagingOn);

	RProcess().SecureApi(RProcess::ESecureApiOn);

#endif

	CActiveScheduler* sched=NULL;

	sched=new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(sched);

	// __EDIT_ME__ Your server name

	CTRtpCoreServer* server = NULL;

	// Create the CTestServer derived server

	// __EDIT_ME__ Your server name

	TRAPD(err,server = CTRtpCoreServer::NewL());

	if(!err)

		{

		// Sync with the client and enter the active scheduler

		RProcess::Rendezvous(KErrNone);

		sched->Start();

		}

	delete server;

	delete sched;

	}

#endif

// Only a DLL on emulator for typhoon and earlier

#if (defined __WINS__ && !defined EKA2)

// and E32Dll(enum TDllReason) defined in rtputils.cpp

/*

GLDEF_C TInt E32Dll(enum TDllReason)

	{

	return 0;

	}

*/

#else

GLDEF_C TInt E32Main()

/**

 * @return - Standard Epoc error code on exit

 */

	{

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(!cleanup)

		{

		return KErrNoMemory;

		}

	TInt err = 0;

	TRAP(err,MainL());

	delete cleanup;

	return err;

	}

#endif

// Create a thread in the calling process

// Emulator typhoon and earlier

#if (defined __WINS__ && !defined EKA2)

TInt ThreadFunc (TAny* /*aParam*/)

/**

 * @return - Server exit code

 * @param - unused

 * Server Thread function. Guts of the code in the MainL() function

 */

	{

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(!cleanup)

		{

		return KErrNoMemory;

		}

	TRAPD(err,MainL());

	delete cleanup;

	return KErrNone;

	}

EXPORT_C TInt NewServer() 

/**

 * @return - Standard Epoc error codes

 * 1st and only ordinal, called by the client API to initialise the server

 */

	{

	_LIT(KThread,"Thread");

	RThread thread;

	// __EDIT_ME__ - Make sure the TBuf is large enough

	TBuf<KMaxTestExecuteNameLength> threadName(KServerName);

	// Create a hopefully unique thread name and use the ThreadFunc

	threadName.Append(KThread);

	const TInt KMaxHeapSize = 0x1000000;			//< Allow a 1Mb max heap

	TInt err = thread.Create(threadName, ThreadFunc, KDefaultStackSize,

													KMinHeapSize, KMaxHeapSize,

													NULL, EOwnerProcess);

	if(err)

		return err;

	thread.Resume();

	thread.Close();

	return KErrNone;

	}

#endif

#define DEF_TEST(_n, _f) if (aStepName == (_n)) { testStep = new _f; testStep->SetTestStepName((_n));}

CTestStep* CTRtpCoreServer::CreateTestStep(const TDesC& aStepName)

/**

 * @return - A CTestStep derived instance

 * Secure and non-secure variants

 * Implementation of CTestServer pure virtual

 */

	{

	CTRtpCoreStep* testStep = NULL;

	// __EDIT_ME__ - Create your own test steps here

	// This server creates just one step but create as many as you want

	// They are created "just in time" when the worker thread is created

	DEF_TEST(KCreateRtpController,CCreateRtpController);

	DEF_TEST(KActivateRtpController,CActivateRtpController);

	DEF_TEST(KDeleteRtpController,CDeleteRtpController);

	DEF_TEST(KBasicSend,CBasicSend);

	DEF_TEST(KBasicReceive,CBasicReceive);

	DEF_TEST(KInitialReceive,CInitialReceive);

	DEF_TEST(KFixedHeader,CFixedHeader);

	DEF_TEST(KRRFixedHeader,CRRFixedHeader);

	DEF_TEST(KBYEReceive,CBYEReceive);

	DEF_TEST(KOom,COom);

	DEF_TEST(KIntervalTest, CIntervalTest);

	DEF_TEST(KConsiderationTest,CConsiderationTest);

	if (testStep)

		testStep->SetServer(this);

	return testStep;

	}

/*

void CTRtpCoreServer::StopScheduler(CTRtpCoreServer* aPtr, const TRtpEvent& aEvent)

	{

	aPtr->iLastEvent = aEvent;

	if (!aPtr->iStopping && !--aPtr->iStopCount)

		{

		CActiveScheduler::Stop();

		aPtr->iStopping = ETrue;

		}

	}

*/

CWaiter* CWaiter::NewLC(CTRtpCoreServer* aServer)

	{

	CWaiter* that = new (ELeave) CWaiter(aServer);

	CleanupStack::PushL(that);

	return that;

	}

void CWaiter::DataAvailable(TInt)

    {

    if (!iServer->iStopping && !--iServer->iStopCount)

        {

        CActiveScheduler::Stop();

        //iServer->iWaitScheduler.AsyncStop();

        iServer->iStopping = ETrue;

        }

    }

CWaiter::~CWaiter()

	{

	}

TBool CTRtpCoreServer::CompareRtpHeadersFromBuf(TDesC8& aBuf1,TDesC8& aBuf2)

	{

	for (TInt i = 0; i < 12/*packet->Length()*/; i++)

		{

		// Don't compare the SSRC or timestamp as it's random.

		//if ((i < 8 || i > 11) && (i != 2 && i != 3))

			if (aBuf1[i] != aBuf2[i])

				return EFalse;

		}

	return ETrue;

	}

TBool CTRtpCoreServer::CompareRtcpHeadersFromBuf(TDesC8& aBuf1,TDesC8& aBuf2)

	{

	// Don't compare the SSRC as it's random.

	for (TInt i = 0; i < 4; i++)

		{

		if (aBuf1[i] != aBuf2[i])

			return EFalse;	

		}

	return ETrue;

	}

TBool CTRtpCoreServer::CompareRtpHeaderWithBuf(TRtpFixedHdrMemLayout& aHeader,TDesC8& aBuf)	

	{

	TUint8 byte;

	//byte 1

	byte = static_cast<TUint8>(aHeader.Version()); // 2 bits

	// padding 1 bit

	byte = static_cast<TUint8>(aHeader.HasPadding() ? (byte << 1)|1 : (byte << 1)); 

	// extension 1 bit

	byte = static_cast<TUint8>(aHeader.HasExtension() ? (byte << 1)|1 : (byte << 1)); 

	// cc count 4 bits

	byte = static_cast<TUint8>((byte << 4)|aHeader.CC()); 

	if (byte != aBuf[0])

		return EFalse;

	// byte 2

	// marker 1 bit

	byte = static_cast<TUint8>(aHeader.HasMarker() ? 1 : 0); 

	// payload type 7 bits

	byte = static_cast<TUint8>((byte << 7)|aHeader.PayloadType()); 

	if (byte != aBuf[1])

		return EFalse;

	// byte 3

	byte = static_cast<TUint8>(aHeader.SequenceNumber() >> 8); // upper byte

	if (byte != aBuf[2])

		return EFalse;

	// byte 4

	byte = static_cast<TUint8>(aHeader.SequenceNumber()&0x0000ffff); // lower byte

	if (byte != aBuf[3])

		return EFalse;

	// TIMESTAMP

	// byte 5 MSB from timestamp

	byte = static_cast<TUint8>(aHeader.TimeStamp() >> 24); // most signicifant byte of timestamp

	if (byte != aBuf[4])

		return EFalse;

	// byte 6

	byte = static_cast<TUint8>(aHeader.TimeStamp() >> 16); // timestamp

	if (byte != aBuf[5])

		return EFalse;

	// byte 7

	byte = static_cast<TUint8>(aHeader.TimeStamp() >> 8); // timestamp

	if (byte != aBuf[6])

		return EFalse;

	// byte 8 LSB from timestamp

	// least signicifant byte of timestamp

	byte = static_cast<TUint8>(aHeader.TimeStamp()&0x000000000000ffff); 

	if (byte != aBuf[7])

		return EFalse;

	// SSRC

	// byte 9 MSB from SSRC

	byte = static_cast<TUint8>(aHeader.SSRC() >> 24); // most signicifant byte of SSRC

	if (byte != aBuf[8])

		return EFalse;

	// byte 10

	byte = static_cast<TUint8>(aHeader.SSRC() >> 16); // SSRC

	if (byte != aBuf[9])

		return EFalse;

	// byte 11

	byte = static_cast<TUint8>(aHeader.SSRC() >> 8); // timestamp

	if (byte != aBuf[10])

		return EFalse;

	// byte 12 LSB from SSRC

	// least signicifant byte of SSRC

	byte = static_cast<TUint8>(aHeader.SSRC()&0x000000000000ffff); 

	if (byte != aBuf[11])

		return EFalse;

	return ETrue;

	}

TBool CTRtpCoreServer::CompareRtcpHeaderWithBuf(TRtcpFixedHdrMemLayout& aHeader,TDesC8& aBuf)	

	{

	TUint8 byte;

	//byte 1

	byte = static_cast<TUint8>(aHeader.Version()); // 2 bits

	// padding 1 bit

	byte = static_cast<TUint8>(aHeader.IsPadding() ? (byte << 1)|1 : (byte << 1));  

	// cc count 5 bits

	byte = static_cast<TUint8>((byte << 5)|aHeader.Count()); 

	if (byte != aBuf[0])

		return EFalse;

	// byte 2 

	// packet type 8 bits

	byte = static_cast<TUint8>(aHeader.PacketType()); 

	if (byte != aBuf[1])

		return EFalse;

	// byte 3

	byte = static_cast<TUint8>(aHeader.Length() >> 8); // upper byte

	if (byte != aBuf[2])

		return EFalse;

	// byte 4

	byte = static_cast<TUint8>(aHeader.Length()&0x0000ffff); // lower byte

	if (byte != aBuf[3])

		return EFalse;

	return ETrue;

	}

/*

_LIT(KRTP_CORE, "RTP-CORE");

GLDEF_C void Panic(TRtpCorePanicCode aPanicCode)

	{

	User::Panic(KRTP_CORE, aPanicCode);

	}

	*/

CRtpFixedHeader::CRtpFixedHeader()

  	{

  	}

CRtpFixedHeader::CRtpFixedHeader(TDes8& aPacket)

  	{

  	TRtpFixedHdrMemLayout header(aPacket);

  	iHeader.iVersion = header.Version();	// protocol version: 2 bits

  	iHeader.iP = header.HasPadding();		// padding flag: 1 bit

  	iHeader.iX = header.HasExtension();		// header extension flag: 1 bit

  	iHeader.iCC = header.CC();				// CSRC count:  4 bits  	

  	iHeader.iM = header.HasMarker();			// marker bit: 1 bit

  	iHeader.iPT = header.PayloadType();		// payload type: 7 bits

  	iHeader.iSequenceNo = header.SequenceNumber();	// sequence number 16 bits

  	iHeader.iTimeStamp = header.TimeStamp();	// timestamp: 32 bits

  	iHeader.iSSRC = header.SSRC();		// synchronization source: 32 bits

  	/*

  	TUint8* csrc = const_cast<unsigned char*>(aPacket.Ptr()+12);

  	for(TUint i = 0;i < iHeader.cc; i++)

  		{

  		iHeader.iCSRC.Append((*(csrc+3))+(*(csrc+2)<<8)+(*(csrc+1)<<16)+(*(csrc)<<24));

  		csrc += 4;

  		}

	*/

  	}

CRtpFixedHeader::~CRtpFixedHeader()

  	{

  	//iHeader.iCSRC.Close();

  	}

void CRtpFixedHeader::SetVersion(TUint aVersion)

  	{

  	iHeader.iVersion = aVersion;

  	}

void CRtpFixedHeader::SetCSRCCount(TUint aCC)

  	{

  	iHeader.iCC = aCC;

  	}

void CRtpFixedHeader::SetSequenceNumber(TUint16 aNo)

  	{

  	iHeader.iSequenceNo = aNo;

  	}

void CRtpFixedHeader::SetSSRC(TUint32 aSSRC)

  	{

  	iHeader.iSSRC = aSSRC;

  	}

void CRtpFixedHeader::SetTimeStamp(TUint32 aTime)

  	{

  	iHeader.iTimeStamp = aTime;

  	}

void CRtpFixedHeader::SetPadding(TBool aPadding)

  	{

  	iHeader.iP = aPadding ? 1 : 0;

  	}

void CRtpFixedHeader::SetExtension(TBool aExtension)

  	{

  	iHeader.iX = aExtension ? 1 : 0;

  	}

TUint32 CRtpFixedHeader::SSRC()

  	{

  	return iHeader.iSSRC;

  	}

TUint8 CRtpFixedHeader::CC()

  	{

  	return iHeader.iCC;

  	}

TUint8 CRtpFixedHeader::PayloadType()

  	{

  	return iHeader.iPT;

  	}

TBool CRtpFixedHeader::IsMarker()

  	{

  	return iHeader.iM;

  	}

TBool CRtpFixedHeader::IsPadding()

  	{

  	return iHeader.iP;

  	}

TBool CRtpFixedHeader::IsExtension()

  	{

  	return iHeader.iX;

  	}

TUint8 CRtpFixedHeader::Version()

  	{

  	return iHeader.iVersion;

  	}

TUint16 CRtpFixedHeader::SequenceNumber()

  	{

  	return iHeader.iSequenceNo;

  	}

TUint32 CRtpFixedHeader::TimeStamp()

  	{

  	return iHeader.iTimeStamp;

  	}

//

CRtcpPacketTest::CRtcpPacketTest(TDes8& aPacket)

	{

	TRtcpFixedHdrMemLayout header(aPacket);

	iPacket.common.iVersion = header.Version();

	iPacket.common.iPadding = header.IsPadding() ? 1 : 0;

	iPacket.common.iCount = header.Count();

	iPacket.common.iPacketType = header.PacketType();

	iPacket.common.iLength = static_cast<TUint16>(header.Length());

	}

//CRtcpRRPacket();

void CRtcpPacketTest::Init(TDes8& aPacket)

	{

	TRtcpFixedHdrMemLayout header(aPacket);

	iPacket.common.iVersion = header.Version();

	iPacket.common.iPadding = header.IsPadding() ? 1 : 0;

	iPacket.common.iCount = header.Count();

	iPacket.common.iPacketType = header.PacketType();

	iPacket.common.iLength = static_cast<TUint16>(header.Length());

	}

CRtcpPacketTest::~CRtcpPacketTest()

	{