1 /*

     2 * Copyright (c) 1997-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 <sys/types.h>

    20 #include <string.h>		// for memcpy

    21 #include <fcntl.h>		// for struct stat

    22 #include <sys/errno.h>		// for ENOTSOCK

    23 #include <sys/socket.h>

    24 #include <sys/ioctl.h>

    25 #include <sys/stat.h>

    26 #include <netinet/in.h>		// for htons

    27 #include <sys/sockio.h>

    28 #include <bt_sock.h>     // Symbian BT constantss needed for cooperation with Symbian sockets

    29 #include <arpa/inet.h>   

    30 #include <es_sock.h>

    31 #include <in_sock.h>

    32 #include <net/if.h>

    33 #include <commdb.h>

    34 #include <cdbcols.h>

    35 #include <commdbconnpref.h>

    36 #include <e32base.h>

    37 #include <e32err.h>

    38 #include <utf.h>

    39 #include <e32std.h>

    40 #include <net/route.h>

    41 #include <in_iface.h>

    42 #include "fdesc.h"

    43 #include "lposix.h"

    44 #include "sysif.h"

    45 

    46 // Support for struct sockaddr conversion

    47 TUSockAddr::TUSockAddr (TAny* aBuf) 

    48 : TSockAddr(), iError(0)

    49 		{

    50 		Prepare(aBuf);

    51 		}

    52 

    53 void TUSockAddr::Prepare (TAny* aBuf) 

    54 //

    55 // Prepare a TUSockAddr to receive an address (used in RecvFrom)

    56 // Setting the length to 0 indicates that we don't really want this address anyway.

    57 //

    58 	{

    59 	if (aBuf==0)

    60 		{

    61 		SetLength(0);

    62 		iError = EFAULT;

    63 		return;

    64 		}

    65 	}

    66 

    67 EXPORT_C TUSockAddr::TUSockAddr (const TAny* aBuf, TUint aLen) 

    68 : TSockAddr(), iError(0)

    69 		{

    70 		Set(aBuf,aLen);

    71 		}

    72 

    73 void TUSockAddr::Set (const TAny* aBuf, TUint aLen) 

    74 //

    75 // Construct an ESOCK TSockAddr from a struct sockaddr.

    76 // We have to deal with the network byte ordering of AF_INET addresses

    77 //

    78 	{

    79 	if (aBuf==0)

    80 		{

    81 		iError = EFAULT;

    82 		SetLength(0);

    83 		return;

    84 		}

    85 	

    86 	const TUint dataOffset = (TUint)&((struct sockaddr *)0)->sa_data[0];

    87 	// aLen should be atleast have minimum size.

    88 	if (aLen < dataOffset)

    89 		{

    90 		iError = EINVAL;

    91 		SetLength(0);

    92 		return;

    93 		}

    94 

    95 	const struct sockaddr* sp= (const struct sockaddr *)(aBuf);

    96 	TUint8 *from=(TUint8*)aBuf;	

    97 

    98 	if (sp->sa_family==AF_INET)

    99 		{		

   100 		// byte-swap sockaddr_in back into host ordering

   101 		TUint port=(from[2]<<8)+from[3];

   102 		from+=4;

   103 		TUint32 addr=(from[0]<<24)+(from[1]<<16)+(from[2]<<8)+from[3];

   104 		from+=4;

   105 		SetFamily(AF_INET);

   106 		SetPort(port);

   107 		*(TUint32*)UserPtr()=addr;

   108 		SetUserLen(4);

   109 		return;

   110 		}

   111 	else if (sp->sa_family == AF_INET6)

   112 		{

   113 		SetFamily(sp->sa_family);

   114 		SetPort(ByteOrder::Swap16(sp->sa_port));

   115 		from+=4;

   116 		// copy the rest of the data as given

   117 		TUint8 *to=UserPtr();

   118 		if (aLen<4)

   119 			aLen=4;

   120 		aLen-=4;	// skip fmaily and port

   121 		if (aLen>24)

   122 			aLen=24;

   123 		memcpy(to,from,aLen);

   124 		SetUserLen(aLen);    	

   125 		return;

   126 		}	

   127 	else if (sp->sa_family == KBTAddrFamily)

   128 		{

   129 		// Make a TBTSockAddr from a sockaddr_bt...

   130 		TBTSockAddr tmpAddr;

   131 

   132 		// Family is always Bluetooth:

   133 		tmpAddr.SetFamily(KBTAddrFamily);

   134 

   135 		// The port number has the correct byte order already, as the

   136 		// POSIX Bluetooth APIs assume litle-endian format:

   137 		tmpAddr.SetPort(sp->sa_port);

   138 

   139 		// For the address we need to reverse the byte ordering, as

   140 		// Symbian appears to index Bluetooth addresses in a

   141 		// big-endian manner:

   142 

   143 		const TInt KBTAddrLength = 6;  // Bytes in a Bluetooth address

   144 		const TInt KBTAddrOffset = 4;  // Offset of address in sockaddr_bt

   145 

   146 		TBTDevAddr devAddr;

   147 		const TInt KMinLength = KBTAddrLength + KBTAddrOffset;

   148 

   149 		if (aLen >= KMinLength)

   150 			{

   151 			for (TInt i=0; i<KBTAddrLength; ++i)

   152 				{

   153 				devAddr[i] = from[KMinLength - 1 - i];

   154 				}

   155 			}

   156 

   157 		tmpAddr.SetBTAddr(devAddr);

   158 

   159 		// Security settings:

   160 		TBTServiceSecurity sec;

   161 		sec.SetUid(TUid::Uid(0));

   162 		sec.SetAuthentication(EFalse);

   163 		sec.SetEncryption(EFalse);

   164 		sec.SetAuthorisation(EFalse);

   165 		sec.SetDenied(EFalse);

   166 		tmpAddr.SetSecurity(sec);

   167 

   168 		// Now we must copy the contents of the "tmpAddr" TBTSockAddr,

   169 		// but unfortunately there isn't an assignment operator for us

   170 		// to use. Still, we know it is a self-contained T class for

   171 		// which a direct shallow copy using memcopy() will be ok:

   172 		//

   173 		memcpy(this, &tmpAddr, sizeof(TBTSockAddr));

   174 

   175 		return;

   176 		}

   177 	else

   178 		{

   179 		// Not AF_INET or KBTAddrFamily:

   180 

   181 		// expand the family and port

   182 		SetFamily(sp->sa_family);

   183 		SetPort(sp->sa_port);

   184 		from+=4;

   185 		// copy the rest of the data as given

   186 		TUint8 *to=UserPtr();

   187 		if (aLen<4)

   188 			aLen=4;

   189 		aLen-=4;	// skip fmaily and port

   190 		if (aLen>24)

   191 			aLen=24;

   192 		memcpy(to,from,aLen);

   193 		SetUserLen(aLen);

   194 		}

   195 	}

   196 

   197 EXPORT_C void TUSockAddr::Get(TAny* addr, unsigned long* len)

   198 //

   199 // Extract a struct sockaddr from a TSockAddr

   200 //

   201 	{

   202 	if (addr==0)

   203 		{

   204 		iError = EFAULT;

   205 		SetLength(0);

   206 		return;

   207 		}

   208 	const TUint dataOffset = (TUint)&((struct sockaddr *)0)->sa_data[0];

   209 	// aLen should be atleast have minimum size.

   210 	if (*len < dataOffset)

   211 		{

   212 		iError = EINVAL;

   213 		SetLength(0);

   214 		return;

   215 		};

   216 

   217 	struct sockaddr* sp=(struct sockaddr*)addr;

   218 	TUint16 port=(TUint16)Port();

   219 

   220 	//The ipv4 address could be obtained either as

   221 	//plain 32 bit address or as ipv4 mapped ipv6 address

   222 	TInetAddr inetAddr(*this);

   223 	TBool isV4Mapped = (Family()==AF_INET6) && (inetAddr.IsV4Mapped() || inetAddr.IsV4Compat());

   224 	if (Family()==AF_INET || isV4Mapped)

   225 		{

   226 		sp->sa_family=AF_INET;

   227 		sp->sa_port= ByteOrder::Swap16(port);

   228 		TUint8* from=UserPtr();

   229 		TUint32 fromaddr;

   230 		//If the address is v4 mapped, we take the last 4 bytes from the 16 bytes long v6 structure. 

   231 		if(isV4Mapped)

   232 			fromaddr = (from[15]<<24)+(from[14]<<16)+(from[13]<<8)+from[12];

   233 		else

   234 			fromaddr = (from[0]<<24)+(from[1]<<16)+(from[2]<<8)+ from[3];

   235 		*(TUint32*)sp->sa_data=fromaddr;

   236 		*len=8;

   237 		return;

   238 		}

   239 	else if (Family()==AF_INET6)

   240 		{

   241 

   242 		sp->sa_family=(TUint16)Family();

   243 		sp->sa_port=ByteOrder::Swap16(port);

   244 		TUint ulen=GetUserLen();

   245 		if (ulen+4>(*len))

   246 			ulen=(*len)-4;

   247 		*len=ulen+4;

   248 		memcpy(sp->sa_data,UserPtr(),ulen);

   249 		sp->sa_len = ulen;

   250 		return;

   251 		}		

   252 	else if (Family()==KBTAddrFamily)

   253 		{

   254 		sp->sa_family=KBTAddrFamily;

   255 		sp->sa_port=port;

   256 

   257 		const TInt KBTAddrLength = 6;

   258 		if (GetUserLen() == KBTAddrLength)

   259 			{

   260 			for (TInt i=0; i<KBTAddrLength; ++i)

   261 				{

   262 				sp->sa_data[KBTAddrLength - 1 - i] = UserPtr()[i];

   263 				}

   264 			}

   265 		return;

   266 		}

   267 	else

   268 		{

   269 		// Not AF_INET or KBTAddrFamily:

   270 		sp->sa_family=(TUint16)Family();

   271 		sp->sa_port=port;

   272 		TUint ulen=GetUserLen();

   273 		if (ulen+4>(*len))

   274 			ulen=(*len)-4;

   275 		*len=ulen+4;

   276 		memcpy(sp->sa_data,UserPtr(),ulen);

   277 		}

   278 	}

   279 

   280 // The Socket descriptor class

   281 CSocketDesc::CSocketDesc()

   282 :iIoctlBuf(0,0),

   283 iSocketPtr(NULL),

   284 iConnPref(),

   285 iConnectionPtr(NULL),

   286 iSubConnectionPtr(NULL),

   287 iRConnectionIndex(-1),		

   288 iSockServPtr(NULL)

   289 		{

   290 

   291 		};

   292 

   293 

   294 TInt CSocketDesc::Socket(RSocketServ& aSs, int family, int style, int protocol)

   295 	{

   296 	if (protocol == 0)

   297 		{

   298 		if (family == AF_INET)

   299 			{

   300 			switch (style)

   301 				{

   302 				case SOCK_STREAM:

   303 					protocol = IPPROTO_TCP;

   304 					break;

   305 

   306 				case SOCK_DGRAM:

   307 					protocol = IPPROTO_UDP;

   308 					break;

   309 				}

   310 			}

   311 		else

   312 			{

   313 			protocol = KUndefinedProtocol;

   314 			}

   315 		}

   316 

   317 	iFcntlFlag = 0;

   318 	TInt err = CreateLock();

   319 	if (err)

   320 		{

   321 		return err;

   322 		}

   323 

   324 	if (family == AF_INET6)

   325 		{

   326 		err = iSocket.Open(aSs, KAfInet, style, protocol);

   327 		}

   328 	else

   329 		{

   330 		err = iSocket.Open(aSs, family, style, protocol);

   331 		}

   332 

   333 	if (err == KErrNone)

   334 		{

   335 		iStyle = style;

   336 		iSocket.Close(); // We will close now, to open later using connection preferences

   337 		iAddrFamily = family;

   338 		iProtocol = protocol; 

   339 		iSockServPtr = &aSs; // Saving the const session pointer for later use

   340 		}

   341 	return err;

   342 	}

   343 

   344 TInt CSocketDesc::FinalClose()

   345 	{

   346 	RHeap* oheap = User::SwitchHeap(Backend()->Heap());

   347 	if (iSocketPtr != NULL)

   348 		{

   349 		iSocketPtr = NULL;	

   350 		StopInterface(NULL); // Checks for RConnection as well as RSubConnection

   351 		}

   352 

   353 	CSockDescBase::FinalClose();

   354 	User::SwitchHeap(oheap);

   355 	return KErrNone;

   356 	}

   357 

   358 

   359 void CSocketDesc::Read (TDes8& aBuf, TRequestStatus& aStatus)

   360 	{

   361 	//Acquire the Lock before read and release it later

   362 	iReadLock.Wait();

   363 	if (iSocketPtr == NULL)

   364 		{

   365 		TInt ret = OpenUsingPreference();

   366 		if (ret != KErrNone)	// Error in open

   367 			{

   368 			Complete(aStatus,ret);

   369 			iReadLock.Signal();

   370 			return;

   371 			}

   372 		}

   373 	CSockDescBase::Read (aBuf,aStatus);

   374 	iReadLock.Signal();

   375 	}

   376 

   377 TInt CSocketDesc::ReadCompletion(TDes8& aBuf, TInt aStatus)

   378 	{

   379 	return CSockDescBase::ReadCompletion(aBuf, aStatus);

   380 	}

   381 

   382 void CSocketDesc::ReadCancel()

   383 	{

   384 	if (iSocketPtr != NULL)

   385 		{

   386 		CSockDescBase::ReadCancel();

   387 		}

   388 	}

   389 

   390 void CSocketDesc::Write (TDes8& aBuf, TRequestStatus& aStatus)

   391 	{

   392 	//Acquire the Lock before write and release it later

   393 	iWriteLock.Wait();	

   394 	if (iSocketPtr == NULL)

   395 		{

   396 		TInt ret = OpenUsingPreference();

   397 		if (ret != KErrNone)	// Error in open

   398 			{

   399 			Complete(aStatus,ret);

   400 			iWriteLock.Signal();

   401 			return;

   402 			}

   403 		}

   404 	CSockDescBase::Write(aBuf, aStatus);

   405 	iWriteLock.Signal();	

   406 	}

   407 

   408 void CSocketDesc::WriteCancel()

   409 	{

   410 	if (iSocketPtr != NULL)

   411 		{

   412 		CSockDescBase::WriteCancel();

   413 		}

   414 	}

   415 

   416 

   417 TInt CSocketDesc::Bind(const struct sockaddr* aAddr, unsigned long aSize)

   418 	{

   419 	TInt ret;

   420 	TUSockAddr addr(aAddr,aSize);

   421 

   422 	if (addr.iError != 0)

   423 		{

   424 		return addr.iError;

   425 		}

   426 

   427 	if (iSocketPtr == NULL)

   428 		{

   429 		ret = OpenUsingPreference();

   430 		if (ret != KErrNone)	// Error in open

   431 			{

   432 			return ret;

   433 			}

   434 		}

   435 	return iSocket.Bind(addr);

   436 	}

   437 

   438 TInt CSocketDesc::Listen(TUint qSize)

   439 	{

   440 	if (iStyle == SOCK_DGRAM) // Listen on UDP socket, crashing at RSocket::Listen().

   441 		{

   442 		return EOPNOTSUPP;

   443 		}

   444 	if (iSocketPtr == NULL)

   445 		{

   446 		TInt ret = OpenUsingPreference();

   447 		if (ret != KErrNone)	// Error in open

   448 			{

   449 			return ret;

   450 			}

   451 		}

   452 	return CSockDescBase::Listen(qSize);

   453 	}

   454 

   455 TInt CSocketDesc::SockName(int anEnd, struct sockaddr* anAddr,unsigned long* aSize)

   456 	{

   457 	TInt ret;

   458 	if (iSocketPtr == NULL)

   459         {

   460             ret = OpenUsingPreference();

   461             if (ret != KErrNone)    // Error in open

   462                 {

   463                 return ret;

   464                 }

   465         }

   466 	

   467 	if ( anAddr == 0 ) // if the sockaddr passed is NULL return EFAULT.

   468         {

   469             return EFAULT;

   470         }

   471 

   472    

   473     struct sockaddr temp;

   474     unsigned long len = sizeof( temp );

   475     

   476 	TUSockAddr nSockAddr(&temp, len );

   477 

   478 	ret = CSockDescBase::SockName(anEnd,nSockAddr);

   479 	if(ret == KErrNone )

   480 	    {

   481             nSockAddr.Get(&temp,&len );

   482             if( *aSize > len )

   483                 *aSize = len;

   484             memcpy( anAddr,&temp,*aSize);

   485             

   486             }

   487 	

   488 	return ret;

   489 	}

   490 

   491 TInt CSocketDesc::GetSockOpt(TInt anOptionName, TInt anOptionLevel, TDes8& anOption)

   492 	{

   493 	TInt ret;

   494 	if (anOption.Ptr() == NULL)

   495 		{

   496 		return EFAULT;

   497 		}

   498 	if (anOption.Length() == 0)

   499 		{

   500 		return EINVAL;

   501 		}

   502 	if (iSocketPtr == NULL)

   503 		{

   504 		ret = OpenUsingPreference();

   505 		if (ret != KErrNone)	// Error in open

   506 			{

   507 			return ret;

   508 			}

   509 		}

   510 

   511 	if (SO_TYPE == anOptionName && SOL_SOCKET == anOptionLevel)

   512 		{

   513 		TProtocolDesc protocolInfo;

   514 		ret = iSocket.Info(protocolInfo);

   515 		if (KErrNone == ret )

   516 			{

   517 			//Copy the Socket Type to the buffer

   518 			TInt size;

   519 			size = (anOption.Length() < sizeof(protocolInfo.iSockType))? anOption.Length(): sizeof(protocolInfo.iSockType);

   520 			Mem::Copy((unsigned char*)anOption.Ptr(), &protocolInfo.iSockType, size);

   521 			anOption.SetLength(size);

   522 			}

   523 		return ret;

   524 		}

   525 

   526 	if(IPPROTO_IP == anOptionLevel && IP_MULTICAST_IF == anOptionName)

   527 		{

   528 		TUSockAddr addr;

   529 		struct sockaddr_in sockAddress;

   530 		sockAddress.sin_family = AF_INET;

   531 		sockAddress.sin_port = iSocket.LocalPort();	

   532 		iSocket.LocalName(addr);

   533 

   534 		TInt a = sizeof(sockAddress);

   535 		addr.Get(&sockAddress,(unsigned long*)&a);  

   536 		TInt size;

   537 		size = (anOption.Length() < sizeof(sockAddress.sin_addr))? anOption.Length(): sizeof(sockAddress.sin_addr);

   538 		Mem::Copy((unsigned char*)anOption.Ptr(), &(sockAddress.sin_addr), size); 

   539 		anOption.SetLength(size);

   540 		return KErrNone;

   541 		}

   542 

   543 

   544 

   545 	switch(anOptionLevel)

   546 		{

   547 		case IPPROTO_TCP:

   548 			anOptionLevel=SOL_TCP;

   549 			break;

   550 		case IPPROTO_IP:

   551 			anOptionLevel=SOL_IP;

   552 			break;

   553 		case SOL_SOCKET:

   554 			{

   555 			switch(anOptionName)

   556 				{

   557 				case SO_REUSEADDR: 

   558 					anOptionLevel=SOL_IP;

   559 					break;

   560 				case SO_OOBINLINE:

   561 				case SO_KEEPALIVE:

   562 					anOptionLevel=SOL_TCP;

   563 					break; 

   564 				case SO_BROADCAST:

   565 					*((TInt*)anOption.Ptr()) = 1;

   566 					return KErrNone;

   567 				}

   568 			}

   569 		} 

   570 

   571 	switch(anOptionName)

   572 		{

   573 		case IP_MULTICAST_TTL:

   574 			anOptionLevel=KSolInetIp;

   575 			anOptionName=KSoIp6MulticastHops;

   576 			break;

   577 		case IP_MULTICAST_LOOP:

   578 			anOptionLevel=KSolInetIp;

   579 			anOptionName=KSoIp6MulticastLoop;

   580 			break;

   581 		}

   582 

   583 	return iSocket.GetOpt(anOptionName,anOptionLevel,anOption);

   584 	}

   585 

   586 TInt CSocketDesc::GetInterfaceIndex(TUint32 anAddr)

   587 	{

   588 	TPckgBuf<TSoInetIfQuery> ifq;

   589 	TInt aIndex = -1;

   590 	if (KInetAddrAny == anAddr)

   591 		{

   592 		aIndex = 0;

   593 		return aIndex;

   594 		}

   595 	else 

   596 		{

   597 		TInt ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);

   598 		if (ret != KErrNone)

   599 			return KErrGeneral;

   600 

   601 		TPckgBuf<TSoInetInterfaceInfo>iface;

   602 		while(iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface) == KErrNone)

   603 			{

   604 			TSoInetInterfaceInfo &info = iface();

   605 			TInt result;

   606 			if(info.iState == EIfUp)

   607 				{

   608 				if (anAddr == info.iAddress.Address()) 

   609 					{      	

   610 					ifq().iName = info.iName;

   611 					result = iSocket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, ifq);

   612 					if (result == KErrNone)

   613 						aIndex = ifq().iIndex;

   614 

   615 					}

   616 				}

   617 

   618 			}   	

   619 		}

   620 	return aIndex;

   621 	}

   622 

   623 TInt CSocketDesc::SetSockOpt(TInt anOptionName, TInt anOptionLevel, TDesC8& anOption)

   624 	{

   625 	TInt ret;

   626 	if (anOption.Ptr() == NULL)

   627 		{

   628 		return EFAULT;

   629 		}

   630 	if (anOption.Length() == 0)

   631 		{

   632 		return EINVAL;

   633 		}

   634 	if (iSocketPtr == NULL)

   635 		{

   636 		ret = OpenUsingPreference();

   637 		if (ret != KErrNone)	// Error in open

   638 			{

   639 			return ret;

   640 			}

   641 		}

   642 

   643 	switch(anOptionLevel)

   644 		{

   645 		case IPPROTO_TCP:

   646 			anOptionLevel=SOL_TCP;

   647 			break;

   648 		case IPPROTO_IP:

   649 			anOptionLevel=SOL_IP;

   650 			break;

   651 		case SOL_SOCKET:

   652 			{

   653 			switch(anOptionName)

   654 				{

   655 				case SO_REUSEADDR: 

   656 					anOptionLevel=SOL_IP;

   657 					break;

   658 				case SO_OOBINLINE:

   659 				case SO_KEEPALIVE:

   660 					anOptionLevel=SOL_TCP;

   661 					break; 

   662 				}

   663 			}

   664 

   665 		}

   666 	TPckgBuf<TIp6Mreq> req;

   667 	struct ip_mreq *mreq;

   668 	TInt aIndex = -1;

   669 	TUint8 *from;

   670 	TUint32 srcAddr;

   671 	TUint32 maddr;

   672 	TInetAddr multiAddr;

   673 	TInt *Option = NULL;

   674 	TInt ttlValue = 0;

   675 	switch(anOptionName) 

   676 		{

   677 		case IP_ADD_MEMBERSHIP:  //KSoIp6JoinGroup

   678 		case IP_DROP_MEMBERSHIP: //KSoIp6LeaveGroup

   679 

   680 			mreq = (struct ip_mreq *)anOption.Ptr();

   681 			from = (TUint8 *)anOption.Ptr(); 

   682 			from+=4;

   683 			// swaping the byte order

   684 			srcAddr = ByteOrder::Swap32( mreq->imr_interface.s_addr); 

   685 			//fetch the interface index

   686 			aIndex = GetInterfaceIndex(srcAddr);

   687 

   688 			// Set the multicast addr

   689 			from = (TUint8 *)anOption.Ptr();

   690 			maddr=(from[0]<<24)+(from[1]<<16)+(from[2]<<8)+from[3];

   691 			multiAddr.SetAddress( maddr);

   692 			multiAddr.ConvertToV4Mapped();

   693 			if(multiAddr.IsMulticast()){

   694 			req().iAddr = multiAddr.Ip6Address();

   695 			req().iInterface = aIndex;  

   696 			}

   697 			return iSocket.SetOpt(anOptionName, anOptionLevel, req);

   698 

   699 		case IP_MULTICAST_TTL:

   700 			anOptionLevel=KSolInetIp;

   701 			anOptionName=KSoIp6MulticastHops;

   702 			Option = (TInt*)anOption.Ptr();

   703 			ttlValue = *Option;

   704 			return iSocket.SetOpt(anOptionName,anOptionLevel,ttlValue);

   705 

   706 		case SO_BROADCAST: 

   707 			//check if user is trying to disable broadcast

   708 			Option = (TInt*)anOption.Ptr();

   709 			if (*Option == 0)  

   710 				{

   711 				return KErrNotSupported;

   712 				}	

   713 			else 

   714 				{

   715 				return KErrNone;	

   716 				}

   717 

   718 		case IP_MULTICAST_IF:

   719 			{

   720 			//No support for equivalent flag KsoIp6MulticastIf presently

   721 			//call bind instead	    

   722 			struct in_addr *inAddress = (struct in_addr*)anOption.Ptr();	    

   723 			struct sockaddr_in sockAddress; 	 		    

   724 			sockAddress.sin_family = AF_INET;

   725 			sockAddress.sin_port = iSocket.LocalPort();

   726 			sockAddress.sin_addr.s_addr = inAddress->s_addr;

   727 			TUSockAddr ifAddress(&sockAddress, sizeof(sockAddress));    	

   728 			return iSocket.Bind(ifAddress);		

   729 			}

   730 

   731 		case IP_MULTICAST_LOOP:

   732 			anOptionLevel=KSolInetIp;

   733 			anOptionName=KSoIp6MulticastLoop;

   734 			break;	    	

   735 

   736 		default:

   737 			break;

   738 

   739 		}

   740 	return iSocket.SetOpt(anOptionName,anOptionLevel,anOption);

   741 	}

   742 

   743 void CSocketDesc::Sync (TRequestStatus& aStatus)

   744 	{

   745 	// Judging from the Solaris man pages, this does nothing.

   746 	Complete(aStatus,KErrNone);

   747 	}

   748 

   749 void CSocketDesc::RecvFrom(TDes8& aDesc, TSockAddr& from, int flags, TRequestStatus& aStatus)

   750 	{

   751 	iReadLock.Wait();

   752 	// RSocket::Open() is postponed from socket()

   753 	if (iSocketPtr == NULL)

   754 		{

   755 		TInt ret = OpenUsingPreference();

   756 		if (ret != KErrNone)

   757 			{

   758 			Complete(aStatus,ret);	// Error in open

   759 			iReadLock.Signal();

   760 			return;

   761 			}

   762 		}

   763 

   764 	CSockDescBase::RecvFrom(aDesc, from, flags, aStatus);

   765 	iReadLock.Signal();

   766 	}

   767 

   768 void CSocketDesc::RecvFromCancel()

   769 	{

   770 	if (iSocketPtr != NULL)

   771 		{

   772 		CSockDescBase::RecvFromCancel();

   773 		}

   774 	}

   775 

   776 

   777 void CSocketDesc::SendTo(TDes8& aDesc, const struct sockaddr* anAddr, unsigned long aAddrLen, int flags, TRequestStatus& aStatus)

   778 	{

   779 	iWriteLock.Wait();	

   780 

   781 	if (iSocketPtr == NULL)

   782 		{

   783 		TInt ret = OpenUsingPreference();

   784 		if (ret != KErrNone)

   785 			{

   786 			Complete(aStatus,ret);   // Error in open

   787 			iWriteLock.Signal();

   788 			return;

   789 			}

   790 		}

   791 	TUSockAddr toAddr(anAddr,aAddrLen);

   792 	CSockDescBase::SendTo(aDesc, toAddr, flags, aStatus);

   793 	iWriteLock.Signal();

   794 	}

   795 

   796 void CSocketDesc::SendToCancel()

   797 	{

   798 	if (iSocketPtr != NULL)

   799 		{

   800 		CSockDescBase::SendToCancel();

   801 		}

   802 	}

   803 

   804 void CSocketDesc::Shutdown(TUint aHow,TRequestStatus& aStatus)

   805 	{

   806 	if (iSocketPtr == NULL) // Not opened at all. Nothing to do.

   807 		{

   808 		Complete(aStatus,KErrNone);

   809 		return;

   810 		}

   811 

   812 	CSockDescBase::Shutdown(aHow,aStatus);

   813 	return;

   814 	}

   815 

   816 void CSocketDesc::Accept(CFileDescBase*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs, TSockAddr * /*aAddr*/)

   817 	{

   818 	//Acquire the Lock before accept and release it later

   819 	iReadLock.Wait();

   820 

   821 	TInt err = KErrNone;

   822 	if (iSocketPtr == NULL)

   823 		{

   824 		err = OpenUsingPreference();

   825 		if (err != KErrNone)	// Error in open

   826 			{			

   827 			Complete(aStatus,err);

   828 			iReadLock.Signal();

   829 			return;

   830 			}

   831 		}

   832 

   833 	//coverity[alloc_fn]

   834 	//coverity[assign]

   835 	CSocketDesc *newSocket = new CSocketDesc;

   836 	if (newSocket!=0)

   837 		{

   838 		err = newSocket->CreateLock();

   839 		if (err)

   840 			{

   841 			Complete(aStatus, KErrNoMemory);

   842 			delete newSocket;

   843 			aNewSocket = NULL;

   844 			iReadLock.Signal();

   845 			//coverity[memory_leak]

   846 			return;

   847 			}

   848 

   849 		err=newSocket->iSocket.Open(aSs);

   850 		}

   851 	if (newSocket ==0 || err!=KErrNone)

   852 		{

   853 		Complete(aStatus,KErrNoMemory);

   854 		delete newSocket;

   855 		aNewSocket = NULL;

   856 		iReadLock.Signal();

   857 		//coverity[memory_leak]

   858 		return;

   859 		}

   860 	newSocket->iSocketPtr = &newSocket->iSocket;

   861 	newSocket->iStyle = iStyle;

   862 	iSocket.Accept(newSocket->iSocket,aStatus);

   863 	aNewSocket = newSocket;

   864 	iReadLock.Signal();

   865 	}

   866 

   867 void CSocketDesc::AcceptCancel()

   868 	{

   869 	if (iSocketPtr != NULL)

   870 		{

   871 		iSocket.CancelAccept();

   872 		}

   873 	}

   874 

   875 void CSocketDesc::Connect(const struct sockaddr* aAddr,unsigned long size,TRequestStatus& aStatus)

   876 	{

   877 	TUSockAddr addr(aAddr,size);

   878 

   879 	if (addr.iError != 0)

   880 		{

   881 		aStatus = addr.iError;

   882 		return;

   883 		}

   884 	if (iSocketPtr == NULL)

   885 		{

   886 		// RSocket::Open() is postponed from socket()	

   887 		TInt ret = OpenUsingPreference();

   888 		if (ret != KErrNone)	// error in open

   889 			{

   890 			aStatus = ret;

   891 			return;

   892 			}

   893 		}

   894 

   895 	iSocket.Connect(addr,aStatus);

   896 	User::WaitForRequest(aStatus);

   897 	}

   898 

   899 void CSocketDesc::ConnectCancel()

   900 	{

   901 	if (iSocketPtr != NULL)

   902 		{

   903 		iSocket.CancelConnect();

   904 		}

   905 	}

   906 

   907 void CSocketDesc::Ioctl(int aCmd, void* aParam, TRequestStatus& aStatus)

   908 	{

   909 	TInt ret=KErrNone;

   910 	int* param = reinterpret_cast<int*>(aParam);

   911 

   912 	if (iSocketPtr == NULL)

   913 		{

   914 		ret = OpenUsingPreference();

   915 		if (ret != KErrNone)	// Error in open

   916 			{

   917 			Complete(aStatus,ret);

   918 			return;

   919 			}

   920 		}

   921 

   922 	switch ((unsigned)aCmd)

   923 		{

   924 		case FIONREAD:

   925 		case E32IONREAD:

   926 			ret=iSocket.GetOpt(KSOReadBytesPending,KSOLSocket,*param);

   927 			break;

   928 		case E32IOSELECT:

   929 			{

   930 			iIoctlBuf.Set((TText8*)aParam,4,4);

   931 			iIoctlLock.Wait();

   932 			iIoctlFlag = ETrue;		

   933 			iSocket.Ioctl(KIOctlSelect,aStatus,&iIoctlBuf,KSOLSocket);

   934 			}

   935 			return;

   936 		case SIOCGIFCONF:

   937 			ret = GetInterfaceList(aParam);

   938 			break;

   939 		case SIOCGIFINDEX:

   940 			ret = GetInterfaceIndexByName(aParam);

   941 			break;

   942 		case SIOCGIFACTIVECONF:

   943 			ret = GetActiveInterfaceList(aParam);

   944 			break;

   945 		case SIOCSIFNAME:

   946 			ret = SetInterfaceByName(aParam);

   947 			break;

   948 		case SIOCIFSTART:

   949 			ret = StartInterface(aParam);

   950 			if(KErrNone == ret)

   951 				{

   952 				iSocket.Close();

   953 				iSocketPtr = NULL;

   954 				}

   955 			break;

   956 		case SIOCIFACTIVESTART:

   957 			ret = StartActiveInterface(aParam);

   958 			if(KErrNone == ret)

   959 				{

   960 				iSocket.Close();

   961 				iSocketPtr = NULL;

   962 				}

   963 			break;

   964 		case SIOCIFSTOP:

   965 			ret = StopInterface(aParam);

   966 			break;	

   967 		case SIOCATMARK:

   968 			ret=iSocket.GetOpt(KSoTcpRcvAtMark,KSolInetTcp,*param);

   969 			break;	

   970 		case SIOCGIFADDR:

   971 			ret = GetIpAddress(aParam);

   972 			break;	

   973 		case SIOCGIFNUM:

   974 			ret = GetInterafceNumber(aParam);

   975 			break;	

   976 		case SIOCADDRT:

   977 			ret = RouteRequest(KSoInetAddRoute, aParam);

   978 			break;	

   979 		case SIOCDELRT:		

   980 			ret = RouteRequest(KSoInetDeleteRoute, aParam);

   981 			break;	

   982 		case SIOCGIFHWADDR:

   983 			ret = GetInterfaceHWAddress(aParam);

   984 		    break;

   985 		case SIOCGIFACTIVEIAP:

   986 		    ret = GetActiveInterface( aParam);

   987 		    break;

   988 		

   989 		default:

   990 			ret=KErrNotSupported;

   991 			break;

   992 		}

   993 	Complete(aStatus,ret);

   994 	}

   995 

   996 TInt CSocketDesc::IoctlCompletion(int /*aCmd*/, void* /*aParam*/, TInt aStatus)

   997 	{

   998 	if(iIoctlFlag)

   999 		{

  1000 		iIoctlLock.Signal();

  1001 		iIoctlFlag = EFalse;

  1002 		}

  1003 	return aStatus;

  1004 	}

  1005 

  1006 void CSocketDesc::IoctlCancel()

  1007 	{

  1008 	if (iSocketPtr && iIoctlFlag)

  1009 		{

  1010 		iSocket.CancelIoctl();

  1011 		iIoctlLock.Signal();

  1012 		iIoctlFlag = EFalse;

  1013 		}

  1014 	}

  1015 // -----------------------------------------------------------------------------

  1016 // CSocketDesc::Fcntl

  1017 // Symbian Socket Specific Implementation for fcntl

  1018 // Implementation of fcntl for Socket will make use of  

  1019 // RSocket::SetOpt(KSONonBlockingIO/KSOBlockingIO, KSOLSocket)

  1020 // As of now fcntl supports F_SETFL and F_GETFL

  1021 // -----------------------------------------------------------------------------

  1022 //

  1023 TInt CSocketDesc::Fcntl(TUint anArg, TUint aCmd)

  1024 	{

  1025 	if (iSocketPtr == NULL)

  1026 		{

  1027 		TInt ret = OpenUsingPreference();

  1028 		if (ret != KErrNone)	// Error in open

  1029 			{

  1030 			return ret;

  1031 			}

  1032 		}

  1033 	return CSockDescBase::Fcntl(anArg, aCmd);

  1034 	}

  1035 

  1036 TInt CSocketDesc :: GetIpAddress( void *aParam )

  1037 	{

  1038 	TInetAddr myAddr;

  1039 	iSocket.LocalName(myAddr);

  1040 	TUint32 myIP = myAddr.Address();			

  1041 	ifreq *ifr = (ifreq *)aParam;

  1042 	if(myIP == 0)

  1043 		{

  1044 		return KErrGeneral;

  1045 		}

  1046 	((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr.s_addr = myIP;

  1047 	return KErrNone;

  1048 	}

  1049 

  1050 TInt CSocketDesc :: GetRemoteIpAddress( void *aParam )

  1051 	{

  1052 	TInetAddr remoteAddr;

  1053 	iSocket.RemoteName(remoteAddr);

  1054 	TUint32 remoteIP = remoteAddr.Address();			

  1055 	ifreq *ifr = (ifreq *)aParam;

  1056 	if(remoteIP == 0)

  1057 		{

  1058 		return KErrGeneral;

  1059 		}

  1060 	((struct sockaddr_in *)&ifr->ifr_dstaddr)->sin_addr.s_addr = remoteIP;

  1061 	return KErrNone;

  1062 	}

  1063 

  1064 TInt CSocketDesc :: GetInterafceNumber( void *aParam )

  1065 	{

  1066 	TInt count = 0;	

  1067 	TInt ret = KErrNone;

  1068 	TRAP(ret, AccessPointCountL(count));

  1069 	*(TInt *)aParam = count;

  1070 	return ret;	

  1071 	}

  1072 

  1073 #ifdef __SYMBIAN_COMPILE_UNUSED__

  1074 TInt CSocketDesc :: GetInterafceParamInfo( void *aParam,TInt aType)

  1075 	{

  1076 	TInt ret = KErrNone;	

  1077 	TAccessPointRecord tempRecord;

  1078 	ifreq *ifr = (ifreq *)aParam;

  1079 	TRAP(ret,FindConnectionInfoL(tempRecord,ifr->ifr_name));

  1080 	if(ret != KErrNone)

  1081 		return ret;

  1082 	wchar_t *str = (wchar_t *)( tempRecord.iServiceType.PtrZ());	 

  1083 	TInt servFlag = 0;

  1084 	if(WcsCmp(str,L"LANService") == 0)

  1085 		{

  1086 		servFlag = 0;

  1087 		}

  1088 	else if(WcsCmp(str,L"OutgoingGPRS") == 0)

  1089 		{

  1090 		servFlag  = 1;	

  1091 		}

  1092 	if(aType == EACCESS_GETMETRIC)

  1093 		{

  1094 		ret = GetInterfaceDetails(aParam,servFlag,EACCESS_GETMETRIC);					

  1095 		}	

  1096 	else if(aType == EACCESS_GETMTU)

  1097 		{

  1098 		ret = GetInterfaceDetails(aParam,servFlag,EACCESS_GETMTU);					

  1099 		}

  1100 	else if(aType == EACCESS_GETNETMASK)

  1101 		{

  1102 		ret = GetInterfaceDetails(aParam,servFlag,EACCESS_GETNETMASK);					

  1103 		}

  1104 	else if(aType == EACCESS_GETBROADCAST)

  1105 		{

  1106 		ret = GetInterfaceDetails(aParam,servFlag,EACCESS_GETBROADCAST);					

  1107 		}

  1108 	else if(aType == EACCESS_GETPHYSADDR)

  1109 		{

  1110 		ret = GetInterfaceDetails(aParam,servFlag,EACCESS_GETPHYSADDR);					

  1111 		}

  1112 	else if(aType == EACCESS_GETFLAGS)

  1113 		{

  1114 		ret = GetInterfaceDetails(aParam,servFlag,EACCESS_GETFLAGS);					

  1115 		}

  1116 	return ret;	

  1117 	}

  1118 

  1119 TInt CSocketDesc :: SetInterafceParamInfo( void *aParam,TInt aType)

  1120 	{

  1121 	TInt ret = KErrNone;	

  1122 	TAccessPointRecord tempRecord;

  1123 	ifreq *ifr = (ifreq *)aParam;

  1124 	TRAP(ret,FindConnectionInfoL(tempRecord,ifr->ifr_name));

  1125 	if(ret != KErrNone)

  1126 		return ret;

  1127 	wchar_t *str = (wchar_t *)(tempRecord.iServiceType.PtrZ());	 

  1128 	TInt servFlag = 0;

  1129 	if(WcsCmp(str,L"LANService") == 0)

  1130 		{

  1131 		servFlag = 0;

  1132 		}

  1133 	else if(WcsCmp(str,L"OutgoingGPRS") == 0)

  1134 		{