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

// Implementation of STDLIB sockets.

// 

//

#include "FDESC.H"

#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 <libc/netinet/in.h>		// for htons

EXPORT_C unsigned short htons(unsigned short hs)

	{ return ByteOrder::Swap16(hs); }

EXPORT_C unsigned long  htonl(unsigned long hl)

	{ return ByteOrder::Swap32(hl); }

// Support for struct sockaddr conversion

TUSockAddr::TUSockAddr (TAny* aBuf) 

	: TSockAddr()

	{

	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);

		return;

		}

	}

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

	: TSockAddr()

	{

	Set(aBuf,aLen);

	}

void TUSockAddr::Set (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==0)

		{

		SetLength(0);

		return;

		}

	struct sockaddr* sp=(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;

		}

	// 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);

	}

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

//

// Extract a struct sockaddr from a TSockAddr

//

	{

	if (addr==0)

		return;

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

	TUint16 port=(TUint16)Port();

	if (Family()==AF_INET)

		{

		sp->sa_family=AF_INET;

		sp->sa_port=htons(port);

		TUint8* from=UserPtr();

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

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

		*len=8;

		return;

		}

	else

		{

		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

TInt CSocketDesc::isStream() const	// inline, but private

	{ 

	return iStyle==SOCK_STREAM; 

	}

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

	{

	if (protocol==0)

		protocol=KUndefinedProtocol;

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

	if (err==KErrNone)

		iStyle=style;

	return err;

	}

TInt CSocketDesc::FinalClose()

	{

	iSocket.Close();

	return KErrNone;

	}

TInt CSocketDesc::LSeek (int&, int)

	{

	return ESPIPE;	// can't seek on a socket

	}

TInt CSocketDesc::FStat (struct stat *st)

	{

	// I am a socket about which little is known

	st->st_mode = S_IFSOCK;

	st->st_blksize=0;

	return KErrNone;

	}

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

	{

	iSocket.Recv(aBuf, 0, aStatus, iLength);	// needs a completion which returns the length

	}

void CSocketDesc::ReadCancel()

	{

	iSocket.CancelRecv();

	}

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

	{

	iSocket.Write(aBuf, aStatus);

	}

void CSocketDesc::WriteCancel()

	{

	iSocket.CancelWrite();

	}

TInt CSocketDesc::Bind(TSockAddr& anAddr)

	{

	return iSocket.Bind(anAddr);

	}

TInt CSocketDesc::Listen(TUint qSize)

	{

	return iSocket.Listen(qSize);

	}

TInt CSocketDesc::SockName(int anEnd, TSockAddr& anAddr)

	{

	const TUint KBadFamily = 0xFF000000;

	anAddr.SetFamily(KBadFamily);

	if (anEnd==0)

		iSocket.LocalName(anAddr);

	else

		iSocket.RemoteName(anAddr);

	if (anAddr.Family()==KBadFamily)

		return KErrGeneral; // assume that the call failed, but there is no way to find out why

	return KErrNone;

	}

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

	{

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

	}

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

	{

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

	}

void CSocketDesc::Sync (TRequestStatus& aStatus)

	{

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

	Complete(aStatus,KErrNone);

	}

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

	{

	if (isStream())

		{

		// recvfrom on a stream ignores the from address - get the peername

		if (from.Length())

			SockName(1,from);

		iSocket.RecvOneOrMore(aDesc,flags,aStatus,iLength);

		}

	else

		iSocket.RecvFrom(aDesc,from,flags,aStatus,iLength);

	}

void CSocketDesc::RecvFromCancel()

	{

	iSocket.CancelRecv();

	}

TInt CSocketDesc::RecvFromCompletion(TInt& aLength, TInt aStatus)

        {

        aLength=iLength();      // ignored if there's an error, 0 at EOF

        if (aStatus == KErrEof || aStatus == KErrDisconnected)

                return 0;       // indicates graceful close at the other end

        return aStatus;

        }

void CSocketDesc::SendTo(TDes8& aDesc, TSockAddr& to, int flags, TRequestStatus& aStatus)

	{

	if (to.Length()==0)

		iSocket.Send(aDesc,flags,aStatus);

	else

		{

		if (isStream())

			Complete(aStatus,KErrNotSupported);	// can't sendto a stream

		else

			iSocket.SendTo(aDesc,to,flags,aStatus);

		}

	}

void CSocketDesc::SendToCancel()

	{

	iSocket.CancelSend();

	}

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

	{

	aHow=(aHow+1)&0x3;	// 0=>EStopInput, 1=>EStopOutput, 2=>EStopInOut

	iSocket.Shutdown(*REINTERPRET_CAST(RSocket::TShutdown*,&aHow),aStatus);

	}

void CSocketDesc::Accept(CSocketDesc*& aNewSocket, TRequestStatus& aStatus, RSocketServ& aSs)

	{

	aNewSocket= new CSocketDesc;

	TInt err=KErrNone;

	if (aNewSocket!=0)

		err=aNewSocket->iSocket.Open(aSs);

	if (aNewSocket==0 || err!=KErrNone)

		{

		Complete(aStatus,KErrNoMemory);

		delete aNewSocket;

		return;

		}

	aNewSocket->iStyle=SOCK_STREAM;	/* necessarily */

	iSocket.Accept(aNewSocket->iSocket,aStatus);

	}

void CSocketDesc::AcceptCancel()

	{

	iSocket.CancelAccept();

	}

void CSocketDesc::Connect(TSockAddr& anAddr,TRequestStatus& aStatus)

	{

	iSocket.Connect(anAddr,aStatus);

	}

void CSocketDesc::ConnectCancel()

	{

	iSocket.CancelConnect();

	}

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

	{

	TInt ret=KErrNone;

	int* param=REINTERPRET_CAST(int*,aParam);

	switch (aCmd)

		{

	case E32IONREAD:

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

		break;

	case E32IOSELECT:

		{

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

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

		}

		return;

	default:

		ret=KErrNotSupported;

		break;

		}

	Complete(aStatus,ret);

	}

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

	{

	return aStatus;

	}

void CSocketDesc::IoctlCancel()

	{

	iSocket.CancelIoctl();

	}