// Copyright (c) 1999-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:
// Test code for interrupted IO operations
// 
//

#include <e32std.h>
#include <e32svr.h>	// for RDebug
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/fcntl.h>
#include <sys/errno.h>

#include <sys/ioctl.h>		// for E32IOSELECT
#include <sys/socket.h>
#include <libc/netinet/in.h>

extern "C" {
#include "CTEST.H"
}
test_Data;

#include <estlib.h>	// for multi-threading control

int testFid;
struct sockaddr_in testAddr;
RSemaphore semaphores[2];

void init_test()
	{
	// We need a datagram socket that we can send to

	test_Next("Create datagram socket");
	testFid=socket(PF_INET, SOCK_DGRAM, 0);
	test_ok(testFid>=0);
	
	test_Next("Bind to local address");
	IN_SET_LOOPBACK_ADDR(&testAddr);
	testAddr.sin_port=0;

	size_t len=sizeof(testAddr);
	int err=bind(testFid, (struct sockaddr*)&testAddr, len);
	test_ok(err==0);

	err=getsockname(testFid, (struct sockaddr*)&testAddr, &len);
	test_ok(err==0);

	// We now have a datagram socket with a known address

	test_Next("Create semaphores for test synchronisation");
	for (int i=0; i<2; i++)
		{
		err=semaphores[i].CreateLocal(0);
		test(err==KErrNone);
		}
	}

/**
Test of the asynchronous ioctl & cancel code

@SYMTestCaseID          SYSLIB-STDLIB-CT-1044
@SYMTestCaseDesc	    Tests for the asynchronous ioctl & cancel code
@SYMTestPriority 	    High
@SYMTestActions  	    Tests that E32IOSELECT ioctl is working
						Tests for asynchronous IOCTL.
						Setup asynchronous IOCTL which won't complete, then cancel.Check for cancel status
						Cancel a completed asynchronous IOCTL,and check for no error
@SYMTestExpectedResults Test must not fail
@SYMREQ                 REQ0000
*/		
void test_ioctl()
	{
	// confirm that the E32IOSELECT ioctl is working
	test_Next("Check synchronous IOCTL");
	int mask=E32SELECT_READ|E32SELECT_WRITE|E32SELECT_EXCEPT;
	int err=ioctl(testFid,E32IOSELECT,&mask);
	test_ok(err==0);
	test(mask==E32SELECT_WRITE);

	test_Next("Check asynchronous IOCTL");
	TRequestStatus status;
	mask=E32SELECT_READ|E32SELECT_WRITE|E32SELECT_EXCEPT;
	err=ioctl(testFid,E32IOSELECT,&mask,status);
	test_ok(err==0);
	User::WaitForRequest(status);
	test(status.Int()==KErrNone);
	err=ioctl_complete(testFid,E32IOSELECT,&mask,status);
	test_ok(err==0);
	test(mask==E32SELECT_WRITE);

	test_Next("Setup asynchronous IOCTL which won't complete, then cancel");
	mask=E32SELECT_READ;
	err=ioctl(testFid,E32IOSELECT,&mask,status);
	test_ok(err==0);
	test(status.Int()==KRequestPending);	// i.e. waiting for input to arrive

	// test_Next("Cancel the pending IOCTL");
	// Sadly this will do write() which will get a KErrInUse and then panic...
	err=ioctl_cancel(testFid);
	test_ok(err==0);
	User::WaitForRequest(status);
	test_Next("Check that ioctl_cancel worked");
	test(status.Int()==KErrCancel);			// i.e. it was cancelled

	test_Next("Cancel a completed asynchronous IOCTL");
	mask=E32SELECT_WRITE;
	err=ioctl(testFid,E32IOSELECT,&mask,status);
	test_ok(err==0);
	
	while (status.Int() == KRequestPending)
		User::After(5000);

	test(status.Int()!=KRequestPending);	// i.e. select has completed

	// test_Next("Cancel the pending IOCTL");
	// Sadly this will do write() which will get a KErrInUse and then panic...
	err=ioctl_cancel(testFid);
	test_ok(err==0);
	User::WaitForRequest(status);
	test(status.Int()==KErrNone);			// i.e. it was cancelled

	}

// Thread functions which will block accessing the socket

TInt ioctl_block(TAny* aSemIndex)
	{
	semaphores[(TInt)aSemIndex].Wait();		// block until the test is ready

	int mask=E32SELECT_READ;
	int err=ioctl(testFid,E32IOSELECT,&mask);
	test_ok(err==0);
	test(mask==E32SELECT_READ);
	return 1;
	}

TInt recv_block(TAny* aSemIndex)
	{
	semaphores[(TInt)aSemIndex].Wait();		// block until the test is ready

	char buf[256];
	// Problem in recvfrom: int err=recvfrom(testFid,buf,MSG_PEEK,sizeof(buf),0,0);
	struct sockaddr_in junk;
	size_t junklen=sizeof(junk);
	// Problem in esock/tcpip: int err=recvfrom(testFid,buf,sizeof(buf),MSG_PEEK,(struct sockaddr*)&junk,&junklen);
	int err=recvfrom(testFid,buf,sizeof(buf),0,(struct sockaddr*)&junk,&junklen);
	// Problem in recfrom: test_ok(err>0);
	test_ok(err>=0);
	return 1;
	}

void kill_and_check(RThread& aVictim, TRequestStatus& aVictimStatus, TRequestStatus& aSurvivorStatus)
	{
	test(aVictimStatus.Int()==KRequestPending);
	test(aSurvivorStatus.Int()==KRequestPending);
	aVictim.Kill(666);
	char* KDatagram="Mine is the last voice you will ever hear";
	int length=strlen(KDatagram)+1;
	
	test_Next("Send datagram");
	int err=sendto(testFid,KDatagram, length,0,(struct sockaddr*)&testAddr,sizeof(testAddr));
	test_ok(err==length);
	User::After(1);

	test_Next("Check the victim status");
	User::WaitForRequest(aVictimStatus);
	test(aVictimStatus.Int()==666);

	test_Next("Check the survivor status");
	User::WaitForRequest(aSurvivorStatus);
	test(aSurvivorStatus.Int()==1);

	// Check to see if the datagram has been swallowed
	int mask=E32SELECT_READ|E32SELECT_WRITE|E32SELECT_EXCEPT;
	err=ioctl(testFid,E32IOSELECT,&mask);
	test_ok(err==0);
	if ((mask&E32SELECT_READ)==0)
		return;		// yes - nothing to read

	test_Next("Consume the datagram");
	char buf[256];
	// Problem in recvfrom: err=recvfrom(testFid,buf,sizeof(buf),0,0,0);
	struct sockaddr_in junk;
	size_t junklen=sizeof(junk);
	err=recvfrom(testFid,buf,sizeof(buf),0,(struct sockaddr*)&junk,&junklen);
	// Problem in recfrom: test_ok(err==length);
	test_ok(err>=0);
	}
/**
@SYMTestCaseID          SYSLIB-STDLIB-CT-1045
@SYMTestCaseDesc	    Tests for killing an ioctl
@SYMTestPriority 	    High
@SYMTestActions  	    Create two threads which will block on the socket
						then kill one of them and send a datagram 
						check the exit status of both threads
@SYMTestExpectedResults Test must not fail
@SYMREQ                 REQ0000
*/		
void test_killing(TInt aThread, TThreadFunction aFunction, char* aTitle)
	{
	_LIT(KThreadName, "TCancel Test Thread %d");
	TBuf<80> threadName;
	static TInt threadNumber=0;

	test_Next(aTitle);
	// test_Next("Create test thread A");
	RThread thread1;
	TRequestStatus status1;
	threadName.Format(KThreadName,++threadNumber);
	TInt err=thread1.Create(threadName,aFunction,0x10000,NULL,(TAny*)0);
	test(err==KErrNone);
	thread1.Logon(status1);
	thread1.Resume();

	// test_Next("Create test thread B");
	RThread thread2;
	TRequestStatus status2;
	threadName.Format(KThreadName,++threadNumber);
	err=thread2.Create(threadName,aFunction,0x10000,NULL,(TAny*)1);
	test(err==KErrNone);
	thread2.Logon(status2);
	thread2.Resume();

	test_Next("Start thread A, then thread B...");
	semaphores[0].Signal();
	User::After(1);
	semaphores[1].Signal();
	User::After(1);

	if (aThread==1)
		{
		test_Next("Kill thread A");
		kill_and_check(thread1, status1, status2);
		}
	else
		{
		test_Next("Kill thread B");
		kill_and_check(thread2, status2, status1);
		}

	thread1.Close();
	thread2.Close();
	}

int main()
	{
	
	start_redirection_server();

	test_Title("TCANCEL");
	init_test();
	test_ioctl();		// explicit cancellation
	test_killing(1,ioctl_block, "Cancellation of active ioctl");	
	test_killing(2,ioctl_block, "Cancellation of queued ioctl");
	test_killing(1,recv_block,  "Cancellation of active recvfrom");	
	test_killing(2,recv_block,  "Cancellation of queued recvfrom");
	test_Close();
	return KErrNone;
	}