/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <sys/types.h>

#include <string.h>		// for memcpy

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

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

#include <sys/socket.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

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

#include <sys/sockio.h>

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

#include <arpa/inet.h>   

#include <es_sock.h>

#include <in_sock.h>

#include <net/if.h>

#include <commdb.h>

#include <cdbcols.h>

#include <commdbconnpref.h>

#include <e32base.h>

#include <e32err.h>

#include <utf.h>

#include <e32std.h>

#include <net/route.h>

#include <in_iface.h>

#include "fdesc.h"

#include "lposix.h"

#include "sysif.h"

// Support for struct sockaddr conversion

TUSockAddr::TUSockAddr (TAny* aBuf) 

: TSockAddr(), iError(0)

		{

		Prepare(aBuf);

		}

void TUSockAddr::Prepare (TAny* aBuf) 

//

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

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

//

	{

	if (aBuf==0)

		{

		SetLength(0);

		iError = EFAULT;

		return;

		}

	}

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

: TSockAddr(), iError(0)

		{

		Set(aBuf,aLen);

		}

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

//

// Construct an ESOCK TSockAddr from a struct sockaddr.

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

//

	{

	if (!aBuf)

		{

		iError = EFAULT;

		SetLength(0);

		return;

		}

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

	// aLen should be atleast have minimum size.

	if (aLen < dataOffset)

		{

		iError = EINVAL;

		SetLength(0);

		return;

		}

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

	TUint8 *from=(TUint8*)aBuf;	

	if (sp->sa_family==AF_INET)

		{		

		// byte-swap sockaddr_in back into host ordering

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

		from+=4;

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

		from+=4;

		SetFamily(AF_INET);

		SetPort(port);

		*(TUint32*)UserPtr()=addr;

		SetUserLen(4);

		return;

		}

	else if (sp->sa_family == AF_INET6)

		{

		SetFamily(sp->sa_family);

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

		from+=4;

		// copy the rest of the data as given

		TUint8 *to=UserPtr();

		if (aLen<4)

			aLen=4;

		aLen-=4;	// skip fmaily and port

		if (aLen>24)

			aLen=24;

		memcpy(to,from,aLen);

		SetUserLen(aLen);    	

		return;

		}	

	else if (sp->sa_family == KBTAddrFamily)

		{

		// Make a TBTSockAddr from a sockaddr_bt...

		TBTSockAddr tmpAddr;

		// Family is always Bluetooth:

		tmpAddr.SetFamily(KBTAddrFamily);

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

		// POSIX Bluetooth APIs assume litle-endian format:

		tmpAddr.SetPort(sp->sa_port);

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

		// Symbian appears to index Bluetooth addresses in a

		// big-endian manner:

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

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

		TBTDevAddr devAddr;

		const TInt KMinLength = KBTAddrLength + KBTAddrOffset;

		if (aLen >= KMinLength)

			{

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

				{

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

				}

			}

		tmpAddr.SetBTAddr(devAddr);

		// Security settings:

		TBTServiceSecurity sec;

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

		sec.SetAuthentication(EFalse);

		sec.SetEncryption(EFalse);

		sec.SetAuthorisation(EFalse);

		sec.SetDenied(EFalse);

		tmpAddr.SetSecurity(sec);

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

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

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

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

		//

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

		return;

		}

	else

		{

		// Not AF_INET or KBTAddrFamily:

		// expand the family and port

		SetFamily(sp->sa_family);

		SetPort(sp->sa_port);

		from+=4;

		// copy the rest of the data as given

		TUint8 *to=UserPtr();

		if (aLen<4)

			aLen=4;

		aLen-=4;	// skip fmaily and port

		if (aLen>24)

			aLen=24;

		memcpy(to,from,aLen);

		SetUserLen(aLen);

		}

	}

/*

 * Extract a struct sockaddr from a TSockAddr

 */

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

	{

	if (addr==0)

		{

		iError = EFAULT;

		SetLength(0);

		return;

		}

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

	// aLen should be atleast have minimum size.

	if (*len < dataOffset)

		{

		iError = EINVAL;

		SetLength(0);

		return;

		};

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

	TUint16 port=(TUint16)Port();

	//The ipv4 address could be obtained either as

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

	TInetAddr inetAddr(*this);

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

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

		{

		sp->sa_family=AF_INET;

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

		TUint8* from=UserPtr();

		TUint32 fromaddr;

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

		if(isV4Mapped)

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

		else

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

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

		*len=8;

		return;

		}

	else if (Family()==AF_INET6)

		{

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

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

		TUint ulen=GetUserLen();

		if (ulen+4>(*len))

			ulen=(*len)-4;

		*len=ulen+4;

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

		sp->sa_len = ulen;

		return;

		}		

	else if (Family()==KBTAddrFamily)

		{

		sp->sa_family=KBTAddrFamily;

		sp->sa_port=port;

		const TInt KBTAddrLength = 6;

		if (GetUserLen() == KBTAddrLength)

			{

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

				{

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

				}

			}

		return;

		}

	else

		{

		// Not AF_INET or KBTAddrFamily:

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

		sp->sa_port=port;

		TUint ulen=GetUserLen();

		if (ulen+4>(*len))

			ulen=(*len)-4;

		*len=ulen+4;

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

		}

	}

// The Socket descriptor class

CSocketDesc::CSocketDesc()

:iIoctlBuf(0,0),

iSocketPtr(NULL),

iConnPref(),

iConnectionPtr(NULL),

iSubConnectionPtr(NULL),

iRConnectionIndex(-1),		

iSockServPtr(NULL)

		{

		};

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

	{

	if (protocol == 0)

		{

		if (family == AF_INET)

			{

			switch (style)

				{

				case SOCK_STREAM:

					protocol = IPPROTO_TCP;

					break;

				case SOCK_DGRAM:

					protocol = IPPROTO_UDP;

					break;

				}

			}

		else

			{

			protocol = KUndefinedProtocol;

			}

		}

	iFcntlFlag = 0;

	TInt err = CreateLock();

	if (err)

		{

		return err;

		}

	if (family == AF_INET6)

		{

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

		}

	else

		{

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

		}

	if (err == KErrNone)

		{

		iStyle = style;

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

		iAddrFamily = family;

		iProtocol = protocol; 

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

		}

	return err;

	}

TInt CSocketDesc::FinalClose()

	{

	CLocalSystemInterface* backend = Backend();

	backend->DefConnLock().Wait();

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

	if (iSocketPtr != NULL)

		{

		iSocketPtr = NULL;	

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

	    backend->RemoveSocket(this);

		}

	CSockDescBase::FinalClose();

	User::SwitchHeap(oheap);

	backend->DefConnLock().Signal();

	return KErrNone;

	}

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

	{

	//Acquire the Lock before read and release it later

	iReadLock.Wait();

	if (iSocketPtr == NULL)

		{

		TInt ret = OpenUsingPreference();

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

			{

			Complete(aStatus,ret);

			iReadLock.Signal();

			return;

			}

		}

	CSockDescBase::Read (aBuf,aStatus);

	iReadLock.Signal();

	}

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

	{

	return CSockDescBase::ReadCompletion(aBuf, aStatus);

	}

void CSocketDesc::ReadCancel()

	{

	if (iSocketPtr != NULL)

		{

		CSockDescBase::ReadCancel();

		}

	}

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

	{

    TInt err = maybe_reopen_socket();

    if (err != KErrNone)

        {

        Complete(aStatus, err);

        return;

        }

	iWriteLock.Wait();

	CSockDescBase::Write(aBuf, aStatus);

	iWriteLock.Signal();	

	}

void CSocketDesc::WriteCancel()

	{

	if (iSocketPtr != NULL)

		{

		CSockDescBase::WriteCancel();

		}

	}

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

	{

	TInt ret;

	TUSockAddr addr(aAddr,aSize);

	if (addr.iError != 0)

		{

		return addr.iError;

		}

	ret = maybe_reopen_socket();

	if (ret != KErrNone)

	    return ret;

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

	return ret;

	}

TInt CSocketDesc::Listen(TUint qSize)

	{

    TInt ret;

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

		{

		return EOPNOTSUPP;

		}

	ret = maybe_reopen_socket();

	if (ret != KErrNone)

	    return ret;

	return CSockDescBase::Listen(qSize);

	}

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

	{

	if (!anAddr)

        {

        return EFAULT;

        }

	TInt ret = maybe_reopen_socket();

	if (ret != KErrNone)

	    return ret;

    struct sockaddr temp;

    unsigned long len = sizeof( temp );

	TUSockAddr nSockAddr(&temp, len );

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

	if(ret == KErrNone )

	    {

            nSockAddr.Get(&temp,&len );

            if( *aSize > len )

                *aSize = len;

            memcpy( anAddr,&temp,*aSize);

            }

	return ret;

	}

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

	{

	TInt ret;

	if (anOption.Ptr() == NULL)

		{

		return EFAULT;

		}

	if (anOption.Length() == 0)

		{

		return EINVAL;

		}

	ret = maybe_reopen_socket();

	if (ret != KErrNone)

	    return ret;

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

		{

		TProtocolDesc protocolInfo;

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

		if (KErrNone == ret )

			{

			// Copy the Socket Type to the buffer

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

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

			anOption.SetLength(size);

			}

		return ret;

		}

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

		{

		TUSockAddr addr;

		struct sockaddr_in sockAddress;

		sockAddress.sin_family = AF_INET;

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

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

		TInt a = sizeof(sockAddress);

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

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

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

		anOption.SetLength(size);

		return KErrNone;

		}