/*

* Copyright (c) 2005-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 "sysreent.h"

#include <sys/socket.h>

#include <stdapis/netinet/in.h>

#include <es_sock.h>

#include <utf.h>

#include "sysif.h"

#include "fdesc.h"

#include "lposix.h"

#include "netdb_r.h"

extern "C" {

EXPORT_C int _socket_r (int *aErrno, int family, int style, int protocol)

	{

	return Backend()->socket(family, style, protocol, *aErrno);

	}

EXPORT_C int _recvfrom_r (int *aErrno, int fd, char *buf, size_t nbyte, int flags, struct sockaddr* from, size_t* fromsize)

	{

	return Backend()->recvfrom(fd, buf, nbyte, flags, from, (unsigned long*)fromsize, *aErrno);

	}

EXPORT_C int _sendto_r (int *aErrno, int fd, const char *buf, size_t nbyte, int flags, struct sockaddr* to, size_t tosize)

	{

	return Backend()->sendto(fd, buf, nbyte, flags, to, tosize, *aErrno);

	}

EXPORT_C int _shutdown_r (int *aErrno, int fd, int how)

	{

	return Backend()->shutdown(fd, how, *aErrno);

	}

EXPORT_C int _listen_r (int *aErrno, int fd, int n)

	{

	return Backend()->listen(fd, n, *aErrno);

	}

EXPORT_C int _accept_r (int *aErrno, int fd, struct sockaddr *addr, size_t *size)

	{

	int newfd = Backend()->accept(fd, addr, size, *aErrno);

	if (newfd>=0 && (addr != NULL) && (size != NULL))

		Backend()->sockname(newfd, addr, (unsigned long*)size, 1, *aErrno);	// getpeername

	return newfd;

	}

EXPORT_C int _bind_r (int *aErrno, int fd,const struct sockaddr *addr, size_t size)

	{

	return Backend()->bind(fd, addr, size, *aErrno);

	}

EXPORT_C int _connect_r (int *aErrno, int fd, const struct sockaddr *addr, size_t size)

	{

	return Backend()->connect(fd, addr, size, *aErrno);

	}

EXPORT_C int _getsockname_r (int *aErrno, int fd, struct sockaddr *addr, size_t* size)

	{

	if (size == 0)

		{

		*aErrno = EINVAL;

		return -1;

		}

	return Backend()->sockname(fd, addr, (unsigned long*)size, 0, *aErrno);

	}

EXPORT_C int _getpeername_r (int *aErrno, int fd, struct sockaddr *addr, size_t* size)

	{

	if (size == 0)

		{

		*aErrno = EINVAL;

		return -1;

		}

	return Backend()->sockname(fd, addr, (unsigned long*)size, 1, *aErrno);

	}

EXPORT_C int _getsockopt_r (int *aErrno, int fd, int level, int opt, void* buf, size_t* len) 

	{

	if (len == 0)

		{

		*aErrno = EFAULT;

		return -1;

		}

	return Backend()->getsockopt(fd, level, opt, buf, (unsigned long*)len, *aErrno);

	}

EXPORT_C int _setsockopt_r (int *aErrno, int fd, int level, int opt, void* buf, size_t len) 

	{

	return Backend()->setsockopt(fd, level, opt, buf, len, *aErrno);

	}

LOCAL_C inline TInt SockServConnect(RSocketServ& aSs)

	{

	TInt err = aSs.Connect(TUint(-1)); // allow arbit number of requests

	if (err == KErrNone)

		{

		err = aSs.ShareAuto();

		}

	return err;

	}

EXPORT_C int _gethostname_r (int *aErrno, char *name, size_t size)

	{

	TInt err = KErrNone;

	if(size <= 0)

        {

        return MapError(EINVAL, *aErrno);

        }

	RSocketServ& ss = Backend()->SockServSession();

	// connect to the Socket Server if necessary

	if (ss.Handle() == 0)

		{

		err = SockServConnect(ss);

		if (err != KErrNone)

			{

			return MapError(err, *aErrno);

			}

		}

	RHostResolver hr;

	RConnection& defConnection = Backend()->GetDefaultConnection();

	if(defConnection.SubSessionHandle() != 0)

	    {

	    err = hr.Open(ss, AF_INET, IPPROTO_UDP,defConnection);

	    }

	else

	    {

	    }

	if (err == KErrNone)

		{

		TBuf<128> hostname;

		err = hr.GetHostName(hostname);

		if (err == KErrNone)

			{

				TPtr8 ret((TText8*)name, size-1);

				if(CnvUtfConverter::ConvertFromUnicodeToUtf8(ret,hostname) == 0)

				{

				name[ret.Size()] = '\0';

				}

		    	else

				{

				err = ENAMETOOLONG;

				}

			}

		}

	return MapError(err, *aErrno);

	}

EXPORT_C int _getprotobyname_r(int* aErrno, const char* name, TProtocolDesc* pProtoInf)

	{

	TInt err = KErrNone;

	RSocketServ& ss = Backend()->SockServSession();

	// connect to the Socket Server if necessary

	if (ss.Handle() == 0)

		{

		err = SockServConnect(ss);

		if (err != KErrNone)

			{

			return MapError(err, *aErrno);

			}

		}

	TBuf<128> buf;

	TPtrC8 bufPtr((TText8*)name);

	buf.Copy(bufPtr);

	err = ss.FindProtocol(buf, *pProtoInf);

	return MapError(err, *aErrno);

	}

EXPORT_C int _getprotobynumber_r(int *aErrno, int proto, TProtocolDesc* pProtoInf)

	{

	TInt err = KErrNone;

	RSocketServ& ss = Backend()->SockServSession();

	// connect to the Socket Server if necessary

	if (ss.Handle() == 0)

		{

		err = SockServConnect(ss);

		if (err != KErrNone)

			{

			return MapError(err, *aErrno);

			}

		}

	TUint count;

	err = ss.NumProtocols(count);

	if (err == KErrNone)

		{

		TInt idx = 1;

		for (; idx <= count; ++idx)

			{

			err = ss.GetProtocolInfo(idx, *pProtoInf);

			if (err != KErrNone || pProtoInf->iProtocol == proto)

				{

				break;

				}

			}

		if (idx > count)

			{

			// no protocol matched input

			return -1;

			}

		}

	return MapError(err, *aErrno);

	}

struct hostent_buf

	{

	struct hostent iHostent;

	struct sockaddr iAddr;

	char* iPtrs[2];

	char iName[1];	// and following bytes

	};

struct hostent* mapNameRecord(struct _reent* rp, TNameRecord& aRecord, int length, int format)

	{

	Backend()->Free(rp->_netdb);

	HBufC8 * name;

	TInt errNum;

	if(ConvertUnicodeToUtf8(aRecord.iName,name,errNum) == -1)

		{

		rp->_errno = EINVAL;

		return 0;

		}

	// Switch to the backend heap

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

	struct hostent_buf* hbp = (struct hostent_buf*)Backend()->Alloc(sizeof(struct hostent_buf)+name->Size()+1);

	// Revert to the default heap

	User::SwitchHeap(oldHeap);

	rp->_netdb = hbp;

	if (hbp == 0)

		{

		delete name;

		rp->_errno = ENOMEM;

		return 0;

		}

	hbp->iHostent.h_name = &hbp->iName[0];		// one name

	hbp->iHostent.h_aliases = &hbp->iPtrs[1];	// no aliases

	hbp->iHostent.h_addrtype = format;

	hbp->iHostent.h_length = length;

	hbp->iHostent.h_addr_list = &hbp->iPtrs[0];		// one address...

	hbp->iPtrs[0] = (char*)&hbp->iAddr.sa_data[0];	// ... which is iAddr

	TPtr8 tname((TText8*)&hbp->iName[0], name->Size()+1);

	tname.Copy(name->Des());

	tname.ZeroTerminate();

    delete name;

	unsigned long len = sizeof(hbp->iAddr);

	aRecord.iAddr.SetFamily(format);	// not set by GetByName(_L(""));

	static_cast<TUSockAddr*>(&aRecord.iAddr)->Get(&hbp->iAddr, &len);	

	return &hbp->iHostent;

	}

/*

Get the internet name of the host by address.

@return 

@param rp pointer

@param addr 

@param length 

@param format 

*/

EXPORT_C struct hostent* _gethostbyaddr_r (struct _reent* rp, const char* addr, int length, int format)

	{

	TInt err = KErrNone;

	struct hostent* retval = NULL;

	RSocketServ& ss = Backend()->SockServSession();

	// connect to the Socket Server if necessary

	if (ss.Handle() == 0)

		{

		err = SockServConnect(ss);

		if (err != KErrNone)

			{

			MapError(err, rp->_errno);

			return retval;

			}

		}

    if(format != AF_INET && format != AF_INET6)

        {

        format = AF_INET;

        }

	if (err == KErrNone)

		{

		RHostResolver r;

		RConnection& defConnection = Backend()->GetDefaultConnection();

		if(defConnection.SubSessionHandle() != 0)

		    {

			err=r.Open(ss, format, IPPROTO_UDP, defConnection);

		    }

		else

		    {

		    }

		if (err == KErrNone)

			{

			struct sockaddr buf;

			buf.sa_family = (unsigned short)format;

			memcpy(buf.sa_data,addr,length);

			TUSockAddr addr(&buf, length+4);

			TNameRecord record;

			TNameEntry entry(record);

		    TInetAddr inetAddr(addr);

            if(inetAddr.IsLoopback())

                {

                if(format == AF_INET)

                    inetAddr.SetAddress(KInetAddrLoop);

                else if(format == AF_INET6)

                    inetAddr.SetAddress(KInet6AddrLoop);

                entry().iAddr = inetAddr;

                entry().iName.Copy(_L("localhost"));

                }

            else

                {

                err = r.GetByAddress(addr, entry);

                while (err == KErrNone)

                    {

                    TInetAddr addr(entry().iAddr);

                    if(!addr.IsUnspecified())

                        {

                        if(format == addr.Family())

                            {

                            break;

                            }

                        else if(format == AF_INET && addr.Family() == AF_INET6 && addr.IsV4Mapped())

                            {

                            addr.ConvertToV4();

                            entry().iAddr = addr;

                            break;

                            }

                        }

                    err = r.Next(entry);

                    }

                }

		             if (err == KErrNone)

		                {

		                record = entry();

		                retval = mapNameRecord(rp, record, length, format);

		                }

			r.Close();

			}

		}

	if (err == -3004)	// NETDIAL busy

		err = TRY_AGAIN;

	if (err < -3000)	// i.e. a NETDIAL error

		err = NO_RECOVERY;

	MapError(err, rp->_errno);

	return retval;

	}

/*

Get the internet name of the host by name.

@return 

@param rp 

@param name name of the host

*/

EXPORT_C struct hostent* _gethostbyname_r (struct _reent* rp, const char* name)

	{

	TInt err = KErrNone;

	struct hostent* retval = NULL;

	RSocketServ& ss = Backend()->SockServSession();

	// connect to the Socket Server if necessary

	if (ss.Handle() == 0)

		{

		err = SockServConnect(ss);

		if (err != KErrNone)

			{

			MapError(err, rp->_errno);

			return retval;

			}

		}

    RHostResolver r;

    RConnection& defConnection = Backend()->GetDefaultConnection();

    if (defConnection.SubSessionHandle() != 0)

        {

        err = r.Open(ss, AF_INET, IPPROTO_UDP, defConnection);

        }

    else

        {

        }

    if (err == KErrNone)

        {

        TNameRecord record;

        TNameEntry entry(record);

        TPtrC8 ptr(reinterpret_cast<const TUint8*> (name));

        THostName hostname;

        hostname.Copy(ptr);

        if (hostname.CompareF(_L("localhost")) == KErrNone)

            {

            TInetAddr addr;

            addr.SetAddress(KInetAddrLoop);

            entry().iAddr = addr;

            entry().iName.Copy(hostname);

            }

        else

            {

            err = r.GetByName(hostname, entry);

            while (err == KErrNone)

                {

                TInetAddr addr(entry().iAddr);

                if(!addr.IsUnspecified())

                    {

                    if (addr.Family() == KAfInet) 

                        {

                        break;

                        }

                        {

                        addr.ConvertToV4(); 

                        entry().iAddr = addr;

                        break;

                        }

                    }

                err = r.Next(entry);

                }

            }

        if (err == KErrNone)

            {

            record = entry();

            retval = mapNameRecord(rp, record, sizeof(struct in_addr), AF_INET);

            }

        r.Close();

        }

	if (err == -3004)	// NETDIAL busy

		err = TRY_AGAIN;

	if (err < -3000)	// i.e. a NETDIAL error

		err = NO_RECOVERY;

	MapError(err, rp->_errno);

	return retval;

	}

/*

 * Set the default IAP interface in the backend

 * @param	aErrno 	The errno to be set

 * @param	aIfReq	Pointer to the ifreq structure containing the interface name

 * @return 			0 on success, -1 on failure 

 */

EXPORT_C int _setdefaultif_r(int *aErrno, const struct ifreq* aIfReq)

	{

	TInt err = KErrNone;

	RSocketServ& ss = Backend()->SockServSession();

	// connect to the Socket Server if necessary

	//NOTE: The following is not really threadsafe. The checking for the 

	//server handle and connecting to the same should be atomic, and should

	//be done everywhere else too

	if (ss.Handle() == 0)

		{

		err = SockServConnect(ss);

		if (err != KErrNone)

			{

			MapError(err, *aErrno);

			return -1;

			}

		}

	err = Backend()->setdefaultif(aIfReq);

	if(err != KErrNone)

		{

		MapError(err, *aErrno);

		return -1;

		}

	return 0;