// 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;

 	}