/*

* Copyright (c) 2002-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:

*

*/

/** @file

 @internalComponent

 @test

 */

#include "tcptest.h"

#include <in_sock.h>

#include <commdbconnpref.h>

#include <es_enum.h>

#include "tcpcommand.h"

#include "ncmtestconsole.h"

_LIT8(KSendData, "TCP-Packet::HelloWorld\n");

static const TInt KMaxNumOfChars = 255;

//The title of TCP test console

_LIT(KTcpServerMode, "Tcp Server");

_LIT(KTcpClientMode, "Tcp Client");

//The default value of data size

static const TInt KDefaultDataSize = 30;

CTcpProcess* CTcpProcess::NewL(CConsoleBase& aConsole, TInetAddr& aAddr, TInt aPort, TInt aSize, TBool aMode)

	{

	CTcpProcess* self = new(ELeave) CTcpProcess(aConsole, aAddr, aPort, aSize, aMode);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTcpProcess::~CTcpProcess()

	{

	Cancel();

	iRecvBuf.Close();

    iSendBuf.Close();

    iSocket.Close();

    iListenSocket.Close();

    iSockServ.Close();

	}

CTcpProcess::CTcpProcess(CConsoleBase& aConsole, TInetAddr& aAddr, TInt aPort, TInt aSize, TBool aMode) 

		:  CActive(EPriorityStandard), iConsole(aConsole), iAddr(aAddr), iPort(aPort), iSize(aSize), iMode(aMode)

	{

	CActiveScheduler::Add(this);

	}

void CTcpProcess::ConstructL()

	{

	//Create the data buffer

	User::LeaveIfError(iSendBuf.Create(iSize));

	User::LeaveIfError(iRecvBuf.Create(iSize));

	iRecvSize = iSize;

	iProcessState = ECreateConnection;

	User::LeaveIfError(iSockServ.Connect());

	if(iMode)

		{

		//Listen at specified port

		TBuf<5>		 protocol = _L("tcp");

		User::LeaveIfError(iListenSocket.Open(iSockServ, protocol));

		User::LeaveIfError(iListenSocket.SetOpt(KSoReuseAddr, KProtocolInetIp, 1));

		User::LeaveIfError(iListenSocket.SetLocalPort(iPort));

		User::LeaveIfError(iListenSocket.Listen(5));

		User::LeaveIfError(iSocket.Open(iSockServ));

		iListenSocket.Accept(iSocket, iStatus);

		iConsole.Printf(_L("\nWait for a connection at port[%d].\n"), iPort);

		}

	else

		{

        RConnection conn;  

        User::LeaveIfError(conn.Open(iSockServ));

        TCommDbConnPref pref;

        pref.SetIapId(13);

        pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

        User::LeaveIfError(conn.Start(pref));

		//Connect to specified server

		User::LeaveIfError(iSocket.Open(iSockServ, KAfInet, KSockStream, KProtocolInetTcp, conn));

		iSocket.Connect(iAddr, iStatus);

		iConsole.Printf(_L("\nConnecting....\n"));

		}

	SetActive();

	}

void CTcpProcess::RunL()

	{

	switch(iProcessState)

		{

		case ECreateConnection:

			//Get result of connect

			if(iStatus.Int() != KErrNone)

				{

				iConsole.Printf(_L("Connect err[%d].\nPress any key to quit."), iStatus.Int());

				return;

				}

			else

				{

				//A TCP connection is created.

				if(iMode)

					{

					iConsole.Printf(_L("Get a connection.\n"));

					}

				else

					{

					iConsole.Printf(_L("\nConnected.\n"));					

					}

				iProcessState = EDataTransfer;

				//Ready for read data

				iSocket.RecvOneOrMore(iRecvBuf, 0, iStatus, iRecvSize);

				__FLOG_STATIC1(KSubSys, KLogComponent , _L8("Ready for read data"), iRecvSize);

				SetActive();

				if(!iMode)

					{

					//As a client, send data first.

					iSendBuf.SetLength(iSize);

					iSendBuf.Repeat(KSendData());

					iConsole.Printf(_L("Send data."));

					PrintData(iSendBuf);

					TInt sendLen = SendDataL(iSendBuf, iSize);

					if(sendLen != iSize)

						{

						iConsole.Printf(_L("The length of data sent is not equal to requested! requested[%d], sent[%d]"),

											iSize, sendLen);

						}

					}

				}

			break;

		case EDataTransfer:

			//In data transfer, some data is received

			iConsole.Printf(_L("recv Package, size[%d], status[%d]\n"), iRecvSize(), iStatus.Int());

			if((KErrEof == iStatus.Int()) || (KErrDisconnected == iStatus.Int()))

				{

				iConsole.Printf(_L("Connection closed!"));

				return;

				}

			else if(KErrNone == iStatus.Int())

				{

				iConsole.Printf(_L("Receive data."));

				PrintData(iRecvBuf);

				if(iMode)

					{

					//As a server, send back the data received

					TInt len = SendDataL(iRecvBuf, iRecvSize());

					iConsole.Printf(_L("Send back the data. len[%d]"), len);

					}

				}	

			iRecvBuf.SetLength(0);

			iRecvSize = iSize;

			iSocket.RecvOneOrMore(iRecvBuf, 0, iStatus, iRecvSize);

			SetActive();	

			break;

		}

	}

void CTcpProcess::DoCancel()

	{

	switch(iProcessState)

		{

		case ECreateConnection:

			if(iMode)

				{

				iListenSocket.CancelAccept();

				}

			else

				{

				iSocket.CancelConnect();

				}

			break;

		case EDataTransfer:

			iSocket.CancelRecv();

			break;

		}

	}

TInt CTcpProcess::RunError(TInt aError)

	{

	User::Panic(_L("CTcpProcess"), aError);

	return aError;

	}

TInt CTcpProcess::SendDataL(TDes8& aData, TInt aSize)

/**

Send data.

  @return the size of data sent

 */

	{

	TRequestStatus status;

	TSockXfrLength sendSize = aSize;

	iSocket.Send(aData, 0, status, sendSize);

	User::WaitForRequest(status);

	switch(status.Int())

		{

		case KErrEof:

			iConsole.Printf(_L("Connection closed!"));

			return 0;		

		case KErrNone:

			iConsole.Printf(_L("Send successfully."));

			break;

		default:

			User::LeaveIfError(status.Int());

			break;

		}

	return sendSize();

	}

void CTcpProcess::PrintData(TDes8& aData)

	{

	iConsole.Printf(_L("The data is: \n"));

	for(TInt i=0; i< aData.Length();i++)

		{

		iConsole.Printf(_L("%c"), aData[i]);

		}

	iConsole.Printf(_L("\n"));

	}

CUdpProcess* CUdpProcess::NewL(CConsoleBase& aConsole, TInetAddr& aAddr,

        TInt aPort, TInt aSize, TBool aMode)

    {

    CUdpProcess* self = new (ELeave) CUdpProcess(aConsole, aAddr, aPort,

            aSize, aMode);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CUdpProcess::~CUdpProcess()

    {

    Cancel();

    iRecvBuf.Close();

    iSendBuf.Close();

    iSocket.Close();

    iListenSocket.Close();

    iSockServ.Close();

    }

CUdpProcess::CUdpProcess(CConsoleBase& aConsole, TInetAddr& aAddr,

        TInt aPort, TInt aSize, TBool aMode) :

    CActive(EPriorityStandard), iConsole(aConsole), iAddr(aAddr),

            iPort(aPort), iSize(aSize), iMode(aMode)

    {

    CActiveScheduler::Add(this);

    }

void CUdpProcess::ConstructL()

    {

    //Create the data buffer

    User::LeaveIfError(iSendBuf.Create(iSize));

    User::LeaveIfError(iRecvBuf.Create(iSize));

    iRecvSize = iSize;

    User::LeaveIfError(iSockServ.Connect());

    // Start NCM IAP

    RConnection conn;

    User::LeaveIfError(conn.Open(iSockServ));

    TCommDbConnPref pref;

    pref.SetIapId(13);

    pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

    User::LeaveIfError(conn.Start(pref));

    User::LeaveIfError(iSocket.Open(iSockServ, KAfInet, KSockDatagram,

            KProtocolInetUdp, conn));

    iConsole.Printf(_L("In constructL, port=%d"), iAddr.Port());

    if (iMode)

        {

        iProcessState = EDataTransfer;

        User::LeaveIfError(iSocket.SetLocalPort(iPort));

        iSocket.RecvFrom(iRecvBuf, iPeerAddr, 0, iStatus);

        iConsole.Printf(_L("\nWait for UDP incoming data at port[%d]...\n"),iPort);

        SetActive();

        }

    else 

        {

        iProcessState = EDataSending;

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete(status, KErrNone);

        }

    }

void CUdpProcess::RunL()

    {

    __FLOG_STATIC0(KSubSys, KLogComponent , _L8("CUdpProcess::RunL"));

    switch (iProcessState)

        {

        case EDataSending:

            //As a client, send data first.

            iSendBuf.SetLength(iSize);

            iSendBuf.Repeat(KSendData());

            iConsole.Printf(_L("Send data.."));

            PrintData(iSendBuf);

            iConsole.Printf(_L("In RunL, port=%d"), iAddr.Port());

            TInt sendLen = SendDataL(iSendBuf, iAddr, iSize);

            if (sendLen != iSize)

                {

                iConsole.Printf(

                        _L("The length of data sent is not equal to requested! requested[%d], sent[%d]"),

                        iSize, sendLen);

                }

            break;

        case EDataTransfer:

            //In data transfer, some data is received

            iConsole.Printf(_L("recv Package, size[%d], status[%d]\n"),

                    iRecvSize(), iStatus.Int());

            if (KErrNone == iStatus.Int())

                {

                iConsole.Printf(_L("Receive data."));

                PrintData(iRecvBuf);

                if (iMode)

                    {

                    //As a server, send back the data received

                    TInt len = SendDataL(iRecvBuf, iPeerAddr, iRecvBuf.Length());

                    iConsole.Printf(_L("Send back the data. len[%d]"), len);

                    }

                }

            else

                {

                iConsole.Printf(_L("Something is wrong..."));

                return;

                }

            iRecvBuf.SetLength(0);

            iRecvSize = iSize;

            //iListenSocket.RecvFrom(iRecvBuf, iPeerAddr, 0, iStatus);

            iSocket.RecvFrom(iRecvBuf, iPeerAddr, 0, iStatus);

            SetActive();

            iConsole.Printf(_L("\nWait for UDP incoming data at port[%d]...\n"),iPort);

            break;

        }

    }

void CUdpProcess::DoCancel()

{

    switch(iProcessState)

    {

    case EDataTransfer:

        //iListenSocket.CancelRecv();

        iSocket.CancelRecv();

        break;

    }

}

TInt CUdpProcess::RunError(TInt aError)

{

    User::Panic(_L("CUdpProcess"), aError);

    return aError;

}

TInt CUdpProcess::SendDataL(TDes8& aData, TInetAddr& aAddr, TInt aSize)

    /**

      Send data.

      @return the size of data sent

      */

{

    TRequestStatus status;

    TInt port = aAddr.Port();

    iConsole.Printf(_L("Before sending, size = %d, port=%d\n"), aSize, port);

    TSockXfrLength sendSize = 0; //aSize;

    iSocket.SendTo(aData, aAddr, 0, status, sendSize);

    User::WaitForRequest(status);

    iConsole.Printf(_L("Sending result = %d, and sent=%d\n"), status.Int(), sendSize());

    switch(status.Int())

    {

    case KErrEof:

        iConsole.Printf(_L("Connection closed!"));

        return 0;       

    case KErrNone:

        iConsole.Printf(_L("Send successfully.\n"));

        break;

    default:

        User::LeaveIfError(status.Int());

        break;

    }

    return sendSize();

}

void CUdpProcess::PrintData(TDes8& aData)

{

    iConsole.Printf(_L("The data is: \n"));

    for(TInt i=0; i< aData.Length();i++)

    {

    iConsole.Printf(_L("%c"), aData[i]);

    }

    iConsole.Printf(_L("\n"));

}

CTcpTestConsole* CTcpTestConsole::NewL(TBool aIsTcp, TBool aMode, TDesC& aDefautAddr, TInt aIndex, CTcpCommand& aOwner)

	{

	CTcpTestConsole* self = new(ELeave) CTcpTestConsole(aIsTcp, aMode, aDefautAddr, aIndex, aOwner);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTcpTestConsole::CTcpTestConsole(TBool aIsTcp, TBool aMode, TDesC& aDefautAddr, TInt aIndex, CTcpCommand& aOwner) 

	: CActive(EPriorityStandard),iCommandMode(ECommandInit),  iIsTcp(aIsTcp), iMode(aMode), 

	  iDefaultAddr(aDefautAddr), iIndex(aIndex), iOwner(aOwner)

	{	

	CActiveScheduler::Add(this);

	}

CTcpTestConsole::~CTcpTestConsole()

	{

	Cancel();

	delete iTcp;

	delete iUdp;

    delete iConsole;

    iChars.Close();

	}

void CTcpTestConsole::ConstructL()

	{

	if(iMode)

		{

		iConsole = Console::NewL(KTcpServerMode(),TSize(KConsFullScreen,KConsFullScreen));

		}

	else

		{

		iConsole = Console::NewL(KTcpClientMode(),TSize(KConsFullScreen,KConsFullScreen));

		}	

	User::LeaveIfError(iChars.Create(KMaxNumOfChars));

	//Generate the default value and display on screen, user can modify it if they want to use other value.

	iChars.AppendFormat(_L("%S %d"), &iDefaultAddr, KDefaultDataSize);

	Help();

	//wait user input

	iConsole->Read(iStatus);

	SetActive();

	}

void CTcpTestConsole::Help()

	{

	iConsole->Printf(_L("Please change the parameters, then press enter\n"));

	if(iMode)

		{

		iConsole->Printf(_L("   The parameters are port size \n"));

		iConsole->Printf(_L("   port - The port of the Tcp/udp Server listen to \n"));

		iConsole->Printf(_L("   size - the max package size \n"));

		}

	else

		{

		iConsole->Printf(_L("   The parameters are destAddr port size \n"));

		iConsole->Printf(_L("   destAddr - The ip address of Tcp/udp Client connect to.\n"));

		iConsole->Printf(_L("   port - The port of Tcp Client connect to \n"));

		iConsole->Printf(_L("   size - the package size \n"));

		}

	//Display the default value

	iConsole->Printf(_L("%S"), &iChars);

	}

TBool CTcpTestConsole::StartL()

	{

	TLex args(iChars);

	// args are separated by spaces

	args.SkipSpace(); 

	TInetAddr addr;

	TInt size;

	if(!iMode)

		{

		//Get ip addr

		TPtrC cmdAddr = args.NextToken();

		if(!args.Eos())

			{

			if(KErrNone == addr.Input(cmdAddr))

				{

				args.Inc();

				}

			else

				{

				return EFalse;

				}

			}

		else

			{

			return EFalse;

			}

		}

	//Get port

	TInt port;

	if(KErrNone != args.Val(port))

		{

		return EFalse;

		}

	addr.SetPort(port);