1 /*

     2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <e32svr.h>

    21 #include "tifioctls.h"

    22 

    23 #include <stdio.h>

    24 #include <sys/types.h>

    25 #include <string.h>

    26 #include <sys/socket.h>

    27 #include <stdapis/arpa/inet.h>

    28 #include <cdblen.h>

    29 #include <stdapis/net/if.h>

    30 #include <sys/ioctl.h>

    31 #include <stdapis/netinet/in.h>

    32 #include <stdlib.h>

    33 #include <unistd.h>

    34 #include <netdb.h>

    35 #include <fcntl.h>

    36 #include <stdapis/net/route.h>

    37 #include <in_sock.h>

    38 #include <in_iface.h>

    39 #include <es_sock.h>

    40 #include <in_sock.h>

    41 #include <in_iface.h>

    42 #include <nifman.h>

    43  

    44 

    45 // EXTERNAL FUNCTION PROTOTYPES

    46 TInt PrintInterfaceList(void *aIfc);

    47 TInt PrintAndSelectInterface(void *aIfc, ifreq &aIfr);

    48 //void GetParameters(char aParamets[10][256]);

    49 void StripStar(char *aString);

    50 

    51 // CONSTANTS

    52 const TInt KErrSocket = -1002;

    53 const TInt KErrIoctl = -1003;

    54 //const TInt KErrGetHostByName = -1004;

    55 const TInt KErrBind = -1005;

    56 const TInt KErrConnect = -1006;

    57 const TInt KErrSendto = -1007;

    58 

    59 const TUint KTestPort = 5000;

    60 

    61 

    62 

    63 // MODULE DATA STRUCTURES

    64 enum InterfaceType

    65 	{

    66 	EACCESS_POINT,

    67 	EACTIVE_CONNECTION

    68 	};

    69 // ============================ MEMBER FUNCTIONS ===============================

    70 

    71 // -----------------------------------------------------------------------------

    72 // CTestIfioctls::ExampleL

    73 // Example test method function.

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

    75 // -----------------------------------------------------------------------------

    76 //

    77 TInt CTestIfioctls::ExampleL(  )

    78     {

    79 

    80     // Print to UI

    81     _LIT( Ktifioctls, "tifioctls: In Example" );

    82     INFO_PRINTF1(Ktifioctls);

    83     

    84     TPtrC string;

    85     _LIT( KParam, "Param: %S" );

    86     _LIT( Kstring, "string" );

    87      

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

    89     if (res)

    90     {

    91         INFO_PRINTF2( KParam, &string );

    92        

    93     }

    94     return KErrNone;

    95 

    96     }

    97 TInt CTestIfioctls::ListInterfaces(  )

    98 	{

    99 	ifconf ifc;

   100 	TInt sockfd;

   101 	TInt ret = KErrNone;

   102 	TBool res = EFalse;

   103 	TInt Iface;

   104 	_LIT( KIface, "Iface" );

   105 	TInt operation ; 

   106 	sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);	

   107     if (sockfd < 0)

   108         {

   109         ret = KErrSocket;

   110         goto close;

   111         }

   112    	

   113    	TInt IfconfLen;

   114    	_LIT( KIfconfLen, "IfconfLen" );

   115 	res = GetIntFromConfig(ConfigSection(), KIfconfLen, IfconfLen);

   116 	if(!res)

   117 		{

   118 	 	_LIT(Kerr , "Failed to read ifconfig length") ;

   119 		close(sockfd);

   120 	 	INFO_PRINTF1(Kerr) ;

   121 	 	return KErrGeneral ;

   122 		}

   123    

   124 	ifc.ifc_len = sizeof(ifreq) * IfconfLen;	

   125 	if (ifc.ifc_len == 0)

   126 		{

   127 		ifc.ifc_buf = NULL;

   128 		}

   129 	else

   130 		{

   131 		ifc.ifc_buf = (caddr_t)malloc( ifc.ifc_len );

   132 		}	

   133 	// 1 = Interfaces, 2 = Active interfaces

   134 	

   135 	res = GetIntFromConfig(ConfigSection(), KIface, Iface);

   136 	if(!res)

   137 		{

   138 	 	_LIT(Kerr , "Failed to read interface type") ;

   139 	 	INFO_PRINTF1(Kerr) ;

   140 		close(sockfd);

   141 	 	return KErrGeneral ;

   142 		}

   143 

   144 	operation = Iface; 

   145 	if (operation == 2)

   146 		{

   147 		ret = ioctl(sockfd,SIOCGIFACTIVECONF, &ifc);

   148 		}

   149 	else if (operation == 1)

   150 		{

   151 		ret = ioctl(sockfd,SIOCGIFCONF, &ifc);

   152 		}

   153 		

   154 	close:

   155 		close(sockfd);

   156 		free(ifc.ifc_buf);

   157 		return ret;

   158 	}

   159 	

   160 	

   161 TInt CTestIfioctls::CreateManyActiveInterfaces(  )

   162 	{

   163 	ifreq ifr;

   164 	TInt sockfdArry[100];

   165 	TInt sockfdCnt;

   166 	TInt ret = KErrNone;

   167 	TInt index;	

   168 	ifconf ifc;	

   169 	TInt sockfd;

   170 	

   171 	// Name of the interface

   172 	TPtrC String;

   173 	_LIT( KString, "String" );

   174     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   175 	if(!res)  

   176 		{

   177      	_LIT(Kerr , "Failed to read interface name") ;

   178      	INFO_PRINTF1(Kerr) ;

   179      	return KErrGeneral ;

   180 		}

   181     TBuf8<256> asciiBuffer;

   182 	asciiBuffer.Copy(String);

   183 	TInt len = asciiBuffer.Length();

   184 	

   185 	Mem::Copy(ifr.ifr_name, asciiBuffer.Ptr(), len);

   186 	ifr.ifr_name[len] = 0;

   187 

   188 	StripStar(ifr.ifr_name);

   189 

   190 	// Number of interafces

   191 	TInt No;

   192 	_LIT( KNo, "No" );

   193 	res = GetIntFromConfig(ConfigSection(), KNo, No);

   194 

   195 	sockfdCnt = No;	

   196 	

   197 	for (index = 0; index < sockfdCnt; index++)

   198 		{

   199 		sockfdArry[index] = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);	

   200     	if (sockfdArry[index] < 0)

   201         	{

   202         	ret = KErrSocket;

   203         	goto close;

   204         	}

   205 		ret = ioctl(sockfdArry[index],SIOCSIFNAME, &ifr);

   206 		if (ret != KErrNone)

   207 			{

   208 			ret = KErrIoctl;

   209 			goto close;

   210 			}

   211 		ret = ioctl(sockfdArry[index], SIOCIFSTART , &ifr);

   212 		if (ret != KErrNone)

   213 			{

   214 			goto close;

   215 			}

   216 		}

   217 	ifc.ifc_buf = NULL;

   218 	sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);	

   219     if (sockfd < 0)

   220        	{

   221        	ret = KErrSocket;

   222        	goto close;

   223        	}

   224 	ret = ioctl(sockfd,SIOCGIFACTIVECONF, &ifc);

   225 

   226 close:

   227 	for (index = 0; index < sockfdCnt; index++)

   228 		{

   229 		ioctl(sockfdArry[index], SIOCIFSTOP, &ifr);

   230 		close(sockfdArry[index]);

   231 		}

   232 	return ret;

   233 	}

   234 	

   235 	

   236 TInt CTestIfioctls::ChooseInterface()

   237 	{

   238 	ifreq ifr;

   239 	TInt sockfd;

   240 	TInt ret = KErrNone;	

   241 	// Name of the interface

   242 	TPtrC String;

   243 	_LIT( KString, "String" );

   244     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   245 	if(!res)  

   246 		{

   247      	_LIT(Kerr , "Failed to read interface name") ;

   248      	INFO_PRINTF1(Kerr) ;

   249      	return KErrGeneral ;

   250 		}

   251     TBuf8<256> asciiBuffer;

   252 	asciiBuffer.Copy(String);

   253 

   254 	TInt len = asciiBuffer.Length();

   255 	Mem::Copy(ifr.ifr_name, asciiBuffer.Ptr(), len);

   256 	ifr.ifr_name[len] = 0;

   257 	StripStar(ifr.ifr_name);

   258 	

   259 	sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);	

   260     if (sockfd < 0)

   261         {

   262         ret = KErrSocket;

   263         close(sockfd);

   264 		return ret;

   265         }

   266 	ret = ioctl(sockfd,SIOCSIFNAME, &ifr);

   267 	if (ret != KErrNone)

   268 		{

   269 		ret = KErrIoctl;

   270 		close(sockfd);

   271 		return ret;

   272 		}

   273 	ret = ioctl(sockfd, SIOCIFSTART , &ifr);

   274 	if (ret != KErrNone)

   275 		{

   276 		close(sockfd);

   277 		return ret;

   278 		}

   279 	

   280 	ret = ioctl(sockfd, SIOCIFSTOP, &ifr);

   281 	return ret;		

   282 	}

   283 		

   284 	

   285 TInt CTestIfioctls::ChooseActiveInterface(  )

   286 	{

   287 	ifreq ifr;

   288 	TInt sockfd1=0, sockfd2=0;

   289 	TInt ret = KErrNone;

   290 	// Name of the interface

   291 	TPtrC String;

   292 	_LIT( KString, "String" );

   293     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   294 	if(!res)  

   295     	{

   296      	_LIT(Kerr , "Failed to read interface name") ;

   297      	INFO_PRINTF1(Kerr) ;

   298      	return KErrGeneral ;

   299     	}

   300 	TBuf8<256> asciiBuffer;

   301 	asciiBuffer.Copy(String);

   302 

   303 	TInt len = asciiBuffer.Length();

   304 	Mem::Copy(ifr.ifr_name, asciiBuffer.Ptr(), len);

   305 	ifr.ifr_name[len] = 0;

   306 	StripStar(ifr.ifr_name);

   307 	

   308 	sockfd1 = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);

   309     if (sockfd1 < 0)

   310         {

   311         ret = KErrSocket;

   312         ioctl(sockfd1, SIOCIFSTOP, &ifr);

   313 		close(sockfd1);

   314 		return ret;

   315         }

   316 	ret = ioctl(sockfd1,SIOCSIFNAME, &ifr);

   317 	if (ret != KErrNone)

   318 		{

   319 		ret = KErrIoctl;

   320 		ioctl(sockfd1, SIOCIFSTOP, &ifr);

   321 		close(sockfd1);

   322 		return ret;

   323 		}

   324 	ret = ioctl(sockfd1, SIOCIFSTART , &ifr);

   325 	if (ret != KErrNone)

   326 		{

   327 		ioctl(sockfd1, SIOCIFSTOP, &ifr);

   328 		close(sockfd1);

   329 		return ret;

   330 		}

   331 		

   332 	sockfd2 = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);

   333     if (sockfd2 < 0)

   334         {

   335         ret = KErrSocket;

   336         ioctl(sockfd2, SIOCIFSTOP, &ifr);

   337 		ioctl(sockfd1, SIOCIFSTOP, &ifr);

   338 		close(sockfd1);

   339 		return ret;

   340         }

   341 	ret = ioctl(sockfd2,SIOCSIFNAME, &ifr);

   342 	if (ret != KErrNone)

   343 		{

   344 		ret = KErrIoctl;

   345 		ioctl(sockfd2, SIOCIFSTOP, &ifr);

   346 		ioctl(sockfd1, SIOCIFSTOP, &ifr);

   347 		close(sockfd1);

   348 		return ret;

   349 		}

   350 	ret = ioctl(sockfd2, SIOCIFACTIVESTART , &ifr);

   351 	if (ret != KErrNone)

   352 		{

   353 		ioctl(sockfd2, SIOCIFSTOP, &ifr);

   354 		ioctl(sockfd1, SIOCIFSTOP, &ifr);

   355 		close(sockfd1);

   356 		return ret;

   357 		}

   358 	return ret;

   359 	}

   360 	

   361 TInt CTestIfioctls::TestIfNameIndex()

   362 	{

   363 	TInt ret = KErrNone;

   364 	struct if_nameindex *ifname;

   365 	ifname = if_nameindex();

   366 	if_freenameindex(ifname);

   367 	return ret;

   368 	}	

   369 	

   370 TInt CTestIfioctls::TestIfIndexToName(  )

   371 	{

   372 	TInt ret = KErrNone;

   373 	char ifName[255];	

   374 	

   375 	TInt IfIndex;

   376 	_LIT( KIfIndex, "IfIndex" );

   377 	TBool res = GetIntFromConfig(ConfigSection(), KIfIndex, IfIndex);

   378 	if(!res)

   379 		{

   380 	 	_LIT(Kerr , "Failed to read interface index from ini file.") ;

   381 	 	INFO_PRINTF1(Kerr) ;

   382 	 	return KErrGeneral ;

   383 		}

   384 

   385 	if_indextoname(IfIndex, ifName);

   386 	

   387 	return ret;

   388 	}	

   389 

   390 TInt CTestIfioctls::TestIfNameToIndex(  )

   391 	{

   392 	TInt ret = KErrNone;

   393 	char IfName[30];

   394 	TPtrC String;

   395 	_LIT( KString, "String" );

   396     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   397     if(!res)  

   398 		{

   399      	_LIT(Kerr , "Failed to read interface name from ini file.") ;

   400      	INFO_PRINTF1(Kerr) ;

   401      	return KErrGeneral ;

   402 		}

   403 	TBuf8<256> asciiBuffer;

   404 	asciiBuffer.Copy(String);

   405 

   406 	TInt len = asciiBuffer.Length();

   407 	Mem::Copy(IfName, asciiBuffer.Ptr(), len);

   408 	IfName[len] = 0;	

   409 	StripStar(IfName);

   410 	if_nametoindex(IfName);

   411 	

   412 	return ret;

   413 	}

   414 	

   415 

   416 TInt CTestIfioctls::TestSiocGIfIndex(  )

   417 	{

   418 	TInt ret = KErrNone;

   419 	

   420 	struct ifreq ifr;

   421 	int sockfd;

   422 	

   423 	TPtrC String;

   424 	_LIT( KString, "String" );

   425     TBool res = GetStringFromConfig(ConfigSection(), KString, String );

   426     if(!res)  

   427 		{

   428      	_LIT(Kerr , "Failed to read interface name from ini file.") ;

   429      	INFO_PRINTF1(Kerr) ;

   430      	return KErrGeneral ;

   431 		}

   432 	TBuf8<256> asciiBuffer;

   433 	 asciiBuffer.Copy(String);

   434 

   435 	TInt len = asciiBuffer.Length();

   436 	Mem::Copy(ifr.ifr_name, asciiBuffer.Ptr(), len);

   437 	ifr.ifr_name[len] = 0;

   438 	StripStar(ifr.ifr_name);

   439 	sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);	

   440 	*(ifr.ifr_name + sizeof(ifr.ifr_name) - 1 ) = '\0';

   441 	if (ioctl(sockfd, SIOCGIFINDEX, &ifr) != -1)

   442 		{

   443 		ret = KErrIoctl;

   444 		}

   445 		

   446 	close(sockfd);

   447 	return ret;

   448 	}

   449 

   450 

   451 TInt CTestIfioctls::ConnectToIpUsingConnection(  )

   452 	{

   453 	ifreq ifr;

   454 	TInt sockfd;

   455 	TInt ret = KErrNone;

   456 	struct sockaddr_in destAddr, selfAddr;	

   457 	TPtrC String = NULL ;

   458 	

   459 	// Name of the interface

   460 	TPtrC IfaceName;

   461 	_LIT( KIfaceName, "IfaceName" );

   462     TBool res = GetStringFromConfig(ConfigSection(), KIfaceName, IfaceName);

   463     if(!res)  

   464 		{

   465      	_LIT(Kerr , "Failed to read interface name from ini file.") ;

   466      	INFO_PRINTF1(Kerr) ;

   467      	return KErrGeneral ;

   468 		}

   469 	TBuf8<256> asciiBuffer;

   470 	 asciiBuffer.Copy(IfaceName);

   471 

   472 	TInt len = asciiBuffer.Length();

   473 	Mem::Copy(ifr.ifr_name, asciiBuffer.Ptr(), len);

   474 	ifr.ifr_name[len] = 0;

   475 	StripStar(ifr.ifr_name);

   476 	

   477 	sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);	

   478     if (sockfd < 0)

   479         {

   480         ret = KErrSocket;

   481         goto close;

   482         }

   483 	ret = ioctl(sockfd,SIOCSIFNAME, &ifr);

   484 	if (ret != KErrNone)

   485 		{

   486 		ret = KErrIoctl;

   487 		goto close;

   488 		}

   489 	ret = ioctl(sockfd, SIOCIFSTART , &ifr);

   490 	if (ret != KErrNone)

   491 		{

   492 		goto close;

   493 		}

   494 	

   495 	selfAddr.sin_family = AF_INET;

   496 	selfAddr.sin_addr.s_addr = INADDR_ANY;

   497 	selfAddr.sin_port = htons(KTestPort);	/* echo */

   498 	

   499 	ret = bind(sockfd,(struct sockaddr*)&selfAddr, sizeof(selfAddr));

   500 	if (ret != KErrNone)

   501 		{

   502 		ret = KErrBind;

   503 		goto close;

   504 		}

   505 	

   506 	destAddr.sin_family = AF_INET;

   507 	

   508 	char ipaddr[20];

   509 	

   510 	_LIT( KString, "String" );

   511     res = GetStringFromConfig(ConfigSection(), KString, String );

   512     if(!res)  

   513 		{

   514      	_LIT(Kerr , "Failed to read interface name from ini file.") ;

   515      	INFO_PRINTF1(Kerr) ;

   516      	return KErrGeneral ;

   517 		}

   518 	asciiBuffer.Copy(String);

   519 

   520 	len = asciiBuffer.Length();

   521 	Mem::Copy(ipaddr, asciiBuffer.Ptr(), len);

   522 	ipaddr[len] = 0;

   523 	

   524 	destAddr.sin_addr.s_addr = inet_addr(ipaddr);

   525 	destAddr.sin_port = htons(KTestPort);	/* http */

   526 	ret = connect(sockfd, (struct sockaddr*)&destAddr, sizeof(destAddr));

   527 	if (ret != KErrNone)

   528 		{

   529 		ret = KErrConnect;

   530 		goto close;

   531 		}

   532 

   533 	close:

   534 	ioctl(sockfd, SIOCIFSTOP, &ifr);

   535 	close(sockfd);

   536 	return ret;

   537 	}

   538 	

   539 

   540 TInt CTestIfioctls::SendtoIpUsingConnection(  )

   541 	{

   542 	ifreq ifr;

   543 	TInt sockfd;

   544 	TInt ret = KErrNone;

   545 	struct sockaddr_in destAddr, selfAddr;		

   546 	

   547 	char message[] = "Hello How Are You";

   548 	TInt length;

   549 	TInt size;

   550 	TPtrC String = NULL;

   551 	

   552 	// Name of the interface

   553 	TPtrC IfaceName;

   554 	_LIT( KIfaceName, "IfaceName" );

   555     TBool res = GetStringFromConfig(ConfigSection(), KIfaceName, IfaceName);

   556     if(!res)  

   557 		{

   558      	_LIT(Kerr , "Failed to read interface name from ini file.") ;

   559      	INFO_PRINTF1(Kerr) ;

   560      	return KErrGeneral ;

   561 		}

   562 	TBuf8<256> asciiBuffer;

   563 	asciiBuffer.Copy(IfaceName);

   564 

   565 	TInt len = asciiBuffer.Length();

   566 	Mem::Copy(ifr.ifr_name, asciiBuffer.Ptr(), len);

   567 	ifr.ifr_name[len] = 0;

   568 	StripStar(ifr.ifr_name);

   569 	

   570 	sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);	

   571     if (sockfd < 0)

   572         {

   573         ret = KErrSocket;

   574         goto close;

   575         }

   576 	ret = ioctl(sockfd,SIOCSIFNAME, &ifr);

   577 	if (ret != KErrNone)

   578 		{

   579 		ret = KErrIoctl;

   580 		goto close;

   581 		}

   582 	ret = ioctl(sockfd, SIOCIFSTART , &ifr);

   583 	if (ret != KErrNone)

   584 		{

   585 		goto close;

   586 		}

   587 	selfAddr.sin_family = AF_INET;

   588 	selfAddr.sin_addr.s_addr = INADDR_ANY;

   589 	selfAddr.sin_port = htons(KTestPort);	/* echo */

   590 	

   591 	ret = bind(sockfd,(struct sockaddr*)&selfAddr, sizeof(selfAddr));

   592 	if (ret != KErrNone)

   593 		{

   594 		ret = KErrBind;

   595 		goto close;

   596 		}

   597 	

   598 	length = strlen(message);

   599 	destAddr.sin_family = AF_INET;

   600 	

   601 	char ipaddr[20];

   602 	

   603 	_LIT( KString, "String" );

   604     res = GetStringFromConfig(ConfigSection(), KString, String );

   605     if(!res)  

   606 		{

   607      	_LIT(Kerr , "Failed to read interface name from ini file.") ;

   608      	INFO_PRINTF1(Kerr) ;

   609 		close(sockfd);

   610      	return KErrGeneral ;

   611 		}

   612 	asciiBuffer.Copy(String);

   613 

   614 	len = asciiBuffer.Length();

   615 	Mem::Copy(ipaddr,asciiBuffer.Ptr(), len);

   616 	ipaddr[len] = 0;

   617 	

   618 	destAddr.sin_addr.s_addr = inet_addr(ipaddr);

   619 	destAddr.sin_port = htons(KTestPort);	/* http */

   620 	size = sizeof(destAddr);

   621 	ret = sendto(sockfd, message, length, 0, (struct sockaddr*)&destAddr, size);

   622 	if (ret == -1)

   623 		{

   624 		ret = KErrSendto;

   625 		goto close;

   626 		}

   627 	if (ret >= 0)

   628 		{

   629 		ret = 0;

   630 		}

   631 

   632 	close:

   633 	ioctl(sockfd, SIOCIFSTOP, &ifr);

   634 	close(sockfd);

   635 	return ret;

   636 	}

   637 

   638 void StripStar(char *aString)

   639 {

   640 	TInt len = strlen(aString);

   641 	TInt index;

   642 	

   643 	for (index = 0; index < len; index++)

   644 		{

   645 		if ( aString[index] == '*' )

   646 			{

   647 			aString[index] = ' ';

   648 			}

   649 		}

   650 }

   651 

   652 

   653 TInt CTestIfioctls::ConnectToUrlUsingConnection()

   654 	{

   655 	ifreq ifr;

   656 	TInt sockfd;

   657 	TInt ret = KErrNone;	

   658 	struct sockaddr_in destAddr, selfAddr;	

   659 	struct in_addr *addrp;

   660 	

   661 	TPtrC accessPointName,url;

   662 	_LIT( KParameter1, "Parameter1" );

   663     TBool res = GetStringFromConfig(ConfigSection(), KParameter1, accessPointName );

   664     

   665     _LIT( KParameter2, "Parameter2" );

   666     res = GetStringFromConfig(ConfigSection(), KParameter2, url );

   667     

   668 	

   669 	// Name of the interface

   670 	TBuf8<256> asciiBuffer;

   671 	asciiBuffer.Copy(accessPointName);

   672 

   673 	TInt len = asciiBuffer.Length();

   674 	Mem::Copy(ifr.ifr_name, asciiBuffer.Ptr(), len);

   675 	ifr.ifr_name[len] = 0;

   676 	

   677 	StripStar(ifr.ifr_name);

   678 	

   679 	struct hostent *hp = 0;

   680 	

   681 	sockfd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);	

   682     if (sockfd < 0)

   683         {

   684         ret = KErrSocket;

   685         goto close;

   686         }

   687 	ret = ioctl(sockfd,SIOCSIFNAME, &ifr);

   688 	if (ret != KErrNone)

   689 		{

   690 		ret = KErrIoctl;

   691 		goto close;

   692 		}

   693 	ret = ioctl(sockfd, SIOCIFSTART , &ifr);

   694 	if (ret != KErrNone)

   695 		{

   696 		goto close;

   697 		}

   698 	

   699 	

   700 	char urlBuf[25];

   701 	asciiBuffer.Copy(url);

   702 

   703 	len = asciiBuffer.Length();

   704 	Mem::Copy((void *)urlBuf, asciiBuffer.Ptr(), len);

   705 	urlBuf[len] = 0;

   706 	hp = gethostbyname((const char*) urlBuf );

   707 	if (hp != NULL)

   708 		{

   709 		addrp = (struct in_addr*)(hp->h_addr_list[0]);

   710 		}

   711 	else

   712 		{

   713 		ret = 0;

   714 		goto close;

   715 		}

   716 	

   717 	selfAddr.sin_family = AF_INET;

   718 	selfAddr.sin_addr.s_addr = INADDR_ANY;

   719 	selfAddr.sin_port = htons(KTestPort);	/* echo */

   720 	

   721 	ret = bind(sockfd,(struct sockaddr*)&selfAddr, sizeof(selfAddr));

   722 	if (ret != KErrNone)

   723 		{

   724 		ret = KErrBind;

   725 		goto close;

   726 		}

   727 	

   728 	destAddr.sin_family = AF_INET;

   729 	destAddr.sin_addr = *addrp;

   730 	destAddr.sin_port = htons(KTestPort);	/* http */

   731 	ret = connect(sockfd, (struct sockaddr*)&destAddr, sizeof(destAddr));

   732 	if (ret != KErrNone)

   733 		{

   734 		ret = KErrConnect;

   735 		goto close;

   736 		}

   737 

   738 	close:

   739 	ioctl(sockfd, SIOCIFSTOP, &ifr);

   740 	close(sockfd);

   741 	return ret;

   742 	}

   743 

   744 /*ioctl test for coverage*/

   745 TInt CTestIfioctls::ioctltest()

   746 	{

   747 	int fd1 = 0;

   748 	int ret = 0;

   749 	int fperm = O_RDWR;

   750 	fd1 = open("CON:", fperm);

   751 	if (fd1 < 0)

   752 		{

   753 		_LIT( Kinfo1, "error in open()" );

   754 		INFO_PRINTF1(Kinfo1);

   755 		return fd1;

   756 		}

   757 	ret = ioctl(fd1, IOC_OUT);

   758 	if (ret < 0)

   759 		{

   760 		_LIT( Kinfo1, "error in ioctl()" );

   761 		INFO_PRINTF1(Kinfo1);

   762 		INFO_PRINTF2(_L("errno = %d"), errno);

   763 		if (errno == ENOSYS)

   764 			{

   765 			_LIT( Kinfo1, "ioctl_completion() not supported on tty console");

   766 			INFO_PRINTF1(Kinfo1);

   767 			return KErrNone;

   768 			}

   769 		return ret;

   770 		}

   771 		

   772 	return KErrNone;

   773 	}

   774 	

   775 	

   776 /*read test for coverage 

   777 //this is supposed to be a manual test

   778 //This is beacuse we cannot automate key pressing characters

   779 //to the console*/

   780 TInt CTestIfioctls::readtest()

   781 	{

   782 	int fd1 = 0;

   783 	int ret = 0;

   784 	int fperm = O_RDONLY;

   785 	char buffer1[9] = "open iam";

   786 	fd1 = open("CON:", fperm);

   787 	if (fd1 < 0)

   788 		{

   789 		_LIT( Kinfo1, "error in open()" );

   790 		INFO_PRINTF1(Kinfo1);

   791 		return fd1;

   792 		}

   793 	ret = read(fd1, &buffer1, 4);

   794 	if (ret < 0)

   795 		{

   796 		close(fd1);

   797 		_LIT( Kinfo2, "error in read()" );

   798 		INFO_PRINTF1(Kinfo2);

   799 		return ret;

   800 		}	

   801 	close(fd1);

   802 	return KErrNone;

   803 	}

   804 

   805 // Util function

   806 void GetIpFromDHCPServer(void)

   807     {

   808     RSocketServ rSockServer;

   809     if(KErrNone==rSockServer.Connect())

   810         {

   811         RConnection rConnect;

   812         if(KErrNone==rConnect.Open(rSockServer))

   813             {

   814             TRequestStatus status; 

   815             rConnect.Start(status);

   816                 

   817             User::WaitForRequest(status); 

   818             }

   819         } 

   820     }

   821 

   822 // Util function

   823 TInt GetIfrName(char* ifrname, int size)

   824     {

   825     char* tInfr = 0;

   826     TBuf8<KMaxName> ifbuf;

   827     

   828 	GetIpFromDHCPServer();

   829     TAutoClose<RSocketServ> ss;

   830     ss.iObj.Connect();

   831     

   832     TAutoClose<RSocket> sock;

   833     sock.iObj.Open(ss.iObj, _L("udp"));

   834     

   835     sock.iObj.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);

   836 

   837     TProtocolDesc in;

   838     sock.iObj.Info(in);

   839     

   840     TPckgBuf<TSoInetInterfaceInfo> info, next;

   841 

   842     TInt res=sock.iObj.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, info);

   843     if(res!=KErrNone)

   844        	return KErrGeneral;

   845     

   846         

   847     while(res==KErrNone)

   848         {

   849 		

   850         res=sock.iObj.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, next);

   851 	

   852 		if(info().iState != EIfUp || info().iFeatures&KIfIsLoopback || info().iName.Left(4) == _L("eth6")) 

   853 			{

   854 			info = next; continue;	

   855 			}

   856 		

   857 		ifbuf.Copy(info().iName);

   858 		tInfr = (char*) ifbuf.Ptr();

   859 		if( tInfr &&  (size > info().iName.Length()) )

   860 			{

   861 			tInfr[info().iName.Length()] = '\0';		

   862 			strcpy(ifrname, tInfr);

   863 			}

   864 			 

   865         TName address;

   866 	    info().iAddress.Output(address);

   867 	    

   868         info().iNetMask.Output(address);

   869                

   870         if(res==KErrNone)

   871             {

   872             info = next;

   873          	}

   874         }

   875 	return KErrNone;

   876     }

   877 

   878 /**

   879 * Function Name		: TestAddDelRoute

   880 * Description		: Add and delete a static route 

   881 * Return Value		: KErrNone

   882 */

   883 TInt CTestIfioctls::TestAddDelRoute()

   884 {

   885 	struct rtentry rt;

   886 	int ret=KErrNone;

   887 	int sockid;

   888 	char ifrname[25];

   889 	

   890 	memset (&ifrname,0,sizeof(ifrname));

   891 	memset (&rt,0,sizeof(struct rtentry));

   892 	sockid=socket ( AF_INET, SOCK_DGRAM, 0 );

   893 	

   894 	ret = GetIfrName(ifrname,  sizeof(ifrname));

   895 	if (ret == KErrGeneral)

   896 		{

   897 		INFO_PRINTF1(_L("GetOpt fails"));

   898 		return KErrGeneral;

   899 		}

   900 	

   901 	if (!ifrname || ifrname[0] == '\0') 

   902 		{

   903         INFO_PRINTF1(_L("invalid ifrname"));

   904     	return KErrGeneral;

   905     	}

   906     

   907 	rt.rt_dev=ifrname;

   908 	memset( &rt.rt_dst, 0, sizeof( struct sockaddr_in ) );

   909 	((struct sockaddr_in * )&rt.rt_dst)->sin_family = AF_INET;

   910 	((struct sockaddr_in * )&rt.rt_dst)->sin_addr.s_addr=inet_addr("225.0.0.0");

   911     ((struct sockaddr_in * )&rt.rt_dst)->sin_port = htons( 6000 );	

   912 

   913 	memset( &rt.rt_gateway, 0, sizeof( struct sockaddr_in ) );

   914 	((struct sockaddr_in * )&rt.rt_gateway)->sin_family = AF_INET;	

   915 	((struct sockaddr_in * )&rt.rt_gateway)->sin_addr.s_addr=inet_addr("169.254.39.111");

   916 	((struct sockaddr_in * )&rt.rt_gateway)->sin_port = htons( 6000 );	

   917 

   918 	memset( &rt.rt_genmask, 0, sizeof( struct sockaddr_in ) );

   919 	((struct sockaddr_in * )&rt.rt_genmask)->sin_family = AF_INET;	

   920 	((struct sockaddr_in * )&rt.rt_genmask)->sin_addr.s_addr=inet_addr("255.255.0.0");

   921     ((struct sockaddr_in * )&rt.rt_genmask)->sin_port = htons( 6000 );	

   922     	

   923 	ret=ioctl(sockid, SIOCADDRT, &rt);

   924 	if(ret == 0)

   925 		{

   926 		ret=ioctl(sockid, SIOCDELRT, &rt);	

   927 		if(ret<0)

   928 			{

   929 			INFO_PRINTF2(_L("ioctl() -SIOCDELRT failed: %d\n"), errno);

   930 			ret = KErrGeneral;	

   931 			}

   932 		}

   933 	else

   934 		{

   935 		INFO_PRINTF2(_L("ioctl() -SIOCADDRT failed: %d\n"), errno);

   936 		ret = KErrGeneral;

   937 		}	

   938 	

   939 	close(sockid);

   940 	return ret;	

   941 }

   942 

   943 /**

   944 * Function Name		: TestAddDelRouteNegative1

   945 * Description		: Pass NULL for interface name

   946 * Return Value		: KErrNotFound by ioctl() and KErrNone by the test case

   947 */

   948 TInt CTestIfioctls::TestAddDelRouteNegative1()

   949 	{

   950 	struct rtentry rt;

   951 	int ret=KErrNone;

   952 	int sockid;

   953 		

   954 	memset (&rt,0,sizeof(struct rtentry));

   955 	sockid=socket ( AF_INET, SOCK_DGRAM, 0 );

   956 	

   957 	rt.rt_dev=NULL;

   958 	

   959 	memset( &rt.rt_dst, 0, sizeof( struct sockaddr_in ) );

   960 	((struct sockaddr_in * )&rt.rt_dst)->sin_family = AF_INET;

   961 	((struct sockaddr_in * )&rt.rt_dst)->sin_addr.s_addr=inet_addr("");

   962     ((struct sockaddr_in * )&rt.rt_dst)->sin_port = htons( 0 );	

   963 

   964 	memset( &rt.rt_gateway, 0, sizeof( struct sockaddr_in ) );

   965 	((struct sockaddr_in * )&rt.rt_gateway)->sin_family = AF_INET;	

   966 	((struct sockaddr_in * )&rt.rt_gateway)->sin_addr.s_addr=inet_addr("");

   967 	((struct sockaddr_in * )&rt.rt_gateway)->sin_port = htons( 0 );	

   968 

   969 	memset( &rt.rt_genmask, 0, sizeof( struct sockaddr_in ) );

   970 	((struct sockaddr_in * )&rt.rt_genmask)->sin_family = AF_INET;	

   971 	((struct sockaddr_in * )&rt.rt_genmask)->sin_addr.s_addr=inet_addr("");

   972     ((struct sockaddr_in * )&rt.rt_genmask)->sin_port = htons( 0 );	

   973     	

   974 	ret=ioctl(sockid, SIOCADDRT, &rt);

   975 	if(ret == KErrNotFound)

   976 		{

   977 		ret = KErrNone;

   978 		}

   979 	else

   980 		{

   981 		INFO_PRINTF2(_L("ioctl() - SIOCADDRT failed: %d\n"), errno);

   982 		ret = KErrGeneral;

   983 		}	

   984 	

   985 	close(sockid);

   986 	return ret;	

   987 	}

   988 

   989 

   990 /**

   991 * Function Name		: TestAddDelRouteNegative2

   992 * Description		: Pass invalid name for interface

   993 * Return Value		: KErrNotFound by ioctl() and KErrNone by the test case

   994 */

   995 TInt CTestIfioctls::TestAddDelRouteNegative2()

   996 	{

   997 	struct rtentry rt;

   998 	int ret=KErrNone;

   999 	int sockid;

  1000 	char ifrname[25]="eth[0x000000]";	

  1001 	memset (&rt,0,sizeof(struct rtentry));

  1002 	sockid=socket ( AF_INET, SOCK_DGRAM, 0 );

  1003 	

  1004 	

  1005 	rt.rt_dev=ifrname;

  1006 	

  1007 	memset( &rt.rt_dst, 0, sizeof( struct sockaddr_in ) );

  1008 	((struct sockaddr_in * )&rt.rt_dst)->sin_family = AF_INET;

  1009 	((struct sockaddr_in * )&rt.rt_dst)->sin_addr.s_addr=inet_addr("");

  1010     ((struct sockaddr_in * )&rt.rt_dst)->sin_port = htons( 0 );	

  1011 

  1012 	memset( &rt.rt_gateway, 0, sizeof( struct sockaddr_in ) );

  1013 	((struct sockaddr_in * )&rt.rt_gateway)->sin_family = AF_INET;	

  1014 	((struct sockaddr_in * )&rt.rt_gateway)->sin_addr.s_addr=inet_addr("");

  1015 	((struct sockaddr_in * )&rt.rt_gateway)->sin_port = htons( 0 );	

  1016 

  1017 	memset( &rt.rt_genmask, 0, sizeof( struct sockaddr_in ) );

  1018 	((struct sockaddr_in * )&rt.rt_genmask)->sin_family = AF_INET;	

  1019 	((struct sockaddr_in * )&rt.rt_genmask)->sin_addr.s_addr=inet_addr("");

  1020     ((struct sockaddr_in * )&rt.rt_genmask)->sin_port = htons( 0 );	

  1021     	

  1022 	ret=ioctl(sockid, SIOCADDRT, &rt);

  1023 	if(ret == KErrNotFound)

  1024 		{

  1025 		INFO_PRINTF1(_L("ioctl() - SIOCADDRT failed with expected error value"));

  1026 		ret = KErrNone;

  1027 		}

  1028 	else

  1029 		{

  1030 		INFO_PRINTF2(_L("ioctl() - SIOCADDRT failed: %d\n"), errno);

  1031 		ret = KErrGeneral;

  1032 		}	

  1033 	

  1034 	close(sockid);

  1035 	return ret;	

  1036 	}

  1037 

  1038 /**

  1039 * Function Name		: TestMacAddress

  1040 * Description		: Gets the MAC address of the device

  1041 * Return Value		: KErrNone

  1042 */	

  1043 TInt CTestIfioctls::TestMacAddress()

  1044 {

  1045     int sd, ret=KErrNone;

  1046     struct ifreq ifr;

  1047     unsigned char *a;

  1048 	char ifrname[25];

  1049 	

  1050 	memset (&ifrname,0,sizeof(ifrname));	

  1051 	ret = GetIfrName(ifrname,  sizeof(ifrname));

  1052 	if (ret == KErrGeneral)

  1053 		{

  1054 		INFO_PRINTF1(_L("GetOpt fails"));

  1055 		return KErrGeneral;

  1056 		}

  1057 	

  1058     if (!ifrname || ifrname[0] == '\0') 

  1059     	{

  1060         INFO_PRINTF1(_L("invalid ifrname"));

  1061         return KErrGeneral;

  1062         }

  1063     

  1064     memset(&ifr, 0, sizeof(ifr));

  1065         

  1066     sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);

  1067 

  1068     strncpy(&ifr.ifr_name[0], ifrname, strlen(ifrname));

  1069     

  1070     if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0) 

  1071     	{

  1072         INFO_PRINTF2(_L("ioctl() -SIOCGIFHWADDR failed: %d\n"), errno);

  1073     	ret = KErrGeneral;

  1074     	}

  1075     

  1076     a = (unsigned char *) &ifr.ifr_hwaddr.sa_data;

  1077     INFO_PRINTF7(_L("%02x:%02x:%02x:%02x:%02x:%02x"), a[0],a[1],a[2],a[3],a[4],a[5]);

  1078     

  1079     return ret;	

  1080 }

  1081 

  1082 //Util function

  1083 void CTestIfioctls::ReadStringParam(char* aString)

  1084 	{

  1085 	_LIT( KSl, "Param%d" );

  1086    	TBuf<8> pNameBuf;

  1087     TPtrC string;

  1088     pNameBuf.Format(KSl,++iParamCount);

  1089 	TBool res = GetStringFromConfig(ConfigSection(), pNameBuf, string);

  1090 	if(!res)

  1091 	 	{

  1092 	 	_LIT(Kerr , "Unable to retrieve string parameter") ;

  1093 	 	INFO_PRINTF1(Kerr);

  1094 	  	}

  1095 	TBuf8<256> bufstring;

  1096 	bufstring.Copy(string);

  1097 	TInt paramLength=string.Length();

  1098 	char* text=(char *)(bufstring.Ptr());

  1099  	*(text+paramLength)='\0';

  1100 	strcpy(aString,text);

  1101 	return;

  1102 	}

  1103 

  1104 

  1105 /**

  1106 * Function Name		: TestMacAddressNegative1

  1107 * Description		: Pass the wrong interface name for ioctl()

  1108 * Return Value		: 

  1109 */	

  1110 TInt CTestIfioctls::TestMacAddressNegative1()

  1111 	{

  1112 	int sd, ret=KErrNone;

  1113     struct ifreq ifr;

  1114 	char ifrname[25];

  1115 	

  1116 	ReadStringParam(ifrname);

  1117     	

  1118 	memset(&ifr, 0, sizeof(ifr));

  1119         

  1120     sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);

  1121     

  1122     if(sd < 0)

  1123     	{

  1124     	INFO_PRINTF2(_L("socket open failed with errno: %d"), errno);

  1125     	return KErrGeneral;

  1126     	}

  1127 

  1128     strncpy(&ifr.ifr_name[0], ifrname, strlen(ifrname));

  1129     

  1130           

  1131     if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0 && errno == ENODEV) 

  1132        	{

  1133         INFO_PRINTF2(_L("ioctl()-SIOCGIFHWADDR returns expected error value %d"), errno);

  1134     	ret = KErrNone;