/*

* 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:

*

*/

 #include "tsocket.h"

 #include <sys/un.h>

const char* tcpdata = "Hello Open C and OPENENV!";

void* myclie(void* pv);

int globalflag=0;

int flag=0;

const char * safdata="hello";

int doClient1(int port, int size);

int doServer1(int port);

const TUint KMaxLine = 100;

const TInt KReadError = -1000;

const TInt KWriteError = -1001;

const TInt KErrSocket = -1002;

const TInt KErrBind = -1003;

const TInt KErrGetSockName=-1004;

const TInt KErrListen=-1006;

const TInt KErrShutdown = -1007;

const TInt KErrRead = -1008;

const TInt KErrConnect = -1009;

const TInt KErrSockAtMark = -1011;

const TInt KErrGetPeerName = -1012;

const TInt KErrIoctl = -1013;

const TInt KErrGetSocketName = -1014;

const TInt KErrGetSockOpt = -1015;

const TInt KErrAccept = -1016;

const TInt KErrGetHostName = -1017;

const TInt KErrLseek = -1018;

const char KSoGet = 1;

const char KSoSet = 2;

const char KSoGetSet = 3;

int read(int newsock_fd,char *line);

int write(int sock_fd);

int read1(int newsock_fd,char *line);

int write1(int sock_fd);

static void* UDPThread(TAny* ptr);

static void* TCPThread(TAny* ptr);

static void* ClientThread(TAny* ptr);

static void* ShutDownThread(TAny* ptr);

static void* UDPThreadSendMsg(TAny* ptr);

static void* TCPThread1(TAny* ptr);

#define PORT 5000

// -----------------------------------------------------------------------------

// CTestSocket::ExampleL

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CTestSocket::ExampleL( )

    {

    _LIT( Ktsocket, "tsocket: ExampleL" );

    // Print to log file

    INFO_PRINTF1( Ktsocket );

    TPtrC string;

    _LIT( KParam, "Parameter: %S" );

    _LIT( Kstring, "Parameter1" );

    TBool res = GetStringFromConfig(ConfigSection(), Kstring, string );

    if(!res)  

		{

     	_LIT(Kerr , "Failed to read input file name") ;

     	INFO_PRINTF1(Kerr) ;

     	return KErrGeneral ;

		}

    INFO_PRINTF2(KParam, &string );

    return KErrNone;

    }

TInt CTestSocket::UDP(  )

    {

    int sock_fd;

	unsigned int sender_len, receiver_len;

	sockaddr_in receiver_addr,sender_addr;

	char line[KMaxLine];

	TInt ret = KErrNone;

	int threadRetVal = 0;

	int error  ;

	pthread_t testThread;

	void *threadRetValPtr = (void*)&threadRetVal;

	sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);

    if (sock_fd < 0)

        {

        ret = KErrSocket;

        goto close;

        }

	receiver_addr.sin_family = AF_INET;

	receiver_addr.sin_addr.s_addr = htonl(INADDR_ANY);

	receiver_addr.sin_port = 0;

	if (bind(sock_fd,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0)

		{

        ret = KErrBind;

        goto close;

		}

	receiver_len = sizeof(receiver_addr);

	if (getsockname(sock_fd, (sockaddr*)&receiver_addr, &receiver_len) < 0)

		{

		ret = KErrGetSockName;

		goto close;

		}

	pthread_create(&testThread, NULL, &UDPThread, (void*)(receiver_addr.sin_port));

	sender_len = sizeof(sender_addr);

	INFO_PRINTF1(_L("B recvfrom\n"));

	error = recvfrom(sock_fd,line,KMaxLine,0,(sockaddr*)&sender_addr,&sender_len);

	if (error < 0)

		{

		ret = KReadError;

        goto close;

		}

	pthread_join(testThread, &threadRetValPtr);	

	if (threadRetVal < 0)

		{		

		ret = threadRetVal;

		goto close;

		}

close:

	shutdown(sock_fd,SHUT_RDWR);

	close(sock_fd);

	return ret;    

    }

static void* UDPThread(TAny* aParam)

	{

	sockaddr_in receiver_addr;

	int sock_fd;

	char character = 'A';

	unsigned int cnt = 0;

	char line[KMaxLine];

    sock_fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);

	if (sock_fd < 0)

		{

		goto close;

		}

    for(; cnt < KMaxLine - 1; cnt++)

        {

        line[cnt] = character;

        character++;

        if (character > 'Z')

            {

            character = 'A';

            }

        }

    line[cnt] = '\0';

	receiver_addr.sin_family = AF_INET;

	receiver_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);	

	receiver_addr.sin_port = (int)aParam;

	if (sendto(sock_fd,line,KMaxLine,0,(sockaddr*)&receiver_addr,sizeof(receiver_addr)) < 0)

		{

		goto close;

		}

close:		

    shutdown(sock_fd,SHUT_RDWR);

	close(sock_fd);

	return (void*)NULL;

	}

TInt CTestSocket::TCP( )

	{

	int sock_fd,newsock_fd;	

	int error;            

	unsigned int addr_len, serv_len;

	sockaddr_in serv_addr,new_socket;

	TInt ret = KErrNone;

	sock_fd = socket(AF_INET,SOCK_STREAM,0);

	if (sock_fd < 0)

        {

        return KErrSocket;

        }

	serv_addr.sin_family = AF_INET;

	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

	serv_addr.sin_port = 0;

	pthread_t testThread;

	int threadRetVal;

	void *threadRetValPtr = (void*)&threadRetVal;

	if (bind(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)

		{

		ret = KErrBind;

		goto close;

		}

	serv_len = sizeof(serv_addr);

	if (getsockname(sock_fd, (sockaddr*)&serv_addr, &serv_len) < 0)

		{

		ret = KErrGetSockName;

		goto close;

		}

	if (listen(sock_fd,1) < 0)

		{

		ret = KErrListen;

		goto close;

		}

	addr_len = sizeof(new_socket);

	// Create the thread and thread is client code 

	pthread_create(&testThread, NULL, &TCPThread, (void*)(serv_addr.sin_port));

	newsock_fd = accept(sock_fd,(sockaddr*)&new_socket,&addr_len); // Code blocks here

	error = write(newsock_fd);

	if (error < 0)

		{		

		ret = error;

		goto close;

		}

close:

	pthread_join(testThread, &threadRetValPtr);

	shutdown(sock_fd,SHUT_RDWR);

	close(sock_fd);

	return ret;	

	}

int write(int sock_fd)

    {

    char line[KMaxLine];    

    char character = 'A';

    unsigned int cnt = 0;

    for(; cnt < KMaxLine - 1; cnt++)

        {

        line[cnt] = character;

        character++;

        if (character > 'Z')

            {

            character = 'A';

            }

        }

    line[cnt] = '\0';

    if (send(sock_fd,line,KMaxLine,0) < 0)

        {

        return KWriteError;

        }

    return KErrNone;

    }

static void* TCPThread(TAny* aParam)

	{

	sockaddr_in serv_addr;

	int sock_fd;

	char line[KMaxLine ];

	serv_addr.sin_family = AF_INET;

	serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

	serv_addr.sin_port = (int)aParam;

    sock_fd = socket(AF_INET,SOCK_STREAM,0);

    if (sock_fd < 0)

		{

		goto close;

		}

	if (connect(sock_fd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)

		{

		goto close;

		}

	if (read(sock_fd,line) < 0)

		{

		goto close;

		}

close:

	close(sock_fd);

	return (void*)NULL;

	}

int read(int newsock_fd,char *line)

    {    

    int ret;    

    int left = KMaxLine;   

    while (1)

        {

        ret = recv(newsock_fd,line,left,0);

        if (ret < 0)

            {

            return KReadError;

            }

        else if (ret == 0)

            {

            break;

            }

        left -= ret;

        line += ret;

        if (left <= 0)

            {

            break;

            }

        }

    return KErrNone;

    }

TInt CTestSocket::GetSocketName(  )

	{

	int sock_fd;

    sockaddr_in addr,ss;

    TInt ret = KErrNone;

	char paramets[10][256];

	unsigned int len = 0, addr_len = 0;

    /**

     * paramets[0]=socket family;

     * paramets[1]=sockettype

     * paramets[2]=protocol 

     */

	GetParameters(paramets);

	sock_fd=socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) );

	addr.sin_family = AF_INET;

	addr.sin_addr.s_addr = htonl(INADDR_ANY);

	addr.sin_port = 0;

    if (sock_fd < 0)

    	{

    	ret = KErrSocket;

    	goto close;

        }

    if ( bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0)

		{		

		ret = KErrBind;

		goto close;

		}

	addr_len = sizeof(addr);

	if (getsockname(sock_fd, (sockaddr*)&addr, &addr_len) < 0)

		{

		ret = KErrGetSockName;

		goto close;

		}

	len=sizeof(ss);

	if ( getsockname(sock_fd,(sockaddr*)&ss,&len) < 0)

		{

		ret = KErrGetSockName;

	 	return KErrGeneral;

		}

	ret = KErrNone;

close:

	close(sock_fd);

	return ret;

	}

TInt CTestSocket::GetSocketNameUsingFileDescriptor(  )

	{

	sockaddr_in ss;

	unsigned int len;

	int ret = KErrNone;

	len = sizeof(ss);

	// Wrong sockfd, errno shoud be ENOTSOCK

    ret = getsockname(0, (sockaddr*)&ss, &len);

    if (errno != ENOTSOCK)

    	{

    	ret = KErrGetSocketName;

        goto close;

    	}

    if (ret == KErrNone)

    	{

    	ret = KErrGetSocketName;

        goto close;

    	}

	ret = KErrNone;

close:

	return ret;

	}

TInt CTestSocket::GetSocketNameUsingInvalidSocketDescriptor(  )

	{

	sockaddr_in ss;

	unsigned int len;

	int ret = KErrNone;

	len = sizeof(ss);

	// Invalid fd, errno shoud be EBADF

	ret = getsockname(-1, (sockaddr*)&ss, &len);	    

    if (errno != EBADF )

    	{

        ret = KErrGetSocketName;

        goto close;

        }

    if (ret == KErrNone)

    	{

    	ret = KErrGetSocketName;

        goto close;

    	}

	ret = KErrNone;

close:

	return ret;	

	}

TInt CTestSocket::GetSocketNameInvalidSocketBuffer(  )

	{

	int sock_fd;

    sockaddr_in addr,ss;

    TInt ret = KErrNone;

	char paramets[10][256];

	unsigned int len;

    /**

     * paramets[0]=socket family;

     * paramets[1]=sockettype

     * paramets[2]=protocol 

     */

	GetParameters(paramets);

	sock_fd=socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) );

	addr.sin_family = AF_INET;

	addr.sin_addr.s_addr = htonl(INADDR_ANY);

	addr.sin_port = 0;

    if (sock_fd < 0)

    	{

    	ret = KErrSocket;

    	goto close;

        }

    if ( bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0)

		{		

		ret = KErrBind;

		goto close;

		}

	len=sizeof(ss);

	ret = getsockname(sock_fd,(sockaddr*)0,&len);    

    if (errno != EFAULT )

    	{

        ret = KErrGetSocketName;

        goto close;

        }

    if (ret == KErrNone)

    	{

    	ret = KErrGetSocketName;

        goto close;

    	}

	ret = KErrNone;

close:

	close(sock_fd);

	return ret;

	}

TInt CTestSocket::GetSocketNameInvalidLength(  )

	{

	int sock_fd;

    sockaddr_in addr,ss;

    TInt ret = KErrNone;

	char paramets[10][256];

	unsigned int len;

    /**

     * paramets[0]=socket family;

     * paramets[1]=sockettype

     * paramets[2]=protocol 

     */

	GetParameters(paramets);

	sock_fd=socket(atoi(paramets[0]), atoi(paramets[1]), atoi(paramets[2]) );

	addr.sin_family = AF_INET;

	addr.sin_addr.s_addr = htonl(INADDR_ANY);

	addr.sin_port = 0;

    if (sock_fd < 0)

    	{

    	ret = KErrSocket;

    	goto close;

        }

   if ( bind(sock_fd,(sockaddr*)&addr,sizeof(addr)) < 0)

		{		

		ret = KErrBind;

		goto close;

		}

	len=1;

	ret = getsockname(sock_fd,(sockaddr*)&ss,&len);	    

    if (errno != KErrNone )

    	{

        ret = KErrGetSocketName;

        goto close;

        }

    ret = KErrNone;