xref: /aoo42x/main/sal/osl/w32/socket.cxx (revision 87d2adbc)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sal.hxx"
26 
27 #include "system.h"
28 
29 #include <osl/socket.h>
30 #include <osl/diagnose.h>
31 #include <rtl/alloc.h>
32 
33 #include "sockimpl.h"
34 
35 extern "C" {
36 
37 /* defines for shutdown */
38 #ifdef GCC
39 #	define SD_RECEIVE 0
40 #	define SD_SEND 1
41 #	define SD_BOTH 2
42 #endif
43 
44 /*
45 	oslSocketAddr is a pointer to a Berkeley struct sockaddr.
46 	I refrained from using sockaddr_in because of possible further
47 	extensions of this socket-interface (IP-NG?).
48 	The intention was to hide all Berkeley data-structures from
49 	direct access past the osl-interface.
50 
51 	The current implementation is internet (IP) centered. All
52 	the constructor-functions (osl_create...) take parameters
53 	that will probably make sense only in the IP-environment
54 	(e.g. because of using the dotted-Addr-format).
55 
56 	If the interface will be extended to host other protocol-
57 	families, I expect no externally visible changes in the
58 	existing functions. You'll probably need only new
59 	constructor-functions who take the different Addr
60 	formats into consideration (maybe a long dotted Addr
61 	or whatever).
62 */
63 
64 /*
65   _Note_ that I rely on the fact that oslSocketAddr and struct sockaddr
66   are the same! I don't like it very much but see no other easy way to
67   conceal the struct sockaddr from the eyes of the user.
68 */
69 
70 #define OSL_INVALID_SOCKET		INVALID_SOCKET			/* WIN32 */
71 #define OSL_SOCKET_ERROR		SOCKET_ERROR			/* WIN32 */
72 
73 /*****************************************************************************/
74 /* enum oslAddrFamily */
75 /*****************************************************************************/
76 
77 /* map */
78 static DWORD FamilyMap[]= {
79 	AF_INET,					/* osl_Socket_FamilyInet */
80 	AF_IPX,						/* osl_Socket_FamilyIpx */
81 	0							/* osl_Socket_FamilyInvalid */
82 };
83 
84 /* reverse map */
85 static oslAddrFamily osl_AddrFamilyFromNative(DWORD nativeType)
86 {
87 	oslAddrFamily i= (oslAddrFamily) 0;
88 	while(i != osl_Socket_FamilyInvalid)
89 	{
90 		if(FamilyMap[i] == nativeType)
91 			return i;
92 		i = (oslAddrFamily) ( (int)i + 1);
93 	}
94 	return i;
95 }
96 
97 /* macros */
98 #define FAMILY_FROM_NATIVE(y) osl_AddrFamilyFromNative(y)
99 #define FAMILY_TO_NATIVE(x)	(short)FamilyMap[x]
100 
101 /*****************************************************************************/
102 /* enum oslProtocol */
103 /*****************************************************************************/
104 
105 /* map */
106 static DWORD ProtocolMap[]= {
107 	0,							/* osl_Socket_FamilyInet */
108 	NSPROTO_IPX,				/* osl_Socket_FamilyIpx */
109 	NSPROTO_SPX,				/* osl_Socket_ProtocolSpx */
110 	NSPROTO_SPXII,				/* osl_Socket_ProtocolSpx_ii */
111 	0							/* osl_Socket_ProtocolInvalid */
112 };
113 
114 /* macros */
115 #define PROTOCOL_FROM_NATIVE(y) osl_ProtocolFromNative(y)
116 #define PROTOCOL_TO_NATIVE(x)	ProtocolMap[x]
117 
118 /*****************************************************************************/
119 /* enum oslSocketType */
120 /*****************************************************************************/
121 
122 /* map */
123 static DWORD TypeMap[]= {
124 	SOCK_STREAM,				/* osl_Socket_TypeStream */
125 	SOCK_DGRAM,					/* osl_Socket_TypeDgram  */
126 	SOCK_RAW,					/* osl_Socket_TypeRaw */
127 	SOCK_RDM,					/* osl_Socket_TypeRdm */
128 	SOCK_SEQPACKET,				/* osl_Socket_TypeSeqPacket */
129 	0							/* osl_Socket_TypeInvalid */
130 };
131 
132 /* reverse map */
133 static oslSocketType osl_SocketTypeFromNative(DWORD nativeType)
134 {
135 	oslSocketType i= (oslSocketType)0;
136 	while(i != osl_Socket_TypeInvalid)
137 	{
138 		if(TypeMap[i] == nativeType)
139 			return i;
140 		i = (oslSocketType)((int)i+1);
141 	}
142 	return i;
143 }
144 
145 /* macros */
146 #define TYPE_TO_NATIVE(x)		TypeMap[x]
147 #define TYPE_FROM_NATIVE(y)		osl_SocketTypeFromNative(y)
148 
149 /*****************************************************************************/
150 /* enum oslSocketOption */
151 /*****************************************************************************/
152 
153 /* map */
154 static DWORD OptionMap[]= {
155 	SO_DEBUG,					/* osl_Socket_OptionDebug */
156 	SO_ACCEPTCONN,				/* osl_Socket_OptionAcceptConn */
157 	SO_REUSEADDR,				/* osl_Socket_OptionReuseAddr */
158 	SO_KEEPALIVE,				/* osl_Socket_OptionKeepAlive */
159 	SO_DONTROUTE,				/* osl_Socket_OptionDontRoute */
160 	SO_BROADCAST,				/* osl_Socket_OptionBroadcast */
161 	SO_USELOOPBACK,				/* osl_Socket_OptionUseLoopback */
162 	SO_LINGER,					/* osl_Socket_OptionLinger */
163 	SO_OOBINLINE,				/* osl_Socket_OptionOOBinLine */
164 	SO_SNDBUF,					/* osl_Socket_OptionSndBuf */
165 	SO_RCVBUF,					/* osl_Socket_OptionRcvBuf */
166 	SO_SNDLOWAT,				/* osl_Socket_OptionSndLowat */
167 	SO_RCVLOWAT,				/* osl_Socket_OptionRcvLowat */
168 	SO_SNDTIMEO,				/* osl_Socket_OptionSndTimeo */
169 	SO_RCVTIMEO,				/* osl_Socket_OptionRcvTimeo */
170 	SO_ERROR,					/* osl_Socket_OptionError */
171 	SO_TYPE,					/* osl_Socket_OptionType */
172 	TCP_NODELAY,				/* osl_Socket_OptionTcpNoDelay */
173 	0							/* osl_Socket_OptionInvalid */
174 };
175 
176 /* macros */
177 #define OPTION_TO_NATIVE(x)		OptionMap[x]
178 #define OPTION_FROM_NATIVE(y)	osl_SocketOptionFromNative(y)
179 
180 /*****************************************************************************/
181 /* enum oslSocketOptionLevel */
182 /*****************************************************************************/
183 
184 static DWORD OptionLevelMap[]= {
185 	SOL_SOCKET,					/* osl_Socket_LevelSocket */
186 	IPPROTO_TCP,				/* osl_Socket_LevelTcp */
187 	0							/* osl_invalid_SocketLevel */
188 };
189 
190 /* macros */
191 #define OPTION_LEVEL_TO_NATIVE(x)		OptionLevelMap[x]
192 #define OPTION_LEVEL_FROM_NATIVE(y)		osl_SocketOptionLevelFromNative(y)
193 
194 /*****************************************************************************/
195 /* enum oslSocketMsgFlag */
196 /*****************************************************************************/
197 
198 static DWORD SocketMsgFlagMap[]= {
199 	0,							/* osl_Socket_MsgNormal */
200 	MSG_OOB,					/* osl_Socket_MsgOOB */
201 	MSG_PEEK,					/* osl_Socket_MsgPeek */
202 	MSG_DONTROUTE,				/* osl_Socket_MsgDontRoute */
203 	MSG_MAXIOVLEN				/* osl_Socket_MsgMaxIOVLen */
204 };
205 
206 /* macros */
207 #define MSG_FLAG_TO_NATIVE(x)		SocketMsgFlagMap[x]
208 #define MSG_FLAG_FROM_NATIVE(y)		osl_SocketMsgFlagFromNative(y)
209 
210 /*****************************************************************************/
211 /* enum oslSocketDirection */
212 /*****************************************************************************/
213 
214 static DWORD SocketDirection[]= {
215 	SD_RECEIVE,					/* osl_Socket_DirRead */
216 	SD_SEND,					/* osl_Socket_DirWrite */
217 	SD_BOTH						/* osl_Socket_DirReadwrite */
218 };
219 
220 /* macros */
221 #define DIRECTION_TO_NATIVE(x)		SocketDirection[x]
222 #define DIRECTION_FROM_NATIVE(y)	osl_SocketDirectionFromNative(y)
223 
224 /*****************************************************************************/
225 /* enum oslSocketError */
226 /*****************************************************************************/
227 
228 static int SocketError[]= {
229 
230 	0,					/* no error */
231 	WSAENOTSOCK,			/* Socket operation on non-socket */
232 	WSAEDESTADDRREQ,		/* Destination address required */
233 	WSAEMSGSIZE,			/* Message too long */
234 	WSAEPROTOTYPE,			/* Protocol wrong type for socket */
235 	WSAENOPROTOOPT,		/* Protocol not available */
236 	WSAEPROTONOSUPPORT,	/* Protocol not supported */
237 	WSAESOCKTNOSUPPORT,	/* Socket type not supported */
238 	WSAEOPNOTSUPP,			/* Operation not supported on socket */
239 	WSAEPFNOSUPPORT,		/* Protocol family not supported */
240 	WSAEAFNOSUPPORT,		/* Address family not supported by */
241 							/* protocol family */
242 	WSAEADDRINUSE,			/* Address already in use */
243 	WSAEADDRNOTAVAIL,		/* Can't assign requested address */
244 	WSAENETDOWN,			/* Network is down */
245 	WSAENETUNREACH,		/* Network is unreachable */
246 	WSAENETRESET,			/* Network dropped connection because */
247 							/* of reset */
248 	WSAECONNABORTED,		/* Software caused connection abort */
249 	WSAECONNRESET,			/* Connection reset by peer */
250 	WSAENOBUFS,			/* No buffer space available */
251 	WSAEISCONN,			/* Socket is already connected */
252 	WSAENOTCONN,			/* Socket is not connected */
253 	WSAESHUTDOWN,			/* Can't send after socket shutdown */
254 	WSAETOOMANYREFS,		/* Too many references: can't splice */
255 	WSAETIMEDOUT,			/* Connection timed out */
256 	WSAECONNREFUSED,		/* Connection refused */
257 	WSAEHOSTDOWN,			/* Host is down */
258 	WSAEHOSTUNREACH,		/* No route to host */
259 	WSAEWOULDBLOCK,		/* call would block on non-blocking socket */
260 	WSAEALREADY,			/* operation already in progress */
261 	WSAEINPROGRESS		/* operation now in progress */
262 };
263 
264 /* reverse map */
265 static oslSocketError osl_SocketErrorFromNative(int nativeType)
266 {
267 	oslSocketError i= (oslSocketError)0;
268 
269 	while(i != osl_Socket_E_InvalidError)
270 	{
271 		if(SocketError[i] == nativeType)
272 			return i;
273 
274 		i = (oslSocketError)( (int) i + 1);
275 	}
276 	return i;
277 }
278 
279 /* macros */
280 #define ERROR_TO_NATIVE(x)		SocketError[x]
281 #define ERROR_FROM_NATIVE(y)	osl_SocketErrorFromNative(y)
282 
283 /*****************************************************************************/
284 /* oslSocketDialupImpl */
285 /*****************************************************************************/
286 static oslSocketDialupImpl *pDialupImpl = NULL;
287 
288 #if 0  /* INTERNAL DEBUG ONLY */
289 BOOL WINAPI __osl_autodial_Impl (DWORD dwFlags, DWORD dwReserved)
290 {
291 	return 0;
292 }
293 
294 BOOL WINAPI __osl_autodialHangup_Impl (DWORD dwReserved)
295 {
296 	return 1;
297 }
298 
299 BOOL WINAPI __osl_getConnectedState_Impl (LPDWORD lpdwFlags, DWORD dwReserved)
300 {
301 	if (lpdwFlags)
302 		*lpdwFlags = 0;
303 	return 0;
304 }
305 #endif /* INTERNAL DEBUG ONLY */
306 
307 /*
308  * __osl_createSocketDialupImpl.
309  */
310 static oslSocketDialupImpl* __osl_createSocketDialupImpl (void)
311 {
312 	oslSocketDialupImpl *pImpl;
313 	pImpl = (oslSocketDialupImpl*)rtl_allocateZeroMemory( sizeof (oslSocketDialupImpl));
314 
315 	InitializeCriticalSection (&pImpl->m_hMutex);
316 
317 	return (pImpl);
318 }
319 
320 /*
321  * __osl_initSocketDialupImpl.
322  */
323 static void __osl_initSocketDialupImpl (oslSocketDialupImpl *pImpl)
324 {
325 #ifdef SOCKET_USE_AUTODIAL
326 	if (pImpl)
327 	{
328 		HINSTANCE hModule;
329 
330 		EnterCriticalSection (&pImpl->m_hMutex);
331 
332 		hModule = LoadLibrary (INTERNET_MODULE_NAME);
333 		if (!(hModule <= (HINSTANCE)HINSTANCE_ERROR))
334 		{
335 			pImpl->m_pfnAttemptConnect = (INTERNETATTEMPTCONNECT)
336 				(GetProcAddress (hModule, "InternetAttemptConnect"));
337 			pImpl->m_pfnAutodial = (INTERNETAUTODIAL)
338 				(GetProcAddress (hModule, "InternetAutodial"));
339 			pImpl->m_pfnAutodialHangup = (INTERNETAUTODIALHANGUP)
340 				(GetProcAddress (hModule, "InternetAutodialHangup"));
341 			pImpl->m_pfnGetConnectedState = (INTERNETGETCONNECTEDSTATE)
342 				(GetProcAddress (hModule, "InternetGetConnectedState"));
343 			pImpl->m_hModule = hModule;
344 		}
345 
346 		LeaveCriticalSection (&pImpl->m_hMutex);
347 	}
348 #else
349     pImpl = pImpl; /* avoid warnings */
350 #endif
351 }
352 
353 /*
354  * __osl_destroySocketDialupImpl.
355  */
356 static void __osl_destroySocketDialupImpl (oslSocketDialupImpl *pImpl)
357 {
358 	if (pImpl)
359 	{
360 		EnterCriticalSection (&pImpl->m_hMutex);
361 
362 		if (pImpl->m_dwFlags & INTERNET_CONNECTION_HANGUP)
363 		{
364 			if (pImpl->m_pfnAutodialHangup)
365 			{
366 				(pImpl->m_pfnAutodialHangup)(0);
367 				pImpl->m_dwFlags &= ~INTERNET_CONNECTION_HANGUP;
368 			}
369 		}
370 
371 		if (pImpl->m_hModule)
372 			FreeLibrary (pImpl->m_hModule);
373 
374 		LeaveCriticalSection (&pImpl->m_hMutex);
375 		DeleteCriticalSection (&pImpl->m_hMutex);
376 
377 		rtl_freeMemory (pImpl);
378 	}
379 }
380 
381 /*
382  * __osl_querySocketDialupImpl.
383  */
384 static sal_Bool __osl_querySocketDialupImpl (void)
385 {
386 	sal_Bool result;
387 
388 	if (pDialupImpl == NULL)
389 	{
390 		pDialupImpl = __osl_createSocketDialupImpl();
391 		__osl_initSocketDialupImpl (pDialupImpl);
392 	}
393 
394 	EnterCriticalSection (&pDialupImpl->m_hMutex);
395 
396 	result = sal_True;
397 	if (pDialupImpl->m_pfnGetConnectedState)
398 	{
399 		DWORD dwFlags = 0;
400 
401 		result = (sal_Bool)(pDialupImpl->m_pfnGetConnectedState)(&dwFlags, 0);
402 		pDialupImpl->m_dwFlags |= dwFlags;
403 	}
404 
405 	LeaveCriticalSection (&pDialupImpl->m_hMutex);
406 	return (result);
407 }
408 
409 /*
410  * __osl_attemptSocketDialupImpl.
411  */
412 static sal_Bool __osl_attemptSocketDialupImpl (void)
413 {
414 	sal_Bool result;
415 
416 	if (pDialupImpl == NULL)
417 	{
418 		pDialupImpl = __osl_createSocketDialupImpl();
419 		__osl_initSocketDialupImpl (pDialupImpl);
420 	}
421 
422 	EnterCriticalSection (&pDialupImpl->m_hMutex);
423 
424 	result = __osl_querySocketDialupImpl();
425 	if (!result)
426 	{
427 		result = sal_True;
428 		if (pDialupImpl->m_pfnAutodial)
429 		{
430 			result = (sal_Bool)(pDialupImpl->m_pfnAutodial)(0, 0);
431 			if (result)
432 				pDialupImpl->m_dwFlags |= INTERNET_CONNECTION_HANGUP;
433 			else
434 				WSASetLastError (WSAENETDOWN);
435 		}
436 	}
437 
438 	LeaveCriticalSection (&pDialupImpl->m_hMutex);
439 	return (result);
440 }
441 
442 /*****************************************************************************/
443 /* oslSocketImpl */
444 /*****************************************************************************/
445 static sal_uInt32 g_nSocketImpl = 0;
446 
447 #if OSL_DEBUG_LEVEL > 1
448 static sal_uInt32 g_nSocketAddr = 0;
449 struct LeakWarning
450 {
451 	~LeakWarning()
452 	{
453 		if( g_nSocketImpl )
454 			OSL_TRACE( "sal_socket: %d socket instances leak\n" , g_nSocketImpl );
455 		if( g_nSocketAddr )
456 			OSL_TRACE( "sal_socket: %d socket address instances leak\n" , g_nSocketAddr );
457 	}
458 };
459 LeakWarning socketWarning;
460 #endif
461 
462 /*
463  * __osl_createSocketImpl.
464  */
465 oslSocket __osl_createSocketImpl(SOCKET Socket)
466 {
467 	oslSocket pSockImpl = (oslSocket) rtl_allocateZeroMemory( sizeof(struct oslSocketImpl));
468 	pSockImpl->m_Socket = Socket;
469 	pSockImpl->m_nRefCount = 1;
470 
471 	g_nSocketImpl++;
472 
473 	return (pSockImpl);
474 }
475 
476 /*
477  * __osl_destroySocketImpl.
478  */
479 void __osl_destroySocketImpl(oslSocketImpl *pImpl)
480 {
481 	if (pImpl)
482 	{
483 		if (--g_nSocketImpl == 0)
484 		{
485 			__osl_destroySocketDialupImpl (pDialupImpl);
486 			pDialupImpl = NULL;
487 		}
488 		rtl_freeMemory (pImpl);
489 	}
490 }
491 /*****************************************************************************/
492 static oslSocketAddr __osl_createSocketAddr(  )
493 {
494 	oslSocketAddr pAddr = (oslSocketAddr) rtl_allocateZeroMemory( sizeof( struct oslSocketAddrImpl ));
495 	pAddr->m_nRefCount = 1;
496 #if OSL_DEBUG_LEVEL > 1
497 	g_nSocketAddr ++;
498 #endif
499 	return pAddr;
500 }
501 
502 static oslSocketAddr __osl_createSocketAddrWithFamily(
503 	oslAddrFamily family, sal_Int32 port, sal_uInt32 nAddr )
504 {
505 	OSL_ASSERT( family == osl_Socket_FamilyInet );
506 
507 	oslSocketAddr pAddr = __osl_createSocketAddr();
508 	switch( family )
509 	{
510 	case osl_Socket_FamilyInet:
511 	{
512 		struct sockaddr_in* pInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
513 
514 		pInetAddr->sin_family = FAMILY_TO_NATIVE(osl_Socket_FamilyInet);
515 		pInetAddr->sin_addr.s_addr = nAddr;
516 		pInetAddr->sin_port = (sal_uInt16)(port&0xffff);
517 		break;
518    	}
519 	default:
520 		pAddr->m_sockaddr.sa_family = FAMILY_TO_NATIVE(family);
521 	}
522 	return pAddr;
523 }
524 
525 static oslSocketAddr __osl_createSocketAddrFromSystem( struct sockaddr *pSystemSockAddr )
526 {
527 	oslSocketAddr pAddr = __osl_createSocketAddr();
528 	memcpy( &(pAddr->m_sockaddr), pSystemSockAddr, sizeof( sockaddr ) );
529 	return pAddr;
530 }
531 
532 static void __osl_destroySocketAddr( oslSocketAddr addr )
533 {
534 #if OSL_DEBUG_LEVEL > 1
535 	g_nSocketAddr --;
536 #endif
537 	rtl_freeMemory( addr );
538 }
539 /*****************************************************************************/
540 /* osl_createEmptySocketAddr */
541 /*****************************************************************************/
542 oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family)
543 {
544 	oslSocketAddr pAddr = 0;
545 
546 	/* is it an internet-Addr? */
547 	if (Family == osl_Socket_FamilyInet)
548 	{
549 		pAddr = __osl_createSocketAddrWithFamily(Family, 0 , htonl(INADDR_ANY) );
550 	}
551 	else
552 	{
553 		pAddr = __osl_createSocketAddrWithFamily( Family , 0 , 0 );
554 	}
555 
556 	return pAddr;
557 }
558 
559 /*****************************************************************************/
560 /* osl_copySocketAddr */
561 /*****************************************************************************/
562 // @deprecated, to be removed
563 oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr)
564 {
565 	oslSocketAddr pCopy = 0;
566 	if (Addr)
567 	{
568 		pCopy = __osl_createSocketAddr();
569 
570 		if (pCopy)
571 			memcpy(&(pCopy->m_sockaddr),&(Addr->m_sockaddr), sizeof(struct sockaddr));
572 	}
573 	return pCopy;
574 }
575 
576 /*****************************************************************************/
577 /* osl_isEqualSocketAddr */
578 /*****************************************************************************/
579 sal_Bool SAL_CALL osl_isEqualSocketAddr(oslSocketAddr Addr1, oslSocketAddr Addr2)
580 {
581 	struct sockaddr* pAddr1= &(Addr1->m_sockaddr);
582 	struct sockaddr* pAddr2= &(Addr2->m_sockaddr);
583 
584 	OSL_ASSERT(pAddr1);
585 	OSL_ASSERT(pAddr2);
586 
587 	if (pAddr1->sa_family == pAddr2->sa_family)
588 	{
589 		switch (pAddr1->sa_family)
590 		{
591 			case AF_INET:
592 			{
593 				struct sockaddr_in* pInetAddr1= (struct sockaddr_in*)pAddr1;
594 				struct sockaddr_in* pInetAddr2= (struct sockaddr_in*)pAddr2;
595 
596 				if ((pInetAddr1->sin_family == pInetAddr2->sin_family) &&
597 					(pInetAddr1->sin_addr.s_addr == pInetAddr2->sin_addr.s_addr) &&
598 					(pInetAddr1->sin_port == pInetAddr2->sin_port))
599 					return (sal_True);
600 			}
601 
602 			default:
603 			{
604 				return (memcmp(pAddr1, Addr2, sizeof(struct sockaddr)) == 0);
605 			}
606 		}
607 	}
608 
609 	return (sal_False);
610 }
611 
612 /*****************************************************************************/
613 /* osl_createInetBroadcastAddr */
614 /*****************************************************************************/
615 oslSocketAddr SAL_CALL osl_createInetBroadcastAddr (
616 	rtl_uString *strDottedAddr,
617 	sal_Int32    Port)
618 {
619 	sal_uInt32          nAddr = OSL_INADDR_NONE;
620 
621 	if (strDottedAddr && strDottedAddr->length)
622 	{
623 		/* Dotted host address for limited broadcast */
624 		rtl_String *pDottedAddr = NULL;
625 
626 		rtl_uString2String (
627 			&pDottedAddr, strDottedAddr->buffer, strDottedAddr->length,
628 			RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
629 
630 		nAddr = inet_addr (pDottedAddr->buffer);
631 		rtl_string_release (pDottedAddr);
632 	}
633 
634 	if (nAddr != OSL_INADDR_NONE)
635 	{
636 		/* Limited broadcast */
637 		nAddr = ntohl(nAddr);
638 		if (IN_CLASSA(nAddr))
639 		{
640 			nAddr &= IN_CLASSA_NET;
641 			nAddr |= IN_CLASSA_HOST;
642 		}
643 		else if (IN_CLASSB(nAddr))
644 		{
645 			nAddr &= IN_CLASSB_NET;
646 			nAddr |= IN_CLASSB_HOST;
647 		}
648 		else if (IN_CLASSC(nAddr))
649 		{
650 			nAddr &= IN_CLASSC_NET;
651 			nAddr |= IN_CLASSC_HOST;
652 		}
653 		else
654 		{
655 			/* No broadcast in class D */
656 			return ((oslSocketAddr)NULL);
657 		}
658 		nAddr = htonl(nAddr);
659 	}
660 
661 	oslSocketAddr pAddr =
662 		__osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons( (sal_uInt16) Port), nAddr );
663 	return pAddr;
664 }
665 
666 /*****************************************************************************/
667 /* osl_createInetSocketAddr */
668 /*****************************************************************************/
669 oslSocketAddr SAL_CALL osl_createInetSocketAddr (
670 	rtl_uString *strDottedAddr,
671 	sal_Int32    Port)
672 {
673 	DWORD Addr;
674 	rtl_String	*pDottedAddr=NULL;
675 
676 	rtl_uString2String(
677 		&pDottedAddr, strDottedAddr->buffer, strDottedAddr->length,
678 		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
679 
680 	Addr= inet_addr (pDottedAddr->buffer);
681 	rtl_string_release (pDottedAddr);
682 
683 	oslSocketAddr pAddr = 0;
684 	if(Addr != -1)
685 	{
686 		pAddr = __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons( (sal_uInt16)Port), Addr );
687 	}
688 	return pAddr;
689 }
690 
691 oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence *pByteSeq )
692 {
693 	OSL_ASSERT( pAddr );
694 	OSL_ASSERT( pByteSeq );
695 
696 	oslSocketResult res = osl_Socket_Error;
697 	if( pAddr && pByteSeq )
698 	{
699 		OSL_ASSERT( pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE( osl_Socket_FamilyInet ) );
700 		OSL_ASSERT( pByteSeq->nElements == 4 );
701 		struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
702 		memcpy( &(pSystemInetAddr->sin_addr) , pByteSeq->elements , 4 );
703 		res = osl_Socket_Ok;
704 	}
705 	return res;
706 }
707 
708 /** Returns the addr field in the struct sockaddr. ppByteSeq is in network byteorder. *ppByteSeq may
709 	either be 0 or contain a constructed sal_Sequence.
710  */
711 oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence **ppByteSeq )
712 {
713 	OSL_ASSERT( pAddr );
714 	OSL_ASSERT( ppByteSeq );
715 
716 	oslSocketResult res = osl_Socket_Error;
717 	if( pAddr && ppByteSeq )
718 	{
719 		struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
720 		rtl_byte_sequence_constructFromArray( ppByteSeq , (sal_Int8 *) &(pSystemInetAddr->sin_addr),4);
721 		res = osl_Socket_Ok;
722 	}
723 	return res;
724 }
725 
726 /*****************************************************************************/
727 /* oslHostAddr */
728 /*****************************************************************************/
729 struct oslHostAddrImpl {
730 	rtl_uString     *pHostName;
731 	oslSocketAddr   pSockAddr;
732 } ;
733 
734 static oslHostAddr __osl_hostentToHostAddr (const struct hostent *he)
735 {
736 	oslHostAddr pAddr= NULL;
737 	oslSocketAddr pSocketAddr = 0;
738 
739 	rtl_uString     *cn= NULL;
740 
741 	if ((he == NULL) || (he->h_name == NULL) || (he->h_addr_list[0] == NULL))
742 		return ((oslHostAddr)NULL);
743 
744 	rtl_string2UString(
745 		&cn, he->h_name, strlen(he->h_name),
746 		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
747     OSL_ASSERT(cn != 0);
748 
749 	pSocketAddr = __osl_createSocketAddr();
750 
751 	if (pSocketAddr == NULL)
752 	{
753 		rtl_uString_release(cn);
754 		return ((oslHostAddr)NULL);
755 	}
756 
757 	pSocketAddr->m_sockaddr.sa_family = he->h_addrtype;
758 	if (pSocketAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
759 	{
760 		struct sockaddr_in *sin= (struct sockaddr_in *)&(pSocketAddr->m_sockaddr);
761 		memcpy (
762 			&(sin->sin_addr.s_addr),
763 			he->h_addr_list[0],
764 			he->h_length);
765 	}
766 	else
767 	{
768 		/* unknown address family */
769 		/* future extensions for new families might be implemented here */
770 
771         OSL_TRACE("_osl_hostentToHostAddr(): unknown address family.\n");
772 		OSL_ASSERT(sal_False);
773 
774 		__osl_destroySocketAddr( pSocketAddr );
775 		rtl_uString_release(cn);
776 		return ((oslHostAddr)NULL);
777 	}
778 
779 	pAddr= (oslHostAddr )rtl_allocateMemory (sizeof (struct oslHostAddrImpl));
780 
781 	if (pAddr == NULL)
782 	{
783 		__osl_destroySocketAddr( pSocketAddr );
784 		rtl_uString_release(cn);
785 		return ((oslHostAddr)NULL);
786 	}
787 
788 	pAddr->pHostName= cn;
789 	pAddr->pSockAddr= pSocketAddr;
790 
791 	return pAddr;
792 }
793 
794 /*****************************************************************************/
795 /* osl_createHostAddr */
796 /*****************************************************************************/
797 oslHostAddr SAL_CALL osl_createHostAddr (
798 	rtl_uString         *strHostname,
799 	const oslSocketAddr  pSocketAddr)
800 {
801 	oslHostAddr pAddr;
802 	rtl_uString     *cn= NULL;
803 
804 	if ((strHostname == NULL)  || (strHostname->length == 0) || (pSocketAddr == NULL))
805 		return ((oslHostAddr)NULL);
806 
807 	rtl_uString_newFromString( &cn, strHostname);
808 
809 	if ( ! pSocketAddr )
810 	{
811 		rtl_uString_release(cn);
812 		return ((oslHostAddr)NULL);
813 	}
814 
815 	pAddr= (oslHostAddr)rtl_allocateMemory (sizeof (struct oslHostAddrImpl));
816 
817 	if (pAddr == NULL)
818 	{
819 		rtl_uString_release(cn);
820 		return ((oslHostAddr)NULL);
821 	}
822 
823 	pAddr->pHostName= cn;
824 	pAddr->pSockAddr= osl_copySocketAddr( pSocketAddr );
825 
826 	return ((oslHostAddr)pAddr);
827 }
828 
829 /*****************************************************************************/
830 /* osl_createHostAddrByName */
831 /*****************************************************************************/
832 oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *strHostname)
833 {
834 	if ((strHostname == NULL) || (strHostname->length == 0))
835 		return ((oslHostAddr)NULL);
836 
837 	if (__osl_attemptSocketDialupImpl())
838 	{
839 		struct hostent *he;
840 		rtl_String     *Hostname= NULL;
841 
842 		rtl_uString2String(
843 			&Hostname, strHostname->buffer, strHostname->length,
844 			RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
845 
846 		he= gethostbyname (Hostname->buffer);
847 
848 		rtl_string_release (Hostname);
849 		return __osl_hostentToHostAddr (he);
850 	}
851 	return ((oslHostAddr)NULL);
852 }
853 
854 /*****************************************************************************/
855 /* osl_createHostAddrByAddr */
856 /*****************************************************************************/
857 oslHostAddr SAL_CALL osl_createHostAddrByAddr(const oslSocketAddr pAddr)
858 {
859 	if (pAddr == NULL)
860 		return ((oslHostAddr)NULL);
861 
862 	if (pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
863 	{
864 		const struct sockaddr_in *sin= (const struct sockaddr_in *)&(pAddr->m_sockaddr);
865 
866 		if (sin->sin_addr.s_addr == htonl(INADDR_ANY))
867 			return ((oslHostAddr)NULL);
868 
869 		if (__osl_attemptSocketDialupImpl())
870 		{
871 			struct hostent *he;
872 			he= gethostbyaddr ((const sal_Char *)&(sin->sin_addr),
873 							   sizeof (sin->sin_addr),
874 							   sin->sin_family);
875 			return __osl_hostentToHostAddr (he);
876 		}
877 	}
878 
879 	return ((oslHostAddr)NULL);
880 }
881 
882 /*****************************************************************************/
883 /* osl_copyHostAddr */
884 /*****************************************************************************/
885 oslHostAddr SAL_CALL osl_copyHostAddr(const oslHostAddr Addr)
886 {
887 	oslHostAddr pAddr= (oslHostAddr)Addr;
888 
889 	if (pAddr)
890 		return osl_createHostAddr (pAddr->pHostName, pAddr->pSockAddr);
891 	else
892 		return ((oslHostAddr)NULL);
893 }
894 
895 /*****************************************************************************/
896 /* osl_getHostnameOfHostAddr */
897 /*****************************************************************************/
898 void SAL_CALL osl_getHostnameOfHostAddr(
899 	const oslHostAddr pAddr, rtl_uString **strHostname)
900 {
901 	if (pAddr)
902 		rtl_uString_assign (strHostname, pAddr->pHostName);
903 	else
904 		rtl_uString_new (strHostname);
905 }
906 
907 /*****************************************************************************/
908 /* osl_getSocketAddrOfHostAddr */
909 /*****************************************************************************/
910 oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr(const oslHostAddr pAddr)
911 {
912 	if (pAddr)
913 		return (const oslSocketAddr)(pAddr->pSockAddr);
914 	else
915 		return NULL;
916 }
917 
918 /*****************************************************************************/
919 /* osl_destroyHostAddr */
920 /*****************************************************************************/
921 void SAL_CALL osl_destroyHostAddr(oslHostAddr pAddr)
922 {
923 	if (pAddr)
924 	{
925 		if (pAddr->pHostName)
926 			rtl_uString_release (pAddr->pHostName);
927 		if (pAddr->pSockAddr)
928 			osl_destroySocketAddr( pAddr->pSockAddr );
929 
930 		rtl_freeMemory (pAddr);
931 	}
932 }
933 
934 /*****************************************************************************/
935 /* osl_getLocalHostname */
936 /*****************************************************************************/
937 oslSocketResult SAL_CALL osl_getLocalHostname (rtl_uString **strLocalHostname)
938 {
939 	static sal_Unicode LocalHostname[256] = {0};
940 
941 	if (rtl_ustr_getLength(LocalHostname) == 0)
942 	{
943 		sal_Char Host[256]= "";
944 		if (gethostname(Host, sizeof(Host)) == 0)
945 		{
946 			/* check if we have an FQDN */
947 	    	if (strchr(Host, '.') == NULL)
948 	        {
949 				oslHostAddr pAddr;
950 				rtl_uString     *hostName= NULL;
951 
952 				rtl_string2UString(
953 					&hostName, Host, strlen(Host),
954 					RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
955                 OSL_ASSERT(hostName != 0);
956 
957 				/* no, determine it via dns */
958 				pAddr = osl_createHostAddrByName(hostName);
959 				rtl_uString_release (hostName);
960 
961 				if (pAddr && pAddr->pHostName)
962 					memcpy(LocalHostname, pAddr->pHostName->buffer, sizeof(sal_Unicode)*(rtl_ustr_getLength(pAddr->pHostName->buffer)+1));
963 				else
964 					memset(LocalHostname, 0, sizeof(LocalHostname));
965 
966 				osl_destroyHostAddr ((oslHostAddr)pAddr);
967 			}
968 		}
969 	}
970 
971 	if (rtl_ustr_getLength(LocalHostname) > 0)
972 	{
973 		rtl_uString_newFromStr (strLocalHostname, LocalHostname);
974 		return osl_Socket_Ok;
975 	}
976 
977 	return osl_Socket_Error;
978 }
979 
980 /*****************************************************************************/
981 /* osl_resolveHostname */
982 /*****************************************************************************/
983 oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString* strHostname)
984 {
985 	oslHostAddr pAddr=
986 		(oslHostAddr )osl_createHostAddrByName (strHostname);
987 	if (pAddr)
988 	{
989 		oslSocketAddr SockAddr = osl_copySocketAddr( pAddr->pSockAddr );
990 		osl_destroyHostAddr(pAddr);
991 		return (SockAddr);
992 	}
993 	return ((oslSocketAddr)NULL);
994 }
995 
996 /*****************************************************************************/
997 /* osl_getServicePort */
998 /*****************************************************************************/
999 sal_Int32 SAL_CALL osl_getServicePort (
1000 	rtl_uString* strServicename,
1001 	rtl_uString* strProtocol)
1002 {
1003 	struct servent* ps;
1004 
1005 	rtl_String *str_Servicename=NULL;
1006 	rtl_String *str_Protocol=NULL;
1007 
1008 	rtl_uString2String(
1009 		&str_Servicename,
1010 		rtl_uString_getStr(strServicename),
1011 		rtl_uString_getLength(strServicename),
1012 		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
1013 	rtl_uString2String(
1014 		&str_Protocol,
1015 		rtl_uString_getStr(strProtocol),
1016 		rtl_uString_getLength(strProtocol),
1017 		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
1018 
1019 	ps= getservbyname(
1020 		rtl_string_getStr(str_Servicename),
1021 		rtl_string_getStr(str_Protocol));
1022 
1023 	rtl_string_release( str_Servicename );
1024 	rtl_string_release( str_Protocol );
1025 
1026 	if (ps != 0)
1027 		return ntohs(ps->s_port);
1028 
1029 	return OSL_INVALID_PORT;
1030 }
1031 
1032 /*****************************************************************************/
1033 /* osl_destroySocketAddr */
1034 /*****************************************************************************/
1035 void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr)
1036 {
1037 	__osl_destroySocketAddr( pAddr );
1038 }
1039 
1040 /*****************************************************************************/
1041 /* osl_getFamilyOfSocketAddr */
1042 /*****************************************************************************/
1043 oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
1044 {
1045 	if (pAddr)
1046 		return FAMILY_FROM_NATIVE(pAddr->m_sockaddr.sa_family);
1047 	else
1048 		return osl_Socket_FamilyInvalid;
1049 }
1050 
1051 /*****************************************************************************/
1052 /* osl_getInetPortOfSocketAddr */
1053 /*****************************************************************************/
1054 sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
1055 {
1056 	if( pAddr )
1057 	{
1058 		struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
1059 
1060 		if ( (pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet)))
1061 			return ntohs(pSystemInetAddr->sin_port);
1062 	}
1063 	return OSL_INVALID_PORT;
1064 }
1065 
1066 /*****************************************************************************/
1067 /* osl_setInetPortOfSocketAddr */
1068 /*****************************************************************************/
1069 sal_Bool SAL_CALL osl_setInetPortOfSocketAddr (
1070 	oslSocketAddr pAddr,
1071 	sal_Int32     Port)
1072 {
1073 	if (pAddr == NULL)
1074 		return sal_False;
1075 
1076 	struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
1077 
1078 	if (pSystemInetAddr->sin_family != FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1079 		return sal_False;
1080 
1081 	pSystemInetAddr->sin_port= htons((short)Port);
1082 	return sal_True;
1083 }
1084 
1085 /*****************************************************************************/
1086 /* osl_getHostnameOfSocketAddr */
1087 /*****************************************************************************/
1088 oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr (
1089 	oslSocketAddr   Addr,
1090 	rtl_uString   **strHostName)
1091 {
1092 	oslHostAddr pAddr= osl_createHostAddrByAddr (Addr);
1093 
1094 	if (pAddr)
1095 	{
1096 		rtl_uString_newFromString(strHostName, pAddr->pHostName);
1097 
1098 		osl_destroyHostAddr(pAddr);
1099 
1100 		return osl_Socket_Ok;
1101 	}
1102 
1103 	return osl_Socket_Error;
1104 }
1105 
1106 /*****************************************************************************/
1107 /* osl_getDottedInetAddrOfSocketAddr */
1108 /*****************************************************************************/
1109 oslSocketResult	SAL_CALL osl_getDottedInetAddrOfSocketAddr (
1110 	oslSocketAddr   pAddr,
1111 	rtl_uString   **strDottedInetAddr)
1112 {
1113 	sal_Char           *pDotted;
1114 
1115 	if (pAddr == NULL)
1116 		return osl_Socket_Error;
1117 
1118 	struct sockaddr_in *pSystemInetAddr = (struct sockaddr_in*) &(pAddr->m_sockaddr);
1119 	if (pSystemInetAddr->sin_family != FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
1120 		return osl_Socket_Error;
1121 
1122 	pDotted = inet_ntoa (pSystemInetAddr->sin_addr);
1123 	rtl_string2UString(
1124 		strDottedInetAddr, pDotted, strlen (pDotted),
1125 		RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
1126     OSL_ASSERT(*strDottedInetAddr != 0);
1127 
1128 	return osl_Socket_Ok;
1129 }
1130 
1131 /*****************************************************************************/
1132 /* osl_createSocket  */
1133 /*****************************************************************************/
1134 oslSocket SAL_CALL osl_createSocket (
1135 	oslAddrFamily Family,
1136 	oslSocketType Type,
1137 	oslProtocol   Protocol)
1138 {
1139 	/* alloc memory */
1140 	oslSocket pSocket = __osl_createSocketImpl(0);
1141 
1142 	if (pSocket == NULL)
1143 		return 0;
1144 
1145 	/* create socket */
1146 	pSocket->m_Socket= socket(FAMILY_TO_NATIVE(Family),
1147 								TYPE_TO_NATIVE(Type),
1148 								PROTOCOL_TO_NATIVE(Protocol));
1149 
1150 	/* creation failed => free memory */
1151 	if(pSocket->m_Socket == OSL_INVALID_SOCKET)
1152 	{
1153 		__osl_destroySocketImpl(pSocket);
1154 		pSocket= 0;
1155 	}
1156 	else
1157 	{
1158 		pSocket->m_Flags			= 0;
1159 		pSocket->m_CloseCallback	= NULL;
1160 		pSocket->m_CallbackArg	= NULL;
1161 	}
1162 
1163 	return pSocket;
1164 }
1165 
1166 void SAL_CALL osl_acquireSocket( oslSocket pSocket )
1167 {
1168 	osl_incrementInterlockedCount( &(pSocket->m_nRefCount) );
1169 }
1170 
1171 void SAL_CALL osl_releaseSocket( oslSocket pSocket )
1172 {
1173 	if( pSocket && 0 == osl_decrementInterlockedCount( &(pSocket->m_nRefCount) ) )
1174 	{
1175 		osl_closeSocket( pSocket );
1176 		__osl_destroySocketImpl( pSocket );
1177 	}
1178 }
1179 
1180 /*****************************************************************************/
1181 /* osl_closeSocket  */
1182 /*****************************************************************************/
1183 void SAL_CALL osl_closeSocket(oslSocket pSocket)
1184 {
1185 	/* socket already invalid */
1186 	if(pSocket==0)
1187 		return;
1188 
1189 	/* close */
1190 	closesocket(pSocket->m_Socket);
1191 
1192 	pSocket->m_Socket = OSL_INVALID_SOCKET;
1193 
1194 	/* registrierten Callback ausfuehren */
1195 	if (pSocket->m_CloseCallback != NULL)
1196 	{
1197 		pSocket->m_CloseCallback(pSocket->m_CallbackArg);
1198 	}
1199 }
1200 
1201 /*****************************************************************************/
1202 /* osl_getLocalAddrOfSocket  */
1203 /* Note that I rely on the fact that oslSocketAddr and struct sockaddr */
1204 /* are the same! I don't like it very much but see no other easy way */
1205 /* to conceal the struct sockaddr from the eyes of the user. */
1206 /*****************************************************************************/
1207 oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket)
1208 {
1209 	struct sockaddr Addr;
1210 	int             AddrLen;
1211 
1212 	if (pSocket == NULL) /* ENOTSOCK */
1213 		return ((oslSocketAddr)NULL);
1214 
1215 	AddrLen= sizeof(struct sockaddr);
1216 
1217 	if (getsockname(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
1218 		return ((oslSocketAddr)NULL);
1219 
1220 	oslSocketAddr pAddr = __osl_createSocketAddrFromSystem( &Addr );
1221 	return pAddr;
1222 }
1223 
1224 /*****************************************************************************/
1225 /* osl_getPeerAddrOfSocket  */
1226 /*****************************************************************************/
1227 oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
1228 {
1229 	struct sockaddr Addr;
1230 	int             AddrLen;
1231 
1232 	if (pSocket == NULL) /* ENOTSOCK */
1233 		return ((oslSocketAddr)NULL);
1234 
1235 	AddrLen= sizeof(struct sockaddr);
1236 
1237 	if (getpeername(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
1238 		return ((oslSocketAddr)NULL);
1239 
1240 	oslSocketAddr pAddr = __osl_createSocketAddrFromSystem( &Addr );
1241 	return pAddr;
1242 }
1243 
1244 /*****************************************************************************/
1245 /* osl_bindAddrToSocket  */
1246 /*****************************************************************************/
1247 sal_Bool SAL_CALL osl_bindAddrToSocket ( oslSocket pSocket, oslSocketAddr pAddr)
1248 {
1249 	OSL_ASSERT( pAddr );
1250 
1251 	if (pSocket == NULL) /* ENOTSOCK */
1252 		return sal_False;
1253 
1254 	return (bind(pSocket->m_Socket,
1255 				 &(pAddr->m_sockaddr),
1256 				 sizeof(struct sockaddr)) != OSL_SOCKET_ERROR);
1257 }
1258 
1259 /*****************************************************************************/
1260 /* osl_connectSocketTo  */
1261 /*****************************************************************************/
1262 oslSocketResult SAL_CALL osl_connectSocketTo (
1263 	oslSocket        pSocket,
1264 	oslSocketAddr    pAddr,
1265 	const TimeValue* pTimeout)
1266 {
1267 
1268 	if (pSocket == NULL) /* ENOTSOCK */
1269 		return osl_Socket_Error;
1270 
1271 	if (pAddr == NULL) /* EDESTADDRREQ */
1272 		return osl_Socket_Error;
1273 
1274 	if (!__osl_attemptSocketDialupImpl()) /* ENETDOWN */
1275 		return osl_Socket_Error;
1276 
1277 	if (pTimeout == NULL)
1278 	{
1279 		if(connect(pSocket->m_Socket,
1280 				   &(pAddr->m_sockaddr),
1281 					sizeof(struct sockaddr)) == OSL_SOCKET_ERROR)
1282 			return osl_Socket_Error;
1283 		else
1284 			return osl_Socket_Ok;
1285 	}
1286 	else
1287 	{
1288 		fd_set          fds;
1289 		int	            error;
1290 	    struct timeval  tv;
1291 		unsigned long   Param;
1292 		oslSocketResult Result= osl_Socket_Ok;
1293 
1294 		if (pSocket->m_Flags & OSL_SOCKET_FLAGS_NONBLOCKING)
1295 	    {
1296 			if (connect(pSocket->m_Socket,
1297 			    	    &(pAddr->m_sockaddr),
1298 						sizeof(struct sockaddr)) == OSL_SOCKET_ERROR)
1299 			{
1300 			    switch (WSAGetLastError())
1301 			    {
1302 					case WSAEWOULDBLOCK:
1303 					case WSAEINPROGRESS:
1304 						return osl_Socket_InProgress;
1305 
1306 					default:
1307 						return osl_Socket_Error;
1308 				}
1309 			}
1310 			else
1311 				return osl_Socket_Ok;
1312 		}
1313 
1314 		/* set socket temporarily to non-blocking */
1315 		Param= 1;
1316 		OSL_VERIFY(ioctlsocket(
1317 			pSocket->m_Socket, FIONBIO, &Param) != OSL_SOCKET_ERROR);
1318 
1319 		/* initiate connect */
1320 		if (connect(pSocket->m_Socket,
1321 		     	    &(pAddr->m_sockaddr),
1322 				    sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
1323 		{
1324 		   /* immediate connection */
1325 
1326 			Param= 0;
1327 			ioctlsocket(pSocket->m_Socket, FIONBIO, &Param);
1328 
1329 			return osl_Socket_Ok;
1330 	    }
1331 		else
1332 		{
1333 			error = WSAGetLastError();
1334 
1335 		    /* really an error or just delayed? */
1336 		    if (error != WSAEWOULDBLOCK && error != WSAEINPROGRESS)
1337 		    {
1338 			     Param= 0;
1339 			     ioctlsocket(pSocket->m_Socket, FIONBIO, &Param);
1340 
1341 			     return osl_Socket_Error;
1342 		    }
1343 		}
1344 
1345 		/* prepare select set for socket  */
1346 		FD_ZERO(&fds);
1347 		FD_SET(pSocket->m_Socket, &fds);
1348 
1349 		/* divide milliseconds into seconds and microseconds */
1350 		tv.tv_sec=	pTimeout->Seconds;
1351 		tv.tv_usec=	pTimeout->Nanosec / 1000L;
1352 
1353 		/* select */
1354 	    error= select(pSocket->m_Socket+1,
1355 		 		      0,
1356 					  &fds,
1357 					  0,
1358 					  &tv);
1359 
1360 		if (error > 0)  /* connected */
1361 		{
1362 			OSL_POSTCOND(
1363 				FD_ISSET(pSocket->m_Socket, &fds),
1364 				"osl_connectSocketTo(): select returned but socket not set\n");
1365 
1366 			Result= osl_Socket_Ok;
1367 
1368 		}
1369 		else if(error < 0)  /* error */
1370 		{
1371 		    /* errno == EBADF: most probably interrupted by close() */
1372 		    if(WSAGetLastError() == WSAEBADF)
1373 			{
1374 			    /* do not access pSockImpl because it is about to be or */
1375 			    /* already destroyed */
1376 			    return osl_Socket_Interrupted;
1377 			}
1378 			else
1379 			    Result= osl_Socket_Error;
1380 
1381 		}
1382 		else    /* timeout */
1383 			Result= osl_Socket_TimedOut;
1384 
1385 
1386 		/* clean up */
1387 		Param= 0;
1388 		ioctlsocket(pSocket->m_Socket, FIONBIO, &Param);
1389 
1390 		return Result;
1391 	}
1392 }
1393 
1394 /*****************************************************************************/
1395 /* osl_listenOnSocket  */
1396 /*****************************************************************************/
1397 sal_Bool SAL_CALL osl_listenOnSocket (
1398 	oslSocket  pSocket,
1399 	sal_Int32  MaxPendingConnections)
1400 {
1401 	if (pSocket == NULL) /* ENOTSOCK */
1402 		return sal_False;
1403 
1404 	return (listen(pSocket->m_Socket,
1405 				   MaxPendingConnections == -1 ?
1406 				   SOMAXCONN :
1407 				   MaxPendingConnections) != OSL_SOCKET_ERROR);
1408 }
1409 
1410 /*****************************************************************************/
1411 /* osl_acceptConnectionOnSocket  */
1412 /*****************************************************************************/
1413 oslSocket SAL_CALL osl_acceptConnectionOnSocket (
1414 	oslSocket      pSocket,
1415 	oslSocketAddr* ppAddr)
1416 {
1417 	if (pSocket == NULL) /* ENOTSOCK */
1418 		return ((oslSocket)NULL);
1419 
1420 	SOCKET          Connection;
1421 	if(ppAddr)
1422 	{
1423 		if( *ppAddr )
1424 		{
1425 			osl_destroySocketAddr( *ppAddr );
1426 			*ppAddr = 0;
1427 		}
1428 		int AddrLen= sizeof(struct sockaddr);
1429 
1430 		/* user wants to know peer Addr */
1431 		struct sockaddr Addr;
1432 
1433 		Connection=	accept(pSocket->m_Socket, &Addr, &AddrLen);
1434 		OSL_ASSERT(AddrLen == sizeof(struct sockaddr));
1435 
1436 		if(Connection != OSL_SOCKET_ERROR)
1437 			*ppAddr= __osl_createSocketAddrFromSystem(&Addr);
1438 		else
1439 			*ppAddr = NULL;
1440 	}
1441 	else
1442 	{
1443 		/* user is not interested in peer-addr */
1444 		Connection=	accept(pSocket->m_Socket, 0, 0);
1445 	}
1446 
1447 	/* accept failed? */
1448 	if(Connection == OSL_SOCKET_ERROR)
1449 		return ((oslSocket)NULL);
1450 
1451 	/* alloc memory */
1452 	oslSocket  pConnectionSocket;
1453 	pConnectionSocket= __osl_createSocketImpl(Connection);
1454 
1455 	pConnectionSocket->m_Flags			= 0;
1456 	pConnectionSocket->m_CloseCallback	= NULL;
1457 	pConnectionSocket->m_CallbackArg	= NULL;
1458 
1459 	return pConnectionSocket;
1460 }
1461 
1462 /*****************************************************************************/
1463 /* osl_receiveSocket  */
1464 /*****************************************************************************/
1465 sal_Int32 SAL_CALL osl_receiveSocket (
1466 	oslSocket        pSocket,
1467 	void*            pBuffer,
1468 	sal_uInt32       BytesToRead,
1469 	oslSocketMsgFlag Flag)
1470 {
1471 	if (pSocket == NULL) /* ENOTSOCK */
1472 		return osl_Socket_Error;
1473 
1474 	return recv(pSocket->m_Socket,
1475 				(sal_Char*)pBuffer,
1476 				BytesToRead,
1477 				MSG_FLAG_TO_NATIVE(Flag));
1478 }
1479 
1480 /*****************************************************************************/
1481 /* osl_receiveFromSocket  */
1482 /*****************************************************************************/
1483 sal_Int32 SAL_CALL osl_receiveFromSocket (
1484 	oslSocket        pSocket,
1485 	oslSocketAddr    SenderAddr,
1486 	void*            pBuffer,
1487 	sal_uInt32       BufferSize,
1488 	oslSocketMsgFlag Flag)
1489 {
1490 	struct sockaddr *pSystemSockAddr = 0;
1491 	int AddrLen = 0;
1492 	if( SenderAddr )
1493 	{
1494 		AddrLen = sizeof( struct sockaddr );
1495 		pSystemSockAddr = &(SenderAddr->m_sockaddr);
1496 	}
1497 
1498 	if (pSocket == NULL) /* ENOTSOCK */
1499 		return osl_Socket_Error;
1500 
1501 	return recvfrom(pSocket->m_Socket,
1502 					 (sal_Char*)pBuffer,
1503 					 BufferSize,
1504 					 MSG_FLAG_TO_NATIVE(Flag),
1505 					 pSystemSockAddr,
1506 					 &AddrLen);
1507 }
1508 
1509 /*****************************************************************************/
1510 /* osl_sendSocket  */
1511 /*****************************************************************************/
1512 sal_Int32 SAL_CALL osl_sendSocket (
1513 	oslSocket        pSocket,
1514 	const void*      pBuffer,
1515 	sal_uInt32       BytesToSend,
1516 	oslSocketMsgFlag Flag)
1517 {
1518 	if (pSocket == NULL) /* ENOTSOCK */
1519 		return osl_Socket_Error;
1520 
1521 	return send(pSocket->m_Socket,
1522 				(sal_Char*)pBuffer,
1523 				BytesToSend,
1524 				MSG_FLAG_TO_NATIVE(Flag));
1525 }
1526 
1527 /*****************************************************************************/
1528 /* osl_sendToSocket  */
1529 /*****************************************************************************/
1530 sal_Int32 SAL_CALL osl_sendToSocket (
1531 	oslSocket        pSocket,
1532 	oslSocketAddr    ReceiverAddr,
1533 	const void*      pBuffer,
1534 	sal_uInt32       BytesToSend,
1535 	oslSocketMsgFlag Flag)
1536 {
1537 	if (pSocket == NULL) /* ENOTSOCK */
1538 		return osl_Socket_Error;
1539 
1540 	/* ReceiverAddr might be 0 when used on a connected socket. */
1541 	/* Then sendto should behave like send. */
1542 
1543 	struct sockaddr *pSystemSockAddr = 0;
1544 	if( ReceiverAddr )
1545 		pSystemSockAddr = &(ReceiverAddr->m_sockaddr);
1546 
1547 	return sendto(pSocket->m_Socket,
1548 				  (sal_Char*)pBuffer,
1549 				  BytesToSend,
1550 				  MSG_FLAG_TO_NATIVE(Flag),
1551 				  pSystemSockAddr,
1552 				  pSystemSockAddr == 0 ? 0 : sizeof(struct sockaddr));
1553 }
1554 
1555 /*****************************************************************************/
1556 /* osl_readSocket  */
1557 /*****************************************************************************/
1558 sal_Int32 SAL_CALL osl_readSocket( oslSocket pSocket, void *pBuffer, sal_Int32 n )
1559 {
1560 	sal_uInt8 * Ptr = (sal_uInt8 *)pBuffer;
1561 
1562 	OSL_ASSERT( pSocket);
1563 
1564 	/* loop until all desired bytes were read or an error occured */
1565 	sal_uInt32 BytesRead= 0;
1566 	sal_uInt32 BytesToRead= n;
1567 	while (BytesToRead > 0)
1568 	{
1569 		sal_Int32 RetVal;
1570 		RetVal= osl_receiveSocket(pSocket,
1571 								   Ptr,
1572 								   BytesToRead,
1573 								   osl_Socket_MsgNormal);
1574 
1575 		/* error occured? */
1576 		if(RetVal <= 0)
1577 		{
1578 			break;
1579 		}
1580 
1581 		BytesToRead -= RetVal;
1582 		BytesRead += RetVal;
1583 		Ptr += RetVal;
1584 	}
1585 
1586 	return BytesRead;
1587 }
1588 
1589 /*****************************************************************************/
1590 /* osl_writeSocket  */
1591 /*****************************************************************************/
1592 sal_Int32 SAL_CALL osl_writeSocket( oslSocket pSocket, const void *pBuffer, sal_Int32 n )
1593 {
1594     OSL_ASSERT( pSocket );
1595 
1596 	/* loop until all desired bytes were send or an error occured */
1597 	sal_uInt32 BytesSend= 0;
1598 	sal_uInt32 BytesToSend= n;
1599 	sal_uInt8 *Ptr = ( sal_uInt8 * )pBuffer;
1600 	while (BytesToSend > 0)
1601 	{
1602 		sal_Int32 RetVal;
1603 
1604 		RetVal= osl_sendSocket( pSocket,Ptr,BytesToSend,osl_Socket_MsgNormal);
1605 
1606 		/* error occured? */
1607 		if(RetVal <= 0)
1608 		{
1609 			break;
1610 		}
1611 
1612 		BytesToSend -= RetVal;
1613 		BytesSend += RetVal;
1614 		Ptr += RetVal;
1615 
1616 	}
1617 	return BytesSend;
1618 }
1619 
1620 
1621 /*****************************************************************************/
1622 /* osl_isReceiveReady  */
1623 /*****************************************************************************/
1624 sal_Bool SAL_CALL osl_isReceiveReady (
1625 	oslSocket        pSocket,
1626 	const TimeValue* pTimeout)
1627 {
1628 	fd_set         fds;
1629 	struct timeval tv;
1630 
1631 	if (pSocket == NULL) /* ENOTSOCK */
1632 		return sal_False;
1633 
1634 	FD_ZERO(&fds);
1635 	FD_SET(pSocket->m_Socket, &fds);
1636 
1637 	if (pTimeout)
1638 	{
1639 		tv.tv_sec  = pTimeout->Seconds;
1640 		tv.tv_usec = pTimeout->Nanosec / 1000L;
1641 	}
1642 
1643 	return (select(pSocket->m_Socket + 1,		/* no of sockets to monitor */
1644 				   &fds,						/* check read operations */
1645 				   0,							/* check write ops */
1646 				   0,							/* ckeck for OOB */
1647 				   (pTimeout) ? &tv : 0)==1);	/* use timeout? */
1648 }
1649 
1650 /*****************************************************************************/
1651 /* osl_isSendReady  */
1652 /*****************************************************************************/
1653 sal_Bool SAL_CALL osl_isSendReady (
1654 	oslSocket        pSocket,
1655 	const TimeValue* pTimeout)
1656 {
1657 	fd_set         fds;
1658 	struct timeval tv;
1659 
1660 	if (pSocket == NULL) /* ENOTSOCK */
1661 		return sal_False;
1662 
1663 	FD_ZERO(&fds);
1664 	FD_SET(pSocket->m_Socket, &fds);
1665 
1666 	if (pTimeout)
1667 	{
1668 		tv.tv_sec  = pTimeout->Seconds;
1669 		tv.tv_usec = pTimeout->Nanosec / 1000L;
1670 	}
1671 
1672 	return (select(pSocket->m_Socket + 1,		/* no of sockets to monitor */
1673 				   0,							/* check read operations */
1674 				   &fds,						/* check write ops */
1675 				   0,							/* ckeck for OOB */
1676 				   (pTimeout) ? &tv : 0)==1);	/* use timeout? */
1677 }
1678 
1679 /*****************************************************************************/
1680 /* osl_isExceptionPending  */
1681 /*****************************************************************************/
1682 sal_Bool SAL_CALL osl_isExceptionPending (
1683 	oslSocket        pSocket,
1684 	const TimeValue* pTimeout)
1685 {
1686 	fd_set         fds;
1687 	struct timeval tv;
1688 
1689 	if (pSocket == NULL) /* ENOTSOCK */
1690 		return sal_False;
1691 
1692 	FD_ZERO(&fds);
1693 	FD_SET(pSocket->m_Socket, &fds);
1694 
1695 	if (pTimeout)
1696 	{
1697 		tv.tv_sec  = pTimeout->Seconds;
1698 		tv.tv_usec = pTimeout->Nanosec / 1000L;
1699 	}
1700 
1701 	return (select(pSocket->m_Socket + 1,	    /* no of sockets to monitor */
1702 				   0,							/* check read operations */
1703 				   0,							/* check write ops */
1704 				   &fds,						/* ckeck for OOB */
1705 				   (pTimeout) ? &tv : 0)==1);	/* use timeout? */
1706 }
1707 
1708 /*****************************************************************************/
1709 /* osl_shutdownSocket  */
1710 /*****************************************************************************/
1711 sal_Bool SAL_CALL osl_shutdownSocket (
1712 	oslSocket          pSocket,
1713 	oslSocketDirection Direction)
1714 {
1715 	if (pSocket == NULL) /* ENOTSOCK */
1716 		return sal_False;
1717 
1718 	return (shutdown(pSocket->m_Socket, DIRECTION_TO_NATIVE(Direction))==0);
1719 }
1720 
1721 /*****************************************************************************/
1722 /* osl_getSocketOption  */
1723 /*****************************************************************************/
1724 sal_Int32 SAL_CALL osl_getSocketOption (
1725 	oslSocket            pSocket,
1726 	oslSocketOptionLevel Level,
1727 	oslSocketOption      Option,
1728 	void*                pBuffer,
1729 	sal_uInt32           BufferLen)
1730 {
1731 	if (pSocket == NULL) /* ENOTSOCK */
1732 		return osl_Socket_Error;
1733 
1734 	if (getsockopt(pSocket->m_Socket,
1735 	     		   OPTION_LEVEL_TO_NATIVE(Level),
1736 				   OPTION_TO_NATIVE(Option),
1737 				   (sal_Char*)pBuffer,
1738 				   (int*)&BufferLen) == -1)
1739 	{
1740 		return -1;
1741 	}
1742 
1743 	return (sal_Int32)BufferLen;
1744 }
1745 
1746 /*****************************************************************************/
1747 /* osl_setSocketOption  */
1748 /*****************************************************************************/
1749 sal_Bool SAL_CALL osl_setSocketOption (
1750 	oslSocket            pSocket,
1751 	oslSocketOptionLevel Level,
1752 	oslSocketOption      Option,
1753 	void*                pBuffer,
1754 	sal_uInt32           BufferLen)
1755 {
1756 	if (pSocket == NULL) /* ENOTSOCK */
1757 		return sal_False;
1758 
1759 	return(setsockopt(pSocket->m_Socket,
1760 					  OPTION_LEVEL_TO_NATIVE(Level),
1761 					  OPTION_TO_NATIVE(Option),
1762 					  (sal_Char*)pBuffer,
1763 					  BufferLen) == 0);
1764 }
1765 
1766 /*****************************************************************************/
1767 /* osl_enableNonBlockingMode  */
1768 /*****************************************************************************/
1769 sal_Bool SAL_CALL osl_enableNonBlockingMode ( oslSocket pSocket, sal_Bool  On)
1770 {
1771 	unsigned long  Param= On ? 1 : 0;
1772 
1773 	if (pSocket == NULL) /* ENOTSOCK */
1774 		return sal_False;
1775 
1776 	pSocket->m_Flags = Param ?
1777 		(pSocket->m_Flags |  OSL_SOCKET_FLAGS_NONBLOCKING) :
1778 		(pSocket->m_Flags & ~OSL_SOCKET_FLAGS_NONBLOCKING) ;
1779 
1780 	return (
1781 		ioctlsocket(pSocket->m_Socket, FIONBIO, &Param) != OSL_SOCKET_ERROR);
1782 }
1783 
1784 /*****************************************************************************/
1785 /* osl_isNonBlockingMode  */
1786 /*****************************************************************************/
1787 sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
1788 {
1789 	if (pSocket == NULL) /* ENOTSOCK */
1790 		return sal_False;
1791 
1792 	return (sal_Bool)((pSocket->m_Flags & OSL_SOCKET_FLAGS_NONBLOCKING) != 0);
1793 }
1794 
1795 /*****************************************************************************/
1796 /* osl_getSocketType  */
1797 /*****************************************************************************/
1798 oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
1799 {
1800 	int            Type=0;
1801 	int            TypeSize= sizeof(Type);
1802 
1803 	if (pSocket == NULL) /* ENOTSOCK */
1804 		return osl_Socket_TypeInvalid;
1805 
1806 	if(getsockopt(pSocket->m_Socket,
1807 				  OPTION_LEVEL_TO_NATIVE(osl_Socket_LevelSocket),
1808 				  OPTION_TO_NATIVE(osl_Socket_OptionType),
1809 				  (sal_Char *)&Type,
1810 				  &TypeSize) == -1)
1811 	{
1812 		/* error */
1813 		return osl_Socket_TypeInvalid;
1814 	}
1815 
1816 	return TYPE_FROM_NATIVE(Type);
1817 }
1818 
1819 /*****************************************************************************/
1820 /* osl_getLastSocketErrorDescription  */
1821 /*****************************************************************************/
1822 void SAL_CALL osl_getLastSocketErrorDescription (
1823 	oslSocket  /*Socket*/,
1824 	rtl_uString	**strError)
1825 {
1826 	int error;
1827 
1828 	switch(error = WSAGetLastError())
1829 	{
1830 		case WSAENOTSOCK:
1831 			rtl_uString_newFromAscii (strError, "WSAENOTSOCK, Socket operation on non-socket. A socket created in one process is used by another process.");
1832             break;
1833 
1834         case WSAEDESTADDRREQ:
1835 			rtl_uString_newFromAscii (strError, "WSAEDESTADDRREQ, Destination Addr required");
1836             break;
1837 
1838         case WSAEMSGSIZE:
1839             rtl_uString_newFromAscii (strError, "WSAEMSGSIZE, Message too long");
1840             break;
1841 
1842         case WSAEPROTOTYPE:
1843 			rtl_uString_newFromAscii (strError, "WSAEPROTOTYPE, Protocol wrong type for socket");
1844             break;
1845 
1846         case WSAENOPROTOOPT:
1847 			rtl_uString_newFromAscii (strError, "WSAENOPROTOOPT, Protocol not available");
1848             break;
1849 
1850         case WSAEPROTONOSUPPORT:
1851 			rtl_uString_newFromAscii (strError, "WSAEPROTONOSUPPORT, Protocol not supported");
1852             break;
1853 
1854         case WSAESOCKTNOSUPPORT:
1855 			rtl_uString_newFromAscii (strError, "WSAESOCKTNOSUPPORT, Socket type not supported");
1856             break;
1857 
1858         case WSAEOPNOTSUPP:
1859 			rtl_uString_newFromAscii (strError, "WSAEOPNOTSUPP, Operation not supported on socket");
1860             break;
1861 
1862         case WSAEPFNOSUPPORT:
1863 			rtl_uString_newFromAscii (strError, "WSAEPFNOSUPPORT, Protocol family not supported");
1864             break;
1865 
1866         case WSAEAFNOSUPPORT:
1867 			rtl_uString_newFromAscii (strError, "WSEAFNOSUPPORT, Addr family not supported by protocol family");
1868             break;
1869 
1870         case WSAEADDRINUSE:
1871 			rtl_uString_newFromAscii (strError, "WSAEADDRINUSE, Triggered by bind() because a process went down without closing a socket.");
1872             break;
1873 
1874         case WSAEADDRNOTAVAIL:
1875 			rtl_uString_newFromAscii (strError, "WSAEADDRNOTAVAIL, Can't assign requested Addr");
1876             break;
1877 
1878         case WSAENETDOWN:
1879 			rtl_uString_newFromAscii (strError, "WSAENETDOWN, Network is down");
1880             break;
1881 
1882         case WSAENETUNREACH:
1883 			rtl_uString_newFromAscii (strError, "WSAENETUNREACH, Network is unreachable");
1884             break;
1885 
1886         case WSAENETRESET:
1887 			rtl_uString_newFromAscii (strError, "WSAENETRESET, Network dropped connection or reset");
1888             break;
1889 
1890         case WSAECONNABORTED:
1891 			rtl_uString_newFromAscii (strError, "WSAECONNABORTED, Software caused connection abort");
1892             break;
1893 
1894         case WSAECONNRESET:
1895 			rtl_uString_newFromAscii (strError, "WSAECONNRESET, Connection reset by peer");
1896             break;
1897 
1898         case WSAENOBUFS:
1899 			rtl_uString_newFromAscii (strError, "WSAENOBUFS, No buffer space available.");
1900             break;
1901 
1902         case WSAEISCONN:
1903 			rtl_uString_newFromAscii (strError, "WSAEISCONN, Socket is already connected");
1904             break;
1905 
1906         case WSAENOTCONN:
1907 			rtl_uString_newFromAscii (strError, "WSAENOTCONN, Socket is not connected");
1908             break;
1909 
1910         case WSAESHUTDOWN:
1911 			rtl_uString_newFromAscii (strError, "WSAESHUTDOWN, Can't send after socket shutdown");
1912             break;
1913 
1914         case WSAETIMEDOUT:
1915 			rtl_uString_newFromAscii (strError, "WSAETIMEDOUT, Connection timed out");
1916             break;
1917 
1918         case WSAECONNREFUSED:
1919 			rtl_uString_newFromAscii (strError, "WSAECONNREFUSED, Connection refused");
1920             break;
1921 
1922         case WSAEHOSTDOWN:
1923 			rtl_uString_newFromAscii (strError, "WSAEHOSTDOWN, Networking subsystem not started");
1924             break;
1925 
1926         case WSAEHOSTUNREACH:
1927 			rtl_uString_newFromAscii (strError, "WSAEHOSTUNREACH, No route to host");
1928             break;
1929 
1930         case WSAEWOULDBLOCK:
1931 			rtl_uString_newFromAscii (strError, "WSAEWOULDBLOCK, Operation would block");
1932             break;
1933 
1934         case WSAEINPROGRESS:
1935 			rtl_uString_newFromAscii (strError, "WSAEINPROGRESS, Operation now in progress");
1936             break;
1937 
1938         case WSAEALREADY:
1939 			rtl_uString_newFromAscii (strError, "WSAEALREADY, Operation already in progress");
1940             break;
1941 
1942         case WSAEINTR:
1943 			rtl_uString_newFromAscii (strError, "WSAEALREADY, Operation was interrupted");
1944             break;
1945 
1946         case WSAEBADF:
1947 			rtl_uString_newFromAscii (strError, "WSAEBADF, Bad file number");
1948             break;
1949 
1950         case WSAEACCES:
1951 			rtl_uString_newFromAscii (strError, "WSAEACCES, Access is denied");
1952             break;
1953 
1954         case WSAEFAULT:
1955 			rtl_uString_newFromAscii (strError, "WSAEFAULT, Bad memory Addr");
1956             break;
1957 
1958         case WSAEINVAL:
1959 			rtl_uString_newFromAscii (strError, "WSAEINVAL, The socket has not been bound with bind() or is already connected");
1960             break;
1961 
1962         case WSAEMFILE:
1963 			rtl_uString_newFromAscii (strError, "WSAEMFILE, No more file descriptors are available");
1964             break;
1965 
1966         case WSAETOOMANYREFS:
1967 			rtl_uString_newFromAscii (strError, "WSAETOOMANYREFS, Undocumented WinSock error");
1968             break;
1969 
1970         case WSAENAMETOOLONG:
1971 			rtl_uString_newFromAscii (strError, "WSAENAMETOOLONG, Undocumented WinSock error");
1972             break;
1973 
1974         case WSAENOTEMPTY:
1975 			rtl_uString_newFromAscii (strError, "WSAENOTEMPTY, Undocumented WinSock error");
1976             break;
1977 
1978         case WSAEPROCLIM:
1979 			rtl_uString_newFromAscii (strError, "WSAEPROCLIM, Undocumented WinSock error");
1980             break;
1981 
1982         case WSAEUSERS:
1983 			rtl_uString_newFromAscii (strError, "WSAEUSERS, Undocumented WinSock error");
1984             break;
1985 
1986         case WSAEDQUOT:
1987 			rtl_uString_newFromAscii (strError, "WSAEDQUOT, Undocumented WinSock error");
1988             break;
1989 
1990         case WSAESTALE:
1991 			rtl_uString_newFromAscii (strError, "WSAESTALE, Undocumented WinSock error");
1992             break;
1993 
1994         case WSAEREMOTE:
1995 			rtl_uString_newFromAscii (strError, "WSAEREMOTE, Undocumented WinSock error");
1996             break;
1997 
1998         case WSAEDISCON:
1999 			rtl_uString_newFromAscii (strError, "WSAEDISCON, Circuit was gracefully terminated");
2000             break;
2001 
2002         case WSASYSNOTREADY:
2003 			rtl_uString_newFromAscii (strError, "WSASYSNOTREADY, The underlying network subsystem is not ready for network communication");
2004             break;
2005 
2006         case WSAVERNOTSUPPORTED:
2007 			rtl_uString_newFromAscii (strError, "WSAVERNOTSUPPORTED, The version of Windows Sockets API support requested is not provided by this particular Windows Sockets implementation");
2008             break;
2009 
2010         case WSANOTINITIALISED:
2011 			rtl_uString_newFromAscii (strError, "WSANOTINITIALISED, WSAStartup() has not been called");
2012             break;
2013 
2014         case WSAHOST_NOT_FOUND:
2015 			rtl_uString_newFromAscii (strError, "WSAHOST_NOT_FOUND, Authoritative answer host not found");
2016             break;
2017 
2018         case WSATRY_AGAIN:
2019 			rtl_uString_newFromAscii (strError, "WSATRY_AGAIN, Non-authoritative answer host not found or SERVERFAIL");
2020             break;
2021 
2022         case WSANO_RECOVERY:
2023 			rtl_uString_newFromAscii (strError, "WSANO_RECOVERY, Non recoverable errors, FORMERR, REFUSED, NOTIMP");
2024             break;
2025 
2026         case WSANO_DATA:
2027 			rtl_uString_newFromAscii (strError, "WSANO_DATA or WSANO_ADDRESS, Valid name, no data record of requested type");
2028             break;
2029 
2030 		default:
2031 		{
2032 			sal_Unicode message[128];
2033 
2034             wsprintfW(reinterpret_cast<LPWSTR>(message), L"Unknown WinSock Error Number %d", error);
2035 			rtl_uString_newFromStr (strError, message);
2036         }
2037 
2038         return;
2039 
2040 	}
2041 }
2042 
2043 /*****************************************************************************/
2044 /* osl_getLastSocketError  */
2045 /*****************************************************************************/
2046 oslSocketError SAL_CALL osl_getLastSocketError(oslSocket /*Socket*/)
2047 {
2048 	return ERROR_FROM_NATIVE(WSAGetLastError());
2049 }
2050 
2051 /*****************************************************************************/
2052 /* SocketSet                                                                 */
2053 /*****************************************************************************/
2054 typedef struct _TSocketSetImpl
2055 {
2056 	fd_set	m_Set;			/* the set of descriptors */
2057 
2058 } TSocketSetImpl;
2059 
2060 /*****************************************************************************/
2061 /* osl_createSocketSet  */
2062 /*****************************************************************************/
2063 oslSocketSet SAL_CALL osl_createSocketSet()
2064 {
2065 	TSocketSetImpl* pSet;
2066 
2067 	pSet = (TSocketSetImpl*) rtl_allocateMemory(sizeof(TSocketSetImpl));
2068 
2069 	if(pSet)
2070 	{
2071 		FD_ZERO(&pSet->m_Set);
2072 	}
2073 
2074 	return (oslSocketSet)pSet;
2075 }
2076 
2077 /*****************************************************************************/
2078 /* osl_destroySocketSet  */
2079 /*****************************************************************************/
2080 void SAL_CALL osl_destroySocketSet (oslSocketSet Set)
2081 {
2082 	if(Set)
2083 		rtl_freeMemory(Set);
2084 }
2085 
2086 /*****************************************************************************/
2087 /* osl_clearSocketSet  */
2088 /*****************************************************************************/
2089 void SAL_CALL osl_clearSocketSet (oslSocketSet Set)
2090 {
2091 	TSocketSetImpl* pSet;
2092 
2093 	pSet= (TSocketSetImpl*)Set;
2094 
2095 	if (pSet)
2096 		FD_ZERO(&pSet->m_Set);
2097 }
2098 
2099 /*****************************************************************************/
2100 /* osl_addToSocketSet  */
2101 /*****************************************************************************/
2102 void SAL_CALL osl_addToSocketSet (
2103 	oslSocketSet Set,
2104 	oslSocket    Socket)
2105 {
2106 	TSocketSetImpl* pSet;
2107 	oslSocketImpl*  pSockImpl;
2108 
2109 	pSet= (TSocketSetImpl*)Set;
2110 	pSockImpl= (oslSocketImpl*)Socket;
2111 
2112 	if (pSet && pSockImpl)
2113 		FD_SET(pSockImpl->m_Socket, &pSet->m_Set);
2114 }
2115 
2116 /*****************************************************************************/
2117 /* osl_removeFromSocketSet  */
2118 /*****************************************************************************/
2119 void SAL_CALL osl_removeFromSocketSet (
2120 	oslSocketSet Set,
2121 	oslSocket    Socket)
2122 {
2123 	TSocketSetImpl* pSet;
2124 	oslSocketImpl*  pSockImpl;
2125 
2126 	pSet= (TSocketSetImpl*)Set;
2127 	pSockImpl= (oslSocketImpl*)Socket;
2128 
2129 	if (pSet && pSockImpl)
2130 		FD_CLR(pSockImpl->m_Socket, &pSet->m_Set);
2131 }
2132 
2133 /*****************************************************************************/
2134 /* osl_isInSocketSet  */
2135 /*****************************************************************************/
2136 sal_Bool SAL_CALL osl_isInSocketSet (
2137 	oslSocketSet Set,
2138 	oslSocket    Socket)
2139 {
2140 	TSocketSetImpl* pSet;
2141 	oslSocketImpl*  pSockImpl;
2142 
2143 	pSet= (TSocketSetImpl*)Set;
2144 	pSockImpl= (oslSocketImpl*)Socket;
2145 
2146 	if (pSet && pSockImpl)
2147 		return (FD_ISSET(pSockImpl->m_Socket, &pSet->m_Set) != 0);
2148 	else
2149 		return sal_False;
2150 }
2151 
2152 /*****************************************************************************/
2153 /* osl_demultiplexSocketEvents  */
2154 /*****************************************************************************/
2155 sal_Int32 SAL_CALL osl_demultiplexSocketEvents (
2156 	oslSocketSet IncomingSet,
2157 	oslSocketSet OutgoingSet,
2158 	oslSocketSet OutOfBandSet,
2159 	const TimeValue* pTimeout)
2160 {
2161 	int             MaxHandle= 0;
2162 	struct timeval  tv;
2163 	TSocketSetImpl* pInSet;
2164 	TSocketSetImpl* pOutSet;
2165 	TSocketSetImpl* pOOBSet;
2166 
2167 	if(pTimeout)
2168 	{
2169 		/* divide milliseconds into seconds and microseconds */
2170 		tv.tv_sec  = pTimeout->Seconds;
2171 		tv.tv_usec = pTimeout->Nanosec / 1000L;
2172 	}
2173 
2174 	/* map opaque data to impl-types */
2175 	pInSet= (TSocketSetImpl*)IncomingSet;
2176 	pOutSet= (TSocketSetImpl*)OutgoingSet;
2177 	pOOBSet= (TSocketSetImpl*)OutOfBandSet;
2178 
2179 	return select(MaxHandle,				/* redundant in WIN32 */
2180 				  pInSet ? &pInSet->m_Set : 0,
2181 				  pOutSet ? &pOutSet->m_Set : 0,
2182 				  pOOBSet ? &pOOBSet->m_Set : 0,
2183 				  pTimeout ? &tv : 0);
2184 }
2185 
2186 }
2187