1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Name        : tlocalsocketblocks.cpp

    15 //

    16 

    17 #include "tlocalsocket.h"

    18 #include <sys/un.h>

    19 #include <sys/stat.h>

    20 #include <pthread.h>

    21 #include <semaphore.h>

    22 

    23 #include <sys/select.h>

    24 

    25 #define SERVPATH "c:\\tmp22.a" 

    26 #define SOCK_PATH "c:\\negsocket.txt"

    27 #define SOCK_PATH1 "c:\\negsocket1.txt"

    28 #define DATA "Hello World"

    29 const TUint KMaxLine = 27;

    30 const TUint KDataLength = sizeof(DATA);

    31 

    32 // Util function to read from a socket

    33 TInt read1(int newsock_fd,char *line)

    34     {    

    35     int ret;    

    36     int left = KMaxLine;   

    37     

    38     while (1)

    39         {

    40         

    41         ret = read(newsock_fd,line,left);

    42         

    43         if (ret < 0)

    44             {

    45             return -1;

    46             }

    47         else if (ret == 0)

    48             {

    49             break;

    50             }

    51         left -= ret;

    52         line += ret;

    53         if (left <= 0)

    54             {

    55             break;

    56             }

    57         }

    58     return 0;

    59     }

    60     

    61 // Util function to write to a socket

    62 TInt write1(int sock_fd)

    63     {

    64     char line[KMaxLine];    

    65     int x;

    66     char character = 'A';

    67     unsigned int cnt = 0;

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

    69         {

    70         line[cnt] = character;

    71         character++;

    72         if (character > 'Z')

    73             {

    74             character = 'A';

    75             }

    76         }

    77     line[cnt] = '\0';

    78     x=write(sock_fd,line,KMaxLine);

    79     if (x < 0)

    80         {

    81         return -1;

    82         }

    83         

    84     return 0;

    85     }

    86     

    87 

    88 static TInt Recv1(int newsock_fd,char *line)

    89     {    

    90     int ret;    

    91     int left = KMaxLine;   

    92     

    93     while (1)

    94         {

    95         

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

    97         

    98         if (ret < 0)

    99             {

   100             return -1;

   101             }

   102         else if (ret == 0)

   103             {

   104             break;

   105             }

   106         left -= ret;

   107         line += ret;

   108         if (left <= 0)

   109             {

   110             break;

   111             }

   112         }

   113     return 0;

   114     }

   115     

   116 // Util function to write to a socket

   117 static TInt Send1(int sock_fd)

   118     {

   119     char line[KMaxLine];    

   120     int x;

   121     char character = 'A';

   122     unsigned int cnt = 0;

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

   124         {

   125         line[cnt] = character;

   126         character++;

   127         if (character > 'Z')

   128             {

   129             character = 'A';

   130             }

   131         }

   132     line[cnt] = '\0';

   133     x=send(sock_fd,line,KMaxLine,0);

   134     if (x < 0)

   135         {

   136         return -1;

   137         }

   138         

   139     return 0;

   140     }

   141 

   142 

   143 // Util function 

   144 static void* TCPThreadWrite(TAny* aPath)

   145 	{

   146 	int sock_fd,len;

   147 		

   148 	struct sockaddr_un remote;

   149 	int tmp;

   150 	memset(&remote, 0x00, sizeof(struct sockaddr_un));    

   151 	remote.sun_family=AF_UNIX;    

   152 	strcpy((char*)&remote.sun_path, (const char *)aPath);

   153 	

   154     sock_fd = socket(AF_UNIX,SOCK_STREAM,0);

   155     if (sock_fd < 0)

   156 		{

   157 		goto close;

   158 		}

   159 	len = sizeof(sockaddr_un);

   160 	tmp = connect(sock_fd,(struct sockaddr *)&remote,len);

   161 	if (tmp < 0)

   162 		{

   163 		goto close;

   164 		}

   165 	if (write1(sock_fd) < 0)

   166 		{

   167 		goto close;

   168 		}

   169 close:

   170 	close(sock_fd);

   171 	unlink((const char *)aPath);

   172 	return (void*)NULL;

   173 	}

   174 	

   175 // Util function	

   176 static void* TCPThreadRead(TAny* aPath)

   177 	{

   178 	int sock_fd,len;

   179 	char line[KMaxLine ];

   180 	

   181 	struct sockaddr_un remote;

   182 	int tmp;

   183 	memset(&remote, 0x00, sizeof(struct sockaddr_un));    

   184 	remote.sun_family=AF_UNIX;    

   185     strcpy((char*)&remote.sun_path, (const char *)aPath);

   186     sock_fd = socket(AF_UNIX,SOCK_STREAM,0);

   187     if (sock_fd < 0)

   188 		{

   189 		goto close;

   190 		}

   191 	len = strlen(remote.sun_path) + sizeof(remote.sun_family);

   192 	tmp = connect(sock_fd,(struct sockaddr *)&remote,len);

   193 	if (tmp < 0)

   194 		{

   195 		goto close;

   196 		}

   197 	if (read1(sock_fd,line) < 0)

   198 		{

   199 		goto close;

   200 		}

   201 close:

   202 	close(sock_fd);

   203 	unlink((const char *)aPath);

   204 	return (void*)NULL;

   205 	}	

   206 	

   207 //Util function to connect to the calling thread

   208 void* ThreadConnect(void*)	

   209 {

   210 	int sockfd = -1;

   211 

   212 	struct sockaddr_un dest;

   213 	unlink(SOCK_PATH);

   214 	sockfd = socket(AF_UNIX, SOCK_STREAM, 0);

   215 	if(sockfd < 0)

   216 		{

   217 		return (void*)NULL;

   218 		}

   219 	memset(&dest, 0x00, sizeof(struct sockaddr_un));

   220 	dest.sun_family=AF_UNIX; 

   221 	strcpy((char*)&dest.sun_path, SOCK_PATH);   

   222 	unlink(SOCK_PATH);

   223 	if ( bind(sockfd,(struct sockaddr *)&dest,sizeof(dest))  < 0)

   224 		{

   225 		if(sockfd)

   226 			close(sockfd);

   227 		return (void*)NULL;

   228 		}

   229 

   230 	strcpy((char*)&dest.sun_path, SERVPATH);

   231 	if(connect(sockfd, (struct sockaddr *)&dest, sizeof(dest)) < 0)

   232 		{

   233 		close(sockfd);

   234 		return (void*)NULL;

   235 		}

   236 	sleep(1);

   237 	if(sockfd)

   238 		close(sockfd);

   239 	return (void*)NULL;

   240 }

   241 

   242 //Util function to sendto() a datagram socket

   243 void *ThreadSendto(void *)

   244 {

   245 	int sockfd = -1;

   246     struct sockaddr_un dest;

   247     sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);

   248     if(sockfd < 0)

   249     	return (void*)NULL;

   250 	memset(&dest, 0x00, sizeof(struct sockaddr_un));    

   251 	dest.sun_family=AF_UNIX;    

   252 	strcpy((char*)&dest.sun_path, SERVPATH);

   253 	socklen_t length = sizeof(struct sockaddr);

   254 	sendto(sockfd, DATA, KDataLength, 0, (struct sockaddr*)&dest, length);

   255 	if(sockfd)

   256 		close(sockfd);

   257 	return (void*)NULL;

   258 }

   259 

   260 //Util function to recvfrom() a datagram socket

   261 void *ThreadRecvfrom(void *)

   262 	{

   263 	int sockfd = -1;

   264 	char buf[KDataLength];

   265 	struct sockaddr_un dest,from;

   266     sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);

   267     if(sockfd < 0)

   268     	return (void*)NULL;

   269     unlink(SERVPATH);

   270 	memset(&dest, 0x00, sizeof(struct sockaddr_un));    

   271 	dest.sun_family=AF_UNIX;    

   272 	strcpy((char*)&dest.sun_path, SERVPATH);

   273 	if ( bind(sockfd,(struct sockaddr *)&dest,sizeof(dest))  < 0)

   274 		{

   275 		if(sockfd)

   276 			close(sockfd);

   277 		unlink(SERVPATH);

   278 		return (void*)NULL;

   279 		}

   280 

   281 	socklen_t length = sizeof(from);

   282 	recvfrom(sockfd, buf, KDataLength, 0, (struct sockaddr*)&from, &length);

   283 	if(sockfd)

   284 		close(sockfd);

   285 	unlink(SERVPATH);

   286 	return (void*)NULL;

   287 	}

   288 

   289 /**

   290 * Function Name		: TestBind

   291 * Description		: bind a local socket

   292 * Return Value		: Test case should return KErrNone

   293 */

   294 TVerdict CTestLocalSocket::TestBind( )

   295     {

   296     INFO_PRINTF1(_L("TestBind"));

   297     int fd = -1;

   298     int rslt = -1;

   299     int sz = 0,err;

   300     const char path[] = "C:\\TestBind";

   301     struct sockaddr_un server;

   302         

   303     server.sun_family = PF_LOCAL;

   304     strncpy(server.sun_path, path, strlen(path)+1);

   305     sz = SUN_LEN(&server);

   306     

   307     fd = socket(PF_LOCAL, SOCK_STREAM, 0);

   308     if (fd < 0)

   309     	{

   310     	INFO_PRINTF2(_L("protocol not supported. Errno is %d"), errno);

   311     	return TestStepResult();

   312     	}

   313 

   314     rslt = bind(fd, (struct sockaddr*)&server, sz);

   315     

   316     if (rslt < 0)

   317        {

   318        INFO_PRINTF2(_L("socket binding error: %d"), errno);

   319        close(fd);

   320        unlink(path);

   321        return TestStepResult();

   322        }

   323     err=fcntl(fd, F_SETFL, O_NONBLOCK);

   324     if(err==-1)

   325     	{

   326     	INFO_PRINTF1(_L("fcntl failure"));

   327     	}

   328     close(fd);

   329     unlink(path);

   330 	

   331     SetTestStepResult(EPass);

   332     return TestStepResult();

   333     }

   334 

   335 /**

   336 * Function Name		: TestLseek

   337 * Description		: Perform LSeek on a local socket

   338 * Return Value		: Test case should return KErrNone

   339 */

   340 TVerdict CTestLocalSocket::TestLseek()

   341 	{

   342 	int sock_fd;

   343 	const char path[] = "C:\\TestLSeek";

   344 	struct sockaddr_un serveraddr;

   345     

   346     serveraddr.sun_family = PF_LOCAL;

   347     strncpy(serveraddr.sun_path, path, strlen(path)+1);

   348 	sock_fd=socket(AF_UNIX, SOCK_STREAM, 0);  

   349     if (sock_fd < 0)

   350     	{

   351     	INFO_PRINTF2(_L("protocol not supported. Errno is %d"), errno);

   352     	return TestStepResult();

   353         }

   354 

   355     if (lseek(sock_fd,0,SEEK_CUR)<0)

   356     	{

   357 		INFO_PRINTF1(_L("Lseek on socket success"));

   358 		close(sock_fd);

   359 		unlink(SERVPATH);

   360 		SetTestStepResult(EPass);

   361     	}

   362     else

   363     	{

   364     	close(sock_fd);

   365     	unlink(SERVPATH);

   366     	INFO_PRINTF2(_L("Lseek fails with errno no: %d"), errno);

   367     	}

   368     return TestStepResult();

   369 	}

   370 

   371 /**

   372 * Function Name		: TestFstat

   373 * Description		: Perform FStat on a local socket

   374 * Return Value		: Test case should return KErrNone

   375 */	

   376 TVerdict CTestLocalSocket::TestFstat()

   377 	{

   378 	int sock_fd;

   379 	const char path[] = "C:\\TestFStat";

   380 	struct sockaddr_un serveraddr;

   381     

   382     serveraddr.sun_family = PF_LOCAL;

   383     strncpy(serveraddr.sun_path, path, strlen(path)+1);

   384 	sock_fd=socket(AF_UNIX, SOCK_STREAM, 0);  

   385     if (sock_fd < 0)

   386     	{

   387     	INFO_PRINTF2(_L("Socket open failed with errno: %d"), errno);

   388     	return TestStepResult();

   389         }

   390 

   391     struct stat buf;

   392     if(fstat(sock_fd , &buf ) < 0 ) 

   393     	{

   394     	INFO_PRINTF1(_L("fstat on socket failure"));

   395 		close(sock_fd);

   396 		unlink(SERVPATH);

   397     	}

   398     else

   399     	{

   400     	close(sock_fd);

   401     	unlink(SERVPATH);

   402     	SetTestStepResult(EPass);

   403     	}

   404     return TestStepResult();

   405 	}

   406 	

   407 /**

   408 * Function Name		: TestThreadSocketRead

   409 * Description		: Perform read on a local socket

   410 * Return Value		: Test case should return KErrNone

   411 */	

   412 TVerdict CTestLocalSocket::TestThreadSocketRead()

   413 	{

   414 	int sock_fd,newsock_fd;	

   415 	int error;            

   416 	unsigned int t;

   417 	struct sockaddr_un serveraddr,remote;

   418 	char line[KMaxLine ];

   419 	sock_fd = socket(AF_UNIX,SOCK_STREAM,0);

   420 	if (sock_fd < 0)

   421         {

   422         INFO_PRINTF2(_L("Socket open failed with errno: %d"), errno);

   423     	return TestStepResult();

   424         }

   425 

   426 	pthread_t testThread;

   427 	int threadRetVal;

   428 	void *threadRetValPtr = (void*)&threadRetVal;

   429 	

   430 	memset(&serveraddr, 0x00, sizeof(struct sockaddr_un));    

   431 	serveraddr.sun_family=AF_UNIX;    

   432 	strcpy((char*)&serveraddr.sun_path, SERVPATH);    

   433 	if ( bind(sock_fd,(struct sockaddr *)&serveraddr,sizeof(serveraddr))  < 0)

   434 		{		

   435 		INFO_PRINTF2(_L("Socket bind failed with errno: %d"), errno);

   436 		goto close;

   437 		}

   438 		

   439 	if(listen(sock_fd,3) < 0)

   440 		{

   441 		ERR_PRINTF2(_L("Listen failed with errno: %d\n"),errno);

   442 		goto close;

   443 		}

   444 	t=sizeof(remote);

   445 	// Create the thread and thread is client code 

   446 	pthread_create(&testThread, NULL, &TCPThreadWrite, (void*)(serveraddr.sun_path));

   447 	

   448 	newsock_fd = accept(sock_fd,(sockaddr*)&remote,&t); 

   449 	if(newsock_fd < 0)

   450 		{

   451 		ERR_PRINTF2(_L("Accept failed %d\n"),errno);

   452 		goto close;

   453 		}

   454 	error = read1(newsock_fd,line);

   455 	if (error < 0)

   456 		{		

   457 		INFO_PRINTF2(_L("read failed with error %d"), error);

   458 		goto close;

   459 		}

   460 	SetTestStepResult(EPass);

   461 close:

   462 	pthread_join(testThread, &threadRetValPtr);

   463 	shutdown(sock_fd,SHUT_RDWR);

   464 	close(sock_fd);

   465 	unlink(SERVPATH);

   466 	return TestStepResult();	

   467 	}

   468 

   469 

   470 /**

   471 * Function Name		: TestThreadSocketRead

   472 * Description		: Perform read on a local socket

   473 * Return Value		: Test case should return KErrNone

   474 */	

   475 TVerdict CTestLocalSocket::TestThreadSocketRecv()

   476 	{

   477 	int sock_fd,newsock_fd;	

   478 	int error;            

   479 	unsigned int t;

   480 	struct sockaddr_un serveraddr,remote;

   481 	char line[KMaxLine ];

   482 	sock_fd = socket(AF_LOCAL,SOCK_STREAM,0);

   483 	if (sock_fd < 0)

   484         {

   485         INFO_PRINTF2(_L("Socket open failed with errno: %d"), errno);

   486     	return TestStepResult();

   487         }

   488 

   489 	memset(&serveraddr, 0x00, sizeof(struct sockaddr_un));    

   490 	serveraddr.sun_family=AF_LOCAL;    

   491 	strcpy((char*)&serveraddr.sun_path, SERVPATH);    

   492 	

   493 	pthread_t testThread;

   494 	int threadRetVal;

   495 	void *threadRetValPtr = (void*)&threadRetVal;

   496 		

   497 	if ( bind(sock_fd,(struct sockaddr *)&serveraddr,sizeof(serveraddr))  < 0)

   498 		{		

   499 		INFO_PRINTF2(_L("Socket bind failed with errno: %d"), errno);

   500 		goto close;

   501 		}

   502 		

   503 	if(listen(sock_fd,3) < 0)

   504 		{

   505 		ERR_PRINTF2(_L("Listen failed with errno: %d\n"),errno);

   506 		goto close;

   507 		}

   508 	

   509 	t=sizeof(remote);

   510 	// Create the thread and thread is client code 

   511 	pthread_create(&testThread, NULL, &TCPThreadWrite, (void*)(serveraddr.sun_path));

   512 

   513 	newsock_fd = accept(sock_fd,(sockaddr*)&remote,&t); 

   514 	if(newsock_fd < 0)

   515 		{

   516 		INFO_PRINTF2(_L("accept bind failed with errno: %d"), errno);

   517 		goto close;

   518 		}

   519 	error = Recv1(newsock_fd,line);

   520 	if (error < 0)

   521 		{		

   522 		INFO_PRINTF2(_L("read failed with error %d"), error);

   523 		goto close;

   524 		}

   525 	SetTestStepResult(EPass);

   526 close:

   527 	pthread_join(testThread, &threadRetValPtr);

   528 	shutdown(sock_fd,SHUT_RDWR);

   529 	close(sock_fd);

   530 	unlink(SERVPATH);

   531 	return TestStepResult();	

   532 	}

   533 	

   534 /**

   535 * Function Name		: TestThreadSocketWrite

   536 * Description		: Perform write on a local socket

   537 * Return Value		: Test case should return KErrNone

   538 */	

   539 TVerdict CTestLocalSocket::TestThreadSocketWrite()

   540 	{

   541 	int sock_fd,newsock_fd;	

   542 	int error;            

   543 	unsigned int t;

   544 	struct sockaddr_un serveraddr,remote;

   545 	sock_fd = socket(AF_UNIX,SOCK_STREAM,0);

   546 	if (sock_fd < 0)

   547         {

   548         INFO_PRINTF2(_L("Socket open failed with errno: %d"), errno);

   549     	return TestStepResult();

   550         }

   551 

   552 	memset(&serveraddr, 0x00, sizeof(struct sockaddr_un));    

   553 	serveraddr.sun_family=AF_UNIX;    

   554 	strcpy((char*)&serveraddr.sun_path, SERVPATH);    

   555 

   556 	pthread_t testThread;

   557 	int threadRetVal;

   558 	void *threadRetValPtr = (void*)&threadRetVal;

   559 	

   560 	if ( bind(sock_fd,(struct sockaddr *)&serveraddr,sizeof(serveraddr))  < 0)

   561 		{		

   562 		INFO_PRINTF2(_L("BIND failed with errno: %d"), errno);

   563 		goto close;

   564 		}

   565 		

   566 	if(listen(sock_fd,3) < 0)

   567 		{

   568 		ERR_PRINTF2(_L("Listen failed with errno: %d\n"),errno);

   569 		goto close;

   570 		}

   571 	

   572 	t=sizeof(remote);

   573 	// Create the thread and thread is client code 

   574 	pthread_create(&testThread, NULL, &TCPThreadRead, (void*)(serveraddr.sun_path));

   575 

   576 	newsock_fd = accept(sock_fd,(sockaddr*)&remote,&t); 

   577 	error = write1(newsock_fd);

   578 	if (error < 0)

   579 		{		

   580 		goto close;

   581 		}

   582 	SetTestStepResult(EPass);

   583 close:

   584 	pthread_join(testThread, &threadRetValPtr);

   585 	shutdown(sock_fd,SHUT_RDWR);

   586 	close(sock_fd);

   587 	unlink(SERVPATH);

   588 	return TestStepResult();	

   589 

   590 	}

   591 

   592 /**

   593 * Function Name		: TestThreadSocketSend

   594 * Description		: Perform Send on a local socket

   595 * Return Value		: Test case should return KErrNone

   596 */	

   597 TVerdict CTestLocalSocket::TestThreadSocketSend()

   598 	{

   599 	int sock_fd,newsock_fd;	

   600 	int error;            

   601 	unsigned int t;

   602 	struct sockaddr_un serveraddr,remote;

   603 	sock_fd = socket(AF_LOCAL,SOCK_STREAM,0);

   604 	if (sock_fd < 0)

   605         {

   606         INFO_PRINTF2(_L("Socket open failed with errno: %d"), errno);

   607     	return TestStepResult();

   608         }

   609 

   610 	memset(&serveraddr, 0x00, sizeof(struct sockaddr_un));    

   611 	serveraddr.sun_family=AF_LOCAL;    

   612 	strcpy((char*)&serveraddr.sun_path, SERVPATH);

   613 	

   614 	pthread_t testThread;

   615 	int threadRetVal;

   616 	void *threadRetValPtr = (void*)&threadRetVal;

   617 		

   618 	if ( bind(sock_fd,(struct sockaddr *)&serveraddr,sizeof(serveraddr))  < 0)

   619 		{		

   620 		INFO_PRINTF2(_L("socket bind failed with errno: %d"), errno);

   621 		goto close;

   622 		}

   623 		

   624 	if(listen(sock_fd,3) < 0)

   625 		{

   626 		ERR_PRINTF2(_L("Listen failed with errno: %d\n"),errno);

   627 		goto close;

   628 		}

   629 	

   630 	t=sizeof(remote);

   631 	// Create the thread and thread is client code 

   632 	pthread_create(&testThread, NULL, &TCPThreadRead, (void*)(serveraddr.sun_path));

   633 

   634 	newsock_fd = accept(sock_fd,(sockaddr*)&remote,&t);

   635 	if(newsock_fd < 0)

   636 		{

   637 		INFO_PRINTF2(_L("accept failed with errno: %d"), errno);

   638 		goto close;

   639 		}

   640 	error = Send1(newsock_fd);

   641 	if (error < 0)

   642 		{		

   643 		INFO_PRINTF2(_L("Send failed with errno: %d"), errno);

   644 		goto close;

   645 		}

   646 	

   647 	SetTestStepResult(EPass);

   648 close:

   649 	pthread_join(testThread, &threadRetValPtr);

   650 	shutdown(sock_fd,SHUT_RDWR);

   651 	close(sock_fd);

   652 	unlink(SERVPATH);

   653 	return TestStepResult();	

   654 

   655 	}

   656 

   657 

   658 /**

   659 * Function Name		: TestMultProc

   660 * Description		: Perform read and write on a local socket across processes

   661 * Return Value		: Test case should return KErrNone

   662 */

   663 TVerdict CTestLocalSocket::TestMultProc()

   664 	{

   665 	char *cmd="Z:\\sys\\bin\\tsample.exe";

   666 	int fp,n=0;

   667 	int sock_fd,len;

   668 	char line[KMaxLine ];

   669     struct sockaddr_un remote;

   670 	

   671 	memset(&remote, 0x00, sizeof(struct sockaddr_un));    

   672 	remote.sun_family=AF_UNIX;    

   673 	strcpy((char*)&remote.sun_path, "c:\\tmp.pipe");

   674 	

   675     sock_fd = socket(AF_UNIX,SOCK_STREAM,0);

   676     INFO_PRINTF1(_L("socket in client called"));

   677     

   678     

   679     int fds[3]; 

   680     int tmp;

   681     int val;

   682     fp = popen3(cmd,NULL, NULL, fds);

   683     if(fp < 0)

   684     	{

   685     	INFO_PRINTF2(_L("popen3 failed with errno: %d"), errno);

   686     	goto close;

   687     	}

   688     sleep(1);

   689     len = strlen(remote.sun_path) + sizeof(remote.sun_family);

   690 	tmp = connect(sock_fd,(struct sockaddr *)&remote,len);

   691 	if (tmp < 0)

   692 		{

   693 		INFO_PRINTF2(_L("connect failed with errno: %d"), errno);

   694 		goto close;

   695 		}   

   696 	

   697 	if (read1(sock_fd,line) < 0)

   698 		{

   699 		INFO_PRINTF2(_L("read failed with errno: %d"), errno);

   700 		goto close;

   701 		}

   702 	

   703 	val=strcmp(line, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");	

   704 	if(val)

   705 		{

   706 		INFO_PRINTF1(_L("string compare failed"));

   707 		}

   708 	else

   709 		{

   710 		SetTestStepResult(EPass);

   711 		}

   712     INFO_PRINTF2(_L("n=%d"),n);    

   713 	n=errno;

   714 close:

   715     close(sock_fd);

   716 	unlink(SERVPATH);

   717     return TestStepResult();	

   718 	}

   719 	

   720 struct TThreadParam

   721 	{

   722 	TInt iDataCount;

   723 	sem_t iSemaphore;

   724 	};

   725 

   726 //Util function

   727 void* SocketReadThreadEntryPoint(void* aParam)

   728 	{

   729 	TInt retVal = 0;

   730 	TInt count = 5;

   731     TThreadParam* pThreadParam = ( TThreadParam* ) aParam;

   732 

   733 	TInt portNum = 0;

   734 	int serverFd = 0;

   735 	int newFd = 0;

   736 	size_t addrSize;

   737 	struct sockaddr_in servAddr;

   738 	struct sockaddr_in sockAddr;

   739 	const char* buff = "Server --> Sending Data Item : ";

   740 	char sendBuff[50];

   741 	char recvBuff[100];

   742 	const unsigned int maxRecv = 100;

   743 

   744 	serverFd = socket(PF_LOCAL, SOCK_STREAM, 0);

   745 	if( serverFd == -1 )

   746 		{

   747 		retVal = -1;

   748 		}

   749 

   750 	(&servAddr)->sin_addr.s_addr  = 0x0100007F;

   751 	(&servAddr)->sin_family = PF_LOCAL;

   752 

   753 	servAddr.sin_port = htons( (TUint16) portNum );

   754 	retVal |= bind( serverFd, (struct sockaddr*)&servAddr, sizeof(servAddr) );

   755 	if( retVal != 0 )

   756 		{

   757 		close( serverFd );

   758 		retVal = -1;

   759 		}

   760 

   761 	

   762 

   763 	addrSize = sizeof( sockAddr );

   764 

   765 	//Tell the other thread that data is ready for reading

   766 	retVal = sem_post(&pThreadParam->iSemaphore);

   767 	if( retVal != 0 )

   768 		{

   769 		close( serverFd );

   770 		retVal = -1;

   771 		}

   772 

   773 	newFd = accept( serverFd, (struct sockaddr*)&sockAddr, &addrSize);

   774 	if( newFd == -1 )

   775 		{

   776 		close( serverFd );

   777 		retVal = -1;

   778 	    return (void*)retVal;

   779 		}

   780 

   781 	if( 0 == retVal )

   782 		{

   783 		//Now Receive and Send some Data

   784 		for(TUint i=1; i<=count; i++)

   785 			{

   786 			TInt ret = recv(newFd, recvBuff, maxRecv, 0);

   787 			if( ret == -1 )

   788 				{

   789 				close( newFd );

   790 				close( serverFd );

   791 				retVal = -1;

   792 				break;

   793 				}

   794 			sprintf(sendBuff, "%s %d", buff, i);

   795 			ret = send(newFd, sendBuff, sizeof(sendBuff), 0);

   796 			if( ret == -1 )

   797 				{

   798 				close( newFd );

   799 				close( serverFd );

   800 				retVal = -1;

   801 				break;

   802 				}

   803 			}

   804 		}

   805 

   806 	if( 0 == retVal )

   807 		{

   808 		close( newFd );

   809 		close( serverFd );

   810 		}

   811 	return (void*)retVal;

   812 	}

   813 

   814 //Util function

   815 void* SocketWriteThreadEntryPoint(void* aParam)

   816 	{

   817 	TInt retVal = 0;

   818 	TInt count = 5;

   819     TThreadParam* pThreadParam = ( TThreadParam* ) aParam;

   820 

   821 	TInt portNum = 0;

   822 	int clientFd;

   823 	size_t addrSize;

   824 	struct sockaddr_in servAddr;

   825 	const char* buff = "Client --> Sending Data Item : ";

   826 	char sendBuff[50];

   827 	char recvBuff[100];

   828 	const unsigned int maxRecv = 100;

   829 

   830 	(&servAddr)->sin_addr.s_addr  = 0x0100007F;

   831 	(&servAddr)->sin_family = PF_LOCAL;

   832 

   833 	servAddr.sin_port = htons( portNum );

   834 

   835 	clientFd = socket(PF_LOCAL, SOCK_STREAM, 0);

   836 	if( clientFd == -1 )

   837 		{

   838 		retVal = -1;

   839 		}

   840 

   841     //Wait for the other thread to write some data to file

   842     retVal = sem_wait(&pThreadParam->iSemaphore);

   843     if( retVal != 0 )

   844     	{

   845     	close(clientFd);

   846     	retVal = -1;

   847 	    return (void*)retVal;

   848     	}

   849 

   850 	addrSize = sizeof(servAddr);

   851 	retVal = connect(clientFd, (struct sockaddr*)&servAddr, addrSize);

   852 	if( retVal == -1 )

   853 		{

   854 		close(clientFd);

   855 		retVal = -1;

   856 		}

   857 

   858 	if( 0 == retVal )

   859 		{

   860 		//Now Send and Receive some Data

   861 		for(TUint i=1; i<=count; i++)

   862 			{

   863 			sprintf(sendBuff, "%s %d", buff, i);

   864 			TInt ret = send(clientFd, sendBuff, sizeof(sendBuff), 0);

   865 			if(ret == -1)

   866 				{

   867 				close( clientFd );

   868 				retVal = -1;

   869 				break;

   870 				}

   871 			ret = recv(clientFd, recvBuff, maxRecv, 0);

   872 			if(ret == -1)

   873 				{

   874 				close( clientFd );

   875 				retVal = -1;

   876 				break;

   877 				}

   878 			}

   879 		}

   880 

   881 	if (0 == retVal )

   882 		{

   883 		close( clientFd );

   884 		}

   885 

   886 	return (void*)retVal;

   887 	}

   888 

   889 /**

   890 * Function Name		: TestMultThread

   891 * Description		: Perform read and write on a local socket across threads

   892 * Return Value		: Test case should return KErrNone

   893 */

   894 TVerdict CTestLocalSocket::TestMultThread()

   895 	{

   896 	int retVal = 0;

   897 	

   898 	

   899     TThreadParam threadParam;

   900 

   901 	if( sem_init( &threadParam.iSemaphore, 0, 0 ) != 0 )

   902     	{

   903     	

   904     	//return -1;

   905     	return TestStepResult();

   906     	}

   907 

   908 	pthread_t threadID1 = 0;

   909 	pthread_t threadID2 = 0;

   910 	pthread_attr_t threadAttr;

   911 	pthread_attr_init( &threadAttr );

   912 	pthread_attr_setdetachstate( &threadAttr, PTHREAD_CREATE_JOINABLE );

   913 

   914 	//Create a Read thread now

   915 	retVal = pthread_create( &threadID1, &threadAttr, SocketReadThreadEntryPoint,

   916 		(void*)&threadParam );

   917 	

   918 	if( retVal == 0)

   919 		{

   920 		//Create Write thread

   921 		retVal = pthread_create( &threadID2, &threadAttr,

   922 			SocketWriteThreadEntryPoint, (void*)&threadParam );

   923 		

   924 		//If its joinable thread and waitFlag id set

   925 		if( 0 == retVal )

   926 			{

   927 			TInt exitReason = 0;

   928 			retVal = pthread_join(threadID1, (void**)&exitReason );

   929 			

   930 			retVal = pthread_join(threadID2, (void**)&exitReason );

   931 			

   932 			}

   933 		}

   934 

   935 	if( sem_destroy( &threadParam.iSemaphore ) != 0 )

   936 		{

   937 		return TestStepResult();

   938 		//retVal = -1;

   939 		}

   940 

   941 	SetTestStepResult(EPass);

   942 	return TestStepResult();

   943 	}

   944 

   945 		

   946 

   947 /*

   948 * Testcase		: TestSetGetSockOpt

   949 * Description	: Test setsockopt for different values of option_name

   950 *					1. SO_SNDBUF

   951 *					2. SO_RCVBUF

   952 *					3. SO_DEBUG

   953 *				  and upon succes of setsockopt, test getsockopt for the same

   954 * Result		: KErrNone

   955 */ 

   956 TVerdict CTestLocalSocket::TestSetGetSockOpt()

   957 	{

   958 	INFO_PRINTF1(_L("TestSetGetSockOpt"));

   959 	int fd;

   960 	int sz = 0, optionName = 0;

   961 	int rslt;

   962 	const char path[] = "C:\\TestSetGetSockOpt";

   963 	struct sockaddr_un server;

   964         

   965     server.sun_family = PF_LOCAL;

   966     strncpy(server.sun_path, path, strlen(path)+1);

   967     sz = SUN_LEN(&server);

   968     

   969     fd = socket(PF_LOCAL, SOCK_STREAM, 0);

   970     if (fd < 0)

   971     	{

   972     	INFO_PRINTF2(_L("protocol not supported. Errno is %d"), errno);

   973     	return TestStepResult();

   974     	}

   975    	   	

   976    	rslt = bind(fd, (struct sockaddr*)&server, sz);

   977     

   978     if (rslt)

   979        	{

   980        	INFO_PRINTF2(_L("socket binding error: %d"), errno);

   981        	unlink(path);

   982 		close(fd);

   983        	return TestStepResult();

   984        	}

   985        

   986     int optionValue = KMaxLine;

   987     _LIT( KOptionName, "OptionName" );

   988 	rslt = GetIntFromConfig(ConfigSection(), KOptionName, optionName);

   989 	if(!rslt)

   990 		{

   991 	 	INFO_PRINTF1(_L("Could not read option name from ini file"));

   992 	 	close(fd);

   993 		unlink(path);

   994 	 	return TestStepResult();

   995 		}    

   996     

   997     rslt = setsockopt(fd, SOL_SOCKET, optionName, &optionValue, sizeof(optionValue));

   998 	if(rslt < 0)

   999 		{

  1000 		INFO_PRINTF2(_L("Setsockopt fails with error no: %d"), errno);

  1001 		}

  1002 	else

  1003 		{

  1004 		INFO_PRINTF1(_L("Setsockopt successful"));

  1005 		

  1006 		unsigned int optionLen = sizeof(optionValue);

  1007   		int readOptionValue = 0;

  1008     	rslt = getsockopt(fd, SOL_SOCKET, optionName, (void *)&readOptionValue, &optionLen);

  1009     

  1010     	if(rslt < 0)

  1011 			{

  1012 			INFO_PRINTF2(_L("Getsockopt fails with error no: %d"), errno);

  1013 			}

  1014 		else

  1015 			{

  1016 			INFO_PRINTF1(_L("Getsockopt successful"));

  1017 			SetTestStepResult(EPass);

  1018 			}

  1019 		}

  1020 	

  1021 	close(fd);

  1022 	unlink(path);

  1023 	return TestStepResult();

  1024 	}

  1025 

  1026 /*

  1027 * Testcase		: TestSetSockOptNegative1

  1028 * Description	: Test setsockopt for an invalid value of option_name

  1029 * Result		: setsockopt returns setting errno to EINVAL, 

  1030 *				  Test case returns KErrNone

  1031 */

  1032 TVerdict CTestLocalSocket::TestSetSockOptNegative1()

  1033 	{

  1034 	INFO_PRINTF1(_L("TestSetSockOptNegative1"));

  1035 	int fd;

  1036 	int sz = 0, optionName = 0;

  1037 	int rslt;

  1038 	const char path[] = "C:\\TestSetSockOptNegative1";

  1039 	struct sockaddr_un server;

  1040         

  1041     server.sun_family = PF_LOCAL;

  1042     strncpy(server.sun_path, path, strlen(path)+1);

  1043     sz = SUN_LEN(&server);

  1044     

  1045     fd = socket(PF_LOCAL, SOCK_STREAM, 0);

  1046     if (fd < 0)

  1047     	{

  1048     	INFO_PRINTF2(_L("protocol not supported. Errno is %d"), errno);

  1049     	return TestStepResult();

  1050     	}

  1051    	   	

  1052    	rslt = bind(fd, (struct sockaddr*)&server, sz);

  1053     

  1054     if (rslt)

  1055        {

  1056        INFO_PRINTF1(_L("socket binding error"));

  1057        return TestStepResult(); 

  1058        }

  1059        

  1060     int optionValue = KMaxLine;

  1061     _LIT( KOptionName, "OptionName" );

  1062 	rslt = GetIntFromConfig(ConfigSection(), KOptionName, optionName);

  1063 	if(!rslt)

  1064 		{

  1065 	 	INFO_PRINTF1(_L("Could not read option name from ini file"));

  1066 	 	close(fd);

  1067 		unlink(path);

  1068 	 	return TestStepResult();

  1069 		}    

  1070     

  1071     rslt = setsockopt(fd, SOL_SOCKET, optionName, &optionValue, sizeof(optionValue));

  1072 	if(rslt < 0 && errno == ENOPROTOOPT)

  1073 		{

  1074 		INFO_PRINTF1(_L("setsockopt fails with right error value"));

  1075 		SetTestStepResult(EPass);

  1076 		}

  1077 	else

  1078 		{

  1079 		INFO_PRINTF2(_L("Setsockopt fails with error no: %d"), errno);

  1080 		}

  1081 	

  1082 	close(fd);

  1083 	unlink(path);

  1084 	return TestStepResult();

  1085 	}

  1086 /*

  1087 * Testcase		: TestSetSockOptNegative2

  1088 * Description	: Test setsockopt for invalid value of socklen_t

  1089 * Result		: setsockopt returns -1 setting errno to EINVAL 

  1090 *				  Test case returns KErrNone

  1091 */	

  1092 TVerdict CTestLocalSocket::TestSetSockOptNegative2()

  1093 	{

  1094 	INFO_PRINTF1(_L("TestSetSockOptNegative2"));

  1095 	int fd;

  1096 	int sz = 0;

  1097 	int rslt;

  1098 	const char path[] = "C:\\TestSetSockOptNegative2";

  1099 	struct sockaddr_un server;

  1100         

  1101     server.sun_family = PF_LOCAL;

  1102     strncpy(server.sun_path, path, strlen(path)+1);

  1103     sz = SUN_LEN(&server);

  1104     

  1105     fd = socket(PF_LOCAL, SOCK_STREAM, 0);

  1106     if (fd < 0)

  1107     	{

  1108     	INFO_PRINTF2(_L("protocol not supported. Errno is %d"), errno);

  1109     	return TestStepResult();

  1110     	}

  1111    	   	

  1112    	rslt = bind(fd, (struct sockaddr*)&server, sz);

  1113     

  1114     if (rslt)

  1115        {

  1116        INFO_PRINTF1(_L("socket binding error"));

  1117        return TestStepResult();

  1118        }

  1119        

  1120     int optionValue = KMaxLine;

  1121     int sockLen=0;

  1122     

  1123     _LIT( KSocketLen, "SocketLen" );

  1124 	rslt = GetIntFromConfig(ConfigSection(), KSocketLen, sockLen);

  1125 	if(!rslt)

  1126 		{

  1127 	 	INFO_PRINTF1(_L("Could not read option name from ini file"));

  1128 	 	close(fd);

  1129 		unlink(path);

  1130 	 	return TestStepResult();

  1131 		}    

  1132     rslt = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optionValue, sockLen);

  1133     if(rslt < 0 && errno == EINVAL)

  1134 		{

  1135 		INFO_PRINTF1(_L("Setsockopt fails with right error value"));