LCOV - code coverage report
Current view: top level - sal/osl/unx - socket.c (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 757 0.0 %
Date: 2014-04-14 Functions: 0 81 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "system.h"
      21             : 
      22             : #include <osl/socket.h>
      23             : #include <osl/diagnose.h>
      24             : #include <osl/mutex.h>
      25             : #include <osl/signal.h>
      26             : 
      27             : #include <rtl/alloc.h>
      28             : 
      29             : #include <ctype.h>
      30             : #include <sal/types.h>
      31             : 
      32             : #include "sockimpl.h"
      33             : 
      34             : /* defines for poll */
      35             : #ifdef HAVE_POLL_H
      36             : #undef HAVE_POLL_H
      37             : #endif
      38             : 
      39             : #if defined(LINUX) || defined(NETBSD) || defined ( FREEBSD ) || \
      40             :     defined (MACOSX) || defined (OPENBSD) || defined(DRAGONFLY)
      41             : #include <sys/poll.h>
      42             : #define HAVE_POLL_H
      43             : #endif /* HAVE_POLL_H */
      44             : 
      45             : #if defined(SOLARIS)
      46             : #include <poll.h>
      47             : #define HAVE_POLL_H
      48             : #endif /* SOLARIS */
      49             : 
      50             : #ifndef HAVE_POLL_H
      51             : #define POLLIN  0x0001
      52             : #define POLLOUT 0x0002
      53             : #define POLLPRI 0x0004
      54             : #endif /* HAVE_POLL_H */
      55             : 
      56             : /* defines for shutdown */
      57             : #define SD_RECEIVE 0
      58             : #define SD_SEND 1
      59             : #define SD_BOTH 2
      60             : 
      61             : /*
      62             :     oslSocketAddr is a pointer to a Berkeley struct sockaddr.
      63             :     I refrained from using sockaddr_in because of possible further
      64             :     extensions of this socket-interface (IP-NG?).
      65             :     The intention was to hide all Berkeley data-structures from
      66             :     direct access past the osl-interface.
      67             : 
      68             :     The current implementation is internet (IP) centered. All
      69             :     the constructor-functions (osl_create...) take parameters
      70             :     that will probably make sense only in the IP-environment
      71             :     (e.g. because of using the dotted-address-format).
      72             : 
      73             :     If the interface will be extended to host other protocol-
      74             :     families, I expect no externally visible changes in the
      75             :     existing functions. You'll probably need only new
      76             :     constructor-functions who take the different address
      77             :     formats into consideration (maybe a long dotted address
      78             :     or whatever).
      79             : */
      80             : 
      81             : /* _Note_ that I rely on the fact that oslSocketAddr and struct sockaddr */
      82             : /* are the same! I don't like it very much but see no other easy way to  */
      83             : /* conceal the struct sockaddr from the eyes of the user. */
      84             : 
      85             : #define OSL_INVALID_SOCKET      -1
      86             : #define OSL_SOCKET_ERROR        -1
      87             : 
      88             : /* Buffer size for gethostbyname */
      89             : #define MAX_HOSTBUFFER_SIZE 2048
      90             : 
      91             : /*****************************************************************************/
      92             : /* enum oslAddrFamily */
      93             : /*****************************************************************************/
      94             : 
      95             : /* map */
      96             : static const unsigned long FamilyMap[]= {
      97             :     AF_INET,                    /* osl_Socket_FamilyInet    */
      98             :     AF_IPX,                     /* osl_Socket_FamilyIpx     */
      99             :     0                           /* osl_Socket_FamilyInvalid */
     100             : };
     101             : 
     102             : /* reverse map */
     103           0 : static oslAddrFamily osl_AddrFamilyFromNative(sal_uInt32 nativeType)
     104             : {
     105           0 :     oslAddrFamily i= (oslAddrFamily)0;
     106             : 
     107           0 :     while(i != osl_Socket_FamilyInvalid)
     108             :     {
     109           0 :         if(FamilyMap[i] == nativeType)
     110           0 :             return i;
     111           0 :         i = (oslAddrFamily) ( i + 1 );
     112             :     }
     113             : 
     114           0 :     return i;
     115             : }
     116             : 
     117             : /* macros */
     118             : #define FAMILY_FROM_NATIVE(y) osl_AddrFamilyFromNative(y)
     119             : #define FAMILY_TO_NATIVE(x) (short)FamilyMap[x]
     120             : 
     121             : /*****************************************************************************/
     122             : /* enum oslProtocol */
     123             : /*****************************************************************************/
     124             : 
     125             : /* map */
     126             : static const sal_uInt32 ProtocolMap[]= {
     127             :     0,                          /* osl_Socket_ProtocolIp      */
     128             :     NSPROTO_IPX,                /* osl_Socket_ProtocolIpx     */
     129             :     NSPROTO_SPX,                /* osl_Socket_ProtocolSpx     */
     130             :     NSPROTO_SPXII,              /* osl_Socket_ProtocolSpxII   */
     131             :     0                           /* osl_Socket_ProtocolInvalid */
     132             : };
     133             : 
     134             : /* reverse map */
     135             : /* mfe: NOT USED
     136             : static oslProtocol osl_ProtocolFromNative(sal_uInt32 nativeType)
     137             : {
     138             :     oslProtocol i= (oslProtocol)0;
     139             : 
     140             :     while(i != osl_Socket_ProtocolInvalid)
     141             :     {
     142             :         if(ProtocolMap[i] == nativeType)
     143             :             return i;
     144             :         i = (oslProtocol) ( i + 1);
     145             :     }
     146             : 
     147             :     return i;
     148             : }
     149             : */
     150             : 
     151             : /* macros */
     152             : #define PROTOCOL_TO_NATIVE(x)   ProtocolMap[x]
     153             : 
     154             : /*****************************************************************************/
     155             : /* enum oslSocketType */
     156             : /*****************************************************************************/
     157             : 
     158             : /* map */
     159             : static const sal_uInt32 TypeMap[]= {
     160             :     SOCK_STREAM,                /* osl_Socket_TypeStream    */
     161             :     SOCK_DGRAM,                 /* osl_Socket_TypeDgram     */
     162             :     SOCK_RAW,                   /* osl_Socket_TypeRaw       */
     163             :     SOCK_RDM,                   /* osl_Socket_TypeRdm       */
     164             :     SOCK_SEQPACKET,             /* osl_Socket_TypeSeqPacket */
     165             :     0                           /* osl_Socket_TypeInvalid   */
     166             : };
     167             : 
     168             : /* reverse map */
     169           0 : static oslSocketType osl_SocketTypeFromNative(sal_uInt32 nativeType)
     170             : {
     171           0 :     oslSocketType i= (oslSocketType)0;
     172             : 
     173           0 :     while(i != osl_Socket_TypeInvalid)
     174             :     {
     175           0 :         if(TypeMap[i] == nativeType)
     176           0 :             return i;
     177           0 :         i = (oslSocketType)(i + 1);
     178             :     }
     179             : 
     180           0 :     return i;
     181             : }
     182             : 
     183             : /* macros */
     184             : #define TYPE_TO_NATIVE(x)       TypeMap[x]
     185             : #define TYPE_FROM_NATIVE(y)     osl_SocketTypeFromNative(y)
     186             : 
     187             : /*****************************************************************************/
     188             : /* enum oslSocketOption */
     189             : /*****************************************************************************/
     190             : 
     191             : /* map */
     192             : static const sal_uInt32 OptionMap[]= {
     193             :     SO_DEBUG,                   /* osl_Socket_OptionDebug       */
     194             :     SO_ACCEPTCONN,              /* osl_Socket_OptionAcceptConn  */
     195             :     SO_REUSEADDR,               /* osl_Socket_OptionReuseAddr   */
     196             :     SO_KEEPALIVE,               /* osl_Socket_OptionKeepAlive   */
     197             :     SO_DONTROUTE,               /* osl_Socket_OptionDontRoute   */
     198             :     SO_BROADCAST,               /* osl_Socket_OptionBroadcast   */
     199             :     SO_USELOOPBACK,             /* osl_Socket_OptionUseLoopback */
     200             :     SO_LINGER,                  /* osl_Socket_OptionLinger      */
     201             :     SO_OOBINLINE,               /* osl_Socket_OptionOOBinLine   */
     202             :     SO_SNDBUF,                  /* osl_Socket_OptionSndBuf      */
     203             :     SO_RCVBUF,                  /* osl_Socket_OptionRcvBuf      */
     204             :     SO_SNDLOWAT,                /* osl_Socket_OptionSndLowat    */
     205             :     SO_RCVLOWAT,                /* osl_Socket_OptionRcvLowat    */
     206             :     SO_SNDTIMEO,                /* osl_Socket_OptionSndTimeo    */
     207             :     SO_RCVTIMEO,                /* osl_Socket_OptionRcvTimeo    */
     208             :     SO_ERROR,                   /* osl_Socket_OptionError       */
     209             :     SO_TYPE,                    /* osl_Socket_OptionType        */
     210             :     TCP_NODELAY,                /* osl_Socket_OptionTcpNoDelay  */
     211             :     0                           /* osl_Socket_OptionInvalid     */
     212             : };
     213             : 
     214             : /* reverse map */
     215             : /* mfe: NOT USED
     216             : static oslSocketOption osl_SocketOptionFromNative(sal_uInt32 nativeType)
     217             : {
     218             :     oslSocketOption i= (oslSocketOption)0;
     219             : 
     220             :     while(i != osl_Socket_OptionInvalid)
     221             :     {
     222             :         if(OptionMap[i] == nativeType)
     223             :             return i;
     224             :         i = (oslSocketOption) ( i + 1 );
     225             :     }
     226             : 
     227             :     return i;
     228             : }
     229             : */
     230             : /* macros */
     231             : #define OPTION_TO_NATIVE(x)     OptionMap[x]
     232             : 
     233             : /*****************************************************************************/
     234             : /* enum oslSocketOptionLevel */
     235             : /*****************************************************************************/
     236             : 
     237             : static const sal_uInt32 OptionLevelMap[]= {
     238             :     SOL_SOCKET,                 /* osl_Socket_LevelSocket  */
     239             :     IPPROTO_TCP,                /* osl_Socket_LevelTcp     */
     240             :     0                           /* osl_Socket_LevelInvalid */
     241             : };
     242             : 
     243             : /* reverse map */
     244             : /* mfe: NOT USED
     245             : static oslSocketOptionLevel osl_SocketOptionLevelFromNative(sal_uInt32 nativeType)
     246             : {
     247             :     oslSocketOptionLevel i= (oslSocketOptionLevel)0;
     248             : 
     249             :     while(i != osl_Socket_LevelInvalid)
     250             :     {
     251             :         if(OptionLevelMap[i] == nativeType)
     252             :             return i;
     253             :         i = (oslSocketOptionLevel) ( i + 1 );
     254             :     }
     255             : 
     256             :     return i;
     257             : }
     258             : */
     259             : /* macros */
     260             : #define OPTION_LEVEL_TO_NATIVE(x)       OptionLevelMap[x]
     261             : 
     262             : /*****************************************************************************/
     263             : /* enum oslSocketMsgFlag */
     264             : /*****************************************************************************/
     265             : 
     266             : static const sal_uInt32 SocketMsgFlagMap[]= {
     267             :     0,                          /* osl_Socket_MsgNormal    */
     268             :     MSG_OOB,                    /* osl_Socket_MsgOOB       */
     269             :     MSG_PEEK,                   /* osl_Socket_MsgPeek      */
     270             :     MSG_DONTROUTE,              /* osl_Socket_MsgDontRoute */
     271             :     MSG_MAXIOVLEN,              /* osl_Socket_MsgMaxIOVLen */
     272             :     0                           /* osl_Socket_MsgInvalid   */
     273             : };
     274             : 
     275             : /* reverse map */
     276             : /* mfe: NOT USED
     277             : static oslSocketMsgFlag osl_SocketMsgFlagFromNative(sal_uInt32 nativeType)
     278             : {
     279             :     oslSocketMsgFlag i= (oslSocketMsgFlag)0;
     280             : 
     281             :     while(i != osl_Socket_MsgInvalid)
     282             :     {
     283             :         if(SocketMsgFlagMap[i] == nativeType)
     284             :             return i;
     285             :         i = (oslSocketMsgFlag) ( i + 1 );
     286             :     }
     287             : 
     288             :     return i;
     289             : }
     290             : */
     291             : 
     292             : /* macros */
     293             : #define MSG_FLAG_TO_NATIVE(x)       SocketMsgFlagMap[x]
     294             : 
     295             : /*****************************************************************************/
     296             : /* enum oslSocketDirection */
     297             : /*****************************************************************************/
     298             : 
     299             : static const sal_uInt32 SocketDirection[]= {
     300             :     SD_RECEIVE,                 /* osl_Socket_DirRead      */
     301             :     SD_SEND,                    /* osl_Socket_DirWrite     */
     302             :     SD_BOTH,                    /* osl_Socket_DirReadWrite */
     303             :     0                           /* osl_Socket_DirInvalid   */
     304             : };
     305             : 
     306             : /* reverse map */
     307             : /* mfe: NOT USED
     308             : static oslSocketDirection osl_SocketDirectionFromNative(sal_uInt32 nativeType)
     309             : {
     310             :     oslSocketDirection i= (oslSocketDirection)0;
     311             : 
     312             :     while(i != osl_Socket_DirInvalid)
     313             :     {
     314             :         if(SocketDirection[i] == nativeType)
     315             :             return i;
     316             :         i = (oslSocketDirection) ( i + 1 );
     317             :     }
     318             : 
     319             :     return i;
     320             : }
     321             : */
     322             : 
     323             : /* macros */
     324             : #define DIRECTION_TO_NATIVE(x)      SocketDirection[x]
     325             : 
     326             : /*****************************************************************************/
     327             : /* enum oslSocketError */
     328             : /*****************************************************************************/
     329             : 
     330             : static const struct
     331             : {
     332             :     int            errcode;
     333             :     oslSocketError error;
     334             : } SocketError[]= {
     335             :     { 0,               osl_Socket_E_None              }, /* no error */
     336             :     { ENOTSOCK,        osl_Socket_E_NotSocket         }, /* Socket operation on non-socket */
     337             :     { EDESTADDRREQ,    osl_Socket_E_DestAddrReq       }, /* Destination address required */
     338             :     { EMSGSIZE,        osl_Socket_E_MsgSize           }, /* Message too long */
     339             :     { EPROTOTYPE,      osl_Socket_E_Prototype         }, /* Protocol wrong type for socket */
     340             :     { ENOPROTOOPT,     osl_Socket_E_NoProtocol        }, /* Protocol not available */
     341             :     { EPROTONOSUPPORT, osl_Socket_E_ProtocolNoSupport }, /* Protocol not supported */
     342             :     { ESOCKTNOSUPPORT, osl_Socket_E_TypeNoSupport     }, /* Socket type not supported */
     343             :     { EOPNOTSUPP,      osl_Socket_E_OpNotSupport      }, /* Operation not supported on socket */
     344             :     { EPFNOSUPPORT,    osl_Socket_E_PfNoSupport       }, /* Protocol family not supported */
     345             :     { EAFNOSUPPORT,    osl_Socket_E_AfNoSupport       }, /* Address family not supported by */
     346             :                                                             /* protocol family */
     347             :     { EADDRINUSE,      osl_Socket_E_AddrInUse         }, /* Address already in use */
     348             :     { EADDRNOTAVAIL,   osl_Socket_E_AddrNotAvail      }, /* Can't assign requested address */
     349             :     { ENETDOWN,        osl_Socket_E_NetDown           }, /* Network is down */
     350             :     { ENETUNREACH,     osl_Socket_E_NetUnreachable    }, /* Network is unreachable */
     351             :     { ENETRESET,       osl_Socket_E_NetReset          }, /* Network dropped connection because */
     352             :                                                              /* of reset */
     353             :     { ECONNABORTED,    osl_Socket_E_ConnAborted       }, /* Software caused connection abort */
     354             :     { ECONNRESET,      osl_Socket_E_ConnReset         }, /* Connection reset by peer */
     355             :     { ENOBUFS,         osl_Socket_E_NoBufferSpace     }, /* No buffer space available */
     356             :     { EISCONN,         osl_Socket_E_IsConnected       }, /* Socket is already connected */
     357             :     { ENOTCONN,        osl_Socket_E_NotConnected      }, /* Socket is not connected */
     358             :     { ESHUTDOWN,       osl_Socket_E_Shutdown          }, /* Can't send after socket shutdown */
     359             :     { ETOOMANYREFS,    osl_Socket_E_TooManyRefs       }, /* Too many references: can't splice */
     360             :     { ETIMEDOUT,       osl_Socket_E_TimedOut          }, /* Connection timed out */
     361             :     { ECONNREFUSED,    osl_Socket_E_ConnRefused       }, /* Connection refused */
     362             :     { EHOSTDOWN,       osl_Socket_E_HostDown          }, /* Host is down */
     363             :     { EHOSTUNREACH,    osl_Socket_E_HostUnreachable   }, /* No route to host */
     364             :     { EWOULDBLOCK,     osl_Socket_E_WouldBlock        }, /* call would block on non-blocking socket */
     365             :     { EALREADY,        osl_Socket_E_Already           }, /* operation already in progress */
     366             :     { EINPROGRESS,     osl_Socket_E_InProgress        }, /* operation now in progress */
     367             :     { EAGAIN,          osl_Socket_E_WouldBlock        }, /* same as EWOULDBLOCK */
     368             :     { -1,              osl_Socket_E_InvalidError      }
     369             : };
     370             : 
     371             : /* map */
     372             : /* mfe: NOT USED
     373             : static int osl_NativeFromSocketError(oslSocketError errorCode)
     374             : {
     375             :     int i = 0;
     376             : 
     377             :     while ((SocketError[i].error != osl_Socket_E_InvalidError) &&
     378             :            (SocketError[i].error != errorCode)) i++;
     379             : 
     380             :     return SocketError[i].errcode;
     381             : }
     382             : */
     383             : 
     384             : /* reverse map */
     385           0 : static oslSocketError osl_SocketErrorFromNative(int nativeType)
     386             : {
     387           0 :     int i = 0;
     388             : 
     389           0 :     while ((SocketError[i].error != osl_Socket_E_InvalidError) &&
     390           0 :            (SocketError[i].errcode != nativeType)) i++;
     391             : 
     392           0 :     return SocketError[i].error;
     393             : }
     394             : 
     395             : /* macros */
     396             : #define ERROR_FROM_NATIVE(y)    osl_SocketErrorFromNative(y)
     397             : 
     398             : /*****************************************************************************/
     399             : /* local function prototypes */
     400             : /*****************************************************************************/
     401             : 
     402             : oslSocketAddr SAL_CALL osl_psz_createInetSocketAddr (
     403             :     const sal_Char* pszDottedAddr, sal_Int32 Port);
     404             : 
     405             : oslHostAddr SAL_CALL osl_psz_createHostAddr (
     406             :     const sal_Char *pszHostname, const oslSocketAddr Addr);
     407             : 
     408             : oslHostAddr SAL_CALL osl_psz_createHostAddrByName (
     409             :     const sal_Char *pszHostname);
     410             : 
     411             : const sal_Char* SAL_CALL osl_psz_getHostnameOfHostAddr (
     412             :     const oslHostAddr Addr);
     413             : 
     414             : oslSocketResult SAL_CALL osl_psz_getLocalHostname (
     415             :     sal_Char *pBuffer, sal_uInt32 nBufLen);
     416             : 
     417             : oslSocketAddr SAL_CALL osl_psz_resolveHostname (
     418             :     const sal_Char* pszHostname);
     419             : 
     420             : sal_Int32 SAL_CALL osl_psz_getServicePort (
     421             :     const sal_Char* pszServicename, const sal_Char* pszProtocol);
     422             : 
     423             : oslSocketResult SAL_CALL osl_psz_getHostnameOfSocketAddr (
     424             :     oslSocketAddr Addr, sal_Char *pBuffer, sal_uInt32 BufferSize);
     425             : 
     426             : oslSocketResult SAL_CALL osl_psz_getDottedInetAddrOfSocketAddr (
     427             :     oslSocketAddr Addr, sal_Char *pBuffer, sal_uInt32 BufferSize);
     428             : 
     429             : void SAL_CALL osl_psz_getLastSocketErrorDescription (
     430             :     oslSocket Socket, sal_Char* pBuffer, sal_uInt32 BufferSize);
     431             : 
     432             : #if OSL_DEBUG_LEVEL > 1
     433             : static sal_uInt32 g_nSocketImpl = 0;
     434             : static sal_uInt32 g_nSocketAddr = 0;
     435             : 
     436             : /* sorry, must be implemented otherwise */
     437             : 
     438             : #endif /* OSL_DEBUG_LEVEL */
     439             : 
     440           0 : oslSocket __osl_createSocketImpl(int Socket)
     441             : {
     442             :     oslSocket pSocket;
     443             : 
     444           0 :     pSocket = (oslSocket)calloc(1, sizeof(struct oslSocketImpl));
     445             : 
     446           0 :     pSocket->m_Socket = Socket;
     447           0 :     pSocket->m_nLastError = 0;
     448           0 :     pSocket->m_nRefCount = 1;
     449             : 
     450             : #if defined(LINUX)
     451           0 :     pSocket->m_bIsAccepting = sal_False;
     452             : #endif
     453             : 
     454             : #if OSL_DEBUG_LEVEL > 1
     455             :     g_nSocketImpl ++;
     456             : #endif
     457           0 :     return pSocket;
     458             : }
     459             : 
     460           0 : void __osl_destroySocketImpl(oslSocket Socket)
     461             : {
     462           0 :     if ( Socket != NULL)
     463           0 :         free((struct oslSocketImpl *) Socket);
     464             : #if OSL_DEBUG_LEVEL > 1
     465             :     g_nSocketImpl --;
     466             : #endif
     467           0 : }
     468             : 
     469           0 : static oslSocketAddr __osl_createSocketAddr(  )
     470             : {
     471           0 :     oslSocketAddr pAddr = (oslSocketAddr) rtl_allocateZeroMemory( sizeof( struct oslSocketAddrImpl ));
     472             : #if OSL_DEBUG_LEVEL > 1
     473             :     g_nSocketAddr ++;
     474             : #endif
     475           0 :     return pAddr;
     476             : }
     477             : 
     478           0 : static oslSocketAddr __osl_createSocketAddrWithFamily(
     479             :     oslAddrFamily family, sal_Int32 port, sal_uInt32 nAddr )
     480             : {
     481             :     oslSocketAddr pAddr;
     482             : 
     483             :     OSL_ASSERT( family == osl_Socket_FamilyInet );
     484             : 
     485           0 :     pAddr = __osl_createSocketAddr();
     486           0 :     switch( family )
     487             :     {
     488             :     case osl_Socket_FamilyInet:
     489             :     {
     490           0 :         struct sockaddr_in* pInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
     491             : 
     492           0 :         pInetAddr->sin_family = FAMILY_TO_NATIVE(osl_Socket_FamilyInet);
     493           0 :         pInetAddr->sin_addr.s_addr = nAddr;
     494           0 :         pInetAddr->sin_port = (sal_uInt16)(port&0xffff);
     495           0 :         break;
     496             :        }
     497             :     default:
     498           0 :         pAddr->m_sockaddr.sa_family = FAMILY_TO_NATIVE(family);
     499             :     }
     500           0 :     return pAddr;
     501             : }
     502             : 
     503           0 : static oslSocketAddr __osl_createSocketAddrFromSystem( struct sockaddr *pSystemSockAddr )
     504             : {
     505           0 :     oslSocketAddr pAddr = __osl_createSocketAddr();
     506           0 :     memcpy( &(pAddr->m_sockaddr), pSystemSockAddr, sizeof( struct sockaddr ) );
     507           0 :     return pAddr;
     508             : }
     509             : 
     510           0 : static void __osl_destroySocketAddr( oslSocketAddr addr )
     511             : {
     512             : #if OSL_DEBUG_LEVEL > 1
     513             :     g_nSocketAddr --;
     514             : #endif
     515           0 :     rtl_freeMemory( addr );
     516           0 : }
     517             : 
     518           0 : oslSocketAddr SAL_CALL osl_createEmptySocketAddr(oslAddrFamily Family)
     519             : {
     520           0 :     oslSocketAddr pAddr = 0;
     521             : 
     522             :     /* is it an internet-Addr? */
     523           0 :     if (Family == osl_Socket_FamilyInet)
     524             :     {
     525           0 :         pAddr = __osl_createSocketAddrWithFamily(Family, 0 , htonl(INADDR_ANY) );
     526             :     }
     527             :     else
     528             :     {
     529           0 :         pAddr = __osl_createSocketAddrWithFamily( Family , 0 , 0 );
     530             :     }
     531             : 
     532           0 :     return pAddr;
     533             : }
     534             : 
     535           0 : oslSocketAddr SAL_CALL osl_copySocketAddr(oslSocketAddr Addr)
     536             : {
     537           0 :     oslSocketAddr pCopy = 0;
     538           0 :     if (Addr)
     539             :     {
     540           0 :         pCopy = __osl_createSocketAddr();
     541             : 
     542           0 :         if (pCopy)
     543           0 :             memcpy(&(pCopy->m_sockaddr),&(Addr->m_sockaddr), sizeof(struct sockaddr));
     544             :     }
     545           0 :     return pCopy;
     546             : }
     547             : 
     548           0 : sal_Bool SAL_CALL osl_isEqualSocketAddr (
     549             :     oslSocketAddr Addr1,
     550             :     oslSocketAddr Addr2)
     551             : {
     552           0 :     struct sockaddr* pAddr1 = NULL;
     553           0 :     struct sockaddr* pAddr2 = NULL;
     554             : 
     555             :     OSL_ASSERT(Addr1);
     556             :     OSL_ASSERT(Addr2);
     557           0 :     pAddr1 = &(Addr1->m_sockaddr);
     558           0 :     pAddr2 = &(Addr2->m_sockaddr);
     559             : 
     560           0 :     if (pAddr1 == pAddr2)
     561             :     {
     562           0 :         return (sal_True);
     563             :     }
     564             : 
     565           0 :     if (pAddr1->sa_family == pAddr2->sa_family)
     566             :     {
     567           0 :         switch (pAddr1->sa_family)
     568             :         {
     569             :             case AF_INET:
     570             :             {
     571           0 :                 struct sockaddr_in* pInetAddr1= (struct sockaddr_in*)pAddr1;
     572           0 :                 struct sockaddr_in* pInetAddr2= (struct sockaddr_in*)pAddr2;
     573             : 
     574           0 :                 if ((pInetAddr1->sin_family == pInetAddr2->sin_family) &&
     575           0 :                     (pInetAddr1->sin_addr.s_addr == pInetAddr2->sin_addr.s_addr) &&
     576           0 :                     (pInetAddr1->sin_port == pInetAddr2->sin_port))
     577           0 :                     return (sal_True);
     578             :             }
     579             : 
     580             :             default:
     581             :             {
     582           0 :                 return (memcmp(pAddr1, pAddr2, sizeof(struct sockaddr)) == 0);
     583             :             }
     584             :         }
     585             :     }
     586             : 
     587           0 :     return (sal_False);
     588             : }
     589             : 
     590           0 : oslSocketAddr SAL_CALL osl_createInetBroadcastAddr (
     591             :     rtl_uString *strDottedAddr,
     592             :     sal_Int32    Port)
     593             : {
     594           0 :     sal_uInt32    nAddr = OSL_INADDR_NONE;
     595             :     oslSocketAddr pAddr;
     596             : 
     597           0 :     if (strDottedAddr && strDottedAddr->length)
     598             :     {
     599             :         /* Dotted host address for limited broadcast */
     600           0 :         rtl_String *pDottedAddr = NULL;
     601             : 
     602           0 :         rtl_uString2String (
     603           0 :             &pDottedAddr, strDottedAddr->buffer, strDottedAddr->length,
     604             :             RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
     605             : 
     606           0 :         nAddr = inet_addr (pDottedAddr->buffer);
     607           0 :         rtl_string_release (pDottedAddr);
     608             :     }
     609             : 
     610           0 :     if (nAddr != OSL_INADDR_NONE)
     611             :     {
     612             :         /* Limited broadcast */
     613           0 :         nAddr = ntohl(nAddr);
     614           0 :         if (IN_CLASSA(nAddr))
     615             :         {
     616           0 :             nAddr &= IN_CLASSA_NET;
     617           0 :             nAddr |= IN_CLASSA_HOST;
     618             :         }
     619           0 :         else if (IN_CLASSB(nAddr))
     620             :         {
     621           0 :             nAddr &= IN_CLASSB_NET;
     622           0 :             nAddr |= IN_CLASSB_HOST;
     623             :         }
     624           0 :         else if (IN_CLASSC(nAddr))
     625             :         {
     626           0 :             nAddr &= IN_CLASSC_NET;
     627           0 :             nAddr |= IN_CLASSC_HOST;
     628             :         }
     629             :         else
     630             :         {
     631             :             /* No broadcast in class D */
     632           0 :             return ((oslSocketAddr)NULL);
     633             :         }
     634           0 :         nAddr = htonl(nAddr);
     635             :     }
     636             : 
     637           0 :     pAddr = __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons(Port), nAddr );
     638           0 :     return pAddr;
     639             : }
     640             : 
     641           0 : oslSocketAddr SAL_CALL osl_createInetSocketAddr (
     642             :     rtl_uString *ustrDottedAddr,
     643             :     sal_Int32    Port)
     644             : {
     645           0 :     rtl_String* strDottedAddr=0;
     646             :     oslSocketAddr Addr;
     647           0 :     sal_Char* pszDottedAddr=0;
     648             : 
     649           0 :     if ( ustrDottedAddr != 0 )
     650             :     {
     651           0 :         rtl_uString2String( &strDottedAddr,
     652           0 :                             rtl_uString_getStr(ustrDottedAddr),
     653             :                             rtl_uString_getLength(ustrDottedAddr),
     654             :                             RTL_TEXTENCODING_UTF8,
     655             :                             OUSTRING_TO_OSTRING_CVTFLAGS);
     656           0 :         pszDottedAddr = rtl_string_getStr(strDottedAddr);
     657             :     }
     658             : 
     659           0 :     Addr = osl_psz_createInetSocketAddr(pszDottedAddr, Port);
     660             : 
     661           0 :     if ( strDottedAddr != 0 )
     662             :     {
     663           0 :         rtl_string_release(strDottedAddr);
     664             :     }
     665             : 
     666           0 :     return Addr;
     667             : }
     668             : 
     669           0 : oslSocketAddr SAL_CALL osl_psz_createInetSocketAddr (
     670             :     const sal_Char* pszDottedAddr,
     671             :     sal_Int32       Port)
     672             : {
     673           0 :     oslSocketAddr pAddr = 0;
     674           0 :     sal_Int32 Addr = inet_addr(pszDottedAddr);
     675           0 :     if(Addr != -1)
     676             :     {
     677             :         /* valid dotted addr */
     678           0 :         pAddr = __osl_createSocketAddrWithFamily( osl_Socket_FamilyInet, htons(Port) , Addr );
     679             :     }
     680           0 :     return pAddr;
     681             : }
     682             : 
     683           0 : oslSocketResult SAL_CALL osl_setAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence *pByteSeq )
     684             : {
     685           0 :     oslSocketResult res = osl_Socket_Error;
     686             : 
     687             :     OSL_ASSERT( pAddr );
     688             :     OSL_ASSERT( pByteSeq );
     689             : 
     690           0 :     if( pAddr && pByteSeq )
     691             :     {
     692             :         struct sockaddr_in * pSystemInetAddr;
     693             : 
     694             :         OSL_ASSERT( pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE( osl_Socket_FamilyInet ) );
     695             :         OSL_ASSERT( pByteSeq->nElements == 4 );
     696             : 
     697           0 :         pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
     698           0 :         memcpy( &(pSystemInetAddr->sin_addr) , pByteSeq->elements , 4 );
     699           0 :         res = osl_Socket_Ok;
     700             :     }
     701           0 :     return res;
     702             : }
     703             : 
     704           0 : oslSocketResult SAL_CALL osl_getAddrOfSocketAddr( oslSocketAddr pAddr, sal_Sequence **ppByteSeq )
     705             : {
     706           0 :     oslSocketResult res = osl_Socket_Error;
     707             : 
     708             :     OSL_ASSERT( pAddr );
     709             :     OSL_ASSERT( ppByteSeq );
     710             : 
     711           0 :     if( pAddr && ppByteSeq )
     712             :     {
     713           0 :         struct sockaddr_in * pSystemInetAddr = (struct sockaddr_in * ) &(pAddr->m_sockaddr);
     714           0 :         rtl_byte_sequence_constructFromArray( ppByteSeq , (sal_Int8 *) &(pSystemInetAddr->sin_addr),4);
     715           0 :         res = osl_Socket_Ok;
     716             :     }
     717           0 :     return res;
     718             : }
     719             : 
     720             : /** try to figure out a full-qualified hostname, by adding the current domain
     721             :     as given by the domainname program to the given hostname.
     722             :     This function MUST NOT call gethostbyname since pHostName already points
     723             :     to data returned by gethostname and would be garbled: use gethostname_r
     724             :     instead!
     725             :  */
     726             : 
     727             : /* wrap around different interfaces to reentrant gethostbyname */
     728           0 : static struct hostent* _osl_gethostbyname_r (
     729             :     const char *name, struct hostent *result,
     730             :     char *buffer, int buflen, int *h_errnop)
     731             : {
     732             : #if defined(LINUX) || defined(ANDROID) || (defined(FREEBSD) && (__FreeBSD_version >= 601103)) || defined(DRAGONFLY)
     733             :     struct hostent *__result; /* will be the same as result */
     734             :     int __error;
     735           0 :     __error = gethostbyname_r (name, result, buffer, buflen,
     736             :                  &__result, h_errnop);
     737           0 :     return __error ? NULL : __result ;
     738             : #elif defined(AIX)
     739             :     *h_errnop = gethostbyname_r (name, result, (struct hostent_data *)buffer);
     740             :     (void)buflen;
     741             :     return *h_errnop ? NULL : result ;
     742             : #else
     743             :     return gethostbyname_r( name, result, buffer, buflen, h_errnop);
     744             : #endif
     745             : }
     746             : 
     747           0 : static sal_Char* _osl_getFullQualifiedDomainName (const sal_Char *pHostName)
     748             : {
     749             :     struct hostent  aHostByName;
     750             :     struct hostent *pHostByName;
     751             :     sal_Char        pQualifiedHostBuffer[ MAX_HOSTBUFFER_SIZE ];
     752           0 :     sal_Char  *pFullQualifiedName = NULL;
     753             :     int     nErrorNo;
     754             : 
     755           0 :     pHostByName = _osl_gethostbyname_r (
     756             :         pHostName,
     757             :         &aHostByName, pQualifiedHostBuffer,
     758             :         sizeof(pQualifiedHostBuffer), &nErrorNo );
     759           0 :     if (pHostByName != NULL)
     760             :     {
     761           0 :         pFullQualifiedName = strdup(pHostByName->h_name);
     762             :     }
     763           0 :     return pFullQualifiedName;
     764             : }
     765             : 
     766           0 : static sal_Bool _osl_isFullQualifiedDomainName (const sal_Char *pHostName)
     767             : {
     768             :     /* a FQDN (aka 'hostname.domain.top_level_domain' )
     769             :      * is a name which contains a dot '.' in it ( would
     770             :      * match as well for 'hostname.' but is good enough
     771             :      * for now )*/
     772           0 :     return (sal_Bool)( strchr( pHostName, (int)'.' ) != NULL );
     773             : }
     774             : 
     775             : struct oslHostAddrImpl
     776             : {
     777             :     sal_Char        *pHostName;
     778             :     oslSocketAddr   pSockAddr;
     779             : };
     780             : 
     781           0 : static oslHostAddr _osl_hostentToHostAddr (const struct hostent *he)
     782             : {
     783           0 :     oslHostAddr pAddr= NULL;
     784           0 :     oslSocketAddr pSockAddr = 0;
     785             : 
     786             :     sal_Char        *cn;
     787             : 
     788           0 :     if ((he == NULL) || (he->h_name == NULL) || (he->h_addr_list[0] == NULL))
     789           0 :         return ((oslHostAddr)NULL);
     790             : 
     791           0 :     if (_osl_isFullQualifiedDomainName(he->h_name))
     792             :     {
     793           0 :         cn= (sal_Char *)malloc(strlen (he->h_name) + 1);
     794             :         OSL_ASSERT(cn);
     795           0 :         if (cn == NULL)
     796           0 :             return ((oslHostAddr)NULL);
     797             : 
     798           0 :         strcpy(cn, he->h_name);
     799             :     }
     800             :     else
     801             :     {
     802           0 :         cn =_osl_getFullQualifiedDomainName (he->h_name);
     803             :         OSL_ASSERT(cn);
     804           0 :         if (cn == NULL)
     805           0 :             return ((oslHostAddr)NULL);
     806             :     }
     807             : 
     808           0 :     pSockAddr = __osl_createSocketAddr();
     809             :     OSL_ASSERT(pSockAddr);
     810           0 :     if (pSockAddr == NULL)
     811             :     {
     812           0 :         free(cn);
     813           0 :         return ((oslHostAddr)NULL);
     814             :     }
     815             : 
     816           0 :     pSockAddr->m_sockaddr.sa_family= he->h_addrtype;
     817           0 :     if (pSockAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
     818             :     {
     819           0 :         struct sockaddr_in *sin= (struct sockaddr_in *)&(pSockAddr->m_sockaddr);
     820           0 :         memcpy (
     821           0 :             &(sin->sin_addr.s_addr),
     822           0 :             he->h_addr_list[0],
     823           0 :             he->h_length);
     824             :     }
     825             :     else
     826             :     {
     827             :         /* unknown address family */
     828             :         /* future extensions for new families might be implemented here */
     829             : 
     830             :         OSL_TRACE("_osl_hostentToHostAddr: unknown address family.");
     831             :         OSL_ASSERT(sal_False);
     832             : 
     833           0 :         __osl_destroySocketAddr( pSockAddr );
     834           0 :         free (cn);
     835           0 :         return ((oslHostAddr)NULL);
     836             :     }
     837             : 
     838           0 :     pAddr= (oslHostAddr) malloc(sizeof(struct oslHostAddrImpl));
     839             :     OSL_ASSERT(pAddr);
     840           0 :     if (pAddr == NULL)
     841             :     {
     842           0 :         __osl_destroySocketAddr( pSockAddr );
     843           0 :         free (cn);
     844           0 :         return ((oslHostAddr)NULL);
     845             :     }
     846             : 
     847           0 :     pAddr->pHostName= cn;
     848           0 :     pAddr->pSockAddr= pSockAddr;
     849             : 
     850           0 :     return pAddr;
     851             : }
     852             : 
     853           0 : oslHostAddr SAL_CALL osl_createHostAddr (
     854             :     rtl_uString        *ustrHostname,
     855             :     const oslSocketAddr Addr)
     856             : {
     857             :     oslHostAddr HostAddr;
     858           0 :     rtl_String* strHostname=0;
     859           0 :     sal_Char* pszHostName=0;
     860             : 
     861           0 :     if ( ustrHostname != 0 )
     862             :     {
     863           0 :         rtl_uString2String( &strHostname,
     864           0 :                             rtl_uString_getStr(ustrHostname),
     865             :                             rtl_uString_getLength(ustrHostname),
     866             :                             RTL_TEXTENCODING_UTF8,
     867             :                             OUSTRING_TO_OSTRING_CVTFLAGS );
     868           0 :         pszHostName = rtl_string_getStr(strHostname);
     869             :     }
     870             : 
     871           0 :     HostAddr = osl_psz_createHostAddr(pszHostName,Addr);
     872             : 
     873           0 :     if ( strHostname != 0 )
     874             :     {
     875           0 :         rtl_string_release(strHostname);
     876             :     }
     877             : 
     878           0 :     return HostAddr;
     879             : }
     880             : 
     881           0 : oslHostAddr SAL_CALL osl_psz_createHostAddr (
     882             :     const sal_Char     *pszHostname,
     883             :     const oslSocketAddr pAddr)
     884             : {
     885             :     oslHostAddr pHostAddr;
     886             :     sal_Char            *cn;
     887             : 
     888             :     OSL_ASSERT(pszHostname && pAddr);
     889           0 :     if ((pszHostname == NULL) || (pAddr == NULL))
     890           0 :         return ((oslHostAddr)NULL);
     891             : 
     892           0 :     cn = (sal_Char *)malloc(strlen (pszHostname) + 1);
     893             :     OSL_ASSERT(cn);
     894           0 :     if (cn == NULL)
     895           0 :         return ((oslHostAddr)NULL);
     896             : 
     897           0 :     strcpy (cn, pszHostname);
     898             : 
     899           0 :     pHostAddr= (oslHostAddr) malloc(sizeof(struct oslHostAddrImpl));
     900             :     OSL_ASSERT(pHostAddr);
     901           0 :     if (pHostAddr == NULL)
     902             :     {
     903           0 :         free (cn);
     904           0 :         return ((oslHostAddr)NULL);
     905             :     }
     906             : 
     907           0 :     pHostAddr->pHostName= cn;
     908           0 :     pHostAddr->pSockAddr= osl_copySocketAddr( pAddr );
     909             : 
     910           0 :     return pHostAddr;
     911             : }
     912             : 
     913           0 : oslHostAddr SAL_CALL osl_createHostAddrByName(rtl_uString *ustrHostname)
     914             : {
     915             :     oslHostAddr HostAddr;
     916           0 :     rtl_String* strHostname=0;
     917           0 :     sal_Char* pszHostName=0;
     918             : 
     919           0 :     if ( ustrHostname != 0 )
     920             :     {
     921           0 :         rtl_uString2String( &strHostname,
     922           0 :                             rtl_uString_getStr(ustrHostname),
     923             :                             rtl_uString_getLength(ustrHostname),
     924             :                             RTL_TEXTENCODING_UTF8,
     925             :                             OUSTRING_TO_OSTRING_CVTFLAGS );
     926           0 :         pszHostName=rtl_string_getStr(strHostname);
     927             :     }
     928             : 
     929           0 :     HostAddr = osl_psz_createHostAddrByName(pszHostName);
     930             : 
     931           0 :     if ( strHostname != 0 )
     932             :     {
     933           0 :         rtl_string_release(strHostname);
     934             :     }
     935             : 
     936           0 :     return HostAddr;
     937             : }
     938             : 
     939           0 : oslHostAddr SAL_CALL osl_psz_createHostAddrByName (const sal_Char *pszHostname)
     940             : {
     941             :     struct      hostent  aHe;
     942             :     struct      hostent *pHe;
     943             :     sal_Char    heBuffer[ MAX_HOSTBUFFER_SIZE ];
     944             :     int         nErrorNo;
     945             : 
     946           0 :     pHe = _osl_gethostbyname_r (
     947             :         pszHostname,
     948             :         &aHe, heBuffer,
     949             :         sizeof(heBuffer), &nErrorNo );
     950             : 
     951           0 :     return _osl_hostentToHostAddr (pHe);
     952             : }
     953             : 
     954           0 : oslHostAddr SAL_CALL osl_createHostAddrByAddr (const oslSocketAddr pAddr)
     955             : {
     956             :     OSL_ASSERT(pAddr);
     957             : 
     958           0 :     if (pAddr == NULL)
     959           0 :         return ((oslHostAddr)NULL);
     960             : 
     961           0 :     if (pAddr->m_sockaddr.sa_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
     962             :     {
     963           0 :         const struct sockaddr_in *sin= (const struct sockaddr_in *)&(pAddr->m_sockaddr);
     964             :         struct hostent *he;
     965             : 
     966           0 :         if (sin->sin_addr.s_addr == htonl(INADDR_ANY))
     967           0 :             return ((oslHostAddr)NULL);
     968             : 
     969           0 :         he= gethostbyaddr((sal_Char *)&(sin->sin_addr),
     970             :                           sizeof (sin->sin_addr),
     971           0 :                           sin->sin_family);
     972           0 :         return _osl_hostentToHostAddr (he);
     973             :     }
     974             : 
     975           0 :     return ((oslHostAddr)NULL);
     976             : }
     977             : 
     978           0 : oslHostAddr SAL_CALL osl_copyHostAddr (const oslHostAddr pAddr)
     979             : {
     980             :     OSL_ASSERT(pAddr);
     981             : 
     982           0 :     if (pAddr)
     983           0 :         return osl_psz_createHostAddr (pAddr->pHostName, pAddr->pSockAddr);
     984             :     else
     985           0 :         return ((oslHostAddr)NULL);
     986             : }
     987             : 
     988           0 : void SAL_CALL osl_getHostnameOfHostAddr (
     989             :     const oslHostAddr   Addr,
     990             :     rtl_uString       **ustrHostname)
     991             : {
     992           0 :     const sal_Char* pHostname=0;
     993             : 
     994           0 :     pHostname = osl_psz_getHostnameOfHostAddr(Addr);
     995             : 
     996           0 :     rtl_uString_newFromAscii (ustrHostname, pHostname);
     997             : 
     998           0 :     return;
     999             : }
    1000             : 
    1001           0 : const sal_Char* SAL_CALL osl_psz_getHostnameOfHostAddr (const oslHostAddr pAddr)
    1002             : {
    1003           0 :     if (pAddr)
    1004           0 :         return pAddr->pHostName;
    1005             :     else
    1006           0 :         return NULL;
    1007             : }
    1008             : 
    1009           0 : oslSocketAddr SAL_CALL osl_getSocketAddrOfHostAddr (const oslHostAddr pAddr)
    1010             : {
    1011             :     OSL_ASSERT(pAddr);
    1012             : 
    1013           0 :     if (pAddr)
    1014           0 :         return ((oslSocketAddr)(pAddr->pSockAddr));
    1015             :     else
    1016           0 :         return NULL;
    1017             : }
    1018             : 
    1019           0 : void SAL_CALL osl_destroyHostAddr (oslHostAddr pAddr)
    1020             : {
    1021           0 :     if (pAddr)
    1022             :     {
    1023           0 :         if (pAddr->pHostName)
    1024           0 :             free (pAddr->pHostName);
    1025           0 :         if (pAddr->pSockAddr)
    1026           0 :             osl_destroySocketAddr (pAddr->pSockAddr);
    1027           0 :         free (pAddr);
    1028             :     }
    1029           0 : }
    1030             : 
    1031           0 : oslSocketResult SAL_CALL osl_getLocalHostname(rtl_uString **ustrLocalHostname)
    1032             : {
    1033             :     oslSocketResult Result;
    1034             :     sal_Char pszHostname[1024];
    1035             : 
    1036           0 :     pszHostname[0] = '\0';
    1037             : 
    1038           0 :     Result = osl_psz_getLocalHostname(pszHostname,sizeof(pszHostname));
    1039             : 
    1040           0 :     rtl_uString_newFromAscii(ustrLocalHostname,pszHostname);
    1041             : 
    1042           0 :     return Result;
    1043             : }
    1044             : 
    1045           0 : oslSocketResult SAL_CALL osl_psz_getLocalHostname (
    1046             :     sal_Char *pBuffer, sal_uInt32 nBufLen)
    1047             : {
    1048             :     static sal_Char LocalHostname[256] = "";
    1049             : 
    1050           0 :     if (strlen(LocalHostname) == 0)
    1051             :     {
    1052             :         const sal_Char *pStr;
    1053             : 
    1054             : #ifdef SYSV
    1055             :         struct utsname uts;
    1056             : 
    1057             :         if (uname(&uts) < 0)
    1058             :             return osl_Socket_Error;
    1059             : 
    1060             :         if ((strlen(uts.nodename) + 1) > nBufLen)
    1061             :             return osl_Socket_Error;
    1062             : 
    1063             :         strncpy(LocalHostname, uts.nodename, sizeof( LocalHostname ));
    1064             : #else  /* BSD compatible */
    1065             : 
    1066           0 :         if (gethostname(LocalHostname, sizeof(LocalHostname)-1) != 0)
    1067           0 :             return osl_Socket_Error;
    1068           0 :         LocalHostname[sizeof(LocalHostname)-1] = 0;
    1069             : #endif /* SYSV */
    1070             : 
    1071             :         /* check if we have an FQDN */
    1072           0 :         if (strchr(LocalHostname, '.') == NULL)
    1073             :         {
    1074             :             oslHostAddr Addr;
    1075             : 
    1076             :             /* no, determine it via dns */
    1077           0 :             Addr = osl_psz_createHostAddrByName(LocalHostname);
    1078             : 
    1079           0 :             if ((pStr = osl_psz_getHostnameOfHostAddr(Addr)) != NULL)
    1080             :             {
    1081           0 :                 strcpy(LocalHostname, pStr);
    1082             :             }
    1083           0 :             osl_destroyHostAddr(Addr);
    1084             :         }
    1085             :     }
    1086             : 
    1087           0 :     if (strlen(LocalHostname) > 0)
    1088             :     {
    1089           0 :         strncpy(pBuffer, LocalHostname, nBufLen);
    1090           0 :         pBuffer[nBufLen - 1] = '\0';
    1091             : 
    1092           0 :         return osl_Socket_Ok;
    1093             :     }
    1094             : 
    1095           0 :     return osl_Socket_Error;
    1096             : }
    1097             : 
    1098           0 : oslSocketAddr SAL_CALL osl_resolveHostname(rtl_uString *ustrHostname)
    1099             : {
    1100             :     oslSocketAddr Addr;
    1101           0 :     rtl_String* strHostname=0;
    1102           0 :     sal_Char* pszHostName=0;
    1103             : 
    1104           0 :     if ( ustrHostname != 0 )
    1105             :     {
    1106           0 :         rtl_uString2String( &strHostname,
    1107           0 :                             rtl_uString_getStr(ustrHostname),
    1108             :                             rtl_uString_getLength(ustrHostname),
    1109             :                             RTL_TEXTENCODING_UTF8,
    1110             :                             OUSTRING_TO_OSTRING_CVTFLAGS );
    1111           0 :         pszHostName = rtl_string_getStr(strHostname);
    1112             :     }
    1113             : 
    1114           0 :     Addr = osl_psz_resolveHostname(pszHostName);
    1115             : 
    1116           0 :     if ( strHostname != 0 )
    1117             :     {
    1118           0 :         rtl_string_release(strHostname);
    1119             :     }
    1120             : 
    1121           0 :     return Addr;
    1122             : }
    1123             : 
    1124           0 : oslSocketAddr SAL_CALL osl_psz_resolveHostname(const sal_Char* pszHostname)
    1125             : {
    1126           0 :     struct oslHostAddrImpl *pAddr = (oslHostAddr)osl_psz_createHostAddrByName(pszHostname);
    1127             : 
    1128           0 :     if (pAddr)
    1129             :     {
    1130           0 :         oslSocketAddr SockAddr = osl_copySocketAddr(pAddr->pSockAddr);
    1131             : 
    1132           0 :         osl_destroyHostAddr(pAddr);
    1133             : 
    1134           0 :         return (SockAddr);
    1135             :     }
    1136             : 
    1137           0 :     return ((oslSocketAddr)NULL);
    1138             : }
    1139             : 
    1140           0 : sal_Int32 SAL_CALL osl_getServicePort(rtl_uString *ustrServicename, rtl_uString *ustrProtocol)
    1141             : {
    1142             :     sal_Int32 nPort;
    1143           0 :     rtl_String* strServicename=0;
    1144           0 :     rtl_String* strProtocol=0;
    1145           0 :     sal_Char* pszServiceName=0;
    1146           0 :     sal_Char* pszProtocol=0;
    1147             : 
    1148           0 :     if ( ustrServicename != 0 )
    1149             :     {
    1150           0 :         rtl_uString2String( &strServicename,
    1151           0 :                             rtl_uString_getStr(ustrServicename),
    1152             :                             rtl_uString_getLength(ustrServicename),
    1153             :                             RTL_TEXTENCODING_UTF8,
    1154             :                             OUSTRING_TO_OSTRING_CVTFLAGS );
    1155           0 :         pszServiceName = rtl_string_getStr(strServicename);
    1156             :     }
    1157             : 
    1158           0 :     if ( ustrProtocol != 0 )
    1159             :     {
    1160           0 :         rtl_uString2String( &strProtocol,
    1161           0 :                             rtl_uString_getStr(ustrProtocol),
    1162             :                             rtl_uString_getLength(ustrProtocol),
    1163             :                             RTL_TEXTENCODING_UTF8,
    1164             :                             OUSTRING_TO_OSTRING_CVTFLAGS );
    1165           0 :         pszProtocol = rtl_string_getStr(strProtocol);
    1166             :     }
    1167             : 
    1168           0 :     nPort = osl_psz_getServicePort(pszServiceName,pszProtocol);
    1169             : 
    1170           0 :     if ( strServicename != 0 )
    1171             :     {
    1172           0 :         rtl_string_release(strServicename);
    1173             :     }
    1174             : 
    1175           0 :     if ( strProtocol != 0 )
    1176             :     {
    1177           0 :         rtl_string_release(strProtocol);
    1178             :     }
    1179             : 
    1180           0 :     return nPort;
    1181             : }
    1182             : 
    1183           0 : sal_Int32 SAL_CALL osl_psz_getServicePort(const sal_Char* pszServicename,
    1184             :                         const sal_Char* pszProtocol)
    1185             : {
    1186             :     struct servent* ps;
    1187             : 
    1188           0 :     ps= getservbyname(pszServicename, pszProtocol);
    1189             : 
    1190           0 :     if (ps != 0)
    1191           0 :         return ntohs(ps->s_port);
    1192             : 
    1193           0 :     return OSL_INVALID_PORT;
    1194             : }
    1195             : 
    1196           0 : void SAL_CALL osl_destroySocketAddr(oslSocketAddr pAddr)
    1197             : {
    1198           0 :     __osl_destroySocketAddr( pAddr );
    1199           0 : }
    1200             : 
    1201           0 : oslAddrFamily SAL_CALL osl_getFamilyOfSocketAddr(oslSocketAddr pAddr)
    1202             : {
    1203             :     OSL_ASSERT(pAddr);
    1204             : 
    1205           0 :     if (pAddr)
    1206           0 :         return FAMILY_FROM_NATIVE(pAddr->m_sockaddr.sa_family);
    1207             :     else
    1208           0 :         return osl_Socket_FamilyInvalid;
    1209             : }
    1210             : 
    1211           0 : sal_Int32 SAL_CALL osl_getInetPortOfSocketAddr(oslSocketAddr pAddr)
    1212             : {
    1213             :     OSL_ASSERT(pAddr);
    1214           0 :     if( pAddr )
    1215             :     {
    1216           0 :         struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
    1217             : 
    1218           0 :         if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
    1219           0 :             return ntohs(pSystemInetAddr->sin_port);
    1220             :     }
    1221           0 :     return OSL_INVALID_PORT;
    1222             : }
    1223             : 
    1224           0 : sal_Bool SAL_CALL osl_setInetPortOfSocketAddr(oslSocketAddr pAddr, sal_Int32 Port)
    1225             : {
    1226             :     OSL_ASSERT(pAddr);
    1227           0 :     if( pAddr )
    1228             :     {
    1229           0 :         struct sockaddr_in* pSystemInetAddr= (struct sockaddr_in*)&(pAddr->m_sockaddr);
    1230           0 :         if ( pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
    1231             :         {
    1232           0 :             pSystemInetAddr->sin_port= htons((short)Port);
    1233           0 :             return sal_True;
    1234             :         }
    1235             :     }
    1236             : 
    1237             :     /* this is not a inet-addr => can't set port */
    1238           0 :     return sal_False;
    1239             : }
    1240             : 
    1241           0 : oslSocketResult SAL_CALL osl_getHostnameOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrHostname)
    1242             : {
    1243             :     oslSocketResult Result;
    1244             :     sal_Char pszHostname[1024];
    1245             : 
    1246           0 :     pszHostname[0] = '\0';
    1247             : 
    1248           0 :     Result = osl_psz_getHostnameOfSocketAddr(Addr,pszHostname,sizeof(pszHostname));
    1249             : 
    1250           0 :     rtl_uString_newFromAscii(ustrHostname,pszHostname);
    1251             : 
    1252           0 :     return Result;
    1253             : }
    1254             : 
    1255           0 : oslSocketResult SAL_CALL osl_psz_getHostnameOfSocketAddr(oslSocketAddr pAddr,
    1256             :                                             sal_Char *pBuffer, sal_uInt32 BufferSize)
    1257             : {
    1258           0 :     oslHostAddr pHostAddr= (oslHostAddr )osl_createHostAddrByAddr(pAddr);
    1259             : 
    1260           0 :     if (pHostAddr)
    1261             :     {
    1262           0 :         strncpy(pBuffer, pHostAddr->pHostName, BufferSize);
    1263             : 
    1264           0 :         pBuffer[BufferSize - 1] = '\0';
    1265             : 
    1266           0 :         osl_destroyHostAddr(pHostAddr);
    1267             : 
    1268           0 :         return osl_Socket_Ok;
    1269             :     }
    1270             : 
    1271           0 :     return osl_Socket_Error;
    1272             : }
    1273             : 
    1274             : /*****************************************************************************/
    1275             : /* osl_getDottedInetAddrOfSocketAddr */
    1276             : /*****************************************************************************/
    1277           0 : oslSocketResult SAL_CALL osl_getDottedInetAddrOfSocketAddr(oslSocketAddr Addr, rtl_uString **ustrDottedInetAddr)
    1278             : {
    1279             :     oslSocketResult Result;
    1280             :     sal_Char pszDottedInetAddr[1024];
    1281             : 
    1282           0 :     pszDottedInetAddr[0] = '\0';
    1283             : 
    1284           0 :     Result = osl_psz_getDottedInetAddrOfSocketAddr(Addr,pszDottedInetAddr,sizeof(pszDottedInetAddr));
    1285             : 
    1286           0 :     rtl_uString_newFromAscii(ustrDottedInetAddr,pszDottedInetAddr);
    1287             : 
    1288           0 :     return Result;
    1289             : 
    1290             : }
    1291             : 
    1292           0 : oslSocketResult SAL_CALL osl_psz_getDottedInetAddrOfSocketAddr(oslSocketAddr pAddr,
    1293             :                                                   sal_Char *pBuffer, sal_uInt32 BufferSize)
    1294             : {
    1295             :     OSL_ASSERT(pAddr);
    1296             : 
    1297           0 :     if( pAddr )
    1298             :     {
    1299           0 :         struct sockaddr_in* pSystemInetAddr = ( struct sockaddr_in * ) &(pAddr->m_sockaddr);
    1300             : 
    1301           0 :         if (pSystemInetAddr->sin_family == FAMILY_TO_NATIVE(osl_Socket_FamilyInet))
    1302             :         {
    1303           0 :             strncpy(pBuffer, inet_ntoa(pSystemInetAddr->sin_addr), BufferSize);
    1304           0 :             pBuffer[BufferSize - 1] = '\0';
    1305             : 
    1306           0 :             return osl_Socket_Ok;
    1307             :         }
    1308             :     }
    1309             : 
    1310           0 :     return osl_Socket_Error;
    1311             : }
    1312             : 
    1313           0 : oslSocket SAL_CALL osl_createSocket(oslAddrFamily   Family,
    1314             :                            oslSocketType    Type,
    1315             :                            oslProtocol      Protocol)
    1316             : {
    1317             :     int            Flags;
    1318             :     oslSocket pSocket;
    1319             : 
    1320             :     /* alloc memory */
    1321           0 :     pSocket= __osl_createSocketImpl(OSL_INVALID_SOCKET);
    1322             : 
    1323             :     /* create socket */
    1324           0 :     pSocket->m_Socket= socket(FAMILY_TO_NATIVE(Family),
    1325           0 :                                 TYPE_TO_NATIVE(Type),
    1326           0 :                                 PROTOCOL_TO_NATIVE(Protocol));
    1327             : 
    1328             :     /* creation failed => free memory */
    1329           0 :     if(pSocket->m_Socket == OSL_INVALID_SOCKET)
    1330             :     {
    1331             :         OSL_TRACE("osl_createSocket failed. Errno: %d; %s\n",
    1332             :                   errno,
    1333             :                   strerror(errno));
    1334             : 
    1335           0 :         __osl_destroySocketImpl((pSocket));
    1336           0 :         pSocket= 0;
    1337             :     }
    1338             :     else
    1339             :     {
    1340             :         /* set close-on-exec flag */
    1341           0 :         if ((Flags = fcntl(pSocket->m_Socket, F_GETFD, 0)) != -1)
    1342             :         {
    1343           0 :             Flags |= FD_CLOEXEC;
    1344           0 :             if (fcntl(pSocket->m_Socket, F_SETFD, Flags) == -1)
    1345             :             {
    1346           0 :                 pSocket->m_nLastError=errno;
    1347             :                 OSL_TRACE("osl_createSocket failed changing socket flags. Errno: %d; %s\n",
    1348             :                           errno,
    1349             :                           strerror(errno));
    1350             :             }
    1351             :         }
    1352             :         else
    1353             :         {
    1354           0 :             pSocket->m_nLastError=errno;
    1355             :         }
    1356             :     }
    1357             : 
    1358           0 :     return pSocket;
    1359             : }
    1360             : 
    1361           0 : void SAL_CALL osl_acquireSocket(oslSocket pSocket)
    1362             : {
    1363           0 :     osl_atomic_increment( &(pSocket->m_nRefCount ) );
    1364           0 : }
    1365             : 
    1366           0 : void SAL_CALL osl_releaseSocket( oslSocket pSocket )
    1367             : {
    1368           0 :     if( pSocket && 0 == osl_atomic_decrement( &(pSocket->m_nRefCount) ) )
    1369             :     {
    1370             : #if defined(LINUX)
    1371           0 :     if ( pSocket->m_bIsAccepting == sal_True )
    1372             :     {
    1373             :         OSL_FAIL("osl_destroySocket : attempt to destroy socket while accepting\n");
    1374           0 :         return;
    1375             :     }
    1376             : #endif /* LINUX */
    1377           0 :         osl_closeSocket( pSocket );
    1378           0 :         __osl_destroySocketImpl( pSocket );
    1379             :     }
    1380             : }
    1381             : 
    1382           0 : void SAL_CALL osl_closeSocket(oslSocket pSocket)
    1383             : {
    1384             :     int nRet;
    1385             :     int nFD;
    1386             : 
    1387             :     /* socket already invalid */
    1388           0 :     if(pSocket==0)
    1389           0 :         return;
    1390             : 
    1391           0 :     pSocket->m_nLastError=0;
    1392           0 :     nFD = pSocket->m_Socket;
    1393             : 
    1394           0 :     if (nFD == OSL_INVALID_SOCKET)
    1395           0 :         return;
    1396             : 
    1397           0 :     pSocket->m_Socket = OSL_INVALID_SOCKET;
    1398             : 
    1399             : #if defined(LINUX)
    1400           0 :     pSocket->m_bIsInShutdown = sal_True;
    1401             : 
    1402           0 :     if ( pSocket->m_bIsAccepting == sal_True )
    1403             :     {
    1404             :         int nConnFD;
    1405             :         union {
    1406             :             struct sockaddr aSockAddr;
    1407             :             struct sockaddr_in aSockAddrIn;
    1408             :         } s;
    1409           0 :         socklen_t nSockLen = sizeof(s.aSockAddr);
    1410             : 
    1411           0 :         nRet = getsockname(nFD, &s.aSockAddr, &nSockLen);
    1412             :         if ( nRet < 0 )
    1413             :         {
    1414             :             OSL_TRACE("getsockname call failed with error: %s", strerror(errno));
    1415             :         }
    1416             : 
    1417           0 :         if ( s.aSockAddr.sa_family == AF_INET )
    1418             :         {
    1419           0 :             if ( s.aSockAddrIn.sin_addr.s_addr == htonl(INADDR_ANY) )
    1420             :             {
    1421           0 :                 s.aSockAddrIn.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    1422             :             }
    1423             : 
    1424           0 :             nConnFD = socket(AF_INET, SOCK_STREAM, 0);
    1425           0 :             if ( nConnFD < 0 )
    1426             :             {
    1427             :                 OSL_TRACE("socket call failed with error: %s", strerror(errno));
    1428             :             }
    1429             :             else
    1430             :             {
    1431           0 :                 nRet = connect(nConnFD, &s.aSockAddr, sizeof(s.aSockAddr));
    1432             :                 if ( nRet < 0 )
    1433             :                 {
    1434             :                     OSL_TRACE("connect call failed with error: %s", strerror(errno));
    1435             :                 }
    1436           0 :                 close(nConnFD);
    1437             :             }
    1438             :         }
    1439           0 :         pSocket->m_bIsAccepting = sal_False;
    1440             :     }
    1441             : #endif /* LINUX */
    1442             : 
    1443           0 :     nRet=close(nFD);
    1444           0 :     if ( nRet != 0 )
    1445             :     {
    1446           0 :         pSocket->m_nLastError=errno;
    1447             :         OSL_TRACE("closeSocket close error '%s'",strerror(errno));
    1448             :     }
    1449             : 
    1450           0 :     pSocket->m_Socket = OSL_INVALID_SOCKET;
    1451             : }
    1452             : 
    1453             : /*****************************************************************************/
    1454             : /* osl_getLocalAddrOfSocket  */
    1455             : /* Note that I rely on the fact that oslSocketAddr and struct sockaddr */
    1456             : /* are the same! I don't like it very much but see no other easy way to conceal */
    1457             : /* the struct sockaddr from the eyes of the user. */
    1458             : /*****************************************************************************/
    1459           0 : oslSocketAddr SAL_CALL osl_getLocalAddrOfSocket(oslSocket pSocket)
    1460             : {
    1461             :     socklen_t AddrLen;
    1462             :     struct sockaddr Addr;
    1463             :     oslSocketAddr  pAddr;
    1464             : 
    1465           0 :     if (pSocket == NULL) /* ENOTSOCK */
    1466           0 :         return ((oslSocketAddr)NULL);
    1467             : 
    1468           0 :     AddrLen= sizeof(struct sockaddr);
    1469             : 
    1470           0 :     if (getsockname(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
    1471           0 :         return ((oslSocketAddr)NULL);
    1472             : 
    1473           0 :     pAddr = __osl_createSocketAddrFromSystem( &Addr );
    1474           0 :     return pAddr;
    1475             : }
    1476             : 
    1477           0 : oslSocketAddr SAL_CALL osl_getPeerAddrOfSocket(oslSocket pSocket)
    1478             : {
    1479             :     socklen_t AddrLen;
    1480             :     struct sockaddr Addr;
    1481             : 
    1482             :     OSL_ASSERT(pSocket);
    1483           0 :     if ( pSocket == 0 )
    1484             :     {
    1485           0 :         return 0;
    1486             :     }
    1487             : 
    1488           0 :     pSocket->m_nLastError=0;
    1489           0 :     AddrLen= sizeof(struct sockaddr);
    1490             : 
    1491           0 :     if(getpeername(pSocket->m_Socket, &Addr, &AddrLen) == OSL_SOCKET_ERROR)
    1492             :     {
    1493           0 :         pSocket->m_nLastError=errno;
    1494           0 :         return 0;
    1495             :     }
    1496           0 :     return __osl_createSocketAddrFromSystem( &Addr );
    1497             : }
    1498             : 
    1499           0 : sal_Bool SAL_CALL osl_bindAddrToSocket(oslSocket pSocket,
    1500             :                              oslSocketAddr pAddr)
    1501             : {
    1502             :     int nRet;
    1503             : 
    1504             :     OSL_ASSERT(pSocket && pAddr );
    1505           0 :     if ( pSocket == 0 || pAddr == 0 )
    1506             :     {
    1507           0 :         return sal_False;
    1508             :     }
    1509             : 
    1510           0 :     pSocket->m_nLastError=0;
    1511             : 
    1512           0 :     nRet = bind(pSocket->m_Socket, &(pAddr->m_sockaddr), sizeof(struct sockaddr));
    1513             : 
    1514           0 :     if ( nRet == OSL_SOCKET_ERROR)
    1515             :     {
    1516           0 :         pSocket->m_nLastError=errno;
    1517           0 :         return sal_False;
    1518             :     }
    1519             : 
    1520           0 :     return sal_True;
    1521             : }
    1522             : 
    1523           0 : sal_Bool SAL_CALL osl_listenOnSocket(oslSocket pSocket,
    1524             :                            sal_Int32 MaxPendingConnections)
    1525             : {
    1526             :     int nRet;
    1527             : 
    1528             :     OSL_ASSERT(pSocket);
    1529           0 :     if ( pSocket == 0 )
    1530             :     {
    1531           0 :         return sal_False;
    1532             :     }
    1533             : 
    1534           0 :     pSocket->m_nLastError=0;
    1535             : 
    1536           0 :     nRet = listen(pSocket->m_Socket,
    1537             :                   MaxPendingConnections == -1 ?
    1538             :                   SOMAXCONN :
    1539             :                   MaxPendingConnections);
    1540           0 :     if ( nRet == OSL_SOCKET_ERROR)
    1541             :     {
    1542           0 :         pSocket->m_nLastError=errno;
    1543           0 :         return sal_False;
    1544             :     }
    1545             : 
    1546           0 :     return sal_True;
    1547             : }
    1548             : 
    1549           0 : oslSocketResult SAL_CALL osl_connectSocketTo(oslSocket pSocket,
    1550             :                                     oslSocketAddr pAddr,
    1551             :                                     const TimeValue* pTimeout)
    1552             : {
    1553             :     fd_set   WriteSet;
    1554             :     fd_set   ExcptSet;
    1555             :     int      ReadyHandles;
    1556             :     struct timeval  tv;
    1557           0 :     oslSocketResult Result= osl_Socket_Ok;
    1558             : 
    1559             :     OSL_PRECOND(pSocket, "osl_connectSocketTo(): need a valid socket!\n");
    1560             : 
    1561           0 :     if ( pSocket == 0 )
    1562             :     {
    1563           0 :         return osl_Socket_Error;
    1564             :     }
    1565             : 
    1566           0 :     pSocket->m_nLastError=0;
    1567             : 
    1568           0 :     if (osl_isNonBlockingMode(pSocket))
    1569             :     {
    1570           0 :         if (connect(pSocket->m_Socket,
    1571           0 :                     &(pAddr->m_sockaddr),
    1572             :                     sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
    1573           0 :             return osl_Socket_Ok;
    1574             :         else
    1575           0 :             if (errno == EWOULDBLOCK || errno == EINPROGRESS)
    1576             :             {
    1577           0 :                 pSocket->m_nLastError=EINPROGRESS;
    1578           0 :                 return osl_Socket_InProgress;
    1579             :             }
    1580             : 
    1581           0 :         pSocket->m_nLastError=errno;
    1582             :         OSL_TRACE("can't connect : '%s'",strerror(errno));
    1583           0 :         return osl_Socket_Error;
    1584             :     }
    1585             : 
    1586             :     /* set socket temporarily to non-blocking */
    1587           0 :     OSL_VERIFY(osl_enableNonBlockingMode(pSocket, sal_True));
    1588             : 
    1589             :     /* initiate connect */
    1590           0 :     if(connect(pSocket->m_Socket,
    1591           0 :                &(pAddr->m_sockaddr),
    1592             :                sizeof(struct sockaddr)) != OSL_SOCKET_ERROR)
    1593             :     {
    1594             :        /* immediate connection */
    1595           0 :         osl_enableNonBlockingMode(pSocket, sal_False);
    1596             : 
    1597           0 :         return osl_Socket_Ok;
    1598             :     }
    1599             :     else
    1600             :     {
    1601             :         /* really an error or just delayed? */
    1602           0 :         if (errno != EINPROGRESS)
    1603             :         {
    1604           0 :             pSocket->m_nLastError=errno;
    1605             :             OSL_TRACE(
    1606             :                 "osl_connectSocketTo(): connect failed: errno: %d (%s)\n",
    1607             :                 errno, strerror(errno));
    1608             : 
    1609           0 :             osl_enableNonBlockingMode(pSocket, sal_False);
    1610           0 :             return osl_Socket_Error;
    1611             :         }
    1612             :     }
    1613             : 
    1614             :     /* prepare select set for socket  */
    1615           0 :     FD_ZERO(&WriteSet);
    1616           0 :     FD_ZERO(&ExcptSet);
    1617           0 :     FD_SET(pSocket->m_Socket, &WriteSet);
    1618           0 :     FD_SET(pSocket->m_Socket, &ExcptSet);
    1619             : 
    1620             :     /* prepare timeout */
    1621           0 :     if (pTimeout)
    1622             :     {
    1623             :         /* divide milliseconds into seconds and microseconds */
    1624           0 :         tv.tv_sec=  pTimeout->Seconds;
    1625           0 :         tv.tv_usec= pTimeout->Nanosec / 1000L;
    1626             :     }
    1627             : 
    1628             :     /* select */
    1629           0 :     ReadyHandles= select(pSocket->m_Socket+1,
    1630             :                          0,
    1631             :                          PTR_FD_SET(WriteSet),
    1632             :                          PTR_FD_SET(ExcptSet),
    1633             :                          (pTimeout) ? &tv : 0);
    1634             : 
    1635           0 :     if (ReadyHandles > 0)  /* connected */
    1636             :     {
    1637           0 :         if ( FD_ISSET(pSocket->m_Socket, &WriteSet ) )
    1638             :         {
    1639           0 :             int nErrorCode = 0;
    1640           0 :             socklen_t nErrorSize = sizeof( nErrorCode );
    1641             : 
    1642             :             int nSockOpt;
    1643             : 
    1644           0 :             nSockOpt = getsockopt ( pSocket->m_Socket, SOL_SOCKET, SO_ERROR,
    1645             :                                     &nErrorCode, &nErrorSize );
    1646           0 :             if ( (nSockOpt == 0) && (nErrorCode == 0))
    1647           0 :                 Result = osl_Socket_Ok;
    1648             :             else
    1649           0 :                 Result = osl_Socket_Error;
    1650             :         }
    1651             :         else
    1652             :         {
    1653           0 :             Result= osl_Socket_Error;
    1654             :         }
    1655             :     }
    1656           0 :     else if (ReadyHandles < 0)  /* error */
    1657             :     {
    1658           0 :         if (errno == EBADF) /* most probably interrupted by close() */
    1659             :         {
    1660             :             /* do not access pSockImpl because it is about to be or */
    1661             :             /* already destroyed */
    1662           0 :             return osl_Socket_Interrupted;
    1663             :         }
    1664             :         else
    1665             :         {
    1666           0 :             pSocket->m_nLastError=errno;
    1667           0 :             Result= osl_Socket_Error;
    1668             :         }
    1669             :     }
    1670             :     else    /* timeout */
    1671             :     {
    1672           0 :         pSocket->m_nLastError=errno;
    1673           0 :         Result= osl_Socket_TimedOut;
    1674             :     }
    1675             : 
    1676           0 :     osl_enableNonBlockingMode(pSocket, sal_False);
    1677             : 
    1678           0 :     return Result;
    1679             : }
    1680             : 
    1681           0 : oslSocket SAL_CALL osl_acceptConnectionOnSocket(oslSocket pSocket,
    1682             :                         oslSocketAddr* ppAddr)
    1683             : {
    1684             :     struct sockaddr Addr;
    1685             :     int Connection, Flags;
    1686             :     oslSocket pConnectionSockImpl;
    1687             : 
    1688           0 :     socklen_t AddrLen = sizeof(struct sockaddr);
    1689             :     OSL_ASSERT(pSocket);
    1690           0 :     if ( pSocket == 0 )
    1691             :     {
    1692           0 :         return 0;
    1693             :     }
    1694             : 
    1695           0 :     pSocket->m_nLastError=0;
    1696             : #if defined(LINUX)
    1697           0 :     pSocket->m_bIsAccepting = sal_True;
    1698             : #endif /* LINUX */
    1699             : 
    1700           0 :     if( ppAddr && *ppAddr )
    1701             :     {
    1702           0 :         osl_destroySocketAddr( *ppAddr );
    1703           0 :         *ppAddr = 0;
    1704             :     }
    1705             : 
    1706             :     /* prevent Linux EINTR behaviour */
    1707             :     do
    1708             :     {
    1709           0 :         Connection = accept(pSocket->m_Socket, &Addr, &AddrLen);
    1710           0 :     } while (Connection == -1 && errno == EINTR);
    1711             : 
    1712             :     /* accept failed? */
    1713           0 :     if( Connection == OSL_SOCKET_ERROR )
    1714             :     {
    1715           0 :         pSocket->m_nLastError=errno;
    1716             :         OSL_TRACE("osl_acceptConnectionOnSocket : accept error '%s'",strerror(errno));
    1717             : 
    1718             : #if defined(LINUX)
    1719           0 :         pSocket->m_bIsAccepting = sal_False;
    1720             : #endif /* LINUX */
    1721           0 :         return 0;
    1722             :     }
    1723             : 
    1724             :     OSL_ASSERT(AddrLen == sizeof(struct sockaddr));
    1725             : 
    1726             : #if defined(LINUX)
    1727           0 :     if ( pSocket->m_bIsInShutdown == sal_True )
    1728             :     {
    1729           0 :         close(Connection);
    1730             :         OSL_TRACE("osl_acceptConnectionOnSocket : close while accept");
    1731           0 :         return 0;
    1732             :     }
    1733             : #endif /* LINUX */
    1734             : 
    1735           0 :     if(ppAddr)
    1736             :     {
    1737           0 :         *ppAddr= __osl_createSocketAddrFromSystem(&Addr);
    1738             :     }
    1739             : 
    1740             :     /* alloc memory */
    1741           0 :     pConnectionSockImpl= __osl_createSocketImpl(OSL_INVALID_SOCKET);
    1742             : 
    1743             :     /* set close-on-exec flag */
    1744           0 :     if ((Flags = fcntl(Connection, F_GETFD, 0)) != -1)
    1745             :     {
    1746           0 :         Flags |= FD_CLOEXEC;
    1747           0 :         if (fcntl(Connection, F_SETFD, Flags) == -1)
    1748             :         {
    1749           0 :             pSocket->m_nLastError=errno;
    1750             :             OSL_TRACE("osl_acceptConnectionOnSocket failed changing socket flags. Errno: %d (%s)\n",
    1751             :                       errno,
    1752             :                       strerror(errno));
    1753             :         }
    1754             : 
    1755             :     }
    1756             : 
    1757           0 :     pConnectionSockImpl->m_Socket           = Connection;
    1758           0 :     pConnectionSockImpl->m_nLastError       = 0;
    1759             : #if defined(LINUX)
    1760           0 :     pConnectionSockImpl->m_bIsAccepting     = sal_False;
    1761             : 
    1762           0 :     pSocket->m_bIsAccepting = sal_False;
    1763             : #endif /* LINUX */
    1764           0 :     return pConnectionSockImpl;
    1765             : }
    1766             : 
    1767           0 : sal_Int32 SAL_CALL osl_receiveSocket(oslSocket pSocket,
    1768             :                           void* pBuffer,
    1769             :                           sal_uInt32 BytesToRead,
    1770             :                           oslSocketMsgFlag Flag)
    1771             : {
    1772             :     int nRead;
    1773             : 
    1774             :     OSL_ASSERT(pSocket);
    1775           0 :     if ( pSocket == 0 )
    1776             :     {
    1777             :         OSL_TRACE("osl_receiveSocket : Invalid socket");
    1778           0 :         return -1;
    1779             :     }
    1780             : 
    1781           0 :     pSocket->m_nLastError=0;
    1782             : 
    1783             :     do
    1784             :     {
    1785           0 :         nRead =  recv(pSocket->m_Socket,
    1786             :                       (sal_Char*)pBuffer,
    1787             :                       BytesToRead,
    1788           0 :                       MSG_FLAG_TO_NATIVE(Flag));
    1789           0 :     } while ( nRead < 0 && errno == EINTR );
    1790             : 
    1791           0 :     if ( nRead < 0 )
    1792             :     {
    1793           0 :         pSocket->m_nLastError=errno;
    1794             :         OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,strerror(errno));
    1795             :     }
    1796             :     else if ( nRead == 0 )
    1797             :     {
    1798             :         OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,"EOL");
    1799             :     }
    1800             : 
    1801           0 :     return nRead;
    1802             : }
    1803             : 
    1804           0 : sal_Int32 SAL_CALL osl_receiveFromSocket(oslSocket pSocket,
    1805             :                               oslSocketAddr pSenderAddr,
    1806             :                               void* pBuffer,
    1807             :                               sal_uInt32 BufferSize,
    1808             :                               oslSocketMsgFlag Flag)
    1809             : {
    1810             :     int nRead;
    1811           0 :     struct sockaddr *pSystemSockAddr = 0;
    1812           0 :     socklen_t AddrLen = 0;
    1813           0 :     if( pSenderAddr )
    1814             :     {
    1815           0 :         AddrLen = sizeof( struct sockaddr );
    1816           0 :         pSystemSockAddr = &(pSenderAddr->m_sockaddr);
    1817             :     }
    1818             : 
    1819             :     OSL_ASSERT(pSocket);
    1820           0 :     if ( pSocket == 0 )
    1821             :     {
    1822             :         OSL_TRACE("osl_receiveFromSocket : Invalid socket");
    1823           0 :         return -1;
    1824             :     }
    1825             : 
    1826           0 :     pSocket->m_nLastError=0;
    1827             : 
    1828           0 :     nRead = recvfrom(pSocket->m_Socket,
    1829             :                      (sal_Char*)pBuffer,
    1830             :                      BufferSize,
    1831           0 :                      MSG_FLAG_TO_NATIVE(Flag),
    1832             :                      pSystemSockAddr,
    1833             :                      &AddrLen);
    1834             : 
    1835           0 :     if ( nRead < 0 )
    1836             :     {
    1837           0 :         pSocket->m_nLastError=errno;
    1838             :         OSL_TRACE("osl_receiveFromSocket failed : %i '%s'",nRead,strerror(errno));
    1839             :     }
    1840             :     else if ( nRead == 0 )
    1841             :     {
    1842             :         OSL_TRACE("osl_receiveSocket failed : %i '%s'",nRead,"EOL");
    1843             :     }
    1844             : 
    1845           0 :     return nRead;
    1846             : }
    1847             : 
    1848           0 : sal_Int32 SAL_CALL osl_sendSocket(oslSocket pSocket,
    1849             :                        const void* pBuffer,
    1850             :                        sal_uInt32 BytesToSend,
    1851             :                        oslSocketMsgFlag Flag)
    1852             : {
    1853             :     int nWritten;
    1854             : 
    1855             :     OSL_ASSERT(pSocket);
    1856           0 :     if ( pSocket == 0 )
    1857             :     {
    1858             :         OSL_TRACE("osl_sendSocket : Invalid socket");
    1859           0 :         return -1;
    1860             :     }
    1861             : 
    1862           0 :     pSocket->m_nLastError=0;
    1863             : 
    1864             :     do
    1865             :     {
    1866           0 :         nWritten = send(pSocket->m_Socket,
    1867             :                         (sal_Char*)pBuffer,
    1868             :                         BytesToSend,
    1869           0 :                         MSG_FLAG_TO_NATIVE(Flag));
    1870           0 :     } while ( nWritten < 0 && errno == EINTR );
    1871             : 
    1872           0 :     if ( nWritten < 0 )
    1873             :     {
    1874           0 :         pSocket->m_nLastError=errno;
    1875             :         OSL_TRACE("osl_sendSocket failed : %i '%s'",nWritten,strerror(errno));
    1876             :     }
    1877             :     else if ( nWritten == 0 )
    1878             :     {
    1879             :         OSL_TRACE("osl_sendSocket failed : %i '%s'",nWritten,"EOL");
    1880             :     }
    1881             : 
    1882           0 :     return nWritten;
    1883             : }
    1884             : 
    1885           0 : sal_Int32 SAL_CALL osl_sendToSocket(oslSocket pSocket,
    1886             :                          oslSocketAddr ReceiverAddr,
    1887             :                          const void* pBuffer,
    1888             :                          sal_uInt32 BytesToSend,
    1889             :                          oslSocketMsgFlag Flag)
    1890             : {
    1891             :     int nWritten;
    1892             : 
    1893           0 :     struct sockaddr *pSystemSockAddr = 0;
    1894           0 :     int AddrLen = 0;
    1895           0 :     if( ReceiverAddr )
    1896             :     {
    1897           0 :         pSystemSockAddr = &(ReceiverAddr->m_sockaddr);
    1898           0 :         AddrLen = sizeof( struct sockaddr );
    1899             :     }
    1900             : 
    1901             :     OSL_ASSERT(pSocket);
    1902           0 :     if ( pSocket == 0 )
    1903             :     {
    1904             :         OSL_TRACE("osl_sendToSocket : Invalid socket");
    1905           0 :         return -1;
    1906             :     }
    1907             : 
    1908           0 :     pSocket->m_nLastError=0;
    1909             : 
    1910             :     /* ReceiverAddr might be 0 when used on a connected socket. */
    1911             :     /* Then sendto should behave like send. */
    1912             : 
    1913           0 :     nWritten = sendto(pSocket->m_Socket,
    1914             :                       (sal_Char*)pBuffer,
    1915             :                       BytesToSend,
    1916           0 :                       MSG_FLAG_TO_NATIVE(Flag),
    1917             :                       pSystemSockAddr,
    1918             :                       AddrLen);
    1919             : 
    1920           0 :     if ( nWritten < 0 )
    1921             :     {
    1922           0 :         pSocket->m_nLastError=errno;
    1923             :         OSL_TRACE("osl_sendToSocket failed : %i '%s'",nWritten,strerror(errno));
    1924             :     }
    1925             :     else if ( nWritten == 0 )
    1926             :     {
    1927             :         OSL_TRACE("osl_sendToSocket failed : %i '%s'",nWritten,"EOL");
    1928             :     }
    1929             : 
    1930           0 :     return nWritten;
    1931             : }
    1932             : 
    1933           0 : sal_Int32 SAL_CALL osl_readSocket (
    1934             :     oslSocket pSocket, void *pBuffer, sal_Int32 n )
    1935             : {
    1936           0 :     sal_uInt8 * Ptr = (sal_uInt8 *)pBuffer;
    1937           0 :     sal_uInt32 BytesRead= 0;
    1938           0 :     sal_uInt32 BytesToRead= n;
    1939             : 
    1940             :     OSL_ASSERT( pSocket);
    1941             : 
    1942             :     /* loop until all desired bytes were read or an error occurred */
    1943           0 :     while (BytesToRead > 0)
    1944             :     {
    1945             :         sal_Int32 RetVal;
    1946           0 :         RetVal= osl_receiveSocket(pSocket,
    1947             :                                    Ptr,
    1948             :                                    BytesToRead,
    1949             :                                    osl_Socket_MsgNormal);
    1950             : 
    1951             :         /* error occurred? */
    1952           0 :         if(RetVal <= 0)
    1953             :         {
    1954           0 :             break;
    1955             :         }
    1956             : 
    1957           0 :         BytesToRead -= RetVal;
    1958           0 :         BytesRead += RetVal;
    1959           0 :         Ptr += RetVal;
    1960             :     }
    1961             : 
    1962           0 :     return BytesRead;
    1963             : }
    1964             : 
    1965           0 : sal_Int32 SAL_CALL osl_writeSocket(
    1966             :     oslSocket pSocket, const void *pBuffer, sal_Int32 n )
    1967             : {
    1968             :     /* loop until all desired bytes were send or an error occurred */
    1969           0 :     sal_uInt32 BytesSend= 0;
    1970           0 :     sal_uInt32 BytesToSend= n;
    1971           0 :     sal_uInt8 *Ptr = ( sal_uInt8 * )pBuffer;
    1972             : 
    1973             :     OSL_ASSERT( pSocket );
    1974             : 
    1975           0 :     while (BytesToSend > 0)
    1976             :     {
    1977             :         sal_Int32 RetVal;
    1978             : 
    1979           0 :         RetVal= osl_sendSocket( pSocket,Ptr,BytesToSend,osl_Socket_MsgNormal);
    1980             : 
    1981             :         /* error occurred? */
    1982           0 :         if(RetVal <= 0)
    1983             :         {
    1984           0 :             break;
    1985             :         }
    1986             : 
    1987           0 :         BytesToSend -= RetVal;
    1988           0 :         BytesSend += RetVal;
    1989           0 :         Ptr += RetVal;
    1990             : 
    1991             :     }
    1992           0 :     return BytesSend;
    1993             : }
    1994             : 
    1995             : #ifdef HAVE_POLL_H /* poll() */
    1996             : 
    1997           0 : sal_Bool __osl_socket_poll (
    1998             :     oslSocket        pSocket,
    1999             :     const TimeValue* pTimeout,
    2000             :     short            nEvent)
    2001             : {
    2002             :     struct pollfd fds;
    2003             :     int           timeout;
    2004             :     int           result;
    2005             : 
    2006             :     OSL_ASSERT(0 != pSocket);
    2007           0 :     if (0 == pSocket)
    2008           0 :       return sal_False; /* EINVAL */
    2009             : 
    2010           0 :     pSocket->m_nLastError = 0;
    2011             : 
    2012           0 :     fds.fd      = pSocket->m_Socket;
    2013           0 :     fds.events  = nEvent;
    2014           0 :     fds.revents = 0;
    2015             : 
    2016           0 :     timeout = -1;
    2017           0 :     if (pTimeout)
    2018             :     {
    2019             :         /* Convert to [ms] */
    2020           0 :         timeout  = pTimeout->Seconds * 1000;
    2021           0 :         timeout += pTimeout->Nanosec / (1000 * 1000);
    2022             :     }
    2023             : 
    2024           0 :     result = poll (&fds, 1, timeout);
    2025           0 :     if (result < 0)
    2026             :     {
    2027           0 :         pSocket->m_nLastError = errno;
    2028             :         OSL_TRACE("__osl_socket_poll(): poll error: %d (%s)",
    2029             :                   errno, strerror(errno));
    2030           0 :         return sal_False;
    2031             :     }
    2032           0 :     if (result == 0)
    2033             :     {
    2034             :         /* Timeout */
    2035           0 :         return sal_False;
    2036             :     }
    2037             : 
    2038           0 :     return ((fds.revents & nEvent) == nEvent);
    2039             : }
    2040             : 
    2041             : #else  /* select() */
    2042             : 
    2043             : sal_Bool __osl_socket_poll (
    2044             :     oslSocket        pSocket,
    2045             :     const TimeValue* pTimeout,
    2046             :     short            nEvent)
    2047             : {
    2048             :     fd_set         fds;
    2049             :     struct timeval tv;
    2050             :     int            result;
    2051             : 
    2052             :     OSL_ASSERT(0 != pSocket);
    2053             :     if (0 == pSocket)
    2054             :       return sal_False; /* EINVAL */
    2055             : 
    2056             :     pSocket->m_nLastError = 0;
    2057             : 
    2058             :     FD_ZERO(&fds);
    2059             :     FD_SET(pSocket->m_Socket, &fds);
    2060             : 
    2061             :     if (pTimeout)
    2062             :     {
    2063             :         /* Convert to 'timeval' */
    2064             :         tv.tv_sec  = pTimeout->Seconds;
    2065             :         tv.tv_usec = pTimeout->Nanosec / 1000;
    2066             :     }
    2067             : 
    2068             :     result = select (
    2069             :         pSocket->m_Socket + 1,
    2070             :         (nEvent == POLLIN ) ? PTR_FD_SET(fds) : NULL,
    2071             :         (nEvent == POLLOUT) ? PTR_FD_SET(fds) : NULL,
    2072             :         (nEvent == POLLPRI) ? PTR_FD_SET(fds) : NULL,
    2073             :         (pTimeout)          ? &tv             : NULL);
    2074             : 
    2075             :     if (result < 0)
    2076             :     {
    2077             :         pSocket->m_nLastError = errno;
    2078             :         OSL_TRACE("__osl_socket_poll(): select error: %d (%s)",
    2079             :                   errno, strerror(errno));
    2080             :         return sal_False;
    2081             :     }
    2082             :     if (result == 0)
    2083             :     {
    2084             :         /* Timeout */
    2085             :         return sal_False;
    2086             :     }
    2087             : 
    2088             :     return (FD_ISSET(pSocket->m_Socket, &fds) ? sal_True : sal_False);
    2089             : }
    2090             : 
    2091             : #endif /* HAVE_POLL_H */
    2092             : 
    2093           0 : sal_Bool SAL_CALL osl_isReceiveReady (
    2094             :     oslSocket pSocket, const TimeValue* pTimeout)
    2095             : {
    2096             :     OSL_ASSERT(pSocket);
    2097           0 :     if (pSocket == NULL)
    2098             :     {
    2099             :         /* ENOTSOCK */
    2100           0 :         return sal_False;
    2101             :     }
    2102             : 
    2103           0 :     return __osl_socket_poll (pSocket, pTimeout, POLLIN);
    2104             : }
    2105             : 
    2106           0 : sal_Bool SAL_CALL osl_isSendReady (
    2107             :     oslSocket pSocket, const TimeValue* pTimeout)
    2108             : {
    2109             :     OSL_ASSERT(pSocket);
    2110           0 :     if (pSocket == NULL)
    2111             :     {
    2112             :         /* ENOTSOCK */
    2113           0 :         return sal_False;
    2114             :     }
    2115             : 
    2116           0 :     return __osl_socket_poll (pSocket, pTimeout, POLLOUT);
    2117             : }
    2118             : 
    2119           0 : sal_Bool SAL_CALL osl_isExceptionPending (
    2120             :     oslSocket pSocket, const TimeValue* pTimeout)
    2121             : {
    2122             :     OSL_ASSERT(pSocket);
    2123           0 :     if (pSocket == NULL)
    2124             :     {
    2125             :         /* ENOTSOCK */
    2126           0 :         return sal_False;
    2127             :     }
    2128             : 
    2129           0 :     return __osl_socket_poll (pSocket, pTimeout, POLLPRI);
    2130             : }
    2131             : 
    2132           0 : sal_Bool SAL_CALL osl_shutdownSocket(oslSocket pSocket,
    2133             :                            oslSocketDirection Direction)
    2134             : {
    2135             :     int nRet;
    2136             : 
    2137             :     OSL_ASSERT(pSocket);
    2138           0 :     if ( pSocket == 0 )
    2139             :     {
    2140           0 :         return sal_False;
    2141             :     }
    2142             : 
    2143           0 :     pSocket->m_nLastError=0;
    2144             : 
    2145           0 :     nRet=shutdown(pSocket->m_Socket, DIRECTION_TO_NATIVE(Direction));
    2146           0 :     if (nRet != 0 )
    2147             :     {
    2148           0 :         pSocket->m_nLastError=errno;
    2149             :         OSL_TRACE("shutdown error '%s'",strerror(errno));
    2150             :     }
    2151           0 :     return (nRet==0);
    2152             : }
    2153             : 
    2154           0 : sal_Int32 SAL_CALL osl_getSocketOption(oslSocket pSocket,
    2155             :                             oslSocketOptionLevel    Level,
    2156             :                             oslSocketOption         Option,
    2157             :                             void*                   pBuffer,
    2158             :                             sal_uInt32                  BufferLen)
    2159             : {
    2160           0 :     socklen_t nOptLen = (socklen_t) BufferLen;
    2161             : 
    2162             :     OSL_ASSERT(pSocket);
    2163           0 :     if ( pSocket == 0 )
    2164             :     {
    2165           0 :         return -1;
    2166             :     }
    2167             : 
    2168           0 :     pSocket->m_nLastError=0;
    2169             : 
    2170           0 :     if(getsockopt(pSocket->m_Socket,
    2171           0 :                   OPTION_LEVEL_TO_NATIVE(Level),
    2172           0 :                   OPTION_TO_NATIVE(Option),
    2173             :                   (sal_Char*)pBuffer,
    2174             :                   &nOptLen) == -1)
    2175             :     {
    2176           0 :         pSocket->m_nLastError=errno;
    2177           0 :         return -1;
    2178             :     }
    2179             : 
    2180           0 :     return BufferLen;
    2181             : }
    2182             : 
    2183           0 : sal_Bool SAL_CALL osl_setSocketOption(oslSocket pSocket,
    2184             :                             oslSocketOptionLevel    Level,
    2185             :                             oslSocketOption         Option,
    2186             :                             void*                   pBuffer,
    2187             :                             sal_uInt32                  BufferLen)
    2188             : {
    2189             :     int nRet;
    2190             : 
    2191             :     OSL_ASSERT(pSocket);
    2192           0 :     if ( pSocket == 0 )
    2193             :     {
    2194           0 :         return sal_False;
    2195             :     }
    2196             : 
    2197           0 :     pSocket->m_nLastError=0;
    2198             : 
    2199           0 :     nRet = setsockopt(pSocket->m_Socket,
    2200           0 :                       OPTION_LEVEL_TO_NATIVE(Level),
    2201           0 :                       OPTION_TO_NATIVE(Option),
    2202             :                       (sal_Char*)pBuffer,
    2203             :                       BufferLen);
    2204             : 
    2205           0 :     if ( nRet < 0 )
    2206             :     {
    2207           0 :         pSocket->m_nLastError=errno;
    2208           0 :         return sal_False;
    2209             :     }
    2210             : 
    2211           0 :     return sal_True;
    2212             : }
    2213             : 
    2214           0 : sal_Bool SAL_CALL osl_enableNonBlockingMode(oslSocket pSocket,
    2215             :                                   sal_Bool On)
    2216             : {
    2217             :     int flags;
    2218             :     int nRet;
    2219             : 
    2220             :     OSL_ASSERT(pSocket);
    2221           0 :     if ( pSocket == 0 )
    2222             :     {
    2223           0 :         return sal_False;
    2224             :     }
    2225             : 
    2226           0 :     pSocket->m_nLastError=0;
    2227             : 
    2228           0 :     flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
    2229             : 
    2230           0 :     if (On)
    2231           0 :         flags |= O_NONBLOCK;
    2232             :     else
    2233           0 :         flags &= ~(O_NONBLOCK);
    2234             : 
    2235           0 :     nRet = fcntl(pSocket->m_Socket, F_SETFL, flags);
    2236             : 
    2237           0 :     if  ( nRet < 0 )
    2238             :     {
    2239           0 :         pSocket->m_nLastError=errno;
    2240           0 :         return sal_False;
    2241             :     }
    2242             : 
    2243           0 :     return sal_True;
    2244             : }
    2245             : 
    2246           0 : sal_Bool SAL_CALL osl_isNonBlockingMode(oslSocket pSocket)
    2247             : {
    2248             :     int flags;
    2249             : 
    2250             :     OSL_ASSERT(pSocket);
    2251           0 :     if ( pSocket == 0 )
    2252             :     {
    2253           0 :         return sal_False;
    2254             :     }
    2255             : 
    2256           0 :     pSocket->m_nLastError=0;
    2257             : 
    2258           0 :     flags = fcntl(pSocket->m_Socket, F_GETFL, 0);
    2259             : 
    2260           0 :     if (flags == -1 || !(flags & O_NONBLOCK))
    2261           0 :         return sal_False;
    2262             :     else
    2263           0 :         return sal_True;
    2264             : }
    2265             : 
    2266           0 : oslSocketType SAL_CALL osl_getSocketType(oslSocket pSocket)
    2267             : {
    2268           0 :     int Type=0;
    2269           0 :     socklen_t TypeSize= sizeof(Type);
    2270             : 
    2271             :     OSL_ASSERT(pSocket);
    2272           0 :     if ( pSocket == 0 )
    2273             :     {
    2274           0 :         return osl_Socket_TypeInvalid;
    2275             :     }
    2276             : 
    2277           0 :     pSocket->m_nLastError=0;
    2278             : 
    2279           0 :     if(getsockopt(pSocket->m_Socket,
    2280           0 :                   OPTION_LEVEL_TO_NATIVE(osl_Socket_LevelSocket),
    2281           0 :                   OPTION_TO_NATIVE(osl_Socket_OptionType),
    2282             :                   (sal_Char*)&Type,
    2283             :                   &TypeSize) == -1)
    2284             :     {
    2285             :         /* error */
    2286           0 :         pSocket->m_nLastError=errno;
    2287           0 :         return osl_Socket_TypeInvalid;
    2288             :     }
    2289             : 
    2290           0 :     return TYPE_FROM_NATIVE(Type);
    2291             : 
    2292             : }
    2293             : 
    2294           0 : void SAL_CALL osl_getLastSocketErrorDescription(oslSocket Socket, rtl_uString **ustrError)
    2295             : {
    2296             :     sal_Char pszError[1024];
    2297             : 
    2298           0 :     pszError[0] = '\0';
    2299             : 
    2300           0 :     osl_psz_getLastSocketErrorDescription(Socket,pszError,sizeof(pszError));
    2301             : 
    2302           0 :     rtl_uString_newFromAscii(ustrError,pszError);
    2303             : 
    2304           0 :     return;
    2305             : }
    2306             : 
    2307           0 : void SAL_CALL osl_psz_getLastSocketErrorDescription(oslSocket pSocket, sal_Char* pBuffer, sal_uInt32 BufferSize)
    2308             : {
    2309             :     /* make shure pBuffer will be a zero-terminated string even when strncpy has to cut */
    2310           0 :     pBuffer[BufferSize-1]= '\0';
    2311             : 
    2312           0 :     if ( pSocket == 0 )
    2313             :     {
    2314           0 :         strncpy(pBuffer, strerror(EINVAL), BufferSize-1);
    2315           0 :         return;
    2316             :     }
    2317             : 
    2318           0 :     strncpy(pBuffer, strerror(pSocket->m_nLastError), BufferSize-1);
    2319           0 :     return;
    2320             : }
    2321             : 
    2322           0 : oslSocketError SAL_CALL osl_getLastSocketError(oslSocket pSocket)
    2323             : {
    2324           0 :     if ( pSocket == 0 )
    2325             :     {
    2326           0 :         return ERROR_FROM_NATIVE(EINVAL);
    2327             :     }
    2328             : 
    2329           0 :     return ERROR_FROM_NATIVE(pSocket->m_nLastError);
    2330             : }
    2331             : 
    2332             : typedef struct _TSocketSetImpl
    2333             : {
    2334             :     int     m_MaxHandle;    /* for select(), the largest descriptor in the set */
    2335             :     fd_set  m_Set;          /* the set of descriptors */
    2336             : 
    2337             : } TSocketSetImpl;
    2338             : 
    2339           0 : oslSocketSet SAL_CALL osl_createSocketSet()
    2340             : {
    2341             :     TSocketSetImpl* pSet;
    2342             : 
    2343           0 :     pSet= (TSocketSetImpl*)malloc(sizeof(TSocketSetImpl));
    2344             : 
    2345             :     OSL_ASSERT(pSet);
    2346             : 
    2347           0 :     if(pSet)
    2348             :     {
    2349           0 :         pSet->m_MaxHandle= 0;
    2350           0 :         FD_ZERO(&pSet->m_Set);
    2351             :     }
    2352             : 
    2353           0 :     return (oslSocketSet)pSet;
    2354             : }
    2355             : 
    2356           0 : void SAL_CALL osl_destroySocketSet(oslSocketSet Set)
    2357             : {
    2358           0 :     if(Set)
    2359           0 :         free(Set);
    2360           0 : }
    2361             : 
    2362           0 : void SAL_CALL osl_clearSocketSet(oslSocketSet Set)
    2363             : {
    2364             :     TSocketSetImpl* pSet;
    2365             :     OSL_ASSERT(Set);
    2366           0 :     if ( Set == 0 )
    2367             :     {
    2368           0 :         return;
    2369             :     }
    2370             : 
    2371           0 :     pSet= (TSocketSetImpl*)Set;
    2372           0 :     pSet->m_MaxHandle= 0;
    2373             : 
    2374           0 :     FD_ZERO(&pSet->m_Set);
    2375             : }
    2376             : 
    2377           0 : void SAL_CALL osl_addToSocketSet(oslSocketSet Set, oslSocket pSocket)
    2378             : {
    2379             :     TSocketSetImpl* pSet;
    2380             : 
    2381             :     OSL_ASSERT(Set);
    2382             :     OSL_ASSERT(pSocket);
    2383             : 
    2384           0 :     if ( Set == 0 || pSocket == 0)
    2385             :     {
    2386           0 :         return;
    2387             :     }
    2388             : 
    2389           0 :     pSet= (TSocketSetImpl*)Set;
    2390             : 
    2391             :     /* correct max handle */
    2392           0 :     if(pSocket->m_Socket > pSet->m_MaxHandle)
    2393           0 :         pSet->m_MaxHandle= pSocket->m_Socket;
    2394           0 :     FD_SET(pSocket->m_Socket, &pSet->m_Set);
    2395             : 
    2396             : }
    2397             : 
    2398           0 : void SAL_CALL osl_removeFromSocketSet(oslSocketSet Set, oslSocket pSocket)
    2399             : {
    2400             :     TSocketSetImpl* pSet;
    2401             : 
    2402             :     OSL_ASSERT(Set);
    2403             :     OSL_ASSERT(pSocket);
    2404             : 
    2405           0 :     if ( Set == 0 || pSocket == 0)
    2406             :     {
    2407           0 :         return;
    2408             :     }
    2409             : 
    2410           0 :     pSet= (TSocketSetImpl*)Set;
    2411             : 
    2412             :     /* correct max handle */
    2413           0 :     if(pSocket->m_Socket == pSet->m_MaxHandle)
    2414             :     {
    2415             :         /* not optimal, since the next used descriptor might be */
    2416             :         /* much smaller than m_Socket-1, but it will do */
    2417           0 :         pSet->m_MaxHandle--;
    2418           0 :         if(pSet->m_MaxHandle < 0)
    2419             :         {
    2420           0 :             pSet->m_MaxHandle= 0;   /* avoid underflow */
    2421             :         }
    2422             :     }
    2423             : 
    2424           0 :     FD_CLR(pSocket->m_Socket, &pSet->m_Set);
    2425             : }
    2426             : 
    2427           0 : sal_Bool SAL_CALL osl_isInSocketSet(oslSocketSet Set, oslSocket pSocket)
    2428             : {
    2429             :     TSocketSetImpl* pSet;
    2430             : 
    2431             :     OSL_ASSERT(Set);
    2432             :     OSL_ASSERT(pSocket);
    2433           0 :     if ( Set == 0 || pSocket == 0 )
    2434             :     {
    2435           0 :         return sal_False;
    2436             :     }
    2437             : 
    2438           0 :     pSet= (TSocketSetImpl*)Set;
    2439             : 
    2440           0 :     return (FD_ISSET(pSocket->m_Socket, &pSet->m_Set) != 0);
    2441             : }
    2442             : 
    2443           0 : sal_Int32 SAL_CALL osl_demultiplexSocketEvents(oslSocketSet IncomingSet,
    2444             :                                     oslSocketSet OutgoingSet,
    2445             :                                     oslSocketSet OutOfBandSet,
    2446             :                                     const TimeValue* pTimeout)
    2447             : {
    2448           0 :     int MaxHandle= 0;
    2449             :     struct timeval  tv;
    2450             :     TSocketSetImpl* pInSet;
    2451             :     TSocketSetImpl* pOutSet;
    2452             :     TSocketSetImpl* pOOBSet;
    2453             : 
    2454           0 :     if (pTimeout)
    2455             :     {
    2456             :         /* non-blocking call */
    2457           0 :         tv.tv_sec  = pTimeout->Seconds;
    2458           0 :         tv.tv_usec = pTimeout->Nanosec / 1000L;
    2459             :     }
    2460             : 
    2461             :     /* map opaque data to impl-types */
    2462           0 :     pInSet=  (TSocketSetImpl*)IncomingSet;
    2463           0 :     pOutSet= (TSocketSetImpl*)OutgoingSet;
    2464           0 :     pOOBSet= (TSocketSetImpl*)OutOfBandSet;
    2465             : 
    2466             :     /* get max handle from all sets */
    2467           0 :     if (pInSet)
    2468           0 :         MaxHandle= pInSet->m_MaxHandle;
    2469             : 
    2470           0 :     if (pOutSet && (pOutSet->m_MaxHandle > MaxHandle))
    2471           0 :         MaxHandle= pOutSet->m_MaxHandle;
    2472             : 
    2473           0 :     if (pOOBSet && (pOOBSet->m_MaxHandle > MaxHandle))
    2474           0 :         MaxHandle= pOOBSet->m_MaxHandle;
    2475             : 
    2476           0 :     return select(MaxHandle+1,
    2477             :                   pInSet  ? PTR_FD_SET(pInSet->m_Set)  : 0,
    2478             :                   pOutSet ? PTR_FD_SET(pOutSet->m_Set) : 0,
    2479             :                   pOOBSet ? PTR_FD_SET(pOOBSet->m_Set) : 0,
    2480             :                   pTimeout ? &tv : 0);
    2481             : }
    2482             : 
    2483             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10