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)

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

   198  * Extract a struct sockaddr from a TSockAddr

   199  */

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

   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 	CLocalSystemInterface* backend = Backend();

   347 	backend->DefConnLock().Wait();

   348 	RHeap* oheap = User::SwitchHeap(backend->Heap());	

   349 	if (iSocketPtr != NULL)

   350 		{

   351 		iSocketPtr = NULL;	

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

   353 	    backend->RemoveSocket(this);

   354 		}

   355 

   356 	CSockDescBase::FinalClose();

   357 	User::SwitchHeap(oheap);

   358 	backend->DefConnLock().Signal();

   359 	return KErrNone;

   360 	}

   361 

   362 

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

   364 	{

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

   366 	iReadLock.Wait();

   367 	if (iSocketPtr == NULL)

   368 		{

   369 		TInt ret = OpenUsingPreference();

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

   371 			{

   372 			Complete(aStatus,ret);

   373 			iReadLock.Signal();

   374 			return;

   375 			}

   376 		}

   377 	CSockDescBase::Read (aBuf,aStatus);

   378 	iReadLock.Signal();

   379 	}

   380 

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

   382 	{

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

   384 	}

   385 

   386 void CSocketDesc::ReadCancel()

   387 	{

   388 	if (iSocketPtr != NULL)

   389 		{

   390 		CSockDescBase::ReadCancel();

   391 		}

   392 	}

   393 

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

   395 	{

   396 

   397     TInt err = maybe_reopen_socket();

   398     if (err != KErrNone)

   399         {

   400         Complete(aStatus, err);

   401         return;

   402         }

   403 	

   404 	iWriteLock.Wait();

   405 	CSockDescBase::Write(aBuf, aStatus);

   406 	iWriteLock.Signal();	

   407 	}

   408 

   409 void CSocketDesc::WriteCancel()

   410 	{

   411 	if (iSocketPtr != NULL)

   412 		{

   413 		CSockDescBase::WriteCancel();

   414 		}

   415 	}

   416 

   417 

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

   419 	{

   420 	TInt ret;

   421 	TUSockAddr addr(aAddr,aSize);

   422 

   423 	if (addr.iError != 0)

   424 		{

   425 		return addr.iError;

   426 		}

   427 	

   428 	ret = maybe_reopen_socket();

   429 	if (ret != KErrNone)

   430 	    return ret;

   431 	ATOMICSOCKETOP(ret = iSocket.Bind(addr),return KErrBadHandle)

   432 	return ret;

   433 	}

   434 

   435 TInt CSocketDesc::Listen(TUint qSize)

   436 	{

   437 

   438     TInt ret;

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

   440 		{

   441 		return EOPNOTSUPP;

   442 		}

   443 	

   444 	ret = maybe_reopen_socket();

   445 	if (ret != KErrNone)

   446 	    return ret;

   447 

   448 	return CSockDescBase::Listen(qSize);

   449 	}

   450 

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

   452 	{

   453 

   454 

   455 	if (!anAddr)

   456         {

   457         return EFAULT;

   458         }

   459 

   460 	TInt ret = maybe_reopen_socket();

   461 	if (ret != KErrNone)

   462 	    return ret;

   463 	

   464    

   465     struct sockaddr temp;

   466     unsigned long len = sizeof( temp );

   467     

   468 	TUSockAddr nSockAddr(&temp, len );

   469 

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

   471 	if(ret == KErrNone )

   472 	    {

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

   474             if( *aSize > len )

   475                 *aSize = len;

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

   477             

   478             }

   479 	

   480 	return ret;

   481 	}

   482 

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

   484 	{

   485 	TInt ret;

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

   487 		{

   488 		return EFAULT;

   489 		}

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

   491 		{

   492 		return EINVAL;

   493 		}

   494 	

   495 	ret = maybe_reopen_socket();

   496 	if (ret != KErrNone)

   497 	    return ret;

   498 

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

   500 		{

   501 		TProtocolDesc protocolInfo;

   502 		ATOMICSOCKETOP(ret = iSocket.Info(protocolInfo), ret = KErrBadHandle)

   503 		if (KErrNone == ret )

   504 			{

   505 			// Copy the Socket Type to the buffer

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

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

   508 			anOption.SetLength(size);

   509 			}

   510 		return ret;

   511 		}

   512 

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

   514 		{

   515 		TUSockAddr addr;

   516 		struct sockaddr_in sockAddress;

   517 		sockAddress.sin_family = AF_INET;

   518 		ATOMICSOCKETOP(sockAddress.sin_port = iSocket.LocalPort(),return KErrBadHandle)			

   519 		ATOMICSOCKETOP(iSocket.LocalName(addr);,return KErrBadHandle)		

   520 		TInt a = sizeof(sockAddress);

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

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

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

   524 		anOption.SetLength(size);

   525 		return KErrNone;

   526 		}

   527 

   528 	switch(anOptionLevel)

   529 		{

   530 		case IPPROTO_TCP:

   531 			anOptionLevel=SOL_TCP;

   532 			break;

   533 		case IPPROTO_IP:

   534 			anOptionLevel=SOL_IP;

   535 			break;

   536 		case SOL_SOCKET:

   537 			{

   538 			switch(anOptionName)

   539 				{

   540 				case SO_REUSEADDR: 

   541 					anOptionLevel=SOL_IP;

   542 					break;

   543 				case SO_OOBINLINE:

   544 				case SO_KEEPALIVE:

   545 					anOptionLevel=SOL_TCP;

   546 					break; 

   547 				case SO_BROADCAST:

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

   549 					return KErrNone;

   550 				}

   551 			}

   552 		} 

   553 

   554 	switch(anOptionName)

   555 		{

   556 		case IP_MULTICAST_TTL:

   557 			anOptionLevel=KSolInetIp;

   558 			anOptionName=KSoIp6MulticastHops;

   559 			break;

   560 		case IP_MULTICAST_LOOP:

   561 			anOptionLevel=KSolInetIp;

   562 			anOptionName=KSoIp6MulticastLoop;

   563 			break;

   564 		}

   565 	ATOMICSOCKETOP(ret = iSocket.GetOpt(anOptionName,anOptionLevel,anOption), return KErrBadHandle)

   566 	return ret;

   567 	}

   568 

   569 TInt CSocketDesc::GetInterfaceIndex(TUint32 anAddr)

   570 	{

   571 	TPckgBuf<TSoInetIfQuery> ifq;

   572 	TInt aIndex = -1;

   573 	if (KInetAddrAny == anAddr)

   574 		{

   575 		aIndex = 0;

   576 		return aIndex;

   577 		}

   578 	else 

   579 		{

   580 		TInt ret = KErrNone;

   581 		ATOMICSOCKETOP(ret = iSocket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl), ret = KErrBadHandle)

   582 		if (ret != KErrNone)

   583 			return KErrGeneral;

   584 

   585 		TPckgBuf<TSoInetInterfaceInfo>iface;

   586 		ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface), ret = KErrBadHandle )

   587 		while(ret == KErrNone)

   588 			{

   589 			TSoInetInterfaceInfo &info = iface();

   590 			TInt result;

   591 			if(info.iState == EIfUp)

   592 				{

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

   594 					{      	

   595 					ifq().iName = info.iName;

   596 					ATOMICSOCKETOP( result = iSocket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, ifq), result = KErrBadHandle )

   597 					if (result == KErrNone)

   598 						aIndex = ifq().iIndex;

   599 

   600 					}

   601 				}

   602 			ATOMICSOCKETOP( ret = iSocket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, iface), ret = KErrBadHandle )

   603 			}   	

   604 		}

   605 	return aIndex;

   606 	}

   607 

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

   609 	{

   610 	TInt ret;

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

   612 		{

   613 		return EFAULT;

   614 		}

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

   616 		{

   617 		return EINVAL;

   618 		}

   619 	

   620 	ret = maybe_reopen_socket();

   621 	if (ret != KErrNone)

   622 	    return ret;

   623 

   624 	switch(anOptionLevel)

   625 		{

   626 		case IPPROTO_TCP:

   627 			anOptionLevel=SOL_TCP;

   628 			break;

   629 		case IPPROTO_IP:

   630 			anOptionLevel=SOL_IP;

   631 			break;

   632 		case SOL_SOCKET:

   633 			{

   634 			switch(anOptionName)

   635 				{

   636 				case SO_REUSEADDR: 

   637 					anOptionLevel=SOL_IP;

   638 					break;

   639 				case SO_OOBINLINE:

   640 				case SO_KEEPALIVE:

   641 					anOptionLevel=SOL_TCP;

   642 					break; 

   643 				}

   644 			}

   645 

   646 		}

   647 	TPckgBuf<TIp6Mreq> req;

   648 	struct ip_mreq *mreq;

   649 	TInt aIndex = -1;

   650 	TUint8 *from;

   651 	TUint32 srcAddr;

   652 	TUint32 maddr;

   653 	TInetAddr multiAddr;

   654 	TInt *Option = NULL;

   655 	TInt ttlValue = 0;

   656 	switch(anOptionName) 

   657 		{

   658 		case IP_ADD_MEMBERSHIP:  //KSoIp6JoinGroup

   659 		case IP_DROP_MEMBERSHIP: //KSoIp6LeaveGroup

   660 

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

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

   663 			from+=4;

   664 			// swaping the byte order

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

   666 			//fetch the interface index

   667 			aIndex = GetInterfaceIndex(srcAddr);

   668 

   669 			// Set the multicast addr

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

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

   672 			multiAddr.SetAddress( maddr);

   673 			multiAddr.ConvertToV4Mapped();

   674 			if (multiAddr.IsMulticast())

   675 			    {

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

   677                 req().iInterface = aIndex;  

   678 			    }

   679 			ATOMICSOCKETOP( ret = iSocket.SetOpt(anOptionName, anOptionLevel, req), return KErrBadHandle )

   680 			return ret;

   681 

   682 		case IP_MULTICAST_TTL:

   683 			anOptionLevel=KSolInetIp;

   684 			anOptionName=KSoIp6MulticastHops;

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

   686 			ttlValue = *Option;

   687 			ATOMICSOCKETOP( ret = iSocket.SetOpt(anOptionName,anOptionLevel,ttlValue), return KErrBadHandle )

   688 			return ret;

   689 			

   690 		case SO_BROADCAST: 

   691 			//check if user is trying to disable broadcast

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

   693 			return (*Option == 0 ? KErrNotSupported : KErrNone);

   694 

   695 		case IP_MULTICAST_IF:

   696 			{

   697 			//No support for equivalent flag KsoIp6MulticastIf presently

   698 			//call bind instead	    

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

   700 			struct sockaddr_in sockAddress; 	 		    

   701 			sockAddress.sin_family = AF_INET;

   702 			ATOMICSOCKETOP(sockAddress.sin_port = iSocket.LocalPort();,return KErrBadHandle)         

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

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

   705 			ATOMICSOCKETOP( ret = iSocket.Bind(ifAddress), return KErrBadHandle )

   706 			return ret;

   707 			}

   708 

   709 		case IP_MULTICAST_LOOP:

   710 			anOptionLevel=KSolInetIp;

   711 			anOptionName=KSoIp6MulticastLoop;

   712 			break;	    	

   713 

   714 

   715 

   716 		}

   717 	ATOMICSOCKETOP( ret = iSocket.SetOpt(anOptionName,anOptionLevel,anOption), return KErrBadHandle )

   718 	return ret;

   719 	}

   720 

   721 void CSocketDesc::Sync (TRequestStatus& aStatus)

   722 	{

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

   724 	Complete(aStatus,KErrNone);

   725 	}

   726 

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

   728 	{

   729     TInt err = maybe_reopen_socket();

   730     if (err != KErrNone)

   731         {

   732         Complete(aStatus, err);

   733         return;

   734         }

   735 

   736 	iReadLock.Wait();

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

   738 	iReadLock.Signal();

   739 	}

   740 

   741 void CSocketDesc::RecvFromCancel()

   742 	{

   743 	if (iSocketPtr != NULL)

   744 		{

   745 		CSockDescBase::RecvFromCancel();

   746 		}

   747 	}

   748 

   749 

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

   751 	{

   752     TInt err = maybe_reopen_socket();

   753     if (err != KErrNone)

   754         {

   755         Complete(aStatus, err);

   756         return;

   757         }

   758     

   759 	TUSockAddr toAddr(anAddr, aAddrLen);

   760 	

   761 	iWriteLock.Wait();  

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

   763 	iWriteLock.Signal();

   764 	}

   765 

   766 void CSocketDesc::SendToCancel()

   767 	{

   768 // Should we use atomic loads here?

   769 	if (iSocketPtr != NULL)

   770 		{

   771 		CSockDescBase::SendToCancel();

   772 		}

   773 	}

   774 

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

   776 	{

   777 

   778     if (__e32_atomic_load_acq32(&iSocketPtr) == NULL) // Not opened at all. Nothing to do.

   779 		{

   780 		Complete(aStatus,KErrNone);

   781 		return;

   782 		}

   783 

   784 	CSockDescBase::Shutdown(aHow,aStatus);

   785 	return;

   786 	}

   787 

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

   789 	{

   790     aNewSocket = NULL;

   791 	TInt err = maybe_reopen_socket();

   792 	if (err != KErrNone)

   793 	    {

   794         Complete(aStatus, err);

   795         return;

   796 	    }

   797 	

   798 	iReadLock.Wait();

   799 	// what are the below coverity thingummichs?

   800 	//coverity[alloc_fn]

   801 	//coverity[assign]

   802 	CSocketDesc *newSocket = new CSocketDesc;

   803 	if (!newSocket)

   804 	    {

   805         Complete(aStatus, KErrNoMemory);

   806         iReadLock.Signal();

   807         return;

   808 	    }

   809 	

   810 	err = newSocket->CreateLock();

   811 	if (err)

   812 		{

   813         Complete(aStatus, KErrNoMemory);

   814         delete newSocket;

   815         iReadLock.Signal();

   816         //coverity[memory_leak]

   817         return;

   818 		}

   819 

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

   821 	if (err)

   822 		{

   823 		Complete(aStatus, err);

   824 		newSocket->FinalClose();  // this will Close locks

   825 		delete newSocket;

   826 

   827 		iReadLock.Signal();

   828 		//coverity[memory_leak]

   829 		return;

   830 		}

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

   832 	newSocket->iStyle = iStyle;

   833 	err = KErrNone;

   834 	ATOMICSOCKETOP( iSocket.Accept(newSocket->iSocket,aStatus), err = KErrBadHandle )

   835 	if( err )

   836 	    {

   837 	    Complete(aStatus, err);

   838 	    newSocket->FinalClose();  // this will Close locks

   839 	    delete newSocket;

   840 	    }

   841 	else

   842 	    {

   843 	    aNewSocket = newSocket;

   844 	    }

   845 	iReadLock.Signal();

   846 	}

   847 

   848 void CSocketDesc::AcceptCancel()

   849 	{

   850 	if (iSocketPtr != NULL)

   851 		{

   852 		ATOMICSOCKETOP( iSocket.CancelAccept(), NOP )

   853 		}

   854 	}

   855 

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

   857 	{

   858 	TUSockAddr addr(aAddr,size);

   859 

   860 	if (addr.iError != 0)

   861 		{

   862 		aStatus = addr.iError;

   863 		return;

   864 		}

   865 	

   866 	TInt err = maybe_reopen_socket();

   867 	if (err != KErrNone)

   868 	    {

   869         aStatus = err;

   870         return;

   871 	    }

   872 	

   873 	iWriteLock.Wait();

   874 	if( GetConnectionProgress() == EFalse )

   875 	    {

   876 		ATOMICSOCKETOP(iSocket.Connect(addr, aStatus), Complete(aStatus,KErrBadHandle))

   877 	    User::WaitForRequest(aStatus);

   878 	    if( aStatus.Int() == KErrWouldBlock )

   879 	        SetConnectionProgress(ETrue);

   880 	    }

   881 	else

   882 	    {

   883 	    aStatus = EALREADY;

   884 	    }

   885 	iWriteLock.Signal();

   886 	}

   887 

   888 void CSocketDesc::ConnectCancel()

   889 	{

   890 	if (iSocketPtr != NULL)

   891 		{

   892 		ATOMICSOCKETOP(iSocket.CancelConnect(),NOP)

   893 		}

   894 	}

   895 

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

   897 	{

   898 	TInt ret = KErrNone;

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

   900 

   901 	ret = maybe_reopen_socket();

   902 	if (ret != KErrNone)

   903 	    {

   904         Complete(aStatus, ret);

   905         return;

   906 	    }

   907 

   908 	switch ((unsigned)aCmd)

   909 		{

   910 		case FIONREAD:

   911 		case E32IONREAD:

   912 		    {

   913 			ATOMICSOCKETOP( ret=iSocket.GetOpt(KSOReadBytesPending,KSOLSocket,*param), ret = KErrBadHandle )

   914 		    }

   915 			break;

   916 		case E32IOSELECT:

   917 			{

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

   919 			iIoctlLock.Wait();

   920 			iIoctlFlag = ETrue;		

   921 			ATOMICSOCKETOP(iSocket.Ioctl(KIOctlSelect,aStatus,&iIoctlBuf,KSOLSocket), Complete(aStatus,KErrBadHandle))

   922 			}

   923 			return;

   924 		case SIOCGIFCONF:

   925 			ret = GetInterfaceList(aParam);

   926 			break;

   927 		case SIOCGIFINDEX:

   928 			ret = GetInterfaceIndexByName(aParam);

   929 			break;

   930 		case SIOCGIFACTIVECONF:

   931 			ret = GetActiveInterfaceList(aParam);

   932 			break;

   933 		case SIOCSIFNAME:

   934 			ret = SetInterfaceByName(aParam);

   935 			break;

   936 		case SIOCIFSTART:

   937 			ret = StartInterface(aParam);

   938 			if(KErrNone == ret)

   939 				{

   940 				iSocket.Close();

   941 				iSocketPtr = NULL;

   942 				}

   943 			break;

   944 		case SIOCIFACTIVESTART:

   945 			ret = StartActiveInterface(aParam);

   946 			if(KErrNone == ret)

   947 				{

   948 				iSocket.Close();

   949 				iSocketPtr = NULL;

   950 				}

   951 			break;

   952 		case SIOCIFSTOP:

   953 			ret = StopInterface(aParam);

   954 			break;	

   955 		case SIOCATMARK:

   956 			ATOMICSOCKETOP(ret=iSocket.GetOpt(KSoTcpRcvAtMark,KSolInetTcp,*param), ret = KErrBadHandle)

   957 			break;	

   958 		case SIOCGIFADDR:

   959 			ret = GetIpAddress(aParam);

   960 			break;	

   961 		case SIOCGIFNUM:

   962 			ret = GetInterafceNumber(aParam);

   963 			break;	

   964 		case SIOCADDRT:

   965 			ret = RouteRequest(KSoInetAddRoute, aParam);

   966 			break;	

   967 		case SIOCDELRT:		

   968 			ret = RouteRequest(KSoInetDeleteRoute, aParam);

   969 			break;	

   970 		case SIOCGIFHWADDR:

   971 			ret = GetInterfaceHWAddress(aParam);

   972 		    break;

   973 		case SIOCGIFACTIVEIAP:

   974 		    ret = GetActiveInterface( aParam);

   975 		    break;

   976 		

   977 		default:

   978 			ret=KErrNotSupported;

   979 			break;

   980 		}

   981 	Complete(aStatus,ret);

   982 	}

   983 

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

   985 	{

   986 	if(iIoctlFlag)

   987 		{

   988 		iIoctlLock.Signal();

   989 		iIoctlFlag = EFalse;

   990 		}

   991 	return aStatus;

   992 	}

   993 

   994 void CSocketDesc::IoctlCancel()

   995 	{

   996 	if (iSocketPtr && iIoctlFlag)

   997 		{

   998 		ATOMICSOCKETOP(iSocket.CancelIoctl(), NOP)

   999 		iIoctlLock.Signal();

  1000 		iIoctlFlag = EFalse;

  1001 		}

  1002 	}

  1003 // -----------------------------------------------------------------------------

  1004 // CSocketDesc::Fcntl

  1005 // Symbian Socket Specific Implementation for fcntl

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

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

  1008 // As of now fcntl supports F_SETFL and F_GETFL

  1009 // -----------------------------------------------------------------------------

  1010 //

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

  1012 	{

  1013 

  1014     TInt err = maybe_reopen_socket();

  1015     if (err != KErrNone)

  1016         return err;

  1017 

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

  1019 	}

  1020 

  1021 TInt CSocketDesc :: GetIpAddress( void *aParam )

  1022 	{

  1023 	TInetAddr myAddr;

  1024 	ATOMICSOCKETOP( iSocket.LocalName(myAddr), return KErrBadHandle )

  1025 	TUint32 myIP = myAddr.Address();			

  1026 	if (myIP == 0)

  1027 		{

  1028 		return KErrGeneral;

  1029 		}

  1030 

  1031 	ifreq *ifr = (ifreq *)aParam;

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

  1033 	return KErrNone;

  1034 	}

  1035 

  1036 TInt CSocketDesc :: GetRemoteIpAddress( void *aParam )

  1037 	{

  1038 	TInetAddr remoteAddr;

  1039 	ATOMICSOCKETOP( iSocket.RemoteName(remoteAddr), return KErrBadHandle )

  1040 	TUint32 remoteIP = remoteAddr.Address();			

  1041 

  1042 	if (remoteIP == 0)

  1043 		{

  1044 		return KErrGeneral;

  1045 		}

  1046 	ifreq *ifr = (ifreq *)aParam;

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

  1048 	return KErrNone;

  1049 	}

  1050 

  1051 TInt CSocketDesc :: GetInterafceNumber( void *aParam )

  1052 	{

  1053 	TInt count = 0;	

  1054 	TInt ret = KErrNone;

  1055 	TRAP(ret, AccessPointCountL(count));

  1056 	*(TInt *)aParam = count;

  1057 	return ret;	

  1058 	}

  1059 

  1060 #ifdef __SYMBIAN_COMPILE_UNUSED__

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

  1062 	{

  1063 	TInt ret = KErrNone;	

  1064 	TAccessPointRecord tempRecord;

  1065 	ifreq *ifr = (ifreq *)aParam;

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

  1067 	if(ret != KErrNone)

  1068 		return ret;

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

  1070 	TInt servFlag = 0;

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

  1072 		{

  1073 		servFlag = 0;

  1074 		}

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

  1076 		{

  1077 		servFlag  = 1;	

  1078 		}

  1079 	if(aType == EACCESS_GETMETRIC)

  1080 		{

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

  1082 		}	

  1083 	else if(aType == EACCESS_GETMTU)

  1084 		{

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

  1086 		}

  1087 	else if(aType == EACCESS_GETNETMASK)

  1088 		{

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

  1090 		}

  1091 	else if(aType == EACCESS_GETBROADCAST)

  1092 		{

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

  1094 		}

  1095 	else if(aType == EACCESS_GETPHYSADDR)

  1096 		{

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

  1098 		}

  1099 	else if(aType == EACCESS_GETFLAGS)

  1100 		{

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

  1102 		}

  1103 	return ret;	

  1104 	}

  1105 

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

  1107 	{

  1108 	TInt ret = KErrNone;	

  1109 	TAccessPointRecord tempRecord;

  1110 	ifreq *ifr = (ifreq *)aParam;

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

  1112 	if(ret != KErrNone)

  1113 		return ret;

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

  1115 	TInt servFlag = 0;

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

  1117 		{

  1118 		servFlag = 0;

  1119 		}

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

  1121 		{

  1122 		servFlag  = 1;	

  1123 		}

  1124 	if(aType == EACCESS_SETMETRIC)

  1125 		{

  1126 		ret = SetInterfaceDetails(aParam,servFlag,EACCESS_SETMETRIC);					

  1127 		}	

  1128 	else if(aType == EACCESS_SETMTU)

  1129 		{

  1130 		ret = SetInterfaceDetails(aParam,servFlag,EACCESS_SETMTU);					

  1131 		}		

  1132 	else if(aType == EACCESS_SETFLAGS)

  1133 		{

  1134 		ret = SetInterfaceDetails(aParam,servFlag,EACCESS_SETFLAGS);