xref: /aoo41x/main/sal/osl/w32/socket.cxx (revision 87d2adbc)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sal.hxx"

#include "system.h"

#include <osl/socket.h>
#include <osl/diagnose.h>
#include <rtl/alloc.h>

#include "sockimpl.h"

extern "C" {

/* defines for shutdown */
#ifdef GCC
#	define SD_RECEIVE 0
#	define SD_SEND 1
#	define SD_BOTH 2
#endif

/*
	oslSocketAddr is a pointer to a Berkeley struct sockaddr.
	I refrained from using sockaddr_in because of possible further
	extensions of this socket-interface (IP-NG?).
	The intention was to hide all Berkeley data-structures from
	direct access past the osl-interface.

	The current implementation is internet (IP) centered. All
	the constructor-functions (osl_create...) take parameters
	that will probably make sense only in the IP-environment
	(e.g. because of using the dotted-Addr-format).

	If the interface will be extended to host other protocol-
	families, I expect no externally visible changes in the
	existing functions. You'll probably need only new
	constructor-functions who take the different Addr
	formats into consideration (maybe a long dotted Addr
	or whatever).
*/

/*
  _Note_ that I rely on the fact that oslSocketAddr and struct sockaddr
  are the same! I don't like it very much but see no other easy way to
  conceal the struct sockaddr from the eyes of the user.
*/

#define OSL_INVALID_SOCKET		INVALID_SOCKET			/* WIN32 */
#define OSL_SOCKET_ERROR		SOCKET_ERROR			/* WIN32 */

/*****************************************************************************/
/* enum oslAddrFamily */
/*****************************************************************************/

/* map */
static DWORD FamilyMap[]= {
	AF_INET,					/* osl_Socket_FamilyInet */
	AF_IPX,						/* osl_Socket_FamilyIpx */
	0							/* osl_Socket_FamilyInvalid */
};

/* reverse map */
static oslAddrFamily osl_AddrFamilyFromNative(DWORD nativeType)
{
	oslAddrFamily i= (oslAddrFamily) 0;
	while(i != osl_Socket_FamilyInvalid)
	{
		if(FamilyMap[i] == nativeType)
			return i;
		i = (oslAddrFamily) ( (int)i + 1);
	}
	return i;
}

/* macros */
#define FAMILY_FROM_NATIVE(y) osl_AddrFamilyFromNative(y)
#define FAMILY_TO_NATIVE(x)	(short)FamilyMap[x]

/*****************************************************************************/
/* enum oslProtocol */
/*****************************************************************************/

/* map */
static DWORD ProtocolMap[]= {
	0,							/* osl_Socket_FamilyInet */
	NSPROTO_IPX,				/* osl_Socket_FamilyIpx */
	NSPROTO_SPX,				/* osl_Socket_ProtocolSpx */
	NSPROTO_SPXII,				/* osl_Socket_ProtocolSpx_ii */
	0							/* osl_Socket_ProtocolInvalid */
};

/* macros */
#define PROTOCOL_FROM_NATIVE(y) osl_ProtocolFromNative(y)
#define PROTOCOL_TO_NATIVE(x)	ProtocolMap[x]

/*****************************************************************************/
/* enum oslSocketType */
/*****************************************************************************/

/* map */
static DWORD TypeMap[]= {
	SOCK_STREAM,				/* osl_Socket_TypeStream */
	SOCK_DGRAM,					/* osl_Socket_TypeDgram  */
	SOCK_RAW,					/* osl_Socket_TypeRaw */
	SOCK_RDM,					/* osl_Socket_TypeRdm */
	SOCK_SEQPACKET,				/* osl_Socket_TypeSeqPacket */
	0							/* osl_Socket_TypeInvalid */
};

/* reverse map */
static oslSocketType osl_SocketTypeFromNative(DWORD nativeType)
{
	oslSocketType i= (oslSocketType)0;
	while(i != osl_Socket_TypeInvalid)
	{
		if(TypeMap[i] == nativeType)
			return i;
		i = (oslSocketType)((int)i+1);
	}
	return i;
}

/* macros */
#define TYPE_TO_NATIVE(x)		TypeMap[x]
#define TYPE_FROM_NATIVE(y)		osl_SocketTypeFromNative(y)

/*****************************************************************************/
/* enum oslSocketOption */
/*****************************************************************************/

/* map */
static DWORD OptionMap[]= {
	SO_DEBUG,					/* osl_Socket_OptionDebug */
	SO_ACCEPTCONN,				/* osl_Socket_OptionAcceptConn */
	SO_REUSEADDR,				/* osl_Socket_OptionReuseAddr */
	SO_KEEPALIVE,				/* osl_Socket_OptionKeepAlive */
	SO_DONTROUTE,				/* osl_Socket_OptionDontRoute */
	SO_BROADCAST,				/* osl_Socket_OptionBroadcast */
	SO_USELOOPBACK,				/* osl_Socket_OptionUseLoopback */
	SO_LINGER,					/* osl_Socket_OptionLinger */
	SO_OOBINLINE,				/* osl_Socket_OptionOOBinLine */
	SO_SNDBUF,					/* osl_Socket_OptionSndBuf */
	SO_RCVBUF,					/* osl_Socket_OptionRcvBuf */
	SO_SNDLOWAT,				/* osl_Socket_OptionSndLowat */
	SO_RCVLOWAT,				/* osl_Socket_OptionRcvLowat */
	SO_SNDTIMEO,				/* osl_Socket_OptionSndTimeo */
	SO_RCVTIMEO,				/* osl_Socket_OptionRcvTimeo */
	SO_ERROR,					/* osl_Socket_OptionError */
	SO_TYPE,					/* osl_Socket_OptionType */
	TCP_NODELAY,				/* osl_Socket_OptionTcpNoDelay */
	0							/* osl_Socket_OptionInvalid */
};

/* macros */
#define OPTION_TO_NATIVE(x)		OptionMap[x]
#define OPTION_FROM_NATIVE(y)	osl_SocketOptionFromNative(y)

/*****************************************************************************/
/* enum oslSocketOptionLevel */
/*****************************************************************************/

static DWORD OptionLevelMap[]= {
	SOL_SOCKET,					/* osl_Socket_LevelSocket */
	IPPROTO_TCP,				/* osl_Socket_LevelTcp */
	0							/* osl_invalid_SocketLevel */
};

/* macros */
#define OPTION_LEVEL_TO_NATIVE(x)		OptionLevelMap[x]
#define OPTION_LEVEL_FROM_NATIVE(y)		osl_SocketOptionLevelFromNative(y)

/*****************************************************************************/
/* enum oslSocketMsgFlag */
/*****************************************************************************/

static DWORD SocketMsgFlagMap[]= {
	0,							/* osl_Socket_MsgNormal */
	MSG_OOB,					/* osl_Socket_MsgOOB */
	MSG_PEEK,					/* osl_Socket_MsgPeek */
	MSG_DONTROUTE,				/* osl_Socket_MsgDontRoute */
	MSG_MAXIOVLEN				/* osl_Socket_MsgMaxIOVLen */
};

/* macros */
#define MSG_FLAG_TO_NATIVE(x)		SocketMsgFlagMap[x]
#define MSG_FLAG_FROM_NATIVE(y)		osl_SocketMsgFlagFromNative(y)

/*****************************************************************************/
/* enum oslSocketDirection */
/*****************************************************************************/

static DWORD SocketDirection[]= {
	SD_RECEIVE,					/* osl_Socket_DirRead */
	SD_SEND,					/* osl_Socket_DirWrite */
	SD_BOTH						/* osl_Socket_DirReadwrite */
};

/* macros */
#define DIRECTION_TO_NATIVE(x)		SocketDirection[x]
#define DIRECTION_FROM_NATIVE(y)	osl_SocketDirectionFromNative(y)

/*****************************************************************************/
/* enum oslSocketError */
/*****************************************************************************/

static int SocketError[]= {

	0,					/* no error */
	WSAENOTSOCK,			/* Socket operation on non-socket */
	WSAEDESTADDRREQ,		/* Destination address required */
	WSAEMSGSIZE,			/* Message too long */
	WSAEPROTOTYPE,			/* Protocol wrong type for socket */
	WSAENOPROTOOPT,		/* Protocol not available */
	WSAEPROTONOSUPPORT,	/* Protocol not supported */
	WSAESOCKTNOSUPPORT,	/* Socket type not supported */
	WSAEOPNOTSUPP,			/* Operation not supported on socket */
	WSAEPFNOSUPPORT,		/* Protocol family not supported */
	WSAEAFNOSUPPORT,		/* Address family not supported by */
							/* protocol family */
	WSAEADDRINUSE,			/* Address already in use */
	WSAEADDRNOTAVAIL,		/* Can't assign requested address */
	WSAENETDOWN,			/* Network is down */
	WSAENETUNREACH,		/* Network is unreachable */
	WSAENETRESET,			/* Network dropped connection because */
							/* of reset */
	WSAECONNABORTED,		/* Software caused connection abort */
	WSAECONNRESET,			/* Connection reset by peer */
	WSAENOBUFS,			/* No buffer space available */
	WSAEISCONN,			/* Socket is already connected */
	WSAENOTCONN,			/* Socket is not connected */
	WSAESHUTDOWN,			/* Can't send after socket shutdown */
	WSAETOOMANYREFS,		/* Too many references: can't splice */
	WSAETIMEDOUT,			/* Connection timed out */
	WSAECONNREFUSED,		/* Connection refused */
	WSAEHOSTDOWN,			/* Host is down */
	WSAEHOSTUNREACH,		/* No route to host */
	WSAEWOULDBLOCK,		/* call would block on non-blocking socket */
	WSAEALREADY,			/* operation already in progress */
	WSAEINPROGRESS		/* operation now in progress */
};

/* reverse map */
static oslSocketError osl_SocketErrorFromNative(int nativeType)
{
	oslSocketError i= (oslSocketError)0;

	while(i != osl_Socket_E_InvalidError)
	{
		if(SocketError[i] == nativeType)
			return i;

		i = (oslSocketError)( (int) i + 1);
	}
	return i;
}

/* macros */
#define ERROR_TO_NATIVE(x)		SocketError[x]
#define ERROR_FROM_NATIVE(y)	osl_SocketErrorFromNative(y)

/*****************************************************************************/
/* oslSocketDialupImpl */
/*****************************************************************************/
static oslSocketDialupImpl *pDialupImpl = NULL;

#if 0  /* INTERNAL DEBUG ONLY */
BOOL WINAPI __osl_autodial_Impl (DWORD dwFlags, DWORD dwReserved)
{
	return 0;
}

BOOL WINAPI __osl_autodialHangup_Impl (DWORD dwReserved)
{
	return 1;
}

BOOL WINAPI __osl_getConnectedState_Impl (LPDWORD lpdwFlags, DWORD dwReserved)
{
	if (lpdwFlags)
		*lpdwFlags = 0;
	return 0;
}
#endif /* INTERNAL DEBUG ONLY */

/*
 * __osl_createSocketDialupImpl.
 */
static oslSocketDialupImpl* __osl_createSocketDialupImpl (void)
{
	oslSocketDialupImpl *pImpl;
	pImpl = (oslSocketDialupImpl*)rtl_allocateZeroMemory( sizeof (oslSocketDialupImpl));

	InitializeCriticalSection (&pImpl->m_hMutex);

	return (pImpl);
}

/*
 * __osl_initSocketDialupImpl.
 */
static void __osl_initSocketDialupImpl (oslSocketDialupImpl *pImpl)
{
#ifdef SOCKET_USE_AUTODIAL
	if (pImpl)
	{
		HINSTANCE hModule;

		EnterCriticalSection (&pImpl->m_hMutex);

		hModule = LoadLibrary (INTERNET_MODULE_NAME);
		if (!(hModule <= (HINSTANCE)HINSTANCE_ERROR))
		{
			pImpl->m_pfnAttemptConnect = (INTERNETATTEMPTCONNECT)
				(GetProcAddress (hModule, "InternetAttemptConnect"));
			pImpl->m_pfnAutodial = (INTERNETAUTODIAL)
				(GetProcAddress (hModule, "InternetAutodial"));
			pImpl->m_pfnAutodialHangup = (INTERNETAUTODIALHANGUP)
				(GetProcAddress (hModule, "InternetAutodialHangup"));
			pImpl->m_pfnGetConnectedState = (INTERNETGETCONNECTEDSTATE)
				(GetProcAddress (hModule, "InternetGetConnectedState"));
			pImpl->m_hModule = hModule;
		}

		LeaveCriticalSection (&pImpl->m_hMutex);
	}
#else
    pImpl = pImpl; /* avoid warnings */
#endif
}

/*
 * __osl_destroySocketDialupImpl.
 */
static void __osl_destroySocketDialupImpl (oslSocketDialupImpl *pImpl)
{
	if (pImpl)
	{
		EnterCriticalSection (&pImpl->m_hMutex);

		if (pImpl->m_dwFlags & INTERNET_CONNECTION_HANGUP)
		{
			if (pImpl->m_pfnAutodialHangup)
			{
				(pImpl->m_pfnAutodialHangup)(0);
				pImpl->m_dwFlags &= ~INTERNET_CONNECTION_HANGUP;
			}
		}

		if (pImpl->m_hModule)
			FreeLibrary (pImpl->m_hModule);

		LeaveCriticalSection (&pImpl->m_hMutex);
		DeleteCriticalSection (&pImpl->m_hMutex);

		rtl_freeMemory (pImpl);
	}
}

/*
 * __osl_querySocketDialupImpl.
 */
static sal_Bool __osl_querySocketDialupImpl (void)
{
	sal_Bool result;

	if (pDialupImpl == NULL)
	{
		pDialupImpl = __osl_createSocketDialupImpl();
		__osl_initSocketDialupImpl (pDialupImpl);
	}

	EnterCriticalSection (&pDialupImpl->m_hMutex);

	result = sal_True;
	if (pDialupImpl->m_pfnGetConnectedState)
	{
		DWORD dwFlags = 0;

		result = (sal_Bool)(pDialupImpl->m_pfnGetConnectedState)(&dwFlags, 0);
		pDialupImpl->m_dwFlags |= dwFlags;
	}

	LeaveCriticalSection (&pDialupImpl->m_hMutex);
	return (result);
}

/*
 * __osl_attemptSocketDialupImpl.
 */
static sal_Bool __osl_attemptSocketDialupImpl (void)
{
	sal_Bool result;

	if (pDialupImpl == NULL)
	{
		pDialupImpl = __osl_createSocketDialupImpl();
		__osl_initSocketDialupImpl (pDialupImpl);
	}

	EnterCriticalSection (&pDialupImpl->m_hMutex);

	result = __osl_querySocketDialupImpl();
	if (!result)
	{
		result = sal_True;
		if (pDialupImpl->m_pfnAutodial)
		{
			result = (sal_Bool)(pDialupImpl->m_pfnAutodial)(0, 0);
			if (result)
				pDialupImpl->m_dwFlags |= INTERNET_CONNECTION_HANGUP;
			else
				WSASetLastError (WSAENETDOWN);
		}
	}

	LeaveCriticalSection (&pDialupImpl->m_hMutex);
	return (result);
}

/*****************************************************************************/
/* oslSocketImpl */
/*****************************************************************************/
static sal_uInt32 g_nSocketImpl = 0;

#if OSL_DEBUG_LEVEL > 1
static sal_uInt32 g_nSocketAddr = 0;
struct LeakWarning
{
	~LeakWarning()
	{
		if( g_nSocketImpl )
			OSL_TRACE( "sal_socket: %d socket instances leak\n" , g_nSocketImpl );
		if( g_nSocketAddr )
			OSL_TRACE( "sal_socket: %d socket address instances leak\n" , g_nSocketAddr );
	}
};
LeakWarning socketWarning;
#endif

/*
 * __osl_createSocketImpl.
 */
oslSocket __osl_createSocketImpl(SOCKET Socket)
{
	oslSocket pSockImpl = (oslSocket) rtl_allocateZeroMemory( sizeof(struct oslSocketImpl));
	pSockImpl->m_Socket = Socket;
	pSockImpl->m_nRefCount = 1;

	g_nSocketImpl++;

	return (pSockImpl);
}

/*
 * __osl_destroySocketImpl.
 */
void __osl_destroySocketImpl(oslSocketImpl *pImpl)
{
	if (pImpl)
	{
		if (--g_nSocketImpl == 0)
		{
			__osl_destroySocketDialupImpl (pDialupImpl);
			pDialupImpl = NULL;
		}
		rtl_freeMemory (pImpl);
	}
}
/*****************************************************************************/
static oslSocketAddr __osl_createSocketAddr(  )
{
	oslSocketAddr pAddr = (oslSocketAddr) rtl_allocateZeroMemory( sizeof( struct oslSocketAddrImpl ));
	pAddr->m_nRefCount = 1;
#if OSL_DEBUG_LEVEL > 1
	g_nSocketAddr ++;
#endif
	return pAddr;
}

static oslSocketAddr __osl_createSocketAddrWithFamily(
	oslAddrFamily family, sal_Int32 port, sal_uInt32 nAddr )
{
	OSL_ASSERT( family == osl_Socket_FamilyInet );

	oslSocketAddr pAddr = __osl_createSocketAddr();
	switch( family )
	{
	case osl_Socket_FamilyInet:
	{
		struct sockaddr_in* pInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);

		pInetAddr->sin_family = FAMILY_TO_NATIVE(osl_Socket_FamilyInet);
		pInetAddr->sin_addr.s_addr = nAddr;
		pInetAddr->sin_port = (sal_uInt16)(port&0xffff);
		break;
   	}
	default:
		pAddr->m_sockaddr.sa_family = FAMILY_TO_NATIVE(family);
	}
	return pAddr;
}

static oslSocketAddr __osl_createSocketAddrFromSystem( struct sockaddr *pSystemSockAddr )
{
	oslSocketAddr pAddr = __osl_createSocketAddr();
	memcpy( &(pAddr->m_sockaddr), pSystemSockAddr, sizeof( sockaddr ) );
	return pAddr;
}

static void __osl_destroySocketAddr( oslSocketAddr addr )
{
#if OSL_DEBUG_LEVEL > 1
	g_nSocketAddr --;
#endif
	rtl_freeMemory( addr );
}
/*****************************************************************************/
/* osl_createEmptySocketAddr */
/*****************************************************************************/
oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family)
{
	oslSocketAddr pAddr = 0;

	/* is it an internet-Addr? */
	if (Family == osl_Socket_FamilyInet)
	{
		pAddr = __osl_createSocketAddrWithFamily(Family, 0 , htonl(INADDR_ANY) );
	}
	else
	{
		pAddr = __osl_createSocketAddrWithFamily( Family , 0 , 0 );
	}

	return pAddr;
}

/*****************************************************************************/
/* osl_copySocketAddr */
/*****************************************************************************/
// @deprecated, to be removed
oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr)
{
	oslSocketAddr pCopy = 0;
	if (Addr)
	{
		pCopy = __osl_createSocketAddr();

		if (pCopy)
			memcpy(&(pCopy->m_sockaddr),&(Addr->m_sockaddr), sizeof(struct sockaddr));
	}
	return pCopy;
}

/*****************************************************************************/
/* osl_isEqualSocketAddr */
/*****************************************************************************/
sal_Bool SAL_CALL osl_isEqualSocketAddr(oslSocketAddr Addr1, oslSocketAddr Addr2)
{
	struct sockaddr* pAddr1= &(Addr1->m_sockaddr);
	struct sockaddr* pAddr2= &(Addr2->m_sockaddr);

	OSL_ASSERT(pAddr1);
	OSL_ASSERT(pAddr2);

	if (pAddr1->sa_family == pAddr2->sa_family)
	{
		switch (pAddr1->sa_family)
		{
			case AF_INET:
			{
				struct sockaddr_in* pInetAddr1= (struct sockaddr_in*)pAddr1;
				struct sockaddr_in* pInetAddr2= (struct sockaddr_in*)pAddr2;

				if ((pInetAddr1->sin_family == pInetAddr2->sin_family) &&
					(pInetAddr1->sin_addr.s_addr == pInetAddr2->sin_addr.s_addr) &&
					(pInetAddr1->sin_port == pInetAddr2->sin_port))
					return (sal_True);
			}

			default:
			{
				return (memcmp(pAddr1, Addr2, sizeof(struct sockaddr)) == 0);
			}
		}
	}

	return (sal_False);
}

/*****************************************************************************/
/* osl_createInetBroadcastAddr */
/*****************************************************************************/
oslSocketAddr SAL_CALL osl_createInetBroadcastAddr (
	rtl_uString *strDottedAddr,
	sal_Int32    Port)
{
	sal_uInt32          nAddr = OSL_INADDR_NONE;

	if (strDottedAddr && strDottedAddr->length)
	{
		/* Dotted host address for limited broadcast */
		rtl_String *pDottedAddr = NULL;

		rtl_uString2String (
			&pDottedAddr, strDottedAddr->buffer, strDottedAddr->length,
			RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);

		nAddr = inet_addr (pDottedAddr->buffer);
		rtl_string_release (pDottedAddr);
	}

	if (nAddr != OSL_INADDR_NONE)
	{
		/* Limited broadcast */
		nAddr = ntohl(nAddr);
		if (IN_CLASSA(nAddr))
		{
			nAddr &= IN_CLASSA_NET;
			nAddr |= IN_CLASSA_HOST;
		}
		else if (IN_CLASSB(nAddr))
		{
			nAddr &= IN_CLASSB_NET;
			nAddr |= IN_CLASSB_HOST;
		}
		else if (IN_CLASSC(nAddr))
		{
			nAddr &= IN_CLASSC_NET;
			nAddr |= IN_CLASSC_HOST;
		}
		else
		{
			/* No broadcast in class D */
			return ((oslSocketAddr)NULL);
		}
		nAddr = htonl(nAddr);
	}

	oslSocketAddr pAddr =
		__osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons( (sal_uInt16) Port), nAddr );
	return pAddr;
}

/*****************************************************************************/
/* osl_createInetSocketAddr */
/*****************************************************************************/
oslSocketAddr SAL_CALL osl_createInetSocketAddr (
	rtl_uString *strDottedAddr,
	sal_Int32    Port)
{
	DWORD Addr;
	rtl_String	*pDottedAddr=NULL;

	rtl_uString2String(
		&pDottedAddr, strDottedAddr->buffer, strDottedAddr->length,
		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);

	Addr= inet_addr (pDottedAddr->buffer);
	rtl_string_release (pDottedAddr);

	oslSocketAddr pAddr = 0;
	if(Addr != -1)
	{
		pAddr = __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons( (sal_uInt16)Port), Addr );
	}
	return pAddr;
}

oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence *pByteSeq )
{
	OSL_ASSERT( pAddr );
	OSL_ASSERT( pByteSeq );

	oslSocketResult res = osl_Socket_Error;
	if( pAddr && pByteSeq )
	{
		OSL_ASSERT( pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE( osl_Socket_FamilyInet ) );
		OSL_ASSERT( pByteSeq->nElements == 4 );
		struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
		memcpy( &(pSystemInetAddr->sin_addr) , pByteSeq->elements , 4 );
		res = osl_Socket_Ok;
	}
	return res;
}

/** Returns the addr field in the struct sockaddr. ppByteSeq is in network byteorder. *ppByteSeq may
	either be 0 or contain a constructed sal_Sequence.
 */
oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence **ppByteSeq )
{
	OSL_ASSERT( pAddr );
	OSL_ASSERT( ppByteSeq );

	oslSocketResult res = osl_Socket_Error;
	if( pAddr && ppByteSeq )
	{
		struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
		rtl_byte_sequence_constructFromArray( ppByteSeq , (sal_Int8 *) &(pSystemInetAddr->sin_addr),4);
		res = osl_Socket_Ok;
	}
	return res;
}

/*****************************************************************************/
/* oslHostAddr */
/*****************************************************************************/
struct oslHostAddrImpl {
	rtl_uString     *pHostName;
	oslSocketAddr   pSockAddr;
} ;

static oslHostAddr __osl_hostentToHostAddr (const struct hostent *he)
{
	oslHostAddr pAddr= NULL;
	oslSocketAddr pSocketAddr = 0;

	rtl_uString     *cn= NULL;

	if ((he == NULL) || (he->h_name == NULL) || (he->h_addr_list[0] == NULL))
		return ((oslHostAddr)NULL);

	rtl_string2UString(
		&cn, he->h_name, strlen(he->h_name),
		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
    OSL_ASSERT(cn != 0);

	pSocketAddr = __osl_createSocketAddr();

	if (pSocketAddr == NULL)
	{
		rtl_uString_release(cn);
		return ((oslHostAddr)NULL);
	}

	pSocketAddr->m_sockaddr.sa_family = he->h_addrtype;
	if (pSocketAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
	{
		struct sockaddr_in *sin= (struct sockaddr_in *)&(pSocketAddr->m_sockaddr);
		memcpy (
			&(sin->sin_addr.s_addr),
			he->h_addr_list[0],
			he->h_length);
	}
	else
	{
		/* unknown address family */
		/* future extensions for new families might be implemented here */

        OSL_TRACE("_osl_hostentToHostAddr(): unknown address family.\n");
		OSL_ASSERT(sal_False);

		__osl_destroySocketAddr( pSocketAddr );
		rtl_uString_release(cn);
		return ((oslHostAddr)NULL);
	}

	pAddr= (oslHostAddr )rtl_allocateMemory (sizeof (struct oslHostAddrImpl));

	if (pAddr == NULL)
	{
		__osl_destroySocketAddr( pSocketAddr );
		rtl_uString_release(cn);
		return ((oslHostAddr)NULL);
	}

	pAddr->pHostName= cn;
	pAddr->pSockAddr= pSocketAddr;

	return pAddr;
}

/*****************************************************************************/
/* osl_createHostAddr */
/*****************************************************************************/
oslHostAddr SAL_CALL osl_createHostAddr (
	rtl_uString         *strHostname,
	const oslSocketAddr  pSocketAddr)
{
	oslHostAddr pAddr;
	rtl_uString     *cn= NULL;

	if ((strHostname == NULL)  || (strHostname->length == 0) || (pSocketAddr == NULL))
		return ((oslHostAddr)NULL);

	rtl_uString_newFromString( &cn, strHostname);

	if ( ! pSocketAddr )
	{
		rtl_uString_release(cn);
		return ((oslHostAddr)NULL);
	}

	pAddr= (oslHostAddr)rtl_allocateMemory (sizeof (struct oslHostAddrImpl));

	if (pAddr == NULL)
	{
		rtl_uString_release(cn);
		return ((oslHostAddr)NULL);
	}

	pAddr->pHostName= cn;
	pAddr->pSockAddr= osl_copySocketAddr( pSocketAddr );

	return ((oslHostAddr)pAddr);
}

/*****************************************************************************/
/* osl_createHostAddrByName */
/*****************************************************************************/
oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *strHostname)
{
	if ((strHostname == NULL) || (strHostname->length == 0))
		return ((oslHostAddr)NULL);

	if (__osl_attemptSocketDialupImpl())
	{
		struct hostent *he;
		rtl_String     *Hostname= NULL;

		rtl_uString2String(
			&Hostname, strHostname->buffer, strHostname->length,
			RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);

		he= gethostbyname (Hostname->buffer);

		rtl_string_release (Hostname);
		return __osl_hostentToHostAddr (he);
	}
	return ((oslHostAddr)NULL);
}

/*****************************************************************************/
/* osl_createHostAddrByAddr */
/*****************************************************************************/
oslHostAddr SAL_CALL osl_createHostAddrByAddr(const oslSocketAddr pAddr)
{
	if (pAddr == NULL)
		return ((oslHostAddr)NULL);

	if (pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
	{
		const struct sockaddr_in *sin= (const struct sockaddr_in *)&(pAddr->m_sockaddr);

		if (sin->sin_addr.s_addr == htonl(INADDR_ANY))
			return ((oslHostAddr)NULL);

		if (__osl_attemptSocketDialupImpl())
		{
			struct hostent *he;
			he= gethostbyaddr ((const sal_Char *)&(sin->sin_addr),
							   sizeof (sin->sin_addr),
							   sin->sin_family);
			return __osl_hostentToHostAddr (he);
		}
	}

	return ((oslHostAddr)NULL);
}

/*****************************************************************************/
/* osl_copyHostAddr */
/*****************************************************************************/
oslHostAddr SAL_CALL osl_copyHostAddr(const oslHostAddr Addr)
{
	oslHostAddr pAddr= (oslHostAddr)Addr;

	if (pAddr)
		return osl_createHostAddr (pAddr->pHostName, pAddr->pSockAddr);
	else
		return ((oslHostAddr)NULL);
}

/*****************************************************************************/
/* osl_getHostnameOfHostAddr */
/*****************************************************************************/
void SAL_CALL osl_getHostnameOfHostAddr(
	const oslHostAddr pAddr, rtl_uString **strHostname)
{
	if (pAddr)
		rtl_uString_assign (strHostname, pAddr->pHostName);
	else
		rtl_uString_new (strHostname);
}

/*****************************************************************************/
/* osl_getSocketAddrOfHostAddr */
/*****************************************************************************/
oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr(const oslHostAddr pAddr)
{
	if (pAddr)
		return (const oslSocketAddr)(pAddr->pSockAddr);
	else
		return NULL;
}

/*****************************************************************************/
/* osl_destroyHostAddr */
/*****************************************************************************/
void SAL_CALL osl_destroyHostAddr(oslHostAddr pAddr)
{
	if (pAddr)
	{
		if (pAddr->pHostName)
			rtl_uString_release (pAddr->pHostName);
		if (pAddr->pSockAddr)
			osl_destroySocketAddr( pAddr->pSockAddr );

		rtl_freeMemory (pAddr);
	}
}

/*****************************************************************************/
/* osl_getLocalHostname */
/*****************************************************************************/
oslSocketResult SAL_CALL osl_getLocalHostname (rtl_uString **strLocalHostname)
{
	static sal_Unicode LocalHostname[256] = {0};

	if (rtl_ustr_getLength(LocalHostname) == 0)
	{
		sal_Char Host[256]= "";
		if (gethostname(Host, sizeof(Host)) == 0)
		{
			/* check if we have an FQDN */
	    	if (strchr(Host, '.') == NULL)
	        {
				oslHostAddr pAddr;
				rtl_uString     *hostName= NULL;

				rtl_string2UString(
					&hostName, Host, strlen(Host),
					RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
                OSL_ASSERT(hostName != 0);

				/* no, determine it via dns */
				pAddr = osl_createHostAddrByName(hostName);
				rtl_uString_release (hostName);

				if (pAddr && pAddr->pHostName)
					memcpy(LocalHostname, pAddr->pHostName->buffer, sizeof(sal_Unicode)*(rtl_ustr_getLength(pAddr->pHostName->buffer)+1));
				else
					memset(LocalHostname, 0, sizeof(LocalHostname));

				osl_destroyHostAddr ((oslHostAddr)pAddr);
			}
		}
	}

	if (rtl_ustr_getLength(LocalHostname) > 0)
	{
		rtl_uString_newFromStr (strLocalHostname, LocalHostname);
		return osl_Socket_Ok;
	}

	return osl_Socket_Error;
}

/*****************************************************************************/
/* osl_resolveHostname */
/*****************************************************************************/
oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString* strHostname)
{
	oslHostAddr pAddr=
		(oslHostAddr )osl_createHostAddrByName (strHostname);
	if (pAddr)
	{
		oslSocketAddr SockAddr = osl_copySocketAddr( pAddr->pSockAddr );
		osl_destroyHostAddr(pAddr);
		return (SockAddr);
	}
	return ((oslSocketAddr)NULL);
}

/*****************************************************************************/
/* osl_getServicePort */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_getServicePort (
	rtl_uString* strServicename,
	rtl_uString* strProtocol)
{
	struct servent* ps;

	rtl_String *str_Servicename=NULL;
	rtl_String *str_Protocol=NULL;

	rtl_uString2String(
		&str_Servicename,
		rtl_uString_getStr(strServicename),
		rtl_uString_getLength(strServicename),
		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
	rtl_uString2String(
		&str_Protocol,
		rtl_uString_getStr(strProtocol),
		rtl_uString_getLength(strProtocol),
		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);

	ps= getservbyname(
		rtl_string_getStr(str_Servicename),
		rtl_string_getStr(str_Protocol));

	rtl_string_release( str_Servicename );
	rtl_string_release( str_Protocol );

	if (ps != 0)
		return ntohs(ps->s_port);

	return OSL_INVALID_PORT;
}

/*****************************************************************************/
/* osl_destroySocketAddr */
/*****************************************************************************/
void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr)
{
	__osl_destroySocketAddr( pAddr );
}

/*****************************************************************************/
/* osl_getFamilyOfSocketAddr */
/*****************************************************************************/
oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
{
	if (pAddr)
		return FAMILY_FROM_NATIVE(pAddr->m_sockaddr.sa_family);
	else
		return osl_Socket_FamilyInvalid;
}

/*****************************************************************************/
/* osl_getInetPortOfSocketAddr */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
{
	if( pAddr )
	{
		struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);

		if ( (pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet)))
			return ntohs(pSystemInetAddr->sin_port);
	}
	return OSL_INVALID_PORT;
}

/*****************************************************************************/
/* osl_setInetPortOfSocketAddr */
/*****************************************************************************/
sal_Bool SAL_CALL osl_setInetPortOfSocketAddr (
	oslSocketAddr pAddr,
	sal_Int32     Port)
{
	if (pAddr == NULL)
		return sal_False;

	struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);

	if (pSystemInetAddr->sin_family != FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
		return sal_False;

	pSystemInetAddr->sin_port= htons((short)Port);
	return sal_True;
}

/*****************************************************************************/
/* osl_getHostnameOfSocketAddr */
/*****************************************************************************/
oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr (
	oslSocketAddr   Addr,
	rtl_uString   **strHostName)
{
	oslHostAddr pAddr= osl_createHostAddrByAddr (Addr);

	if (pAddr)
	{
		rtl_uString_newFromString(strHostName, pAddr->pHostName);

		osl_destroyHostAddr(pAddr);

		return osl_Socket_Ok;
	}

	return osl_Socket_Error;
}

/*****************************************************************************/
/* osl_getDottedInetAddrOfSocketAddr */
/*****************************************************************************/
oslSocketResult	SAL_CALL osl_getDottedInetAddrOfSocketAddr (
	oslSocketAddr   pAddr,
	rtl_uString   **strDottedInetAddr)
{
	sal_Char           *pDotted;

	if (pAddr == NULL)
		return osl_Socket_Error;

	struct sockaddr_in *pSystemInetAddr = (struct sockaddr_in*) &(pAddr->m_sockaddr);
	if (pSystemInetAddr->sin_family != FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
		return osl_Socket_Error;

	pDotted = inet_ntoa (pSystemInetAddr->sin_addr);
	rtl_string2UString(
		strDottedInetAddr, pDotted, strlen (pDotted),
		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
    OSL_ASSERT(*strDottedInetAddr != 0);

	return osl_Socket_Ok;
}

/*****************************************************************************/
/* osl_createSocket  */
/*****************************************************************************/
oslSocket SAL_CALL osl_createSocket (
	oslAddrFamily Family,
	oslSocketType Type,
	oslProtocol   Protocol)
{
	/* alloc memory */
	oslSocket pSocket = __osl_createSocketImpl(0);

	if (pSocket == NULL)
		return 0;

	/* create socket */
	pSocket->m_Socket= socket(FAMILY_TO_NATIVE(Family),
								TYPE_TO_NATIVE(Type),
								PROTOCOL_TO_NATIVE(Protocol));

	/* creation failed => free memory */
	if(pSocket->m_Socket == OSL_INVALID_SOCKET)
	{
		__osl_destroySocketImpl(pSocket);
		pSocket= 0;
	}
	else
	{
		pSocket->m_Flags			= 0;
		pSocket->m_CloseCallback	= NULL;
		pSocket->m_CallbackArg	= NULL;
	}

	return pSocket;
}

void SAL_CALL osl_acquireSocket( oslSocket pSocket )
{
	osl_incrementInterlockedCount( &(pSocket->m_nRefCount) );
}

void SAL_CALL osl_releaseSocket( oslSocket pSocket )
{
	if( pSocket && 0 == osl_decrementInterlockedCount( &(pSocket->m_nRefCount) ) )
	{
		osl_closeSocket( pSocket );
		__osl_destroySocketImpl( pSocket );
	}
}

/*****************************************************************************/
/* osl_closeSocket  */
/*****************************************************************************/
void SAL_CALL osl_closeSocket(oslSocket pSocket)
{
	/* socket already invalid */
	if(pSocket==0)
		return;

	/* close */
	closesocket(pSocket->m_Socket);

	pSocket->m_Socket = OSL_INVALID_SOCKET;

	/* registrierten Callback ausfuehren */
	if (pSocket->m_CloseCallback != NULL)
	{
		pSocket->m_CloseCallback(pSocket->m_CallbackArg);
	}
}

/*****************************************************************************/
/* osl_getLocalAddrOfSocket  */
/* Note that I rely on the fact that oslSocketAddr and struct sockaddr */
/* are the same! I don't like it very much but see no other easy way */
/* to conceal the struct sockaddr from the eyes of the user. */
/*****************************************************************************/
oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket)
{
	struct sockaddr Addr;
	int             AddrLen;

	if (pSocket == NULL) /* ENOTSOCK */
		return ((oslSocketAddr)NULL);

	AddrLen= sizeof(struct sockaddr);

	if (getsockname(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
		return ((oslSocketAddr)NULL);

	oslSocketAddr pAddr = __osl_createSocketAddrFromSystem( &Addr );
	return pAddr;
}

/*****************************************************************************/
/* osl_getPeerAddrOfSocket  */
/*****************************************************************************/
oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
{
	struct sockaddr Addr;
	int             AddrLen;

	if (pSocket == NULL) /* ENOTSOCK */
		return ((oslSocketAddr)NULL);

	AddrLen= sizeof(struct sockaddr);

	if (getpeername(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
		return ((oslSocketAddr)NULL);

	oslSocketAddr pAddr = __osl_createSocketAddrFromSystem( &Addr );
	return pAddr;
}

/*****************************************************************************/
/* osl_bindAddrToSocket  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_bindAddrToSocket ( oslSocket pSocket, oslSocketAddr pAddr)
{
	OSL_ASSERT( pAddr );

	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	return (bind(pSocket->m_Socket,
				 &(pAddr->m_sockaddr),
				 sizeof(struct sockaddr)) != OSL_SOCKET_ERROR);
}

/*****************************************************************************/
/* osl_connectSocketTo  */
/*****************************************************************************/
oslSocketResult SAL_CALL osl_connectSocketTo (
	oslSocket        pSocket,
	oslSocketAddr    pAddr,
	const TimeValue* pTimeout)
{

	if (pSocket == NULL) /* ENOTSOCK */
		return osl_Socket_Error;

	if (pAddr == NULL) /* EDESTADDRREQ */
		return osl_Socket_Error;

	if (!__osl_attemptSocketDialupImpl()) /* ENETDOWN */
		return osl_Socket_Error;

	if (pTimeout == NULL)
	{
		if(connect(pSocket->m_Socket,
				   &(pAddr->m_sockaddr),
					sizeof(struct sockaddr)) == OSL_SOCKET_ERROR)
			return osl_Socket_Error;
		else
			return osl_Socket_Ok;
	}
	else
	{
		fd_set          fds;
		int	            error;
	    struct timeval  tv;
		unsigned long   Param;
		oslSocketResult Result= osl_Socket_Ok;

		if (pSocket->m_Flags & OSL_SOCKET_FLAGS_NONBLOCKING)
	    {
			if (connect(pSocket->m_Socket,
			    	    &(pAddr->m_sockaddr),
						sizeof(struct sockaddr)) == OSL_SOCKET_ERROR)
			{
			    switch (WSAGetLastError())
			    {
					case WSAEWOULDBLOCK:
					case WSAEINPROGRESS:
						return osl_Socket_InProgress;

					default:
						return osl_Socket_Error;
				}
			}
			else
				return osl_Socket_Ok;
		}

		/* set socket temporarily to non-blocking */
		Param= 1;
		OSL_VERIFY(ioctlsocket(
			pSocket->m_Socket, FIONBIO, &Param) != OSL_SOCKET_ERROR);

		/* initiate connect */
		if (connect(pSocket->m_Socket,
		     	    &(pAddr->m_sockaddr),
				    sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
		{
		   /* immediate connection */

			Param= 0;
			ioctlsocket(pSocket->m_Socket, FIONBIO, &Param);

			return osl_Socket_Ok;
	    }
		else
		{
			error = WSAGetLastError();

		    /* really an error or just delayed? */
		    if (error != WSAEWOULDBLOCK && error != WSAEINPROGRESS)
		    {
			     Param= 0;
			     ioctlsocket(pSocket->m_Socket, FIONBIO, &Param);

			     return osl_Socket_Error;
		    }
		}

		/* prepare select set for socket  */
		FD_ZERO(&fds);
		FD_SET(pSocket->m_Socket, &fds);

		/* divide milliseconds into seconds and microseconds */
		tv.tv_sec=	pTimeout->Seconds;
		tv.tv_usec=	pTimeout->Nanosec / 1000L;

		/* select */
	    error= select(pSocket->m_Socket+1,
		 		      0,
					  &fds,
					  0,
					  &tv);

		if (error > 0)  /* connected */
		{
			OSL_POSTCOND(
				FD_ISSET(pSocket->m_Socket, &fds),
				"osl_connectSocketTo(): select returned but socket not set\n");

			Result= osl_Socket_Ok;

		}
		else if(error < 0)  /* error */
		{
		    /* errno == EBADF: most probably interrupted by close() */
		    if(WSAGetLastError() == WSAEBADF)
			{
			    /* do not access pSockImpl because it is about to be or */
			    /* already destroyed */
			    return osl_Socket_Interrupted;
			}
			else
			    Result= osl_Socket_Error;

		}
		else    /* timeout */
			Result= osl_Socket_TimedOut;


		/* clean up */
		Param= 0;
		ioctlsocket(pSocket->m_Socket, FIONBIO, &Param);

		return Result;
	}
}

/*****************************************************************************/
/* osl_listenOnSocket  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_listenOnSocket (
	oslSocket  pSocket,
	sal_Int32  MaxPendingConnections)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	return (listen(pSocket->m_Socket,
				   MaxPendingConnections == -1 ?
				   SOMAXCONN :
				   MaxPendingConnections) != OSL_SOCKET_ERROR);
}

/*****************************************************************************/
/* osl_acceptConnectionOnSocket  */
/*****************************************************************************/
oslSocket SAL_CALL osl_acceptConnectionOnSocket (
	oslSocket      pSocket,
	oslSocketAddr* ppAddr)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return ((oslSocket)NULL);

	SOCKET          Connection;
	if(ppAddr)
	{
		if( *ppAddr )
		{
			osl_destroySocketAddr( *ppAddr );
			*ppAddr = 0;
		}
		int AddrLen= sizeof(struct sockaddr);

		/* user wants to know peer Addr */
		struct sockaddr Addr;

		Connection=	accept(pSocket->m_Socket, &Addr, &AddrLen);
		OSL_ASSERT(AddrLen == sizeof(struct sockaddr));

		if(Connection != OSL_SOCKET_ERROR)
			*ppAddr= __osl_createSocketAddrFromSystem(&Addr);
		else
			*ppAddr = NULL;
	}
	else
	{
		/* user is not interested in peer-addr */
		Connection=	accept(pSocket->m_Socket, 0, 0);
	}

	/* accept failed? */
	if(Connection == OSL_SOCKET_ERROR)
		return ((oslSocket)NULL);

	/* alloc memory */
	oslSocket  pConnectionSocket;
	pConnectionSocket= __osl_createSocketImpl(Connection);

	pConnectionSocket->m_Flags			= 0;
	pConnectionSocket->m_CloseCallback	= NULL;
	pConnectionSocket->m_CallbackArg	= NULL;

	return pConnectionSocket;
}

/*****************************************************************************/
/* osl_receiveSocket  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_receiveSocket (
	oslSocket        pSocket,
	void*            pBuffer,
	sal_uInt32       BytesToRead,
	oslSocketMsgFlag Flag)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return osl_Socket_Error;

	return recv(pSocket->m_Socket,
				(sal_Char*)pBuffer,
				BytesToRead,
				MSG_FLAG_TO_NATIVE(Flag));
}

/*****************************************************************************/
/* osl_receiveFromSocket  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_receiveFromSocket (
	oslSocket        pSocket,
	oslSocketAddr    SenderAddr,
	void*            pBuffer,
	sal_uInt32       BufferSize,
	oslSocketMsgFlag Flag)
{
	struct sockaddr *pSystemSockAddr = 0;
	int AddrLen = 0;
	if( SenderAddr )
	{
		AddrLen = sizeof( struct sockaddr );
		pSystemSockAddr = &(SenderAddr->m_sockaddr);
	}

	if (pSocket == NULL) /* ENOTSOCK */
		return osl_Socket_Error;

	return recvfrom(pSocket->m_Socket,
					 (sal_Char*)pBuffer,
					 BufferSize,
					 MSG_FLAG_TO_NATIVE(Flag),
					 pSystemSockAddr,
					 &AddrLen);
}

/*****************************************************************************/
/* osl_sendSocket  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_sendSocket (
	oslSocket        pSocket,
	const void*      pBuffer,
	sal_uInt32       BytesToSend,
	oslSocketMsgFlag Flag)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return osl_Socket_Error;

	return send(pSocket->m_Socket,
				(sal_Char*)pBuffer,
				BytesToSend,
				MSG_FLAG_TO_NATIVE(Flag));
}

/*****************************************************************************/
/* osl_sendToSocket  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_sendToSocket (
	oslSocket        pSocket,
	oslSocketAddr    ReceiverAddr,
	const void*      pBuffer,
	sal_uInt32       BytesToSend,
	oslSocketMsgFlag Flag)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return osl_Socket_Error;

	/* ReceiverAddr might be 0 when used on a connected socket. */
	/* Then sendto should behave like send. */

	struct sockaddr *pSystemSockAddr = 0;
	if( ReceiverAddr )
		pSystemSockAddr = &(ReceiverAddr->m_sockaddr);

	return sendto(pSocket->m_Socket,
				  (sal_Char*)pBuffer,
				  BytesToSend,
				  MSG_FLAG_TO_NATIVE(Flag),
				  pSystemSockAddr,
				  pSystemSockAddr == 0 ? 0 : sizeof(struct sockaddr));
}

/*****************************************************************************/
/* osl_readSocket  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_readSocket( oslSocket pSocket, void *pBuffer, sal_Int32 n )
{
	sal_uInt8 * Ptr = (sal_uInt8 *)pBuffer;

	OSL_ASSERT( pSocket);

	/* loop until all desired bytes were read or an error occured */
	sal_uInt32 BytesRead= 0;
	sal_uInt32 BytesToRead= n;
	while (BytesToRead > 0)
	{
		sal_Int32 RetVal;
		RetVal= osl_receiveSocket(pSocket,
								   Ptr,
								   BytesToRead,
								   osl_Socket_MsgNormal);

		/* error occured? */
		if(RetVal <= 0)
		{
			break;
		}

		BytesToRead -= RetVal;
		BytesRead += RetVal;
		Ptr += RetVal;
	}

	return BytesRead;
}

/*****************************************************************************/
/* osl_writeSocket  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_writeSocket( oslSocket pSocket, const void *pBuffer, sal_Int32 n )
{
    OSL_ASSERT( pSocket );

	/* loop until all desired bytes were send or an error occured */
	sal_uInt32 BytesSend= 0;
	sal_uInt32 BytesToSend= n;
	sal_uInt8 *Ptr = ( sal_uInt8 * )pBuffer;
	while (BytesToSend > 0)
	{
		sal_Int32 RetVal;

		RetVal= osl_sendSocket( pSocket,Ptr,BytesToSend,osl_Socket_MsgNormal);

		/* error occured? */
		if(RetVal <= 0)
		{
			break;
		}

		BytesToSend -= RetVal;
		BytesSend += RetVal;
		Ptr += RetVal;

	}
	return BytesSend;
}


/*****************************************************************************/
/* osl_isReceiveReady  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_isReceiveReady (
	oslSocket        pSocket,
	const TimeValue* pTimeout)
{
	fd_set         fds;
	struct timeval tv;

	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	FD_ZERO(&fds);
	FD_SET(pSocket->m_Socket, &fds);

	if (pTimeout)
	{
		tv.tv_sec  = pTimeout->Seconds;
		tv.tv_usec = pTimeout->Nanosec / 1000L;
	}

	return (select(pSocket->m_Socket + 1,		/* no of sockets to monitor */
				   &fds,						/* check read operations */
				   0,							/* check write ops */
				   0,							/* ckeck for OOB */
				   (pTimeout) ? &tv : 0)==1);	/* use timeout? */
}

/*****************************************************************************/
/* osl_isSendReady  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_isSendReady (
	oslSocket        pSocket,
	const TimeValue* pTimeout)
{
	fd_set         fds;
	struct timeval tv;

	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	FD_ZERO(&fds);
	FD_SET(pSocket->m_Socket, &fds);

	if (pTimeout)
	{
		tv.tv_sec  = pTimeout->Seconds;
		tv.tv_usec = pTimeout->Nanosec / 1000L;
	}

	return (select(pSocket->m_Socket + 1,		/* no of sockets to monitor */
				   0,							/* check read operations */
				   &fds,						/* check write ops */
				   0,							/* ckeck for OOB */
				   (pTimeout) ? &tv : 0)==1);	/* use timeout? */
}

/*****************************************************************************/
/* osl_isExceptionPending  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_isExceptionPending (
	oslSocket        pSocket,
	const TimeValue* pTimeout)
{
	fd_set         fds;
	struct timeval tv;

	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	FD_ZERO(&fds);
	FD_SET(pSocket->m_Socket, &fds);

	if (pTimeout)
	{
		tv.tv_sec  = pTimeout->Seconds;
		tv.tv_usec = pTimeout->Nanosec / 1000L;
	}

	return (select(pSocket->m_Socket + 1,	    /* no of sockets to monitor */
				   0,							/* check read operations */
				   0,							/* check write ops */
				   &fds,						/* ckeck for OOB */
				   (pTimeout) ? &tv : 0)==1);	/* use timeout? */
}

/*****************************************************************************/
/* osl_shutdownSocket  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_shutdownSocket (
	oslSocket          pSocket,
	oslSocketDirection Direction)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	return (shutdown(pSocket->m_Socket, DIRECTION_TO_NATIVE(Direction))==0);
}

/*****************************************************************************/
/* osl_getSocketOption  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_getSocketOption (
	oslSocket            pSocket,
	oslSocketOptionLevel Level,
	oslSocketOption      Option,
	void*                pBuffer,
	sal_uInt32           BufferLen)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return osl_Socket_Error;

	if (getsockopt(pSocket->m_Socket,
	     		   OPTION_LEVEL_TO_NATIVE(Level),
				   OPTION_TO_NATIVE(Option),
				   (sal_Char*)pBuffer,
				   (int*)&BufferLen) == -1)
	{
		return -1;
	}

	return (sal_Int32)BufferLen;
}

/*****************************************************************************/
/* osl_setSocketOption  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_setSocketOption (
	oslSocket            pSocket,
	oslSocketOptionLevel Level,
	oslSocketOption      Option,
	void*                pBuffer,
	sal_uInt32           BufferLen)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	return(setsockopt(pSocket->m_Socket,
					  OPTION_LEVEL_TO_NATIVE(Level),
					  OPTION_TO_NATIVE(Option),
					  (sal_Char*)pBuffer,
					  BufferLen) == 0);
}

/*****************************************************************************/
/* osl_enableNonBlockingMode  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_enableNonBlockingMode ( oslSocket pSocket, sal_Bool  On)
{
	unsigned long  Param= On ? 1 : 0;

	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	pSocket->m_Flags = Param ?
		(pSocket->m_Flags |  OSL_SOCKET_FLAGS_NONBLOCKING) :
		(pSocket->m_Flags & ~OSL_SOCKET_FLAGS_NONBLOCKING) ;

	return (
		ioctlsocket(pSocket->m_Socket, FIONBIO, &Param) != OSL_SOCKET_ERROR);
}

/*****************************************************************************/
/* osl_isNonBlockingMode  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
{
	if (pSocket == NULL) /* ENOTSOCK */
		return sal_False;

	return (sal_Bool)((pSocket->m_Flags & OSL_SOCKET_FLAGS_NONBLOCKING) != 0);
}

/*****************************************************************************/
/* osl_getSocketType  */
/*****************************************************************************/
oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
{
	int            Type=0;
	int            TypeSize= sizeof(Type);

	if (pSocket == NULL) /* ENOTSOCK */
		return osl_Socket_TypeInvalid;

	if(getsockopt(pSocket->m_Socket,
				  OPTION_LEVEL_TO_NATIVE(osl_Socket_LevelSocket),
				  OPTION_TO_NATIVE(osl_Socket_OptionType),
				  (sal_Char *)&Type,
				  &TypeSize) == -1)
	{
		/* error */
		return osl_Socket_TypeInvalid;
	}

	return TYPE_FROM_NATIVE(Type);
}

/*****************************************************************************/
/* osl_getLastSocketErrorDescription  */
/*****************************************************************************/
void SAL_CALL osl_getLastSocketErrorDescription (
	oslSocket  /*Socket*/,
	rtl_uString	**strError)
{
	int error;

	switch(error = WSAGetLastError())
	{
		case WSAENOTSOCK:
			rtl_uString_newFromAscii (strError, "WSAENOTSOCK, Socket operation on non-socket. A socket created in one process is used by another process.");
            break;

        case WSAEDESTADDRREQ:
			rtl_uString_newFromAscii (strError, "WSAEDESTADDRREQ, Destination Addr required");
            break;

        case WSAEMSGSIZE:
            rtl_uString_newFromAscii (strError, "WSAEMSGSIZE, Message too long");
            break;

        case WSAEPROTOTYPE:
			rtl_uString_newFromAscii (strError, "WSAEPROTOTYPE, Protocol wrong type for socket");
            break;

        case WSAENOPROTOOPT:
			rtl_uString_newFromAscii (strError, "WSAENOPROTOOPT, Protocol not available");
            break;

        case WSAEPROTONOSUPPORT:
			rtl_uString_newFromAscii (strError, "WSAEPROTONOSUPPORT, Protocol not supported");
            break;

        case WSAESOCKTNOSUPPORT:
			rtl_uString_newFromAscii (strError, "WSAESOCKTNOSUPPORT, Socket type not supported");
            break;

        case WSAEOPNOTSUPP:
			rtl_uString_newFromAscii (strError, "WSAEOPNOTSUPP, Operation not supported on socket");
            break;

        case WSAEPFNOSUPPORT:
			rtl_uString_newFromAscii (strError, "WSAEPFNOSUPPORT, Protocol family not supported");
            break;

        case WSAEAFNOSUPPORT:
			rtl_uString_newFromAscii (strError, "WSEAFNOSUPPORT, Addr family not supported by protocol family");
            break;

        case WSAEADDRINUSE:
			rtl_uString_newFromAscii (strError, "WSAEADDRINUSE, Triggered by bind() because a process went down without closing a socket.");
            break;

        case WSAEADDRNOTAVAIL:
			rtl_uString_newFromAscii (strError, "WSAEADDRNOTAVAIL, Can't assign requested Addr");
            break;

        case WSAENETDOWN:
			rtl_uString_newFromAscii (strError, "WSAENETDOWN, Network is down");
            break;

        case WSAENETUNREACH:
			rtl_uString_newFromAscii (strError, "WSAENETUNREACH, Network is unreachable");
            break;

        case WSAENETRESET:
			rtl_uString_newFromAscii (strError, "WSAENETRESET, Network dropped connection or reset");
            break;

        case WSAECONNABORTED:
			rtl_uString_newFromAscii (strError, "WSAECONNABORTED, Software caused connection abort");
            break;

        case WSAECONNRESET:
			rtl_uString_newFromAscii (strError, "WSAECONNRESET, Connection reset by peer");
            break;

        case WSAENOBUFS:
			rtl_uString_newFromAscii (strError, "WSAENOBUFS, No buffer space available.");
            break;

        case WSAEISCONN:
			rtl_uString_newFromAscii (strError, "WSAEISCONN, Socket is already connected");
            break;

        case WSAENOTCONN:
			rtl_uString_newFromAscii (strError, "WSAENOTCONN, Socket is not connected");
            break;

        case WSAESHUTDOWN:
			rtl_uString_newFromAscii (strError, "WSAESHUTDOWN, Can't send after socket shutdown");
            break;

        case WSAETIMEDOUT:
			rtl_uString_newFromAscii (strError, "WSAETIMEDOUT, Connection timed out");
            break;

        case WSAECONNREFUSED:
			rtl_uString_newFromAscii (strError, "WSAECONNREFUSED, Connection refused");
            break;

        case WSAEHOSTDOWN:
			rtl_uString_newFromAscii (strError, "WSAEHOSTDOWN, Networking subsystem not started");
            break;

        case WSAEHOSTUNREACH:
			rtl_uString_newFromAscii (strError, "WSAEHOSTUNREACH, No route to host");
            break;

        case WSAEWOULDBLOCK:
			rtl_uString_newFromAscii (strError, "WSAEWOULDBLOCK, Operation would block");
            break;

        case WSAEINPROGRESS:
			rtl_uString_newFromAscii (strError, "WSAEINPROGRESS, Operation now in progress");
            break;

        case WSAEALREADY:
			rtl_uString_newFromAscii (strError, "WSAEALREADY, Operation already in progress");
            break;

        case WSAEINTR:
			rtl_uString_newFromAscii (strError, "WSAEALREADY, Operation was interrupted");
            break;

        case WSAEBADF:
			rtl_uString_newFromAscii (strError, "WSAEBADF, Bad file number");
            break;

        case WSAEACCES:
			rtl_uString_newFromAscii (strError, "WSAEACCES, Access is denied");
            break;

        case WSAEFAULT:
			rtl_uString_newFromAscii (strError, "WSAEFAULT, Bad memory Addr");
            break;

        case WSAEINVAL:
			rtl_uString_newFromAscii (strError, "WSAEINVAL, The socket has not been bound with bind() or is already connected");
            break;

        case WSAEMFILE:
			rtl_uString_newFromAscii (strError, "WSAEMFILE, No more file descriptors are available");
            break;

        case WSAETOOMANYREFS:
			rtl_uString_newFromAscii (strError, "WSAETOOMANYREFS, Undocumented WinSock error");
            break;

        case WSAENAMETOOLONG:
			rtl_uString_newFromAscii (strError, "WSAENAMETOOLONG, Undocumented WinSock error");
            break;

        case WSAENOTEMPTY:
			rtl_uString_newFromAscii (strError, "WSAENOTEMPTY, Undocumented WinSock error");
            break;

        case WSAEPROCLIM:
			rtl_uString_newFromAscii (strError, "WSAEPROCLIM, Undocumented WinSock error");
            break;

        case WSAEUSERS:
			rtl_uString_newFromAscii (strError, "WSAEUSERS, Undocumented WinSock error");
            break;

        case WSAEDQUOT:
			rtl_uString_newFromAscii (strError, "WSAEDQUOT, Undocumented WinSock error");
            break;

        case WSAESTALE:
			rtl_uString_newFromAscii (strError, "WSAESTALE, Undocumented WinSock error");
            break;

        case WSAEREMOTE:
			rtl_uString_newFromAscii (strError, "WSAEREMOTE, Undocumented WinSock error");
            break;

        case WSAEDISCON:
			rtl_uString_newFromAscii (strError, "WSAEDISCON, Circuit was gracefully terminated");
            break;

        case WSASYSNOTREADY:
			rtl_uString_newFromAscii (strError, "WSASYSNOTREADY, The underlying network subsystem is not ready for network communication");
            break;

        case WSAVERNOTSUPPORTED:
			rtl_uString_newFromAscii (strError, "WSAVERNOTSUPPORTED, The version of Windows Sockets API support requested is not provided by this particular Windows Sockets implementation");
            break;

        case WSANOTINITIALISED:
			rtl_uString_newFromAscii (strError, "WSANOTINITIALISED, WSAStartup() has not been called");
            break;

        case WSAHOST_NOT_FOUND:
			rtl_uString_newFromAscii (strError, "WSAHOST_NOT_FOUND, Authoritative answer host not found");
            break;

        case WSATRY_AGAIN:
			rtl_uString_newFromAscii (strError, "WSATRY_AGAIN, Non-authoritative answer host not found or SERVERFAIL");
            break;

        case WSANO_RECOVERY:
			rtl_uString_newFromAscii (strError, "WSANO_RECOVERY, Non recoverable errors, FORMERR, REFUSED, NOTIMP");
            break;

        case WSANO_DATA:
			rtl_uString_newFromAscii (strError, "WSANO_DATA or WSANO_ADDRESS, Valid name, no data record of requested type");
            break;

		default:
		{
			sal_Unicode message[128];

            wsprintfW(reinterpret_cast<LPWSTR>(message), L"Unknown WinSock Error Number %d", error);
			rtl_uString_newFromStr (strError, message);
        }

        return;

	}
}

/*****************************************************************************/
/* osl_getLastSocketError  */
/*****************************************************************************/
oslSocketError SAL_CALL osl_getLastSocketError(oslSocket /*Socket*/)
{
	return ERROR_FROM_NATIVE(WSAGetLastError());
}

/*****************************************************************************/
/* SocketSet                                                                 */
/*****************************************************************************/
typedef struct _TSocketSetImpl
{
	fd_set	m_Set;			/* the set of descriptors */

} TSocketSetImpl;

/*****************************************************************************/
/* osl_createSocketSet  */
/*****************************************************************************/
oslSocketSet SAL_CALL osl_createSocketSet()
{
	TSocketSetImpl* pSet;

	pSet = (TSocketSetImpl*) rtl_allocateMemory(sizeof(TSocketSetImpl));

	if(pSet)
	{
		FD_ZERO(&pSet->m_Set);
	}

	return (oslSocketSet)pSet;
}

/*****************************************************************************/
/* osl_destroySocketSet  */
/*****************************************************************************/
void SAL_CALL osl_destroySocketSet (oslSocketSet Set)
{
	if(Set)
		rtl_freeMemory(Set);
}

/*****************************************************************************/
/* osl_clearSocketSet  */
/*****************************************************************************/
void SAL_CALL osl_clearSocketSet (oslSocketSet Set)
{
	TSocketSetImpl* pSet;

	pSet= (TSocketSetImpl*)Set;

	if (pSet)
		FD_ZERO(&pSet->m_Set);
}

/*****************************************************************************/
/* osl_addToSocketSet  */
/*****************************************************************************/
void SAL_CALL osl_addToSocketSet (
	oslSocketSet Set,
	oslSocket    Socket)
{
	TSocketSetImpl* pSet;
	oslSocketImpl*  pSockImpl;

	pSet= (TSocketSetImpl*)Set;
	pSockImpl= (oslSocketImpl*)Socket;

	if (pSet && pSockImpl)
		FD_SET(pSockImpl->m_Socket, &pSet->m_Set);
}

/*****************************************************************************/
/* osl_removeFromSocketSet  */
/*****************************************************************************/
void SAL_CALL osl_removeFromSocketSet (
	oslSocketSet Set,
	oslSocket    Socket)
{
	TSocketSetImpl* pSet;
	oslSocketImpl*  pSockImpl;

	pSet= (TSocketSetImpl*)Set;
	pSockImpl= (oslSocketImpl*)Socket;

	if (pSet && pSockImpl)
		FD_CLR(pSockImpl->m_Socket, &pSet->m_Set);
}

/*****************************************************************************/
/* osl_isInSocketSet  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_isInSocketSet (
	oslSocketSet Set,
	oslSocket    Socket)
{
	TSocketSetImpl* pSet;
	oslSocketImpl*  pSockImpl;

	pSet= (TSocketSetImpl*)Set;
	pSockImpl= (oslSocketImpl*)Socket;

	if (pSet && pSockImpl)
		return (FD_ISSET(pSockImpl->m_Socket, &pSet->m_Set) != 0);
	else
		return sal_False;
}

/*****************************************************************************/
/* osl_demultiplexSocketEvents  */
/*****************************************************************************/
sal_Int32 SAL_CALL osl_demultiplexSocketEvents (
	oslSocketSet IncomingSet,
	oslSocketSet OutgoingSet,
	oslSocketSet OutOfBandSet,
	const TimeValue* pTimeout)
{
	int             MaxHandle= 0;
	struct timeval  tv;
	TSocketSetImpl* pInSet;
	TSocketSetImpl* pOutSet;
	TSocketSetImpl* pOOBSet;

	if(pTimeout)
	{
		/* divide milliseconds into seconds and microseconds */
		tv.tv_sec  = pTimeout->Seconds;
		tv.tv_usec = pTimeout->Nanosec / 1000L;
	}

	/* map opaque data to impl-types */
	pInSet= (TSocketSetImpl*)IncomingSet;
	pOutSet= (TSocketSetImpl*)OutgoingSet;
	pOOBSet= (TSocketSetImpl*)OutOfBandSet;

	return select(MaxHandle,				/* redundant in WIN32 */
				  pInSet ? &pInSet->m_Set : 0,
				  pOutSet ? &pOutSet->m_Set : 0,
				  pOOBSet ? &pOOBSet->m_Set : 0,
				  pTimeout ? &tv : 0);
}

}